437
302
policy = self.determine_repository_policy(force_new_repo)
438
303
return policy.acquire_repository()[0]
441
def create_branch_convenience(base, force_new_repo=False,
442
force_new_tree=None, format=None,
443
possible_transports=None):
444
"""Create a new BzrDir, Branch and Repository at the url 'base'.
446
This is a convenience function - it will use an existing repository
447
if possible, can be told explicitly whether to create a working tree or
450
This will use the current default BzrDirFormat unless one is
451
specified, and use whatever
452
repository format that that uses via bzrdir.create_branch and
453
create_repository. If a shared repository is available that is used
454
preferentially. Whatever repository is used, its tree creation policy
457
The created Branch object is returned.
458
If a working tree cannot be made due to base not being a file:// url,
459
no error is raised unless force_new_tree is True, in which case no
460
data is created on disk and NotLocalUrl is raised.
462
:param base: The URL to create the branch at.
463
:param force_new_repo: If True a new repository is always created.
464
:param force_new_tree: If True or False force creation of a tree or
465
prevent such creation respectively.
466
:param format: Override for the bzrdir format to create.
467
:param possible_transports: An optional reusable transports list.
470
# check for non local urls
471
t = _mod_transport.get_transport(base, possible_transports)
472
if not isinstance(t, local.LocalTransport):
473
raise errors.NotLocalUrl(base)
474
bzrdir = BzrDir.create(base, format, possible_transports)
475
repo = bzrdir._find_or_create_repository(force_new_repo)
476
result = bzrdir.create_branch()
477
if force_new_tree or (repo.make_working_trees() and
478
force_new_tree is None):
480
bzrdir.create_workingtree()
481
except errors.NotLocalUrl:
305
def _find_source_repo(self, add_cleanup, source_branch):
306
"""Find the source branch and repo for a sprout operation.
308
This is helper intended for use by _sprout.
310
:returns: (source_branch, source_repository). Either or both may be
311
None. If not None, they will be read-locked (and their unlock(s)
312
scheduled via the add_cleanup param).
314
if source_branch is not None:
315
add_cleanup(source_branch.lock_read().unlock)
316
return source_branch, source_branch.repository
318
source_branch = self.open_branch()
319
source_repository = source_branch.repository
320
except errors.NotBranchError:
323
source_repository = self.open_repository()
324
except errors.NoRepositoryPresent:
325
source_repository = None
327
add_cleanup(source_repository.lock_read().unlock)
329
add_cleanup(source_branch.lock_read().unlock)
330
return source_branch, source_repository
332
def sprout(self, url, revision_id=None, force_new_repo=False,
333
recurse='down', possible_transports=None,
334
accelerator_tree=None, hardlink=False, stacked=False,
335
source_branch=None, create_tree_if_local=True):
336
"""Create a copy of this controldir prepared for use as a new line of
339
If url's last component does not exist, it will be created.
341
Attributes related to the identity of the source branch like
342
branch nickname will be cleaned, a working tree is created
343
whether one existed before or not; and a local branch is always
346
if revision_id is not None, then the clone operation may tune
347
itself to download less data.
349
:param accelerator_tree: A tree which can be used for retrieving file
350
contents more quickly than the revision tree, i.e. a workingtree.
351
The revision tree will be used for cases where accelerator_tree's
352
content is different.
353
:param hardlink: If true, hard-link files from accelerator_tree,
355
:param stacked: If true, create a stacked branch referring to the
356
location of this control directory.
357
:param create_tree_if_local: If true, a working-tree will be created
358
when working locally.
359
:return: The created control directory
361
operation = cleanup.OperationWithCleanups(self._sprout)
362
return operation.run(url, revision_id=revision_id,
363
force_new_repo=force_new_repo, recurse=recurse,
364
possible_transports=possible_transports,
365
accelerator_tree=accelerator_tree, hardlink=hardlink,
366
stacked=stacked, source_branch=source_branch,
367
create_tree_if_local=create_tree_if_local)
369
def _sprout(self, op, url, revision_id=None, force_new_repo=False,
370
recurse='down', possible_transports=None,
371
accelerator_tree=None, hardlink=False, stacked=False,
372
source_branch=None, create_tree_if_local=True):
373
add_cleanup = op.add_cleanup
374
fetch_spec_factory = fetch.FetchSpecFactory()
375
if revision_id is not None:
376
fetch_spec_factory.add_revision_ids([revision_id])
377
fetch_spec_factory.source_branch_stop_revision_id = revision_id
378
if possible_transports is None:
379
possible_transports = []
381
possible_transports = list(possible_transports) + [
383
target_transport = _mod_transport.get_transport(url,
385
target_transport.ensure_base()
386
cloning_format = self.cloning_metadir(stacked)
387
# Create/update the result branch
389
result = controldir.ControlDir.open_from_transport(target_transport)
390
except errors.NotBranchError:
391
result = cloning_format.initialize_on_transport(target_transport)
392
source_branch, source_repository = self._find_source_repo(
393
add_cleanup, source_branch)
394
fetch_spec_factory.source_branch = source_branch
395
# if a stacked branch wasn't requested, we don't create one
396
# even if the origin was stacked
397
if stacked and source_branch is not None:
398
stacked_branch_url = self.root_transport.base
400
stacked_branch_url = None
401
repository_policy = result.determine_repository_policy(
402
force_new_repo, stacked_branch_url, require_stacking=stacked)
403
result_repo, is_new_repo = repository_policy.acquire_repository(
404
possible_transports=possible_transports)
405
add_cleanup(result_repo.lock_write().unlock)
406
fetch_spec_factory.source_repo = source_repository
407
fetch_spec_factory.target_repo = result_repo
408
if stacked or (len(result_repo._fallback_repositories) != 0):
409
target_repo_kind = fetch.TargetRepoKinds.STACKED
411
target_repo_kind = fetch.TargetRepoKinds.EMPTY
413
target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
414
fetch_spec_factory.target_repo_kind = target_repo_kind
415
if source_repository is not None:
416
fetch_spec = fetch_spec_factory.make_fetch_spec()
417
result_repo.fetch(source_repository, fetch_spec=fetch_spec)
419
if source_branch is None:
420
# this is for sprouting a controldir without a branch; is that
422
# Not especially, but it's part of the contract.
423
result_branch = result.create_branch()
425
result_branch = source_branch.sprout(result,
426
revision_id=revision_id, repository_policy=repository_policy,
427
repository=result_repo)
428
mutter("created new branch %r" % (result_branch,))
430
# Create/update the result working tree
431
if (create_tree_if_local and not result.has_workingtree() and
432
isinstance(target_transport, local.LocalTransport) and
433
(result_repo is None or result_repo.make_working_trees())):
434
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
435
hardlink=hardlink, from_branch=result_branch)
438
if wt.path2id('') is None:
440
wt.set_root_id(self.open_workingtree.get_root_id())
441
except errors.NoWorkingTree:
447
if recurse == 'down':
450
basis = wt.basis_tree()
451
elif result_branch is not None:
452
basis = result_branch.basis_tree()
453
elif source_branch is not None:
454
basis = source_branch.basis_tree()
455
if basis is not None:
456
add_cleanup(basis.lock_read().unlock)
457
subtrees = basis.iter_references()
460
for path, file_id in subtrees:
461
target = urlutils.join(url, urlutils.escape(path))
462
sublocation = source_branch.reference_parent(file_id, path)
463
sublocation.bzrdir.sprout(target,
464
basis.get_reference_revision(file_id, path),
465
force_new_repo=force_new_repo, recurse=recurse,
486
def create_standalone_workingtree(base, format=None):
487
"""Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
489
'base' must be a local path or a file:// url.
491
This will use the current default BzrDirFormat unless one is
492
specified, and use whatever
493
repository format that that uses for bzrdirformat.create_workingtree,
494
create_branch and create_repository.
496
:param format: Override for the bzrdir format to create.
497
:return: The WorkingTree object.
499
t = _mod_transport.get_transport(base)
500
if not isinstance(t, local.LocalTransport):
501
raise errors.NotLocalUrl(base)
502
bzrdir = BzrDir.create_branch_and_repo(base,
504
format=format).bzrdir
505
return bzrdir.create_workingtree()
507
@deprecated_method(deprecated_in((2, 3, 0)))
508
def generate_backup_name(self, base):
509
return self._available_backup_name(base)
511
469
def _available_backup_name(self, base):
512
470
"""Find a non-existing backup file name based on base.
705
664
# add new tests for it to the appropriate place.
706
665
return filename == '.bzr' or filename.startswith('.bzr/')
709
def open_unsupported(base):
710
"""Open a branch which is not supported."""
711
return BzrDir.open(base, _unsupported=True)
714
def open(base, _unsupported=False, possible_transports=None):
715
"""Open an existing bzrdir, rooted at 'base' (url).
717
:param _unsupported: a private parameter to the BzrDir class.
719
t = _mod_transport.get_transport(base, possible_transports)
720
return BzrDir.open_from_transport(t, _unsupported=_unsupported)
723
def open_from_transport(transport, _unsupported=False,
724
_server_formats=True):
725
"""Open a bzrdir within a particular directory.
727
:param transport: Transport containing the bzrdir.
728
:param _unsupported: private.
730
for hook in BzrDir.hooks['pre_open']:
732
# Keep initial base since 'transport' may be modified while following
734
base = transport.base
735
def find_format(transport):
736
return transport, controldir.ControlDirFormat.find_format(
737
transport, _server_formats=_server_formats)
739
def redirected(transport, e, redirection_notice):
740
redirected_transport = transport._redirected_to(e.source, e.target)
741
if redirected_transport is None:
742
raise errors.NotBranchError(base)
743
note('%s is%s redirected to %s',
744
transport.base, e.permanently, redirected_transport.base)
745
return redirected_transport
748
transport, format = do_catching_redirections(find_format,
751
except errors.TooManyRedirections:
752
raise errors.NotBranchError(base)
754
BzrDir._check_supported(format, _unsupported)
755
return format.open(transport, _found=True)
758
def open_containing(url, possible_transports=None):
759
"""Open an existing branch which contains url.
761
:param url: url to search from.
762
See open_containing_from_transport for more detail.
764
transport = _mod_transport.get_transport(url, possible_transports)
765
return BzrDir.open_containing_from_transport(transport)
768
def open_containing_from_transport(a_transport):
769
"""Open an existing branch which contains a_transport.base.
771
This probes for a branch at a_transport, and searches upwards from there.
773
Basically we keep looking up until we find the control directory or
774
run into the root. If there isn't one, raises NotBranchError.
775
If there is one and it is either an unrecognised format or an unsupported
776
format, UnknownFormatError or UnsupportedFormatError are raised.
777
If there is one, it is returned, along with the unused portion of url.
779
:return: The BzrDir that contains the path, and a Unicode path
780
for the rest of the URL.
782
# this gets the normalised url back. I.e. '.' -> the full path.
783
url = a_transport.base
786
result = BzrDir.open_from_transport(a_transport)
787
return result, urlutils.unescape(a_transport.relpath(url))
788
except errors.NotBranchError, e:
791
new_t = a_transport.clone('..')
792
except errors.InvalidURLJoin:
793
# reached the root, whatever that may be
794
raise errors.NotBranchError(path=url)
795
if new_t.base == a_transport.base:
796
# reached the root, whatever that may be
797
raise errors.NotBranchError(path=url)
801
def open_tree_or_branch(klass, location):
802
"""Return the branch and working tree at a location.
804
If there is no tree at the location, tree will be None.
805
If there is no branch at the location, an exception will be
807
:return: (tree, branch)
809
bzrdir = klass.open(location)
810
return bzrdir._get_tree_branch()
813
def open_containing_tree_or_branch(klass, location):
814
"""Return the branch and working tree contained by a location.
816
Returns (tree, branch, relpath).
817
If there is no tree at containing the location, tree will be None.
818
If there is no branch containing the location, an exception will be
820
relpath is the portion of the path that is contained by the branch.
822
bzrdir, relpath = klass.open_containing(location)
823
tree, branch = bzrdir._get_tree_branch()
824
return tree, branch, relpath
827
def open_containing_tree_branch_or_repository(klass, location):
828
"""Return the working tree, branch and repo contained by a location.
830
Returns (tree, branch, repository, relpath).
831
If there is no tree containing the location, tree will be None.
832
If there is no branch containing the location, branch will be None.
833
If there is no repository containing the location, repository will be
835
relpath is the portion of the path that is contained by the innermost
838
If no tree, branch or repository is found, a NotBranchError is raised.
840
bzrdir, relpath = klass.open_containing(location)
842
tree, branch = bzrdir._get_tree_branch()
843
except errors.NotBranchError:
845
repo = bzrdir.find_repository()
846
return None, None, repo, relpath
847
except (errors.NoRepositoryPresent):
848
raise errors.NotBranchError(location)
849
return tree, branch, branch.repository, relpath
851
667
def _cloning_metadir(self):
852
668
"""Produce a metadir suitable for cloning with.
921
776
can be reused to share a remote connection.
923
778
if cls is not BzrDir:
924
raise AssertionError("BzrDir.create always creates the"
779
raise AssertionError("BzrDir.create always creates the "
925
780
"default format, not one of %r" % cls)
926
t = _mod_transport.get_transport(base, possible_transports)
929
format = controldir.ControlDirFormat.get_default_format()
930
return format.initialize_on_transport(t)
933
class BzrDirHooks(hooks.Hooks):
934
"""Hooks for BzrDir operations."""
937
"""Create the default hooks."""
938
hooks.Hooks.__init__(self)
939
self.create_hook(hooks.HookPoint('pre_open',
940
"Invoked before attempting to open a BzrDir with the transport "
941
"that the open will use.", (1, 14), None))
942
self.create_hook(hooks.HookPoint('post_repo_init',
943
"Invoked after a repository has been initialized. "
944
"post_repo_init is called with a "
945
"bzrlib.bzrdir.RepoInitHookParams.",
948
# install the default hooks
949
BzrDir.hooks = BzrDirHooks()
952
class RepoInitHookParams(object):
953
"""Object holding parameters passed to *_repo_init hooks.
955
There are 4 fields that hooks may wish to access:
957
:ivar repository: Repository created
958
:ivar format: Repository format
959
:ivar bzrdir: The bzrdir for the repository
960
:ivar shared: The repository is shared
963
def __init__(self, repository, format, a_bzrdir, shared):
964
"""Create a group of RepoInitHook parameters.
966
:param repository: Repository created
967
:param format: Repository format
968
:param bzrdir: The bzrdir for the repository
969
:param shared: The repository is shared
971
self.repository = repository
973
self.bzrdir = a_bzrdir
976
def __eq__(self, other):
977
return self.__dict__ == other.__dict__
781
return controldir.ControlDir.create(base, format=format,
782
possible_transports=possible_transports)
979
784
def __repr__(self):
981
return "<%s for %s>" % (self.__class__.__name__,
984
return "<%s for %s>" % (self.__class__.__name__,
988
class BzrDirPreSplitOut(BzrDir):
989
"""A common class for the all-in-one formats."""
991
def __init__(self, _transport, _format):
992
"""See BzrDir.__init__."""
993
super(BzrDirPreSplitOut, self).__init__(_transport, _format)
994
self._control_files = lockable_files.LockableFiles(
995
self.get_branch_transport(None),
996
self._format._lock_file_name,
997
self._format._lock_class)
999
def break_lock(self):
1000
"""Pre-splitout bzrdirs do not suffer from stale locks."""
1001
raise NotImplementedError(self.break_lock)
1003
def cloning_metadir(self, require_stacking=False):
1004
"""Produce a metadir suitable for cloning with."""
1005
if require_stacking:
1006
return controldir.format_registry.make_bzrdir('1.6')
1007
return self._format.__class__()
1009
def clone(self, url, revision_id=None, force_new_repo=False,
1010
preserve_stacking=False):
1011
"""See BzrDir.clone().
1013
force_new_repo has no effect, since this family of formats always
1014
require a new repository.
1015
preserve_stacking has no effect, since no source branch using this
1016
family of formats can be stacked, so there is no stacking to preserve.
785
return "<%s at %r>" % (self.__class__.__name__, self.user_url)
787
def update_feature_flags(self, updated_flags):
788
"""Update the features required by this bzrdir.
790
:param updated_flags: Dictionary mapping feature names to necessities
791
A necessity can be None to indicate the feature should be removed
1018
self._make_tail(url)
1019
result = self._format._initialize_for_clone(url)
1020
self.open_repository().clone(result, revision_id=revision_id)
1021
from_branch = self.open_branch()
1022
from_branch.clone(result, revision_id=revision_id)
1024
tree = self.open_workingtree()
1025
except errors.NotLocalUrl:
1026
# make a new one, this format always has to have one.
1027
result._init_workingtree()
1032
def create_branch(self, name=None, repository=None):
1033
"""See BzrDir.create_branch."""
1034
if repository is not None:
1035
raise NotImplementedError(
1036
"create_branch(repository=<not None>) on %r" % (self,))
1037
return self._format.get_branch_format().initialize(self, name=name)
1039
def destroy_branch(self, name=None):
1040
"""See BzrDir.destroy_branch."""
1041
raise errors.UnsupportedOperation(self.destroy_branch, self)
1043
def create_repository(self, shared=False):
1044
"""See BzrDir.create_repository."""
1046
raise errors.IncompatibleFormat('shared repository', self._format)
1047
return self.open_repository()
1049
def destroy_repository(self):
1050
"""See BzrDir.destroy_repository."""
1051
raise errors.UnsupportedOperation(self.destroy_repository, self)
1053
def create_workingtree(self, revision_id=None, from_branch=None,
1054
accelerator_tree=None, hardlink=False):
1055
"""See BzrDir.create_workingtree."""
1056
# The workingtree is sometimes created when the bzrdir is created,
1057
# but not when cloning.
1059
# this looks buggy but is not -really-
1060
# because this format creates the workingtree when the bzrdir is
1062
# clone and sprout will have set the revision_id
1063
# and that will have set it for us, its only
1064
# specific uses of create_workingtree in isolation
1065
# that can do wonky stuff here, and that only
1066
# happens for creating checkouts, which cannot be
1067
# done on this format anyway. So - acceptable wart.
1069
warning("can't support hardlinked working trees in %r"
1072
result = self.open_workingtree(recommend_upgrade=False)
1073
except errors.NoSuchFile:
1074
result = self._init_workingtree()
1075
if revision_id is not None:
1076
if revision_id == _mod_revision.NULL_REVISION:
1077
result.set_parent_ids([])
1079
result.set_parent_ids([revision_id])
1082
def _init_workingtree(self):
1083
from bzrlib.workingtree import WorkingTreeFormat2
1085
return WorkingTreeFormat2().initialize(self)
1086
except errors.NotLocalUrl:
1087
# Even though we can't access the working tree, we need to
1088
# create its control files.
1089
return WorkingTreeFormat2()._stub_initialize_on_transport(
1090
self.transport, self._control_files._file_mode)
1092
def destroy_workingtree(self):
1093
"""See BzrDir.destroy_workingtree."""
1094
raise errors.UnsupportedOperation(self.destroy_workingtree, self)
1096
def destroy_workingtree_metadata(self):
1097
"""See BzrDir.destroy_workingtree_metadata."""
1098
raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
1101
def get_branch_transport(self, branch_format, name=None):
1102
"""See BzrDir.get_branch_transport()."""
1103
if name is not None:
1104
raise errors.NoColocatedBranchSupport(self)
1105
if branch_format is None:
1106
return self.transport
1108
branch_format.get_format_string()
1109
except NotImplementedError:
1110
return self.transport
1111
raise errors.IncompatibleFormat(branch_format, self._format)
1113
def get_repository_transport(self, repository_format):
1114
"""See BzrDir.get_repository_transport()."""
1115
if repository_format is None:
1116
return self.transport
1118
repository_format.get_format_string()
1119
except NotImplementedError:
1120
return self.transport
1121
raise errors.IncompatibleFormat(repository_format, self._format)
1123
def get_workingtree_transport(self, workingtree_format):
1124
"""See BzrDir.get_workingtree_transport()."""
1125
if workingtree_format is None:
1126
return self.transport
1128
workingtree_format.get_format_string()
1129
except NotImplementedError:
1130
return self.transport
1131
raise errors.IncompatibleFormat(workingtree_format, self._format)
1133
def needs_format_conversion(self, format):
1134
"""See BzrDir.needs_format_conversion()."""
1135
return not isinstance(self._format, format.__class__)
1137
def open_branch(self, name=None, unsupported=False,
1138
ignore_fallbacks=False):
1139
"""See BzrDir.open_branch."""
1140
from bzrlib.branch import BzrBranchFormat4
1141
format = BzrBranchFormat4()
1142
self._check_supported(format, unsupported)
1143
return format.open(self, name, _found=True)
1145
def sprout(self, url, revision_id=None, force_new_repo=False,
1146
possible_transports=None, accelerator_tree=None,
1147
hardlink=False, stacked=False, create_tree_if_local=True,
1148
source_branch=None):
1149
"""See BzrDir.sprout()."""
1150
if source_branch is not None:
1151
my_branch = self.open_branch()
1152
if source_branch.base != my_branch.base:
1153
raise AssertionError(
1154
"source branch %r is not within %r with branch %r" %
1155
(source_branch, self, my_branch))
1157
raise errors.UnstackableBranchFormat(
1158
self._format, self.root_transport.base)
1159
if not create_tree_if_local:
1160
raise errors.MustHaveWorkingTree(
1161
self._format, self.root_transport.base)
1162
from bzrlib.workingtree import WorkingTreeFormat2
1163
self._make_tail(url)
1164
result = self._format._initialize_for_clone(url)
1166
self.open_repository().clone(result, revision_id=revision_id)
1167
except errors.NoRepositoryPresent:
1170
self.open_branch().sprout(result, revision_id=revision_id)
1171
except errors.NotBranchError:
1174
# we always want a working tree
1175
WorkingTreeFormat2().initialize(result,
1176
accelerator_tree=accelerator_tree,
1181
class BzrDir4(BzrDirPreSplitOut):
1182
"""A .bzr version 4 control object.
1184
This is a deprecated format and may be removed after sept 2006.
1187
def create_repository(self, shared=False):
1188
"""See BzrDir.create_repository."""
1189
return self._format.repository_format.initialize(self, shared)
1191
def needs_format_conversion(self, format):
1192
"""Format 4 dirs are always in need of conversion."""
1195
def open_repository(self):
1196
"""See BzrDir.open_repository."""
1197
from bzrlib.repofmt.weaverepo import RepositoryFormat4
1198
return RepositoryFormat4().open(self, _found=True)
1201
class BzrDir5(BzrDirPreSplitOut):
1202
"""A .bzr version 5 control object.
1204
This is a deprecated format and may be removed after sept 2006.
1207
def has_workingtree(self):
1208
"""See BzrDir.has_workingtree."""
1211
def open_repository(self):
1212
"""See BzrDir.open_repository."""
1213
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1214
return RepositoryFormat5().open(self, _found=True)
1216
def open_workingtree(self, _unsupported=False,
1217
recommend_upgrade=True):
1218
"""See BzrDir.create_workingtree."""
1219
from bzrlib.workingtree import WorkingTreeFormat2
1220
wt_format = WorkingTreeFormat2()
1221
# we don't warn here about upgrades; that ought to be handled for the
1223
return wt_format.open(self, _found=True)
1226
class BzrDir6(BzrDirPreSplitOut):
1227
"""A .bzr version 6 control object.
1229
This is a deprecated format and may be removed after sept 2006.
1232
def has_workingtree(self):
1233
"""See BzrDir.has_workingtree."""
1236
def open_repository(self):
1237
"""See BzrDir.open_repository."""
1238
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1239
return RepositoryFormat6().open(self, _found=True)
1241
def open_workingtree(self, _unsupported=False,
1242
recommend_upgrade=True):
1243
"""See BzrDir.create_workingtree."""
1244
# we don't warn here about upgrades; that ought to be handled for the
1246
from bzrlib.workingtree import WorkingTreeFormat2
1247
return WorkingTreeFormat2().open(self, _found=True)
793
self.control_files.lock_write()
795
self._format._update_feature_flags(updated_flags)
796
self.transport.put_bytes('branch-format', self._format.as_string())
798
self.control_files.unlock()
1250
801
class BzrDirMeta1(BzrDir):
1439
1098
return config.TransportConfig(self.transport, 'control.conf')
1101
class BzrFormat(object):
1102
"""Base class for all formats of things living in metadirs.
1104
This class manages the format string that is stored in the 'format'
1105
or 'branch-format' file.
1107
All classes for (branch-, repository-, workingtree-) formats that
1108
live in meta directories and have their own 'format' file
1109
(i.e. different from .bzr/branch-format) derive from this class,
1110
as well as the relevant base class for their kind
1111
(BranchFormat, WorkingTreeFormat, RepositoryFormat).
1113
Each format is identified by a "format" or "branch-format" file with a
1114
single line containing the base format name and then an optional list of
1117
Feature flags are supported as of bzr 2.5. Setting feature flags on formats
1118
will render them inaccessible to older versions of bzr.
1120
:ivar features: Dictionary mapping feature names to their necessity
1123
_present_features = set()
1129
def register_feature(cls, name):
1130
"""Register a feature as being present.
1132
:param name: Name of the feature
1135
raise ValueError("spaces are not allowed in feature names")
1136
if name in cls._present_features:
1137
raise errors.FeatureAlreadyRegistered(name)
1138
cls._present_features.add(name)
1141
def unregister_feature(cls, name):
1142
"""Unregister a feature."""
1143
cls._present_features.remove(name)
1145
def check_support_status(self, allow_unsupported, recommend_upgrade=True,
1147
for name, necessity in self.features.iteritems():
1148
if name in self._present_features:
1150
if necessity == "optional":
1151
mutter("ignoring optional missing feature %s", name)
1153
elif necessity == "required":
1154
raise errors.MissingFeature(name)
1156
mutter("treating unknown necessity as require for %s",
1158
raise errors.MissingFeature(name)
1161
def get_format_string(cls):
1162
"""Return the ASCII format string that identifies this format."""
1163
raise NotImplementedError(cls.get_format_string)
1166
def from_string(cls, text):
1167
format_string = cls.get_format_string()
1168
if not text.startswith(format_string):
1169
raise AssertionError("Invalid format header %r for %r" % (text, cls))
1170
lines = text[len(format_string):].splitlines()
1172
for lineno, line in enumerate(lines):
1174
(necessity, feature) = line.split(" ", 1)
1176
raise errors.ParseFormatError(format=cls, lineno=lineno+2,
1177
line=line, text=text)
1178
ret.features[feature] = necessity
1181
def as_string(self):
1182
"""Return the string representation of this format.
1184
lines = [self.get_format_string()]
1185
lines.extend([("%s %s\n" % (item[1], item[0])) for item in
1186
self.features.iteritems()])
1187
return "".join(lines)
1190
def _find_format(klass, registry, kind, format_string):
1192
first_line = format_string[:format_string.index("\n")+1]
1194
first_line = format_string
1196
cls = registry.get(first_line)
1198
raise errors.UnknownFormatError(format=first_line, kind=kind)
1199
return cls.from_string(format_string)
1201
def network_name(self):
1202
"""A simple byte string uniquely identifying this format for RPC calls.
1204
Metadir branch formats use their format string.
1206
return self.as_string()
1208
def __eq__(self, other):
1209
return (self.__class__ is other.__class__ and
1210
self.features == other.features)
1212
def _update_feature_flags(self, updated_flags):
1213
"""Update the feature flags in this format.
1215
:param updated_flags: Updated feature flags
1217
for name, necessity in updated_flags.iteritems():
1218
if necessity is None:
1220
del self.features[name]
1224
self.features[name] = necessity
1442
1227
class BzrProber(controldir.Prober):
1443
1228
"""Prober for formats that use a .bzr/ control directory."""
1230
formats = registry.FormatRegistry(controldir.network_format_registry)
1446
1231
"""The known .bzr formats."""
1449
def register_bzrdir_format(klass, format):
1450
klass._formats[format.get_format_string()] = format
1453
def unregister_bzrdir_format(klass, format):
1454
del klass._formats[format.get_format_string()]
1457
1234
def probe_transport(klass, transport):
1458
1235
"""Return the .bzrdir style format present in a directory."""
1713
1504
compatible with whatever sub formats are supported by self.
1718
def unregister_format(klass, format):
1719
BzrProber.unregister_bzrdir_format(format)
1720
controldir.ControlDirFormat.unregister_format(format)
1721
controldir.network_format_registry.remove(format.get_format_string())
1724
class BzrDirFormat4(BzrDirFormat):
1725
"""Bzr dir format 4.
1727
This format is a combined format for working tree, branch and repository.
1729
- Format 1 working trees [always]
1730
- Format 4 branches [always]
1731
- Format 4 repositories [always]
1733
This format is deprecated: it indexes texts using a text it which is
1734
removed in format 5; write support for this format has been removed.
1737
_lock_class = lockable_files.TransportLock
1739
fixed_components = True
1741
def get_format_string(self):
1742
"""See BzrDirFormat.get_format_string()."""
1743
return "Bazaar-NG branch, format 0.0.4\n"
1745
def get_format_description(self):
1746
"""See BzrDirFormat.get_format_description()."""
1747
return "All-in-one format 4"
1749
def get_converter(self, format=None):
1750
"""See BzrDirFormat.get_converter()."""
1751
# there is one and only one upgrade path here.
1752
return ConvertBzrDir4To5()
1754
def initialize_on_transport(self, transport):
1755
"""Format 4 branches cannot be created."""
1756
raise errors.UninitializableFormat(self)
1758
def is_supported(self):
1759
"""Format 4 is not supported.
1761
It is not supported because the model changed from 4 to 5 and the
1762
conversion logic is expensive - so doing it on the fly was not
1767
def network_name(self):
1768
return self.get_format_string()
1770
def _open(self, transport):
1771
"""See BzrDirFormat._open."""
1772
return BzrDir4(transport, self)
1774
def __return_repository_format(self):
1775
"""Circular import protection."""
1776
from bzrlib.repofmt.weaverepo import RepositoryFormat4
1777
return RepositoryFormat4()
1778
repository_format = property(__return_repository_format)
1781
class BzrDirFormatAllInOne(BzrDirFormat):
1782
"""Common class for formats before meta-dirs."""
1784
fixed_components = True
1786
def initialize_on_transport_ex(self, transport, use_existing_dir=False,
1787
create_prefix=False, force_new_repo=False, stacked_on=None,
1788
stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
1790
"""See BzrDirFormat.initialize_on_transport_ex."""
1791
require_stacking = (stacked_on is not None)
1792
# Format 5 cannot stack, but we've been asked to - actually init
1794
if require_stacking:
1795
format = BzrDirMetaFormat1()
1796
return format.initialize_on_transport_ex(transport,
1797
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
1798
force_new_repo=force_new_repo, stacked_on=stacked_on,
1799
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
1800
make_working_trees=make_working_trees, shared_repo=shared_repo)
1801
return BzrDirFormat.initialize_on_transport_ex(self, transport,
1802
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
1803
force_new_repo=force_new_repo, stacked_on=stacked_on,
1804
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
1805
make_working_trees=make_working_trees, shared_repo=shared_repo)
1808
class BzrDirFormat5(BzrDirFormatAllInOne):
1809
"""Bzr control format 5.
1811
This format is a combined format for working tree, branch and repository.
1813
- Format 2 working trees [always]
1814
- Format 4 branches [always]
1815
- Format 5 repositories [always]
1816
Unhashed stores in the repository.
1819
_lock_class = lockable_files.TransportLock
1821
def get_format_string(self):
1822
"""See BzrDirFormat.get_format_string()."""
1823
return "Bazaar-NG branch, format 5\n"
1825
def get_branch_format(self):
1826
from bzrlib import branch
1827
return branch.BzrBranchFormat4()
1829
def get_format_description(self):
1830
"""See BzrDirFormat.get_format_description()."""
1831
return "All-in-one format 5"
1833
def get_converter(self, format=None):
1834
"""See BzrDirFormat.get_converter()."""
1835
# there is one and only one upgrade path here.
1836
return ConvertBzrDir5To6()
1838
def _initialize_for_clone(self, url):
1839
return self.initialize_on_transport(
1840
_mod_transport.get_transport(url), _cloning=True)
1842
def initialize_on_transport(self, transport, _cloning=False):
1843
"""Format 5 dirs always have working tree, branch and repository.
1845
Except when they are being cloned.
1847
from bzrlib.branch import BzrBranchFormat4
1848
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1849
result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
1850
RepositoryFormat5().initialize(result, _internal=True)
1852
branch = BzrBranchFormat4().initialize(result)
1853
result._init_workingtree()
1856
def network_name(self):
1857
return self.get_format_string()
1859
def _open(self, transport):
1860
"""See BzrDirFormat._open."""
1861
return BzrDir5(transport, self)
1863
def __return_repository_format(self):
1864
"""Circular import protection."""
1865
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1866
return RepositoryFormat5()
1867
repository_format = property(__return_repository_format)
1870
class BzrDirFormat6(BzrDirFormatAllInOne):
1871
"""Bzr control format 6.
1873
This format is a combined format for working tree, branch and repository.
1875
- Format 2 working trees [always]
1876
- Format 4 branches [always]
1877
- Format 6 repositories [always]
1880
_lock_class = lockable_files.TransportLock
1882
def get_format_string(self):
1883
"""See BzrDirFormat.get_format_string()."""
1884
return "Bazaar-NG branch, format 6\n"
1886
def get_format_description(self):
1887
"""See BzrDirFormat.get_format_description()."""
1888
return "All-in-one format 6"
1890
def get_branch_format(self):
1891
from bzrlib import branch
1892
return branch.BzrBranchFormat4()
1894
def get_converter(self, format=None):
1895
"""See BzrDirFormat.get_converter()."""
1896
# there is one and only one upgrade path here.
1897
return ConvertBzrDir6ToMeta()
1899
def _initialize_for_clone(self, url):
1900
return self.initialize_on_transport(
1901
_mod_transport.get_transport(url), _cloning=True)
1903
def initialize_on_transport(self, transport, _cloning=False):
1904
"""Format 6 dirs always have working tree, branch and repository.
1906
Except when they are being cloned.
1908
from bzrlib.branch import BzrBranchFormat4
1909
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1910
result = super(BzrDirFormat6, self).initialize_on_transport(transport)
1911
RepositoryFormat6().initialize(result, _internal=True)
1913
branch = BzrBranchFormat4().initialize(result)
1914
result._init_workingtree()
1917
def network_name(self):
1918
return self.get_format_string()
1920
def _open(self, transport):
1921
"""See BzrDirFormat._open."""
1922
return BzrDir6(transport, self)
1924
def __return_repository_format(self):
1925
"""Circular import protection."""
1926
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1927
return RepositoryFormat6()
1928
repository_format = property(__return_repository_format)
1507
other_format.features = dict(self.features)
1509
def supports_transport(self, transport):
1510
# bzr formats can be opened over all known transports
1513
def check_support_status(self, allow_unsupported, recommend_upgrade=True,
1515
controldir.ControlDirFormat.check_support_status(self,
1516
allow_unsupported=allow_unsupported, recommend_upgrade=recommend_upgrade,
1518
BzrFormat.check_support_status(self, allow_unsupported=allow_unsupported,
1519
recommend_upgrade=recommend_upgrade, basedir=basedir)
1931
1522
class BzrDirMetaFormat1(BzrDirFormat):
2134
1737
def __set_workingtree_format(self, wt_format):
2135
1738
self._workingtree_format = wt_format
1741
return "<%r>" % (self.__class__.__name__,)
2137
1743
workingtree_format = property(__get_workingtree_format,
2138
1744
__set_workingtree_format)
2141
1747
# Register bzr formats
2142
BzrDirFormat.register_format(BzrDirFormat4())
2143
BzrDirFormat.register_format(BzrDirFormat5())
2144
BzrDirFormat.register_format(BzrDirFormat6())
2145
__default_format = BzrDirMetaFormat1()
2146
BzrDirFormat.register_format(__default_format)
2147
controldir.ControlDirFormat._default_format = __default_format
2150
class Converter(object):
2151
"""Converts a disk format object from one format to another."""
2153
def convert(self, to_convert, pb):
2154
"""Perform the conversion of to_convert, giving feedback via pb.
2156
:param to_convert: The disk object to convert.
2157
:param pb: a progress bar to use for progress information.
2160
def step(self, message):
2161
"""Update the pb by a step."""
2163
self.pb.update(message, self.count, self.total)
2166
class ConvertBzrDir4To5(Converter):
2167
"""Converts format 4 bzr dirs to format 5."""
2170
super(ConvertBzrDir4To5, self).__init__()
2171
self.converted_revs = set()
2172
self.absent_revisions = set()
2176
def convert(self, to_convert, pb):
2177
"""See Converter.convert()."""
2178
self.bzrdir = to_convert
2180
warnings.warn("pb parameter to convert() is deprecated")
2181
self.pb = ui.ui_factory.nested_progress_bar()
2183
ui.ui_factory.note('starting upgrade from format 4 to 5')
2184
if isinstance(self.bzrdir.transport, local.LocalTransport):
2185
self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
2186
self._convert_to_weaves()
2187
return BzrDir.open(self.bzrdir.user_url)
2191
def _convert_to_weaves(self):
2192
ui.ui_factory.note('note: upgrade may be faster if all store files are ungzipped first')
2195
stat = self.bzrdir.transport.stat('weaves')
2196
if not S_ISDIR(stat.st_mode):
2197
self.bzrdir.transport.delete('weaves')
2198
self.bzrdir.transport.mkdir('weaves')
2199
except errors.NoSuchFile:
2200
self.bzrdir.transport.mkdir('weaves')
2201
# deliberately not a WeaveFile as we want to build it up slowly.
2202
self.inv_weave = Weave('inventory')
2203
# holds in-memory weaves for all files
2204
self.text_weaves = {}
2205
self.bzrdir.transport.delete('branch-format')
2206
self.branch = self.bzrdir.open_branch()
2207
self._convert_working_inv()
2208
rev_history = self.branch.revision_history()
2209
# to_read is a stack holding the revisions we still need to process;
2210
# appending to it adds new highest-priority revisions
2211
self.known_revisions = set(rev_history)
2212
self.to_read = rev_history[-1:]
2214
rev_id = self.to_read.pop()
2215
if (rev_id not in self.revisions
2216
and rev_id not in self.absent_revisions):
2217
self._load_one_rev(rev_id)
2219
to_import = self._make_order()
2220
for i, rev_id in enumerate(to_import):
2221
self.pb.update('converting revision', i, len(to_import))
2222
self._convert_one_rev(rev_id)
2224
self._write_all_weaves()
2225
self._write_all_revs()
2226
ui.ui_factory.note('upgraded to weaves:')
2227
ui.ui_factory.note(' %6d revisions and inventories' % len(self.revisions))
2228
ui.ui_factory.note(' %6d revisions not present' % len(self.absent_revisions))
2229
ui.ui_factory.note(' %6d texts' % self.text_count)
2230
self._cleanup_spare_files_after_format4()
2231
self.branch._transport.put_bytes(
2233
BzrDirFormat5().get_format_string(),
2234
mode=self.bzrdir._get_file_mode())
2236
def _cleanup_spare_files_after_format4(self):
2237
# FIXME working tree upgrade foo.
2238
for n in 'merged-patches', 'pending-merged-patches':
2240
## assert os.path.getsize(p) == 0
2241
self.bzrdir.transport.delete(n)
2242
except errors.NoSuchFile:
2244
self.bzrdir.transport.delete_tree('inventory-store')
2245
self.bzrdir.transport.delete_tree('text-store')
2247
def _convert_working_inv(self):
2248
inv = xml4.serializer_v4.read_inventory(
2249
self.branch._transport.get('inventory'))
2250
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv, working=True)
2251
self.branch._transport.put_bytes('inventory', new_inv_xml,
2252
mode=self.bzrdir._get_file_mode())
2254
def _write_all_weaves(self):
2255
controlweaves = VersionedFileStore(self.bzrdir.transport, prefixed=False,
2256
versionedfile_class=WeaveFile)
2257
weave_transport = self.bzrdir.transport.clone('weaves')
2258
weaves = VersionedFileStore(weave_transport, prefixed=False,
2259
versionedfile_class=WeaveFile)
2260
transaction = WriteTransaction()
2264
for file_id, file_weave in self.text_weaves.items():
2265
self.pb.update('writing weave', i, len(self.text_weaves))
2266
weaves._put_weave(file_id, file_weave, transaction)
2268
self.pb.update('inventory', 0, 1)
2269
controlweaves._put_weave('inventory', self.inv_weave, transaction)
2270
self.pb.update('inventory', 1, 1)
2274
def _write_all_revs(self):
2275
"""Write all revisions out in new form."""
2276
self.bzrdir.transport.delete_tree('revision-store')
2277
self.bzrdir.transport.mkdir('revision-store')
2278
revision_transport = self.bzrdir.transport.clone('revision-store')
2280
from bzrlib.xml5 import serializer_v5
2281
from bzrlib.repofmt.weaverepo import RevisionTextStore
2282
revision_store = RevisionTextStore(revision_transport,
2283
serializer_v5, False, versionedfile.PrefixMapper(),
2284
lambda:True, lambda:True)
2286
for i, rev_id in enumerate(self.converted_revs):
2287
self.pb.update('write revision', i, len(self.converted_revs))
2288
text = serializer_v5.write_revision_to_string(
2289
self.revisions[rev_id])
2291
revision_store.add_lines(key, None, osutils.split_lines(text))
2295
def _load_one_rev(self, rev_id):
2296
"""Load a revision object into memory.
2298
Any parents not either loaded or abandoned get queued to be
2300
self.pb.update('loading revision',
2301
len(self.revisions),
2302
len(self.known_revisions))
2303
if not self.branch.repository.has_revision(rev_id):
2305
ui.ui_factory.note('revision {%s} not present in branch; '
2306
'will be converted as a ghost' %
2308
self.absent_revisions.add(rev_id)
2310
rev = self.branch.repository.get_revision(rev_id)
2311
for parent_id in rev.parent_ids:
2312
self.known_revisions.add(parent_id)
2313
self.to_read.append(parent_id)
2314
self.revisions[rev_id] = rev
2316
def _load_old_inventory(self, rev_id):
2317
f = self.branch.repository.inventory_store.get(rev_id)
2319
old_inv_xml = f.read()
2322
inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
2323
inv.revision_id = rev_id
2324
rev = self.revisions[rev_id]
2327
def _load_updated_inventory(self, rev_id):
2328
inv_xml = self.inv_weave.get_text(rev_id)
2329
inv = xml5.serializer_v5.read_inventory_from_string(inv_xml, rev_id)
2332
def _convert_one_rev(self, rev_id):
2333
"""Convert revision and all referenced objects to new format."""
2334
rev = self.revisions[rev_id]
2335
inv = self._load_old_inventory(rev_id)
2336
present_parents = [p for p in rev.parent_ids
2337
if p not in self.absent_revisions]
2338
self._convert_revision_contents(rev, inv, present_parents)
2339
self._store_new_inv(rev, inv, present_parents)
2340
self.converted_revs.add(rev_id)
2342
def _store_new_inv(self, rev, inv, present_parents):
2343
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
2344
new_inv_sha1 = sha_string(new_inv_xml)
2345
self.inv_weave.add_lines(rev.revision_id,
2347
new_inv_xml.splitlines(True))
2348
rev.inventory_sha1 = new_inv_sha1
2350
def _convert_revision_contents(self, rev, inv, present_parents):
2351
"""Convert all the files within a revision.
2353
Also upgrade the inventory to refer to the text revision ids."""
2354
rev_id = rev.revision_id
2355
mutter('converting texts of revision {%s}',
2357
parent_invs = map(self._load_updated_inventory, present_parents)
2358
entries = inv.iter_entries()
2360
for path, ie in entries:
2361
self._convert_file_version(rev, ie, parent_invs)
2363
def _convert_file_version(self, rev, ie, parent_invs):
2364
"""Convert one version of one file.
2366
The file needs to be added into the weave if it is a merge
2367
of >=2 parents or if it's changed from its parent.
2369
file_id = ie.file_id
2370
rev_id = rev.revision_id
2371
w = self.text_weaves.get(file_id)
2374
self.text_weaves[file_id] = w
2375
text_changed = False
2376
parent_candiate_entries = ie.parent_candidates(parent_invs)
2377
heads = graph.Graph(self).heads(parent_candiate_entries.keys())
2378
# XXX: Note that this is unordered - and this is tolerable because
2379
# the previous code was also unordered.
2380
previous_entries = dict((head, parent_candiate_entries[head]) for head
2382
self.snapshot_ie(previous_entries, ie, w, rev_id)
2384
def get_parent_map(self, revision_ids):
2385
"""See graph.StackedParentsProvider.get_parent_map"""
2386
return dict((revision_id, self.revisions[revision_id])
2387
for revision_id in revision_ids
2388
if revision_id in self.revisions)
2390
def snapshot_ie(self, previous_revisions, ie, w, rev_id):
2391
# TODO: convert this logic, which is ~= snapshot to
2392
# a call to:. This needs the path figured out. rather than a work_tree
2393
# a v4 revision_tree can be given, or something that looks enough like
2394
# one to give the file content to the entry if it needs it.
2395
# and we need something that looks like a weave store for snapshot to
2397
#ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
2398
if len(previous_revisions) == 1:
2399
previous_ie = previous_revisions.values()[0]
2400
if ie._unchanged(previous_ie):
2401
ie.revision = previous_ie.revision
2404
f = self.branch.repository._text_store.get(ie.text_id)
2406
file_lines = f.readlines()
2409
w.add_lines(rev_id, previous_revisions, file_lines)
2410
self.text_count += 1
2412
w.add_lines(rev_id, previous_revisions, [])
2413
ie.revision = rev_id
2415
def _make_order(self):
2416
"""Return a suitable order for importing revisions.
2418
The order must be such that an revision is imported after all
2419
its (present) parents.
2421
todo = set(self.revisions.keys())
2422
done = self.absent_revisions.copy()
2425
# scan through looking for a revision whose parents
2427
for rev_id in sorted(list(todo)):
2428
rev = self.revisions[rev_id]
2429
parent_ids = set(rev.parent_ids)
2430
if parent_ids.issubset(done):
2431
# can take this one now
2432
order.append(rev_id)
2438
class ConvertBzrDir5To6(Converter):
2439
"""Converts format 5 bzr dirs to format 6."""
2441
def convert(self, to_convert, pb):
2442
"""See Converter.convert()."""
2443
self.bzrdir = to_convert
2444
pb = ui.ui_factory.nested_progress_bar()
2446
ui.ui_factory.note('starting upgrade from format 5 to 6')
2447
self._convert_to_prefixed()
2448
return BzrDir.open(self.bzrdir.user_url)
2452
def _convert_to_prefixed(self):
2453
from bzrlib.store import TransportStore
2454
self.bzrdir.transport.delete('branch-format')
2455
for store_name in ["weaves", "revision-store"]:
2456
ui.ui_factory.note("adding prefixes to %s" % store_name)
2457
store_transport = self.bzrdir.transport.clone(store_name)
2458
store = TransportStore(store_transport, prefixed=True)
2459
for urlfilename in store_transport.list_dir('.'):
2460
filename = urlutils.unescape(urlfilename)
2461
if (filename.endswith(".weave") or
2462
filename.endswith(".gz") or
2463
filename.endswith(".sig")):
2464
file_id, suffix = os.path.splitext(filename)
2468
new_name = store._mapper.map((file_id,)) + suffix
2469
# FIXME keep track of the dirs made RBC 20060121
2471
store_transport.move(filename, new_name)
2472
except errors.NoSuchFile: # catches missing dirs strangely enough
2473
store_transport.mkdir(osutils.dirname(new_name))
2474
store_transport.move(filename, new_name)
2475
self.bzrdir.transport.put_bytes(
2477
BzrDirFormat6().get_format_string(),
2478
mode=self.bzrdir._get_file_mode())
2481
class ConvertBzrDir6ToMeta(Converter):
2482
"""Converts format 6 bzr dirs to metadirs."""
2484
def convert(self, to_convert, pb):
2485
"""See Converter.convert()."""
2486
from bzrlib.repofmt.weaverepo import RepositoryFormat7
2487
from bzrlib.branch import BzrBranchFormat5
2488
self.bzrdir = to_convert
2489
self.pb = ui.ui_factory.nested_progress_bar()
2491
self.total = 20 # the steps we know about
2492
self.garbage_inventories = []
2493
self.dir_mode = self.bzrdir._get_dir_mode()
2494
self.file_mode = self.bzrdir._get_file_mode()
2496
ui.ui_factory.note('starting upgrade from format 6 to metadir')
2497
self.bzrdir.transport.put_bytes(
2499
"Converting to format 6",
2500
mode=self.file_mode)
2501
# its faster to move specific files around than to open and use the apis...
2502
# first off, nuke ancestry.weave, it was never used.
2504
self.step('Removing ancestry.weave')
2505
self.bzrdir.transport.delete('ancestry.weave')
2506
except errors.NoSuchFile:
2508
# find out whats there
2509
self.step('Finding branch files')
2510
last_revision = self.bzrdir.open_branch().last_revision()
2511
bzrcontents = self.bzrdir.transport.list_dir('.')
2512
for name in bzrcontents:
2513
if name.startswith('basis-inventory.'):
2514
self.garbage_inventories.append(name)
2515
# create new directories for repository, working tree and branch
2516
repository_names = [('inventory.weave', True),
2517
('revision-store', True),
2519
self.step('Upgrading repository ')
2520
self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
2521
self.make_lock('repository')
2522
# we hard code the formats here because we are converting into
2523
# the meta format. The meta format upgrader can take this to a
2524
# future format within each component.
2525
self.put_format('repository', RepositoryFormat7())
2526
for entry in repository_names:
2527
self.move_entry('repository', entry)
2529
self.step('Upgrading branch ')
2530
self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
2531
self.make_lock('branch')
2532
self.put_format('branch', BzrBranchFormat5())
2533
branch_files = [('revision-history', True),
2534
('branch-name', True),
2536
for entry in branch_files:
2537
self.move_entry('branch', entry)
2539
checkout_files = [('pending-merges', True),
2540
('inventory', True),
2541
('stat-cache', False)]
2542
# If a mandatory checkout file is not present, the branch does not have
2543
# a functional checkout. Do not create a checkout in the converted
2545
for name, mandatory in checkout_files:
2546
if mandatory and name not in bzrcontents:
2547
has_checkout = False
2551
if not has_checkout:
2552
ui.ui_factory.note('No working tree.')
2553
# If some checkout files are there, we may as well get rid of them.
2554
for name, mandatory in checkout_files:
2555
if name in bzrcontents:
2556
self.bzrdir.transport.delete(name)
2558
from bzrlib.workingtree import WorkingTreeFormat3
2559
self.step('Upgrading working tree')
2560
self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
2561
self.make_lock('checkout')
2563
'checkout', WorkingTreeFormat3())
2564
self.bzrdir.transport.delete_multi(
2565
self.garbage_inventories, self.pb)
2566
for entry in checkout_files:
2567
self.move_entry('checkout', entry)
2568
if last_revision is not None:
2569
self.bzrdir.transport.put_bytes(
2570
'checkout/last-revision', last_revision)
2571
self.bzrdir.transport.put_bytes(
2573
BzrDirMetaFormat1().get_format_string(),
2574
mode=self.file_mode)
2576
return BzrDir.open(self.bzrdir.user_url)
2578
def make_lock(self, name):
2579
"""Make a lock for the new control dir name."""
2580
self.step('Make %s lock' % name)
2581
ld = lockdir.LockDir(self.bzrdir.transport,
2583
file_modebits=self.file_mode,
2584
dir_modebits=self.dir_mode)
2587
def move_entry(self, new_dir, entry):
2588
"""Move then entry name into new_dir."""
2590
mandatory = entry[1]
2591
self.step('Moving %s' % name)
2593
self.bzrdir.transport.move(name, '%s/%s' % (new_dir, name))
2594
except errors.NoSuchFile:
2598
def put_format(self, dirname, format):
2599
self.bzrdir.transport.put_bytes('%s/format' % dirname,
2600
format.get_format_string(),
2604
class ConvertMetaToMeta(Converter):
1748
BzrProber.formats.register(BzrDirMetaFormat1.get_format_string(),
1750
controldir.ControlDirFormat._default_format = BzrDirMetaFormat1()
1753
class BzrDirMetaFormat1Colo(BzrDirMetaFormat1):
1754
"""BzrDirMeta1 format with support for colocated branches."""
1756
colocated_branches = True
1759
def get_format_string(cls):
1760
"""See BzrDirFormat.get_format_string()."""
1761
return "Bazaar meta directory, format 1 (with colocated branches)\n"
1763
def get_format_description(self):
1764
"""See BzrDirFormat.get_format_description()."""
1765
return "Meta directory format 1 with support for colocated branches"
1767
def _open(self, transport):
1768
"""See BzrDirFormat._open."""
1769
# Create a new format instance because otherwise initialisation of new
1770
# metadirs share the global default format object leading to alias
1772
format = BzrDirMetaFormat1Colo()
1773
self._supply_sub_formats_to(format)
1774
return BzrDirMeta1(transport, format)
1777
BzrProber.formats.register(BzrDirMetaFormat1Colo.get_format_string(),
1778
BzrDirMetaFormat1Colo)
1781
class ConvertMetaToMeta(controldir.Converter):
2605
1782
"""Converts the components of metadirs."""
2607
1784
def __init__(self, target_format):
2680
1856
return to_convert
2683
# This is not in remote.py because it's relatively small, and needs to be
2684
# registered. Putting it in remote.py creates a circular import problem.
2685
# we can make it a lazy object if the control formats is turned into something
2687
class RemoteBzrDirFormat(BzrDirMetaFormat1):
2688
"""Format representing bzrdirs accessed via a smart server"""
2690
supports_workingtrees = False
2693
BzrDirMetaFormat1.__init__(self)
2694
# XXX: It's a bit ugly that the network name is here, because we'd
2695
# like to believe that format objects are stateless or at least
2696
# immutable, However, we do at least avoid mutating the name after
2697
# it's returned. See <https://bugs.launchpad.net/bzr/+bug/504102>
2698
self._network_name = None
2701
return "%s(_network_name=%r)" % (self.__class__.__name__,
2704
def get_format_description(self):
2705
if self._network_name:
2706
real_format = controldir.network_format_registry.get(self._network_name)
2707
return 'Remote: ' + real_format.get_format_description()
2708
return 'bzr remote bzrdir'
2710
def get_format_string(self):
2711
raise NotImplementedError(self.get_format_string)
2713
def network_name(self):
2714
if self._network_name:
2715
return self._network_name
2717
raise AssertionError("No network name set.")
2719
def initialize_on_transport(self, transport):
2721
# hand off the request to the smart server
2722
client_medium = transport.get_smart_medium()
2723
except errors.NoSmartMedium:
2724
# TODO: lookup the local format from a server hint.
2725
local_dir_format = BzrDirMetaFormat1()
2726
return local_dir_format.initialize_on_transport(transport)
2727
client = _SmartClient(client_medium)
2728
path = client.remote_path_from_transport(transport)
2730
response = client.call('BzrDirFormat.initialize', path)
2731
except errors.ErrorFromSmartServer, err:
2732
remote._translate_error(err, path=path)
2733
if response[0] != 'ok':
2734
raise errors.SmartProtocolError('unexpected response code %s' % (response,))
2735
format = RemoteBzrDirFormat()
2736
self._supply_sub_formats_to(format)
2737
return remote.RemoteBzrDir(transport, format)
2739
def parse_NoneTrueFalse(self, arg):
2746
raise AssertionError("invalid arg %r" % arg)
2748
def _serialize_NoneTrueFalse(self, arg):
2755
def _serialize_NoneString(self, arg):
2758
def initialize_on_transport_ex(self, transport, use_existing_dir=False,
2759
create_prefix=False, force_new_repo=False, stacked_on=None,
2760
stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
2763
# hand off the request to the smart server
2764
client_medium = transport.get_smart_medium()
2765
except errors.NoSmartMedium:
2768
# Decline to open it if the server doesn't support our required
2769
# version (3) so that the VFS-based transport will do it.
2770
if client_medium.should_probe():
2772
server_version = client_medium.protocol_version()
2773
if server_version != '2':
2777
except errors.SmartProtocolError:
2778
# Apparently there's no usable smart server there, even though
2779
# the medium supports the smart protocol.
2784
client = _SmartClient(client_medium)
2785
path = client.remote_path_from_transport(transport)
2786
if client_medium._is_remote_before((1, 16)):
2789
# TODO: lookup the local format from a server hint.
2790
local_dir_format = BzrDirMetaFormat1()
2791
self._supply_sub_formats_to(local_dir_format)
2792
return local_dir_format.initialize_on_transport_ex(transport,
2793
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
2794
force_new_repo=force_new_repo, stacked_on=stacked_on,
2795
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
2796
make_working_trees=make_working_trees, shared_repo=shared_repo,
2798
return self._initialize_on_transport_ex_rpc(client, path, transport,
2799
use_existing_dir, create_prefix, force_new_repo, stacked_on,
2800
stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
2802
def _initialize_on_transport_ex_rpc(self, client, path, transport,
2803
use_existing_dir, create_prefix, force_new_repo, stacked_on,
2804
stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
2806
args.append(self._serialize_NoneTrueFalse(use_existing_dir))
2807
args.append(self._serialize_NoneTrueFalse(create_prefix))
2808
args.append(self._serialize_NoneTrueFalse(force_new_repo))
2809
args.append(self._serialize_NoneString(stacked_on))
2810
# stack_on_pwd is often/usually our transport
2813
stack_on_pwd = transport.relpath(stack_on_pwd)
2814
if not stack_on_pwd:
2816
except errors.PathNotChild:
2818
args.append(self._serialize_NoneString(stack_on_pwd))
2819
args.append(self._serialize_NoneString(repo_format_name))
2820
args.append(self._serialize_NoneTrueFalse(make_working_trees))
2821
args.append(self._serialize_NoneTrueFalse(shared_repo))
2822
request_network_name = self._network_name or \
2823
BzrDirFormat.get_default_format().network_name()
2825
response = client.call('BzrDirFormat.initialize_ex_1.16',
2826
request_network_name, path, *args)
2827
except errors.UnknownSmartMethod:
2828
client._medium._remember_remote_is_before((1,16))
2829
local_dir_format = BzrDirMetaFormat1()
2830
self._supply_sub_formats_to(local_dir_format)
2831
return local_dir_format.initialize_on_transport_ex(transport,
2832
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
2833
force_new_repo=force_new_repo, stacked_on=stacked_on,
2834
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
2835
make_working_trees=make_working_trees, shared_repo=shared_repo,
2837
except errors.ErrorFromSmartServer, err:
2838
remote._translate_error(err, path=path)
2839
repo_path = response[0]
2840
bzrdir_name = response[6]
2841
require_stacking = response[7]
2842
require_stacking = self.parse_NoneTrueFalse(require_stacking)
2843
format = RemoteBzrDirFormat()
2844
format._network_name = bzrdir_name
2845
self._supply_sub_formats_to(format)
2846
bzrdir = remote.RemoteBzrDir(transport, format, _client=client)
2848
repo_format = remote.response_tuple_to_repo_format(response[1:])
2849
if repo_path == '.':
2852
repo_bzrdir_format = RemoteBzrDirFormat()
2853
repo_bzrdir_format._network_name = response[5]
2854
repo_bzr = remote.RemoteBzrDir(transport.clone(repo_path),
2858
final_stack = response[8] or None
2859
final_stack_pwd = response[9] or None
2861
final_stack_pwd = urlutils.join(
2862
transport.base, final_stack_pwd)
2863
remote_repo = remote.RemoteRepository(repo_bzr, repo_format)
2864
if len(response) > 10:
2865
# Updated server verb that locks remotely.
2866
repo_lock_token = response[10] or None
2867
remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
2869
remote_repo.dont_leave_lock_in_place()
2871
remote_repo.lock_write()
2872
policy = UseExistingRepository(remote_repo, final_stack,
2873
final_stack_pwd, require_stacking)
2874
policy.acquire_repository()
2878
bzrdir._format.set_branch_format(self.get_branch_format())
2879
if require_stacking:
2880
# The repo has already been created, but we need to make sure that
2881
# we'll make a stackable branch.
2882
bzrdir._format.require_stacking(_skip_repo=True)
2883
return remote_repo, bzrdir, require_stacking, policy
2885
def _open(self, transport):
2886
return remote.RemoteBzrDir(transport, self)
2888
def __eq__(self, other):
2889
if not isinstance(other, RemoteBzrDirFormat):
2891
return self.get_format_description() == other.get_format_description()
2893
def __return_repository_format(self):
2894
# Always return a RemoteRepositoryFormat object, but if a specific bzr
2895
# repository format has been asked for, tell the RemoteRepositoryFormat
2896
# that it should use that for init() etc.
2897
result = remote.RemoteRepositoryFormat()
2898
custom_format = getattr(self, '_repository_format', None)
2900
if isinstance(custom_format, remote.RemoteRepositoryFormat):
2901
return custom_format
2903
# We will use the custom format to create repositories over the
2904
# wire; expose its details like rich_root_data for code to
2906
result._custom_format = custom_format
2909
def get_branch_format(self):
2910
result = BzrDirMetaFormat1.get_branch_format(self)
2911
if not isinstance(result, remote.RemoteBranchFormat):
2912
new_result = remote.RemoteBranchFormat()
2913
new_result._custom_format = result
2915
self.set_branch_format(new_result)
2919
repository_format = property(__return_repository_format,
2920
BzrDirMetaFormat1._set_repository_format) #.im_func)
1859
class ConvertMetaToColo(controldir.Converter):
1860
"""Add colocated branch support."""
1862
def __init__(self, target_format):
1863
"""Create a converter.that upgrades a metadir to the colo format.
1865
:param target_format: The final metadir format that is desired.
1867
self.target_format = target_format
1869
def convert(self, to_convert, pb):
1870
"""See Converter.convert()."""
1871
to_convert.transport.put_bytes('branch-format',
1872
self.target_format.as_string())
1873
return BzrDir.open_from_transport(to_convert.root_transport)
1876
class ConvertMetaToColo(controldir.Converter):
1877
"""Convert a 'development-colo' bzrdir to a '2a' bzrdir."""
1879
def __init__(self, target_format):
1880
"""Create a converter that converts a 'development-colo' metadir
1883
:param target_format: The final metadir format that is desired.
1885
self.target_format = target_format
1887
def convert(self, to_convert, pb):
1888
"""See Converter.convert()."""
1889
to_convert.transport.put_bytes('branch-format',
1890
self.target_format.as_string())
1891
return BzrDir.open_from_transport(to_convert.root_transport)
2923
1894
controldir.ControlDirFormat.register_server_prober(RemoteBzrProber)
3124
2111
registry.register(key, helper, help, native, deprecated, hidden,
3125
2112
experimental, alias)
3127
# The pre-0.8 formats have their repository format network name registered in
3128
# repository.py. MetaDir formats have their repository format network name
3129
# inferred from their disk format string.
3130
controldir.format_registry.register('weave', BzrDirFormat6,
3131
'Pre-0.8 format. Slower than knit and does not'
3132
' support checkouts or shared repositories.',
3135
register_metadir(controldir.format_registry, 'metaweave',
3136
'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3137
'Transitional format in 0.8. Slower than knit.',
3138
branch_format='bzrlib.branch.BzrBranchFormat5',
3139
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3142
2114
register_metadir(controldir.format_registry, 'knit',
3143
2115
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3144
2116
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
3145
branch_format='bzrlib.branch.BzrBranchFormat5',
3146
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
2117
branch_format='bzrlib.branchfmt.fullhistory.BzrBranchFormat5',
2118
tree_format='bzrlib.workingtree_3.WorkingTreeFormat3',
3148
2120
deprecated=True)
3149
2121
register_metadir(controldir.format_registry, 'dirstate',
3150
2122
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3151
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
3152
'above when accessed over the network.',
3153
branch_format='bzrlib.branch.BzrBranchFormat5',
3154
# this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
3155
# directly from workingtree_4 triggers a circular import.
3156
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2123
help='Format using dirstate for working trees. '
2124
'Compatible with bzr 0.8 and '
2125
'above when accessed over the network. Introduced in bzr 0.15.',
2126
branch_format='bzrlib.branchfmt.fullhistory.BzrBranchFormat5',
2127
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3158
2129
deprecated=True)
3159
2130
register_metadir(controldir.format_registry, 'dirstate-tags',
3160
2131
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3161
help='New in 0.15: Fast local operations and improved scaling for '
3162
'network operations. Additionally adds support for tags.'
3163
' Incompatible with bzr < 0.15.',
2132
help='Variant of dirstate with support for tags. '
2133
'Introduced in bzr 0.15.',
3164
2134
branch_format='bzrlib.branch.BzrBranchFormat6',
3165
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2135
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3167
2137
deprecated=True)
3168
2138
register_metadir(controldir.format_registry, 'rich-root',
3169
2139
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
3170
help='New in 1.0. Better handling of tree roots. Incompatible with'
2140
help='Variant of dirstate with better handling of tree roots. '
2141
'Introduced in bzr 1.0',
3172
2142
branch_format='bzrlib.branch.BzrBranchFormat6',
3173
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2143
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3175
2145
deprecated=True)
3176
2146
register_metadir(controldir.format_registry, 'dirstate-with-subtree',
3177
2147
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
3178
help='New in 0.15: Fast local operations and improved scaling for '
3179
'network operations. Additionally adds support for versioning nested '
3180
'bzr branches. Incompatible with bzr < 0.15.',
2148
help='Variant of dirstate with support for nested trees. '
2149
'Introduced in 0.15.',
3181
2150
branch_format='bzrlib.branch.BzrBranchFormat6',
3182
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2151
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3183
2152
experimental=True,
3186
2155
register_metadir(controldir.format_registry, 'pack-0.92',
3187
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack1',
3188
help='New in 0.92: Pack-based format with data compatible with '
3189
'dirstate-tags format repositories. Interoperates with '
3190
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
2156
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack1',
2157
help='Pack-based format used in 1.x series. Introduced in 0.92. '
2158
'Interoperates with bzr repositories before 0.92 but cannot be '
2159
'read by bzr < 0.92. '
3192
2161
branch_format='bzrlib.branch.BzrBranchFormat6',
3193
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2162
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3195
2165
register_metadir(controldir.format_registry, 'pack-0.92-subtree',
3196
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack3',
3197
help='New in 0.92: Pack-based format with data compatible with '
3198
'dirstate-with-subtree format repositories. Interoperates with '
2166
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack3',
2167
help='Pack-based format used in 1.x series, with subtree support. '
2168
'Introduced in 0.92. Interoperates with '
3199
2169
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3201
2171
branch_format='bzrlib.branch.BzrBranchFormat6',
3202
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2172
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3204
2175
experimental=True,
3206
2177
register_metadir(controldir.format_registry, 'rich-root-pack',
3207
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3208
help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
3209
'(needed for bzr-svn and bzr-git).',
2178
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack4',
2179
help='A variant of pack-0.92 that supports rich-root data '
2180
'(needed for bzr-svn and bzr-git). Introduced in 1.0.',
3210
2181
branch_format='bzrlib.branch.BzrBranchFormat6',
3211
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2182
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3214
2186
register_metadir(controldir.format_registry, '1.6',
3215
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
2187
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack5',
3216
2188
help='A format that allows a branch to indicate that there is another '
3217
2189
'(stacked) repository that should be used to access data that is '
3218
2190
'not present locally.',
3219
2191
branch_format='bzrlib.branch.BzrBranchFormat7',
3220
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2192
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3223
2196
register_metadir(controldir.format_registry, '1.6.1-rich-root',
3224
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
2197
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack5RichRoot',
3225
2198
help='A variant of 1.6 that supports rich-root data '
3226
2199
'(needed for bzr-svn and bzr-git).',
3227
2200
branch_format='bzrlib.branch.BzrBranchFormat7',
3228
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2201
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3231
2205
register_metadir(controldir.format_registry, '1.9',
3232
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
2206
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6',
3233
2207
help='A repository format using B+tree indexes. These indexes '
3234
2208
'are smaller in size, have smarter caching and provide faster '
3235
2209
'performance for most operations.',
3236
2210
branch_format='bzrlib.branch.BzrBranchFormat7',
3237
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2211
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3240
2215
register_metadir(controldir.format_registry, '1.9-rich-root',
3241
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
2216
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6RichRoot',
3242
2217
help='A variant of 1.9 that supports rich-root data '
3243
2218
'(needed for bzr-svn and bzr-git).',
3244
2219
branch_format='bzrlib.branch.BzrBranchFormat7',
3245
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2220
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3248
2224
register_metadir(controldir.format_registry, '1.14',
3249
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
2225
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6',
3250
2226
help='A working-tree format that supports content filtering.',
3251
2227
branch_format='bzrlib.branch.BzrBranchFormat7',
3252
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
2228
tree_format='bzrlib.workingtree_4.WorkingTreeFormat5',
3254
2232
register_metadir(controldir.format_registry, '1.14-rich-root',
3255
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
2233
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6RichRoot',
3256
2234
help='A variant of 1.14 that supports rich-root data '
3257
2235
'(needed for bzr-svn and bzr-git).',
3258
2236
branch_format='bzrlib.branch.BzrBranchFormat7',
3259
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
2237
tree_format='bzrlib.workingtree_4.WorkingTreeFormat5',
3261
2241
# The following un-numbered 'development' formats should always just be aliases.
3262
2242
register_metadir(controldir.format_registry, 'development-subtree',
added
removed
bzrlib/bzrdir.py
