430
299
policy = self.determine_repository_policy(force_new_repo)
431
300
return policy.acquire_repository()[0]
434
def create_branch_convenience(base, force_new_repo=False,
435
force_new_tree=None, format=None,
436
possible_transports=None):
437
"""Create a new BzrDir, Branch and Repository at the url 'base'.
439
This is a convenience function - it will use an existing repository
440
if possible, can be told explicitly whether to create a working tree or
443
This will use the current default BzrDirFormat unless one is
444
specified, and use whatever
445
repository format that that uses via bzrdir.create_branch and
446
create_repository. If a shared repository is available that is used
447
preferentially. Whatever repository is used, its tree creation policy
450
The created Branch object is returned.
451
If a working tree cannot be made due to base not being a file:// url,
452
no error is raised unless force_new_tree is True, in which case no
453
data is created on disk and NotLocalUrl is raised.
455
:param base: The URL to create the branch at.
456
:param force_new_repo: If True a new repository is always created.
457
:param force_new_tree: If True or False force creation of a tree or
458
prevent such creation respectively.
459
:param format: Override for the bzrdir format to create.
460
:param possible_transports: An optional reusable transports list.
463
# check for non local urls
464
t = get_transport(base, possible_transports)
465
if not isinstance(t, local.LocalTransport):
466
raise errors.NotLocalUrl(base)
467
bzrdir = BzrDir.create(base, format, possible_transports)
468
repo = bzrdir._find_or_create_repository(force_new_repo)
469
result = bzrdir.create_branch()
470
if force_new_tree or (repo.make_working_trees() and
471
force_new_tree is None):
473
bzrdir.create_workingtree()
474
except errors.NotLocalUrl:
302
def _find_source_repo(self, add_cleanup, source_branch):
303
"""Find the source branch and repo for a sprout operation.
305
This is helper intended for use by _sprout.
307
:returns: (source_branch, source_repository). Either or both may be
308
None. If not None, they will be read-locked (and their unlock(s)
309
scheduled via the add_cleanup param).
311
if source_branch is not None:
312
add_cleanup(source_branch.lock_read().unlock)
313
return source_branch, source_branch.repository
315
source_branch = self.open_branch()
316
source_repository = source_branch.repository
317
except errors.NotBranchError:
320
source_repository = self.open_repository()
321
except errors.NoRepositoryPresent:
322
source_repository = None
324
add_cleanup(source_repository.lock_read().unlock)
326
add_cleanup(source_branch.lock_read().unlock)
327
return source_branch, source_repository
329
def sprout(self, url, revision_id=None, force_new_repo=False,
330
recurse='down', possible_transports=None,
331
accelerator_tree=None, hardlink=False, stacked=False,
332
source_branch=None, create_tree_if_local=True):
333
"""Create a copy of this controldir prepared for use as a new line of
336
If url's last component does not exist, it will be created.
338
Attributes related to the identity of the source branch like
339
branch nickname will be cleaned, a working tree is created
340
whether one existed before or not; and a local branch is always
343
if revision_id is not None, then the clone operation may tune
344
itself to download less data.
346
:param accelerator_tree: A tree which can be used for retrieving file
347
contents more quickly than the revision tree, i.e. a workingtree.
348
The revision tree will be used for cases where accelerator_tree's
349
content is different.
350
:param hardlink: If true, hard-link files from accelerator_tree,
352
:param stacked: If true, create a stacked branch referring to the
353
location of this control directory.
354
:param create_tree_if_local: If true, a working-tree will be created
355
when working locally.
357
operation = cleanup.OperationWithCleanups(self._sprout)
358
return operation.run(url, revision_id=revision_id,
359
force_new_repo=force_new_repo, recurse=recurse,
360
possible_transports=possible_transports,
361
accelerator_tree=accelerator_tree, hardlink=hardlink,
362
stacked=stacked, source_branch=source_branch,
363
create_tree_if_local=create_tree_if_local)
365
def _sprout(self, op, url, revision_id=None, force_new_repo=False,
366
recurse='down', possible_transports=None,
367
accelerator_tree=None, hardlink=False, stacked=False,
368
source_branch=None, create_tree_if_local=True):
369
add_cleanup = op.add_cleanup
370
fetch_spec_factory = fetch.FetchSpecFactory()
371
if revision_id is not None:
372
fetch_spec_factory.add_revision_ids([revision_id])
373
fetch_spec_factory.source_branch_stop_revision_id = revision_id
374
if possible_transports is None:
375
possible_transports = []
377
possible_transports = list(possible_transports) + [
379
target_transport = _mod_transport.get_transport(url,
381
target_transport.ensure_base()
382
cloning_format = self.cloning_metadir(stacked)
383
# Create/update the result branch
385
result = controldir.ControlDir.open_from_transport(target_transport)
386
except errors.NotBranchError:
387
result = cloning_format.initialize_on_transport(target_transport)
388
source_branch, source_repository = self._find_source_repo(
389
add_cleanup, source_branch)
390
fetch_spec_factory.source_branch = source_branch
391
# if a stacked branch wasn't requested, we don't create one
392
# even if the origin was stacked
393
if stacked and source_branch is not None:
394
stacked_branch_url = self.root_transport.base
396
stacked_branch_url = None
397
repository_policy = result.determine_repository_policy(
398
force_new_repo, stacked_branch_url, require_stacking=stacked)
399
result_repo, is_new_repo = repository_policy.acquire_repository(
400
possible_transports=possible_transports)
401
add_cleanup(result_repo.lock_write().unlock)
402
fetch_spec_factory.source_repo = source_repository
403
fetch_spec_factory.target_repo = result_repo
404
if stacked or (len(result_repo._fallback_repositories) != 0):
405
target_repo_kind = fetch.TargetRepoKinds.STACKED
407
target_repo_kind = fetch.TargetRepoKinds.EMPTY
409
target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
410
fetch_spec_factory.target_repo_kind = target_repo_kind
411
if source_repository is not None:
412
fetch_spec = fetch_spec_factory.make_fetch_spec()
413
result_repo.fetch(source_repository, fetch_spec=fetch_spec)
415
if source_branch is None:
416
# this is for sprouting a controldir without a branch; is that
418
# Not especially, but it's part of the contract.
419
result_branch = result.create_branch()
421
result_branch = source_branch.sprout(result,
422
revision_id=revision_id, repository_policy=repository_policy,
423
repository=result_repo)
424
mutter("created new branch %r" % (result_branch,))
426
# Create/update the result working tree
427
if (create_tree_if_local and not result.has_workingtree() and
428
isinstance(target_transport, local.LocalTransport) and
429
(result_repo is None or result_repo.make_working_trees())):
430
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
431
hardlink=hardlink, from_branch=result_branch)
434
if wt.path2id('') is None:
436
wt.set_root_id(self.open_workingtree.get_root_id())
437
except errors.NoWorkingTree:
443
if recurse == 'down':
446
basis = wt.basis_tree()
447
elif result_branch is not None:
448
basis = result_branch.basis_tree()
449
elif source_branch is not None:
450
basis = source_branch.basis_tree()
451
if basis is not None:
452
add_cleanup(basis.lock_read().unlock)
453
subtrees = basis.iter_references()
456
for path, file_id in subtrees:
457
target = urlutils.join(url, urlutils.escape(path))
458
sublocation = source_branch.reference_parent(file_id, path)
459
sublocation.bzrdir.sprout(target,
460
basis.get_reference_revision(file_id, path),
461
force_new_repo=force_new_repo, recurse=recurse,
479
def create_standalone_workingtree(base, format=None):
480
"""Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
482
'base' must be a local path or a file:// url.
484
This will use the current default BzrDirFormat unless one is
485
specified, and use whatever
486
repository format that that uses for bzrdirformat.create_workingtree,
487
create_branch and create_repository.
489
:param format: Override for the bzrdir format to create.
490
:return: The WorkingTree object.
492
t = get_transport(base)
493
if not isinstance(t, local.LocalTransport):
494
raise errors.NotLocalUrl(base)
495
bzrdir = BzrDir.create_branch_and_repo(base,
497
format=format).bzrdir
498
return bzrdir.create_workingtree()
465
@deprecated_method(deprecated_in((2, 3, 0)))
500
466
def generate_backup_name(self, base):
501
"""Generate a non-existing backup file name based on base."""
503
name = "%s.~%d~" % (base, counter)
504
while self.root_transport.has(name):
506
name = "%s.~%d~" % (base, counter)
467
return self._available_backup_name(base)
469
def _available_backup_name(self, base):
470
"""Find a non-existing backup file name based on base.
472
See bzrlib.osutils.available_backup_name about race conditions.
474
return osutils.available_backup_name(base, self.root_transport.has)
509
476
def backup_bzrdir(self):
510
477
"""Backup this bzr control directory.
699
664
# add new tests for it to the appropriate place.
700
665
return filename == '.bzr' or filename.startswith('.bzr/')
703
def open_unsupported(base):
704
"""Open a branch which is not supported."""
705
return BzrDir.open(base, _unsupported=True)
708
def open(base, _unsupported=False, possible_transports=None):
709
"""Open an existing bzrdir, rooted at 'base' (url).
711
:param _unsupported: a private parameter to the BzrDir class.
713
t = get_transport(base, possible_transports=possible_transports)
714
return BzrDir.open_from_transport(t, _unsupported=_unsupported)
717
def open_from_transport(transport, _unsupported=False,
718
_server_formats=True):
719
"""Open a bzrdir within a particular directory.
721
:param transport: Transport containing the bzrdir.
722
:param _unsupported: private.
724
for hook in BzrDir.hooks['pre_open']:
726
# Keep initial base since 'transport' may be modified while following
728
base = transport.base
729
def find_format(transport):
730
return transport, controldir.ControlDirFormat.find_format(
731
transport, _server_formats=_server_formats)
733
def redirected(transport, e, redirection_notice):
734
redirected_transport = transport._redirected_to(e.source, e.target)
735
if redirected_transport is None:
736
raise errors.NotBranchError(base)
737
note('%s is%s redirected to %s',
738
transport.base, e.permanently, redirected_transport.base)
739
return redirected_transport
742
transport, format = do_catching_redirections(find_format,
745
except errors.TooManyRedirections:
746
raise errors.NotBranchError(base)
748
BzrDir._check_supported(format, _unsupported)
749
return format.open(transport, _found=True)
752
def open_containing(url, possible_transports=None):
753
"""Open an existing branch which contains url.
755
:param url: url to search from.
756
See open_containing_from_transport for more detail.
758
transport = get_transport(url, possible_transports)
759
return BzrDir.open_containing_from_transport(transport)
762
def open_containing_from_transport(a_transport):
763
"""Open an existing branch which contains a_transport.base.
765
This probes for a branch at a_transport, and searches upwards from there.
767
Basically we keep looking up until we find the control directory or
768
run into the root. If there isn't one, raises NotBranchError.
769
If there is one and it is either an unrecognised format or an unsupported
770
format, UnknownFormatError or UnsupportedFormatError are raised.
771
If there is one, it is returned, along with the unused portion of url.
773
:return: The BzrDir that contains the path, and a Unicode path
774
for the rest of the URL.
776
# this gets the normalised url back. I.e. '.' -> the full path.
777
url = a_transport.base
780
result = BzrDir.open_from_transport(a_transport)
781
return result, urlutils.unescape(a_transport.relpath(url))
782
except errors.NotBranchError, e:
785
new_t = a_transport.clone('..')
786
except errors.InvalidURLJoin:
787
# reached the root, whatever that may be
788
raise errors.NotBranchError(path=url)
789
if new_t.base == a_transport.base:
790
# reached the root, whatever that may be
791
raise errors.NotBranchError(path=url)
795
def open_tree_or_branch(klass, location):
796
"""Return the branch and working tree at a location.
798
If there is no tree at the location, tree will be None.
799
If there is no branch at the location, an exception will be
801
:return: (tree, branch)
803
bzrdir = klass.open(location)
804
return bzrdir._get_tree_branch()
807
def open_containing_tree_or_branch(klass, location):
808
"""Return the branch and working tree contained by a location.
810
Returns (tree, branch, relpath).
811
If there is no tree at containing the location, tree will be None.
812
If there is no branch containing the location, an exception will be
814
relpath is the portion of the path that is contained by the branch.
816
bzrdir, relpath = klass.open_containing(location)
817
tree, branch = bzrdir._get_tree_branch()
818
return tree, branch, relpath
821
def open_containing_tree_branch_or_repository(klass, location):
822
"""Return the working tree, branch and repo contained by a location.
824
Returns (tree, branch, repository, relpath).
825
If there is no tree containing the location, tree will be None.
826
If there is no branch containing the location, branch will be None.
827
If there is no repository containing the location, repository will be
829
relpath is the portion of the path that is contained by the innermost
832
If no tree, branch or repository is found, a NotBranchError is raised.
834
bzrdir, relpath = klass.open_containing(location)
836
tree, branch = bzrdir._get_tree_branch()
837
except errors.NotBranchError:
839
repo = bzrdir.find_repository()
840
return None, None, repo, relpath
841
except (errors.NoRepositoryPresent):
842
raise errors.NotBranchError(location)
843
return tree, branch, branch.repository, relpath
845
667
def _cloning_metadir(self):
846
668
"""Produce a metadir suitable for cloning with.
915
776
can be reused to share a remote connection.
917
778
if cls is not BzrDir:
918
raise AssertionError("BzrDir.create always creates the"
779
raise AssertionError("BzrDir.create always creates the "
919
780
"default format, not one of %r" % cls)
920
t = get_transport(base, possible_transports)
923
format = controldir.ControlDirFormat.get_default_format()
924
return format.initialize_on_transport(t)
928
class BzrDirHooks(hooks.Hooks):
929
"""Hooks for BzrDir operations."""
932
"""Create the default hooks."""
933
hooks.Hooks.__init__(self)
934
self.create_hook(hooks.HookPoint('pre_open',
935
"Invoked before attempting to open a BzrDir with the transport "
936
"that the open will use.", (1, 14), None))
937
self.create_hook(hooks.HookPoint('post_repo_init',
938
"Invoked after a repository has been initialized. "
939
"post_repo_init is called with a "
940
"bzrlib.bzrdir.RepoInitHookParams.",
943
# install the default hooks
944
BzrDir.hooks = BzrDirHooks()
947
class RepoInitHookParams(object):
948
"""Object holding parameters passed to *_repo_init hooks.
950
There are 4 fields that hooks may wish to access:
952
:ivar repository: Repository created
953
:ivar format: Repository format
954
:ivar bzrdir: The bzrdir for the repository
955
:ivar shared: The repository is shared
958
def __init__(self, repository, format, a_bzrdir, shared):
959
"""Create a group of RepoInitHook parameters.
961
:param repository: Repository created
962
:param format: Repository format
963
:param bzrdir: The bzrdir for the repository
964
:param shared: The repository is shared
966
self.repository = repository
968
self.bzrdir = a_bzrdir
971
def __eq__(self, other):
972
return self.__dict__ == other.__dict__
781
return controldir.ControlDir.create(base, format=format,
782
possible_transports=possible_transports)
974
784
def __repr__(self):
976
return "<%s for %s>" % (self.__class__.__name__,
979
return "<%s for %s>" % (self.__class__.__name__,
983
class BzrDirPreSplitOut(BzrDir):
984
"""A common class for the all-in-one formats."""
986
def __init__(self, _transport, _format):
987
"""See BzrDir.__init__."""
988
super(BzrDirPreSplitOut, self).__init__(_transport, _format)
989
self._control_files = lockable_files.LockableFiles(
990
self.get_branch_transport(None),
991
self._format._lock_file_name,
992
self._format._lock_class)
994
def break_lock(self):
995
"""Pre-splitout bzrdirs do not suffer from stale locks."""
996
raise NotImplementedError(self.break_lock)
998
def cloning_metadir(self, require_stacking=False):
999
"""Produce a metadir suitable for cloning with."""
1000
if require_stacking:
1001
return controldir.format_registry.make_bzrdir('1.6')
1002
return self._format.__class__()
1004
def clone(self, url, revision_id=None, force_new_repo=False,
1005
preserve_stacking=False):
1006
"""See BzrDir.clone().
1008
force_new_repo has no effect, since this family of formats always
1009
require a new repository.
1010
preserve_stacking has no effect, since no source branch using this
1011
family of formats can be stacked, so there is no stacking to preserve.
1013
self._make_tail(url)
1014
result = self._format._initialize_for_clone(url)
1015
self.open_repository().clone(result, revision_id=revision_id)
1016
from_branch = self.open_branch()
1017
from_branch.clone(result, revision_id=revision_id)
1019
tree = self.open_workingtree()
1020
except errors.NotLocalUrl:
1021
# make a new one, this format always has to have one.
1022
result._init_workingtree()
1027
def create_branch(self, name=None):
1028
"""See BzrDir.create_branch."""
1029
return self._format.get_branch_format().initialize(self, name=name)
1031
def destroy_branch(self, name=None):
1032
"""See BzrDir.destroy_branch."""
1033
raise errors.UnsupportedOperation(self.destroy_branch, self)
1035
def create_repository(self, shared=False):
1036
"""See BzrDir.create_repository."""
1038
raise errors.IncompatibleFormat('shared repository', self._format)
1039
return self.open_repository()
1041
def destroy_repository(self):
1042
"""See BzrDir.destroy_repository."""
1043
raise errors.UnsupportedOperation(self.destroy_repository, self)
1045
def create_workingtree(self, revision_id=None, from_branch=None,
1046
accelerator_tree=None, hardlink=False):
1047
"""See BzrDir.create_workingtree."""
1048
# The workingtree is sometimes created when the bzrdir is created,
1049
# but not when cloning.
1051
# this looks buggy but is not -really-
1052
# because this format creates the workingtree when the bzrdir is
1054
# clone and sprout will have set the revision_id
1055
# and that will have set it for us, its only
1056
# specific uses of create_workingtree in isolation
1057
# that can do wonky stuff here, and that only
1058
# happens for creating checkouts, which cannot be
1059
# done on this format anyway. So - acceptable wart.
1061
warning("can't support hardlinked working trees in %r"
1064
result = self.open_workingtree(recommend_upgrade=False)
1065
except errors.NoSuchFile:
1066
result = self._init_workingtree()
1067
if revision_id is not None:
1068
if revision_id == _mod_revision.NULL_REVISION:
1069
result.set_parent_ids([])
1071
result.set_parent_ids([revision_id])
1074
def _init_workingtree(self):
1075
from bzrlib.workingtree import WorkingTreeFormat2
1077
return WorkingTreeFormat2().initialize(self)
1078
except errors.NotLocalUrl:
1079
# Even though we can't access the working tree, we need to
1080
# create its control files.
1081
return WorkingTreeFormat2()._stub_initialize_on_transport(
1082
self.transport, self._control_files._file_mode)
1084
def destroy_workingtree(self):
1085
"""See BzrDir.destroy_workingtree."""
1086
raise errors.UnsupportedOperation(self.destroy_workingtree, self)
1088
def destroy_workingtree_metadata(self):
1089
"""See BzrDir.destroy_workingtree_metadata."""
1090
raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
1093
def get_branch_transport(self, branch_format, name=None):
1094
"""See BzrDir.get_branch_transport()."""
1095
if name is not None:
1096
raise errors.NoColocatedBranchSupport(self)
1097
if branch_format is None:
1098
return self.transport
1100
branch_format.get_format_string()
1101
except NotImplementedError:
1102
return self.transport
1103
raise errors.IncompatibleFormat(branch_format, self._format)
1105
def get_repository_transport(self, repository_format):
1106
"""See BzrDir.get_repository_transport()."""
1107
if repository_format is None:
1108
return self.transport
1110
repository_format.get_format_string()
1111
except NotImplementedError:
1112
return self.transport
1113
raise errors.IncompatibleFormat(repository_format, self._format)
1115
def get_workingtree_transport(self, workingtree_format):
1116
"""See BzrDir.get_workingtree_transport()."""
1117
if workingtree_format is None:
1118
return self.transport
1120
workingtree_format.get_format_string()
1121
except NotImplementedError:
1122
return self.transport
1123
raise errors.IncompatibleFormat(workingtree_format, self._format)
1125
def needs_format_conversion(self, format=None):
1126
"""See BzrDir.needs_format_conversion()."""
1127
# if the format is not the same as the system default,
1128
# an upgrade is needed.
1130
symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1131
% 'needs_format_conversion(format=None)')
1132
format = BzrDirFormat.get_default_format()
1133
return not isinstance(self._format, format.__class__)
1135
def open_branch(self, name=None, unsupported=False,
1136
ignore_fallbacks=False):
1137
"""See BzrDir.open_branch."""
1138
from bzrlib.branch import BzrBranchFormat4
1139
format = BzrBranchFormat4()
1140
self._check_supported(format, unsupported)
1141
return format.open(self, name, _found=True)
1143
def sprout(self, url, revision_id=None, force_new_repo=False,
1144
possible_transports=None, accelerator_tree=None,
1145
hardlink=False, stacked=False, create_tree_if_local=True,
1146
source_branch=None):
1147
"""See BzrDir.sprout()."""
1148
if source_branch is not None:
1149
my_branch = self.open_branch()
1150
if source_branch.base != my_branch.base:
1151
raise AssertionError(
1152
"source branch %r is not within %r with branch %r" %
1153
(source_branch, self, my_branch))
1155
raise errors.UnstackableBranchFormat(
1156
self._format, self.root_transport.base)
1157
if not create_tree_if_local:
1158
raise errors.MustHaveWorkingTree(
1159
self._format, self.root_transport.base)
1160
from bzrlib.workingtree import WorkingTreeFormat2
1161
self._make_tail(url)
1162
result = self._format._initialize_for_clone(url)
1164
self.open_repository().clone(result, revision_id=revision_id)
1165
except errors.NoRepositoryPresent:
1168
self.open_branch().sprout(result, revision_id=revision_id)
1169
except errors.NotBranchError:
1172
# we always want a working tree
1173
WorkingTreeFormat2().initialize(result,
1174
accelerator_tree=accelerator_tree,
1179
class BzrDir4(BzrDirPreSplitOut):
1180
"""A .bzr version 4 control object.
1182
This is a deprecated format and may be removed after sept 2006.
1185
def create_repository(self, shared=False):
1186
"""See BzrDir.create_repository."""
1187
return self._format.repository_format.initialize(self, shared)
1189
def needs_format_conversion(self, format=None):
1190
"""Format 4 dirs are always in need of conversion."""
1192
symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1193
% 'needs_format_conversion(format=None)')
1196
def open_repository(self):
1197
"""See BzrDir.open_repository."""
1198
from bzrlib.repofmt.weaverepo import RepositoryFormat4
1199
return RepositoryFormat4().open(self, _found=True)
1202
class BzrDir5(BzrDirPreSplitOut):
1203
"""A .bzr version 5 control object.
1205
This is a deprecated format and may be removed after sept 2006.
1208
def has_workingtree(self):
1209
"""See BzrDir.has_workingtree."""
1212
def open_repository(self):
1213
"""See BzrDir.open_repository."""
1214
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1215
return RepositoryFormat5().open(self, _found=True)
1217
def open_workingtree(self, _unsupported=False,
1218
recommend_upgrade=True):
1219
"""See BzrDir.create_workingtree."""
1220
from bzrlib.workingtree import WorkingTreeFormat2
1221
wt_format = WorkingTreeFormat2()
1222
# we don't warn here about upgrades; that ought to be handled for the
1224
return wt_format.open(self, _found=True)
1227
class BzrDir6(BzrDirPreSplitOut):
1228
"""A .bzr version 6 control object.
1230
This is a deprecated format and may be removed after sept 2006.
1233
def has_workingtree(self):
1234
"""See BzrDir.has_workingtree."""
1237
def open_repository(self):
1238
"""See BzrDir.open_repository."""
1239
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1240
return RepositoryFormat6().open(self, _found=True)
1242
def open_workingtree(self, _unsupported=False,
1243
recommend_upgrade=True):
1244
"""See BzrDir.create_workingtree."""
1245
# we don't warn here about upgrades; that ought to be handled for the
1247
from bzrlib.workingtree import WorkingTreeFormat2
1248
return WorkingTreeFormat2().open(self, _found=True)
785
return "<%s at %r>" % (self.__class__.__name__, self.user_url)
1251
788
class BzrDirMeta1(BzrDir):
1441
984
return config.TransportConfig(self.transport, 'control.conf')
987
class BzrDirMeta1Colo(BzrDirMeta1):
988
"""BzrDirMeta1 with support for colocated branches.
990
This format is experimental, and will eventually be merged back into
994
def __init__(self, _transport, _format):
995
super(BzrDirMeta1Colo, self).__init__(_transport, _format)
996
self.control_files = lockable_files.LockableFiles(self.control_transport,
997
self._format._lock_file_name, self._format._lock_class)
999
def _get_branch_path(self, name):
1000
"""Obtain the branch path to use.
1002
This uses the API specified branch name first, and then falls back to
1003
the branch name specified in the URL. If neither of those is specified,
1004
it uses the default branch.
1006
:param name: Optional branch name to use
1007
:return: Relative path to branch
1011
return urlutils.join('branches', name.encode("utf-8"))
1013
def _read_branch_list(self):
1014
"""Read the branch list.
1016
:return: List of utf-8 encoded branch names.
1019
f = self.control_transport.get('branch-list')
1020
except errors.NoSuchFile:
1026
ret.append(name.rstrip("\n"))
1031
def _write_branch_list(self, branches):
1032
"""Write out the branch list.
1034
:param branches: List of utf-8 branch names to write
1036
self.transport.put_bytes('branch-list',
1037
"".join([name+"\n" for name in branches]))
1039
def destroy_branch(self, name=None):
1040
"""See BzrDir.create_branch."""
1042
name = self._get_selected_branch()
1043
path = self._get_branch_path(name)
1044
if name is not None:
1045
self.control_files.lock_write()
1047
branches = self._read_branch_list()
1049
branches.remove(name.encode("utf-8"))
1051
raise errors.NotBranchError(name)
1052
self._write_branch_list(branches)
1054
self.control_files.unlock()
1055
self.transport.delete_tree(path)
1057
def get_branches(self):
1058
"""See ControlDir.get_branches."""
1061
ret[None] = self.open_branch()
1062
except (errors.NotBranchError, errors.NoRepositoryPresent):
1065
for name in self._read_branch_list():
1066
ret[name] = self.open_branch(name.decode('utf-8'))
1070
def get_branch_transport(self, branch_format, name=None):
1071
"""See BzrDir.get_branch_transport()."""
1072
path = self._get_branch_path(name)
1073
# XXX: this shouldn't implicitly create the directory if it's just
1074
# promising to get a transport -- mbp 20090727
1075
if branch_format is None:
1076
return self.transport.clone(path)
1078
branch_format.get_format_string()
1079
except NotImplementedError:
1080
raise errors.IncompatibleFormat(branch_format, self._format)
1081
if name is not None:
1083
self.transport.mkdir('branches', mode=self._get_mkdir_mode())
1084
except errors.FileExists:
1086
branches = self._read_branch_list()
1087
utf8_name = name.encode("utf-8")
1088
if not utf8_name in branches:
1089
self.control_files.lock_write()
1091
branches = self._read_branch_list()
1092
branches.append(utf8_name)
1093
self._write_branch_list(branches)
1095
self.control_files.unlock()
1097
self.transport.mkdir(path, mode=self._get_mkdir_mode())
1098
except errors.FileExists:
1100
return self.transport.clone(path)
1103
class BzrDirMetaComponentFormat(controldir.ControlComponentFormat):
1104
"""Base class for all formats of things living in metadirs.
1106
This class manages the format string that is stored in the 'format'
1107
or 'branch-format' file.
1109
All classes for (branch-, repository-, workingtree-) formats that
1110
live in meta directories and have their own 'format' file
1111
(i.e. different from .bzr/branch-format) derive from this class,
1112
as well as the relevant base class for their kind
1113
(BranchFormat, WorkingTreeFormat, RepositoryFormat).
1117
def get_format_string(cls):
1118
"""Return the ASCII format string that identifies this format."""
1119
raise NotImplementedError(cls.get_format_string)
1122
def from_string(cls, format_string):
1123
if format_string != cls.get_format_string():
1124
raise ValueError("Invalid format header %r" % format_string)
1128
def _find_format(klass, registry, kind, format_string):
1130
cls = registry.get(format_string)
1132
raise errors.UnknownFormatError(format=format_string, kind=kind)
1135
def network_name(self):
1136
"""A simple byte string uniquely identifying this format for RPC calls.
1138
Metadir branch formats use their format string.
1140
return self.get_format_string()
1142
def __eq__(self, other):
1143
return (self.__class__ is other.__class__)
1444
1146
class BzrProber(controldir.Prober):
1445
1147
"""Prober for formats that use a .bzr/ control directory."""
1149
formats = registry.FormatRegistry(controldir.network_format_registry)
1448
1150
"""The known .bzr formats."""
1153
@deprecated_method(deprecated_in((2, 4, 0)))
1451
1154
def register_bzrdir_format(klass, format):
1452
klass._formats[format.get_format_string()] = format
1155
klass.formats.register(format.get_format_string(), format)
1158
@deprecated_method(deprecated_in((2, 4, 0)))
1455
1159
def unregister_bzrdir_format(klass, format):
1456
del klass._formats[format.get_format_string()]
1160
klass.formats.remove(format.get_format_string())
1459
1163
def probe_transport(klass, transport):
1720
def unregister_format(klass, format):
1721
BzrProber.unregister_bzrdir_format(format)
1722
controldir.ControlDirFormat.unregister_format(format)
1723
controldir.network_format_registry.remove(format.get_format_string())
1726
class BzrDirFormat4(BzrDirFormat):
1727
"""Bzr dir format 4.
1729
This format is a combined format for working tree, branch and repository.
1731
- Format 1 working trees [always]
1732
- Format 4 branches [always]
1733
- Format 4 repositories [always]
1735
This format is deprecated: it indexes texts using a text it which is
1736
removed in format 5; write support for this format has been removed.
1739
_lock_class = lockable_files.TransportLock
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
def initialize_on_transport_ex(self, transport, use_existing_dir=False,
1785
create_prefix=False, force_new_repo=False, stacked_on=None,
1786
stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
1788
"""See BzrDirFormat.initialize_on_transport_ex."""
1789
require_stacking = (stacked_on is not None)
1790
# Format 5 cannot stack, but we've been asked to - actually init
1792
if require_stacking:
1793
format = BzrDirMetaFormat1()
1794
return format.initialize_on_transport_ex(transport,
1795
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
1796
force_new_repo=force_new_repo, stacked_on=stacked_on,
1797
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
1798
make_working_trees=make_working_trees, shared_repo=shared_repo)
1799
return BzrDirFormat.initialize_on_transport_ex(self, transport,
1800
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
1801
force_new_repo=force_new_repo, stacked_on=stacked_on,
1802
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
1803
make_working_trees=make_working_trees, shared_repo=shared_repo)
1806
class BzrDirFormat5(BzrDirFormatAllInOne):
1807
"""Bzr control format 5.
1809
This format is a combined format for working tree, branch and repository.
1811
- Format 2 working trees [always]
1812
- Format 4 branches [always]
1813
- Format 5 repositories [always]
1814
Unhashed stores in the repository.
1817
_lock_class = lockable_files.TransportLock
1819
def get_format_string(self):
1820
"""See BzrDirFormat.get_format_string()."""
1821
return "Bazaar-NG branch, format 5\n"
1823
def get_branch_format(self):
1824
from bzrlib import branch
1825
return branch.BzrBranchFormat4()
1827
def get_format_description(self):
1828
"""See BzrDirFormat.get_format_description()."""
1829
return "All-in-one format 5"
1831
def get_converter(self, format=None):
1832
"""See BzrDirFormat.get_converter()."""
1833
# there is one and only one upgrade path here.
1834
return ConvertBzrDir5To6()
1836
def _initialize_for_clone(self, url):
1837
return self.initialize_on_transport(get_transport(url), _cloning=True)
1839
def initialize_on_transport(self, transport, _cloning=False):
1840
"""Format 5 dirs always have working tree, branch and repository.
1842
Except when they are being cloned.
1844
from bzrlib.branch import BzrBranchFormat4
1845
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1846
result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
1847
RepositoryFormat5().initialize(result, _internal=True)
1849
branch = BzrBranchFormat4().initialize(result)
1850
result._init_workingtree()
1853
def network_name(self):
1854
return self.get_format_string()
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(BzrDirFormatAllInOne):
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_branch_format(self):
1888
from bzrlib import branch
1889
return branch.BzrBranchFormat4()
1891
def get_converter(self, format=None):
1892
"""See BzrDirFormat.get_converter()."""
1893
# there is one and only one upgrade path here.
1894
return ConvertBzrDir6ToMeta()
1896
def _initialize_for_clone(self, url):
1897
return self.initialize_on_transport(get_transport(url), _cloning=True)
1899
def initialize_on_transport(self, transport, _cloning=False):
1900
"""Format 6 dirs always have working tree, branch and repository.
1902
Except when they are being cloned.
1904
from bzrlib.branch import BzrBranchFormat4
1905
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1906
result = super(BzrDirFormat6, self).initialize_on_transport(transport)
1907
RepositoryFormat6().initialize(result, _internal=True)
1909
branch = BzrBranchFormat4().initialize(result)
1910
result._init_workingtree()
1913
def network_name(self):
1914
return self.get_format_string()
1916
def _open(self, transport):
1917
"""See BzrDirFormat._open."""
1918
return BzrDir6(transport, self)
1920
def __return_repository_format(self):
1921
"""Circular import protection."""
1922
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1923
return RepositoryFormat6()
1924
repository_format = property(__return_repository_format)
1435
def supports_transport(self, transport):
1436
# bzr formats can be opened over all known transports
1927
1440
class BzrDirMetaFormat1(BzrDirFormat):
2119
1652
def __get_workingtree_format(self):
2120
1653
if self._workingtree_format is None:
2121
from bzrlib.workingtree import WorkingTreeFormat
2122
self._workingtree_format = WorkingTreeFormat.get_default_format()
1654
from bzrlib.workingtree import (
1655
format_registry as wt_format_registry,
1657
self._workingtree_format = wt_format_registry.get_default()
2123
1658
return self._workingtree_format
2125
1660
def __set_workingtree_format(self, wt_format):
2126
1661
self._workingtree_format = wt_format
1664
return "<%r>" % (self.__class__.__name__,)
2128
1666
workingtree_format = property(__get_workingtree_format,
2129
1667
__set_workingtree_format)
2132
1670
# Register bzr formats
2133
BzrDirFormat.register_format(BzrDirFormat4())
2134
BzrDirFormat.register_format(BzrDirFormat5())
2135
BzrDirFormat.register_format(BzrDirFormat6())
2136
__default_format = BzrDirMetaFormat1()
2137
BzrDirFormat.register_format(__default_format)
2138
controldir.ControlDirFormat._default_format = __default_format
2141
class Converter(object):
2142
"""Converts a disk format object from one format to another."""
2144
def convert(self, to_convert, pb):
2145
"""Perform the conversion of to_convert, giving feedback via pb.
2147
:param to_convert: The disk object to convert.
2148
:param pb: a progress bar to use for progress information.
2151
def step(self, message):
2152
"""Update the pb by a step."""
2154
self.pb.update(message, self.count, self.total)
2157
class ConvertBzrDir4To5(Converter):
2158
"""Converts format 4 bzr dirs to format 5."""
2161
super(ConvertBzrDir4To5, self).__init__()
2162
self.converted_revs = set()
2163
self.absent_revisions = set()
2167
def convert(self, to_convert, pb):
2168
"""See Converter.convert()."""
2169
self.bzrdir = to_convert
2171
warnings.warn("pb parameter to convert() is deprecated")
2172
self.pb = ui.ui_factory.nested_progress_bar()
2174
ui.ui_factory.note('starting upgrade from format 4 to 5')
2175
if isinstance(self.bzrdir.transport, local.LocalTransport):
2176
self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
2177
self._convert_to_weaves()
2178
return BzrDir.open(self.bzrdir.user_url)
2182
def _convert_to_weaves(self):
2183
ui.ui_factory.note('note: upgrade may be faster if all store files are ungzipped first')
2186
stat = self.bzrdir.transport.stat('weaves')
2187
if not S_ISDIR(stat.st_mode):
2188
self.bzrdir.transport.delete('weaves')
2189
self.bzrdir.transport.mkdir('weaves')
2190
except errors.NoSuchFile:
2191
self.bzrdir.transport.mkdir('weaves')
2192
# deliberately not a WeaveFile as we want to build it up slowly.
2193
self.inv_weave = Weave('inventory')
2194
# holds in-memory weaves for all files
2195
self.text_weaves = {}
2196
self.bzrdir.transport.delete('branch-format')
2197
self.branch = self.bzrdir.open_branch()
2198
self._convert_working_inv()
2199
rev_history = self.branch.revision_history()
2200
# to_read is a stack holding the revisions we still need to process;
2201
# appending to it adds new highest-priority revisions
2202
self.known_revisions = set(rev_history)
2203
self.to_read = rev_history[-1:]
2205
rev_id = self.to_read.pop()
2206
if (rev_id not in self.revisions
2207
and rev_id not in self.absent_revisions):
2208
self._load_one_rev(rev_id)
2210
to_import = self._make_order()
2211
for i, rev_id in enumerate(to_import):
2212
self.pb.update('converting revision', i, len(to_import))
2213
self._convert_one_rev(rev_id)
2215
self._write_all_weaves()
2216
self._write_all_revs()
2217
ui.ui_factory.note('upgraded to weaves:')
2218
ui.ui_factory.note(' %6d revisions and inventories' % len(self.revisions))
2219
ui.ui_factory.note(' %6d revisions not present' % len(self.absent_revisions))
2220
ui.ui_factory.note(' %6d texts' % self.text_count)
2221
self._cleanup_spare_files_after_format4()
2222
self.branch._transport.put_bytes(
2224
BzrDirFormat5().get_format_string(),
2225
mode=self.bzrdir._get_file_mode())
2227
def _cleanup_spare_files_after_format4(self):
2228
# FIXME working tree upgrade foo.
2229
for n in 'merged-patches', 'pending-merged-patches':
2231
## assert os.path.getsize(p) == 0
2232
self.bzrdir.transport.delete(n)
2233
except errors.NoSuchFile:
2235
self.bzrdir.transport.delete_tree('inventory-store')
2236
self.bzrdir.transport.delete_tree('text-store')
2238
def _convert_working_inv(self):
2239
inv = xml4.serializer_v4.read_inventory(
2240
self.branch._transport.get('inventory'))
2241
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv, working=True)
2242
self.branch._transport.put_bytes('inventory', new_inv_xml,
2243
mode=self.bzrdir._get_file_mode())
2245
def _write_all_weaves(self):
2246
controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
2247
weave_transport = self.bzrdir.transport.clone('weaves')
2248
weaves = WeaveStore(weave_transport, prefixed=False)
2249
transaction = WriteTransaction()
2253
for file_id, file_weave in self.text_weaves.items():
2254
self.pb.update('writing weave', i, len(self.text_weaves))
2255
weaves._put_weave(file_id, file_weave, transaction)
2257
self.pb.update('inventory', 0, 1)
2258
controlweaves._put_weave('inventory', self.inv_weave, transaction)
2259
self.pb.update('inventory', 1, 1)
2263
def _write_all_revs(self):
2264
"""Write all revisions out in new form."""
2265
self.bzrdir.transport.delete_tree('revision-store')
2266
self.bzrdir.transport.mkdir('revision-store')
2267
revision_transport = self.bzrdir.transport.clone('revision-store')
2269
from bzrlib.xml5 import serializer_v5
2270
from bzrlib.repofmt.weaverepo import RevisionTextStore
2271
revision_store = RevisionTextStore(revision_transport,
2272
serializer_v5, False, versionedfile.PrefixMapper(),
2273
lambda:True, lambda:True)
2275
for i, rev_id in enumerate(self.converted_revs):
2276
self.pb.update('write revision', i, len(self.converted_revs))
2277
text = serializer_v5.write_revision_to_string(
2278
self.revisions[rev_id])
2280
revision_store.add_lines(key, None, osutils.split_lines(text))
2284
def _load_one_rev(self, rev_id):
2285
"""Load a revision object into memory.
2287
Any parents not either loaded or abandoned get queued to be
2289
self.pb.update('loading revision',
2290
len(self.revisions),
2291
len(self.known_revisions))
2292
if not self.branch.repository.has_revision(rev_id):
2294
ui.ui_factory.note('revision {%s} not present in branch; '
2295
'will be converted as a ghost' %
2297
self.absent_revisions.add(rev_id)
2299
rev = self.branch.repository.get_revision(rev_id)
2300
for parent_id in rev.parent_ids:
2301
self.known_revisions.add(parent_id)
2302
self.to_read.append(parent_id)
2303
self.revisions[rev_id] = rev
2305
def _load_old_inventory(self, rev_id):
2306
f = self.branch.repository.inventory_store.get(rev_id)
2308
old_inv_xml = f.read()
2311
inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
2312
inv.revision_id = rev_id
2313
rev = self.revisions[rev_id]
2316
def _load_updated_inventory(self, rev_id):
2317
inv_xml = self.inv_weave.get_text(rev_id)
2318
inv = xml5.serializer_v5.read_inventory_from_string(inv_xml, rev_id)
2321
def _convert_one_rev(self, rev_id):
2322
"""Convert revision and all referenced objects to new format."""
2323
rev = self.revisions[rev_id]
2324
inv = self._load_old_inventory(rev_id)
2325
present_parents = [p for p in rev.parent_ids
2326
if p not in self.absent_revisions]
2327
self._convert_revision_contents(rev, inv, present_parents)
2328
self._store_new_inv(rev, inv, present_parents)
2329
self.converted_revs.add(rev_id)
2331
def _store_new_inv(self, rev, inv, present_parents):
2332
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
2333
new_inv_sha1 = sha_string(new_inv_xml)
2334
self.inv_weave.add_lines(rev.revision_id,
2336
new_inv_xml.splitlines(True))
2337
rev.inventory_sha1 = new_inv_sha1
2339
def _convert_revision_contents(self, rev, inv, present_parents):
2340
"""Convert all the files within a revision.
2342
Also upgrade the inventory to refer to the text revision ids."""
2343
rev_id = rev.revision_id
2344
mutter('converting texts of revision {%s}',
2346
parent_invs = map(self._load_updated_inventory, present_parents)
2347
entries = inv.iter_entries()
2349
for path, ie in entries:
2350
self._convert_file_version(rev, ie, parent_invs)
2352
def _convert_file_version(self, rev, ie, parent_invs):
2353
"""Convert one version of one file.
2355
The file needs to be added into the weave if it is a merge
2356
of >=2 parents or if it's changed from its parent.
2358
file_id = ie.file_id
2359
rev_id = rev.revision_id
2360
w = self.text_weaves.get(file_id)
2363
self.text_weaves[file_id] = w
2364
text_changed = False
2365
parent_candiate_entries = ie.parent_candidates(parent_invs)
2366
heads = graph.Graph(self).heads(parent_candiate_entries.keys())
2367
# XXX: Note that this is unordered - and this is tolerable because
2368
# the previous code was also unordered.
2369
previous_entries = dict((head, parent_candiate_entries[head]) for head
2371
self.snapshot_ie(previous_entries, ie, w, rev_id)
2373
def get_parent_map(self, revision_ids):
2374
"""See graph.StackedParentsProvider.get_parent_map"""
2375
return dict((revision_id, self.revisions[revision_id])
2376
for revision_id in revision_ids
2377
if revision_id in self.revisions)
2379
def snapshot_ie(self, previous_revisions, ie, w, rev_id):
2380
# TODO: convert this logic, which is ~= snapshot to
2381
# a call to:. This needs the path figured out. rather than a work_tree
2382
# a v4 revision_tree can be given, or something that looks enough like
2383
# one to give the file content to the entry if it needs it.
2384
# and we need something that looks like a weave store for snapshot to
2386
#ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
2387
if len(previous_revisions) == 1:
2388
previous_ie = previous_revisions.values()[0]
2389
if ie._unchanged(previous_ie):
2390
ie.revision = previous_ie.revision
2393
f = self.branch.repository._text_store.get(ie.text_id)
2395
file_lines = f.readlines()
2398
w.add_lines(rev_id, previous_revisions, file_lines)
2399
self.text_count += 1
2401
w.add_lines(rev_id, previous_revisions, [])
2402
ie.revision = rev_id
2404
def _make_order(self):
2405
"""Return a suitable order for importing revisions.
2407
The order must be such that an revision is imported after all
2408
its (present) parents.
2410
todo = set(self.revisions.keys())
2411
done = self.absent_revisions.copy()
2414
# scan through looking for a revision whose parents
2416
for rev_id in sorted(list(todo)):
2417
rev = self.revisions[rev_id]
2418
parent_ids = set(rev.parent_ids)
2419
if parent_ids.issubset(done):
2420
# can take this one now
2421
order.append(rev_id)
2427
class ConvertBzrDir5To6(Converter):
2428
"""Converts format 5 bzr dirs to format 6."""
2430
def convert(self, to_convert, pb):
2431
"""See Converter.convert()."""
2432
self.bzrdir = to_convert
2433
pb = ui.ui_factory.nested_progress_bar()
2435
ui.ui_factory.note('starting upgrade from format 5 to 6')
2436
self._convert_to_prefixed()
2437
return BzrDir.open(self.bzrdir.user_url)
2441
def _convert_to_prefixed(self):
2442
from bzrlib.store import TransportStore
2443
self.bzrdir.transport.delete('branch-format')
2444
for store_name in ["weaves", "revision-store"]:
2445
ui.ui_factory.note("adding prefixes to %s" % store_name)
2446
store_transport = self.bzrdir.transport.clone(store_name)
2447
store = TransportStore(store_transport, prefixed=True)
2448
for urlfilename in store_transport.list_dir('.'):
2449
filename = urlutils.unescape(urlfilename)
2450
if (filename.endswith(".weave") or
2451
filename.endswith(".gz") or
2452
filename.endswith(".sig")):
2453
file_id, suffix = os.path.splitext(filename)
2457
new_name = store._mapper.map((file_id,)) + suffix
2458
# FIXME keep track of the dirs made RBC 20060121
2460
store_transport.move(filename, new_name)
2461
except errors.NoSuchFile: # catches missing dirs strangely enough
2462
store_transport.mkdir(osutils.dirname(new_name))
2463
store_transport.move(filename, new_name)
2464
self.bzrdir.transport.put_bytes(
2466
BzrDirFormat6().get_format_string(),
2467
mode=self.bzrdir._get_file_mode())
2470
class ConvertBzrDir6ToMeta(Converter):
2471
"""Converts format 6 bzr dirs to metadirs."""
2473
def convert(self, to_convert, pb):
2474
"""See Converter.convert()."""
2475
from bzrlib.repofmt.weaverepo import RepositoryFormat7
2476
from bzrlib.branch import BzrBranchFormat5
2477
self.bzrdir = to_convert
2478
self.pb = ui.ui_factory.nested_progress_bar()
2480
self.total = 20 # the steps we know about
2481
self.garbage_inventories = []
2482
self.dir_mode = self.bzrdir._get_dir_mode()
2483
self.file_mode = self.bzrdir._get_file_mode()
2485
ui.ui_factory.note('starting upgrade from format 6 to metadir')
2486
self.bzrdir.transport.put_bytes(
2488
"Converting to format 6",
2489
mode=self.file_mode)
2490
# its faster to move specific files around than to open and use the apis...
2491
# first off, nuke ancestry.weave, it was never used.
2493
self.step('Removing ancestry.weave')
2494
self.bzrdir.transport.delete('ancestry.weave')
2495
except errors.NoSuchFile:
2497
# find out whats there
2498
self.step('Finding branch files')
2499
last_revision = self.bzrdir.open_branch().last_revision()
2500
bzrcontents = self.bzrdir.transport.list_dir('.')
2501
for name in bzrcontents:
2502
if name.startswith('basis-inventory.'):
2503
self.garbage_inventories.append(name)
2504
# create new directories for repository, working tree and branch
2505
repository_names = [('inventory.weave', True),
2506
('revision-store', True),
2508
self.step('Upgrading repository ')
2509
self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
2510
self.make_lock('repository')
2511
# we hard code the formats here because we are converting into
2512
# the meta format. The meta format upgrader can take this to a
2513
# future format within each component.
2514
self.put_format('repository', RepositoryFormat7())
2515
for entry in repository_names:
2516
self.move_entry('repository', entry)
2518
self.step('Upgrading branch ')
2519
self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
2520
self.make_lock('branch')
2521
self.put_format('branch', BzrBranchFormat5())
2522
branch_files = [('revision-history', True),
2523
('branch-name', True),
2525
for entry in branch_files:
2526
self.move_entry('branch', entry)
2528
checkout_files = [('pending-merges', True),
2529
('inventory', True),
2530
('stat-cache', False)]
2531
# If a mandatory checkout file is not present, the branch does not have
2532
# a functional checkout. Do not create a checkout in the converted
2534
for name, mandatory in checkout_files:
2535
if mandatory and name not in bzrcontents:
2536
has_checkout = False
2540
if not has_checkout:
2541
ui.ui_factory.note('No working tree.')
2542
# If some checkout files are there, we may as well get rid of them.
2543
for name, mandatory in checkout_files:
2544
if name in bzrcontents:
2545
self.bzrdir.transport.delete(name)
2547
from bzrlib.workingtree import WorkingTreeFormat3
2548
self.step('Upgrading working tree')
2549
self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
2550
self.make_lock('checkout')
2552
'checkout', WorkingTreeFormat3())
2553
self.bzrdir.transport.delete_multi(
2554
self.garbage_inventories, self.pb)
2555
for entry in checkout_files:
2556
self.move_entry('checkout', entry)
2557
if last_revision is not None:
2558
self.bzrdir.transport.put_bytes(
2559
'checkout/last-revision', last_revision)
2560
self.bzrdir.transport.put_bytes(
2562
BzrDirMetaFormat1().get_format_string(),
2563
mode=self.file_mode)
2565
return BzrDir.open(self.bzrdir.user_url)
2567
def make_lock(self, name):
2568
"""Make a lock for the new control dir name."""
2569
self.step('Make %s lock' % name)
2570
ld = lockdir.LockDir(self.bzrdir.transport,
2572
file_modebits=self.file_mode,
2573
dir_modebits=self.dir_mode)
2576
def move_entry(self, new_dir, entry):
2577
"""Move then entry name into new_dir."""
2579
mandatory = entry[1]
2580
self.step('Moving %s' % name)
2582
self.bzrdir.transport.move(name, '%s/%s' % (new_dir, name))
2583
except errors.NoSuchFile:
2587
def put_format(self, dirname, format):
2588
self.bzrdir.transport.put_bytes('%s/format' % dirname,
2589
format.get_format_string(),
2593
class ConvertMetaToMeta(Converter):
1671
BzrProber.formats.register(BzrDirMetaFormat1.get_format_string(),
1673
controldir.ControlDirFormat._default_format = BzrDirMetaFormat1()
1676
class BzrDirMetaFormat1Colo(BzrDirMetaFormat1):
1677
"""BzrDirMeta1 format with support for colocated branches."""
1679
colocated_branches = True
1682
def get_format_string(cls):
1683
"""See BzrDirFormat.get_format_string()."""
1684
return "Bazaar meta directory, format 1 (with colocated branches)\n"
1686
def get_format_description(self):
1687
"""See BzrDirFormat.get_format_description()."""
1688
return "Meta directory format 1 with support for colocated branches"
1690
def _open(self, transport):
1691
"""See BzrDirFormat._open."""
1692
# Create a new format instance because otherwise initialisation of new
1693
# metadirs share the global default format object leading to alias
1695
format = BzrDirMetaFormat1Colo()
1696
self._supply_sub_formats_to(format)
1697
return BzrDirMeta1Colo(transport, format)
1700
BzrProber.formats.register(BzrDirMetaFormat1Colo.get_format_string(),
1701
BzrDirMetaFormat1Colo)
1704
class ConvertMetaToMeta(controldir.Converter):
2594
1705
"""Converts the components of metadirs."""
2596
1707
def __init__(self, target_format):
2669
1779
return to_convert
2672
# This is not in remote.py because it's relatively small, and needs to be
2673
# registered. Putting it in remote.py creates a circular import problem.
2674
# we can make it a lazy object if the control formats is turned into something
2676
class RemoteBzrDirFormat(BzrDirMetaFormat1):
2677
"""Format representing bzrdirs accessed via a smart server"""
2679
supports_workingtrees = False
2682
BzrDirMetaFormat1.__init__(self)
2683
# XXX: It's a bit ugly that the network name is here, because we'd
2684
# like to believe that format objects are stateless or at least
2685
# immutable, However, we do at least avoid mutating the name after
2686
# it's returned. See <https://bugs.launchpad.net/bzr/+bug/504102>
2687
self._network_name = None
2690
return "%s(_network_name=%r)" % (self.__class__.__name__,
2693
def get_format_description(self):
2694
if self._network_name:
2695
real_format = controldir.network_format_registry.get(self._network_name)
2696
return 'Remote: ' + real_format.get_format_description()
2697
return 'bzr remote bzrdir'
2699
def get_format_string(self):
2700
raise NotImplementedError(self.get_format_string)
2702
def network_name(self):
2703
if self._network_name:
2704
return self._network_name
2706
raise AssertionError("No network name set.")
2708
def initialize_on_transport(self, transport):
2710
# hand off the request to the smart server
2711
client_medium = transport.get_smart_medium()
2712
except errors.NoSmartMedium:
2713
# TODO: lookup the local format from a server hint.
2714
local_dir_format = BzrDirMetaFormat1()
2715
return local_dir_format.initialize_on_transport(transport)
2716
client = _SmartClient(client_medium)
2717
path = client.remote_path_from_transport(transport)
2719
response = client.call('BzrDirFormat.initialize', path)
2720
except errors.ErrorFromSmartServer, err:
2721
remote._translate_error(err, path=path)
2722
if response[0] != 'ok':
2723
raise errors.SmartProtocolError('unexpected response code %s' % (response,))
2724
format = RemoteBzrDirFormat()
2725
self._supply_sub_formats_to(format)
2726
return remote.RemoteBzrDir(transport, format)
2728
def parse_NoneTrueFalse(self, arg):
2735
raise AssertionError("invalid arg %r" % arg)
2737
def _serialize_NoneTrueFalse(self, arg):
2744
def _serialize_NoneString(self, arg):
2747
def initialize_on_transport_ex(self, transport, use_existing_dir=False,
2748
create_prefix=False, force_new_repo=False, stacked_on=None,
2749
stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
2752
# hand off the request to the smart server
2753
client_medium = transport.get_smart_medium()
2754
except errors.NoSmartMedium:
2757
# Decline to open it if the server doesn't support our required
2758
# version (3) so that the VFS-based transport will do it.
2759
if client_medium.should_probe():
2761
server_version = client_medium.protocol_version()
2762
if server_version != '2':
2766
except errors.SmartProtocolError:
2767
# Apparently there's no usable smart server there, even though
2768
# the medium supports the smart protocol.
2773
client = _SmartClient(client_medium)
2774
path = client.remote_path_from_transport(transport)
2775
if client_medium._is_remote_before((1, 16)):
2778
# TODO: lookup the local format from a server hint.
2779
local_dir_format = BzrDirMetaFormat1()
2780
self._supply_sub_formats_to(local_dir_format)
2781
return local_dir_format.initialize_on_transport_ex(transport,
2782
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
2783
force_new_repo=force_new_repo, stacked_on=stacked_on,
2784
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
2785
make_working_trees=make_working_trees, shared_repo=shared_repo,
2787
return self._initialize_on_transport_ex_rpc(client, path, transport,
2788
use_existing_dir, create_prefix, force_new_repo, stacked_on,
2789
stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
2791
def _initialize_on_transport_ex_rpc(self, client, path, transport,
2792
use_existing_dir, create_prefix, force_new_repo, stacked_on,
2793
stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
2795
args.append(self._serialize_NoneTrueFalse(use_existing_dir))
2796
args.append(self._serialize_NoneTrueFalse(create_prefix))
2797
args.append(self._serialize_NoneTrueFalse(force_new_repo))
2798
args.append(self._serialize_NoneString(stacked_on))
2799
# stack_on_pwd is often/usually our transport
2802
stack_on_pwd = transport.relpath(stack_on_pwd)
2803
if not stack_on_pwd:
2805
except errors.PathNotChild:
2807
args.append(self._serialize_NoneString(stack_on_pwd))
2808
args.append(self._serialize_NoneString(repo_format_name))
2809
args.append(self._serialize_NoneTrueFalse(make_working_trees))
2810
args.append(self._serialize_NoneTrueFalse(shared_repo))
2811
request_network_name = self._network_name or \
2812
BzrDirFormat.get_default_format().network_name()
2814
response = client.call('BzrDirFormat.initialize_ex_1.16',
2815
request_network_name, path, *args)
2816
except errors.UnknownSmartMethod:
2817
client._medium._remember_remote_is_before((1,16))
2818
local_dir_format = BzrDirMetaFormat1()
2819
self._supply_sub_formats_to(local_dir_format)
2820
return local_dir_format.initialize_on_transport_ex(transport,
2821
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
2822
force_new_repo=force_new_repo, stacked_on=stacked_on,
2823
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
2824
make_working_trees=make_working_trees, shared_repo=shared_repo,
2826
except errors.ErrorFromSmartServer, err:
2827
remote._translate_error(err, path=path)
2828
repo_path = response[0]
2829
bzrdir_name = response[6]
2830
require_stacking = response[7]
2831
require_stacking = self.parse_NoneTrueFalse(require_stacking)
2832
format = RemoteBzrDirFormat()
2833
format._network_name = bzrdir_name
2834
self._supply_sub_formats_to(format)
2835
bzrdir = remote.RemoteBzrDir(transport, format, _client=client)
2837
repo_format = remote.response_tuple_to_repo_format(response[1:])
2838
if repo_path == '.':
2841
repo_bzrdir_format = RemoteBzrDirFormat()
2842
repo_bzrdir_format._network_name = response[5]
2843
repo_bzr = remote.RemoteBzrDir(transport.clone(repo_path),
2847
final_stack = response[8] or None
2848
final_stack_pwd = response[9] or None
2850
final_stack_pwd = urlutils.join(
2851
transport.base, final_stack_pwd)
2852
remote_repo = remote.RemoteRepository(repo_bzr, repo_format)
2853
if len(response) > 10:
2854
# Updated server verb that locks remotely.
2855
repo_lock_token = response[10] or None
2856
remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
2858
remote_repo.dont_leave_lock_in_place()
2860
remote_repo.lock_write()
2861
policy = UseExistingRepository(remote_repo, final_stack,
2862
final_stack_pwd, require_stacking)
2863
policy.acquire_repository()
2867
bzrdir._format.set_branch_format(self.get_branch_format())
2868
if require_stacking:
2869
# The repo has already been created, but we need to make sure that
2870
# we'll make a stackable branch.
2871
bzrdir._format.require_stacking(_skip_repo=True)
2872
return remote_repo, bzrdir, require_stacking, policy
2874
def _open(self, transport):
2875
return remote.RemoteBzrDir(transport, self)
2877
def __eq__(self, other):
2878
if not isinstance(other, RemoteBzrDirFormat):
2880
return self.get_format_description() == other.get_format_description()
2882
def __return_repository_format(self):
2883
# Always return a RemoteRepositoryFormat object, but if a specific bzr
2884
# repository format has been asked for, tell the RemoteRepositoryFormat
2885
# that it should use that for init() etc.
2886
result = remote.RemoteRepositoryFormat()
2887
custom_format = getattr(self, '_repository_format', None)
2889
if isinstance(custom_format, remote.RemoteRepositoryFormat):
2890
return custom_format
2892
# We will use the custom format to create repositories over the
2893
# wire; expose its details like rich_root_data for code to
2895
result._custom_format = custom_format
2898
def get_branch_format(self):
2899
result = BzrDirMetaFormat1.get_branch_format(self)
2900
if not isinstance(result, remote.RemoteBranchFormat):
2901
new_result = remote.RemoteBranchFormat()
2902
new_result._custom_format = result
2904
self.set_branch_format(new_result)
2908
repository_format = property(__return_repository_format,
2909
BzrDirMetaFormat1._set_repository_format) #.im_func)
1782
class ConvertMetaToColo(controldir.Converter):
1783
"""Add colocated branch support."""
1785
def __init__(self, target_format):
1786
"""Create a converter.that upgrades a metadir to the colo format.
1788
:param target_format: The final metadir format that is desired.
1790
self.target_format = target_format
1792
def convert(self, to_convert, pb):
1793
"""See Converter.convert()."""
1794
to_convert.transport.put_bytes('branch-format',
1795
self.target_format.get_format_string())
1796
return BzrDir.open_from_transport(to_convert.root_transport)
1799
class ConvertMetaRemoveColo(controldir.Converter):
1800
"""Remove colocated branch support from a bzrdir."""
1802
def __init__(self, target_format):
1803
"""Create a converter.that downgrades a colocated branch metadir
1804
to a regular metadir.
1806
:param target_format: The final metadir format that is desired.
1808
self.target_format = target_format
1810
def convert(self, to_convert, pb):
1811
"""See Converter.convert()."""
1812
to_convert.control_files.lock_write()
1814
branches = to_convert.list_branches()
1815
if len(branches) > 1:
1816
raise errors.BzrError("remove all but a single "
1817
"colocated branch when downgrading")
1819
to_convert.control_files.unlock()
1820
to_convert.transport.put_bytes('branch-format',
1821
self.target_format.get_format_string())
1822
return BzrDir.open_from_transport(to_convert.root_transport)
2912
1825
controldir.ControlDirFormat.register_server_prober(RemoteBzrProber)
3113
2042
registry.register(key, helper, help, native, deprecated, hidden,
3114
2043
experimental, alias)
3116
# The pre-0.8 formats have their repository format network name registered in
3117
# repository.py. MetaDir formats have their repository format network name
3118
# inferred from their disk format string.
3119
controldir.format_registry.register('weave', BzrDirFormat6,
3120
'Pre-0.8 format. Slower than knit and does not'
3121
' support checkouts or shared repositories.',
3124
register_metadir(controldir.format_registry, 'metaweave',
3125
'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3126
'Transitional format in 0.8. Slower than knit.',
3127
branch_format='bzrlib.branch.BzrBranchFormat5',
3128
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3131
2045
register_metadir(controldir.format_registry, 'knit',
3132
2046
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3133
2047
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
3134
2048
branch_format='bzrlib.branch.BzrBranchFormat5',
3135
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
2049
tree_format='bzrlib.workingtree_3.WorkingTreeFormat3',
3137
2051
deprecated=True)
3138
2052
register_metadir(controldir.format_registry, 'dirstate',
3139
2053
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3140
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
3141
'above when accessed over the network.',
2054
help='Format using dirstate for working trees. '
2055
'Compatible with bzr 0.8 and '
2056
'above when accessed over the network. Introduced in bzr 0.15.',
3142
2057
branch_format='bzrlib.branch.BzrBranchFormat5',
3143
# this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
3144
# directly from workingtree_4 triggers a circular import.
3145
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2058
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3147
2060
deprecated=True)
3148
2061
register_metadir(controldir.format_registry, 'dirstate-tags',
3149
2062
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3150
help='New in 0.15: Fast local operations and improved scaling for '
3151
'network operations. Additionally adds support for tags.'
3152
' Incompatible with bzr < 0.15.',
2063
help='Variant of dirstate with support for tags. '
2064
'Introduced in bzr 0.15.',
3153
2065
branch_format='bzrlib.branch.BzrBranchFormat6',
3154
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2066
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3156
2068
deprecated=True)
3157
2069
register_metadir(controldir.format_registry, 'rich-root',
3158
2070
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
3159
help='New in 1.0. Better handling of tree roots. Incompatible with'
2071
help='Variant of dirstate with better handling of tree roots. '
2072
'Introduced in bzr 1.0',
3161
2073
branch_format='bzrlib.branch.BzrBranchFormat6',
3162
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2074
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3164
2076
deprecated=True)
3165
2077
register_metadir(controldir.format_registry, 'dirstate-with-subtree',
3166
2078
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
3167
help='New in 0.15: Fast local operations and improved scaling for '
3168
'network operations. Additionally adds support for versioning nested '
3169
'bzr branches. Incompatible with bzr < 0.15.',
2079
help='Variant of dirstate with support for nested trees. '
2080
'Introduced in 0.15.',
3170
2081
branch_format='bzrlib.branch.BzrBranchFormat6',
3171
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2082
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3172
2083
experimental=True,
3175
2086
register_metadir(controldir.format_registry, 'pack-0.92',
3176
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack1',
3177
help='New in 0.92: Pack-based format with data compatible with '
3178
'dirstate-tags format repositories. Interoperates with '
3179
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
2087
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack1',
2088
help='Pack-based format used in 1.x series. Introduced in 0.92. '
2089
'Interoperates with bzr repositories before 0.92 but cannot be '
2090
'read by bzr < 0.92. '
3181
2092
branch_format='bzrlib.branch.BzrBranchFormat6',
3182
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2093
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3184
2096
register_metadir(controldir.format_registry, 'pack-0.92-subtree',
3185
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack3',
3186
help='New in 0.92: Pack-based format with data compatible with '
3187
'dirstate-with-subtree format repositories. Interoperates with '
2097
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack3',
2098
help='Pack-based format used in 1.x series, with subtree support. '
2099
'Introduced in 0.92. Interoperates with '
3188
2100
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3190
2102
branch_format='bzrlib.branch.BzrBranchFormat6',
3191
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2103
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3193
2106
experimental=True,
3195
2108
register_metadir(controldir.format_registry, 'rich-root-pack',
3196
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3197
help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
3198
'(needed for bzr-svn and bzr-git).',
2109
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack4',
2110
help='A variant of pack-0.92 that supports rich-root data '
2111
'(needed for bzr-svn and bzr-git). Introduced in 1.0.',
3199
2112
branch_format='bzrlib.branch.BzrBranchFormat6',
3200
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2113
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3203
2117
register_metadir(controldir.format_registry, '1.6',
3204
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
2118
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack5',
3205
2119
help='A format that allows a branch to indicate that there is another '
3206
2120
'(stacked) repository that should be used to access data that is '
3207
2121
'not present locally.',
3208
2122
branch_format='bzrlib.branch.BzrBranchFormat7',
3209
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2123
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3212
2127
register_metadir(controldir.format_registry, '1.6.1-rich-root',
3213
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
2128
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack5RichRoot',
3214
2129
help='A variant of 1.6 that supports rich-root data '
3215
2130
'(needed for bzr-svn and bzr-git).',
3216
2131
branch_format='bzrlib.branch.BzrBranchFormat7',
3217
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2132
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3220
2136
register_metadir(controldir.format_registry, '1.9',
3221
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
2137
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6',
3222
2138
help='A repository format using B+tree indexes. These indexes '
3223
2139
'are smaller in size, have smarter caching and provide faster '
3224
2140
'performance for most operations.',
3225
2141
branch_format='bzrlib.branch.BzrBranchFormat7',
3226
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2142
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3229
2146
register_metadir(controldir.format_registry, '1.9-rich-root',
3230
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
2147
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6RichRoot',
3231
2148
help='A variant of 1.9 that supports rich-root data '
3232
2149
'(needed for bzr-svn and bzr-git).',
3233
2150
branch_format='bzrlib.branch.BzrBranchFormat7',
3234
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2151
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3237
2155
register_metadir(controldir.format_registry, '1.14',
3238
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
2156
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6',
3239
2157
help='A working-tree format that supports content filtering.',
3240
2158
branch_format='bzrlib.branch.BzrBranchFormat7',
3241
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
2159
tree_format='bzrlib.workingtree_4.WorkingTreeFormat5',
3243
2163
register_metadir(controldir.format_registry, '1.14-rich-root',
3244
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
2164
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6RichRoot',
3245
2165
help='A variant of 1.14 that supports rich-root data '
3246
2166
'(needed for bzr-svn and bzr-git).',
3247
2167
branch_format='bzrlib.branch.BzrBranchFormat7',
3248
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
2168
tree_format='bzrlib.workingtree_4.WorkingTreeFormat5',
3250
2172
# The following un-numbered 'development' formats should always just be aliases.
3251
register_metadir(controldir.format_registry, 'development-rich-root',
3252
'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3253
help='Current development format. Supports rich roots. Can convert data '
3254
'to and from rich-root-pack (and anything compatible with '
3255
'rich-root-pack) format repositories. Repositories and branches in '
3256
'this format can only be read by bzr.dev. Please read '
3257
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3259
branch_format='bzrlib.branch.BzrBranchFormat7',
3260
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3265
register_metadir(controldir.format_registry, 'development5-subtree',
3266
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3267
help='Development format, subtree variant. Can convert data to and '
3268
'from pack-0.92-subtree (and anything compatible with '
3269
'pack-0.92-subtree) format repositories. Repositories and branches in '
3270
'this format can only be read by bzr.dev. Please read '
3271
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3273
branch_format='bzrlib.branch.BzrBranchFormat7',
3274
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3281
2173
register_metadir(controldir.format_registry, 'development-subtree',
3282
2174
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2aSubtree',
3283
2175
help='Current development format, subtree variant. Can convert data to and '
added
removed
bzrlib/bzrdir.py
