1
# Copyright (C) 2005, 2006, 2007, 2008 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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
28
# TODO: Move old formats into a plugin to make this file smaller.
30
from cStringIO import StringIO
34
from bzrlib.lazy_import import lazy_import
35
lazy_import(globals(), """
36
from stat import S_ISDIR
38
from warnings import warn
50
revision as _mod_revision,
61
from bzrlib.osutils import (
65
from bzrlib.repository import Repository
66
from bzrlib.smart.client import _SmartClient
67
from bzrlib.smart import protocol
68
from bzrlib.store.versioned import WeaveStore
69
from bzrlib.transactions import WriteTransaction
70
from bzrlib.transport import (
71
do_catching_redirections,
74
from bzrlib.weave import Weave
77
from bzrlib.trace import (
81
from bzrlib.transport.local import LocalTransport
82
from bzrlib.symbol_versioning import (
89
"""A .bzr control diretory.
91
BzrDir instances let you create or open any of the things that can be
92
found within .bzr - checkouts, branches and repositories.
95
the transport which this bzr dir is rooted at (i.e. file:///.../.bzr/)
97
a transport connected to the directory this bzr was opened from
98
(i.e. the parent directory holding the .bzr directory).
100
Everything in the bzrdir should have the same file permissions.
103
def break_lock(self):
104
"""Invoke break_lock on the first object in the bzrdir.
106
If there is a tree, the tree is opened and break_lock() called.
107
Otherwise, branch is tried, and finally repository.
109
# XXX: This seems more like a UI function than something that really
110
# belongs in this class.
112
thing_to_unlock = self.open_workingtree()
113
except (errors.NotLocalUrl, errors.NoWorkingTree):
115
thing_to_unlock = self.open_branch()
116
except errors.NotBranchError:
118
thing_to_unlock = self.open_repository()
119
except errors.NoRepositoryPresent:
121
thing_to_unlock.break_lock()
123
def can_convert_format(self):
124
"""Return true if this bzrdir is one whose format we can convert from."""
127
def check_conversion_target(self, target_format):
128
target_repo_format = target_format.repository_format
129
source_repo_format = self._format.repository_format
130
source_repo_format.check_conversion_target(target_repo_format)
133
def _check_supported(format, allow_unsupported,
134
recommend_upgrade=True,
136
"""Give an error or warning on old formats.
138
:param format: may be any kind of format - workingtree, branch,
141
:param allow_unsupported: If true, allow opening
142
formats that are strongly deprecated, and which may
143
have limited functionality.
145
:param recommend_upgrade: If true (default), warn
146
the user through the ui object that they may wish
147
to upgrade the object.
149
# TODO: perhaps move this into a base Format class; it's not BzrDir
150
# specific. mbp 20070323
151
if not allow_unsupported and not format.is_supported():
152
# see open_downlevel to open legacy branches.
153
raise errors.UnsupportedFormatError(format=format)
154
if recommend_upgrade \
155
and getattr(format, 'upgrade_recommended', False):
156
ui.ui_factory.recommend_upgrade(
157
format.get_format_description(),
160
def clone(self, url, revision_id=None, force_new_repo=False,
161
preserve_stacking=False):
162
"""Clone this bzrdir and its contents to url verbatim.
164
:param url: The url create the clone at. If url's last component does
165
not exist, it will be created.
166
:param revision_id: The tip revision-id to use for any branch or
167
working tree. If not None, then the clone operation may tune
168
itself to download less data.
169
:param force_new_repo: Do not use a shared repository for the target
170
even if one is available.
171
:param preserve_stacking: When cloning a stacked branch, stack the
172
new branch on top of the other branch's stacked-on branch.
174
return self.clone_on_transport(get_transport(url),
175
revision_id=revision_id,
176
force_new_repo=force_new_repo,
177
preserve_stacking=preserve_stacking)
179
def clone_on_transport(self, transport, revision_id=None,
180
force_new_repo=False, preserve_stacking=False):
181
"""Clone this bzrdir and its contents to transport verbatim.
183
:param transport: The transport for the location to produce the clone
184
at. If the target directory does not exist, it will be created.
185
:param revision_id: The tip revision-id to use for any branch or
186
working tree. If not None, then the clone operation may tune
187
itself to download less data.
188
:param force_new_repo: Do not use a shared repository for the target,
189
even if one is available.
190
:param preserve_stacking: When cloning a stacked branch, stack the
191
new branch on top of the other branch's stacked-on branch.
193
transport.ensure_base()
194
result = self.cloning_metadir().initialize_on_transport(transport)
195
repository_policy = None
198
local_repo = self.find_repository()
199
except errors.NoRepositoryPresent:
202
local_branch = self.open_branch()
203
except errors.NotBranchError:
206
# enable fallbacks when branch is not a branch reference
207
if local_branch.repository.has_same_location(local_repo):
208
local_repo = local_branch.repository
209
if preserve_stacking:
211
stack_on = local_branch.get_stacked_on_url()
212
except (errors.UnstackableBranchFormat,
213
errors.UnstackableRepositoryFormat,
218
# may need to copy content in
219
repository_policy = result.determine_repository_policy(
220
force_new_repo, stack_on)
221
make_working_trees = local_repo.make_working_trees()
222
result_repo = repository_policy.acquire_repository(
223
make_working_trees, local_repo.is_shared())
224
result_repo.fetch(local_repo, revision_id=revision_id)
227
# 1 if there is a branch present
228
# make sure its content is available in the target repository
230
if local_branch is not None:
231
result_branch = local_branch.clone(result, revision_id=revision_id)
232
if repository_policy is not None:
233
repository_policy.configure_branch(result_branch)
234
if result_repo is None or result_repo.make_working_trees():
236
self.open_workingtree().clone(result)
237
except (errors.NoWorkingTree, errors.NotLocalUrl):
241
# TODO: This should be given a Transport, and should chdir up; otherwise
242
# this will open a new connection.
243
def _make_tail(self, url):
244
t = get_transport(url)
248
def create(cls, base, format=None, possible_transports=None):
249
"""Create a new BzrDir at the url 'base'.
251
:param format: If supplied, the format of branch to create. If not
252
supplied, the default is used.
253
:param possible_transports: If supplied, a list of transports that
254
can be reused to share a remote connection.
256
if cls is not BzrDir:
257
raise AssertionError("BzrDir.create always creates the default"
258
" format, not one of %r" % cls)
259
t = get_transport(base, possible_transports)
262
format = BzrDirFormat.get_default_format()
263
return format.initialize_on_transport(t)
266
def find_bzrdirs(transport, evaluate=None, list_current=None):
267
"""Find bzrdirs recursively from current location.
269
This is intended primarily as a building block for more sophisticated
270
functionality, like finding trees under a directory, or finding
271
branches that use a given repository.
272
:param evaluate: An optional callable that yields recurse, value,
273
where recurse controls whether this bzrdir is recursed into
274
and value is the value to yield. By default, all bzrdirs
275
are recursed into, and the return value is the bzrdir.
276
:param list_current: if supplied, use this function to list the current
277
directory, instead of Transport.list_dir
278
:return: a generator of found bzrdirs, or whatever evaluate returns.
280
if list_current is None:
281
def list_current(transport):
282
return transport.list_dir('')
284
def evaluate(bzrdir):
287
pending = [transport]
288
while len(pending) > 0:
289
current_transport = pending.pop()
292
bzrdir = BzrDir.open_from_transport(current_transport)
293
except errors.NotBranchError:
296
recurse, value = evaluate(bzrdir)
299
subdirs = list_current(current_transport)
300
except errors.NoSuchFile:
303
for subdir in sorted(subdirs, reverse=True):
304
pending.append(current_transport.clone(subdir))
307
def find_branches(transport):
308
"""Find all branches under a transport.
310
This will find all branches below the transport, including branches
311
inside other branches. Where possible, it will use
312
Repository.find_branches.
314
To list all the branches that use a particular Repository, see
315
Repository.find_branches
317
def evaluate(bzrdir):
319
repository = bzrdir.open_repository()
320
except errors.NoRepositoryPresent:
323
return False, (None, repository)
325
branch = bzrdir.open_branch()
326
except errors.NotBranchError:
327
return True, (None, None)
329
return True, (branch, None)
331
for branch, repo in BzrDir.find_bzrdirs(transport, evaluate=evaluate):
333
branches.extend(repo.find_branches())
334
if branch is not None:
335
branches.append(branch)
338
def destroy_repository(self):
339
"""Destroy the repository in this BzrDir"""
340
raise NotImplementedError(self.destroy_repository)
342
def create_branch(self):
343
"""Create a branch in this BzrDir.
345
The bzrdir's format will control what branch format is created.
346
For more control see BranchFormatXX.create(a_bzrdir).
348
raise NotImplementedError(self.create_branch)
350
def destroy_branch(self):
351
"""Destroy the branch in this BzrDir"""
352
raise NotImplementedError(self.destroy_branch)
355
def create_branch_and_repo(base, force_new_repo=False, format=None):
356
"""Create a new BzrDir, Branch and Repository at the url 'base'.
358
This will use the current default BzrDirFormat unless one is
359
specified, and use whatever
360
repository format that that uses via bzrdir.create_branch and
361
create_repository. If a shared repository is available that is used
364
The created Branch object is returned.
366
:param base: The URL to create the branch at.
367
:param force_new_repo: If True a new repository is always created.
368
:param format: If supplied, the format of branch to create. If not
369
supplied, the default is used.
371
bzrdir = BzrDir.create(base, format)
372
bzrdir._find_or_create_repository(force_new_repo)
373
return bzrdir.create_branch()
375
def determine_repository_policy(self, force_new_repo=False, stack_on=None,
376
stack_on_pwd=None, require_stacking=False):
377
"""Return an object representing a policy to use.
379
This controls whether a new repository is created, or a shared
380
repository used instead.
382
If stack_on is supplied, will not seek a containing shared repo.
383
:param force_new_repo: If True, require a new repository to be created.
384
:param stack_on: If supplied, the location to stack on. If not
385
supplied, a default_stack_on location may be used.
386
:param stack_on_pwd: If stack_on is relative, the location it is
389
def repository_policy(found_bzrdir):
392
config = found_bzrdir.get_config()
394
if config is not None:
395
stack_on = config.get_default_stack_on()
396
if stack_on is not None:
397
stack_on_pwd = found_bzrdir.root_transport.base
399
note('Using default stacking branch %s at %s', stack_on,
401
# does it have a repository ?
403
repository = found_bzrdir.open_repository()
404
except errors.NoRepositoryPresent:
407
if ((found_bzrdir.root_transport.base !=
408
self.root_transport.base) and not repository.is_shared()):
415
return UseExistingRepository(repository, stack_on,
416
stack_on_pwd, require_stacking=require_stacking), True
418
return CreateRepository(self, stack_on, stack_on_pwd,
419
require_stacking=require_stacking), True
421
if not force_new_repo:
423
policy = self._find_containing(repository_policy)
424
if policy is not None:
428
return UseExistingRepository(self.open_repository(),
429
stack_on, stack_on_pwd,
430
require_stacking=require_stacking)
431
except errors.NoRepositoryPresent:
433
return CreateRepository(self, stack_on, stack_on_pwd,
434
require_stacking=require_stacking)
436
def _find_or_create_repository(self, force_new_repo):
437
"""Create a new repository if needed, returning the repository."""
438
policy = self.determine_repository_policy(force_new_repo)
439
return policy.acquire_repository()
442
def create_branch_convenience(base, force_new_repo=False,
443
force_new_tree=None, format=None,
444
possible_transports=None):
445
"""Create a new BzrDir, Branch and Repository at the url 'base'.
447
This is a convenience function - it will use an existing repository
448
if possible, can be told explicitly whether to create a working tree or
451
This will use the current default BzrDirFormat unless one is
452
specified, and use whatever
453
repository format that that uses via bzrdir.create_branch and
454
create_repository. If a shared repository is available that is used
455
preferentially. Whatever repository is used, its tree creation policy
458
The created Branch object is returned.
459
If a working tree cannot be made due to base not being a file:// url,
460
no error is raised unless force_new_tree is True, in which case no
461
data is created on disk and NotLocalUrl is raised.
463
:param base: The URL to create the branch at.
464
:param force_new_repo: If True a new repository is always created.
465
:param force_new_tree: If True or False force creation of a tree or
466
prevent such creation respectively.
467
:param format: Override for the bzrdir format to create.
468
:param possible_transports: An optional reusable transports list.
471
# check for non local urls
472
t = get_transport(base, possible_transports)
473
if not isinstance(t, LocalTransport):
474
raise errors.NotLocalUrl(base)
475
bzrdir = BzrDir.create(base, format, possible_transports)
476
repo = bzrdir._find_or_create_repository(force_new_repo)
477
result = bzrdir.create_branch()
478
if force_new_tree or (repo.make_working_trees() and
479
force_new_tree is None):
481
bzrdir.create_workingtree()
482
except errors.NotLocalUrl:
487
def create_standalone_workingtree(base, format=None):
488
"""Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
490
'base' must be a local path or a file:// url.
492
This will use the current default BzrDirFormat unless one is
493
specified, and use whatever
494
repository format that that uses for bzrdirformat.create_workingtree,
495
create_branch and create_repository.
497
:param format: Override for the bzrdir format to create.
498
:return: The WorkingTree object.
500
t = get_transport(base)
501
if not isinstance(t, LocalTransport):
502
raise errors.NotLocalUrl(base)
503
bzrdir = BzrDir.create_branch_and_repo(base,
505
format=format).bzrdir
506
return bzrdir.create_workingtree()
508
def create_workingtree(self, revision_id=None, from_branch=None,
509
accelerator_tree=None, hardlink=False):
510
"""Create a working tree at this BzrDir.
512
:param revision_id: create it as of this revision id.
513
:param from_branch: override bzrdir branch (for lightweight checkouts)
514
:param accelerator_tree: A tree which can be used for retrieving file
515
contents more quickly than the revision tree, i.e. a workingtree.
516
The revision tree will be used for cases where accelerator_tree's
517
content is different.
519
raise NotImplementedError(self.create_workingtree)
521
def retire_bzrdir(self, limit=10000):
522
"""Permanently disable the bzrdir.
524
This is done by renaming it to give the user some ability to recover
525
if there was a problem.
527
This will have horrible consequences if anyone has anything locked or
529
:param limit: number of times to retry
534
to_path = '.bzr.retired.%d' % i
535
self.root_transport.rename('.bzr', to_path)
536
note("renamed %s to %s"
537
% (self.root_transport.abspath('.bzr'), to_path))
539
except (errors.TransportError, IOError, errors.PathError):
546
def destroy_workingtree(self):
547
"""Destroy the working tree at this BzrDir.
549
Formats that do not support this may raise UnsupportedOperation.
551
raise NotImplementedError(self.destroy_workingtree)
553
def destroy_workingtree_metadata(self):
554
"""Destroy the control files for the working tree at this BzrDir.
556
The contents of working tree files are not affected.
557
Formats that do not support this may raise UnsupportedOperation.
559
raise NotImplementedError(self.destroy_workingtree_metadata)
561
def _find_containing(self, evaluate):
562
"""Find something in a containing control directory.
564
This method will scan containing control dirs, until it finds what
565
it is looking for, decides that it will never find it, or runs out
566
of containing control directories to check.
568
It is used to implement find_repository and
569
determine_repository_policy.
571
:param evaluate: A function returning (value, stop). If stop is True,
572
the value will be returned.
576
result, stop = evaluate(found_bzrdir)
579
next_transport = found_bzrdir.root_transport.clone('..')
580
if (found_bzrdir.root_transport.base == next_transport.base):
581
# top of the file system
583
# find the next containing bzrdir
585
found_bzrdir = BzrDir.open_containing_from_transport(
587
except errors.NotBranchError:
590
def find_repository(self):
591
"""Find the repository that should be used.
593
This does not require a branch as we use it to find the repo for
594
new branches as well as to hook existing branches up to their
597
def usable_repository(found_bzrdir):
598
# does it have a repository ?
600
repository = found_bzrdir.open_repository()
601
except errors.NoRepositoryPresent:
603
if found_bzrdir.root_transport.base == self.root_transport.base:
604
return repository, True
605
elif repository.is_shared():
606
return repository, True
610
found_repo = self._find_containing(usable_repository)
611
if found_repo is None:
612
raise errors.NoRepositoryPresent(self)
615
def get_branch_reference(self):
616
"""Return the referenced URL for the branch in this bzrdir.
618
:raises NotBranchError: If there is no Branch.
619
:return: The URL the branch in this bzrdir references if it is a
620
reference branch, or None for regular branches.
624
def get_branch_transport(self, branch_format):
625
"""Get the transport for use by branch format in this BzrDir.
627
Note that bzr dirs that do not support format strings will raise
628
IncompatibleFormat if the branch format they are given has
629
a format string, and vice versa.
631
If branch_format is None, the transport is returned with no
632
checking. If it is not None, then the returned transport is
633
guaranteed to point to an existing directory ready for use.
635
raise NotImplementedError(self.get_branch_transport)
637
def _find_creation_modes(self):
638
"""Determine the appropriate modes for files and directories.
640
They're always set to be consistent with the base directory,
641
assuming that this transport allows setting modes.
643
# TODO: Do we need or want an option (maybe a config setting) to turn
644
# this off or override it for particular locations? -- mbp 20080512
645
if self._mode_check_done:
647
self._mode_check_done = True
649
st = self.transport.stat('.')
650
except errors.TransportNotPossible:
651
self._dir_mode = None
652
self._file_mode = None
654
# Check the directory mode, but also make sure the created
655
# directories and files are read-write for this user. This is
656
# mostly a workaround for filesystems which lie about being able to
657
# write to a directory (cygwin & win32)
658
self._dir_mode = (st.st_mode & 07777) | 00700
659
# Remove the sticky and execute bits for files
660
self._file_mode = self._dir_mode & ~07111
662
def _get_file_mode(self):
663
"""Return Unix mode for newly created files, or None.
665
if not self._mode_check_done:
666
self._find_creation_modes()
667
return self._file_mode
669
def _get_dir_mode(self):
670
"""Return Unix mode for newly created directories, or None.
672
if not self._mode_check_done:
673
self._find_creation_modes()
674
return self._dir_mode
676
def get_repository_transport(self, repository_format):
677
"""Get the transport for use by repository format in this BzrDir.
679
Note that bzr dirs that do not support format strings will raise
680
IncompatibleFormat if the repository format they are given has
681
a format string, and vice versa.
683
If repository_format is None, the transport is returned with no
684
checking. If it is not None, then the returned transport is
685
guaranteed to point to an existing directory ready for use.
687
raise NotImplementedError(self.get_repository_transport)
689
def get_workingtree_transport(self, tree_format):
690
"""Get the transport for use by workingtree format in this BzrDir.
692
Note that bzr dirs that do not support format strings will raise
693
IncompatibleFormat if the workingtree format they are given has a
694
format string, and vice versa.
696
If workingtree_format is None, the transport is returned with no
697
checking. If it is not None, then the returned transport is
698
guaranteed to point to an existing directory ready for use.
700
raise NotImplementedError(self.get_workingtree_transport)
702
def get_config(self):
703
if getattr(self, '_get_config', None) is None:
705
return self._get_config()
707
def __init__(self, _transport, _format):
708
"""Initialize a Bzr control dir object.
710
Only really common logic should reside here, concrete classes should be
711
made with varying behaviours.
713
:param _format: the format that is creating this BzrDir instance.
714
:param _transport: the transport this dir is based at.
716
self._format = _format
717
self.transport = _transport.clone('.bzr')
718
self.root_transport = _transport
719
self._mode_check_done = False
721
def is_control_filename(self, filename):
722
"""True if filename is the name of a path which is reserved for bzrdir's.
724
:param filename: A filename within the root transport of this bzrdir.
726
This is true IF and ONLY IF the filename is part of the namespace reserved
727
for bzr control dirs. Currently this is the '.bzr' directory in the root
728
of the root_transport. it is expected that plugins will need to extend
729
this in the future - for instance to make bzr talk with svn working
732
# this might be better on the BzrDirFormat class because it refers to
733
# all the possible bzrdir disk formats.
734
# This method is tested via the workingtree is_control_filename tests-
735
# it was extracted from WorkingTree.is_control_filename. If the method's
736
# contract is extended beyond the current trivial implementation, please
737
# add new tests for it to the appropriate place.
738
return filename == '.bzr' or filename.startswith('.bzr/')
740
def needs_format_conversion(self, format=None):
741
"""Return true if this bzrdir needs convert_format run on it.
743
For instance, if the repository format is out of date but the
744
branch and working tree are not, this should return True.
746
:param format: Optional parameter indicating a specific desired
747
format we plan to arrive at.
749
raise NotImplementedError(self.needs_format_conversion)
752
def open_unsupported(base):
753
"""Open a branch which is not supported."""
754
return BzrDir.open(base, _unsupported=True)
757
def open(base, _unsupported=False, possible_transports=None):
758
"""Open an existing bzrdir, rooted at 'base' (url).
760
:param _unsupported: a private parameter to the BzrDir class.
762
t = get_transport(base, possible_transports=possible_transports)
763
return BzrDir.open_from_transport(t, _unsupported=_unsupported)
766
def open_from_transport(transport, _unsupported=False,
767
_server_formats=True):
768
"""Open a bzrdir within a particular directory.
770
:param transport: Transport containing the bzrdir.
771
:param _unsupported: private.
773
base = transport.base
775
def find_format(transport):
776
return transport, BzrDirFormat.find_format(
777
transport, _server_formats=_server_formats)
779
def redirected(transport, e, redirection_notice):
780
qualified_source = e.get_source_url()
781
relpath = transport.relpath(qualified_source)
782
if not e.target.endswith(relpath):
783
# Not redirected to a branch-format, not a branch
784
raise errors.NotBranchError(path=e.target)
785
target = e.target[:-len(relpath)]
786
note('%s is%s redirected to %s',
787
transport.base, e.permanently, target)
788
# Let's try with a new transport
789
# FIXME: If 'transport' has a qualifier, this should
790
# be applied again to the new transport *iff* the
791
# schemes used are the same. Uncomment this code
792
# once the function (and tests) exist.
794
#target = urlutils.copy_url_qualifiers(original, target)
795
return get_transport(target)
798
transport, format = do_catching_redirections(find_format,
801
except errors.TooManyRedirections:
802
raise errors.NotBranchError(base)
804
BzrDir._check_supported(format, _unsupported)
805
return format.open(transport, _found=True)
807
def open_branch(self, unsupported=False):
808
"""Open the branch object at this BzrDir if one is present.
810
If unsupported is True, then no longer supported branch formats can
813
TODO: static convenience version of this?
815
raise NotImplementedError(self.open_branch)
818
def open_containing(url, possible_transports=None):
819
"""Open an existing branch which contains url.
821
:param url: url to search from.
822
See open_containing_from_transport for more detail.
824
transport = get_transport(url, possible_transports)
825
return BzrDir.open_containing_from_transport(transport)
828
def open_containing_from_transport(a_transport):
829
"""Open an existing branch which contains a_transport.base.
831
This probes for a branch at a_transport, and searches upwards from there.
833
Basically we keep looking up until we find the control directory or
834
run into the root. If there isn't one, raises NotBranchError.
835
If there is one and it is either an unrecognised format or an unsupported
836
format, UnknownFormatError or UnsupportedFormatError are raised.
837
If there is one, it is returned, along with the unused portion of url.
839
:return: The BzrDir that contains the path, and a Unicode path
840
for the rest of the URL.
842
# this gets the normalised url back. I.e. '.' -> the full path.
843
url = a_transport.base
846
result = BzrDir.open_from_transport(a_transport)
847
return result, urlutils.unescape(a_transport.relpath(url))
848
except errors.NotBranchError, e:
851
new_t = a_transport.clone('..')
852
except errors.InvalidURLJoin:
853
# reached the root, whatever that may be
854
raise errors.NotBranchError(path=url)
855
if new_t.base == a_transport.base:
856
# reached the root, whatever that may be
857
raise errors.NotBranchError(path=url)
860
def _get_tree_branch(self):
861
"""Return the branch and tree, if any, for this bzrdir.
863
Return None for tree if not present or inaccessible.
864
Raise NotBranchError if no branch is present.
865
:return: (tree, branch)
868
tree = self.open_workingtree()
869
except (errors.NoWorkingTree, errors.NotLocalUrl):
871
branch = self.open_branch()
877
def open_tree_or_branch(klass, location):
878
"""Return the branch and working tree at a location.
880
If there is no tree at the location, tree will be None.
881
If there is no branch at the location, an exception will be
883
:return: (tree, branch)
885
bzrdir = klass.open(location)
886
return bzrdir._get_tree_branch()
889
def open_containing_tree_or_branch(klass, location):
890
"""Return the branch and working tree contained by a location.
892
Returns (tree, branch, relpath).
893
If there is no tree at containing the location, tree will be None.
894
If there is no branch containing the location, an exception will be
896
relpath is the portion of the path that is contained by the branch.
898
bzrdir, relpath = klass.open_containing(location)
899
tree, branch = bzrdir._get_tree_branch()
900
return tree, branch, relpath
903
def open_containing_tree_branch_or_repository(klass, location):
904
"""Return the working tree, branch and repo contained by a location.
906
Returns (tree, branch, repository, relpath).
907
If there is no tree containing the location, tree will be None.
908
If there is no branch containing the location, branch will be None.
909
If there is no repository containing the location, repository will be
911
relpath is the portion of the path that is contained by the innermost
914
If no tree, branch or repository is found, a NotBranchError is raised.
916
bzrdir, relpath = klass.open_containing(location)
918
tree, branch = bzrdir._get_tree_branch()
919
except errors.NotBranchError:
921
repo = bzrdir.find_repository()
922
return None, None, repo, relpath
923
except (errors.NoRepositoryPresent):
924
raise errors.NotBranchError(location)
925
return tree, branch, branch.repository, relpath
927
def open_repository(self, _unsupported=False):
928
"""Open the repository object at this BzrDir if one is present.
930
This will not follow the Branch object pointer - it's strictly a direct
931
open facility. Most client code should use open_branch().repository to
934
:param _unsupported: a private parameter, not part of the api.
935
TODO: static convenience version of this?
937
raise NotImplementedError(self.open_repository)
939
def open_workingtree(self, _unsupported=False,
940
recommend_upgrade=True, from_branch=None):
941
"""Open the workingtree object at this BzrDir if one is present.
943
:param recommend_upgrade: Optional keyword parameter, when True (the
944
default), emit through the ui module a recommendation that the user
945
upgrade the working tree when the workingtree being opened is old
946
(but still fully supported).
947
:param from_branch: override bzrdir branch (for lightweight checkouts)
949
raise NotImplementedError(self.open_workingtree)
951
def has_branch(self):
952
"""Tell if this bzrdir contains a branch.
954
Note: if you're going to open the branch, you should just go ahead
955
and try, and not ask permission first. (This method just opens the
956
branch and discards it, and that's somewhat expensive.)
961
except errors.NotBranchError:
964
def has_workingtree(self):
965
"""Tell if this bzrdir contains a working tree.
967
This will still raise an exception if the bzrdir has a workingtree that
968
is remote & inaccessible.
970
Note: if you're going to open the working tree, you should just go ahead
971
and try, and not ask permission first. (This method just opens the
972
workingtree and discards it, and that's somewhat expensive.)
975
self.open_workingtree(recommend_upgrade=False)
977
except errors.NoWorkingTree:
980
def _cloning_metadir(self):
981
"""Produce a metadir suitable for cloning with."""
982
result_format = self._format.__class__()
985
branch = self.open_branch()
986
source_repository = branch.repository
987
except errors.NotBranchError:
989
source_repository = self.open_repository()
990
except errors.NoRepositoryPresent:
991
source_repository = None
993
# XXX TODO: This isinstance is here because we have not implemented
994
# the fix recommended in bug # 103195 - to delegate this choice the
996
repo_format = source_repository._format
997
if not isinstance(repo_format, remote.RemoteRepositoryFormat):
998
result_format.repository_format = repo_format
1000
# TODO: Couldn't we just probe for the format in these cases,
1001
# rather than opening the whole tree? It would be a little
1002
# faster. mbp 20070401
1003
tree = self.open_workingtree(recommend_upgrade=False)
1004
except (errors.NoWorkingTree, errors.NotLocalUrl):
1005
result_format.workingtree_format = None
1007
result_format.workingtree_format = tree._format.__class__()
1008
return result_format, source_repository
1010
def cloning_metadir(self):
1011
"""Produce a metadir suitable for cloning or sprouting with.
1013
These operations may produce workingtrees (yes, even though they're
1014
"cloning" something that doesn't have a tree), so a viable workingtree
1015
format must be selected.
1017
format, repository = self._cloning_metadir()
1018
if format._workingtree_format is None:
1019
if repository is None:
1021
tree_format = repository._format._matchingbzrdir.workingtree_format
1022
format.workingtree_format = tree_format.__class__()
1025
def checkout_metadir(self):
1026
return self.cloning_metadir()
1028
def sprout(self, url, revision_id=None, force_new_repo=False,
1029
recurse='down', possible_transports=None,
1030
accelerator_tree=None, hardlink=False, stacked=False):
1031
"""Create a copy of this bzrdir prepared for use as a new line of
1034
If url's last component does not exist, it will be created.
1036
Attributes related to the identity of the source branch like
1037
branch nickname will be cleaned, a working tree is created
1038
whether one existed before or not; and a local branch is always
1041
if revision_id is not None, then the clone operation may tune
1042
itself to download less data.
1043
:param accelerator_tree: A tree which can be used for retrieving file
1044
contents more quickly than the revision tree, i.e. a workingtree.
1045
The revision tree will be used for cases where accelerator_tree's
1046
content is different.
1047
:param hardlink: If true, hard-link files from accelerator_tree,
1049
:param stacked: If true, create a stacked branch referring to the
1050
location of this control directory.
1052
target_transport = get_transport(url, possible_transports)
1053
target_transport.ensure_base()
1054
cloning_format = self.cloning_metadir()
1055
result = cloning_format.initialize_on_transport(target_transport)
1057
source_branch = self.open_branch()
1058
source_repository = source_branch.repository
1060
stacked_branch_url = self.root_transport.base
1062
# if a stacked branch wasn't requested, we don't create one
1063
# even if the origin was stacked
1064
stacked_branch_url = None
1065
except errors.NotBranchError:
1066
source_branch = None
1068
source_repository = self.open_repository()
1069
except errors.NoRepositoryPresent:
1070
source_repository = None
1071
stacked_branch_url = None
1072
repository_policy = result.determine_repository_policy(
1073
force_new_repo, stacked_branch_url, require_stacking=stacked)
1074
result_repo = repository_policy.acquire_repository()
1075
if source_repository is not None:
1076
result_repo.fetch(source_repository, revision_id=revision_id)
1078
# Create/update the result branch
1079
if source_branch is not None:
1080
result_branch = source_branch.sprout(result,
1081
revision_id=revision_id)
1083
result_branch = result.create_branch()
1084
repository_policy.configure_branch(result_branch)
1086
# Create/update the result working tree
1087
if isinstance(target_transport, LocalTransport) and (
1088
result_repo is None or result_repo.make_working_trees()):
1089
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
1093
if wt.path2id('') is None:
1095
wt.set_root_id(self.open_workingtree.get_root_id())
1096
except errors.NoWorkingTree:
1102
if recurse == 'down':
1104
basis = wt.basis_tree()
1106
subtrees = basis.iter_references()
1107
elif source_branch is not None:
1108
basis = source_branch.basis_tree()
1110
subtrees = basis.iter_references()
1115
for path, file_id in subtrees:
1116
target = urlutils.join(url, urlutils.escape(path))
1117
sublocation = source_branch.reference_parent(file_id, path)
1118
sublocation.bzrdir.sprout(target,
1119
basis.get_reference_revision(file_id, path),
1120
force_new_repo=force_new_repo, recurse=recurse,
1123
if basis is not None:
1128
class BzrDirPreSplitOut(BzrDir):
1129
"""A common class for the all-in-one formats."""
1131
def __init__(self, _transport, _format):
1132
"""See BzrDir.__init__."""
1133
super(BzrDirPreSplitOut, self).__init__(_transport, _format)
1134
self._control_files = lockable_files.LockableFiles(
1135
self.get_branch_transport(None),
1136
self._format._lock_file_name,
1137
self._format._lock_class)
1139
def break_lock(self):
1140
"""Pre-splitout bzrdirs do not suffer from stale locks."""
1141
raise NotImplementedError(self.break_lock)
1143
def cloning_metadir(self):
1144
"""Produce a metadir suitable for cloning with."""
1145
return self._format.__class__()
1147
def clone(self, url, revision_id=None, force_new_repo=False,
1148
preserve_stacking=False):
1149
"""See BzrDir.clone().
1151
force_new_repo has no effect, since this family of formats always
1152
require a new repository.
1153
preserve_stacking has no effect, since no source branch using this
1154
family of formats can be stacked, so there is no stacking to preserve.
1156
from bzrlib.workingtree import WorkingTreeFormat2
1157
self._make_tail(url)
1158
result = self._format._initialize_for_clone(url)
1159
self.open_repository().clone(result, revision_id=revision_id)
1160
from_branch = self.open_branch()
1161
from_branch.clone(result, revision_id=revision_id)
1163
self.open_workingtree().clone(result)
1164
except errors.NotLocalUrl:
1165
# make a new one, this format always has to have one.
1167
WorkingTreeFormat2().initialize(result)
1168
except errors.NotLocalUrl:
1169
# but we cannot do it for remote trees.
1170
to_branch = result.open_branch()
1171
WorkingTreeFormat2()._stub_initialize_remote(to_branch)
1174
def create_branch(self):
1175
"""See BzrDir.create_branch."""
1176
return self.open_branch()
1178
def destroy_branch(self):
1179
"""See BzrDir.destroy_branch."""
1180
raise errors.UnsupportedOperation(self.destroy_branch, self)
1182
def create_repository(self, shared=False):
1183
"""See BzrDir.create_repository."""
1185
raise errors.IncompatibleFormat('shared repository', self._format)
1186
return self.open_repository()
1188
def destroy_repository(self):
1189
"""See BzrDir.destroy_repository."""
1190
raise errors.UnsupportedOperation(self.destroy_repository, self)
1192
def create_workingtree(self, revision_id=None, from_branch=None,
1193
accelerator_tree=None, hardlink=False):
1194
"""See BzrDir.create_workingtree."""
1195
# this looks buggy but is not -really-
1196
# because this format creates the workingtree when the bzrdir is
1198
# clone and sprout will have set the revision_id
1199
# and that will have set it for us, its only
1200
# specific uses of create_workingtree in isolation
1201
# that can do wonky stuff here, and that only
1202
# happens for creating checkouts, which cannot be
1203
# done on this format anyway. So - acceptable wart.
1204
result = self.open_workingtree(recommend_upgrade=False)
1205
if revision_id is not None:
1206
if revision_id == _mod_revision.NULL_REVISION:
1207
result.set_parent_ids([])
1209
result.set_parent_ids([revision_id])
1212
def destroy_workingtree(self):
1213
"""See BzrDir.destroy_workingtree."""
1214
raise errors.UnsupportedOperation(self.destroy_workingtree, self)
1216
def destroy_workingtree_metadata(self):
1217
"""See BzrDir.destroy_workingtree_metadata."""
1218
raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
1221
def get_branch_transport(self, branch_format):
1222
"""See BzrDir.get_branch_transport()."""
1223
if branch_format is None:
1224
return self.transport
1226
branch_format.get_format_string()
1227
except NotImplementedError:
1228
return self.transport
1229
raise errors.IncompatibleFormat(branch_format, self._format)
1231
def get_repository_transport(self, repository_format):
1232
"""See BzrDir.get_repository_transport()."""
1233
if repository_format is None:
1234
return self.transport
1236
repository_format.get_format_string()
1237
except NotImplementedError:
1238
return self.transport
1239
raise errors.IncompatibleFormat(repository_format, self._format)
1241
def get_workingtree_transport(self, workingtree_format):
1242
"""See BzrDir.get_workingtree_transport()."""
1243
if workingtree_format is None:
1244
return self.transport
1246
workingtree_format.get_format_string()
1247
except NotImplementedError:
1248
return self.transport
1249
raise errors.IncompatibleFormat(workingtree_format, self._format)
1251
def needs_format_conversion(self, format=None):
1252
"""See BzrDir.needs_format_conversion()."""
1253
# if the format is not the same as the system default,
1254
# an upgrade is needed.
1256
format = BzrDirFormat.get_default_format()
1257
return not isinstance(self._format, format.__class__)
1259
def open_branch(self, unsupported=False):
1260
"""See BzrDir.open_branch."""
1261
from bzrlib.branch import BzrBranchFormat4
1262
format = BzrBranchFormat4()
1263
self._check_supported(format, unsupported)
1264
return format.open(self, _found=True)
1266
def sprout(self, url, revision_id=None, force_new_repo=False,
1267
possible_transports=None, accelerator_tree=None,
1268
hardlink=False, stacked=False):
1269
"""See BzrDir.sprout()."""
1271
raise errors.UnstackableBranchFormat(
1272
self._format, self.root_transport.base)
1273
from bzrlib.workingtree import WorkingTreeFormat2
1274
self._make_tail(url)
1275
result = self._format._initialize_for_clone(url)
1277
self.open_repository().clone(result, revision_id=revision_id)
1278
except errors.NoRepositoryPresent:
1281
self.open_branch().sprout(result, revision_id=revision_id)
1282
except errors.NotBranchError:
1284
# we always want a working tree
1285
WorkingTreeFormat2().initialize(result,
1286
accelerator_tree=accelerator_tree,
1291
class BzrDir4(BzrDirPreSplitOut):
1292
"""A .bzr version 4 control object.
1294
This is a deprecated format and may be removed after sept 2006.
1297
def create_repository(self, shared=False):
1298
"""See BzrDir.create_repository."""
1299
return self._format.repository_format.initialize(self, shared)
1301
def needs_format_conversion(self, format=None):
1302
"""Format 4 dirs are always in need of conversion."""
1305
def open_repository(self):
1306
"""See BzrDir.open_repository."""
1307
from bzrlib.repofmt.weaverepo import RepositoryFormat4
1308
return RepositoryFormat4().open(self, _found=True)
1311
class BzrDir5(BzrDirPreSplitOut):
1312
"""A .bzr version 5 control object.
1314
This is a deprecated format and may be removed after sept 2006.
1317
def open_repository(self):
1318
"""See BzrDir.open_repository."""
1319
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1320
return RepositoryFormat5().open(self, _found=True)
1322
def open_workingtree(self, _unsupported=False,
1323
recommend_upgrade=True):
1324
"""See BzrDir.create_workingtree."""
1325
from bzrlib.workingtree import WorkingTreeFormat2
1326
wt_format = WorkingTreeFormat2()
1327
# we don't warn here about upgrades; that ought to be handled for the
1329
return wt_format.open(self, _found=True)
1332
class BzrDir6(BzrDirPreSplitOut):
1333
"""A .bzr version 6 control object.
1335
This is a deprecated format and may be removed after sept 2006.
1338
def open_repository(self):
1339
"""See BzrDir.open_repository."""
1340
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1341
return RepositoryFormat6().open(self, _found=True)
1343
def open_workingtree(self, _unsupported=False,
1344
recommend_upgrade=True):
1345
"""See BzrDir.create_workingtree."""
1346
# we don't warn here about upgrades; that ought to be handled for the
1348
from bzrlib.workingtree import WorkingTreeFormat2
1349
return WorkingTreeFormat2().open(self, _found=True)
1352
class BzrDirMeta1(BzrDir):
1353
"""A .bzr meta version 1 control object.
1355
This is the first control object where the
1356
individual aspects are really split out: there are separate repository,
1357
workingtree and branch subdirectories and any subset of the three can be
1358
present within a BzrDir.
1361
def can_convert_format(self):
1362
"""See BzrDir.can_convert_format()."""
1365
def create_branch(self):
1366
"""See BzrDir.create_branch."""
1367
return self._format.get_branch_format().initialize(self)
1369
def destroy_branch(self):
1370
"""See BzrDir.create_branch."""
1371
self.transport.delete_tree('branch')
1373
def create_repository(self, shared=False):
1374
"""See BzrDir.create_repository."""
1375
return self._format.repository_format.initialize(self, shared)
1377
def destroy_repository(self):
1378
"""See BzrDir.destroy_repository."""
1379
self.transport.delete_tree('repository')
1381
def create_workingtree(self, revision_id=None, from_branch=None,
1382
accelerator_tree=None, hardlink=False):
1383
"""See BzrDir.create_workingtree."""
1384
return self._format.workingtree_format.initialize(
1385
self, revision_id, from_branch=from_branch,
1386
accelerator_tree=accelerator_tree, hardlink=hardlink)
1388
def destroy_workingtree(self):
1389
"""See BzrDir.destroy_workingtree."""
1390
wt = self.open_workingtree(recommend_upgrade=False)
1391
repository = wt.branch.repository
1392
empty = repository.revision_tree(_mod_revision.NULL_REVISION)
1393
wt.revert(old_tree=empty)
1394
self.destroy_workingtree_metadata()
1396
def destroy_workingtree_metadata(self):
1397
self.transport.delete_tree('checkout')
1399
def find_branch_format(self):
1400
"""Find the branch 'format' for this bzrdir.
1402
This might be a synthetic object for e.g. RemoteBranch and SVN.
1404
from bzrlib.branch import BranchFormat
1405
return BranchFormat.find_format(self)
1407
def _get_mkdir_mode(self):
1408
"""Figure out the mode to use when creating a bzrdir subdir."""
1409
temp_control = lockable_files.LockableFiles(self.transport, '',
1410
lockable_files.TransportLock)
1411
return temp_control._dir_mode
1413
def get_branch_reference(self):
1414
"""See BzrDir.get_branch_reference()."""
1415
from bzrlib.branch import BranchFormat
1416
format = BranchFormat.find_format(self)
1417
return format.get_reference(self)
1419
def get_branch_transport(self, branch_format):
1420
"""See BzrDir.get_branch_transport()."""
1421
if branch_format is None:
1422
return self.transport.clone('branch')
1424
branch_format.get_format_string()
1425
except NotImplementedError:
1426
raise errors.IncompatibleFormat(branch_format, self._format)
1428
self.transport.mkdir('branch', mode=self._get_mkdir_mode())
1429
except errors.FileExists:
1431
return self.transport.clone('branch')
1433
def get_repository_transport(self, repository_format):
1434
"""See BzrDir.get_repository_transport()."""
1435
if repository_format is None:
1436
return self.transport.clone('repository')
1438
repository_format.get_format_string()
1439
except NotImplementedError:
1440
raise errors.IncompatibleFormat(repository_format, self._format)
1442
self.transport.mkdir('repository', mode=self._get_mkdir_mode())
1443
except errors.FileExists:
1445
return self.transport.clone('repository')
1447
def get_workingtree_transport(self, workingtree_format):
1448
"""See BzrDir.get_workingtree_transport()."""
1449
if workingtree_format is None:
1450
return self.transport.clone('checkout')
1452
workingtree_format.get_format_string()
1453
except NotImplementedError:
1454
raise errors.IncompatibleFormat(workingtree_format, self._format)
1456
self.transport.mkdir('checkout', mode=self._get_mkdir_mode())
1457
except errors.FileExists:
1459
return self.transport.clone('checkout')
1461
def needs_format_conversion(self, format=None):
1462
"""See BzrDir.needs_format_conversion()."""
1464
format = BzrDirFormat.get_default_format()
1465
if not isinstance(self._format, format.__class__):
1466
# it is not a meta dir format, conversion is needed.
1468
# we might want to push this down to the repository?
1470
if not isinstance(self.open_repository()._format,
1471
format.repository_format.__class__):
1472
# the repository needs an upgrade.
1474
except errors.NoRepositoryPresent:
1477
if not isinstance(self.open_branch()._format,
1478
format.get_branch_format().__class__):
1479
# the branch needs an upgrade.
1481
except errors.NotBranchError:
1484
my_wt = self.open_workingtree(recommend_upgrade=False)
1485
if not isinstance(my_wt._format,
1486
format.workingtree_format.__class__):
1487
# the workingtree needs an upgrade.
1489
except (errors.NoWorkingTree, errors.NotLocalUrl):
1493
def open_branch(self, unsupported=False):
1494
"""See BzrDir.open_branch."""
1495
format = self.find_branch_format()
1496
self._check_supported(format, unsupported)
1497
return format.open(self, _found=True)
1499
def open_repository(self, unsupported=False):
1500
"""See BzrDir.open_repository."""
1501
from bzrlib.repository import RepositoryFormat
1502
format = RepositoryFormat.find_format(self)
1503
self._check_supported(format, unsupported)
1504
return format.open(self, _found=True)
1506
def open_workingtree(self, unsupported=False,
1507
recommend_upgrade=True):
1508
"""See BzrDir.open_workingtree."""
1509
from bzrlib.workingtree import WorkingTreeFormat
1510
format = WorkingTreeFormat.find_format(self)
1511
self._check_supported(format, unsupported,
1513
basedir=self.root_transport.base)
1514
return format.open(self, _found=True)
1516
def _get_config(self):
1517
return config.BzrDirConfig(self.transport)
1520
class BzrDirFormat(object):
1521
"""An encapsulation of the initialization and open routines for a format.
1523
Formats provide three things:
1524
* An initialization routine,
1528
Formats are placed in a dict by their format string for reference
1529
during bzrdir opening. These should be subclasses of BzrDirFormat
1532
Once a format is deprecated, just deprecate the initialize and open
1533
methods on the format class. Do not deprecate the object, as the
1534
object will be created every system load.
1537
_default_format = None
1538
"""The default format used for new .bzr dirs."""
1541
"""The known formats."""
1543
_control_formats = []
1544
"""The registered control formats - .bzr, ....
1546
This is a list of BzrDirFormat objects.
1549
_control_server_formats = []
1550
"""The registered control server formats, e.g. RemoteBzrDirs.
1552
This is a list of BzrDirFormat objects.
1555
_lock_file_name = 'branch-lock'
1557
# _lock_class must be set in subclasses to the lock type, typ.
1558
# TransportLock or LockDir
1561
def find_format(klass, transport, _server_formats=True):
1562
"""Return the format present at transport."""
1564
formats = klass._control_server_formats + klass._control_formats
1566
formats = klass._control_formats
1567
for format in formats:
1569
return format.probe_transport(transport)
1570
except errors.NotBranchError:
1571
# this format does not find a control dir here.
1573
raise errors.NotBranchError(path=transport.base)
1576
def probe_transport(klass, transport):
1577
"""Return the .bzrdir style format present in a directory."""
1579
format_string = transport.get(".bzr/branch-format").read()
1580
except errors.NoSuchFile:
1581
raise errors.NotBranchError(path=transport.base)
1584
return klass._formats[format_string]
1586
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1589
def get_default_format(klass):
1590
"""Return the current default format."""
1591
return klass._default_format
1593
def get_format_string(self):
1594
"""Return the ASCII format string that identifies this format."""
1595
raise NotImplementedError(self.get_format_string)
1597
def get_format_description(self):
1598
"""Return the short description for this format."""
1599
raise NotImplementedError(self.get_format_description)
1601
def get_converter(self, format=None):
1602
"""Return the converter to use to convert bzrdirs needing converts.
1604
This returns a bzrlib.bzrdir.Converter object.
1606
This should return the best upgrader to step this format towards the
1607
current default format. In the case of plugins we can/should provide
1608
some means for them to extend the range of returnable converters.
1610
:param format: Optional format to override the default format of the
1613
raise NotImplementedError(self.get_converter)
1615
def initialize(self, url, possible_transports=None):
1616
"""Create a bzr control dir at this url and return an opened copy.
1618
Subclasses should typically override initialize_on_transport
1619
instead of this method.
1621
return self.initialize_on_transport(get_transport(url,
1622
possible_transports))
1624
def initialize_on_transport(self, transport):
1625
"""Initialize a new bzrdir in the base directory of a Transport."""
1626
# Since we don't have a .bzr directory, inherit the
1627
# mode from the root directory
1628
temp_control = lockable_files.LockableFiles(transport,
1629
'', lockable_files.TransportLock)
1630
temp_control._transport.mkdir('.bzr',
1631
# FIXME: RBC 20060121 don't peek under
1633
mode=temp_control._dir_mode)
1634
if sys.platform == 'win32' and isinstance(transport, LocalTransport):
1635
win32utils.set_file_attr_hidden(transport._abspath('.bzr'))
1636
file_mode = temp_control._file_mode
1638
bzrdir_transport = transport.clone('.bzr')
1639
utf8_files = [('README',
1640
"This is a Bazaar control directory.\n"
1641
"Do not change any files in this directory.\n"
1642
"See http://bazaar-vcs.org/ for more information about Bazaar.\n"),
1643
('branch-format', self.get_format_string()),
1645
# NB: no need to escape relative paths that are url safe.
1646
control_files = lockable_files.LockableFiles(bzrdir_transport,
1647
self._lock_file_name, self._lock_class)
1648
control_files.create_lock()
1649
control_files.lock_write()
1651
for (filename, content) in utf8_files:
1652
bzrdir_transport.put_bytes(filename, content,
1655
control_files.unlock()
1656
return self.open(transport, _found=True)
1658
def is_supported(self):
1659
"""Is this format supported?
1661
Supported formats must be initializable and openable.
1662
Unsupported formats may not support initialization or committing or
1663
some other features depending on the reason for not being supported.
1667
def same_model(self, target_format):
1668
return (self.repository_format.rich_root_data ==
1669
target_format.rich_root_data)
1672
def known_formats(klass):
1673
"""Return all the known formats.
1675
Concrete formats should override _known_formats.
1677
# There is double indirection here to make sure that control
1678
# formats used by more than one dir format will only be probed
1679
# once. This can otherwise be quite expensive for remote connections.
1681
for format in klass._control_formats:
1682
result.update(format._known_formats())
1686
def _known_formats(klass):
1687
"""Return the known format instances for this control format."""
1688
return set(klass._formats.values())
1690
def open(self, transport, _found=False):
1691
"""Return an instance of this format for the dir transport points at.
1693
_found is a private parameter, do not use it.
1696
found_format = BzrDirFormat.find_format(transport)
1697
if not isinstance(found_format, self.__class__):
1698
raise AssertionError("%s was asked to open %s, but it seems to need "
1700
% (self, transport, found_format))
1701
return self._open(transport)
1703
def _open(self, transport):
1704
"""Template method helper for opening BzrDirectories.
1706
This performs the actual open and any additional logic or parameter
1709
raise NotImplementedError(self._open)
1712
def register_format(klass, format):
1713
klass._formats[format.get_format_string()] = format
1716
def register_control_format(klass, format):
1717
"""Register a format that does not use '.bzr' for its control dir.
1719
TODO: This should be pulled up into a 'ControlDirFormat' base class
1720
which BzrDirFormat can inherit from, and renamed to register_format
1721
there. It has been done without that for now for simplicity of
1724
klass._control_formats.append(format)
1727
def register_control_server_format(klass, format):
1728
"""Register a control format for client-server environments.
1730
These formats will be tried before ones registered with
1731
register_control_format. This gives implementations that decide to the
1732
chance to grab it before anything looks at the contents of the format
1735
klass._control_server_formats.append(format)
1738
def _set_default_format(klass, format):
1739
"""Set default format (for testing behavior of defaults only)"""
1740
klass._default_format = format
1744
return self.get_format_string().rstrip()
1747
def unregister_format(klass, format):
1748
del klass._formats[format.get_format_string()]
1751
def unregister_control_format(klass, format):
1752
klass._control_formats.remove(format)
1755
class BzrDirFormat4(BzrDirFormat):
1756
"""Bzr dir format 4.
1758
This format is a combined format for working tree, branch and repository.
1760
- Format 1 working trees [always]
1761
- Format 4 branches [always]
1762
- Format 4 repositories [always]
1764
This format is deprecated: it indexes texts using a text it which is
1765
removed in format 5; write support for this format has been removed.
1768
_lock_class = lockable_files.TransportLock
1770
def get_format_string(self):
1771
"""See BzrDirFormat.get_format_string()."""
1772
return "Bazaar-NG branch, format 0.0.4\n"
1774
def get_format_description(self):
1775
"""See BzrDirFormat.get_format_description()."""
1776
return "All-in-one format 4"
1778
def get_converter(self, format=None):
1779
"""See BzrDirFormat.get_converter()."""
1780
# there is one and only one upgrade path here.
1781
return ConvertBzrDir4To5()
1783
def initialize_on_transport(self, transport):
1784
"""Format 4 branches cannot be created."""
1785
raise errors.UninitializableFormat(self)
1787
def is_supported(self):
1788
"""Format 4 is not supported.
1790
It is not supported because the model changed from 4 to 5 and the
1791
conversion logic is expensive - so doing it on the fly was not
1796
def _open(self, transport):
1797
"""See BzrDirFormat._open."""
1798
return BzrDir4(transport, self)
1800
def __return_repository_format(self):
1801
"""Circular import protection."""
1802
from bzrlib.repofmt.weaverepo import RepositoryFormat4
1803
return RepositoryFormat4()
1804
repository_format = property(__return_repository_format)
1807
class BzrDirFormat5(BzrDirFormat):
1808
"""Bzr control format 5.
1810
This format is a combined format for working tree, branch and repository.
1812
- Format 2 working trees [always]
1813
- Format 4 branches [always]
1814
- Format 5 repositories [always]
1815
Unhashed stores in the repository.
1818
_lock_class = lockable_files.TransportLock
1820
def get_format_string(self):
1821
"""See BzrDirFormat.get_format_string()."""
1822
return "Bazaar-NG branch, format 5\n"
1824
def get_format_description(self):
1825
"""See BzrDirFormat.get_format_description()."""
1826
return "All-in-one format 5"
1828
def get_converter(self, format=None):
1829
"""See BzrDirFormat.get_converter()."""
1830
# there is one and only one upgrade path here.
1831
return ConvertBzrDir5To6()
1833
def _initialize_for_clone(self, url):
1834
return self.initialize_on_transport(get_transport(url), _cloning=True)
1836
def initialize_on_transport(self, transport, _cloning=False):
1837
"""Format 5 dirs always have working tree, branch and repository.
1839
Except when they are being cloned.
1841
from bzrlib.branch import BzrBranchFormat4
1842
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1843
from bzrlib.workingtree import WorkingTreeFormat2
1844
result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
1845
RepositoryFormat5().initialize(result, _internal=True)
1847
branch = BzrBranchFormat4().initialize(result)
1849
WorkingTreeFormat2().initialize(result)
1850
except errors.NotLocalUrl:
1851
# Even though we can't access the working tree, we need to
1852
# create its control files.
1853
WorkingTreeFormat2()._stub_initialize_remote(branch)
1856
def _open(self, transport):
1857
"""See BzrDirFormat._open."""
1858
return BzrDir5(transport, self)
1860
def __return_repository_format(self):
1861
"""Circular import protection."""
1862
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1863
return RepositoryFormat5()
1864
repository_format = property(__return_repository_format)
1867
class BzrDirFormat6(BzrDirFormat):
1868
"""Bzr control format 6.
1870
This format is a combined format for working tree, branch and repository.
1872
- Format 2 working trees [always]
1873
- Format 4 branches [always]
1874
- Format 6 repositories [always]
1877
_lock_class = lockable_files.TransportLock
1879
def get_format_string(self):
1880
"""See BzrDirFormat.get_format_string()."""
1881
return "Bazaar-NG branch, format 6\n"
1883
def get_format_description(self):
1884
"""See BzrDirFormat.get_format_description()."""
1885
return "All-in-one format 6"
1887
def get_converter(self, format=None):
1888
"""See BzrDirFormat.get_converter()."""
1889
# there is one and only one upgrade path here.
1890
return ConvertBzrDir6ToMeta()
1892
def _initialize_for_clone(self, url):
1893
return self.initialize_on_transport(get_transport(url), _cloning=True)
1895
def initialize_on_transport(self, transport, _cloning=False):
1896
"""Format 6 dirs always have working tree, branch and repository.
1898
Except when they are being cloned.
1900
from bzrlib.branch import BzrBranchFormat4
1901
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1902
from bzrlib.workingtree import WorkingTreeFormat2
1903
result = super(BzrDirFormat6, self).initialize_on_transport(transport)
1904
RepositoryFormat6().initialize(result, _internal=True)
1906
branch = BzrBranchFormat4().initialize(result)
1908
WorkingTreeFormat2().initialize(result)
1909
except errors.NotLocalUrl:
1910
# Even though we can't access the working tree, we need to
1911
# create its control files.
1912
WorkingTreeFormat2()._stub_initialize_remote(branch)
1915
def _open(self, transport):
1916
"""See BzrDirFormat._open."""
1917
return BzrDir6(transport, self)
1919
def __return_repository_format(self):
1920
"""Circular import protection."""
1921
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1922
return RepositoryFormat6()
1923
repository_format = property(__return_repository_format)
1926
class BzrDirMetaFormat1(BzrDirFormat):
1927
"""Bzr meta control format 1
1929
This is the first format with split out working tree, branch and repository
1932
- Format 3 working trees [optional]
1933
- Format 5 branches [optional]
1934
- Format 7 repositories [optional]
1937
_lock_class = lockdir.LockDir
1940
self._workingtree_format = None
1941
self._branch_format = None
1943
def __eq__(self, other):
1944
if other.__class__ is not self.__class__:
1946
if other.repository_format != self.repository_format:
1948
if other.workingtree_format != self.workingtree_format:
1952
def __ne__(self, other):
1953
return not self == other
1955
def get_branch_format(self):
1956
if self._branch_format is None:
1957
from bzrlib.branch import BranchFormat
1958
self._branch_format = BranchFormat.get_default_format()
1959
return self._branch_format
1961
def set_branch_format(self, format):
1962
self._branch_format = format
1964
def get_converter(self, format=None):
1965
"""See BzrDirFormat.get_converter()."""
1967
format = BzrDirFormat.get_default_format()
1968
if not isinstance(self, format.__class__):
1969
# converting away from metadir is not implemented
1970
raise NotImplementedError(self.get_converter)
1971
return ConvertMetaToMeta(format)
1973
def get_format_string(self):
1974
"""See BzrDirFormat.get_format_string()."""
1975
return "Bazaar-NG meta directory, format 1\n"
1977
def get_format_description(self):
1978
"""See BzrDirFormat.get_format_description()."""
1979
return "Meta directory format 1"
1981
def _open(self, transport):
1982
"""See BzrDirFormat._open."""
1983
return BzrDirMeta1(transport, self)
1985
def __return_repository_format(self):
1986
"""Circular import protection."""
1987
if getattr(self, '_repository_format', None):
1988
return self._repository_format
1989
from bzrlib.repository import RepositoryFormat
1990
return RepositoryFormat.get_default_format()
1992
def __set_repository_format(self, value):
1993
"""Allow changing the repository format for metadir formats."""
1994
self._repository_format = value
1996
repository_format = property(__return_repository_format, __set_repository_format)
1998
def __get_workingtree_format(self):
1999
if self._workingtree_format is None:
2000
from bzrlib.workingtree import WorkingTreeFormat
2001
self._workingtree_format = WorkingTreeFormat.get_default_format()
2002
return self._workingtree_format
2004
def __set_workingtree_format(self, wt_format):
2005
self._workingtree_format = wt_format
2007
workingtree_format = property(__get_workingtree_format,
2008
__set_workingtree_format)
2011
# Register bzr control format
2012
BzrDirFormat.register_control_format(BzrDirFormat)
2014
# Register bzr formats
2015
BzrDirFormat.register_format(BzrDirFormat4())
2016
BzrDirFormat.register_format(BzrDirFormat5())
2017
BzrDirFormat.register_format(BzrDirFormat6())
2018
__default_format = BzrDirMetaFormat1()
2019
BzrDirFormat.register_format(__default_format)
2020
BzrDirFormat._default_format = __default_format
2023
class Converter(object):
2024
"""Converts a disk format object from one format to another."""
2026
def convert(self, to_convert, pb):
2027
"""Perform the conversion of to_convert, giving feedback via pb.
2029
:param to_convert: The disk object to convert.
2030
:param pb: a progress bar to use for progress information.
2033
def step(self, message):
2034
"""Update the pb by a step."""
2036
self.pb.update(message, self.count, self.total)
2039
class ConvertBzrDir4To5(Converter):
2040
"""Converts format 4 bzr dirs to format 5."""
2043
super(ConvertBzrDir4To5, self).__init__()
2044
self.converted_revs = set()
2045
self.absent_revisions = set()
2049
def convert(self, to_convert, pb):
2050
"""See Converter.convert()."""
2051
self.bzrdir = to_convert
2053
self.pb.note('starting upgrade from format 4 to 5')
2054
if isinstance(self.bzrdir.transport, LocalTransport):
2055
self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
2056
self._convert_to_weaves()
2057
return BzrDir.open(self.bzrdir.root_transport.base)
2059
def _convert_to_weaves(self):
2060
self.pb.note('note: upgrade may be faster if all store files are ungzipped first')
2063
stat = self.bzrdir.transport.stat('weaves')
2064
if not S_ISDIR(stat.st_mode):
2065
self.bzrdir.transport.delete('weaves')
2066
self.bzrdir.transport.mkdir('weaves')
2067
except errors.NoSuchFile:
2068
self.bzrdir.transport.mkdir('weaves')
2069
# deliberately not a WeaveFile as we want to build it up slowly.
2070
self.inv_weave = Weave('inventory')
2071
# holds in-memory weaves for all files
2072
self.text_weaves = {}
2073
self.bzrdir.transport.delete('branch-format')
2074
self.branch = self.bzrdir.open_branch()
2075
self._convert_working_inv()
2076
rev_history = self.branch.revision_history()
2077
# to_read is a stack holding the revisions we still need to process;
2078
# appending to it adds new highest-priority revisions
2079
self.known_revisions = set(rev_history)
2080
self.to_read = rev_history[-1:]
2082
rev_id = self.to_read.pop()
2083
if (rev_id not in self.revisions
2084
and rev_id not in self.absent_revisions):
2085
self._load_one_rev(rev_id)
2087
to_import = self._make_order()
2088
for i, rev_id in enumerate(to_import):
2089
self.pb.update('converting revision', i, len(to_import))
2090
self._convert_one_rev(rev_id)
2092
self._write_all_weaves()
2093
self._write_all_revs()
2094
self.pb.note('upgraded to weaves:')
2095
self.pb.note(' %6d revisions and inventories', len(self.revisions))
2096
self.pb.note(' %6d revisions not present', len(self.absent_revisions))
2097
self.pb.note(' %6d texts', self.text_count)
2098
self._cleanup_spare_files_after_format4()
2099
self.branch._transport.put_bytes(
2101
BzrDirFormat5().get_format_string(),
2102
mode=self.bzrdir._get_file_mode())
2104
def _cleanup_spare_files_after_format4(self):
2105
# FIXME working tree upgrade foo.
2106
for n in 'merged-patches', 'pending-merged-patches':
2108
## assert os.path.getsize(p) == 0
2109
self.bzrdir.transport.delete(n)
2110
except errors.NoSuchFile:
2112
self.bzrdir.transport.delete_tree('inventory-store')
2113
self.bzrdir.transport.delete_tree('text-store')
2115
def _convert_working_inv(self):
2116
inv = xml4.serializer_v4.read_inventory(
2117
self.branch._transport.get('inventory'))
2118
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv, working=True)
2119
self.branch._transport.put_bytes('inventory', new_inv_xml,
2120
mode=self.bzrdir._get_file_mode())
2122
def _write_all_weaves(self):
2123
controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
2124
weave_transport = self.bzrdir.transport.clone('weaves')
2125
weaves = WeaveStore(weave_transport, prefixed=False)
2126
transaction = WriteTransaction()
2130
for file_id, file_weave in self.text_weaves.items():
2131
self.pb.update('writing weave', i, len(self.text_weaves))
2132
weaves._put_weave(file_id, file_weave, transaction)
2134
self.pb.update('inventory', 0, 1)
2135
controlweaves._put_weave('inventory', self.inv_weave, transaction)
2136
self.pb.update('inventory', 1, 1)
2140
def _write_all_revs(self):
2141
"""Write all revisions out in new form."""
2142
self.bzrdir.transport.delete_tree('revision-store')
2143
self.bzrdir.transport.mkdir('revision-store')
2144
revision_transport = self.bzrdir.transport.clone('revision-store')
2146
from bzrlib.xml5 import serializer_v5
2147
from bzrlib.repofmt.weaverepo import RevisionTextStore
2148
revision_store = RevisionTextStore(revision_transport,
2149
serializer_v5, False, versionedfile.PrefixMapper(),
2150
lambda:True, lambda:True)
2152
for i, rev_id in enumerate(self.converted_revs):
2153
self.pb.update('write revision', i, len(self.converted_revs))
2154
text = serializer_v5.write_revision_to_string(
2155
self.revisions[rev_id])
2157
revision_store.add_lines(key, None, osutils.split_lines(text))
2161
def _load_one_rev(self, rev_id):
2162
"""Load a revision object into memory.
2164
Any parents not either loaded or abandoned get queued to be
2166
self.pb.update('loading revision',
2167
len(self.revisions),
2168
len(self.known_revisions))
2169
if not self.branch.repository.has_revision(rev_id):
2171
self.pb.note('revision {%s} not present in branch; '
2172
'will be converted as a ghost',
2174
self.absent_revisions.add(rev_id)
2176
rev = self.branch.repository.get_revision(rev_id)
2177
for parent_id in rev.parent_ids:
2178
self.known_revisions.add(parent_id)
2179
self.to_read.append(parent_id)
2180
self.revisions[rev_id] = rev
2182
def _load_old_inventory(self, rev_id):
2183
old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
2184
inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
2185
inv.revision_id = rev_id
2186
rev = self.revisions[rev_id]
2189
def _load_updated_inventory(self, rev_id):
2190
inv_xml = self.inv_weave.get_text(rev_id)
2191
inv = xml5.serializer_v5.read_inventory_from_string(inv_xml, rev_id)
2194
def _convert_one_rev(self, rev_id):
2195
"""Convert revision and all referenced objects to new format."""
2196
rev = self.revisions[rev_id]
2197
inv = self._load_old_inventory(rev_id)
2198
present_parents = [p for p in rev.parent_ids
2199
if p not in self.absent_revisions]
2200
self._convert_revision_contents(rev, inv, present_parents)
2201
self._store_new_inv(rev, inv, present_parents)
2202
self.converted_revs.add(rev_id)
2204
def _store_new_inv(self, rev, inv, present_parents):
2205
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
2206
new_inv_sha1 = sha_string(new_inv_xml)
2207
self.inv_weave.add_lines(rev.revision_id,
2209
new_inv_xml.splitlines(True))
2210
rev.inventory_sha1 = new_inv_sha1
2212
def _convert_revision_contents(self, rev, inv, present_parents):
2213
"""Convert all the files within a revision.
2215
Also upgrade the inventory to refer to the text revision ids."""
2216
rev_id = rev.revision_id
2217
mutter('converting texts of revision {%s}',
2219
parent_invs = map(self._load_updated_inventory, present_parents)
2220
entries = inv.iter_entries()
2222
for path, ie in entries:
2223
self._convert_file_version(rev, ie, parent_invs)
2225
def _convert_file_version(self, rev, ie, parent_invs):
2226
"""Convert one version of one file.
2228
The file needs to be added into the weave if it is a merge
2229
of >=2 parents or if it's changed from its parent.
2231
file_id = ie.file_id
2232
rev_id = rev.revision_id
2233
w = self.text_weaves.get(file_id)
2236
self.text_weaves[file_id] = w
2237
text_changed = False
2238
parent_candiate_entries = ie.parent_candidates(parent_invs)
2239
heads = graph.Graph(self).heads(parent_candiate_entries.keys())
2240
# XXX: Note that this is unordered - and this is tolerable because
2241
# the previous code was also unordered.
2242
previous_entries = dict((head, parent_candiate_entries[head]) for head
2244
self.snapshot_ie(previous_entries, ie, w, rev_id)
2247
@symbol_versioning.deprecated_method(symbol_versioning.one_one)
2248
def get_parents(self, revision_ids):
2249
for revision_id in revision_ids:
2250
yield self.revisions[revision_id].parent_ids
2252
def get_parent_map(self, revision_ids):
2253
"""See graph._StackedParentsProvider.get_parent_map"""
2254
return dict((revision_id, self.revisions[revision_id])
2255
for revision_id in revision_ids
2256
if revision_id in self.revisions)
2258
def snapshot_ie(self, previous_revisions, ie, w, rev_id):
2259
# TODO: convert this logic, which is ~= snapshot to
2260
# a call to:. This needs the path figured out. rather than a work_tree
2261
# a v4 revision_tree can be given, or something that looks enough like
2262
# one to give the file content to the entry if it needs it.
2263
# and we need something that looks like a weave store for snapshot to
2265
#ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
2266
if len(previous_revisions) == 1:
2267
previous_ie = previous_revisions.values()[0]
2268
if ie._unchanged(previous_ie):
2269
ie.revision = previous_ie.revision
2272
text = self.branch.repository._text_store.get(ie.text_id)
2273
file_lines = text.readlines()
2274
w.add_lines(rev_id, previous_revisions, file_lines)
2275
self.text_count += 1
2277
w.add_lines(rev_id, previous_revisions, [])
2278
ie.revision = rev_id
2280
def _make_order(self):
2281
"""Return a suitable order for importing revisions.
2283
The order must be such that an revision is imported after all
2284
its (present) parents.
2286
todo = set(self.revisions.keys())
2287
done = self.absent_revisions.copy()
2290
# scan through looking for a revision whose parents
2292
for rev_id in sorted(list(todo)):
2293
rev = self.revisions[rev_id]
2294
parent_ids = set(rev.parent_ids)
2295
if parent_ids.issubset(done):
2296
# can take this one now
2297
order.append(rev_id)
2303
class ConvertBzrDir5To6(Converter):
2304
"""Converts format 5 bzr dirs to format 6."""
2306
def convert(self, to_convert, pb):
2307
"""See Converter.convert()."""
2308
self.bzrdir = to_convert
2310
self.pb.note('starting upgrade from format 5 to 6')
2311
self._convert_to_prefixed()
2312
return BzrDir.open(self.bzrdir.root_transport.base)
2314
def _convert_to_prefixed(self):
2315
from bzrlib.store import TransportStore
2316
self.bzrdir.transport.delete('branch-format')
2317
for store_name in ["weaves", "revision-store"]:
2318
self.pb.note("adding prefixes to %s" % store_name)
2319
store_transport = self.bzrdir.transport.clone(store_name)
2320
store = TransportStore(store_transport, prefixed=True)
2321
for urlfilename in store_transport.list_dir('.'):
2322
filename = urlutils.unescape(urlfilename)
2323
if (filename.endswith(".weave") or
2324
filename.endswith(".gz") or
2325
filename.endswith(".sig")):
2326
file_id, suffix = os.path.splitext(filename)
2330
new_name = store._mapper.map((file_id,)) + suffix
2331
# FIXME keep track of the dirs made RBC 20060121
2333
store_transport.move(filename, new_name)
2334
except errors.NoSuchFile: # catches missing dirs strangely enough
2335
store_transport.mkdir(osutils.dirname(new_name))
2336
store_transport.move(filename, new_name)
2337
self.bzrdir.transport.put_bytes(
2339
BzrDirFormat6().get_format_string(),
2340
mode=self.bzrdir._get_file_mode())
2343
class ConvertBzrDir6ToMeta(Converter):
2344
"""Converts format 6 bzr dirs to metadirs."""
2346
def convert(self, to_convert, pb):
2347
"""See Converter.convert()."""
2348
from bzrlib.repofmt.weaverepo import RepositoryFormat7
2349
from bzrlib.branch import BzrBranchFormat5
2350
self.bzrdir = to_convert
2353
self.total = 20 # the steps we know about
2354
self.garbage_inventories = []
2355
self.dir_mode = self.bzrdir._get_dir_mode()
2356
self.file_mode = self.bzrdir._get_file_mode()
2358
self.pb.note('starting upgrade from format 6 to metadir')
2359
self.bzrdir.transport.put_bytes(
2361
"Converting to format 6",
2362
mode=self.file_mode)
2363
# its faster to move specific files around than to open and use the apis...
2364
# first off, nuke ancestry.weave, it was never used.
2366
self.step('Removing ancestry.weave')
2367
self.bzrdir.transport.delete('ancestry.weave')
2368
except errors.NoSuchFile:
2370
# find out whats there
2371
self.step('Finding branch files')
2372
last_revision = self.bzrdir.open_branch().last_revision()
2373
bzrcontents = self.bzrdir.transport.list_dir('.')
2374
for name in bzrcontents:
2375
if name.startswith('basis-inventory.'):
2376
self.garbage_inventories.append(name)
2377
# create new directories for repository, working tree and branch
2378
repository_names = [('inventory.weave', True),
2379
('revision-store', True),
2381
self.step('Upgrading repository ')
2382
self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
2383
self.make_lock('repository')
2384
# we hard code the formats here because we are converting into
2385
# the meta format. The meta format upgrader can take this to a
2386
# future format within each component.
2387
self.put_format('repository', RepositoryFormat7())
2388
for entry in repository_names:
2389
self.move_entry('repository', entry)
2391
self.step('Upgrading branch ')
2392
self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
2393
self.make_lock('branch')
2394
self.put_format('branch', BzrBranchFormat5())
2395
branch_files = [('revision-history', True),
2396
('branch-name', True),
2398
for entry in branch_files:
2399
self.move_entry('branch', entry)
2401
checkout_files = [('pending-merges', True),
2402
('inventory', True),
2403
('stat-cache', False)]
2404
# If a mandatory checkout file is not present, the branch does not have
2405
# a functional checkout. Do not create a checkout in the converted
2407
for name, mandatory in checkout_files:
2408
if mandatory and name not in bzrcontents:
2409
has_checkout = False
2413
if not has_checkout:
2414
self.pb.note('No working tree.')
2415
# If some checkout files are there, we may as well get rid of them.
2416
for name, mandatory in checkout_files:
2417
if name in bzrcontents:
2418
self.bzrdir.transport.delete(name)
2420
from bzrlib.workingtree import WorkingTreeFormat3
2421
self.step('Upgrading working tree')
2422
self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
2423
self.make_lock('checkout')
2425
'checkout', WorkingTreeFormat3())
2426
self.bzrdir.transport.delete_multi(
2427
self.garbage_inventories, self.pb)
2428
for entry in checkout_files:
2429
self.move_entry('checkout', entry)
2430
if last_revision is not None:
2431
self.bzrdir.transport.put_bytes(
2432
'checkout/last-revision', last_revision)
2433
self.bzrdir.transport.put_bytes(
2435
BzrDirMetaFormat1().get_format_string(),
2436
mode=self.file_mode)
2437
return BzrDir.open(self.bzrdir.root_transport.base)
2439
def make_lock(self, name):
2440
"""Make a lock for the new control dir name."""
2441
self.step('Make %s lock' % name)
2442
ld = lockdir.LockDir(self.bzrdir.transport,
2444
file_modebits=self.file_mode,
2445
dir_modebits=self.dir_mode)
2448
def move_entry(self, new_dir, entry):
2449
"""Move then entry name into new_dir."""
2451
mandatory = entry[1]
2452
self.step('Moving %s' % name)
2454
self.bzrdir.transport.move(name, '%s/%s' % (new_dir, name))
2455
except errors.NoSuchFile:
2459
def put_format(self, dirname, format):
2460
self.bzrdir.transport.put_bytes('%s/format' % dirname,
2461
format.get_format_string(),
2465
class ConvertMetaToMeta(Converter):
2466
"""Converts the components of metadirs."""
2468
def __init__(self, target_format):
2469
"""Create a metadir to metadir converter.
2471
:param target_format: The final metadir format that is desired.
2473
self.target_format = target_format
2475
def convert(self, to_convert, pb):
2476
"""See Converter.convert()."""
2477
self.bzrdir = to_convert
2481
self.step('checking repository format')
2483
repo = self.bzrdir.open_repository()
2484
except errors.NoRepositoryPresent:
2487
if not isinstance(repo._format, self.target_format.repository_format.__class__):
2488
from bzrlib.repository import CopyConverter
2489
self.pb.note('starting repository conversion')
2490
converter = CopyConverter(self.target_format.repository_format)
2491
converter.convert(repo, pb)
2493
branch = self.bzrdir.open_branch()
2494
except errors.NotBranchError:
2497
# TODO: conversions of Branch and Tree should be done by
2498
# InterXFormat lookups/some sort of registry.
2499
# Avoid circular imports
2500
from bzrlib import branch as _mod_branch
2501
old = branch._format.__class__
2502
new = self.target_format.get_branch_format().__class__
2504
if (old == _mod_branch.BzrBranchFormat5 and
2505
new in (_mod_branch.BzrBranchFormat6,
2506
_mod_branch.BzrBranchFormat7)):
2507
branch_converter = _mod_branch.Converter5to6()
2508
elif (old == _mod_branch.BzrBranchFormat6 and
2509
new == _mod_branch.BzrBranchFormat7):
2510
branch_converter = _mod_branch.Converter6to7()
2512
raise errors.BadConversionTarget("No converter", new)
2513
branch_converter.convert(branch)
2514
branch = self.bzrdir.open_branch()
2515
old = branch._format.__class__
2517
tree = self.bzrdir.open_workingtree(recommend_upgrade=False)
2518
except (errors.NoWorkingTree, errors.NotLocalUrl):
2521
# TODO: conversions of Branch and Tree should be done by
2522
# InterXFormat lookups
2523
if (isinstance(tree, workingtree.WorkingTree3) and
2524
not isinstance(tree, workingtree_4.WorkingTree4) and
2525
isinstance(self.target_format.workingtree_format,
2526
workingtree_4.WorkingTreeFormat4)):
2527
workingtree_4.Converter3to4().convert(tree)
2531
# This is not in remote.py because it's small, and needs to be registered.
2532
# Putting it in remote.py creates a circular import problem.
2533
# we can make it a lazy object if the control formats is turned into something
2535
class RemoteBzrDirFormat(BzrDirMetaFormat1):
2536
"""Format representing bzrdirs accessed via a smart server"""
2538
def get_format_description(self):
2539
return 'bzr remote bzrdir'
2542
def probe_transport(klass, transport):
2543
"""Return a RemoteBzrDirFormat object if it looks possible."""
2545
medium = transport.get_smart_medium()
2546
except (NotImplementedError, AttributeError,
2547
errors.TransportNotPossible, errors.NoSmartMedium,
2548
errors.SmartProtocolError):
2549
# no smart server, so not a branch for this format type.
2550
raise errors.NotBranchError(path=transport.base)
2552
# Decline to open it if the server doesn't support our required
2553
# version (3) so that the VFS-based transport will do it.
2554
if medium.should_probe():
2556
server_version = medium.protocol_version()
2557
except errors.SmartProtocolError:
2558
# Apparently there's no usable smart server there, even though
2559
# the medium supports the smart protocol.
2560
raise errors.NotBranchError(path=transport.base)
2561
if server_version != '2':
2562
raise errors.NotBranchError(path=transport.base)
2565
def initialize_on_transport(self, transport):
2567
# hand off the request to the smart server
2568
client_medium = transport.get_smart_medium()
2569
except errors.NoSmartMedium:
2570
# TODO: lookup the local format from a server hint.
2571
local_dir_format = BzrDirMetaFormat1()
2572
return local_dir_format.initialize_on_transport(transport)
2573
client = _SmartClient(client_medium)
2574
path = client.remote_path_from_transport(transport)
2575
response = client.call('BzrDirFormat.initialize', path)
2576
if response[0] != 'ok':
2577
raise errors.SmartProtocolError('unexpected response code %s' % (response,))
2578
return remote.RemoteBzrDir(transport)
2580
def _open(self, transport):
2581
return remote.RemoteBzrDir(transport)
2583
def __eq__(self, other):
2584
if not isinstance(other, RemoteBzrDirFormat):
2586
return self.get_format_description() == other.get_format_description()
2589
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
2592
class BzrDirFormatInfo(object):
2594
def __init__(self, native, deprecated, hidden, experimental):
2595
self.deprecated = deprecated
2596
self.native = native
2597
self.hidden = hidden
2598
self.experimental = experimental
2601
class BzrDirFormatRegistry(registry.Registry):
2602
"""Registry of user-selectable BzrDir subformats.
2604
Differs from BzrDirFormat._control_formats in that it provides sub-formats,
2605
e.g. BzrDirMeta1 with weave repository. Also, it's more user-oriented.
2609
"""Create a BzrDirFormatRegistry."""
2610
self._aliases = set()
2611
super(BzrDirFormatRegistry, self).__init__()
2614
"""Return a set of the format names which are aliases."""
2615
return frozenset(self._aliases)
2617
def register_metadir(self, key,
2618
repository_format, help, native=True, deprecated=False,
2624
"""Register a metadir subformat.
2626
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
2627
by the Repository format.
2629
:param repository_format: The fully-qualified repository format class
2631
:param branch_format: Fully-qualified branch format class name as
2633
:param tree_format: Fully-qualified tree format class name as
2636
# This should be expanded to support setting WorkingTree and Branch
2637
# formats, once BzrDirMetaFormat1 supports that.
2638
def _load(full_name):
2639
mod_name, factory_name = full_name.rsplit('.', 1)
2641
mod = __import__(mod_name, globals(), locals(),
2643
except ImportError, e:
2644
raise ImportError('failed to load %s: %s' % (full_name, e))
2646
factory = getattr(mod, factory_name)
2647
except AttributeError:
2648
raise AttributeError('no factory %s in module %r'
2653
bd = BzrDirMetaFormat1()
2654
if branch_format is not None:
2655
bd.set_branch_format(_load(branch_format))
2656
if tree_format is not None:
2657
bd.workingtree_format = _load(tree_format)
2658
if repository_format is not None:
2659
bd.repository_format = _load(repository_format)
2661
self.register(key, helper, help, native, deprecated, hidden,
2662
experimental, alias)
2664
def register(self, key, factory, help, native=True, deprecated=False,
2665
hidden=False, experimental=False, alias=False):
2666
"""Register a BzrDirFormat factory.
2668
The factory must be a callable that takes one parameter: the key.
2669
It must produce an instance of the BzrDirFormat when called.
2671
This function mainly exists to prevent the info object from being
2674
registry.Registry.register(self, key, factory, help,
2675
BzrDirFormatInfo(native, deprecated, hidden, experimental))
2677
self._aliases.add(key)
2679
def register_lazy(self, key, module_name, member_name, help, native=True,
2680
deprecated=False, hidden=False, experimental=False, alias=False):
2681
registry.Registry.register_lazy(self, key, module_name, member_name,
2682
help, BzrDirFormatInfo(native, deprecated, hidden, experimental))
2684
self._aliases.add(key)
2686
def set_default(self, key):
2687
"""Set the 'default' key to be a clone of the supplied key.
2689
This method must be called once and only once.
2691
registry.Registry.register(self, 'default', self.get(key),
2692
self.get_help(key), info=self.get_info(key))
2693
self._aliases.add('default')
2695
def set_default_repository(self, key):
2696
"""Set the FormatRegistry default and Repository default.
2698
This is a transitional method while Repository.set_default_format
2701
if 'default' in self:
2702
self.remove('default')
2703
self.set_default(key)
2704
format = self.get('default')()
2706
def make_bzrdir(self, key):
2707
return self.get(key)()
2709
def help_topic(self, topic):
2710
output = textwrap.dedent("""\
2711
These formats can be used for creating branches, working trees, and
2715
default_realkey = None
2716
default_help = self.get_help('default')
2718
for key in self.keys():
2719
if key == 'default':
2721
help = self.get_help(key)
2722
if help == default_help:
2723
default_realkey = key
2725
help_pairs.append((key, help))
2727
def wrapped(key, help, info):
2729
help = '(native) ' + help
2730
return ':%s:\n%s\n\n' % (key,
2731
textwrap.fill(help, initial_indent=' ',
2732
subsequent_indent=' '))
2733
if default_realkey is not None:
2734
output += wrapped(default_realkey, '(default) %s' % default_help,
2735
self.get_info('default'))
2736
deprecated_pairs = []
2737
experimental_pairs = []
2738
for key, help in help_pairs:
2739
info = self.get_info(key)
2742
elif info.deprecated:
2743
deprecated_pairs.append((key, help))
2744
elif info.experimental:
2745
experimental_pairs.append((key, help))
2747
output += wrapped(key, help, info)
2748
if len(experimental_pairs) > 0:
2749
output += "Experimental formats are shown below.\n\n"
2750
for key, help in experimental_pairs:
2751
info = self.get_info(key)
2752
output += wrapped(key, help, info)
2753
if len(deprecated_pairs) > 0:
2754
output += "Deprecated formats are shown below.\n\n"
2755
for key, help in deprecated_pairs:
2756
info = self.get_info(key)
2757
output += wrapped(key, help, info)
2762
class RepositoryAcquisitionPolicy(object):
2763
"""Abstract base class for repository acquisition policies.
2765
A repository acquisition policy decides how a BzrDir acquires a repository
2766
for a branch that is being created. The most basic policy decision is
2767
whether to create a new repository or use an existing one.
2769
def __init__(self, stack_on, stack_on_pwd, require_stacking):
2772
:param stack_on: A location to stack on
2773
:param stack_on_pwd: If stack_on is relative, the location it is
2775
:param require_stacking: If True, it is a failure to not stack.
2777
self._stack_on = stack_on
2778
self._stack_on_pwd = stack_on_pwd
2779
self._require_stacking = require_stacking
2781
def configure_branch(self, branch):
2782
"""Apply any configuration data from this policy to the branch.
2784
Default implementation sets repository stacking.
2786
if self._stack_on is None:
2788
if self._stack_on_pwd is None:
2789
stack_on = self._stack_on
2792
stack_on = urlutils.rebase_url(self._stack_on,
2794
branch.bzrdir.root_transport.base)
2795
except errors.InvalidRebaseURLs:
2796
stack_on = self._get_full_stack_on()
2798
branch.set_stacked_on_url(stack_on)
2799
except errors.UnstackableBranchFormat:
2800
if self._require_stacking:
2803
def _get_full_stack_on(self):
2804
"""Get a fully-qualified URL for the stack_on location."""
2805
if self._stack_on is None:
2807
if self._stack_on_pwd is None:
2808
return self._stack_on
2810
return urlutils.join(self._stack_on_pwd, self._stack_on)
2812
def _add_fallback(self, repository):
2813
"""Add a fallback to the supplied repository, if stacking is set."""
2814
stack_on = self._get_full_stack_on()
2815
if stack_on is None:
2817
stacked_dir = BzrDir.open(stack_on)
2819
stacked_repo = stacked_dir.open_branch().repository
2820
except errors.NotBranchError:
2821
stacked_repo = stacked_dir.open_repository()
2823
repository.add_fallback_repository(stacked_repo)
2824
except errors.UnstackableRepositoryFormat:
2825
if self._require_stacking:
2828
def acquire_repository(self, make_working_trees=None, shared=False):
2829
"""Acquire a repository for this bzrdir.
2831
Implementations may create a new repository or use a pre-exising
2833
:param make_working_trees: If creating a repository, set
2834
make_working_trees to this value (if non-None)
2835
:param shared: If creating a repository, make it shared if True
2836
:return: A repository
2838
raise NotImplemented(RepositoryAcquisitionPolicy.acquire_repository)
2841
class CreateRepository(RepositoryAcquisitionPolicy):
2842
"""A policy of creating a new repository"""
2844
def __init__(self, bzrdir, stack_on=None, stack_on_pwd=None,
2845
require_stacking=False):
2848
:param bzrdir: The bzrdir to create the repository on.
2849
:param stack_on: A location to stack on
2850
:param stack_on_pwd: If stack_on is relative, the location it is
2853
RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
2855
self._bzrdir = bzrdir
2857
def acquire_repository(self, make_working_trees=None, shared=False):
2858
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
2860
Creates the desired repository in the bzrdir we already have.
2862
repository = self._bzrdir.create_repository(shared=shared)
2863
self._add_fallback(repository)
2864
if make_working_trees is not None:
2865
repository.set_make_working_trees(make_working_trees)
2869
class UseExistingRepository(RepositoryAcquisitionPolicy):
2870
"""A policy of reusing an existing repository"""
2872
def __init__(self, repository, stack_on=None, stack_on_pwd=None,
2873
require_stacking=False):
2876
:param repository: The repository to use.
2877
:param stack_on: A location to stack on
2878
:param stack_on_pwd: If stack_on is relative, the location it is
2881
RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
2883
self._repository = repository
2885
def acquire_repository(self, make_working_trees=None, shared=False):
2886
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
2888
Returns an existing repository to use
2890
self._add_fallback(self._repository)
2891
return self._repository
2894
format_registry = BzrDirFormatRegistry()
2895
format_registry.register('weave', BzrDirFormat6,
2896
'Pre-0.8 format. Slower than knit and does not'
2897
' support checkouts or shared repositories.',
2899
format_registry.register_metadir('knit',
2900
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2901
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
2902
branch_format='bzrlib.branch.BzrBranchFormat5',
2903
tree_format='bzrlib.workingtree.WorkingTreeFormat3')
2904
format_registry.register_metadir('metaweave',
2905
'bzrlib.repofmt.weaverepo.RepositoryFormat7',
2906
'Transitional format in 0.8. Slower than knit.',
2907
branch_format='bzrlib.branch.BzrBranchFormat5',
2908
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
2910
format_registry.register_metadir('dirstate',
2911
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2912
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
2913
'above when accessed over the network.',
2914
branch_format='bzrlib.branch.BzrBranchFormat5',
2915
# this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
2916
# directly from workingtree_4 triggers a circular import.
2917
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2919
format_registry.register_metadir('dirstate-tags',
2920
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2921
help='New in 0.15: Fast local operations and improved scaling for '
2922
'network operations. Additionally adds support for tags.'
2923
' Incompatible with bzr < 0.15.',
2924
branch_format='bzrlib.branch.BzrBranchFormat6',
2925
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2927
format_registry.register_metadir('rich-root',
2928
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
2929
help='New in 1.0. Better handling of tree roots. Incompatible with'
2931
branch_format='bzrlib.branch.BzrBranchFormat6',
2932
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2934
format_registry.register_metadir('dirstate-with-subtree',
2935
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
2936
help='New in 0.15: Fast local operations and improved scaling for '
2937
'network operations. Additionally adds support for versioning nested '
2938
'bzr branches. Incompatible with bzr < 0.15.',
2939
branch_format='bzrlib.branch.BzrBranchFormat6',
2940
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2944
format_registry.register_metadir('pack-0.92',
2945
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack1',
2946
help='New in 0.92: Pack-based format with data compatible with '
2947
'dirstate-tags format repositories. Interoperates with '
2948
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
2949
'Previously called knitpack-experimental. '
2950
'For more information, see '
2951
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
2952
branch_format='bzrlib.branch.BzrBranchFormat6',
2953
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2955
format_registry.register_metadir('pack-0.92-subtree',
2956
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack3',
2957
help='New in 0.92: Pack-based format with data compatible with '
2958
'dirstate-with-subtree format repositories. Interoperates with '
2959
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
2960
'Previously called knitpack-experimental. '
2961
'For more information, see '
2962
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
2963
branch_format='bzrlib.branch.BzrBranchFormat6',
2964
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2968
format_registry.register_metadir('rich-root-pack',
2969
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
2970
help='New in 1.0: Pack-based format with data compatible with '
2971
'rich-root format repositories. Incompatible with'
2973
branch_format='bzrlib.branch.BzrBranchFormat6',
2974
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2976
# The following two formats should always just be aliases.
2977
format_registry.register_metadir('development',
2978
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment1',
2979
help='Current development format. Can convert data to and from pack-0.92 '
2980
'(and anything compatible with pack-0.92) format repositories. '
2981
'Repositories and branches in this format can only be read by bzr.dev. '
2983
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
2985
branch_format='bzrlib.branch.BzrBranchFormat7',
2986
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2990
format_registry.register_metadir('development-subtree',
2991
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment1Subtree',
2992
help='Current development format, subtree variant. Can convert data to and '
2993
'from pack-0.92-subtree (and anything compatible with '
2994
'pack-0.92-subtree) format repositories. Repositories and branches in '
2995
'this format can only be read by bzr.dev. Please read '
2996
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
2998
branch_format='bzrlib.branch.BzrBranchFormat7',
2999
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3003
# And the development formats which the will have aliased one of follow:
3004
format_registry.register_metadir('development0',
3005
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment0',
3006
help='Trivial rename of pack-0.92 to provide a development format. '
3008
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3010
branch_format='bzrlib.branch.BzrBranchFormat6',
3011
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3015
format_registry.register_metadir('development0-subtree',
3016
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment0Subtree',
3017
help='Trivial rename of pack-0.92-subtree to provide a development format. '
3019
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3021
branch_format='bzrlib.branch.BzrBranchFormat6',
3022
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3026
format_registry.register_metadir('development1',
3027
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment1',
3028
help='A branch and pack based repository that supports stacking. '
3030
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3032
branch_format='bzrlib.branch.BzrBranchFormat7',
3033
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3037
format_registry.register_metadir('development1-subtree',
3038
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment1Subtree',
3039
help='A branch and pack based repository that supports stacking. '
3041
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3043
branch_format='bzrlib.branch.BzrBranchFormat7',
3044
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3048
# The current format that is made on 'bzr init'.
3049
format_registry.set_default('pack-0.92')
added
removed
bzrlib/bzrdir.py
