1
# Copyright (C) 2006-2011 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
"""BzrDir logic. The BzrDir is the basic control directory used by bzr.
19
At format 7 this was split out into Branch, Repository and Checkout control
22
Note: This module has a lot of ``open`` functions/methods that return
23
references to in-memory objects. As a rule, there are no matching ``close``
24
methods. To free any associated resources, simply stop referencing the
30
from bzrlib.lazy_import import lazy_import
31
lazy_import(globals(), """
34
branch as _mod_branch,
45
revision as _mod_revision,
46
transport as _mod_transport,
53
from bzrlib.repofmt import knitpack_repo
54
from bzrlib.transport import (
55
do_catching_redirections,
58
from bzrlib.i18n import gettext
61
from bzrlib.trace import (
72
from bzrlib.symbol_versioning import (
78
class BzrDir(controldir.ControlDir):
79
"""A .bzr control diretory.
81
BzrDir instances let you create or open any of the things that can be
82
found within .bzr - checkouts, branches and repositories.
85
the transport which this bzr dir is rooted at (i.e. file:///.../.bzr/)
87
a transport connected to the directory this bzr was opened from
88
(i.e. the parent directory holding the .bzr directory).
90
Everything in the bzrdir should have the same file permissions.
92
:cvar hooks: An instance of BzrDirHooks.
96
"""Invoke break_lock on the first object in the bzrdir.
98
If there is a tree, the tree is opened and break_lock() called.
99
Otherwise, branch is tried, and finally repository.
101
# XXX: This seems more like a UI function than something that really
102
# belongs in this class.
104
thing_to_unlock = self.open_workingtree()
105
except (errors.NotLocalUrl, errors.NoWorkingTree):
107
thing_to_unlock = self.open_branch()
108
except errors.NotBranchError:
110
thing_to_unlock = self.open_repository()
111
except errors.NoRepositoryPresent:
113
thing_to_unlock.break_lock()
115
def check_conversion_target(self, target_format):
116
"""Check that a bzrdir as a whole can be converted to a new format."""
117
# The only current restriction is that the repository content can be
118
# fetched compatibly with the target.
119
target_repo_format = target_format.repository_format
121
self.open_repository()._format.check_conversion_target(
123
except errors.NoRepositoryPresent:
124
# No repo, no problem.
127
def clone_on_transport(self, transport, revision_id=None,
128
force_new_repo=False, preserve_stacking=False, stacked_on=None,
129
create_prefix=False, use_existing_dir=True, no_tree=False):
130
"""Clone this bzrdir and its contents to transport verbatim.
132
:param transport: The transport for the location to produce the clone
133
at. If the target directory does not exist, it will be created.
134
:param revision_id: The tip revision-id to use for any branch or
135
working tree. If not None, then the clone operation may tune
136
itself to download less data.
137
:param force_new_repo: Do not use a shared repository for the target,
138
even if one is available.
139
:param preserve_stacking: When cloning a stacked branch, stack the
140
new branch on top of the other branch's stacked-on branch.
141
:param create_prefix: Create any missing directories leading up to
143
:param use_existing_dir: Use an existing directory if one exists.
144
:param no_tree: If set to true prevents creation of a working tree.
146
# Overview: put together a broad description of what we want to end up
147
# with; then make as few api calls as possible to do it.
149
# We may want to create a repo/branch/tree, if we do so what format
150
# would we want for each:
151
require_stacking = (stacked_on is not None)
152
format = self.cloning_metadir(require_stacking)
154
# Figure out what objects we want:
156
local_repo = self.find_repository()
157
except errors.NoRepositoryPresent:
160
local_branch = self.open_branch()
161
except errors.NotBranchError:
164
# enable fallbacks when branch is not a branch reference
165
if local_branch.repository.has_same_location(local_repo):
166
local_repo = local_branch.repository
167
if preserve_stacking:
169
stacked_on = local_branch.get_stacked_on_url()
170
except (errors.UnstackableBranchFormat,
171
errors.UnstackableRepositoryFormat,
174
# Bug: We create a metadir without knowing if it can support stacking,
175
# we should look up the policy needs first, or just use it as a hint,
178
make_working_trees = local_repo.make_working_trees() and not no_tree
179
want_shared = local_repo.is_shared()
180
repo_format_name = format.repository_format.network_name()
182
make_working_trees = False
184
repo_format_name = None
186
result_repo, result, require_stacking, repository_policy = \
187
format.initialize_on_transport_ex(transport,
188
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
189
force_new_repo=force_new_repo, stacked_on=stacked_on,
190
stack_on_pwd=self.root_transport.base,
191
repo_format_name=repo_format_name,
192
make_working_trees=make_working_trees, shared_repo=want_shared)
195
# If the result repository is in the same place as the
196
# resulting bzr dir, it will have no content, further if the
197
# result is not stacked then we know all content should be
198
# copied, and finally if we are copying up to a specific
199
# revision_id then we can use the pending-ancestry-result which
200
# does not require traversing all of history to describe it.
201
if (result_repo.user_url == result.user_url
202
and not require_stacking and
203
revision_id is not None):
204
fetch_spec = graph.PendingAncestryResult(
205
[revision_id], local_repo)
206
result_repo.fetch(local_repo, fetch_spec=fetch_spec)
208
result_repo.fetch(local_repo, revision_id=revision_id)
212
if result_repo is not None:
213
raise AssertionError('result_repo not None(%r)' % result_repo)
214
# 1 if there is a branch present
215
# make sure its content is available in the target repository
217
if local_branch is not None:
218
result_branch = local_branch.clone(result, revision_id=revision_id,
219
repository_policy=repository_policy)
221
# Cheaper to check if the target is not local, than to try making
223
result.root_transport.local_abspath('.')
224
if result_repo is None or result_repo.make_working_trees():
225
self.open_workingtree().clone(result)
226
except (errors.NoWorkingTree, errors.NotLocalUrl):
230
# TODO: This should be given a Transport, and should chdir up; otherwise
231
# this will open a new connection.
232
def _make_tail(self, url):
233
t = _mod_transport.get_transport(url)
237
def find_bzrdirs(transport, evaluate=None, list_current=None):
238
"""Find bzrdirs recursively from current location.
240
This is intended primarily as a building block for more sophisticated
241
functionality, like finding trees under a directory, or finding
242
branches that use a given repository.
244
:param evaluate: An optional callable that yields recurse, value,
245
where recurse controls whether this bzrdir is recursed into
246
and value is the value to yield. By default, all bzrdirs
247
are recursed into, and the return value is the bzrdir.
248
:param list_current: if supplied, use this function to list the current
249
directory, instead of Transport.list_dir
250
:return: a generator of found bzrdirs, or whatever evaluate returns.
252
if list_current is None:
253
def list_current(transport):
254
return transport.list_dir('')
256
def evaluate(bzrdir):
259
pending = [transport]
260
while len(pending) > 0:
261
current_transport = pending.pop()
264
bzrdir = BzrDir.open_from_transport(current_transport)
265
except (errors.NotBranchError, errors.PermissionDenied):
268
recurse, value = evaluate(bzrdir)
271
subdirs = list_current(current_transport)
272
except (errors.NoSuchFile, errors.PermissionDenied):
275
for subdir in sorted(subdirs, reverse=True):
276
pending.append(current_transport.clone(subdir))
279
def find_branches(transport):
280
"""Find all branches under a transport.
282
This will find all branches below the transport, including branches
283
inside other branches. Where possible, it will use
284
Repository.find_branches.
286
To list all the branches that use a particular Repository, see
287
Repository.find_branches
289
def evaluate(bzrdir):
291
repository = bzrdir.open_repository()
292
except errors.NoRepositoryPresent:
295
return False, ([], repository)
296
return True, (bzrdir.list_branches(), None)
298
for branches, repo in BzrDir.find_bzrdirs(transport,
301
ret.extend(repo.find_branches())
302
if branches is not None:
307
def create_branch_and_repo(base, force_new_repo=False, format=None):
308
"""Create a new BzrDir, Branch and Repository at the url 'base'.
310
This will use the current default BzrDirFormat unless one is
311
specified, and use whatever
312
repository format that that uses via bzrdir.create_branch and
313
create_repository. If a shared repository is available that is used
316
The created Branch object is returned.
318
:param base: The URL to create the branch at.
319
:param force_new_repo: If True a new repository is always created.
320
:param format: If supplied, the format of branch to create. If not
321
supplied, the default is used.
323
bzrdir = BzrDir.create(base, format)
324
bzrdir._find_or_create_repository(force_new_repo)
325
return bzrdir.create_branch()
327
def determine_repository_policy(self, force_new_repo=False, stack_on=None,
328
stack_on_pwd=None, require_stacking=False):
329
"""Return an object representing a policy to use.
331
This controls whether a new repository is created, and the format of
332
that repository, or some existing shared repository used instead.
334
If stack_on is supplied, will not seek a containing shared repo.
336
:param force_new_repo: If True, require a new repository to be created.
337
:param stack_on: If supplied, the location to stack on. If not
338
supplied, a default_stack_on location may be used.
339
:param stack_on_pwd: If stack_on is relative, the location it is
342
def repository_policy(found_bzrdir):
345
config = found_bzrdir.get_config()
347
stack_on = config.get_default_stack_on()
348
if stack_on is not None:
349
stack_on_pwd = found_bzrdir.user_url
351
# does it have a repository ?
353
repository = found_bzrdir.open_repository()
354
except errors.NoRepositoryPresent:
357
if (found_bzrdir.user_url != self.user_url
358
and not repository.is_shared()):
359
# Don't look higher, can't use a higher shared repo.
367
return UseExistingRepository(repository, stack_on,
368
stack_on_pwd, require_stacking=require_stacking), True
370
return CreateRepository(self, stack_on, stack_on_pwd,
371
require_stacking=require_stacking), True
373
if not force_new_repo:
375
policy = self._find_containing(repository_policy)
376
if policy is not None:
380
return UseExistingRepository(self.open_repository(),
381
stack_on, stack_on_pwd,
382
require_stacking=require_stacking)
383
except errors.NoRepositoryPresent:
385
return CreateRepository(self, stack_on, stack_on_pwd,
386
require_stacking=require_stacking)
388
def _find_or_create_repository(self, force_new_repo):
389
"""Create a new repository if needed, returning the repository."""
390
policy = self.determine_repository_policy(force_new_repo)
391
return policy.acquire_repository()[0]
393
def _find_source_repo(self, add_cleanup, source_branch):
394
"""Find the source branch and repo for a sprout operation.
396
This is helper intended for use by _sprout.
398
:returns: (source_branch, source_repository). Either or both may be
399
None. If not None, they will be read-locked (and their unlock(s)
400
scheduled via the add_cleanup param).
402
if source_branch is not None:
403
add_cleanup(source_branch.lock_read().unlock)
404
return source_branch, source_branch.repository
406
source_branch = self.open_branch()
407
source_repository = source_branch.repository
408
except errors.NotBranchError:
411
source_repository = self.open_repository()
412
except errors.NoRepositoryPresent:
413
source_repository = None
415
add_cleanup(source_repository.lock_read().unlock)
417
add_cleanup(source_branch.lock_read().unlock)
418
return source_branch, source_repository
420
def sprout(self, url, revision_id=None, force_new_repo=False,
421
recurse='down', possible_transports=None,
422
accelerator_tree=None, hardlink=False, stacked=False,
423
source_branch=None, create_tree_if_local=True):
424
"""Create a copy of this controldir prepared for use as a new line of
427
If url's last component does not exist, it will be created.
429
Attributes related to the identity of the source branch like
430
branch nickname will be cleaned, a working tree is created
431
whether one existed before or not; and a local branch is always
434
if revision_id is not None, then the clone operation may tune
435
itself to download less data.
437
:param accelerator_tree: A tree which can be used for retrieving file
438
contents more quickly than the revision tree, i.e. a workingtree.
439
The revision tree will be used for cases where accelerator_tree's
440
content is different.
441
:param hardlink: If true, hard-link files from accelerator_tree,
443
:param stacked: If true, create a stacked branch referring to the
444
location of this control directory.
445
:param create_tree_if_local: If true, a working-tree will be created
446
when working locally.
448
operation = cleanup.OperationWithCleanups(self._sprout)
449
return operation.run(url, revision_id=revision_id,
450
force_new_repo=force_new_repo, recurse=recurse,
451
possible_transports=possible_transports,
452
accelerator_tree=accelerator_tree, hardlink=hardlink,
453
stacked=stacked, source_branch=source_branch,
454
create_tree_if_local=create_tree_if_local)
456
def _sprout(self, op, url, revision_id=None, force_new_repo=False,
457
recurse='down', possible_transports=None,
458
accelerator_tree=None, hardlink=False, stacked=False,
459
source_branch=None, create_tree_if_local=True):
460
add_cleanup = op.add_cleanup
461
fetch_spec_factory = fetch.FetchSpecFactory()
462
if revision_id is not None:
463
fetch_spec_factory.add_revision_ids([revision_id])
464
fetch_spec_factory.source_branch_stop_revision_id = revision_id
465
target_transport = _mod_transport.get_transport(url,
467
target_transport.ensure_base()
468
cloning_format = self.cloning_metadir(stacked)
469
# Create/update the result branch
470
result = cloning_format.initialize_on_transport(target_transport)
471
source_branch, source_repository = self._find_source_repo(
472
add_cleanup, source_branch)
473
fetch_spec_factory.source_branch = source_branch
474
# if a stacked branch wasn't requested, we don't create one
475
# even if the origin was stacked
476
if stacked and source_branch is not None:
477
stacked_branch_url = self.root_transport.base
479
stacked_branch_url = None
480
repository_policy = result.determine_repository_policy(
481
force_new_repo, stacked_branch_url, require_stacking=stacked)
482
result_repo, is_new_repo = repository_policy.acquire_repository()
483
add_cleanup(result_repo.lock_write().unlock)
484
fetch_spec_factory.source_repo = source_repository
485
fetch_spec_factory.target_repo = result_repo
486
if stacked or (len(result_repo._fallback_repositories) != 0):
487
target_repo_kind = fetch.TargetRepoKinds.STACKED
489
target_repo_kind = fetch.TargetRepoKinds.EMPTY
491
target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
492
fetch_spec_factory.target_repo_kind = target_repo_kind
493
if source_repository is not None:
494
fetch_spec = fetch_spec_factory.make_fetch_spec()
495
result_repo.fetch(source_repository, fetch_spec=fetch_spec)
497
if source_branch is None:
498
# this is for sprouting a controldir without a branch; is that
500
# Not especially, but it's part of the contract.
501
result_branch = result.create_branch()
503
result_branch = source_branch.sprout(result,
504
revision_id=revision_id, repository_policy=repository_policy,
505
repository=result_repo)
506
mutter("created new branch %r" % (result_branch,))
508
# Create/update the result working tree
509
if (create_tree_if_local and
510
isinstance(target_transport, local.LocalTransport) and
511
(result_repo is None or result_repo.make_working_trees())):
512
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
513
hardlink=hardlink, from_branch=result_branch)
516
if wt.path2id('') is None:
518
wt.set_root_id(self.open_workingtree.get_root_id())
519
except errors.NoWorkingTree:
525
if recurse == 'down':
528
basis = wt.basis_tree()
529
elif result_branch is not None:
530
basis = result_branch.basis_tree()
531
elif source_branch is not None:
532
basis = source_branch.basis_tree()
533
if basis is not None:
534
add_cleanup(basis.lock_read().unlock)
535
subtrees = basis.iter_references()
538
for path, file_id in subtrees:
539
target = urlutils.join(url, urlutils.escape(path))
540
sublocation = source_branch.reference_parent(file_id, path)
541
sublocation.bzrdir.sprout(target,
542
basis.get_reference_revision(file_id, path),
543
force_new_repo=force_new_repo, recurse=recurse,
548
def create_branch_convenience(base, force_new_repo=False,
549
force_new_tree=None, format=None,
550
possible_transports=None):
551
"""Create a new BzrDir, Branch and Repository at the url 'base'.
553
This is a convenience function - it will use an existing repository
554
if possible, can be told explicitly whether to create a working tree or
557
This will use the current default BzrDirFormat unless one is
558
specified, and use whatever
559
repository format that that uses via bzrdir.create_branch and
560
create_repository. If a shared repository is available that is used
561
preferentially. Whatever repository is used, its tree creation policy
564
The created Branch object is returned.
565
If a working tree cannot be made due to base not being a file:// url,
566
no error is raised unless force_new_tree is True, in which case no
567
data is created on disk and NotLocalUrl is raised.
569
:param base: The URL to create the branch at.
570
:param force_new_repo: If True a new repository is always created.
571
:param force_new_tree: If True or False force creation of a tree or
572
prevent such creation respectively.
573
:param format: Override for the bzrdir format to create.
574
:param possible_transports: An optional reusable transports list.
577
# check for non local urls
578
t = _mod_transport.get_transport(base, possible_transports)
579
if not isinstance(t, local.LocalTransport):
580
raise errors.NotLocalUrl(base)
581
bzrdir = BzrDir.create(base, format, possible_transports)
582
repo = bzrdir._find_or_create_repository(force_new_repo)
583
result = bzrdir.create_branch()
584
if force_new_tree or (repo.make_working_trees() and
585
force_new_tree is None):
587
bzrdir.create_workingtree()
588
except errors.NotLocalUrl:
593
def create_standalone_workingtree(base, format=None):
594
"""Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
596
'base' must be a local path or a file:// url.
598
This will use the current default BzrDirFormat unless one is
599
specified, and use whatever
600
repository format that that uses for bzrdirformat.create_workingtree,
601
create_branch and create_repository.
603
:param format: Override for the bzrdir format to create.
604
:return: The WorkingTree object.
606
t = _mod_transport.get_transport(base)
607
if not isinstance(t, local.LocalTransport):
608
raise errors.NotLocalUrl(base)
609
bzrdir = BzrDir.create_branch_and_repo(base,
611
format=format).bzrdir
612
return bzrdir.create_workingtree()
614
@deprecated_method(deprecated_in((2, 3, 0)))
615
def generate_backup_name(self, base):
616
return self._available_backup_name(base)
618
def _available_backup_name(self, base):
619
"""Find a non-existing backup file name based on base.
621
See bzrlib.osutils.available_backup_name about race conditions.
623
return osutils.available_backup_name(base, self.root_transport.has)
625
def backup_bzrdir(self):
626
"""Backup this bzr control directory.
628
:return: Tuple with old path name and new path name
631
pb = ui.ui_factory.nested_progress_bar()
633
old_path = self.root_transport.abspath('.bzr')
634
backup_dir = self._available_backup_name('backup.bzr')
635
new_path = self.root_transport.abspath(backup_dir)
636
ui.ui_factory.note(gettext('making backup of {0}\n to {1}').format(
637
urlutils.unescape_for_display(old_path, 'utf-8'),
638
urlutils.unescape_for_display(new_path, 'utf-8')))
639
self.root_transport.copy_tree('.bzr', backup_dir)
640
return (old_path, new_path)
644
def retire_bzrdir(self, limit=10000):
645
"""Permanently disable the bzrdir.
647
This is done by renaming it to give the user some ability to recover
648
if there was a problem.
650
This will have horrible consequences if anyone has anything locked or
652
:param limit: number of times to retry
657
to_path = '.bzr.retired.%d' % i
658
self.root_transport.rename('.bzr', to_path)
659
note(gettext("renamed {0} to {1}").format(
660
self.root_transport.abspath('.bzr'), to_path))
662
except (errors.TransportError, IOError, errors.PathError):
669
def _find_containing(self, evaluate):
670
"""Find something in a containing control directory.
672
This method will scan containing control dirs, until it finds what
673
it is looking for, decides that it will never find it, or runs out
674
of containing control directories to check.
676
It is used to implement find_repository and
677
determine_repository_policy.
679
:param evaluate: A function returning (value, stop). If stop is True,
680
the value will be returned.
684
result, stop = evaluate(found_bzrdir)
687
next_transport = found_bzrdir.root_transport.clone('..')
688
if (found_bzrdir.user_url == next_transport.base):
689
# top of the file system
691
# find the next containing bzrdir
693
found_bzrdir = BzrDir.open_containing_from_transport(
695
except errors.NotBranchError:
698
def find_repository(self):
699
"""Find the repository that should be used.
701
This does not require a branch as we use it to find the repo for
702
new branches as well as to hook existing branches up to their
705
def usable_repository(found_bzrdir):
706
# does it have a repository ?
708
repository = found_bzrdir.open_repository()
709
except errors.NoRepositoryPresent:
711
if found_bzrdir.user_url == self.user_url:
712
return repository, True
713
elif repository.is_shared():
714
return repository, True
718
found_repo = self._find_containing(usable_repository)
719
if found_repo is None:
720
raise errors.NoRepositoryPresent(self)
723
def _find_creation_modes(self):
724
"""Determine the appropriate modes for files and directories.
726
They're always set to be consistent with the base directory,
727
assuming that this transport allows setting modes.
729
# TODO: Do we need or want an option (maybe a config setting) to turn
730
# this off or override it for particular locations? -- mbp 20080512
731
if self._mode_check_done:
733
self._mode_check_done = True
735
st = self.transport.stat('.')
736
except errors.TransportNotPossible:
737
self._dir_mode = None
738
self._file_mode = None
740
# Check the directory mode, but also make sure the created
741
# directories and files are read-write for this user. This is
742
# mostly a workaround for filesystems which lie about being able to
743
# write to a directory (cygwin & win32)
744
if (st.st_mode & 07777 == 00000):
745
# FTP allows stat but does not return dir/file modes
746
self._dir_mode = None
747
self._file_mode = None
749
self._dir_mode = (st.st_mode & 07777) | 00700
750
# Remove the sticky and execute bits for files
751
self._file_mode = self._dir_mode & ~07111
753
def _get_file_mode(self):
754
"""Return Unix mode for newly created files, or None.
756
if not self._mode_check_done:
757
self._find_creation_modes()
758
return self._file_mode
760
def _get_dir_mode(self):
761
"""Return Unix mode for newly created directories, or None.
763
if not self._mode_check_done:
764
self._find_creation_modes()
765
return self._dir_mode
767
def get_config(self):
768
"""Get configuration for this BzrDir."""
769
return config.BzrDirConfig(self)
771
def _get_config(self):
772
"""By default, no configuration is available."""
775
def __init__(self, _transport, _format):
776
"""Initialize a Bzr control dir object.
778
Only really common logic should reside here, concrete classes should be
779
made with varying behaviours.
781
:param _format: the format that is creating this BzrDir instance.
782
:param _transport: the transport this dir is based at.
784
self._format = _format
785
# these are also under the more standard names of
786
# control_transport and user_transport
787
self.transport = _transport.clone('.bzr')
788
self.root_transport = _transport
789
self._mode_check_done = False
792
def user_transport(self):
793
return self.root_transport
796
def control_transport(self):
797
return self.transport
799
def is_control_filename(self, filename):
800
"""True if filename is the name of a path which is reserved for bzrdir's.
802
:param filename: A filename within the root transport of this bzrdir.
804
This is true IF and ONLY IF the filename is part of the namespace reserved
805
for bzr control dirs. Currently this is the '.bzr' directory in the root
806
of the root_transport.
808
# this might be better on the BzrDirFormat class because it refers to
809
# all the possible bzrdir disk formats.
810
# This method is tested via the workingtree is_control_filename tests-
811
# it was extracted from WorkingTree.is_control_filename. If the method's
812
# contract is extended beyond the current trivial implementation, please
813
# add new tests for it to the appropriate place.
814
return filename == '.bzr' or filename.startswith('.bzr/')
817
def open_unsupported(base):
818
"""Open a branch which is not supported."""
819
return BzrDir.open(base, _unsupported=True)
822
def open(base, _unsupported=False, possible_transports=None):
823
"""Open an existing bzrdir, rooted at 'base' (url).
825
:param _unsupported: a private parameter to the BzrDir class.
827
t = _mod_transport.get_transport(base, possible_transports)
828
return BzrDir.open_from_transport(t, _unsupported=_unsupported)
831
def open_from_transport(transport, _unsupported=False,
832
_server_formats=True):
833
"""Open a bzrdir within a particular directory.
835
:param transport: Transport containing the bzrdir.
836
:param _unsupported: private.
838
for hook in BzrDir.hooks['pre_open']:
840
# Keep initial base since 'transport' may be modified while following
842
base = transport.base
843
def find_format(transport):
844
return transport, controldir.ControlDirFormat.find_format(
845
transport, _server_formats=_server_formats)
847
def redirected(transport, e, redirection_notice):
848
redirected_transport = transport._redirected_to(e.source, e.target)
849
if redirected_transport is None:
850
raise errors.NotBranchError(base)
851
note(gettext('{0} is{1} redirected to {2}').format(
852
transport.base, e.permanently, redirected_transport.base))
853
return redirected_transport
856
transport, format = do_catching_redirections(find_format,
859
except errors.TooManyRedirections:
860
raise errors.NotBranchError(base)
862
format.check_support_status(_unsupported)
863
return format.open(transport, _found=True)
866
def open_containing(url, possible_transports=None):
867
"""Open an existing branch which contains url.
869
:param url: url to search from.
871
See open_containing_from_transport for more detail.
873
transport = _mod_transport.get_transport(url, possible_transports)
874
return BzrDir.open_containing_from_transport(transport)
877
def open_containing_from_transport(a_transport):
878
"""Open an existing branch which contains a_transport.base.
880
This probes for a branch at a_transport, and searches upwards from there.
882
Basically we keep looking up until we find the control directory or
883
run into the root. If there isn't one, raises NotBranchError.
884
If there is one and it is either an unrecognised format or an unsupported
885
format, UnknownFormatError or UnsupportedFormatError are raised.
886
If there is one, it is returned, along with the unused portion of url.
888
:return: The BzrDir that contains the path, and a Unicode path
889
for the rest of the URL.
891
# this gets the normalised url back. I.e. '.' -> the full path.
892
url = a_transport.base
895
result = BzrDir.open_from_transport(a_transport)
896
return result, urlutils.unescape(a_transport.relpath(url))
897
except errors.NotBranchError, e:
900
new_t = a_transport.clone('..')
901
except errors.InvalidURLJoin:
902
# reached the root, whatever that may be
903
raise errors.NotBranchError(path=url)
904
if new_t.base == a_transport.base:
905
# reached the root, whatever that may be
906
raise errors.NotBranchError(path=url)
910
def open_tree_or_branch(klass, location):
911
"""Return the branch and working tree at a location.
913
If there is no tree at the location, tree will be None.
914
If there is no branch at the location, an exception will be
916
:return: (tree, branch)
918
bzrdir = klass.open(location)
919
return bzrdir._get_tree_branch()
922
def open_containing_tree_or_branch(klass, location):
923
"""Return the branch and working tree contained by a location.
925
Returns (tree, branch, relpath).
926
If there is no tree at containing the location, tree will be None.
927
If there is no branch containing the location, an exception will be
929
relpath is the portion of the path that is contained by the branch.
931
bzrdir, relpath = klass.open_containing(location)
932
tree, branch = bzrdir._get_tree_branch()
933
return tree, branch, relpath
936
def open_containing_tree_branch_or_repository(klass, location):
937
"""Return the working tree, branch and repo contained by a location.
939
Returns (tree, branch, repository, relpath).
940
If there is no tree containing the location, tree will be None.
941
If there is no branch containing the location, branch will be None.
942
If there is no repository containing the location, repository will be
944
relpath is the portion of the path that is contained by the innermost
947
If no tree, branch or repository is found, a NotBranchError is raised.
949
bzrdir, relpath = klass.open_containing(location)
951
tree, branch = bzrdir._get_tree_branch()
952
except errors.NotBranchError:
954
repo = bzrdir.find_repository()
955
return None, None, repo, relpath
956
except (errors.NoRepositoryPresent):
957
raise errors.NotBranchError(location)
958
return tree, branch, branch.repository, relpath
960
def _cloning_metadir(self):
961
"""Produce a metadir suitable for cloning with.
963
:returns: (destination_bzrdir_format, source_repository)
965
result_format = self._format.__class__()
968
branch = self.open_branch(ignore_fallbacks=True)
969
source_repository = branch.repository
970
result_format._branch_format = branch._format
971
except errors.NotBranchError:
973
source_repository = self.open_repository()
974
except errors.NoRepositoryPresent:
975
source_repository = None
977
# XXX TODO: This isinstance is here because we have not implemented
978
# the fix recommended in bug # 103195 - to delegate this choice the
980
repo_format = source_repository._format
981
if isinstance(repo_format, remote.RemoteRepositoryFormat):
982
source_repository._ensure_real()
983
repo_format = source_repository._real_repository._format
984
result_format.repository_format = repo_format
986
# TODO: Couldn't we just probe for the format in these cases,
987
# rather than opening the whole tree? It would be a little
988
# faster. mbp 20070401
989
tree = self.open_workingtree(recommend_upgrade=False)
990
except (errors.NoWorkingTree, errors.NotLocalUrl):
991
result_format.workingtree_format = None
993
result_format.workingtree_format = tree._format.__class__()
994
return result_format, source_repository
996
def cloning_metadir(self, require_stacking=False):
997
"""Produce a metadir suitable for cloning or sprouting with.
999
These operations may produce workingtrees (yes, even though they're
1000
"cloning" something that doesn't have a tree), so a viable workingtree
1001
format must be selected.
1003
:require_stacking: If True, non-stackable formats will be upgraded
1004
to similar stackable formats.
1005
:returns: a BzrDirFormat with all component formats either set
1006
appropriately or set to None if that component should not be
1009
format, repository = self._cloning_metadir()
1010
if format._workingtree_format is None:
1012
if repository is None:
1013
# No repository either
1015
# We have a repository, so set a working tree? (Why? This seems to
1016
# contradict the stated return value in the docstring).
1017
tree_format = repository._format._matchingbzrdir.workingtree_format
1018
format.workingtree_format = tree_format.__class__()
1019
if require_stacking:
1020
format.require_stacking()
1024
def create(cls, base, format=None, possible_transports=None):
1025
"""Create a new BzrDir at the url 'base'.
1027
:param format: If supplied, the format of branch to create. If not
1028
supplied, the default is used.
1029
:param possible_transports: If supplied, a list of transports that
1030
can be reused to share a remote connection.
1032
if cls is not BzrDir:
1033
raise AssertionError("BzrDir.create always creates the"
1034
"default format, not one of %r" % cls)
1035
t = _mod_transport.get_transport(base, possible_transports)
1038
format = controldir.ControlDirFormat.get_default_format()
1039
return format.initialize_on_transport(t)
1041
def get_branch_transport(self, branch_format, name=None):
1042
"""Get the transport for use by branch format in this BzrDir.
1044
Note that bzr dirs that do not support format strings will raise
1045
IncompatibleFormat if the branch format they are given has
1046
a format string, and vice versa.
1048
If branch_format is None, the transport is returned with no
1049
checking. If it is not None, then the returned transport is
1050
guaranteed to point to an existing directory ready for use.
1052
raise NotImplementedError(self.get_branch_transport)
1054
def get_repository_transport(self, repository_format):
1055
"""Get the transport for use by repository format in this BzrDir.
1057
Note that bzr dirs that do not support format strings will raise
1058
IncompatibleFormat if the repository format they are given has
1059
a format string, and vice versa.
1061
If repository_format is None, the transport is returned with no
1062
checking. If it is not None, then the returned transport is
1063
guaranteed to point to an existing directory ready for use.
1065
raise NotImplementedError(self.get_repository_transport)
1067
def get_workingtree_transport(self, tree_format):
1068
"""Get the transport for use by workingtree format in this BzrDir.
1070
Note that bzr dirs that do not support format strings will raise
1071
IncompatibleFormat if the workingtree format they are given has a
1072
format string, and vice versa.
1074
If workingtree_format is None, the transport is returned with no
1075
checking. If it is not None, then the returned transport is
1076
guaranteed to point to an existing directory ready for use.
1078
raise NotImplementedError(self.get_workingtree_transport)
1081
class BzrDirHooks(hooks.Hooks):
1082
"""Hooks for BzrDir operations."""
1085
"""Create the default hooks."""
1086
hooks.Hooks.__init__(self, "bzrlib.bzrdir", "BzrDir.hooks")
1087
self.add_hook('pre_open',
1088
"Invoked before attempting to open a BzrDir with the transport "
1089
"that the open will use.", (1, 14))
1090
self.add_hook('post_repo_init',
1091
"Invoked after a repository has been initialized. "
1092
"post_repo_init is called with a "
1093
"bzrlib.bzrdir.RepoInitHookParams.",
1096
# install the default hooks
1097
BzrDir.hooks = BzrDirHooks()
1100
class RepoInitHookParams(object):
1101
"""Object holding parameters passed to `*_repo_init` hooks.
1103
There are 4 fields that hooks may wish to access:
1105
:ivar repository: Repository created
1106
:ivar format: Repository format
1107
:ivar bzrdir: The bzrdir for the repository
1108
:ivar shared: The repository is shared
1111
def __init__(self, repository, format, a_bzrdir, shared):
1112
"""Create a group of RepoInitHook parameters.
1114
:param repository: Repository created
1115
:param format: Repository format
1116
:param bzrdir: The bzrdir for the repository
1117
:param shared: The repository is shared
1119
self.repository = repository
1120
self.format = format
1121
self.bzrdir = a_bzrdir
1122
self.shared = shared
1124
def __eq__(self, other):
1125
return self.__dict__ == other.__dict__
1129
return "<%s for %s>" % (self.__class__.__name__,
1132
return "<%s for %s>" % (self.__class__.__name__,
1136
class BzrDirMeta1(BzrDir):
1137
"""A .bzr meta version 1 control object.
1139
This is the first control object where the
1140
individual aspects are really split out: there are separate repository,
1141
workingtree and branch subdirectories and any subset of the three can be
1142
present within a BzrDir.
1145
def can_convert_format(self):
1146
"""See BzrDir.can_convert_format()."""
1149
def create_branch(self, name=None, repository=None,
1150
append_revisions_only=None):
1151
"""See BzrDir.create_branch."""
1152
return self._format.get_branch_format().initialize(self, name=name,
1153
repository=repository,
1154
append_revisions_only=append_revisions_only)
1156
def destroy_branch(self, name=None):
1157
"""See BzrDir.create_branch."""
1158
if name is not None:
1159
raise errors.NoColocatedBranchSupport(self)
1160
self.transport.delete_tree('branch')
1162
def create_repository(self, shared=False):
1163
"""See BzrDir.create_repository."""
1164
return self._format.repository_format.initialize(self, shared)
1166
def destroy_repository(self):
1167
"""See BzrDir.destroy_repository."""
1168
self.transport.delete_tree('repository')
1170
def create_workingtree(self, revision_id=None, from_branch=None,
1171
accelerator_tree=None, hardlink=False):
1172
"""See BzrDir.create_workingtree."""
1173
return self._format.workingtree_format.initialize(
1174
self, revision_id, from_branch=from_branch,
1175
accelerator_tree=accelerator_tree, hardlink=hardlink)
1177
def destroy_workingtree(self):
1178
"""See BzrDir.destroy_workingtree."""
1179
wt = self.open_workingtree(recommend_upgrade=False)
1180
repository = wt.branch.repository
1181
empty = repository.revision_tree(_mod_revision.NULL_REVISION)
1182
# We ignore the conflicts returned by wt.revert since we're about to
1183
# delete the wt metadata anyway, all that should be left here are
1184
# detritus. But see bug #634470 about subtree .bzr dirs.
1185
conflicts = wt.revert(old_tree=empty)
1186
self.destroy_workingtree_metadata()
1188
def destroy_workingtree_metadata(self):
1189
self.transport.delete_tree('checkout')
1191
def find_branch_format(self, name=None):
1192
"""Find the branch 'format' for this bzrdir.
1194
This might be a synthetic object for e.g. RemoteBranch and SVN.
1196
from bzrlib.branch import BranchFormat
1197
return BranchFormat.find_format(self, name=name)
1199
def _get_mkdir_mode(self):
1200
"""Figure out the mode to use when creating a bzrdir subdir."""
1201
temp_control = lockable_files.LockableFiles(self.transport, '',
1202
lockable_files.TransportLock)
1203
return temp_control._dir_mode
1205
def get_branch_reference(self, name=None):
1206
"""See BzrDir.get_branch_reference()."""
1207
from bzrlib.branch import BranchFormat
1208
format = BranchFormat.find_format(self, name=name)
1209
return format.get_reference(self, name=name)
1211
def get_branch_transport(self, branch_format, name=None):
1212
"""See BzrDir.get_branch_transport()."""
1213
if name is not None:
1214
raise errors.NoColocatedBranchSupport(self)
1215
# XXX: this shouldn't implicitly create the directory if it's just
1216
# promising to get a transport -- mbp 20090727
1217
if branch_format is None:
1218
return self.transport.clone('branch')
1220
branch_format.get_format_string()
1221
except NotImplementedError:
1222
raise errors.IncompatibleFormat(branch_format, self._format)
1224
self.transport.mkdir('branch', mode=self._get_mkdir_mode())
1225
except errors.FileExists:
1227
return self.transport.clone('branch')
1229
def get_repository_transport(self, repository_format):
1230
"""See BzrDir.get_repository_transport()."""
1231
if repository_format is None:
1232
return self.transport.clone('repository')
1234
repository_format.get_format_string()
1235
except NotImplementedError:
1236
raise errors.IncompatibleFormat(repository_format, self._format)
1238
self.transport.mkdir('repository', mode=self._get_mkdir_mode())
1239
except errors.FileExists:
1241
return self.transport.clone('repository')
1243
def get_workingtree_transport(self, workingtree_format):
1244
"""See BzrDir.get_workingtree_transport()."""
1245
if workingtree_format is None:
1246
return self.transport.clone('checkout')
1248
workingtree_format.get_format_string()
1249
except NotImplementedError:
1250
raise errors.IncompatibleFormat(workingtree_format, self._format)
1252
self.transport.mkdir('checkout', mode=self._get_mkdir_mode())
1253
except errors.FileExists:
1255
return self.transport.clone('checkout')
1257
def has_workingtree(self):
1258
"""Tell if this bzrdir contains a working tree.
1260
Note: if you're going to open the working tree, you should just go
1261
ahead and try, and not ask permission first.
1263
from bzrlib.workingtree import WorkingTreeFormat
1265
WorkingTreeFormat.find_format_string(self)
1266
except errors.NoWorkingTree:
1270
def needs_format_conversion(self, format):
1271
"""See BzrDir.needs_format_conversion()."""
1272
if not isinstance(self._format, format.__class__):
1273
# it is not a meta dir format, conversion is needed.
1275
# we might want to push this down to the repository?
1277
if not isinstance(self.open_repository()._format,
1278
format.repository_format.__class__):
1279
# the repository needs an upgrade.
1281
except errors.NoRepositoryPresent:
1283
for branch in self.list_branches():
1284
if not isinstance(branch._format,
1285
format.get_branch_format().__class__):
1286
# the branch needs an upgrade.
1289
my_wt = self.open_workingtree(recommend_upgrade=False)
1290
if not isinstance(my_wt._format,
1291
format.workingtree_format.__class__):
1292
# the workingtree needs an upgrade.
1294
except (errors.NoWorkingTree, errors.NotLocalUrl):
1298
def open_branch(self, name=None, unsupported=False,
1299
ignore_fallbacks=False):
1300
"""See BzrDir.open_branch."""
1301
format = self.find_branch_format(name=name)
1302
format.check_support_status(unsupported)
1303
return format.open(self, name=name,
1304
_found=True, ignore_fallbacks=ignore_fallbacks)
1306
def open_repository(self, unsupported=False):
1307
"""See BzrDir.open_repository."""
1308
from bzrlib.repository import RepositoryFormat
1309
format = RepositoryFormat.find_format(self)
1310
format.check_support_status(unsupported)
1311
return format.open(self, _found=True)
1313
def open_workingtree(self, unsupported=False,
1314
recommend_upgrade=True):
1315
"""See BzrDir.open_workingtree."""
1316
from bzrlib.workingtree import WorkingTreeFormat
1317
format = WorkingTreeFormat.find_format(self)
1318
format.check_support_status(unsupported, recommend_upgrade,
1319
basedir=self.root_transport.base)
1320
return format.open(self, _found=True)
1322
def _get_config(self):
1323
return config.TransportConfig(self.transport, 'control.conf')
1326
class BzrDirMeta1Colo(BzrDirMeta1):
1327
"""BzrDirMeta1 with support for colocated branches.
1329
This format is experimental, and will eventually be merged back into
1333
def __init__(self, _transport, _format):
1334
super(BzrDirMeta1Colo, self).__init__(_transport, _format)
1335
self.control_files = lockable_files.LockableFiles(_transport,
1336
self._format._lock_file_name, self._format._lock_class)
1338
def _get_branch_path(self, name):
1339
"""Obtain the branch path to use.
1341
This uses the API specified branch name first, and then falls back to
1342
the branch name specified in the URL. If neither of those is specified,
1343
it uses the default branch.
1345
:param name: Optional branch name to use
1346
:return: Relative path to branch, branch name
1349
name = self._get_selected_branch()
1351
return 'branch', None
1352
return urlutils.join('branches', name), name
1354
def _read_branch_list(self):
1355
"""Read the branch list.
1357
:return: List of utf-8 encoded branch names.
1360
f = self.control_transport.get('branch-list')
1361
except errors.NoSuchFile:
1367
ret.append(name.rstrip("\n"))
1372
def _write_branch_list(self, branches):
1373
"""Write out the branch list.
1375
:param branches: List of utf-8 branch names to write
1377
self.transport.put_bytes('branch-list',
1378
"".join([name+"\n" for name in branches]))
1380
def destroy_branch(self, name=None):
1381
"""See BzrDir.create_branch."""
1382
path, name = self._get_branch_path(name)
1383
if name is not None:
1384
self.control_files.lock_write()
1386
branches = self._read_branch_list()
1388
branches.remove(name)
1390
raise errors.NotBranchError(name)
1391
self._write_branch_list(name)
1393
self.control_files.unlock()
1394
self.transport.delete_tree(path)
1396
def list_branches(self):
1397
"""See ControlDir.list_branches."""
1401
ret.append(self.open_branch())
1402
except (errors.NotBranchError, errors.NoRepositoryPresent):
1405
# colocated branches
1406
ret.extend([self.open_branch(name) for name in
1407
self._read_branch_list()])
1411
def get_branch_transport(self, branch_format, name=None):
1412
"""See BzrDir.get_branch_transport()."""
1413
path, name = self._get_branch_path(name)
1414
# XXX: this shouldn't implicitly create the directory if it's just
1415
# promising to get a transport -- mbp 20090727
1416
if branch_format is None:
1417
return self.transport.clone(path)
1419
branch_format.get_format_string()
1420
except NotImplementedError:
1421
raise errors.IncompatibleFormat(branch_format, self._format)
1422
if name is not None:
1424
self.transport.mkdir('branches', mode=self._get_mkdir_mode())
1425
except errors.FileExists:
1427
branches = self._read_branch_list()
1428
if not name in branches:
1429
self.control_files.lock_write()
1431
branches = self._read_branch_list()
1432
branches.append(name)
1433
self._write_branch_list(branches)
1435
self.control_files.unlock()
1437
self.transport.mkdir(path, mode=self._get_mkdir_mode())
1438
except errors.FileExists:
1440
return self.transport.clone(path)
1443
class BzrProber(controldir.Prober):
1444
"""Prober for formats that use a .bzr/ control directory."""
1446
formats = registry.FormatRegistry(controldir.network_format_registry)
1447
"""The known .bzr formats."""
1450
@deprecated_method(deprecated_in((2, 4, 0)))
1451
def register_bzrdir_format(klass, format):
1452
klass.formats.register(format.get_format_string(), format)
1455
@deprecated_method(deprecated_in((2, 4, 0)))
1456
def unregister_bzrdir_format(klass, format):
1457
klass.formats.remove(format.get_format_string())
1460
def probe_transport(klass, transport):
1461
"""Return the .bzrdir style format present in a directory."""
1463
format_string = transport.get_bytes(".bzr/branch-format")
1464
except errors.NoSuchFile:
1465
raise errors.NotBranchError(path=transport.base)
1467
return klass.formats.get(format_string)
1469
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1472
def known_formats(cls):
1474
for name, format in cls.formats.iteritems():
1475
if callable(format):
1481
controldir.ControlDirFormat.register_prober(BzrProber)
1484
class RemoteBzrProber(controldir.Prober):
1485
"""Prober for remote servers that provide a Bazaar smart server."""
1488
def probe_transport(klass, transport):
1489
"""Return a RemoteBzrDirFormat object if it looks possible."""
1491
medium = transport.get_smart_medium()
1492
except (NotImplementedError, AttributeError,
1493
errors.TransportNotPossible, errors.NoSmartMedium,
1494
errors.SmartProtocolError):
1495
# no smart server, so not a branch for this format type.
1496
raise errors.NotBranchError(path=transport.base)
1498
# Decline to open it if the server doesn't support our required
1499
# version (3) so that the VFS-based transport will do it.
1500
if medium.should_probe():
1502
server_version = medium.protocol_version()
1503
except errors.SmartProtocolError:
1504
# Apparently there's no usable smart server there, even though
1505
# the medium supports the smart protocol.
1506
raise errors.NotBranchError(path=transport.base)
1507
if server_version != '2':
1508
raise errors.NotBranchError(path=transport.base)
1509
from bzrlib.remote import RemoteBzrDirFormat
1510
return RemoteBzrDirFormat()
1513
def known_formats(cls):
1514
from bzrlib.remote import RemoteBzrDirFormat
1515
return set([RemoteBzrDirFormat()])
1518
class BzrDirFormat(controldir.ControlDirFormat):
1519
"""ControlDirFormat base class for .bzr/ directories.
1521
Formats are placed in a dict by their format string for reference
1522
during bzrdir opening. These should be subclasses of BzrDirFormat
1525
Once a format is deprecated, just deprecate the initialize and open
1526
methods on the format class. Do not deprecate the object, as the
1527
object will be created every system load.
1530
_lock_file_name = 'branch-lock'
1532
# _lock_class must be set in subclasses to the lock type, typ.
1533
# TransportLock or LockDir
1536
def get_format_string(cls):
1537
"""Return the ASCII format string that identifies this format."""
1538
raise NotImplementedError(cls.get_format_string)
1540
def initialize_on_transport(self, transport):
1541
"""Initialize a new bzrdir in the base directory of a Transport."""
1543
# can we hand off the request to the smart server rather than using
1545
client_medium = transport.get_smart_medium()
1546
except errors.NoSmartMedium:
1547
return self._initialize_on_transport_vfs(transport)
1549
# Current RPC's only know how to create bzr metadir1 instances, so
1550
# we still delegate to vfs methods if the requested format is not a
1552
if type(self) != BzrDirMetaFormat1:
1553
return self._initialize_on_transport_vfs(transport)
1554
from bzrlib.remote import RemoteBzrDirFormat
1555
remote_format = RemoteBzrDirFormat()
1556
self._supply_sub_formats_to(remote_format)
1557
return remote_format.initialize_on_transport(transport)
1559
def initialize_on_transport_ex(self, transport, use_existing_dir=False,
1560
create_prefix=False, force_new_repo=False, stacked_on=None,
1561
stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
1562
shared_repo=False, vfs_only=False):
1563
"""Create this format on transport.
1565
The directory to initialize will be created.
1567
:param force_new_repo: Do not use a shared repository for the target,
1568
even if one is available.
1569
:param create_prefix: Create any missing directories leading up to
1571
:param use_existing_dir: Use an existing directory if one exists.
1572
:param stacked_on: A url to stack any created branch on, None to follow
1573
any target stacking policy.
1574
:param stack_on_pwd: If stack_on is relative, the location it is
1576
:param repo_format_name: If non-None, a repository will be
1577
made-or-found. Should none be found, or if force_new_repo is True
1578
the repo_format_name is used to select the format of repository to
1580
:param make_working_trees: Control the setting of make_working_trees
1581
for a new shared repository when one is made. None to use whatever
1582
default the format has.
1583
:param shared_repo: Control whether made repositories are shared or
1585
:param vfs_only: If True do not attempt to use a smart server
1586
:return: repo, bzrdir, require_stacking, repository_policy. repo is
1587
None if none was created or found, bzrdir is always valid.
1588
require_stacking is the result of examining the stacked_on
1589
parameter and any stacking policy found for the target.
1592
# Try to hand off to a smart server
1594
client_medium = transport.get_smart_medium()
1595
except errors.NoSmartMedium:
1598
from bzrlib.remote import RemoteBzrDirFormat
1599
# TODO: lookup the local format from a server hint.
1600
remote_dir_format = RemoteBzrDirFormat()
1601
remote_dir_format._network_name = self.network_name()
1602
self._supply_sub_formats_to(remote_dir_format)
1603
return remote_dir_format.initialize_on_transport_ex(transport,
1604
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
1605
force_new_repo=force_new_repo, stacked_on=stacked_on,
1606
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
1607
make_working_trees=make_working_trees, shared_repo=shared_repo)
1608
# XXX: Refactor the create_prefix/no_create_prefix code into a
1609
# common helper function
1610
# The destination may not exist - if so make it according to policy.
1611
def make_directory(transport):
1612
transport.mkdir('.')
1614
def redirected(transport, e, redirection_notice):
1615
note(redirection_notice)
1616
return transport._redirected_to(e.source, e.target)
1618
transport = do_catching_redirections(make_directory, transport,
1620
except errors.FileExists:
1621
if not use_existing_dir:
1623
except errors.NoSuchFile:
1624
if not create_prefix:
1626
transport.create_prefix()
1628
require_stacking = (stacked_on is not None)
1629
# Now the target directory exists, but doesn't have a .bzr
1630
# directory. So we need to create it, along with any work to create
1631
# all of the dependent branches, etc.
1633
result = self.initialize_on_transport(transport)
1634
if repo_format_name:
1636
# use a custom format
1637
result._format.repository_format = \
1638
repository.network_format_registry.get(repo_format_name)
1639
except AttributeError:
1640
# The format didn't permit it to be set.
1642
# A repository is desired, either in-place or shared.
1643
repository_policy = result.determine_repository_policy(
1644
force_new_repo, stacked_on, stack_on_pwd,
1645
require_stacking=require_stacking)
1646
result_repo, is_new_repo = repository_policy.acquire_repository(
1647
make_working_trees, shared_repo)
1648
if not require_stacking and repository_policy._require_stacking:
1649
require_stacking = True
1650
result._format.require_stacking()
1651
result_repo.lock_write()
1654
repository_policy = None
1655
return result_repo, result, require_stacking, repository_policy
1657
def _initialize_on_transport_vfs(self, transport):
1658
"""Initialize a new bzrdir using VFS calls.
1660
:param transport: The transport to create the .bzr directory in.
1663
# Since we are creating a .bzr directory, inherit the
1664
# mode from the root directory
1665
temp_control = lockable_files.LockableFiles(transport,
1666
'', lockable_files.TransportLock)
1667
temp_control._transport.mkdir('.bzr',
1668
# FIXME: RBC 20060121 don't peek under
1670
mode=temp_control._dir_mode)
1671
if sys.platform == 'win32' and isinstance(transport, local.LocalTransport):
1672
win32utils.set_file_attr_hidden(transport._abspath('.bzr'))
1673
file_mode = temp_control._file_mode
1675
bzrdir_transport = transport.clone('.bzr')
1676
utf8_files = [('README',
1677
"This is a Bazaar control directory.\n"
1678
"Do not change any files in this directory.\n"
1679
"See http://bazaar.canonical.com/ for more information about Bazaar.\n"),
1680
('branch-format', self.get_format_string()),
1682
# NB: no need to escape relative paths that are url safe.
1683
control_files = lockable_files.LockableFiles(bzrdir_transport,
1684
self._lock_file_name, self._lock_class)
1685
control_files.create_lock()
1686
control_files.lock_write()
1688
for (filename, content) in utf8_files:
1689
bzrdir_transport.put_bytes(filename, content,
1692
control_files.unlock()
1693
return self.open(transport, _found=True)
1695
def open(self, transport, _found=False):
1696
"""Return an instance of this format for the dir transport points at.
1698
_found is a private parameter, do not use it.
1701
found_format = controldir.ControlDirFormat.find_format(transport)
1702
if not isinstance(found_format, self.__class__):
1703
raise AssertionError("%s was asked to open %s, but it seems to need "
1705
% (self, transport, found_format))
1706
# Allow subclasses - use the found format.
1707
self._supply_sub_formats_to(found_format)
1708
return found_format._open(transport)
1709
return self._open(transport)
1711
def _open(self, transport):
1712
"""Template method helper for opening BzrDirectories.
1714
This performs the actual open and any additional logic or parameter
1717
raise NotImplementedError(self._open)
1719
def _supply_sub_formats_to(self, other_format):
1720
"""Give other_format the same values for sub formats as this has.
1722
This method is expected to be used when parameterising a
1723
RemoteBzrDirFormat instance with the parameters from a
1724
BzrDirMetaFormat1 instance.
1726
:param other_format: other_format is a format which should be
1727
compatible with whatever sub formats are supported by self.
1732
class BzrDirMetaFormat1(BzrDirFormat):
1733
"""Bzr meta control format 1
1735
This is the first format with split out working tree, branch and repository
1740
- Format 3 working trees [optional]
1741
- Format 5 branches [optional]
1742
- Format 7 repositories [optional]
1745
_lock_class = lockdir.LockDir
1747
fixed_components = False
1749
colocated_branches = False
1752
self._workingtree_format = None
1753
self._branch_format = None
1754
self._repository_format = None
1756
def __eq__(self, other):
1757
if other.__class__ is not self.__class__:
1759
if other.repository_format != self.repository_format:
1761
if other.workingtree_format != self.workingtree_format:
1765
def __ne__(self, other):
1766
return not self == other
1768
def get_branch_format(self):
1769
if self._branch_format is None:
1770
from bzrlib.branch import format_registry as branch_format_registry
1771
self._branch_format = branch_format_registry.get_default()
1772
return self._branch_format
1774
def set_branch_format(self, format):
1775
self._branch_format = format
1777
def require_stacking(self, stack_on=None, possible_transports=None,
1779
"""We have a request to stack, try to ensure the formats support it.
1781
:param stack_on: If supplied, it is the URL to a branch that we want to
1782
stack on. Check to see if that format supports stacking before
1785
# Stacking is desired. requested by the target, but does the place it
1786
# points at support stacking? If it doesn't then we should
1787
# not implicitly upgrade. We check this here.
1788
new_repo_format = None
1789
new_branch_format = None
1791
# a bit of state for get_target_branch so that we don't try to open it
1792
# 2 times, for both repo *and* branch
1793
target = [None, False, None] # target_branch, checked, upgrade anyway
1794
def get_target_branch():
1796
# We've checked, don't check again
1798
if stack_on is None:
1799
# No target format, that means we want to force upgrading
1800
target[:] = [None, True, True]
1803
target_dir = BzrDir.open(stack_on,
1804
possible_transports=possible_transports)
1805
except errors.NotBranchError:
1806
# Nothing there, don't change formats
1807
target[:] = [None, True, False]
1809
except errors.JailBreak:
1810
# JailBreak, JFDI and upgrade anyway
1811
target[:] = [None, True, True]
1814
target_branch = target_dir.open_branch()
1815
except errors.NotBranchError:
1816
# No branch, don't upgrade formats
1817
target[:] = [None, True, False]
1819
target[:] = [target_branch, True, False]
1822
if (not _skip_repo and
1823
not self.repository_format.supports_external_lookups):
1824
# We need to upgrade the Repository.
1825
target_branch, _, do_upgrade = get_target_branch()
1826
if target_branch is None:
1827
# We don't have a target branch, should we upgrade anyway?
1829
# stack_on is inaccessible, JFDI.
1830
# TODO: bad monkey, hard-coded formats...
1831
if self.repository_format.rich_root_data:
1832
new_repo_format = knitpack_repo.RepositoryFormatKnitPack5RichRoot()
1834
new_repo_format = knitpack_repo.RepositoryFormatKnitPack5()
1836
# If the target already supports stacking, then we know the
1837
# project is already able to use stacking, so auto-upgrade
1839
new_repo_format = target_branch.repository._format
1840
if not new_repo_format.supports_external_lookups:
1841
# target doesn't, source doesn't, so don't auto upgrade
1843
new_repo_format = None
1844
if new_repo_format is not None:
1845
self.repository_format = new_repo_format
1846
note(gettext('Source repository format does not support stacking,'
1847
' using format:\n %s'),
1848
new_repo_format.get_format_description())
1850
if not self.get_branch_format().supports_stacking():
1851
# We just checked the repo, now lets check if we need to
1852
# upgrade the branch format
1853
target_branch, _, do_upgrade = get_target_branch()
1854
if target_branch is None:
1856
# TODO: bad monkey, hard-coded formats...
1857
from bzrlib.branch import BzrBranchFormat7
1858
new_branch_format = BzrBranchFormat7()
1860
new_branch_format = target_branch._format
1861
if not new_branch_format.supports_stacking():
1862
new_branch_format = None
1863
if new_branch_format is not None:
1864
# Does support stacking, use its format.
1865
self.set_branch_format(new_branch_format)
1866
note(gettext('Source branch format does not support stacking,'
1867
' using format:\n %s'),
1868
new_branch_format.get_format_description())
1870
def get_converter(self, format=None):
1871
"""See BzrDirFormat.get_converter()."""
1873
format = BzrDirFormat.get_default_format()
1874
if not isinstance(self, format.__class__):
1875
# converting away from metadir is not implemented
1876
raise NotImplementedError(self.get_converter)
1877
return ConvertMetaToMeta(format)
1880
def get_format_string(cls):
1881
"""See BzrDirFormat.get_format_string()."""
1882
return "Bazaar-NG meta directory, format 1\n"
1884
def get_format_description(self):
1885
"""See BzrDirFormat.get_format_description()."""
1886
return "Meta directory format 1"
1888
def network_name(self):
1889
return self.get_format_string()
1891
def _open(self, transport):
1892
"""See BzrDirFormat._open."""
1893
# Create a new format instance because otherwise initialisation of new
1894
# metadirs share the global default format object leading to alias
1896
format = BzrDirMetaFormat1()
1897
self._supply_sub_formats_to(format)
1898
return BzrDirMeta1(transport, format)
1900
def __return_repository_format(self):
1901
"""Circular import protection."""
1902
if self._repository_format:
1903
return self._repository_format
1904
from bzrlib.repository import format_registry
1905
return format_registry.get_default()
1907
def _set_repository_format(self, value):
1908
"""Allow changing the repository format for metadir formats."""
1909
self._repository_format = value
1911
repository_format = property(__return_repository_format,
1912
_set_repository_format)
1914
def _supply_sub_formats_to(self, other_format):
1915
"""Give other_format the same values for sub formats as this has.
1917
This method is expected to be used when parameterising a
1918
RemoteBzrDirFormat instance with the parameters from a
1919
BzrDirMetaFormat1 instance.
1921
:param other_format: other_format is a format which should be
1922
compatible with whatever sub formats are supported by self.
1925
if getattr(self, '_repository_format', None) is not None:
1926
other_format.repository_format = self.repository_format
1927
if self._branch_format is not None:
1928
other_format._branch_format = self._branch_format
1929
if self._workingtree_format is not None:
1930
other_format.workingtree_format = self.workingtree_format
1932
def __get_workingtree_format(self):
1933
if self._workingtree_format is None:
1934
from bzrlib.workingtree import (
1935
format_registry as wt_format_registry,
1937
self._workingtree_format = wt_format_registry.get_default()
1938
return self._workingtree_format
1940
def __set_workingtree_format(self, wt_format):
1941
self._workingtree_format = wt_format
1943
workingtree_format = property(__get_workingtree_format,
1944
__set_workingtree_format)
1947
# Register bzr formats
1948
BzrProber.formats.register(BzrDirMetaFormat1.get_format_string(),
1950
controldir.ControlDirFormat._default_format = BzrDirMetaFormat1()
1953
class BzrDirMetaFormat1Colo(BzrDirMetaFormat1):
1954
"""BzrDirMeta1 format with support for colocated branches."""
1956
colocated_branches = True
1959
def get_format_string(cls):
1960
"""See BzrDirFormat.get_format_string()."""
1961
return "Bazaar meta directory, format 1 (with colocated branches)\n"
1963
def get_format_description(self):
1964
"""See BzrDirFormat.get_format_description()."""
1965
return "Meta directory format 1 with support for colocated branches"
1967
def _open(self, transport):
1968
"""See BzrDirFormat._open."""
1969
# Create a new format instance because otherwise initialisation of new
1970
# metadirs share the global default format object leading to alias
1972
format = BzrDirMetaFormat1Colo()
1973
self._supply_sub_formats_to(format)
1974
return BzrDirMeta1Colo(transport, format)
1977
BzrProber.formats.register(BzrDirMetaFormat1Colo.get_format_string(),
1978
BzrDirMetaFormat1Colo)
1981
class ConvertMetaToMeta(controldir.Converter):
1982
"""Converts the components of metadirs."""
1984
def __init__(self, target_format):
1985
"""Create a metadir to metadir converter.
1987
:param target_format: The final metadir format that is desired.
1989
self.target_format = target_format
1991
def convert(self, to_convert, pb):
1992
"""See Converter.convert()."""
1993
self.bzrdir = to_convert
1994
self.pb = ui.ui_factory.nested_progress_bar()
1997
self.step('checking repository format')
1999
repo = self.bzrdir.open_repository()
2000
except errors.NoRepositoryPresent:
2003
if not isinstance(repo._format, self.target_format.repository_format.__class__):
2004
from bzrlib.repository import CopyConverter
2005
ui.ui_factory.note(gettext('starting repository conversion'))
2006
converter = CopyConverter(self.target_format.repository_format)
2007
converter.convert(repo, pb)
2008
for branch in self.bzrdir.list_branches():
2009
# TODO: conversions of Branch and Tree should be done by
2010
# InterXFormat lookups/some sort of registry.
2011
# Avoid circular imports
2012
old = branch._format.__class__
2013
new = self.target_format.get_branch_format().__class__
2015
if (old == _mod_branch.BzrBranchFormat5 and
2016
new in (_mod_branch.BzrBranchFormat6,
2017
_mod_branch.BzrBranchFormat7,
2018
_mod_branch.BzrBranchFormat8)):
2019
branch_converter = _mod_branch.Converter5to6()
2020
elif (old == _mod_branch.BzrBranchFormat6 and
2021
new in (_mod_branch.BzrBranchFormat7,
2022
_mod_branch.BzrBranchFormat8)):
2023
branch_converter = _mod_branch.Converter6to7()
2024
elif (old == _mod_branch.BzrBranchFormat7 and
2025
new is _mod_branch.BzrBranchFormat8):
2026
branch_converter = _mod_branch.Converter7to8()
2028
raise errors.BadConversionTarget("No converter", new,
2030
branch_converter.convert(branch)
2031
branch = self.bzrdir.open_branch()
2032
old = branch._format.__class__
2034
tree = self.bzrdir.open_workingtree(recommend_upgrade=False)
2035
except (errors.NoWorkingTree, errors.NotLocalUrl):
2038
# TODO: conversions of Branch and Tree should be done by
2039
# InterXFormat lookups
2040
if (isinstance(tree, workingtree_3.WorkingTree3) and
2041
not isinstance(tree, workingtree_4.DirStateWorkingTree) and
2042
isinstance(self.target_format.workingtree_format,
2043
workingtree_4.DirStateWorkingTreeFormat)):
2044
workingtree_4.Converter3to4().convert(tree)
2045
if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
2046
not isinstance(tree, workingtree_4.WorkingTree5) and
2047
isinstance(self.target_format.workingtree_format,
2048
workingtree_4.WorkingTreeFormat5)):
2049
workingtree_4.Converter4to5().convert(tree)
2050
if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
2051
not isinstance(tree, workingtree_4.WorkingTree6) and
2052
isinstance(self.target_format.workingtree_format,
2053
workingtree_4.WorkingTreeFormat6)):
2054
workingtree_4.Converter4or5to6().convert(tree)
2059
controldir.ControlDirFormat.register_server_prober(RemoteBzrProber)
2062
class RepositoryAcquisitionPolicy(object):
2063
"""Abstract base class for repository acquisition policies.
2065
A repository acquisition policy decides how a BzrDir acquires a repository
2066
for a branch that is being created. The most basic policy decision is
2067
whether to create a new repository or use an existing one.
2069
def __init__(self, stack_on, stack_on_pwd, require_stacking):
2072
:param stack_on: A location to stack on
2073
:param stack_on_pwd: If stack_on is relative, the location it is
2075
:param require_stacking: If True, it is a failure to not stack.
2077
self._stack_on = stack_on
2078
self._stack_on_pwd = stack_on_pwd
2079
self._require_stacking = require_stacking
2081
def configure_branch(self, branch):
2082
"""Apply any configuration data from this policy to the branch.
2084
Default implementation sets repository stacking.
2086
if self._stack_on is None:
2088
if self._stack_on_pwd is None:
2089
stack_on = self._stack_on
2092
stack_on = urlutils.rebase_url(self._stack_on,
2095
except errors.InvalidRebaseURLs:
2096
stack_on = self._get_full_stack_on()
2098
branch.set_stacked_on_url(stack_on)
2099
except (errors.UnstackableBranchFormat,
2100
errors.UnstackableRepositoryFormat):
2101
if self._require_stacking:
2104
def requires_stacking(self):
2105
"""Return True if this policy requires stacking."""
2106
return self._stack_on is not None and self._require_stacking
2108
def _get_full_stack_on(self):
2109
"""Get a fully-qualified URL for the stack_on location."""
2110
if self._stack_on is None:
2112
if self._stack_on_pwd is None:
2113
return self._stack_on
2115
return urlutils.join(self._stack_on_pwd, self._stack_on)
2117
def _add_fallback(self, repository, possible_transports=None):
2118
"""Add a fallback to the supplied repository, if stacking is set."""
2119
stack_on = self._get_full_stack_on()
2120
if stack_on is None:
2123
stacked_dir = BzrDir.open(stack_on,
2124
possible_transports=possible_transports)
2125
except errors.JailBreak:
2126
# We keep the stacking details, but we are in the server code so
2127
# actually stacking is not needed.
2130
stacked_repo = stacked_dir.open_branch().repository
2131
except errors.NotBranchError:
2132
stacked_repo = stacked_dir.open_repository()
2134
repository.add_fallback_repository(stacked_repo)
2135
except errors.UnstackableRepositoryFormat:
2136
if self._require_stacking:
2139
self._require_stacking = True
2141
def acquire_repository(self, make_working_trees=None, shared=False):
2142
"""Acquire a repository for this bzrdir.
2144
Implementations may create a new repository or use a pre-exising
2147
:param make_working_trees: If creating a repository, set
2148
make_working_trees to this value (if non-None)
2149
:param shared: If creating a repository, make it shared if True
2150
:return: A repository, is_new_flag (True if the repository was
2153
raise NotImplemented(RepositoryAcquisitionPolicy.acquire_repository)
2156
class CreateRepository(RepositoryAcquisitionPolicy):
2157
"""A policy of creating a new repository"""
2159
def __init__(self, bzrdir, stack_on=None, stack_on_pwd=None,
2160
require_stacking=False):
2163
:param bzrdir: The bzrdir to create the repository on.
2164
:param stack_on: A location to stack on
2165
:param stack_on_pwd: If stack_on is relative, the location it is
2168
RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
2170
self._bzrdir = bzrdir
2172
def acquire_repository(self, make_working_trees=None, shared=False):
2173
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
2175
Creates the desired repository in the bzrdir we already have.
2177
stack_on = self._get_full_stack_on()
2179
format = self._bzrdir._format
2180
format.require_stacking(stack_on=stack_on,
2181
possible_transports=[self._bzrdir.root_transport])
2182
if not self._require_stacking:
2183
# We have picked up automatic stacking somewhere.
2184
note(gettext('Using default stacking branch {0} at {1}').format(
2185
self._stack_on, self._stack_on_pwd))
2186
repository = self._bzrdir.create_repository(shared=shared)
2187
self._add_fallback(repository,
2188
possible_transports=[self._bzrdir.transport])
2189
if make_working_trees is not None:
2190
repository.set_make_working_trees(make_working_trees)
2191
return repository, True
2194
class UseExistingRepository(RepositoryAcquisitionPolicy):
2195
"""A policy of reusing an existing repository"""
2197
def __init__(self, repository, stack_on=None, stack_on_pwd=None,
2198
require_stacking=False):
2201
:param repository: The repository to use.
2202
:param stack_on: A location to stack on
2203
:param stack_on_pwd: If stack_on is relative, the location it is
2206
RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
2208
self._repository = repository
2210
def acquire_repository(self, make_working_trees=None, shared=False):
2211
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
2213
Returns an existing repository to use.
2215
self._add_fallback(self._repository,
2216
possible_transports=[self._repository.bzrdir.transport])
2217
return self._repository, False
2220
def register_metadir(registry, key,
2221
repository_format, help, native=True, deprecated=False,
2226
alias=False, bzrdir_format=None):
2227
"""Register a metadir subformat.
2229
These all use a meta bzrdir, but can be parameterized by the
2230
Repository/Branch/WorkingTreeformats.
2232
:param repository_format: The fully-qualified repository format class
2234
:param branch_format: Fully-qualified branch format class name as
2236
:param tree_format: Fully-qualified tree format class name as
2239
if bzrdir_format is None:
2240
bzrdir_format = BzrDirMetaFormat1
2241
# This should be expanded to support setting WorkingTree and Branch
2242
# formats, once the API supports that.
2243
def _load(full_name):
2244
mod_name, factory_name = full_name.rsplit('.', 1)
2246
factory = pyutils.get_named_object(mod_name, factory_name)
2247
except ImportError, e:
2248
raise ImportError('failed to load %s: %s' % (full_name, e))
2249
except AttributeError:
2250
raise AttributeError('no factory %s in module %r'
2251
% (full_name, sys.modules[mod_name]))
2255
bd = bzrdir_format()
2256
if branch_format is not None:
2257
bd.set_branch_format(_load(branch_format))
2258
if tree_format is not None:
2259
bd.workingtree_format = _load(tree_format)
2260
if repository_format is not None:
2261
bd.repository_format = _load(repository_format)
2263
registry.register(key, helper, help, native, deprecated, hidden,
2264
experimental, alias)
2266
register_metadir(controldir.format_registry, 'knit',
2267
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2268
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
2269
branch_format='bzrlib.branch.BzrBranchFormat5',
2270
tree_format='bzrlib.workingtree_3.WorkingTreeFormat3',
2273
register_metadir(controldir.format_registry, 'dirstate',
2274
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2275
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
2276
'above when accessed over the network.',
2277
branch_format='bzrlib.branch.BzrBranchFormat5',
2278
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2281
register_metadir(controldir.format_registry, 'dirstate-tags',
2282
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2283
help='New in 0.15: Fast local operations and improved scaling for '
2284
'network operations. Additionally adds support for tags.'
2285
' Incompatible with bzr < 0.15.',
2286
branch_format='bzrlib.branch.BzrBranchFormat6',
2287
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2290
register_metadir(controldir.format_registry, 'rich-root',
2291
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
2292
help='New in 1.0. Better handling of tree roots. Incompatible with'
2294
branch_format='bzrlib.branch.BzrBranchFormat6',
2295
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2298
register_metadir(controldir.format_registry, 'dirstate-with-subtree',
2299
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
2300
help='New in 0.15: Fast local operations and improved scaling for '
2301
'network operations. Additionally adds support for versioning nested '
2302
'bzr branches. Incompatible with bzr < 0.15.',
2303
branch_format='bzrlib.branch.BzrBranchFormat6',
2304
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2308
register_metadir(controldir.format_registry, 'pack-0.92',
2309
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack1',
2310
help='New in 0.92: Pack-based format with data compatible with '
2311
'dirstate-tags format repositories. Interoperates with '
2312
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
2314
branch_format='bzrlib.branch.BzrBranchFormat6',
2315
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2317
register_metadir(controldir.format_registry, 'pack-0.92-subtree',
2318
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack3',
2319
help='New in 0.92: Pack-based format with data compatible with '
2320
'dirstate-with-subtree format repositories. Interoperates with '
2321
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
2323
branch_format='bzrlib.branch.BzrBranchFormat6',
2324
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2328
register_metadir(controldir.format_registry, 'rich-root-pack',
2329
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack4',
2330
help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
2331
'(needed for bzr-svn and bzr-git).',
2332
branch_format='bzrlib.branch.BzrBranchFormat6',
2333
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2336
register_metadir(controldir.format_registry, '1.6',
2337
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack5',
2338
help='A format that allows a branch to indicate that there is another '
2339
'(stacked) repository that should be used to access data that is '
2340
'not present locally.',
2341
branch_format='bzrlib.branch.BzrBranchFormat7',
2342
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2345
register_metadir(controldir.format_registry, '1.6.1-rich-root',
2346
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack5RichRoot',
2347
help='A variant of 1.6 that supports rich-root data '
2348
'(needed for bzr-svn and bzr-git).',
2349
branch_format='bzrlib.branch.BzrBranchFormat7',
2350
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2353
register_metadir(controldir.format_registry, '1.9',
2354
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6',
2355
help='A repository format using B+tree indexes. These indexes '
2356
'are smaller in size, have smarter caching and provide faster '
2357
'performance for most operations.',
2358
branch_format='bzrlib.branch.BzrBranchFormat7',
2359
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2362
register_metadir(controldir.format_registry, '1.9-rich-root',
2363
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6RichRoot',
2364
help='A variant of 1.9 that supports rich-root data '
2365
'(needed for bzr-svn and bzr-git).',
2366
branch_format='bzrlib.branch.BzrBranchFormat7',
2367
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2370
register_metadir(controldir.format_registry, '1.14',
2371
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6',
2372
help='A working-tree format that supports content filtering.',
2373
branch_format='bzrlib.branch.BzrBranchFormat7',
2374
tree_format='bzrlib.workingtree_4.WorkingTreeFormat5',
2376
register_metadir(controldir.format_registry, '1.14-rich-root',
2377
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6RichRoot',
2378
help='A variant of 1.14 that supports rich-root data '
2379
'(needed for bzr-svn and bzr-git).',
2380
branch_format='bzrlib.branch.BzrBranchFormat7',
2381
tree_format='bzrlib.workingtree_4.WorkingTreeFormat5',
2383
# The following un-numbered 'development' formats should always just be aliases.
2384
register_metadir(controldir.format_registry, 'development-subtree',
2385
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2aSubtree',
2386
help='Current development format, subtree variant. Can convert data to and '
2387
'from pack-0.92-subtree (and anything compatible with '
2388
'pack-0.92-subtree) format repositories. Repositories and branches in '
2389
'this format can only be read by bzr.dev. Please read '
2390
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
2392
branch_format='bzrlib.branch.BzrBranchFormat7',
2393
tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
2396
alias=False, # Restore to being an alias when an actual development subtree format is added
2397
# This current non-alias status is simply because we did not introduce a
2398
# chk based subtree format.
2400
register_metadir(controldir.format_registry, 'development5-subtree',
2401
'bzrlib.repofmt.knitpack_repo.RepositoryFormatPackDevelopment2Subtree',
2402
help='Development format, subtree variant. Can convert data to and '
2403
'from pack-0.92-subtree (and anything compatible with '
2404
'pack-0.92-subtree) format repositories. Repositories and branches in '
2405
'this format can only be read by bzr.dev. Please read '
2406
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
2408
branch_format='bzrlib.branch.BzrBranchFormat7',
2409
tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
2415
register_metadir(controldir.format_registry, 'development-colo',
2416
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
2417
help='The 2a format with experimental support for colocated branches.\n',
2418
branch_format='bzrlib.branch.BzrBranchFormat7',
2419
tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
2421
bzrdir_format=BzrDirMetaFormat1Colo,
2425
# And the development formats above will have aliased one of the following:
2427
# Finally, the current format.
2428
register_metadir(controldir.format_registry, '2a',
2429
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
2430
help='First format for bzr 2.0 series.\n'
2431
'Uses group-compress storage.\n'
2432
'Provides rich roots which are a one-way transition.\n',
2433
# 'storage in packs, 255-way hashed CHK inventory, bencode revision, group compress, '
2434
# 'rich roots. Supported by bzr 1.16 and later.',
2435
branch_format='bzrlib.branch.BzrBranchFormat7',
2436
tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
2440
# The following format should be an alias for the rich root equivalent
2441
# of the default format
2442
register_metadir(controldir.format_registry, 'default-rich-root',
2443
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
2444
branch_format='bzrlib.branch.BzrBranchFormat7',
2445
tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
2450
# The current format that is made on 'bzr init'.
2451
format_name = config.GlobalStack().get('default_format')
2452
controldir.format_registry.set_default(format_name)
2454
# XXX 2010-08-20 JRV: There is still a lot of code relying on
2455
# bzrlib.bzrdir.format_registry existing. When BzrDir.create/BzrDir.open/etc
2456
# get changed to ControlDir.create/ControlDir.open/etc this should be removed.
2457
format_registry = controldir.format_registry
added
removed
bzrlib/bzrdir.py
