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,
60
from bzrlib.trace import (
71
from bzrlib.symbol_versioning import (
77
class BzrDir(controldir.ControlDir):
78
"""A .bzr control diretory.
80
BzrDir instances let you create or open any of the things that can be
81
found within .bzr - checkouts, branches and repositories.
84
the transport which this bzr dir is rooted at (i.e. file:///.../.bzr/)
86
a transport connected to the directory this bzr was opened from
87
(i.e. the parent directory holding the .bzr directory).
89
Everything in the bzrdir should have the same file permissions.
91
:cvar hooks: An instance of BzrDirHooks.
95
"""Invoke break_lock on the first object in the bzrdir.
97
If there is a tree, the tree is opened and break_lock() called.
98
Otherwise, branch is tried, and finally repository.
100
# XXX: This seems more like a UI function than something that really
101
# belongs in this class.
103
thing_to_unlock = self.open_workingtree()
104
except (errors.NotLocalUrl, errors.NoWorkingTree):
106
thing_to_unlock = self.open_branch()
107
except errors.NotBranchError:
109
thing_to_unlock = self.open_repository()
110
except errors.NoRepositoryPresent:
112
thing_to_unlock.break_lock()
114
def check_conversion_target(self, target_format):
115
"""Check that a bzrdir as a whole can be converted to a new format."""
116
# The only current restriction is that the repository content can be
117
# fetched compatibly with the target.
118
target_repo_format = target_format.repository_format
120
self.open_repository()._format.check_conversion_target(
122
except errors.NoRepositoryPresent:
123
# No repo, no problem.
126
def clone_on_transport(self, transport, revision_id=None,
127
force_new_repo=False, preserve_stacking=False, stacked_on=None,
128
create_prefix=False, use_existing_dir=True, no_tree=False):
129
"""Clone this bzrdir and its contents to transport verbatim.
131
:param transport: The transport for the location to produce the clone
132
at. If the target directory does not exist, it will be created.
133
:param revision_id: The tip revision-id to use for any branch or
134
working tree. If not None, then the clone operation may tune
135
itself to download less data.
136
:param force_new_repo: Do not use a shared repository for the target,
137
even if one is available.
138
:param preserve_stacking: When cloning a stacked branch, stack the
139
new branch on top of the other branch's stacked-on branch.
140
:param create_prefix: Create any missing directories leading up to
142
:param use_existing_dir: Use an existing directory if one exists.
143
:param no_tree: If set to true prevents creation of a working tree.
145
# Overview: put together a broad description of what we want to end up
146
# with; then make as few api calls as possible to do it.
148
# We may want to create a repo/branch/tree, if we do so what format
149
# would we want for each:
150
require_stacking = (stacked_on is not None)
151
format = self.cloning_metadir(require_stacking)
153
# Figure out what objects we want:
155
local_repo = self.find_repository()
156
except errors.NoRepositoryPresent:
159
local_branch = self.open_branch()
160
except errors.NotBranchError:
163
# enable fallbacks when branch is not a branch reference
164
if local_branch.repository.has_same_location(local_repo):
165
local_repo = local_branch.repository
166
if preserve_stacking:
168
stacked_on = local_branch.get_stacked_on_url()
169
except (errors.UnstackableBranchFormat,
170
errors.UnstackableRepositoryFormat,
173
# Bug: We create a metadir without knowing if it can support stacking,
174
# we should look up the policy needs first, or just use it as a hint,
177
make_working_trees = local_repo.make_working_trees() and not no_tree
178
want_shared = local_repo.is_shared()
179
repo_format_name = format.repository_format.network_name()
181
make_working_trees = False
183
repo_format_name = None
185
result_repo, result, require_stacking, repository_policy = \
186
format.initialize_on_transport_ex(transport,
187
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
188
force_new_repo=force_new_repo, stacked_on=stacked_on,
189
stack_on_pwd=self.root_transport.base,
190
repo_format_name=repo_format_name,
191
make_working_trees=make_working_trees, shared_repo=want_shared)
194
# If the result repository is in the same place as the
195
# resulting bzr dir, it will have no content, further if the
196
# result is not stacked then we know all content should be
197
# copied, and finally if we are copying up to a specific
198
# revision_id then we can use the pending-ancestry-result which
199
# does not require traversing all of history to describe it.
200
if (result_repo.user_url == result.user_url
201
and not require_stacking and
202
revision_id is not None):
203
fetch_spec = graph.PendingAncestryResult(
204
[revision_id], local_repo)
205
result_repo.fetch(local_repo, fetch_spec=fetch_spec)
207
result_repo.fetch(local_repo, revision_id=revision_id)
211
if result_repo is not None:
212
raise AssertionError('result_repo not None(%r)' % result_repo)
213
# 1 if there is a branch present
214
# make sure its content is available in the target repository
216
if local_branch is not None:
217
result_branch = local_branch.clone(result, revision_id=revision_id,
218
repository_policy=repository_policy)
220
# Cheaper to check if the target is not local, than to try making
222
result.root_transport.local_abspath('.')
223
if result_repo is None or result_repo.make_working_trees():
224
self.open_workingtree().clone(result)
225
except (errors.NoWorkingTree, errors.NotLocalUrl):
229
# TODO: This should be given a Transport, and should chdir up; otherwise
230
# this will open a new connection.
231
def _make_tail(self, url):
232
t = _mod_transport.get_transport(url)
236
def find_bzrdirs(transport, evaluate=None, list_current=None):
237
"""Find bzrdirs recursively from current location.
239
This is intended primarily as a building block for more sophisticated
240
functionality, like finding trees under a directory, or finding
241
branches that use a given repository.
243
:param evaluate: An optional callable that yields recurse, value,
244
where recurse controls whether this bzrdir is recursed into
245
and value is the value to yield. By default, all bzrdirs
246
are recursed into, and the return value is the bzrdir.
247
:param list_current: if supplied, use this function to list the current
248
directory, instead of Transport.list_dir
249
:return: a generator of found bzrdirs, or whatever evaluate returns.
251
if list_current is None:
252
def list_current(transport):
253
return transport.list_dir('')
255
def evaluate(bzrdir):
258
pending = [transport]
259
while len(pending) > 0:
260
current_transport = pending.pop()
263
bzrdir = BzrDir.open_from_transport(current_transport)
264
except (errors.NotBranchError, errors.PermissionDenied):
267
recurse, value = evaluate(bzrdir)
270
subdirs = list_current(current_transport)
271
except (errors.NoSuchFile, errors.PermissionDenied):
274
for subdir in sorted(subdirs, reverse=True):
275
pending.append(current_transport.clone(subdir))
278
def find_branches(transport):
279
"""Find all branches under a transport.
281
This will find all branches below the transport, including branches
282
inside other branches. Where possible, it will use
283
Repository.find_branches.
285
To list all the branches that use a particular Repository, see
286
Repository.find_branches
288
def evaluate(bzrdir):
290
repository = bzrdir.open_repository()
291
except errors.NoRepositoryPresent:
294
return False, ([], repository)
295
return True, (bzrdir.list_branches(), None)
297
for branches, repo in BzrDir.find_bzrdirs(transport,
300
ret.extend(repo.find_branches())
301
if branches is not None:
306
def create_branch_and_repo(base, force_new_repo=False, format=None):
307
"""Create a new BzrDir, Branch and Repository at the url 'base'.
309
This will use the current default BzrDirFormat unless one is
310
specified, and use whatever
311
repository format that that uses via bzrdir.create_branch and
312
create_repository. If a shared repository is available that is used
315
The created Branch object is returned.
317
:param base: The URL to create the branch at.
318
:param force_new_repo: If True a new repository is always created.
319
:param format: If supplied, the format of branch to create. If not
320
supplied, the default is used.
322
bzrdir = BzrDir.create(base, format)
323
bzrdir._find_or_create_repository(force_new_repo)
324
return bzrdir.create_branch()
326
def determine_repository_policy(self, force_new_repo=False, stack_on=None,
327
stack_on_pwd=None, require_stacking=False):
328
"""Return an object representing a policy to use.
330
This controls whether a new repository is created, and the format of
331
that repository, or some existing shared repository used instead.
333
If stack_on is supplied, will not seek a containing shared repo.
335
:param force_new_repo: If True, require a new repository to be created.
336
:param stack_on: If supplied, the location to stack on. If not
337
supplied, a default_stack_on location may be used.
338
:param stack_on_pwd: If stack_on is relative, the location it is
341
def repository_policy(found_bzrdir):
344
config = found_bzrdir.get_config()
346
stack_on = config.get_default_stack_on()
347
if stack_on is not None:
348
stack_on_pwd = found_bzrdir.user_url
350
# does it have a repository ?
352
repository = found_bzrdir.open_repository()
353
except errors.NoRepositoryPresent:
356
if (found_bzrdir.user_url != self.user_url
357
and not repository.is_shared()):
358
# Don't look higher, can't use a higher shared repo.
366
return UseExistingRepository(repository, stack_on,
367
stack_on_pwd, require_stacking=require_stacking), True
369
return CreateRepository(self, stack_on, stack_on_pwd,
370
require_stacking=require_stacking), True
372
if not force_new_repo:
374
policy = self._find_containing(repository_policy)
375
if policy is not None:
379
return UseExistingRepository(self.open_repository(),
380
stack_on, stack_on_pwd,
381
require_stacking=require_stacking)
382
except errors.NoRepositoryPresent:
384
return CreateRepository(self, stack_on, stack_on_pwd,
385
require_stacking=require_stacking)
387
def _find_or_create_repository(self, force_new_repo):
388
"""Create a new repository if needed, returning the repository."""
389
policy = self.determine_repository_policy(force_new_repo)
390
return policy.acquire_repository()[0]
392
def _find_source_repo(self, add_cleanup, source_branch):
393
"""Find the source branch and repo for a sprout operation.
395
This is helper intended for use by _sprout.
397
:returns: (source_branch, source_repository). Either or both may be
398
None. If not None, they will be read-locked (and their unlock(s)
399
scheduled via the add_cleanup param).
401
if source_branch is not None:
402
add_cleanup(source_branch.lock_read().unlock)
403
return source_branch, source_branch.repository
405
source_branch = self.open_branch()
406
source_repository = source_branch.repository
407
except errors.NotBranchError:
410
source_repository = self.open_repository()
411
except errors.NoRepositoryPresent:
412
source_repository = None
414
add_cleanup(source_repository.lock_read().unlock)
416
add_cleanup(source_branch.lock_read().unlock)
417
return source_branch, source_repository
419
def sprout(self, url, revision_id=None, force_new_repo=False,
420
recurse='down', possible_transports=None,
421
accelerator_tree=None, hardlink=False, stacked=False,
422
source_branch=None, create_tree_if_local=True):
423
"""Create a copy of this controldir prepared for use as a new line of
426
If url's last component does not exist, it will be created.
428
Attributes related to the identity of the source branch like
429
branch nickname will be cleaned, a working tree is created
430
whether one existed before or not; and a local branch is always
433
if revision_id is not None, then the clone operation may tune
434
itself to download less data.
436
:param accelerator_tree: A tree which can be used for retrieving file
437
contents more quickly than the revision tree, i.e. a workingtree.
438
The revision tree will be used for cases where accelerator_tree's
439
content is different.
440
:param hardlink: If true, hard-link files from accelerator_tree,
442
:param stacked: If true, create a stacked branch referring to the
443
location of this control directory.
444
:param create_tree_if_local: If true, a working-tree will be created
445
when working locally.
447
operation = cleanup.OperationWithCleanups(self._sprout)
448
return operation.run(url, revision_id=revision_id,
449
force_new_repo=force_new_repo, recurse=recurse,
450
possible_transports=possible_transports,
451
accelerator_tree=accelerator_tree, hardlink=hardlink,
452
stacked=stacked, source_branch=source_branch,
453
create_tree_if_local=create_tree_if_local)
455
def _sprout(self, op, url, revision_id=None, force_new_repo=False,
456
recurse='down', possible_transports=None,
457
accelerator_tree=None, hardlink=False, stacked=False,
458
source_branch=None, create_tree_if_local=True):
459
add_cleanup = op.add_cleanup
460
fetch_spec_factory = fetch.FetchSpecFactory()
461
if revision_id is not None:
462
fetch_spec_factory.add_revision_ids([revision_id])
463
fetch_spec_factory.source_branch_stop_revision_id = revision_id
464
target_transport = _mod_transport.get_transport(url,
466
target_transport.ensure_base()
467
cloning_format = self.cloning_metadir(stacked)
468
# Create/update the result branch
469
result = cloning_format.initialize_on_transport(target_transport)
470
source_branch, source_repository = self._find_source_repo(
471
add_cleanup, source_branch)
472
fetch_spec_factory.source_branch = source_branch
473
# if a stacked branch wasn't requested, we don't create one
474
# even if the origin was stacked
475
if stacked and source_branch is not None:
476
stacked_branch_url = self.root_transport.base
478
stacked_branch_url = None
479
repository_policy = result.determine_repository_policy(
480
force_new_repo, stacked_branch_url, require_stacking=stacked)
481
result_repo, is_new_repo = repository_policy.acquire_repository()
482
add_cleanup(result_repo.lock_write().unlock)
483
fetch_spec_factory.source_repo = source_repository
484
fetch_spec_factory.target_repo = result_repo
485
if stacked or (len(result_repo._fallback_repositories) != 0):
486
target_repo_kind = fetch.TargetRepoKinds.STACKED
488
target_repo_kind = fetch.TargetRepoKinds.EMPTY
490
target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
491
fetch_spec_factory.target_repo_kind = target_repo_kind
492
if source_repository is not None:
493
fetch_spec = fetch_spec_factory.make_fetch_spec()
494
result_repo.fetch(source_repository, fetch_spec=fetch_spec)
496
if source_branch is None:
497
# this is for sprouting a controldir without a branch; is that
499
# Not especially, but it's part of the contract.
500
result_branch = result.create_branch()
502
result_branch = source_branch.sprout(result,
503
revision_id=revision_id, repository_policy=repository_policy,
504
repository=result_repo)
505
mutter("created new branch %r" % (result_branch,))
507
# Create/update the result working tree
508
if (create_tree_if_local and
509
isinstance(target_transport, local.LocalTransport) and
510
(result_repo is None or result_repo.make_working_trees())):
511
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
512
hardlink=hardlink, from_branch=result_branch)
515
if wt.path2id('') is None:
517
wt.set_root_id(self.open_workingtree.get_root_id())
518
except errors.NoWorkingTree:
524
if recurse == 'down':
527
basis = wt.basis_tree()
528
elif result_branch is not None:
529
basis = result_branch.basis_tree()
530
elif source_branch is not None:
531
basis = source_branch.basis_tree()
532
if basis is not None:
533
add_cleanup(basis.lock_read().unlock)
534
subtrees = basis.iter_references()
537
for path, file_id in subtrees:
538
target = urlutils.join(url, urlutils.escape(path))
539
sublocation = source_branch.reference_parent(file_id, path)
540
sublocation.bzrdir.sprout(target,
541
basis.get_reference_revision(file_id, path),
542
force_new_repo=force_new_repo, recurse=recurse,
547
def create_branch_convenience(base, force_new_repo=False,
548
force_new_tree=None, format=None,
549
possible_transports=None):
550
"""Create a new BzrDir, Branch and Repository at the url 'base'.
552
This is a convenience function - it will use an existing repository
553
if possible, can be told explicitly whether to create a working tree or
556
This will use the current default BzrDirFormat unless one is
557
specified, and use whatever
558
repository format that that uses via bzrdir.create_branch and
559
create_repository. If a shared repository is available that is used
560
preferentially. Whatever repository is used, its tree creation policy
563
The created Branch object is returned.
564
If a working tree cannot be made due to base not being a file:// url,
565
no error is raised unless force_new_tree is True, in which case no
566
data is created on disk and NotLocalUrl is raised.
568
:param base: The URL to create the branch at.
569
:param force_new_repo: If True a new repository is always created.
570
:param force_new_tree: If True or False force creation of a tree or
571
prevent such creation respectively.
572
:param format: Override for the bzrdir format to create.
573
:param possible_transports: An optional reusable transports list.
576
# check for non local urls
577
t = _mod_transport.get_transport(base, possible_transports)
578
if not isinstance(t, local.LocalTransport):
579
raise errors.NotLocalUrl(base)
580
bzrdir = BzrDir.create(base, format, possible_transports)
581
repo = bzrdir._find_or_create_repository(force_new_repo)
582
result = bzrdir.create_branch()
583
if force_new_tree or (repo.make_working_trees() and
584
force_new_tree is None):
586
bzrdir.create_workingtree()
587
except errors.NotLocalUrl:
592
def create_standalone_workingtree(base, format=None):
593
"""Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
595
'base' must be a local path or a file:// url.
597
This will use the current default BzrDirFormat unless one is
598
specified, and use whatever
599
repository format that that uses for bzrdirformat.create_workingtree,
600
create_branch and create_repository.
602
:param format: Override for the bzrdir format to create.
603
:return: The WorkingTree object.
605
t = _mod_transport.get_transport(base)
606
if not isinstance(t, local.LocalTransport):
607
raise errors.NotLocalUrl(base)
608
bzrdir = BzrDir.create_branch_and_repo(base,
610
format=format).bzrdir
611
return bzrdir.create_workingtree()
613
@deprecated_method(deprecated_in((2, 3, 0)))
614
def generate_backup_name(self, base):
615
return self._available_backup_name(base)
617
def _available_backup_name(self, base):
618
"""Find a non-existing backup file name based on base.
620
See bzrlib.osutils.available_backup_name about race conditions.
622
return osutils.available_backup_name(base, self.root_transport.has)
624
def backup_bzrdir(self):
625
"""Backup this bzr control directory.
627
:return: Tuple with old path name and new path name
630
pb = ui.ui_factory.nested_progress_bar()
632
old_path = self.root_transport.abspath('.bzr')
633
backup_dir = self._available_backup_name('backup.bzr')
634
new_path = self.root_transport.abspath(backup_dir)
635
ui.ui_factory.note('making backup of %s\n to %s' % (
636
urlutils.unescape_for_display(old_path, 'utf-8'),
637
urlutils.unescape_for_display(new_path, 'utf-8')))
638
self.root_transport.copy_tree('.bzr', backup_dir)
639
return (old_path, new_path)
643
def retire_bzrdir(self, limit=10000):
644
"""Permanently disable the bzrdir.
646
This is done by renaming it to give the user some ability to recover
647
if there was a problem.
649
This will have horrible consequences if anyone has anything locked or
651
:param limit: number of times to retry
656
to_path = '.bzr.retired.%d' % i
657
self.root_transport.rename('.bzr', to_path)
658
note("renamed %s to %s"
659
% (self.root_transport.abspath('.bzr'), to_path))
661
except (errors.TransportError, IOError, errors.PathError):
668
def _find_containing(self, evaluate):
669
"""Find something in a containing control directory.
671
This method will scan containing control dirs, until it finds what
672
it is looking for, decides that it will never find it, or runs out
673
of containing control directories to check.
675
It is used to implement find_repository and
676
determine_repository_policy.
678
:param evaluate: A function returning (value, stop). If stop is True,
679
the value will be returned.
683
result, stop = evaluate(found_bzrdir)
686
next_transport = found_bzrdir.root_transport.clone('..')
687
if (found_bzrdir.user_url == next_transport.base):
688
# top of the file system
690
# find the next containing bzrdir
692
found_bzrdir = BzrDir.open_containing_from_transport(
694
except errors.NotBranchError:
697
def find_repository(self):
698
"""Find the repository that should be used.
700
This does not require a branch as we use it to find the repo for
701
new branches as well as to hook existing branches up to their
704
def usable_repository(found_bzrdir):
705
# does it have a repository ?
707
repository = found_bzrdir.open_repository()
708
except errors.NoRepositoryPresent:
710
if found_bzrdir.user_url == self.user_url:
711
return repository, True
712
elif repository.is_shared():
713
return repository, True
717
found_repo = self._find_containing(usable_repository)
718
if found_repo is None:
719
raise errors.NoRepositoryPresent(self)
722
def _find_creation_modes(self):
723
"""Determine the appropriate modes for files and directories.
725
They're always set to be consistent with the base directory,
726
assuming that this transport allows setting modes.
728
# TODO: Do we need or want an option (maybe a config setting) to turn
729
# this off or override it for particular locations? -- mbp 20080512
730
if self._mode_check_done:
732
self._mode_check_done = True
734
st = self.transport.stat('.')
735
except errors.TransportNotPossible:
736
self._dir_mode = None
737
self._file_mode = None
739
# Check the directory mode, but also make sure the created
740
# directories and files are read-write for this user. This is
741
# mostly a workaround for filesystems which lie about being able to
742
# write to a directory (cygwin & win32)
743
if (st.st_mode & 07777 == 00000):
744
# FTP allows stat but does not return dir/file modes
745
self._dir_mode = None
746
self._file_mode = None
748
self._dir_mode = (st.st_mode & 07777) | 00700
749
# Remove the sticky and execute bits for files
750
self._file_mode = self._dir_mode & ~07111
752
def _get_file_mode(self):
753
"""Return Unix mode for newly created files, or None.
755
if not self._mode_check_done:
756
self._find_creation_modes()
757
return self._file_mode
759
def _get_dir_mode(self):
760
"""Return Unix mode for newly created directories, or None.
762
if not self._mode_check_done:
763
self._find_creation_modes()
764
return self._dir_mode
766
def get_config(self):
767
"""Get configuration for this BzrDir."""
768
return config.BzrDirConfig(self)
770
def _get_config(self):
771
"""By default, no configuration is available."""
774
def __init__(self, _transport, _format):
775
"""Initialize a Bzr control dir object.
777
Only really common logic should reside here, concrete classes should be
778
made with varying behaviours.
780
:param _format: the format that is creating this BzrDir instance.
781
:param _transport: the transport this dir is based at.
783
self._format = _format
784
# these are also under the more standard names of
785
# control_transport and user_transport
786
self.transport = _transport.clone('.bzr')
787
self.root_transport = _transport
788
self._mode_check_done = False
791
def user_transport(self):
792
return self.root_transport
795
def control_transport(self):
796
return self.transport
798
def is_control_filename(self, filename):
799
"""True if filename is the name of a path which is reserved for bzrdir's.
801
:param filename: A filename within the root transport of this bzrdir.
803
This is true IF and ONLY IF the filename is part of the namespace reserved
804
for bzr control dirs. Currently this is the '.bzr' directory in the root
805
of the root_transport.
807
# this might be better on the BzrDirFormat class because it refers to
808
# all the possible bzrdir disk formats.
809
# This method is tested via the workingtree is_control_filename tests-
810
# it was extracted from WorkingTree.is_control_filename. If the method's
811
# contract is extended beyond the current trivial implementation, please
812
# add new tests for it to the appropriate place.
813
return filename == '.bzr' or filename.startswith('.bzr/')
816
def open_unsupported(base):
817
"""Open a branch which is not supported."""
818
return BzrDir.open(base, _unsupported=True)
821
def open(base, _unsupported=False, possible_transports=None):
822
"""Open an existing bzrdir, rooted at 'base' (url).
824
:param _unsupported: a private parameter to the BzrDir class.
826
t = _mod_transport.get_transport(base, possible_transports)
827
return BzrDir.open_from_transport(t, _unsupported=_unsupported)
830
def open_from_transport(transport, _unsupported=False,
831
_server_formats=True):
832
"""Open a bzrdir within a particular directory.
834
:param transport: Transport containing the bzrdir.
835
:param _unsupported: private.
837
for hook in BzrDir.hooks['pre_open']:
839
# Keep initial base since 'transport' may be modified while following
841
base = transport.base
842
def find_format(transport):
843
return transport, controldir.ControlDirFormat.find_format(
844
transport, _server_formats=_server_formats)
846
def redirected(transport, e, redirection_notice):
847
redirected_transport = transport._redirected_to(e.source, e.target)
848
if redirected_transport is None:
849
raise errors.NotBranchError(base)
850
note('%s is%s redirected to %s',
851
transport.base, e.permanently, redirected_transport.base)
852
return redirected_transport
855
transport, format = do_catching_redirections(find_format,
858
except errors.TooManyRedirections:
859
raise errors.NotBranchError(base)
861
format.check_support_status(_unsupported)
862
return format.open(transport, _found=True)
865
def open_containing(url, possible_transports=None):
866
"""Open an existing branch which contains url.
868
:param url: url to search from.
870
See open_containing_from_transport for more detail.
872
transport = _mod_transport.get_transport(url, possible_transports)
873
return BzrDir.open_containing_from_transport(transport)
876
def open_containing_from_transport(a_transport):
877
"""Open an existing branch which contains a_transport.base.
879
This probes for a branch at a_transport, and searches upwards from there.
881
Basically we keep looking up until we find the control directory or
882
run into the root. If there isn't one, raises NotBranchError.
883
If there is one and it is either an unrecognised format or an unsupported
884
format, UnknownFormatError or UnsupportedFormatError are raised.
885
If there is one, it is returned, along with the unused portion of url.
887
:return: The BzrDir that contains the path, and a Unicode path
888
for the rest of the URL.
890
# this gets the normalised url back. I.e. '.' -> the full path.
891
url = a_transport.base
894
result = BzrDir.open_from_transport(a_transport)
895
return result, urlutils.unescape(a_transport.relpath(url))
896
except errors.NotBranchError, e:
899
new_t = a_transport.clone('..')
900
except errors.InvalidURLJoin:
901
# reached the root, whatever that may be
902
raise errors.NotBranchError(path=url)
903
if new_t.base == a_transport.base:
904
# reached the root, whatever that may be
905
raise errors.NotBranchError(path=url)
909
def open_tree_or_branch(klass, location):
910
"""Return the branch and working tree at a location.
912
If there is no tree at the location, tree will be None.
913
If there is no branch at the location, an exception will be
915
:return: (tree, branch)
917
bzrdir = klass.open(location)
918
return bzrdir._get_tree_branch()
921
def open_containing_tree_or_branch(klass, location):
922
"""Return the branch and working tree contained by a location.
924
Returns (tree, branch, relpath).
925
If there is no tree at containing the location, tree will be None.
926
If there is no branch containing the location, an exception will be
928
relpath is the portion of the path that is contained by the branch.
930
bzrdir, relpath = klass.open_containing(location)
931
tree, branch = bzrdir._get_tree_branch()
932
return tree, branch, relpath
935
def open_containing_tree_branch_or_repository(klass, location):
936
"""Return the working tree, branch and repo contained by a location.
938
Returns (tree, branch, repository, relpath).
939
If there is no tree containing the location, tree will be None.
940
If there is no branch containing the location, branch will be None.
941
If there is no repository containing the location, repository will be
943
relpath is the portion of the path that is contained by the innermost
946
If no tree, branch or repository is found, a NotBranchError is raised.
948
bzrdir, relpath = klass.open_containing(location)
950
tree, branch = bzrdir._get_tree_branch()
951
except errors.NotBranchError:
953
repo = bzrdir.find_repository()
954
return None, None, repo, relpath
955
except (errors.NoRepositoryPresent):
956
raise errors.NotBranchError(location)
957
return tree, branch, branch.repository, relpath
959
def _cloning_metadir(self):
960
"""Produce a metadir suitable for cloning with.
962
:returns: (destination_bzrdir_format, source_repository)
964
result_format = self._format.__class__()
967
branch = self.open_branch(ignore_fallbacks=True)
968
source_repository = branch.repository
969
result_format._branch_format = branch._format
970
except errors.NotBranchError:
972
source_repository = self.open_repository()
973
except errors.NoRepositoryPresent:
974
source_repository = None
976
# XXX TODO: This isinstance is here because we have not implemented
977
# the fix recommended in bug # 103195 - to delegate this choice the
979
repo_format = source_repository._format
980
if isinstance(repo_format, remote.RemoteRepositoryFormat):
981
source_repository._ensure_real()
982
repo_format = source_repository._real_repository._format
983
result_format.repository_format = repo_format
985
# TODO: Couldn't we just probe for the format in these cases,
986
# rather than opening the whole tree? It would be a little
987
# faster. mbp 20070401
988
tree = self.open_workingtree(recommend_upgrade=False)
989
except (errors.NoWorkingTree, errors.NotLocalUrl):
990
result_format.workingtree_format = None
992
result_format.workingtree_format = tree._format.__class__()
993
return result_format, source_repository
995
def cloning_metadir(self, require_stacking=False):
996
"""Produce a metadir suitable for cloning or sprouting with.
998
These operations may produce workingtrees (yes, even though they're
999
"cloning" something that doesn't have a tree), so a viable workingtree
1000
format must be selected.
1002
:require_stacking: If True, non-stackable formats will be upgraded
1003
to similar stackable formats.
1004
:returns: a BzrDirFormat with all component formats either set
1005
appropriately or set to None if that component should not be
1008
format, repository = self._cloning_metadir()
1009
if format._workingtree_format is None:
1011
if repository is None:
1012
# No repository either
1014
# We have a repository, so set a working tree? (Why? This seems to
1015
# contradict the stated return value in the docstring).
1016
tree_format = repository._format._matchingbzrdir.workingtree_format
1017
format.workingtree_format = tree_format.__class__()
1018
if require_stacking:
1019
format.require_stacking()
1023
def create(cls, base, format=None, possible_transports=None):
1024
"""Create a new BzrDir at the url 'base'.
1026
:param format: If supplied, the format of branch to create. If not
1027
supplied, the default is used.
1028
:param possible_transports: If supplied, a list of transports that
1029
can be reused to share a remote connection.
1031
if cls is not BzrDir:
1032
raise AssertionError("BzrDir.create always creates the"
1033
"default format, not one of %r" % cls)
1034
t = _mod_transport.get_transport(base, possible_transports)
1037
format = controldir.ControlDirFormat.get_default_format()
1038
return format.initialize_on_transport(t)
1040
def get_branch_transport(self, branch_format, name=None):
1041
"""Get the transport for use by branch format in this BzrDir.
1043
Note that bzr dirs that do not support format strings will raise
1044
IncompatibleFormat if the branch format they are given has
1045
a format string, and vice versa.
1047
If branch_format is None, the transport is returned with no
1048
checking. If it is not None, then the returned transport is
1049
guaranteed to point to an existing directory ready for use.
1051
raise NotImplementedError(self.get_branch_transport)
1053
def get_repository_transport(self, repository_format):
1054
"""Get the transport for use by repository format in this BzrDir.
1056
Note that bzr dirs that do not support format strings will raise
1057
IncompatibleFormat if the repository format they are given has
1058
a format string, and vice versa.
1060
If repository_format is None, the transport is returned with no
1061
checking. If it is not None, then the returned transport is
1062
guaranteed to point to an existing directory ready for use.
1064
raise NotImplementedError(self.get_repository_transport)
1066
def get_workingtree_transport(self, tree_format):
1067
"""Get the transport for use by workingtree format in this BzrDir.
1069
Note that bzr dirs that do not support format strings will raise
1070
IncompatibleFormat if the workingtree format they are given has a
1071
format string, and vice versa.
1073
If workingtree_format is None, the transport is returned with no
1074
checking. If it is not None, then the returned transport is
1075
guaranteed to point to an existing directory ready for use.
1077
raise NotImplementedError(self.get_workingtree_transport)
1080
class BzrDirHooks(hooks.Hooks):
1081
"""Hooks for BzrDir operations."""
1084
"""Create the default hooks."""
1085
hooks.Hooks.__init__(self, "bzrlib.bzrdir", "BzrDir.hooks")
1086
self.add_hook('pre_open',
1087
"Invoked before attempting to open a BzrDir with the transport "
1088
"that the open will use.", (1, 14))
1089
self.add_hook('post_repo_init',
1090
"Invoked after a repository has been initialized. "
1091
"post_repo_init is called with a "
1092
"bzrlib.bzrdir.RepoInitHookParams.",
1095
# install the default hooks
1096
BzrDir.hooks = BzrDirHooks()
1099
class RepoInitHookParams(object):
1100
"""Object holding parameters passed to `*_repo_init` hooks.
1102
There are 4 fields that hooks may wish to access:
1104
:ivar repository: Repository created
1105
:ivar format: Repository format
1106
:ivar bzrdir: The bzrdir for the repository
1107
:ivar shared: The repository is shared
1110
def __init__(self, repository, format, a_bzrdir, shared):
1111
"""Create a group of RepoInitHook parameters.
1113
:param repository: Repository created
1114
:param format: Repository format
1115
:param bzrdir: The bzrdir for the repository
1116
:param shared: The repository is shared
1118
self.repository = repository
1119
self.format = format
1120
self.bzrdir = a_bzrdir
1121
self.shared = shared
1123
def __eq__(self, other):
1124
return self.__dict__ == other.__dict__
1128
return "<%s for %s>" % (self.__class__.__name__,
1131
return "<%s for %s>" % (self.__class__.__name__,
1135
class BzrDirMeta1(BzrDir):
1136
"""A .bzr meta version 1 control object.
1138
This is the first control object where the
1139
individual aspects are really split out: there are separate repository,
1140
workingtree and branch subdirectories and any subset of the three can be
1141
present within a BzrDir.
1144
def can_convert_format(self):
1145
"""See BzrDir.can_convert_format()."""
1148
def create_branch(self, name=None, repository=None,
1149
append_revisions_only=None):
1150
"""See BzrDir.create_branch."""
1151
return self._format.get_branch_format().initialize(self, name=name,
1152
repository=repository,
1153
append_revisions_only=append_revisions_only)
1155
def destroy_branch(self, name=None):
1156
"""See BzrDir.create_branch."""
1157
if name is not None:
1158
raise errors.NoColocatedBranchSupport(self)
1159
self.transport.delete_tree('branch')
1161
def create_repository(self, shared=False):
1162
"""See BzrDir.create_repository."""
1163
return self._format.repository_format.initialize(self, shared)
1165
def destroy_repository(self):
1166
"""See BzrDir.destroy_repository."""
1167
self.transport.delete_tree('repository')
1169
def create_workingtree(self, revision_id=None, from_branch=None,
1170
accelerator_tree=None, hardlink=False):
1171
"""See BzrDir.create_workingtree."""
1172
return self._format.workingtree_format.initialize(
1173
self, revision_id, from_branch=from_branch,
1174
accelerator_tree=accelerator_tree, hardlink=hardlink)
1176
def destroy_workingtree(self):
1177
"""See BzrDir.destroy_workingtree."""
1178
wt = self.open_workingtree(recommend_upgrade=False)
1179
repository = wt.branch.repository
1180
empty = repository.revision_tree(_mod_revision.NULL_REVISION)
1181
# We ignore the conflicts returned by wt.revert since we're about to
1182
# delete the wt metadata anyway, all that should be left here are
1183
# detritus. But see bug #634470 about subtree .bzr dirs.
1184
conflicts = wt.revert(old_tree=empty)
1185
self.destroy_workingtree_metadata()
1187
def destroy_workingtree_metadata(self):
1188
self.transport.delete_tree('checkout')
1190
def find_branch_format(self, name=None):
1191
"""Find the branch 'format' for this bzrdir.
1193
This might be a synthetic object for e.g. RemoteBranch and SVN.
1195
from bzrlib.branch import BranchFormat
1196
return BranchFormat.find_format(self, name=name)
1198
def _get_mkdir_mode(self):
1199
"""Figure out the mode to use when creating a bzrdir subdir."""
1200
temp_control = lockable_files.LockableFiles(self.transport, '',
1201
lockable_files.TransportLock)
1202
return temp_control._dir_mode
1204
def get_branch_reference(self, name=None):
1205
"""See BzrDir.get_branch_reference()."""
1206
from bzrlib.branch import BranchFormat
1207
format = BranchFormat.find_format(self, name=name)
1208
return format.get_reference(self, name=name)
1210
def get_branch_transport(self, branch_format, name=None):
1211
"""See BzrDir.get_branch_transport()."""
1212
if name is not None:
1213
raise errors.NoColocatedBranchSupport(self)
1214
# XXX: this shouldn't implicitly create the directory if it's just
1215
# promising to get a transport -- mbp 20090727
1216
if branch_format is None:
1217
return self.transport.clone('branch')
1219
branch_format.get_format_string()
1220
except NotImplementedError:
1221
raise errors.IncompatibleFormat(branch_format, self._format)
1223
self.transport.mkdir('branch', mode=self._get_mkdir_mode())
1224
except errors.FileExists:
1226
return self.transport.clone('branch')
1228
def get_repository_transport(self, repository_format):
1229
"""See BzrDir.get_repository_transport()."""
1230
if repository_format is None:
1231
return self.transport.clone('repository')
1233
repository_format.get_format_string()
1234
except NotImplementedError:
1235
raise errors.IncompatibleFormat(repository_format, self._format)
1237
self.transport.mkdir('repository', mode=self._get_mkdir_mode())
1238
except errors.FileExists:
1240
return self.transport.clone('repository')
1242
def get_workingtree_transport(self, workingtree_format):
1243
"""See BzrDir.get_workingtree_transport()."""
1244
if workingtree_format is None:
1245
return self.transport.clone('checkout')
1247
workingtree_format.get_format_string()
1248
except NotImplementedError:
1249
raise errors.IncompatibleFormat(workingtree_format, self._format)
1251
self.transport.mkdir('checkout', mode=self._get_mkdir_mode())
1252
except errors.FileExists:
1254
return self.transport.clone('checkout')
1256
def has_workingtree(self):
1257
"""Tell if this bzrdir contains a working tree.
1259
Note: if you're going to open the working tree, you should just go
1260
ahead and try, and not ask permission first.
1262
from bzrlib.workingtree import WorkingTreeFormat
1264
WorkingTreeFormat.find_format_string(self)
1265
except errors.NoWorkingTree:
1269
def needs_format_conversion(self, format):
1270
"""See BzrDir.needs_format_conversion()."""
1271
if not isinstance(self._format, format.__class__):
1272
# it is not a meta dir format, conversion is needed.
1274
# we might want to push this down to the repository?
1276
if not isinstance(self.open_repository()._format,
1277
format.repository_format.__class__):
1278
# the repository needs an upgrade.
1280
except errors.NoRepositoryPresent:
1282
for branch in self.list_branches():
1283
if not isinstance(branch._format,
1284
format.get_branch_format().__class__):
1285
# the branch needs an upgrade.
1288
my_wt = self.open_workingtree(recommend_upgrade=False)
1289
if not isinstance(my_wt._format,
1290
format.workingtree_format.__class__):
1291
# the workingtree needs an upgrade.
1293
except (errors.NoWorkingTree, errors.NotLocalUrl):
1297
def open_branch(self, name=None, unsupported=False,
1298
ignore_fallbacks=False):
1299
"""See BzrDir.open_branch."""
1300
format = self.find_branch_format(name=name)
1301
format.check_support_status(unsupported)
1302
return format.open(self, name=name,
1303
_found=True, ignore_fallbacks=ignore_fallbacks)
1305
def open_repository(self, unsupported=False):
1306
"""See BzrDir.open_repository."""
1307
from bzrlib.repository import RepositoryFormat
1308
format = RepositoryFormat.find_format(self)
1309
format.check_support_status(unsupported)
1310
return format.open(self, _found=True)
1312
def open_workingtree(self, unsupported=False,
1313
recommend_upgrade=True):
1314
"""See BzrDir.open_workingtree."""
1315
from bzrlib.workingtree import WorkingTreeFormat
1316
format = WorkingTreeFormat.find_format(self)
1317
format.check_support_status(unsupported, recommend_upgrade,
1318
basedir=self.root_transport.base)
1319
return format.open(self, _found=True)
1321
def _get_config(self):
1322
return config.TransportConfig(self.transport, 'control.conf')
1325
class BzrProber(controldir.Prober):
1326
"""Prober for formats that use a .bzr/ control directory."""
1328
formats = registry.FormatRegistry(controldir.network_format_registry)
1329
"""The known .bzr formats."""
1332
@deprecated_method(deprecated_in((2, 4, 0)))
1333
def register_bzrdir_format(klass, format):
1334
klass.formats.register(format.get_format_string(), format)
1337
@deprecated_method(deprecated_in((2, 4, 0)))
1338
def unregister_bzrdir_format(klass, format):
1339
klass.formats.remove(format.get_format_string())
1342
def probe_transport(klass, transport):
1343
"""Return the .bzrdir style format present in a directory."""
1345
format_string = transport.get_bytes(".bzr/branch-format")
1346
except errors.NoSuchFile:
1347
raise errors.NotBranchError(path=transport.base)
1349
return klass.formats.get(format_string)
1351
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1354
def known_formats(cls):
1356
for name, format in cls.formats.iteritems():
1357
if callable(format):
1363
controldir.ControlDirFormat.register_prober(BzrProber)
1366
class RemoteBzrProber(controldir.Prober):
1367
"""Prober for remote servers that provide a Bazaar smart server."""
1370
def probe_transport(klass, transport):
1371
"""Return a RemoteBzrDirFormat object if it looks possible."""
1373
medium = transport.get_smart_medium()
1374
except (NotImplementedError, AttributeError,
1375
errors.TransportNotPossible, errors.NoSmartMedium,
1376
errors.SmartProtocolError):
1377
# no smart server, so not a branch for this format type.
1378
raise errors.NotBranchError(path=transport.base)
1380
# Decline to open it if the server doesn't support our required
1381
# version (3) so that the VFS-based transport will do it.
1382
if medium.should_probe():
1384
server_version = medium.protocol_version()
1385
except errors.SmartProtocolError:
1386
# Apparently there's no usable smart server there, even though
1387
# the medium supports the smart protocol.
1388
raise errors.NotBranchError(path=transport.base)
1389
if server_version != '2':
1390
raise errors.NotBranchError(path=transport.base)
1391
from bzrlib.remote import RemoteBzrDirFormat
1392
return RemoteBzrDirFormat()
1395
def known_formats(cls):
1396
from bzrlib.remote import RemoteBzrDirFormat
1397
return set([RemoteBzrDirFormat()])
1400
class BzrDirFormat(controldir.ControlDirFormat):
1401
"""ControlDirFormat base class for .bzr/ directories.
1403
Formats are placed in a dict by their format string for reference
1404
during bzrdir opening. These should be subclasses of BzrDirFormat
1407
Once a format is deprecated, just deprecate the initialize and open
1408
methods on the format class. Do not deprecate the object, as the
1409
object will be created every system load.
1412
_lock_file_name = 'branch-lock'
1414
# _lock_class must be set in subclasses to the lock type, typ.
1415
# TransportLock or LockDir
1418
def get_format_string(cls):
1419
"""Return the ASCII format string that identifies this format."""
1420
raise NotImplementedError(cls.get_format_string)
1422
def initialize_on_transport(self, transport):
1423
"""Initialize a new bzrdir in the base directory of a Transport."""
1425
# can we hand off the request to the smart server rather than using
1427
client_medium = transport.get_smart_medium()
1428
except errors.NoSmartMedium:
1429
return self._initialize_on_transport_vfs(transport)
1431
# Current RPC's only know how to create bzr metadir1 instances, so
1432
# we still delegate to vfs methods if the requested format is not a
1434
if type(self) != BzrDirMetaFormat1:
1435
return self._initialize_on_transport_vfs(transport)
1436
from bzrlib.remote import RemoteBzrDirFormat
1437
remote_format = RemoteBzrDirFormat()
1438
self._supply_sub_formats_to(remote_format)
1439
return remote_format.initialize_on_transport(transport)
1441
def initialize_on_transport_ex(self, transport, use_existing_dir=False,
1442
create_prefix=False, force_new_repo=False, stacked_on=None,
1443
stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
1444
shared_repo=False, vfs_only=False):
1445
"""Create this format on transport.
1447
The directory to initialize will be created.
1449
:param force_new_repo: Do not use a shared repository for the target,
1450
even if one is available.
1451
:param create_prefix: Create any missing directories leading up to
1453
:param use_existing_dir: Use an existing directory if one exists.
1454
:param stacked_on: A url to stack any created branch on, None to follow
1455
any target stacking policy.
1456
:param stack_on_pwd: If stack_on is relative, the location it is
1458
:param repo_format_name: If non-None, a repository will be
1459
made-or-found. Should none be found, or if force_new_repo is True
1460
the repo_format_name is used to select the format of repository to
1462
:param make_working_trees: Control the setting of make_working_trees
1463
for a new shared repository when one is made. None to use whatever
1464
default the format has.
1465
:param shared_repo: Control whether made repositories are shared or
1467
:param vfs_only: If True do not attempt to use a smart server
1468
:return: repo, bzrdir, require_stacking, repository_policy. repo is
1469
None if none was created or found, bzrdir is always valid.
1470
require_stacking is the result of examining the stacked_on
1471
parameter and any stacking policy found for the target.
1474
# Try to hand off to a smart server
1476
client_medium = transport.get_smart_medium()
1477
except errors.NoSmartMedium:
1480
from bzrlib.remote import RemoteBzrDirFormat
1481
# TODO: lookup the local format from a server hint.
1482
remote_dir_format = RemoteBzrDirFormat()
1483
remote_dir_format._network_name = self.network_name()
1484
self._supply_sub_formats_to(remote_dir_format)
1485
return remote_dir_format.initialize_on_transport_ex(transport,
1486
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
1487
force_new_repo=force_new_repo, stacked_on=stacked_on,
1488
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
1489
make_working_trees=make_working_trees, shared_repo=shared_repo)
1490
# XXX: Refactor the create_prefix/no_create_prefix code into a
1491
# common helper function
1492
# The destination may not exist - if so make it according to policy.
1493
def make_directory(transport):
1494
transport.mkdir('.')
1496
def redirected(transport, e, redirection_notice):
1497
note(redirection_notice)
1498
return transport._redirected_to(e.source, e.target)
1500
transport = do_catching_redirections(make_directory, transport,
1502
except errors.FileExists:
1503
if not use_existing_dir:
1505
except errors.NoSuchFile:
1506
if not create_prefix:
1508
transport.create_prefix()
1510
require_stacking = (stacked_on is not None)
1511
# Now the target directory exists, but doesn't have a .bzr
1512
# directory. So we need to create it, along with any work to create
1513
# all of the dependent branches, etc.
1515
result = self.initialize_on_transport(transport)
1516
if repo_format_name:
1518
# use a custom format
1519
result._format.repository_format = \
1520
repository.network_format_registry.get(repo_format_name)
1521
except AttributeError:
1522
# The format didn't permit it to be set.
1524
# A repository is desired, either in-place or shared.
1525
repository_policy = result.determine_repository_policy(
1526
force_new_repo, stacked_on, stack_on_pwd,
1527
require_stacking=require_stacking)
1528
result_repo, is_new_repo = repository_policy.acquire_repository(
1529
make_working_trees, shared_repo)
1530
if not require_stacking and repository_policy._require_stacking:
1531
require_stacking = True
1532
result._format.require_stacking()
1533
result_repo.lock_write()
1536
repository_policy = None
1537
return result_repo, result, require_stacking, repository_policy
1539
def _initialize_on_transport_vfs(self, transport):
1540
"""Initialize a new bzrdir using VFS calls.
1542
:param transport: The transport to create the .bzr directory in.
1545
# Since we are creating a .bzr directory, inherit the
1546
# mode from the root directory
1547
temp_control = lockable_files.LockableFiles(transport,
1548
'', lockable_files.TransportLock)
1549
temp_control._transport.mkdir('.bzr',
1550
# FIXME: RBC 20060121 don't peek under
1552
mode=temp_control._dir_mode)
1553
if sys.platform == 'win32' and isinstance(transport, local.LocalTransport):
1554
win32utils.set_file_attr_hidden(transport._abspath('.bzr'))
1555
file_mode = temp_control._file_mode
1557
bzrdir_transport = transport.clone('.bzr')
1558
utf8_files = [('README',
1559
"This is a Bazaar control directory.\n"
1560
"Do not change any files in this directory.\n"
1561
"See http://bazaar.canonical.com/ for more information about Bazaar.\n"),
1562
('branch-format', self.get_format_string()),
1564
# NB: no need to escape relative paths that are url safe.
1565
control_files = lockable_files.LockableFiles(bzrdir_transport,
1566
self._lock_file_name, self._lock_class)
1567
control_files.create_lock()
1568
control_files.lock_write()
1570
for (filename, content) in utf8_files:
1571
bzrdir_transport.put_bytes(filename, content,
1574
control_files.unlock()
1575
return self.open(transport, _found=True)
1577
def open(self, transport, _found=False):
1578
"""Return an instance of this format for the dir transport points at.
1580
_found is a private parameter, do not use it.
1583
found_format = controldir.ControlDirFormat.find_format(transport)
1584
if not isinstance(found_format, self.__class__):
1585
raise AssertionError("%s was asked to open %s, but it seems to need "
1587
% (self, transport, found_format))
1588
# Allow subclasses - use the found format.
1589
self._supply_sub_formats_to(found_format)
1590
return found_format._open(transport)
1591
return self._open(transport)
1593
def _open(self, transport):
1594
"""Template method helper for opening BzrDirectories.
1596
This performs the actual open and any additional logic or parameter
1599
raise NotImplementedError(self._open)
1601
def _supply_sub_formats_to(self, other_format):
1602
"""Give other_format the same values for sub formats as this has.
1604
This method is expected to be used when parameterising a
1605
RemoteBzrDirFormat instance with the parameters from a
1606
BzrDirMetaFormat1 instance.
1608
:param other_format: other_format is a format which should be
1609
compatible with whatever sub formats are supported by self.
1614
class BzrDirMetaFormat1(BzrDirFormat):
1615
"""Bzr meta control format 1
1617
This is the first format with split out working tree, branch and repository
1622
- Format 3 working trees [optional]
1623
- Format 5 branches [optional]
1624
- Format 7 repositories [optional]
1627
_lock_class = lockdir.LockDir
1629
fixed_components = False
1632
self._workingtree_format = None
1633
self._branch_format = None
1634
self._repository_format = None
1636
def __eq__(self, other):
1637
if other.__class__ is not self.__class__:
1639
if other.repository_format != self.repository_format:
1641
if other.workingtree_format != self.workingtree_format:
1645
def __ne__(self, other):
1646
return not self == other
1648
def get_branch_format(self):
1649
if self._branch_format is None:
1650
from bzrlib.branch import format_registry as branch_format_registry
1651
self._branch_format = branch_format_registry.get_default()
1652
return self._branch_format
1654
def set_branch_format(self, format):
1655
self._branch_format = format
1657
def require_stacking(self, stack_on=None, possible_transports=None,
1659
"""We have a request to stack, try to ensure the formats support it.
1661
:param stack_on: If supplied, it is the URL to a branch that we want to
1662
stack on. Check to see if that format supports stacking before
1665
# Stacking is desired. requested by the target, but does the place it
1666
# points at support stacking? If it doesn't then we should
1667
# not implicitly upgrade. We check this here.
1668
new_repo_format = None
1669
new_branch_format = None
1671
# a bit of state for get_target_branch so that we don't try to open it
1672
# 2 times, for both repo *and* branch
1673
target = [None, False, None] # target_branch, checked, upgrade anyway
1674
def get_target_branch():
1676
# We've checked, don't check again
1678
if stack_on is None:
1679
# No target format, that means we want to force upgrading
1680
target[:] = [None, True, True]
1683
target_dir = BzrDir.open(stack_on,
1684
possible_transports=possible_transports)
1685
except errors.NotBranchError:
1686
# Nothing there, don't change formats
1687
target[:] = [None, True, False]
1689
except errors.JailBreak:
1690
# JailBreak, JFDI and upgrade anyway
1691
target[:] = [None, True, True]
1694
target_branch = target_dir.open_branch()
1695
except errors.NotBranchError:
1696
# No branch, don't upgrade formats
1697
target[:] = [None, True, False]
1699
target[:] = [target_branch, True, False]
1702
if (not _skip_repo and
1703
not self.repository_format.supports_external_lookups):
1704
# We need to upgrade the Repository.
1705
target_branch, _, do_upgrade = get_target_branch()
1706
if target_branch is None:
1707
# We don't have a target branch, should we upgrade anyway?
1709
# stack_on is inaccessible, JFDI.
1710
# TODO: bad monkey, hard-coded formats...
1711
if self.repository_format.rich_root_data:
1712
new_repo_format = knitpack_repo.RepositoryFormatKnitPack5RichRoot()
1714
new_repo_format = knitpack_repo.RepositoryFormatKnitPack5()
1716
# If the target already supports stacking, then we know the
1717
# project is already able to use stacking, so auto-upgrade
1719
new_repo_format = target_branch.repository._format
1720
if not new_repo_format.supports_external_lookups:
1721
# target doesn't, source doesn't, so don't auto upgrade
1723
new_repo_format = None
1724
if new_repo_format is not None:
1725
self.repository_format = new_repo_format
1726
note('Source repository format does not support stacking,'
1727
' using format:\n %s',
1728
new_repo_format.get_format_description())
1730
if not self.get_branch_format().supports_stacking():
1731
# We just checked the repo, now lets check if we need to
1732
# upgrade the branch format
1733
target_branch, _, do_upgrade = get_target_branch()
1734
if target_branch is None:
1736
# TODO: bad monkey, hard-coded formats...
1737
from bzrlib.branch import BzrBranchFormat7
1738
new_branch_format = BzrBranchFormat7()
1740
new_branch_format = target_branch._format
1741
if not new_branch_format.supports_stacking():
1742
new_branch_format = None
1743
if new_branch_format is not None:
1744
# Does support stacking, use its format.
1745
self.set_branch_format(new_branch_format)
1746
note('Source branch format does not support stacking,'
1747
' using format:\n %s',
1748
new_branch_format.get_format_description())
1750
def get_converter(self, format=None):
1751
"""See BzrDirFormat.get_converter()."""
1753
format = BzrDirFormat.get_default_format()
1754
if not isinstance(self, format.__class__):
1755
# converting away from metadir is not implemented
1756
raise NotImplementedError(self.get_converter)
1757
return ConvertMetaToMeta(format)
1760
def get_format_string(cls):
1761
"""See BzrDirFormat.get_format_string()."""
1762
return "Bazaar-NG meta directory, format 1\n"
1764
def get_format_description(self):
1765
"""See BzrDirFormat.get_format_description()."""
1766
return "Meta directory format 1"
1768
def network_name(self):
1769
return self.get_format_string()
1771
def _open(self, transport):
1772
"""See BzrDirFormat._open."""
1773
# Create a new format instance because otherwise initialisation of new
1774
# metadirs share the global default format object leading to alias
1776
format = BzrDirMetaFormat1()
1777
self._supply_sub_formats_to(format)
1778
return BzrDirMeta1(transport, format)
1780
def __return_repository_format(self):
1781
"""Circular import protection."""
1782
if self._repository_format:
1783
return self._repository_format
1784
from bzrlib.repository import format_registry
1785
return format_registry.get_default()
1787
def _set_repository_format(self, value):
1788
"""Allow changing the repository format for metadir formats."""
1789
self._repository_format = value
1791
repository_format = property(__return_repository_format,
1792
_set_repository_format)
1794
def _supply_sub_formats_to(self, other_format):
1795
"""Give other_format the same values for sub formats as this has.
1797
This method is expected to be used when parameterising a
1798
RemoteBzrDirFormat instance with the parameters from a
1799
BzrDirMetaFormat1 instance.
1801
:param other_format: other_format is a format which should be
1802
compatible with whatever sub formats are supported by self.
1805
if getattr(self, '_repository_format', None) is not None:
1806
other_format.repository_format = self.repository_format
1807
if self._branch_format is not None:
1808
other_format._branch_format = self._branch_format
1809
if self._workingtree_format is not None:
1810
other_format.workingtree_format = self.workingtree_format
1812
def __get_workingtree_format(self):
1813
if self._workingtree_format is None:
1814
from bzrlib.workingtree import (
1815
format_registry as wt_format_registry,
1817
self._workingtree_format = wt_format_registry.get_default()
1818
return self._workingtree_format
1820
def __set_workingtree_format(self, wt_format):
1821
self._workingtree_format = wt_format
1823
workingtree_format = property(__get_workingtree_format,
1824
__set_workingtree_format)
1827
# Register bzr formats
1828
BzrProber.formats.register(BzrDirMetaFormat1.get_format_string(),
1830
controldir.ControlDirFormat._default_format = BzrDirMetaFormat1()
1833
class ConvertMetaToMeta(controldir.Converter):
1834
"""Converts the components of metadirs."""
1836
def __init__(self, target_format):
1837
"""Create a metadir to metadir converter.
1839
:param target_format: The final metadir format that is desired.
1841
self.target_format = target_format
1843
def convert(self, to_convert, pb):
1844
"""See Converter.convert()."""
1845
self.bzrdir = to_convert
1846
self.pb = ui.ui_factory.nested_progress_bar()
1849
self.step('checking repository format')
1851
repo = self.bzrdir.open_repository()
1852
except errors.NoRepositoryPresent:
1855
if not isinstance(repo._format, self.target_format.repository_format.__class__):
1856
from bzrlib.repository import CopyConverter
1857
ui.ui_factory.note('starting repository conversion')
1858
converter = CopyConverter(self.target_format.repository_format)
1859
converter.convert(repo, pb)
1860
for branch in self.bzrdir.list_branches():
1861
# TODO: conversions of Branch and Tree should be done by
1862
# InterXFormat lookups/some sort of registry.
1863
# Avoid circular imports
1864
old = branch._format.__class__
1865
new = self.target_format.get_branch_format().__class__
1867
if (old == _mod_branch.BzrBranchFormat5 and
1868
new in (_mod_branch.BzrBranchFormat6,
1869
_mod_branch.BzrBranchFormat7,
1870
_mod_branch.BzrBranchFormat8)):
1871
branch_converter = _mod_branch.Converter5to6()
1872
elif (old == _mod_branch.BzrBranchFormat6 and
1873
new in (_mod_branch.BzrBranchFormat7,
1874
_mod_branch.BzrBranchFormat8)):
1875
branch_converter = _mod_branch.Converter6to7()
1876
elif (old == _mod_branch.BzrBranchFormat7 and
1877
new is _mod_branch.BzrBranchFormat8):
1878
branch_converter = _mod_branch.Converter7to8()
1880
raise errors.BadConversionTarget("No converter", new,
1882
branch_converter.convert(branch)
1883
branch = self.bzrdir.open_branch()
1884
old = branch._format.__class__
1886
tree = self.bzrdir.open_workingtree(recommend_upgrade=False)
1887
except (errors.NoWorkingTree, errors.NotLocalUrl):
1890
# TODO: conversions of Branch and Tree should be done by
1891
# InterXFormat lookups
1892
if (isinstance(tree, workingtree_3.WorkingTree3) and
1893
not isinstance(tree, workingtree_4.DirStateWorkingTree) and
1894
isinstance(self.target_format.workingtree_format,
1895
workingtree_4.DirStateWorkingTreeFormat)):
1896
workingtree_4.Converter3to4().convert(tree)
1897
if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
1898
not isinstance(tree, workingtree_4.WorkingTree5) and
1899
isinstance(self.target_format.workingtree_format,
1900
workingtree_4.WorkingTreeFormat5)):
1901
workingtree_4.Converter4to5().convert(tree)
1902
if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
1903
not isinstance(tree, workingtree_4.WorkingTree6) and
1904
isinstance(self.target_format.workingtree_format,
1905
workingtree_4.WorkingTreeFormat6)):
1906
workingtree_4.Converter4or5to6().convert(tree)
1911
controldir.ControlDirFormat.register_server_prober(RemoteBzrProber)
1914
class RepositoryAcquisitionPolicy(object):
1915
"""Abstract base class for repository acquisition policies.
1917
A repository acquisition policy decides how a BzrDir acquires a repository
1918
for a branch that is being created. The most basic policy decision is
1919
whether to create a new repository or use an existing one.
1921
def __init__(self, stack_on, stack_on_pwd, require_stacking):
1924
:param stack_on: A location to stack on
1925
:param stack_on_pwd: If stack_on is relative, the location it is
1927
:param require_stacking: If True, it is a failure to not stack.
1929
self._stack_on = stack_on
1930
self._stack_on_pwd = stack_on_pwd
1931
self._require_stacking = require_stacking
1933
def configure_branch(self, branch):
1934
"""Apply any configuration data from this policy to the branch.
1936
Default implementation sets repository stacking.
1938
if self._stack_on is None:
1940
if self._stack_on_pwd is None:
1941
stack_on = self._stack_on
1944
stack_on = urlutils.rebase_url(self._stack_on,
1947
except errors.InvalidRebaseURLs:
1948
stack_on = self._get_full_stack_on()
1950
branch.set_stacked_on_url(stack_on)
1951
except (errors.UnstackableBranchFormat,
1952
errors.UnstackableRepositoryFormat):
1953
if self._require_stacking:
1956
def requires_stacking(self):
1957
"""Return True if this policy requires stacking."""
1958
return self._stack_on is not None and self._require_stacking
1960
def _get_full_stack_on(self):
1961
"""Get a fully-qualified URL for the stack_on location."""
1962
if self._stack_on is None:
1964
if self._stack_on_pwd is None:
1965
return self._stack_on
1967
return urlutils.join(self._stack_on_pwd, self._stack_on)
1969
def _add_fallback(self, repository, possible_transports=None):
1970
"""Add a fallback to the supplied repository, if stacking is set."""
1971
stack_on = self._get_full_stack_on()
1972
if stack_on is None:
1975
stacked_dir = BzrDir.open(stack_on,
1976
possible_transports=possible_transports)
1977
except errors.JailBreak:
1978
# We keep the stacking details, but we are in the server code so
1979
# actually stacking is not needed.
1982
stacked_repo = stacked_dir.open_branch().repository
1983
except errors.NotBranchError:
1984
stacked_repo = stacked_dir.open_repository()
1986
repository.add_fallback_repository(stacked_repo)
1987
except errors.UnstackableRepositoryFormat:
1988
if self._require_stacking:
1991
self._require_stacking = True
1993
def acquire_repository(self, make_working_trees=None, shared=False):
1994
"""Acquire a repository for this bzrdir.
1996
Implementations may create a new repository or use a pre-exising
1999
:param make_working_trees: If creating a repository, set
2000
make_working_trees to this value (if non-None)
2001
:param shared: If creating a repository, make it shared if True
2002
:return: A repository, is_new_flag (True if the repository was
2005
raise NotImplemented(RepositoryAcquisitionPolicy.acquire_repository)
2008
class CreateRepository(RepositoryAcquisitionPolicy):
2009
"""A policy of creating a new repository"""
2011
def __init__(self, bzrdir, stack_on=None, stack_on_pwd=None,
2012
require_stacking=False):
2015
:param bzrdir: The bzrdir to create the repository on.
2016
:param stack_on: A location to stack on
2017
:param stack_on_pwd: If stack_on is relative, the location it is
2020
RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
2022
self._bzrdir = bzrdir
2024
def acquire_repository(self, make_working_trees=None, shared=False):
2025
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
2027
Creates the desired repository in the bzrdir we already have.
2029
stack_on = self._get_full_stack_on()
2031
format = self._bzrdir._format
2032
format.require_stacking(stack_on=stack_on,
2033
possible_transports=[self._bzrdir.root_transport])
2034
if not self._require_stacking:
2035
# We have picked up automatic stacking somewhere.
2036
note('Using default stacking branch %s at %s', self._stack_on,
2038
repository = self._bzrdir.create_repository(shared=shared)
2039
self._add_fallback(repository,
2040
possible_transports=[self._bzrdir.transport])
2041
if make_working_trees is not None:
2042
repository.set_make_working_trees(make_working_trees)
2043
return repository, True
2046
class UseExistingRepository(RepositoryAcquisitionPolicy):
2047
"""A policy of reusing an existing repository"""
2049
def __init__(self, repository, stack_on=None, stack_on_pwd=None,
2050
require_stacking=False):
2053
:param repository: The repository to use.
2054
:param stack_on: A location to stack on
2055
:param stack_on_pwd: If stack_on is relative, the location it is
2058
RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
2060
self._repository = repository
2062
def acquire_repository(self, make_working_trees=None, shared=False):
2063
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
2065
Returns an existing repository to use.
2067
self._add_fallback(self._repository,
2068
possible_transports=[self._repository.bzrdir.transport])
2069
return self._repository, False
2072
def register_metadir(registry, key,
2073
repository_format, help, native=True, deprecated=False,
2079
"""Register a metadir subformat.
2081
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
2082
by the Repository/Branch/WorkingTreeformats.
2084
:param repository_format: The fully-qualified repository format class
2086
:param branch_format: Fully-qualified branch format class name as
2088
:param tree_format: Fully-qualified tree format class name as
2091
# This should be expanded to support setting WorkingTree and Branch
2092
# formats, once BzrDirMetaFormat1 supports that.
2093
def _load(full_name):
2094
mod_name, factory_name = full_name.rsplit('.', 1)
2096
factory = pyutils.get_named_object(mod_name, factory_name)
2097
except ImportError, e:
2098
raise ImportError('failed to load %s: %s' % (full_name, e))
2099
except AttributeError:
2100
raise AttributeError('no factory %s in module %r'
2101
% (full_name, sys.modules[mod_name]))
2105
bd = BzrDirMetaFormat1()
2106
if branch_format is not None:
2107
bd.set_branch_format(_load(branch_format))
2108
if tree_format is not None:
2109
bd.workingtree_format = _load(tree_format)
2110
if repository_format is not None:
2111
bd.repository_format = _load(repository_format)
2113
registry.register(key, helper, help, native, deprecated, hidden,
2114
experimental, alias)
2116
register_metadir(controldir.format_registry, 'knit',
2117
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2118
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
2119
branch_format='bzrlib.branch.BzrBranchFormat5',
2120
tree_format='bzrlib.workingtree_3.WorkingTreeFormat3',
2123
register_metadir(controldir.format_registry, 'dirstate',
2124
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2125
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
2126
'above when accessed over the network.',
2127
branch_format='bzrlib.branch.BzrBranchFormat5',
2128
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2131
register_metadir(controldir.format_registry, 'dirstate-tags',
2132
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2133
help='New in 0.15: Fast local operations and improved scaling for '
2134
'network operations. Additionally adds support for tags.'
2135
' Incompatible with bzr < 0.15.',
2136
branch_format='bzrlib.branch.BzrBranchFormat6',
2137
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2140
register_metadir(controldir.format_registry, 'rich-root',
2141
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
2142
help='New in 1.0. Better handling of tree roots. Incompatible with'
2144
branch_format='bzrlib.branch.BzrBranchFormat6',
2145
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2148
register_metadir(controldir.format_registry, 'dirstate-with-subtree',
2149
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
2150
help='New in 0.15: Fast local operations and improved scaling for '
2151
'network operations. Additionally adds support for versioning nested '
2152
'bzr branches. Incompatible with bzr < 0.15.',
2153
branch_format='bzrlib.branch.BzrBranchFormat6',
2154
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2158
register_metadir(controldir.format_registry, 'pack-0.92',
2159
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack1',
2160
help='New in 0.92: Pack-based format with data compatible with '
2161
'dirstate-tags format repositories. Interoperates with '
2162
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
2164
branch_format='bzrlib.branch.BzrBranchFormat6',
2165
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2167
register_metadir(controldir.format_registry, 'pack-0.92-subtree',
2168
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack3',
2169
help='New in 0.92: Pack-based format with data compatible with '
2170
'dirstate-with-subtree format repositories. Interoperates with '
2171
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
2173
branch_format='bzrlib.branch.BzrBranchFormat6',
2174
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2178
register_metadir(controldir.format_registry, 'rich-root-pack',
2179
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack4',
2180
help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
2181
'(needed for bzr-svn and bzr-git).',
2182
branch_format='bzrlib.branch.BzrBranchFormat6',
2183
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2186
register_metadir(controldir.format_registry, '1.6',
2187
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack5',
2188
help='A format that allows a branch to indicate that there is another '
2189
'(stacked) repository that should be used to access data that is '
2190
'not present locally.',
2191
branch_format='bzrlib.branch.BzrBranchFormat7',
2192
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2195
register_metadir(controldir.format_registry, '1.6.1-rich-root',
2196
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack5RichRoot',
2197
help='A variant of 1.6 that supports rich-root data '
2198
'(needed for bzr-svn and bzr-git).',
2199
branch_format='bzrlib.branch.BzrBranchFormat7',
2200
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2203
register_metadir(controldir.format_registry, '1.9',
2204
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6',
2205
help='A repository format using B+tree indexes. These indexes '
2206
'are smaller in size, have smarter caching and provide faster '
2207
'performance for most operations.',
2208
branch_format='bzrlib.branch.BzrBranchFormat7',
2209
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2212
register_metadir(controldir.format_registry, '1.9-rich-root',
2213
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6RichRoot',
2214
help='A variant of 1.9 that supports rich-root data '
2215
'(needed for bzr-svn and bzr-git).',
2216
branch_format='bzrlib.branch.BzrBranchFormat7',
2217
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2220
register_metadir(controldir.format_registry, '1.14',
2221
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6',
2222
help='A working-tree format that supports content filtering.',
2223
branch_format='bzrlib.branch.BzrBranchFormat7',
2224
tree_format='bzrlib.workingtree_4.WorkingTreeFormat5',
2226
register_metadir(controldir.format_registry, '1.14-rich-root',
2227
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6RichRoot',
2228
help='A variant of 1.14 that supports rich-root data '
2229
'(needed for bzr-svn and bzr-git).',
2230
branch_format='bzrlib.branch.BzrBranchFormat7',
2231
tree_format='bzrlib.workingtree_4.WorkingTreeFormat5',
2233
# The following un-numbered 'development' formats should always just be aliases.
2234
register_metadir(controldir.format_registry, 'development-subtree',
2235
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2aSubtree',
2236
help='Current development format, subtree variant. Can convert data to and '
2237
'from pack-0.92-subtree (and anything compatible with '
2238
'pack-0.92-subtree) format repositories. Repositories and branches in '
2239
'this format can only be read by bzr.dev. Please read '
2240
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
2242
branch_format='bzrlib.branch.BzrBranchFormat7',
2243
tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
2246
alias=False, # Restore to being an alias when an actual development subtree format is added
2247
# This current non-alias status is simply because we did not introduce a
2248
# chk based subtree format.
2250
register_metadir(controldir.format_registry, 'development5-subtree',
2251
'bzrlib.repofmt.knitpack_repo.RepositoryFormatPackDevelopment2Subtree',
2252
help='Development format, subtree variant. Can convert data to and '
2253
'from pack-0.92-subtree (and anything compatible with '
2254
'pack-0.92-subtree) format repositories. Repositories and branches in '
2255
'this format can only be read by bzr.dev. Please read '
2256
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
2258
branch_format='bzrlib.branch.BzrBranchFormat7',
2259
tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
2265
# And the development formats above will have aliased one of the following:
2267
# Finally, the current format.
2268
register_metadir(controldir.format_registry, '2a',
2269
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
2270
help='First format for bzr 2.0 series.\n'
2271
'Uses group-compress storage.\n'
2272
'Provides rich roots which are a one-way transition.\n',
2273
# 'storage in packs, 255-way hashed CHK inventory, bencode revision, group compress, '
2274
# 'rich roots. Supported by bzr 1.16 and later.',
2275
branch_format='bzrlib.branch.BzrBranchFormat7',
2276
tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
2280
# The following format should be an alias for the rich root equivalent
2281
# of the default format
2282
register_metadir(controldir.format_registry, 'default-rich-root',
2283
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
2284
branch_format='bzrlib.branch.BzrBranchFormat7',
2285
tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
2290
# The current format that is made on 'bzr init'.
2291
format_name = config.GlobalStack().get('default_format')
2292
controldir.format_registry.set_default(format_name)
2294
# XXX 2010-08-20 JRV: There is still a lot of code relying on
2295
# bzrlib.bzrdir.format_registry existing. When BzrDir.create/BzrDir.open/etc
2296
# get changed to ControlDir.create/ControlDir.open/etc this should be removed.
2297
format_registry = controldir.format_registry
added
removed
bzrlib/bzrdir.py
