389
455
policy = self.determine_repository_policy(force_new_repo)
390
456
return policy.acquire_repository()[0]
392
def _find_source_repo(self, add_cleanup, source_branch):
393
"""Find the source branch and repo for a sprout operation.
395
This is helper intended for use by _sprout.
397
:returns: (source_branch, source_repository). Either or both may be
398
None. If not None, they will be read-locked (and their unlock(s)
399
scheduled via the add_cleanup param).
401
if source_branch is not None:
402
add_cleanup(source_branch.lock_read().unlock)
403
return source_branch, source_branch.repository
405
source_branch = self.open_branch()
406
source_repository = source_branch.repository
407
except errors.NotBranchError:
410
source_repository = self.open_repository()
411
except errors.NoRepositoryPresent:
412
source_repository = None
414
add_cleanup(source_repository.lock_read().unlock)
416
add_cleanup(source_branch.lock_read().unlock)
417
return source_branch, source_repository
419
def sprout(self, url, revision_id=None, force_new_repo=False,
420
recurse='down', possible_transports=None,
421
accelerator_tree=None, hardlink=False, stacked=False,
422
source_branch=None, create_tree_if_local=True):
423
"""Create a copy of this controldir prepared for use as a new line of
426
If url's last component does not exist, it will be created.
428
Attributes related to the identity of the source branch like
429
branch nickname will be cleaned, a working tree is created
430
whether one existed before or not; and a local branch is always
433
if revision_id is not None, then the clone operation may tune
434
itself to download less data.
436
:param accelerator_tree: A tree which can be used for retrieving file
437
contents more quickly than the revision tree, i.e. a workingtree.
438
The revision tree will be used for cases where accelerator_tree's
439
content is different.
440
:param hardlink: If true, hard-link files from accelerator_tree,
442
:param stacked: If true, create a stacked branch referring to the
443
location of this control directory.
444
:param create_tree_if_local: If true, a working-tree will be created
445
when working locally.
447
operation = cleanup.OperationWithCleanups(self._sprout)
448
return operation.run(url, revision_id=revision_id,
449
force_new_repo=force_new_repo, recurse=recurse,
450
possible_transports=possible_transports,
451
accelerator_tree=accelerator_tree, hardlink=hardlink,
452
stacked=stacked, source_branch=source_branch,
453
create_tree_if_local=create_tree_if_local)
455
def _sprout(self, op, url, revision_id=None, force_new_repo=False,
456
recurse='down', possible_transports=None,
457
accelerator_tree=None, hardlink=False, stacked=False,
458
source_branch=None, create_tree_if_local=True):
459
add_cleanup = op.add_cleanup
460
fetch_spec_factory = fetch.FetchSpecFactory()
461
if revision_id is not None:
462
fetch_spec_factory.add_revision_ids([revision_id])
463
fetch_spec_factory.source_branch_stop_revision_id = revision_id
464
target_transport = _mod_transport.get_transport(url,
466
target_transport.ensure_base()
467
cloning_format = self.cloning_metadir(stacked)
468
# Create/update the result branch
469
result = cloning_format.initialize_on_transport(target_transport)
470
source_branch, source_repository = self._find_source_repo(
471
add_cleanup, source_branch)
472
fetch_spec_factory.source_branch = source_branch
473
# if a stacked branch wasn't requested, we don't create one
474
# even if the origin was stacked
475
if stacked and source_branch is not None:
476
stacked_branch_url = self.root_transport.base
478
stacked_branch_url = None
479
repository_policy = result.determine_repository_policy(
480
force_new_repo, stacked_branch_url, require_stacking=stacked)
481
result_repo, is_new_repo = repository_policy.acquire_repository()
482
add_cleanup(result_repo.lock_write().unlock)
483
fetch_spec_factory.source_repo = source_repository
484
fetch_spec_factory.target_repo = result_repo
485
if stacked or (len(result_repo._fallback_repositories) != 0):
486
target_repo_kind = fetch.TargetRepoKinds.STACKED
488
target_repo_kind = fetch.TargetRepoKinds.EMPTY
490
target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
491
fetch_spec_factory.target_repo_kind = target_repo_kind
492
if source_repository is not None:
493
fetch_spec = fetch_spec_factory.make_fetch_spec()
494
result_repo.fetch(source_repository, fetch_spec=fetch_spec)
496
if source_branch is None:
497
# this is for sprouting a controldir without a branch; is that
499
# Not especially, but it's part of the contract.
500
result_branch = result.create_branch()
502
result_branch = source_branch.sprout(result,
503
revision_id=revision_id, repository_policy=repository_policy,
504
repository=result_repo)
505
mutter("created new branch %r" % (result_branch,))
507
# Create/update the result working tree
508
if (create_tree_if_local and
509
isinstance(target_transport, local.LocalTransport) and
510
(result_repo is None or result_repo.make_working_trees())):
511
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
512
hardlink=hardlink, from_branch=result_branch)
515
if wt.path2id('') is None:
517
wt.set_root_id(self.open_workingtree.get_root_id())
518
except errors.NoWorkingTree:
524
if recurse == 'down':
527
basis = wt.basis_tree()
528
elif result_branch is not None:
529
basis = result_branch.basis_tree()
530
elif source_branch is not None:
531
basis = source_branch.basis_tree()
532
if basis is not None:
533
add_cleanup(basis.lock_read().unlock)
534
subtrees = basis.iter_references()
537
for path, file_id in subtrees:
538
target = urlutils.join(url, urlutils.escape(path))
539
sublocation = source_branch.reference_parent(file_id, path)
540
sublocation.bzrdir.sprout(target,
541
basis.get_reference_revision(file_id, path),
542
force_new_repo=force_new_repo, recurse=recurse,
549
459
def create_branch_convenience(base, force_new_repo=False,
550
460
force_new_tree=None, format=None,
1009
1066
format, repository = self._cloning_metadir()
1010
1067
if format._workingtree_format is None:
1012
1068
if repository is None:
1013
# No repository either
1015
# We have a repository, so set a working tree? (Why? This seems to
1016
# contradict the stated return value in the docstring).
1017
1070
tree_format = repository._format._matchingbzrdir.workingtree_format
1018
1071
format.workingtree_format = tree_format.__class__()
1019
1072
if require_stacking:
1020
1073
format.require_stacking()
1024
def create(cls, base, format=None, possible_transports=None):
1025
"""Create a new BzrDir at the url 'base'.
1027
:param format: If supplied, the format of branch to create. If not
1028
supplied, the default is used.
1029
:param possible_transports: If supplied, a list of transports that
1030
can be reused to share a remote connection.
1032
if cls is not BzrDir:
1033
raise AssertionError("BzrDir.create always creates the"
1034
"default format, not one of %r" % cls)
1035
t = _mod_transport.get_transport(base, possible_transports)
1038
format = controldir.ControlDirFormat.get_default_format()
1039
return format.initialize_on_transport(t)
1041
def get_branch_transport(self, branch_format, name=None):
1042
"""Get the transport for use by branch format in this BzrDir.
1044
Note that bzr dirs that do not support format strings will raise
1045
IncompatibleFormat if the branch format they are given has
1046
a format string, and vice versa.
1048
If branch_format is None, the transport is returned with no
1049
checking. If it is not None, then the returned transport is
1050
guaranteed to point to an existing directory ready for use.
1052
raise NotImplementedError(self.get_branch_transport)
1054
def get_repository_transport(self, repository_format):
1055
"""Get the transport for use by repository format in this BzrDir.
1057
Note that bzr dirs that do not support format strings will raise
1058
IncompatibleFormat if the repository format they are given has
1059
a format string, and vice versa.
1061
If repository_format is None, the transport is returned with no
1062
checking. If it is not None, then the returned transport is
1063
guaranteed to point to an existing directory ready for use.
1065
raise NotImplementedError(self.get_repository_transport)
1067
def get_workingtree_transport(self, tree_format):
1068
"""Get the transport for use by workingtree format in this BzrDir.
1070
Note that bzr dirs that do not support format strings will raise
1071
IncompatibleFormat if the workingtree format they are given has a
1072
format string, and vice versa.
1074
If workingtree_format is None, the transport is returned with no
1075
checking. If it is not None, then the returned transport is
1076
guaranteed to point to an existing directory ready for use.
1078
raise NotImplementedError(self.get_workingtree_transport)
1076
def checkout_metadir(self):
1077
return self.cloning_metadir()
1079
def sprout(self, url, revision_id=None, force_new_repo=False,
1080
recurse='down', possible_transports=None,
1081
accelerator_tree=None, hardlink=False, stacked=False,
1082
source_branch=None, create_tree_if_local=True):
1083
"""Create a copy of this bzrdir prepared for use as a new line of
1086
If url's last component does not exist, it will be created.
1088
Attributes related to the identity of the source branch like
1089
branch nickname will be cleaned, a working tree is created
1090
whether one existed before or not; and a local branch is always
1093
if revision_id is not None, then the clone operation may tune
1094
itself to download less data.
1095
:param accelerator_tree: A tree which can be used for retrieving file
1096
contents more quickly than the revision tree, i.e. a workingtree.
1097
The revision tree will be used for cases where accelerator_tree's
1098
content is different.
1099
:param hardlink: If true, hard-link files from accelerator_tree,
1101
:param stacked: If true, create a stacked branch referring to the
1102
location of this control directory.
1103
:param create_tree_if_local: If true, a working-tree will be created
1104
when working locally.
1106
target_transport = get_transport(url, possible_transports)
1107
target_transport.ensure_base()
1108
cloning_format = self.cloning_metadir(stacked)
1109
# Create/update the result branch
1110
result = cloning_format.initialize_on_transport(target_transport)
1111
# if a stacked branch wasn't requested, we don't create one
1112
# even if the origin was stacked
1113
stacked_branch_url = None
1114
if source_branch is not None:
1116
stacked_branch_url = self.root_transport.base
1117
source_repository = source_branch.repository
1120
source_branch = self.open_branch()
1121
source_repository = source_branch.repository
1123
stacked_branch_url = self.root_transport.base
1124
except errors.NotBranchError:
1125
source_branch = None
1127
source_repository = self.open_repository()
1128
except errors.NoRepositoryPresent:
1129
source_repository = None
1130
repository_policy = result.determine_repository_policy(
1131
force_new_repo, stacked_branch_url, require_stacking=stacked)
1132
result_repo, is_new_repo = repository_policy.acquire_repository()
1133
if is_new_repo and revision_id is not None and not stacked:
1134
fetch_spec = graph.PendingAncestryResult(
1135
[revision_id], source_repository)
1138
if source_repository is not None:
1139
# Fetch while stacked to prevent unstacked fetch from
1141
if fetch_spec is None:
1142
result_repo.fetch(source_repository, revision_id=revision_id)
1144
result_repo.fetch(source_repository, fetch_spec=fetch_spec)
1146
if source_branch is None:
1147
# this is for sprouting a bzrdir without a branch; is that
1149
# Not especially, but it's part of the contract.
1150
result_branch = result.create_branch()
1152
result_branch = source_branch.sprout(result,
1153
revision_id=revision_id, repository_policy=repository_policy)
1154
mutter("created new branch %r" % (result_branch,))
1156
# Create/update the result working tree
1157
if (create_tree_if_local and
1158
isinstance(target_transport, local.LocalTransport) and
1159
(result_repo is None or result_repo.make_working_trees())):
1160
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
1164
if wt.path2id('') is None:
1166
wt.set_root_id(self.open_workingtree.get_root_id())
1167
except errors.NoWorkingTree:
1173
if recurse == 'down':
1175
basis = wt.basis_tree()
1177
subtrees = basis.iter_references()
1178
elif result_branch is not None:
1179
basis = result_branch.basis_tree()
1181
subtrees = basis.iter_references()
1182
elif source_branch is not None:
1183
basis = source_branch.basis_tree()
1185
subtrees = basis.iter_references()
1190
for path, file_id in subtrees:
1191
target = urlutils.join(url, urlutils.escape(path))
1192
sublocation = source_branch.reference_parent(file_id, path)
1193
sublocation.bzrdir.sprout(target,
1194
basis.get_reference_revision(file_id, path),
1195
force_new_repo=force_new_repo, recurse=recurse,
1198
if basis is not None:
1202
def push_branch(self, source, revision_id=None, overwrite=False,
1204
"""Push the source branch into this BzrDir."""
1206
# If we can open a branch, use its direct repository, otherwise see
1207
# if there is a repository without a branch.
1209
br_to = self.open_branch()
1210
except errors.NotBranchError:
1211
# Didn't find a branch, can we find a repository?
1212
repository_to = self.find_repository()
1214
# Found a branch, so we must have found a repository
1215
repository_to = br_to.repository
1217
push_result = PushResult()
1218
push_result.source_branch = source
1220
# We have a repository but no branch, copy the revisions, and then
1222
repository_to.fetch(source.repository, revision_id=revision_id)
1223
br_to = source.clone(self, revision_id=revision_id)
1224
if source.get_push_location() is None or remember:
1225
source.set_push_location(br_to.base)
1226
push_result.stacked_on = None
1227
push_result.branch_push_result = None
1228
push_result.old_revno = None
1229
push_result.old_revid = _mod_revision.NULL_REVISION
1230
push_result.target_branch = br_to
1231
push_result.master_branch = None
1232
push_result.workingtree_updated = False
1234
# We have successfully opened the branch, remember if necessary:
1235
if source.get_push_location() is None or remember:
1236
source.set_push_location(br_to.base)
1238
tree_to = self.open_workingtree()
1239
except errors.NotLocalUrl:
1240
push_result.branch_push_result = source.push(br_to,
1241
overwrite, stop_revision=revision_id)
1242
push_result.workingtree_updated = False
1243
except errors.NoWorkingTree:
1244
push_result.branch_push_result = source.push(br_to,
1245
overwrite, stop_revision=revision_id)
1246
push_result.workingtree_updated = None # Not applicable
1248
tree_to.lock_write()
1250
push_result.branch_push_result = source.push(
1251
tree_to.branch, overwrite, stop_revision=revision_id)
1255
push_result.workingtree_updated = True
1256
push_result.old_revno = push_result.branch_push_result.old_revno
1257
push_result.old_revid = push_result.branch_push_result.old_revid
1258
push_result.target_branch = \
1259
push_result.branch_push_result.target_branch
1081
1263
class BzrDirHooks(hooks.Hooks):
1084
1266
def __init__(self):
1085
1267
"""Create the default hooks."""
1086
hooks.Hooks.__init__(self, "bzrlib.bzrdir", "BzrDir.hooks")
1087
self.add_hook('pre_open',
1268
hooks.Hooks.__init__(self)
1269
self.create_hook(hooks.HookPoint('pre_open',
1088
1270
"Invoked before attempting to open a BzrDir with the transport "
1089
"that the open will use.", (1, 14))
1090
self.add_hook('post_repo_init',
1091
"Invoked after a repository has been initialized. "
1092
"post_repo_init is called with a "
1093
"bzrlib.bzrdir.RepoInitHookParams.",
1271
"that the open will use.", (1, 14), None))
1096
1273
# install the default hooks
1097
1274
BzrDir.hooks = BzrDirHooks()
1100
class RepoInitHookParams(object):
1101
"""Object holding parameters passed to `*_repo_init` hooks.
1103
There are 4 fields that hooks may wish to access:
1105
:ivar repository: Repository created
1106
:ivar format: Repository format
1107
:ivar bzrdir: The bzrdir for the repository
1108
:ivar shared: The repository is shared
1111
def __init__(self, repository, format, a_bzrdir, shared):
1112
"""Create a group of RepoInitHook parameters.
1114
:param repository: Repository created
1115
:param format: Repository format
1116
:param bzrdir: The bzrdir for the repository
1117
:param shared: The repository is shared
1277
class BzrDirPreSplitOut(BzrDir):
1278
"""A common class for the all-in-one formats."""
1280
def __init__(self, _transport, _format):
1281
"""See BzrDir.__init__."""
1282
super(BzrDirPreSplitOut, self).__init__(_transport, _format)
1283
self._control_files = lockable_files.LockableFiles(
1284
self.get_branch_transport(None),
1285
self._format._lock_file_name,
1286
self._format._lock_class)
1288
def break_lock(self):
1289
"""Pre-splitout bzrdirs do not suffer from stale locks."""
1290
raise NotImplementedError(self.break_lock)
1292
def cloning_metadir(self, require_stacking=False):
1293
"""Produce a metadir suitable for cloning with."""
1294
if require_stacking:
1295
return format_registry.make_bzrdir('1.6')
1296
return self._format.__class__()
1298
def clone(self, url, revision_id=None, force_new_repo=False,
1299
preserve_stacking=False):
1300
"""See BzrDir.clone().
1302
force_new_repo has no effect, since this family of formats always
1303
require a new repository.
1304
preserve_stacking has no effect, since no source branch using this
1305
family of formats can be stacked, so there is no stacking to preserve.
1119
self.repository = repository
1120
self.format = format
1121
self.bzrdir = a_bzrdir
1122
self.shared = shared
1124
def __eq__(self, other):
1125
return self.__dict__ == other.__dict__
1129
return "<%s for %s>" % (self.__class__.__name__,
1307
self._make_tail(url)
1308
result = self._format._initialize_for_clone(url)
1309
self.open_repository().clone(result, revision_id=revision_id)
1310
from_branch = self.open_branch()
1311
from_branch.clone(result, revision_id=revision_id)
1313
tree = self.open_workingtree()
1314
except errors.NotLocalUrl:
1315
# make a new one, this format always has to have one.
1316
result._init_workingtree()
1132
return "<%s for %s>" % (self.__class__.__name__,
1321
def create_branch(self):
1322
"""See BzrDir.create_branch."""
1323
return self._format.get_branch_format().initialize(self)
1325
def destroy_branch(self):
1326
"""See BzrDir.destroy_branch."""
1327
raise errors.UnsupportedOperation(self.destroy_branch, self)
1329
def create_repository(self, shared=False):
1330
"""See BzrDir.create_repository."""
1332
raise errors.IncompatibleFormat('shared repository', self._format)
1333
return self.open_repository()
1335
def destroy_repository(self):
1336
"""See BzrDir.destroy_repository."""
1337
raise errors.UnsupportedOperation(self.destroy_repository, self)
1339
def create_workingtree(self, revision_id=None, from_branch=None,
1340
accelerator_tree=None, hardlink=False):
1341
"""See BzrDir.create_workingtree."""
1342
# The workingtree is sometimes created when the bzrdir is created,
1343
# but not when cloning.
1345
# this looks buggy but is not -really-
1346
# because this format creates the workingtree when the bzrdir is
1348
# clone and sprout will have set the revision_id
1349
# and that will have set it for us, its only
1350
# specific uses of create_workingtree in isolation
1351
# that can do wonky stuff here, and that only
1352
# happens for creating checkouts, which cannot be
1353
# done on this format anyway. So - acceptable wart.
1355
result = self.open_workingtree(recommend_upgrade=False)
1356
except errors.NoSuchFile:
1357
result = self._init_workingtree()
1358
if revision_id is not None:
1359
if revision_id == _mod_revision.NULL_REVISION:
1360
result.set_parent_ids([])
1362
result.set_parent_ids([revision_id])
1365
def _init_workingtree(self):
1366
from bzrlib.workingtree import WorkingTreeFormat2
1368
return WorkingTreeFormat2().initialize(self)
1369
except errors.NotLocalUrl:
1370
# Even though we can't access the working tree, we need to
1371
# create its control files.
1372
return WorkingTreeFormat2()._stub_initialize_on_transport(
1373
self.transport, self._control_files._file_mode)
1375
def destroy_workingtree(self):
1376
"""See BzrDir.destroy_workingtree."""
1377
raise errors.UnsupportedOperation(self.destroy_workingtree, self)
1379
def destroy_workingtree_metadata(self):
1380
"""See BzrDir.destroy_workingtree_metadata."""
1381
raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
1384
def get_branch_transport(self, branch_format):
1385
"""See BzrDir.get_branch_transport()."""
1386
if branch_format is None:
1387
return self.transport
1389
branch_format.get_format_string()
1390
except NotImplementedError:
1391
return self.transport
1392
raise errors.IncompatibleFormat(branch_format, self._format)
1394
def get_repository_transport(self, repository_format):
1395
"""See BzrDir.get_repository_transport()."""
1396
if repository_format is None:
1397
return self.transport
1399
repository_format.get_format_string()
1400
except NotImplementedError:
1401
return self.transport
1402
raise errors.IncompatibleFormat(repository_format, self._format)
1404
def get_workingtree_transport(self, workingtree_format):
1405
"""See BzrDir.get_workingtree_transport()."""
1406
if workingtree_format is None:
1407
return self.transport
1409
workingtree_format.get_format_string()
1410
except NotImplementedError:
1411
return self.transport
1412
raise errors.IncompatibleFormat(workingtree_format, self._format)
1414
def needs_format_conversion(self, format=None):
1415
"""See BzrDir.needs_format_conversion()."""
1416
# if the format is not the same as the system default,
1417
# an upgrade is needed.
1419
symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1420
% 'needs_format_conversion(format=None)')
1421
format = BzrDirFormat.get_default_format()
1422
return not isinstance(self._format, format.__class__)
1424
def open_branch(self, unsupported=False, ignore_fallbacks=False):
1425
"""See BzrDir.open_branch."""
1426
from bzrlib.branch import BzrBranchFormat4
1427
format = BzrBranchFormat4()
1428
self._check_supported(format, unsupported)
1429
return format.open(self, _found=True)
1431
def sprout(self, url, revision_id=None, force_new_repo=False,
1432
possible_transports=None, accelerator_tree=None,
1433
hardlink=False, stacked=False, create_tree_if_local=True,
1434
source_branch=None):
1435
"""See BzrDir.sprout()."""
1436
if source_branch is not None:
1437
my_branch = self.open_branch()
1438
if source_branch.base != my_branch.base:
1439
raise AssertionError(
1440
"source branch %r is not within %r with branch %r" %
1441
(source_branch, self, my_branch))
1443
raise errors.UnstackableBranchFormat(
1444
self._format, self.root_transport.base)
1445
if not create_tree_if_local:
1446
raise errors.MustHaveWorkingTree(
1447
self._format, self.root_transport.base)
1448
from bzrlib.workingtree import WorkingTreeFormat2
1449
self._make_tail(url)
1450
result = self._format._initialize_for_clone(url)
1452
self.open_repository().clone(result, revision_id=revision_id)
1453
except errors.NoRepositoryPresent:
1456
self.open_branch().sprout(result, revision_id=revision_id)
1457
except errors.NotBranchError:
1460
# we always want a working tree
1461
WorkingTreeFormat2().initialize(result,
1462
accelerator_tree=accelerator_tree,
1467
class BzrDir4(BzrDirPreSplitOut):
1468
"""A .bzr version 4 control object.
1470
This is a deprecated format and may be removed after sept 2006.
1473
def create_repository(self, shared=False):
1474
"""See BzrDir.create_repository."""
1475
return self._format.repository_format.initialize(self, shared)
1477
def needs_format_conversion(self, format=None):
1478
"""Format 4 dirs are always in need of conversion."""
1480
symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1481
% 'needs_format_conversion(format=None)')
1484
def open_repository(self):
1485
"""See BzrDir.open_repository."""
1486
from bzrlib.repofmt.weaverepo import RepositoryFormat4
1487
return RepositoryFormat4().open(self, _found=True)
1490
class BzrDir5(BzrDirPreSplitOut):
1491
"""A .bzr version 5 control object.
1493
This is a deprecated format and may be removed after sept 2006.
1496
def open_repository(self):
1497
"""See BzrDir.open_repository."""
1498
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1499
return RepositoryFormat5().open(self, _found=True)
1501
def open_workingtree(self, _unsupported=False,
1502
recommend_upgrade=True):
1503
"""See BzrDir.create_workingtree."""
1504
from bzrlib.workingtree import WorkingTreeFormat2
1505
wt_format = WorkingTreeFormat2()
1506
# we don't warn here about upgrades; that ought to be handled for the
1508
return wt_format.open(self, _found=True)
1511
class BzrDir6(BzrDirPreSplitOut):
1512
"""A .bzr version 6 control object.
1514
This is a deprecated format and may be removed after sept 2006.
1517
def open_repository(self):
1518
"""See BzrDir.open_repository."""
1519
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1520
return RepositoryFormat6().open(self, _found=True)
1522
def open_workingtree(self, _unsupported=False,
1523
recommend_upgrade=True):
1524
"""See BzrDir.create_workingtree."""
1525
# we don't warn here about upgrades; that ought to be handled for the
1527
from bzrlib.workingtree import WorkingTreeFormat2
1528
return WorkingTreeFormat2().open(self, _found=True)
1136
1531
class BzrDirMeta1(BzrDir):
1313
1690
"""See BzrDir.open_workingtree."""
1314
1691
from bzrlib.workingtree import WorkingTreeFormat
1315
1692
format = WorkingTreeFormat.find_format(self)
1316
format.check_support_status(unsupported, recommend_upgrade,
1693
self._check_supported(format, unsupported,
1317
1695
basedir=self.root_transport.base)
1318
1696
return format.open(self, _found=True)
1320
1698
def _get_config(self):
1321
return config.TransportConfig(self.transport, 'control.conf')
1324
class BzrProber(controldir.Prober):
1325
"""Prober for formats that use a .bzr/ control directory."""
1327
formats = registry.FormatRegistry(controldir.network_format_registry)
1328
"""The known .bzr formats."""
1331
@deprecated_method(deprecated_in((2, 4, 0)))
1332
def register_bzrdir_format(klass, format):
1333
klass.formats.register(format.get_format_string(), format)
1336
@deprecated_method(deprecated_in((2, 4, 0)))
1337
def unregister_bzrdir_format(klass, format):
1338
klass.formats.remove(format.get_format_string())
1341
def probe_transport(klass, transport):
1342
"""Return the .bzrdir style format present in a directory."""
1344
format_string = transport.get_bytes(".bzr/branch-format")
1345
except errors.NoSuchFile:
1346
raise errors.NotBranchError(path=transport.base)
1348
return klass.formats.get(format_string)
1350
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1353
def known_formats(cls):
1355
for name, format in cls.formats.iteritems():
1356
if callable(format):
1362
controldir.ControlDirFormat.register_prober(BzrProber)
1365
class RemoteBzrProber(controldir.Prober):
1366
"""Prober for remote servers that provide a Bazaar smart server."""
1369
def probe_transport(klass, transport):
1370
"""Return a RemoteBzrDirFormat object if it looks possible."""
1372
medium = transport.get_smart_medium()
1373
except (NotImplementedError, AttributeError,
1374
errors.TransportNotPossible, errors.NoSmartMedium,
1375
errors.SmartProtocolError):
1376
# no smart server, so not a branch for this format type.
1377
raise errors.NotBranchError(path=transport.base)
1379
# Decline to open it if the server doesn't support our required
1380
# version (3) so that the VFS-based transport will do it.
1381
if medium.should_probe():
1383
server_version = medium.protocol_version()
1384
except errors.SmartProtocolError:
1385
# Apparently there's no usable smart server there, even though
1386
# the medium supports the smart protocol.
1387
raise errors.NotBranchError(path=transport.base)
1388
if server_version != '2':
1389
raise errors.NotBranchError(path=transport.base)
1390
from bzrlib.remote import RemoteBzrDirFormat
1391
return RemoteBzrDirFormat()
1394
def known_formats(cls):
1395
from bzrlib.remote import RemoteBzrDirFormat
1396
return set([RemoteBzrDirFormat()])
1399
class BzrDirFormat(controldir.ControlDirFormat):
1400
"""ControlDirFormat base class for .bzr/ directories.
1699
return config.BzrDirConfig(self.transport)
1702
class BzrDirFormat(object):
1703
"""An encapsulation of the initialization and open routines for a format.
1705
Formats provide three things:
1706
* An initialization routine,
1402
1710
Formats are placed in a dict by their format string for reference
1403
1711
during bzrdir opening. These should be subclasses of BzrDirFormat
1433
1818
if type(self) != BzrDirMetaFormat1:
1434
1819
return self._initialize_on_transport_vfs(transport)
1435
from bzrlib.remote import RemoteBzrDirFormat
1436
1820
remote_format = RemoteBzrDirFormat()
1437
1821
self._supply_sub_formats_to(remote_format)
1438
1822
return remote_format.initialize_on_transport(transport)
1440
def initialize_on_transport_ex(self, transport, use_existing_dir=False,
1441
create_prefix=False, force_new_repo=False, stacked_on=None,
1442
stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
1443
shared_repo=False, vfs_only=False):
1444
"""Create this format on transport.
1446
The directory to initialize will be created.
1448
:param force_new_repo: Do not use a shared repository for the target,
1449
even if one is available.
1450
:param create_prefix: Create any missing directories leading up to
1452
:param use_existing_dir: Use an existing directory if one exists.
1453
:param stacked_on: A url to stack any created branch on, None to follow
1454
any target stacking policy.
1455
:param stack_on_pwd: If stack_on is relative, the location it is
1457
:param repo_format_name: If non-None, a repository will be
1458
made-or-found. Should none be found, or if force_new_repo is True
1459
the repo_format_name is used to select the format of repository to
1461
:param make_working_trees: Control the setting of make_working_trees
1462
for a new shared repository when one is made. None to use whatever
1463
default the format has.
1464
:param shared_repo: Control whether made repositories are shared or
1466
:param vfs_only: If True do not attempt to use a smart server
1467
:return: repo, bzrdir, require_stacking, repository_policy. repo is
1468
None if none was created or found, bzrdir is always valid.
1469
require_stacking is the result of examining the stacked_on
1470
parameter and any stacking policy found for the target.
1473
# Try to hand off to a smart server
1475
client_medium = transport.get_smart_medium()
1476
except errors.NoSmartMedium:
1479
from bzrlib.remote import RemoteBzrDirFormat
1480
# TODO: lookup the local format from a server hint.
1481
remote_dir_format = RemoteBzrDirFormat()
1482
remote_dir_format._network_name = self.network_name()
1483
self._supply_sub_formats_to(remote_dir_format)
1484
return remote_dir_format.initialize_on_transport_ex(transport,
1485
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
1486
force_new_repo=force_new_repo, stacked_on=stacked_on,
1487
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
1488
make_working_trees=make_working_trees, shared_repo=shared_repo)
1489
# XXX: Refactor the create_prefix/no_create_prefix code into a
1490
# common helper function
1491
# The destination may not exist - if so make it according to policy.
1492
def make_directory(transport):
1493
transport.mkdir('.')
1495
def redirected(transport, e, redirection_notice):
1496
note(redirection_notice)
1497
return transport._redirected_to(e.source, e.target)
1499
transport = do_catching_redirections(make_directory, transport,
1501
except errors.FileExists:
1502
if not use_existing_dir:
1504
except errors.NoSuchFile:
1505
if not create_prefix:
1507
transport.create_prefix()
1509
require_stacking = (stacked_on is not None)
1510
# Now the target directory exists, but doesn't have a .bzr
1511
# directory. So we need to create it, along with any work to create
1512
# all of the dependent branches, etc.
1514
result = self.initialize_on_transport(transport)
1515
if repo_format_name:
1517
# use a custom format
1518
result._format.repository_format = \
1519
repository.network_format_registry.get(repo_format_name)
1520
except AttributeError:
1521
# The format didn't permit it to be set.
1523
# A repository is desired, either in-place or shared.
1524
repository_policy = result.determine_repository_policy(
1525
force_new_repo, stacked_on, stack_on_pwd,
1526
require_stacking=require_stacking)
1527
result_repo, is_new_repo = repository_policy.acquire_repository(
1528
make_working_trees, shared_repo)
1529
if not require_stacking and repository_policy._require_stacking:
1530
require_stacking = True
1531
result._format.require_stacking()
1532
result_repo.lock_write()
1535
repository_policy = None
1536
return result_repo, result, require_stacking, repository_policy
1538
1824
def _initialize_on_transport_vfs(self, transport):
1539
1825
"""Initialize a new bzrdir using VFS calls.
1978
def unregister_format(klass, format):
1979
del klass._formats[format.get_format_string()]
1982
def unregister_control_format(klass, format):
1983
klass._control_formats.remove(format)
1986
class BzrDirFormat4(BzrDirFormat):
1987
"""Bzr dir format 4.
1989
This format is a combined format for working tree, branch and repository.
1991
- Format 1 working trees [always]
1992
- Format 4 branches [always]
1993
- Format 4 repositories [always]
1995
This format is deprecated: it indexes texts using a text it which is
1996
removed in format 5; write support for this format has been removed.
1999
_lock_class = lockable_files.TransportLock
2001
def get_format_string(self):
2002
"""See BzrDirFormat.get_format_string()."""
2003
return "Bazaar-NG branch, format 0.0.4\n"
2005
def get_format_description(self):
2006
"""See BzrDirFormat.get_format_description()."""
2007
return "All-in-one format 4"
2009
def get_converter(self, format=None):
2010
"""See BzrDirFormat.get_converter()."""
2011
# there is one and only one upgrade path here.
2012
return ConvertBzrDir4To5()
2014
def initialize_on_transport(self, transport):
2015
"""Format 4 branches cannot be created."""
2016
raise errors.UninitializableFormat(self)
2018
def is_supported(self):
2019
"""Format 4 is not supported.
2021
It is not supported because the model changed from 4 to 5 and the
2022
conversion logic is expensive - so doing it on the fly was not
2027
def network_name(self):
2028
return self.get_format_string()
2030
def _open(self, transport):
2031
"""See BzrDirFormat._open."""
2032
return BzrDir4(transport, self)
2034
def __return_repository_format(self):
2035
"""Circular import protection."""
2036
from bzrlib.repofmt.weaverepo import RepositoryFormat4
2037
return RepositoryFormat4()
2038
repository_format = property(__return_repository_format)
2041
class BzrDirFormat5(BzrDirFormat):
2042
"""Bzr control format 5.
2044
This format is a combined format for working tree, branch and repository.
2046
- Format 2 working trees [always]
2047
- Format 4 branches [always]
2048
- Format 5 repositories [always]
2049
Unhashed stores in the repository.
2052
_lock_class = lockable_files.TransportLock
2054
def get_format_string(self):
2055
"""See BzrDirFormat.get_format_string()."""
2056
return "Bazaar-NG branch, format 5\n"
2058
def get_branch_format(self):
2059
from bzrlib import branch
2060
return branch.BzrBranchFormat4()
2062
def get_format_description(self):
2063
"""See BzrDirFormat.get_format_description()."""
2064
return "All-in-one format 5"
2066
def get_converter(self, format=None):
2067
"""See BzrDirFormat.get_converter()."""
2068
# there is one and only one upgrade path here.
2069
return ConvertBzrDir5To6()
2071
def _initialize_for_clone(self, url):
2072
return self.initialize_on_transport(get_transport(url), _cloning=True)
2074
def initialize_on_transport(self, transport, _cloning=False):
2075
"""Format 5 dirs always have working tree, branch and repository.
2077
Except when they are being cloned.
2079
from bzrlib.branch import BzrBranchFormat4
2080
from bzrlib.repofmt.weaverepo import RepositoryFormat5
2081
result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
2082
RepositoryFormat5().initialize(result, _internal=True)
2084
branch = BzrBranchFormat4().initialize(result)
2085
result._init_workingtree()
2088
def network_name(self):
2089
return self.get_format_string()
2091
def _open(self, transport):
2092
"""See BzrDirFormat._open."""
2093
return BzrDir5(transport, self)
2095
def __return_repository_format(self):
2096
"""Circular import protection."""
2097
from bzrlib.repofmt.weaverepo import RepositoryFormat5
2098
return RepositoryFormat5()
2099
repository_format = property(__return_repository_format)
2102
class BzrDirFormat6(BzrDirFormat):
2103
"""Bzr control format 6.
2105
This format is a combined format for working tree, branch and repository.
2107
- Format 2 working trees [always]
2108
- Format 4 branches [always]
2109
- Format 6 repositories [always]
2112
_lock_class = lockable_files.TransportLock
2114
def get_format_string(self):
2115
"""See BzrDirFormat.get_format_string()."""
2116
return "Bazaar-NG branch, format 6\n"
2118
def get_format_description(self):
2119
"""See BzrDirFormat.get_format_description()."""
2120
return "All-in-one format 6"
2122
def get_branch_format(self):
2123
from bzrlib import branch
2124
return branch.BzrBranchFormat4()
2126
def get_converter(self, format=None):
2127
"""See BzrDirFormat.get_converter()."""
2128
# there is one and only one upgrade path here.
2129
return ConvertBzrDir6ToMeta()
2131
def _initialize_for_clone(self, url):
2132
return self.initialize_on_transport(get_transport(url), _cloning=True)
2134
def initialize_on_transport(self, transport, _cloning=False):
2135
"""Format 6 dirs always have working tree, branch and repository.
2137
Except when they are being cloned.
2139
from bzrlib.branch import BzrBranchFormat4
2140
from bzrlib.repofmt.weaverepo import RepositoryFormat6
2141
result = super(BzrDirFormat6, self).initialize_on_transport(transport)
2142
RepositoryFormat6().initialize(result, _internal=True)
2144
branch = BzrBranchFormat4().initialize(result)
2145
result._init_workingtree()
2148
def network_name(self):
2149
return self.get_format_string()
2151
def _open(self, transport):
2152
"""See BzrDirFormat._open."""
2153
return BzrDir6(transport, self)
2155
def __return_repository_format(self):
2156
"""Circular import protection."""
2157
from bzrlib.repofmt.weaverepo import RepositoryFormat6
2158
return RepositoryFormat6()
2159
repository_format = property(__return_repository_format)
1613
2162
class BzrDirMetaFormat1(BzrDirFormat):
1614
2163
"""Bzr meta control format 1
1616
2165
This is the first format with split out working tree, branch and repository
1621
- Format 3 working trees [optional]
1622
- Format 5 branches [optional]
1623
- Format 7 repositories [optional]
2168
- Format 3 working trees [optional]
2169
- Format 5 branches [optional]
2170
- Format 7 repositories [optional]
1626
2173
_lock_class = lockdir.LockDir
1628
fixed_components = False
1630
2175
def __init__(self):
1631
2176
self._workingtree_format = None
1632
2177
self._branch_format = None
1647
2192
def get_branch_format(self):
1648
2193
if self._branch_format is None:
1649
from bzrlib.branch import format_registry as branch_format_registry
1650
self._branch_format = branch_format_registry.get_default()
2194
from bzrlib.branch import BranchFormat
2195
self._branch_format = BranchFormat.get_default_format()
1651
2196
return self._branch_format
1653
2198
def set_branch_format(self, format):
1654
2199
self._branch_format = format
1656
def require_stacking(self, stack_on=None, possible_transports=None,
1658
"""We have a request to stack, try to ensure the formats support it.
1660
:param stack_on: If supplied, it is the URL to a branch that we want to
1661
stack on. Check to see if that format supports stacking before
1664
# Stacking is desired. requested by the target, but does the place it
1665
# points at support stacking? If it doesn't then we should
1666
# not implicitly upgrade. We check this here.
1667
new_repo_format = None
1668
new_branch_format = None
1670
# a bit of state for get_target_branch so that we don't try to open it
1671
# 2 times, for both repo *and* branch
1672
target = [None, False, None] # target_branch, checked, upgrade anyway
1673
def get_target_branch():
1675
# We've checked, don't check again
1677
if stack_on is None:
1678
# No target format, that means we want to force upgrading
1679
target[:] = [None, True, True]
1682
target_dir = BzrDir.open(stack_on,
1683
possible_transports=possible_transports)
1684
except errors.NotBranchError:
1685
# Nothing there, don't change formats
1686
target[:] = [None, True, False]
1688
except errors.JailBreak:
1689
# JailBreak, JFDI and upgrade anyway
1690
target[:] = [None, True, True]
1693
target_branch = target_dir.open_branch()
1694
except errors.NotBranchError:
1695
# No branch, don't upgrade formats
1696
target[:] = [None, True, False]
1698
target[:] = [target_branch, True, False]
1701
if (not _skip_repo and
1702
not self.repository_format.supports_external_lookups):
1703
# We need to upgrade the Repository.
1704
target_branch, _, do_upgrade = get_target_branch()
1705
if target_branch is None:
1706
# We don't have a target branch, should we upgrade anyway?
1708
# stack_on is inaccessible, JFDI.
1709
# TODO: bad monkey, hard-coded formats...
1710
if self.repository_format.rich_root_data:
1711
new_repo_format = knitpack_repo.RepositoryFormatKnitPack5RichRoot()
1713
new_repo_format = knitpack_repo.RepositoryFormatKnitPack5()
1715
# If the target already supports stacking, then we know the
1716
# project is already able to use stacking, so auto-upgrade
1718
new_repo_format = target_branch.repository._format
1719
if not new_repo_format.supports_external_lookups:
1720
# target doesn't, source doesn't, so don't auto upgrade
1722
new_repo_format = None
1723
if new_repo_format is not None:
1724
self.repository_format = new_repo_format
1725
note('Source repository format does not support stacking,'
1726
' using format:\n %s',
1727
new_repo_format.get_format_description())
2201
def require_stacking(self):
1729
2202
if not self.get_branch_format().supports_stacking():
1730
# We just checked the repo, now lets check if we need to
1731
# upgrade the branch format
1732
target_branch, _, do_upgrade = get_target_branch()
1733
if target_branch is None:
1735
# TODO: bad monkey, hard-coded formats...
1736
from bzrlib.branch import BzrBranchFormat7
1737
new_branch_format = BzrBranchFormat7()
2203
# We need to make a stacked branch, but the default format for the
2204
# target doesn't support stacking. So force a branch that *can*
2206
from bzrlib.branch import BzrBranchFormat7
2207
branch_format = BzrBranchFormat7()
2208
self.set_branch_format(branch_format)
2209
mutter("using %r for stacking" % (branch_format,))
2210
from bzrlib.repofmt import pack_repo
2211
if self.repository_format.rich_root_data:
2212
bzrdir_format_name = '1.6.1-rich-root'
2213
repo_format = pack_repo.RepositoryFormatKnitPack5RichRoot()
1739
new_branch_format = target_branch._format
1740
if not new_branch_format.supports_stacking():
1741
new_branch_format = None
1742
if new_branch_format is not None:
1743
# Does support stacking, use its format.
1744
self.set_branch_format(new_branch_format)
1745
note('Source branch format does not support stacking,'
1746
' using format:\n %s',
1747
new_branch_format.get_format_description())
2215
bzrdir_format_name = '1.6'
2216
repo_format = pack_repo.RepositoryFormatKnitPack5()
2217
note('Source format does not support stacking, using format:'
2219
bzrdir_format_name, repo_format.get_format_description())
2220
self.repository_format = repo_format
1749
2222
def get_converter(self, format=None):
1750
2223
"""See BzrDirFormat.get_converter()."""
1823
2288
__set_workingtree_format)
2291
network_format_registry = registry.FormatRegistry()
2292
"""Registry of formats indexed by their network name.
2294
The network name for a BzrDirFormat is an identifier that can be used when
2295
referring to formats with smart server operations. See
2296
BzrDirFormat.network_name() for more detail.
2300
# Register bzr control format
2301
BzrDirFormat.register_control_format(BzrDirFormat)
1826
2303
# Register bzr formats
1827
BzrProber.formats.register(BzrDirMetaFormat1.get_format_string(),
1829
controldir.ControlDirFormat._default_format = BzrDirMetaFormat1()
1832
class ConvertMetaToMeta(controldir.Converter):
2304
BzrDirFormat.register_format(BzrDirFormat4())
2305
BzrDirFormat.register_format(BzrDirFormat5())
2306
BzrDirFormat.register_format(BzrDirFormat6())
2307
__default_format = BzrDirMetaFormat1()
2308
BzrDirFormat.register_format(__default_format)
2309
BzrDirFormat._default_format = __default_format
2312
class Converter(object):
2313
"""Converts a disk format object from one format to another."""
2315
def convert(self, to_convert, pb):
2316
"""Perform the conversion of to_convert, giving feedback via pb.
2318
:param to_convert: The disk object to convert.
2319
:param pb: a progress bar to use for progress information.
2322
def step(self, message):
2323
"""Update the pb by a step."""
2325
self.pb.update(message, self.count, self.total)
2328
class ConvertBzrDir4To5(Converter):
2329
"""Converts format 4 bzr dirs to format 5."""
2332
super(ConvertBzrDir4To5, self).__init__()
2333
self.converted_revs = set()
2334
self.absent_revisions = set()
2338
def convert(self, to_convert, pb):
2339
"""See Converter.convert()."""
2340
self.bzrdir = to_convert
2342
self.pb.note('starting upgrade from format 4 to 5')
2343
if isinstance(self.bzrdir.transport, local.LocalTransport):
2344
self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
2345
self._convert_to_weaves()
2346
return BzrDir.open(self.bzrdir.root_transport.base)
2348
def _convert_to_weaves(self):
2349
self.pb.note('note: upgrade may be faster if all store files are ungzipped first')
2352
stat = self.bzrdir.transport.stat('weaves')
2353
if not S_ISDIR(stat.st_mode):
2354
self.bzrdir.transport.delete('weaves')
2355
self.bzrdir.transport.mkdir('weaves')
2356
except errors.NoSuchFile:
2357
self.bzrdir.transport.mkdir('weaves')
2358
# deliberately not a WeaveFile as we want to build it up slowly.
2359
self.inv_weave = Weave('inventory')
2360
# holds in-memory weaves for all files
2361
self.text_weaves = {}
2362
self.bzrdir.transport.delete('branch-format')
2363
self.branch = self.bzrdir.open_branch()
2364
self._convert_working_inv()
2365
rev_history = self.branch.revision_history()
2366
# to_read is a stack holding the revisions we still need to process;
2367
# appending to it adds new highest-priority revisions
2368
self.known_revisions = set(rev_history)
2369
self.to_read = rev_history[-1:]
2371
rev_id = self.to_read.pop()
2372
if (rev_id not in self.revisions
2373
and rev_id not in self.absent_revisions):
2374
self._load_one_rev(rev_id)
2376
to_import = self._make_order()
2377
for i, rev_id in enumerate(to_import):
2378
self.pb.update('converting revision', i, len(to_import))
2379
self._convert_one_rev(rev_id)
2381
self._write_all_weaves()
2382
self._write_all_revs()
2383
self.pb.note('upgraded to weaves:')
2384
self.pb.note(' %6d revisions and inventories', len(self.revisions))
2385
self.pb.note(' %6d revisions not present', len(self.absent_revisions))
2386
self.pb.note(' %6d texts', self.text_count)
2387
self._cleanup_spare_files_after_format4()
2388
self.branch._transport.put_bytes(
2390
BzrDirFormat5().get_format_string(),
2391
mode=self.bzrdir._get_file_mode())
2393
def _cleanup_spare_files_after_format4(self):
2394
# FIXME working tree upgrade foo.
2395
for n in 'merged-patches', 'pending-merged-patches':
2397
## assert os.path.getsize(p) == 0
2398
self.bzrdir.transport.delete(n)
2399
except errors.NoSuchFile:
2401
self.bzrdir.transport.delete_tree('inventory-store')
2402
self.bzrdir.transport.delete_tree('text-store')
2404
def _convert_working_inv(self):
2405
inv = xml4.serializer_v4.read_inventory(
2406
self.branch._transport.get('inventory'))
2407
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv, working=True)
2408
self.branch._transport.put_bytes('inventory', new_inv_xml,
2409
mode=self.bzrdir._get_file_mode())
2411
def _write_all_weaves(self):
2412
controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
2413
weave_transport = self.bzrdir.transport.clone('weaves')
2414
weaves = WeaveStore(weave_transport, prefixed=False)
2415
transaction = WriteTransaction()
2419
for file_id, file_weave in self.text_weaves.items():
2420
self.pb.update('writing weave', i, len(self.text_weaves))
2421
weaves._put_weave(file_id, file_weave, transaction)
2423
self.pb.update('inventory', 0, 1)
2424
controlweaves._put_weave('inventory', self.inv_weave, transaction)
2425
self.pb.update('inventory', 1, 1)
2429
def _write_all_revs(self):
2430
"""Write all revisions out in new form."""
2431
self.bzrdir.transport.delete_tree('revision-store')
2432
self.bzrdir.transport.mkdir('revision-store')
2433
revision_transport = self.bzrdir.transport.clone('revision-store')
2435
from bzrlib.xml5 import serializer_v5
2436
from bzrlib.repofmt.weaverepo import RevisionTextStore
2437
revision_store = RevisionTextStore(revision_transport,
2438
serializer_v5, False, versionedfile.PrefixMapper(),
2439
lambda:True, lambda:True)
2441
for i, rev_id in enumerate(self.converted_revs):
2442
self.pb.update('write revision', i, len(self.converted_revs))
2443
text = serializer_v5.write_revision_to_string(
2444
self.revisions[rev_id])
2446
revision_store.add_lines(key, None, osutils.split_lines(text))
2450
def _load_one_rev(self, rev_id):
2451
"""Load a revision object into memory.
2453
Any parents not either loaded or abandoned get queued to be
2455
self.pb.update('loading revision',
2456
len(self.revisions),
2457
len(self.known_revisions))
2458
if not self.branch.repository.has_revision(rev_id):
2460
self.pb.note('revision {%s} not present in branch; '
2461
'will be converted as a ghost',
2463
self.absent_revisions.add(rev_id)
2465
rev = self.branch.repository.get_revision(rev_id)
2466
for parent_id in rev.parent_ids:
2467
self.known_revisions.add(parent_id)
2468
self.to_read.append(parent_id)
2469
self.revisions[rev_id] = rev
2471
def _load_old_inventory(self, rev_id):
2472
old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
2473
inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
2474
inv.revision_id = rev_id
2475
rev = self.revisions[rev_id]
2478
def _load_updated_inventory(self, rev_id):
2479
inv_xml = self.inv_weave.get_text(rev_id)
2480
inv = xml5.serializer_v5.read_inventory_from_string(inv_xml, rev_id)
2483
def _convert_one_rev(self, rev_id):
2484
"""Convert revision and all referenced objects to new format."""
2485
rev = self.revisions[rev_id]
2486
inv = self._load_old_inventory(rev_id)
2487
present_parents = [p for p in rev.parent_ids
2488
if p not in self.absent_revisions]
2489
self._convert_revision_contents(rev, inv, present_parents)
2490
self._store_new_inv(rev, inv, present_parents)
2491
self.converted_revs.add(rev_id)
2493
def _store_new_inv(self, rev, inv, present_parents):
2494
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
2495
new_inv_sha1 = sha_string(new_inv_xml)
2496
self.inv_weave.add_lines(rev.revision_id,
2498
new_inv_xml.splitlines(True))
2499
rev.inventory_sha1 = new_inv_sha1
2501
def _convert_revision_contents(self, rev, inv, present_parents):
2502
"""Convert all the files within a revision.
2504
Also upgrade the inventory to refer to the text revision ids."""
2505
rev_id = rev.revision_id
2506
mutter('converting texts of revision {%s}',
2508
parent_invs = map(self._load_updated_inventory, present_parents)
2509
entries = inv.iter_entries()
2511
for path, ie in entries:
2512
self._convert_file_version(rev, ie, parent_invs)
2514
def _convert_file_version(self, rev, ie, parent_invs):
2515
"""Convert one version of one file.
2517
The file needs to be added into the weave if it is a merge
2518
of >=2 parents or if it's changed from its parent.
2520
file_id = ie.file_id
2521
rev_id = rev.revision_id
2522
w = self.text_weaves.get(file_id)
2525
self.text_weaves[file_id] = w
2526
text_changed = False
2527
parent_candiate_entries = ie.parent_candidates(parent_invs)
2528
heads = graph.Graph(self).heads(parent_candiate_entries.keys())
2529
# XXX: Note that this is unordered - and this is tolerable because
2530
# the previous code was also unordered.
2531
previous_entries = dict((head, parent_candiate_entries[head]) for head
2533
self.snapshot_ie(previous_entries, ie, w, rev_id)
2536
def get_parent_map(self, revision_ids):
2537
"""See graph._StackedParentsProvider.get_parent_map"""
2538
return dict((revision_id, self.revisions[revision_id])
2539
for revision_id in revision_ids
2540
if revision_id in self.revisions)
2542
def snapshot_ie(self, previous_revisions, ie, w, rev_id):
2543
# TODO: convert this logic, which is ~= snapshot to
2544
# a call to:. This needs the path figured out. rather than a work_tree
2545
# a v4 revision_tree can be given, or something that looks enough like
2546
# one to give the file content to the entry if it needs it.
2547
# and we need something that looks like a weave store for snapshot to
2549
#ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
2550
if len(previous_revisions) == 1:
2551
previous_ie = previous_revisions.values()[0]
2552
if ie._unchanged(previous_ie):
2553
ie.revision = previous_ie.revision
2556
text = self.branch.repository._text_store.get(ie.text_id)
2557
file_lines = text.readlines()
2558
w.add_lines(rev_id, previous_revisions, file_lines)
2559
self.text_count += 1
2561
w.add_lines(rev_id, previous_revisions, [])
2562
ie.revision = rev_id
2564
def _make_order(self):
2565
"""Return a suitable order for importing revisions.
2567
The order must be such that an revision is imported after all
2568
its (present) parents.
2570
todo = set(self.revisions.keys())
2571
done = self.absent_revisions.copy()
2574
# scan through looking for a revision whose parents
2576
for rev_id in sorted(list(todo)):
2577
rev = self.revisions[rev_id]
2578
parent_ids = set(rev.parent_ids)
2579
if parent_ids.issubset(done):
2580
# can take this one now
2581
order.append(rev_id)
2587
class ConvertBzrDir5To6(Converter):
2588
"""Converts format 5 bzr dirs to format 6."""
2590
def convert(self, to_convert, pb):
2591
"""See Converter.convert()."""
2592
self.bzrdir = to_convert
2594
self.pb.note('starting upgrade from format 5 to 6')
2595
self._convert_to_prefixed()
2596
return BzrDir.open(self.bzrdir.root_transport.base)
2598
def _convert_to_prefixed(self):
2599
from bzrlib.store import TransportStore
2600
self.bzrdir.transport.delete('branch-format')
2601
for store_name in ["weaves", "revision-store"]:
2602
self.pb.note("adding prefixes to %s" % store_name)
2603
store_transport = self.bzrdir.transport.clone(store_name)
2604
store = TransportStore(store_transport, prefixed=True)
2605
for urlfilename in store_transport.list_dir('.'):
2606
filename = urlutils.unescape(urlfilename)
2607
if (filename.endswith(".weave") or
2608
filename.endswith(".gz") or
2609
filename.endswith(".sig")):
2610
file_id, suffix = os.path.splitext(filename)
2614
new_name = store._mapper.map((file_id,)) + suffix
2615
# FIXME keep track of the dirs made RBC 20060121
2617
store_transport.move(filename, new_name)
2618
except errors.NoSuchFile: # catches missing dirs strangely enough
2619
store_transport.mkdir(osutils.dirname(new_name))
2620
store_transport.move(filename, new_name)
2621
self.bzrdir.transport.put_bytes(
2623
BzrDirFormat6().get_format_string(),
2624
mode=self.bzrdir._get_file_mode())
2627
class ConvertBzrDir6ToMeta(Converter):
2628
"""Converts format 6 bzr dirs to metadirs."""
2630
def convert(self, to_convert, pb):
2631
"""See Converter.convert()."""
2632
from bzrlib.repofmt.weaverepo import RepositoryFormat7
2633
from bzrlib.branch import BzrBranchFormat5
2634
self.bzrdir = to_convert
2637
self.total = 20 # the steps we know about
2638
self.garbage_inventories = []
2639
self.dir_mode = self.bzrdir._get_dir_mode()
2640
self.file_mode = self.bzrdir._get_file_mode()
2642
self.pb.note('starting upgrade from format 6 to metadir')
2643
self.bzrdir.transport.put_bytes(
2645
"Converting to format 6",
2646
mode=self.file_mode)
2647
# its faster to move specific files around than to open and use the apis...
2648
# first off, nuke ancestry.weave, it was never used.
2650
self.step('Removing ancestry.weave')
2651
self.bzrdir.transport.delete('ancestry.weave')
2652
except errors.NoSuchFile:
2654
# find out whats there
2655
self.step('Finding branch files')
2656
last_revision = self.bzrdir.open_branch().last_revision()
2657
bzrcontents = self.bzrdir.transport.list_dir('.')
2658
for name in bzrcontents:
2659
if name.startswith('basis-inventory.'):
2660
self.garbage_inventories.append(name)
2661
# create new directories for repository, working tree and branch
2662
repository_names = [('inventory.weave', True),
2663
('revision-store', True),
2665
self.step('Upgrading repository ')
2666
self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
2667
self.make_lock('repository')
2668
# we hard code the formats here because we are converting into
2669
# the meta format. The meta format upgrader can take this to a
2670
# future format within each component.
2671
self.put_format('repository', RepositoryFormat7())
2672
for entry in repository_names:
2673
self.move_entry('repository', entry)
2675
self.step('Upgrading branch ')
2676
self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
2677
self.make_lock('branch')
2678
self.put_format('branch', BzrBranchFormat5())
2679
branch_files = [('revision-history', True),
2680
('branch-name', True),
2682
for entry in branch_files:
2683
self.move_entry('branch', entry)
2685
checkout_files = [('pending-merges', True),
2686
('inventory', True),
2687
('stat-cache', False)]
2688
# If a mandatory checkout file is not present, the branch does not have
2689
# a functional checkout. Do not create a checkout in the converted
2691
for name, mandatory in checkout_files:
2692
if mandatory and name not in bzrcontents:
2693
has_checkout = False
2697
if not has_checkout:
2698
self.pb.note('No working tree.')
2699
# If some checkout files are there, we may as well get rid of them.
2700
for name, mandatory in checkout_files:
2701
if name in bzrcontents:
2702
self.bzrdir.transport.delete(name)
2704
from bzrlib.workingtree import WorkingTreeFormat3
2705
self.step('Upgrading working tree')
2706
self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
2707
self.make_lock('checkout')
2709
'checkout', WorkingTreeFormat3())
2710
self.bzrdir.transport.delete_multi(
2711
self.garbage_inventories, self.pb)
2712
for entry in checkout_files:
2713
self.move_entry('checkout', entry)
2714
if last_revision is not None:
2715
self.bzrdir.transport.put_bytes(
2716
'checkout/last-revision', last_revision)
2717
self.bzrdir.transport.put_bytes(
2719
BzrDirMetaFormat1().get_format_string(),
2720
mode=self.file_mode)
2721
return BzrDir.open(self.bzrdir.root_transport.base)
2723
def make_lock(self, name):
2724
"""Make a lock for the new control dir name."""
2725
self.step('Make %s lock' % name)
2726
ld = lockdir.LockDir(self.bzrdir.transport,
2728
file_modebits=self.file_mode,
2729
dir_modebits=self.dir_mode)
2732
def move_entry(self, new_dir, entry):
2733
"""Move then entry name into new_dir."""
2735
mandatory = entry[1]
2736
self.step('Moving %s' % name)
2738
self.bzrdir.transport.move(name, '%s/%s' % (new_dir, name))
2739
except errors.NoSuchFile:
2743
def put_format(self, dirname, format):
2744
self.bzrdir.transport.put_bytes('%s/format' % dirname,
2745
format.get_format_string(),
2749
class ConvertMetaToMeta(Converter):
1833
2750
"""Converts the components of metadirs."""
1835
2752
def __init__(self, target_format):
1903
2819
isinstance(self.target_format.workingtree_format,
1904
2820
workingtree_4.WorkingTreeFormat6)):
1905
2821
workingtree_4.Converter4or5to6().convert(tree)
1907
2822
return to_convert
1910
controldir.ControlDirFormat.register_server_prober(RemoteBzrProber)
2825
# This is not in remote.py because it's small, and needs to be registered.
2826
# Putting it in remote.py creates a circular import problem.
2827
# we can make it a lazy object if the control formats is turned into something
2829
class RemoteBzrDirFormat(BzrDirMetaFormat1):
2830
"""Format representing bzrdirs accessed via a smart server"""
2833
BzrDirMetaFormat1.__init__(self)
2834
self._network_name = None
2836
def get_format_description(self):
2837
return 'bzr remote bzrdir'
2839
def get_format_string(self):
2840
raise NotImplementedError(self.get_format_string)
2842
def network_name(self):
2843
if self._network_name:
2844
return self._network_name
2846
raise AssertionError("No network name set.")
2849
def probe_transport(klass, transport):
2850
"""Return a RemoteBzrDirFormat object if it looks possible."""
2852
medium = transport.get_smart_medium()
2853
except (NotImplementedError, AttributeError,
2854
errors.TransportNotPossible, errors.NoSmartMedium,
2855
errors.SmartProtocolError):
2856
# no smart server, so not a branch for this format type.
2857
raise errors.NotBranchError(path=transport.base)
2859
# Decline to open it if the server doesn't support our required
2860
# version (3) so that the VFS-based transport will do it.
2861
if medium.should_probe():
2863
server_version = medium.protocol_version()
2864
except errors.SmartProtocolError:
2865
# Apparently there's no usable smart server there, even though
2866
# the medium supports the smart protocol.
2867
raise errors.NotBranchError(path=transport.base)
2868
if server_version != '2':
2869
raise errors.NotBranchError(path=transport.base)
2872
def initialize_on_transport(self, transport):
2874
# hand off the request to the smart server
2875
client_medium = transport.get_smart_medium()
2876
except errors.NoSmartMedium:
2877
# TODO: lookup the local format from a server hint.
2878
local_dir_format = BzrDirMetaFormat1()
2879
return local_dir_format.initialize_on_transport(transport)
2880
client = _SmartClient(client_medium)
2881
path = client.remote_path_from_transport(transport)
2882
response = client.call('BzrDirFormat.initialize', path)
2883
if response[0] != 'ok':
2884
raise errors.SmartProtocolError('unexpected response code %s' % (response,))
2885
format = RemoteBzrDirFormat()
2886
self._supply_sub_formats_to(format)
2887
return remote.RemoteBzrDir(transport, format)
2889
def _open(self, transport):
2890
return remote.RemoteBzrDir(transport, self)
2892
def __eq__(self, other):
2893
if not isinstance(other, RemoteBzrDirFormat):
2895
return self.get_format_description() == other.get_format_description()
2897
def __return_repository_format(self):
2898
# Always return a RemoteRepositoryFormat object, but if a specific bzr
2899
# repository format has been asked for, tell the RemoteRepositoryFormat
2900
# that it should use that for init() etc.
2901
result = remote.RemoteRepositoryFormat()
2902
custom_format = getattr(self, '_repository_format', None)
2904
if isinstance(custom_format, remote.RemoteRepositoryFormat):
2905
return custom_format
2907
# We will use the custom format to create repositories over the
2908
# wire; expose its details like rich_root_data for code to
2910
result._custom_format = custom_format
2913
def get_branch_format(self):
2914
result = BzrDirMetaFormat1.get_branch_format(self)
2915
if not isinstance(result, remote.RemoteBranchFormat):
2916
new_result = remote.RemoteBranchFormat()
2917
new_result._custom_format = result
2919
self.set_branch_format(new_result)
2923
repository_format = property(__return_repository_format,
2924
BzrDirMetaFormat1._set_repository_format) #.im_func)
2927
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
2930
class BzrDirFormatInfo(object):
2932
def __init__(self, native, deprecated, hidden, experimental):
2933
self.deprecated = deprecated
2934
self.native = native
2935
self.hidden = hidden
2936
self.experimental = experimental
2939
class BzrDirFormatRegistry(registry.Registry):
2940
"""Registry of user-selectable BzrDir subformats.
2942
Differs from BzrDirFormat._control_formats in that it provides sub-formats,
2943
e.g. BzrDirMeta1 with weave repository. Also, it's more user-oriented.
2947
"""Create a BzrDirFormatRegistry."""
2948
self._aliases = set()
2949
self._registration_order = list()
2950
super(BzrDirFormatRegistry, self).__init__()
2953
"""Return a set of the format names which are aliases."""
2954
return frozenset(self._aliases)
2956
def register_metadir(self, key,
2957
repository_format, help, native=True, deprecated=False,
2963
"""Register a metadir subformat.
2965
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
2966
by the Repository/Branch/WorkingTreeformats.
2968
:param repository_format: The fully-qualified repository format class
2970
:param branch_format: Fully-qualified branch format class name as
2972
:param tree_format: Fully-qualified tree format class name as
2975
# This should be expanded to support setting WorkingTree and Branch
2976
# formats, once BzrDirMetaFormat1 supports that.
2977
def _load(full_name):
2978
mod_name, factory_name = full_name.rsplit('.', 1)
2980
mod = __import__(mod_name, globals(), locals(),
2982
except ImportError, e:
2983
raise ImportError('failed to load %s: %s' % (full_name, e))
2985
factory = getattr(mod, factory_name)
2986
except AttributeError:
2987
raise AttributeError('no factory %s in module %r'
2992
bd = BzrDirMetaFormat1()
2993
if branch_format is not None:
2994
bd.set_branch_format(_load(branch_format))
2995
if tree_format is not None:
2996
bd.workingtree_format = _load(tree_format)
2997
if repository_format is not None:
2998
bd.repository_format = _load(repository_format)
3000
self.register(key, helper, help, native, deprecated, hidden,
3001
experimental, alias)
3003
def register(self, key, factory, help, native=True, deprecated=False,
3004
hidden=False, experimental=False, alias=False):
3005
"""Register a BzrDirFormat factory.
3007
The factory must be a callable that takes one parameter: the key.
3008
It must produce an instance of the BzrDirFormat when called.
3010
This function mainly exists to prevent the info object from being
3013
registry.Registry.register(self, key, factory, help,
3014
BzrDirFormatInfo(native, deprecated, hidden, experimental))
3016
self._aliases.add(key)
3017
self._registration_order.append(key)
3019
def register_lazy(self, key, module_name, member_name, help, native=True,
3020
deprecated=False, hidden=False, experimental=False, alias=False):
3021
registry.Registry.register_lazy(self, key, module_name, member_name,
3022
help, BzrDirFormatInfo(native, deprecated, hidden, experimental))
3024
self._aliases.add(key)
3025
self._registration_order.append(key)
3027
def set_default(self, key):
3028
"""Set the 'default' key to be a clone of the supplied key.
3030
This method must be called once and only once.
3032
registry.Registry.register(self, 'default', self.get(key),
3033
self.get_help(key), info=self.get_info(key))
3034
self._aliases.add('default')
3036
def set_default_repository(self, key):
3037
"""Set the FormatRegistry default and Repository default.
3039
This is a transitional method while Repository.set_default_format
3042
if 'default' in self:
3043
self.remove('default')
3044
self.set_default(key)
3045
format = self.get('default')()
3047
def make_bzrdir(self, key):
3048
return self.get(key)()
3050
def help_topic(self, topic):
3052
default_realkey = None
3053
default_help = self.get_help('default')
3055
for key in self._registration_order:
3056
if key == 'default':
3058
help = self.get_help(key)
3059
if help == default_help:
3060
default_realkey = key
3062
help_pairs.append((key, help))
3064
def wrapped(key, help, info):
3066
help = '(native) ' + help
3067
return ':%s:\n%s\n\n' % (key,
3068
textwrap.fill(help, initial_indent=' ',
3069
subsequent_indent=' '))
3070
if default_realkey is not None:
3071
output += wrapped(default_realkey, '(default) %s' % default_help,
3072
self.get_info('default'))
3073
deprecated_pairs = []
3074
experimental_pairs = []
3075
for key, help in help_pairs:
3076
info = self.get_info(key)
3079
elif info.deprecated:
3080
deprecated_pairs.append((key, help))
3081
elif info.experimental:
3082
experimental_pairs.append((key, help))
3084
output += wrapped(key, help, info)
3085
output += "\nSee ``bzr help formats`` for more about storage formats."
3087
if len(experimental_pairs) > 0:
3088
other_output += "Experimental formats are shown below.\n\n"
3089
for key, help in experimental_pairs:
3090
info = self.get_info(key)
3091
other_output += wrapped(key, help, info)
3094
"No experimental formats are available.\n\n"
3095
if len(deprecated_pairs) > 0:
3096
other_output += "\nDeprecated formats are shown below.\n\n"
3097
for key, help in deprecated_pairs:
3098
info = self.get_info(key)
3099
other_output += wrapped(key, help, info)
3102
"\nNo deprecated formats are available.\n\n"
3104
"\nSee ``bzr help formats`` for more about storage formats."
3106
if topic == 'other-formats':
1913
3112
class RepositoryAcquisitionPolicy(object):
2068
3292
return self._repository, False
2071
def register_metadir(registry, key,
2072
repository_format, help, native=True, deprecated=False,
2078
"""Register a metadir subformat.
2080
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
2081
by the Repository/Branch/WorkingTreeformats.
2083
:param repository_format: The fully-qualified repository format class
2085
:param branch_format: Fully-qualified branch format class name as
2087
:param tree_format: Fully-qualified tree format class name as
2090
# This should be expanded to support setting WorkingTree and Branch
2091
# formats, once BzrDirMetaFormat1 supports that.
2092
def _load(full_name):
2093
mod_name, factory_name = full_name.rsplit('.', 1)
2095
factory = pyutils.get_named_object(mod_name, factory_name)
2096
except ImportError, e:
2097
raise ImportError('failed to load %s: %s' % (full_name, e))
2098
except AttributeError:
2099
raise AttributeError('no factory %s in module %r'
2100
% (full_name, sys.modules[mod_name]))
2104
bd = BzrDirMetaFormat1()
2105
if branch_format is not None:
2106
bd.set_branch_format(_load(branch_format))
2107
if tree_format is not None:
2108
bd.workingtree_format = _load(tree_format)
2109
if repository_format is not None:
2110
bd.repository_format = _load(repository_format)
2112
registry.register(key, helper, help, native, deprecated, hidden,
2113
experimental, alias)
2115
register_metadir(controldir.format_registry, 'knit',
3295
# Please register new formats after old formats so that formats
3296
# appear in chronological order and format descriptions can build
3298
format_registry = BzrDirFormatRegistry()
3299
# The pre-0.8 formats have their repository format network name registered in
3300
# repository.py. MetaDir formats have their repository format network name
3301
# inferred from their disk format string.
3302
format_registry.register('weave', BzrDirFormat6,
3303
'Pre-0.8 format. Slower than knit and does not'
3304
' support checkouts or shared repositories.',
3306
format_registry.register_metadir('metaweave',
3307
'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3308
'Transitional format in 0.8. Slower than knit.',
3309
branch_format='bzrlib.branch.BzrBranchFormat5',
3310
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3312
format_registry.register_metadir('knit',
2116
3313
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2117
3314
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
2118
3315
branch_format='bzrlib.branch.BzrBranchFormat5',
2119
tree_format='bzrlib.workingtree_3.WorkingTreeFormat3',
3316
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
2121
3317
deprecated=True)
2122
register_metadir(controldir.format_registry, 'dirstate',
3318
format_registry.register_metadir('dirstate',
2123
3319
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2124
3320
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
2125
3321
'above when accessed over the network.',
2126
3322
branch_format='bzrlib.branch.BzrBranchFormat5',
2127
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3323
# this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
3324
# directly from workingtree_4 triggers a circular import.
3325
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2129
3326
deprecated=True)
2130
register_metadir(controldir.format_registry, 'dirstate-tags',
3327
format_registry.register_metadir('dirstate-tags',
2131
3328
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2132
3329
help='New in 0.15: Fast local operations and improved scaling for '
2133
3330
'network operations. Additionally adds support for tags.'
2134
3331
' Incompatible with bzr < 0.15.',
2135
3332
branch_format='bzrlib.branch.BzrBranchFormat6',
2136
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3333
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2138
3334
deprecated=True)
2139
register_metadir(controldir.format_registry, 'rich-root',
3335
format_registry.register_metadir('rich-root',
2140
3336
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
2141
3337
help='New in 1.0. Better handling of tree roots. Incompatible with'
2143
3339
branch_format='bzrlib.branch.BzrBranchFormat6',
2144
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3340
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2146
3341
deprecated=True)
2147
register_metadir(controldir.format_registry, 'dirstate-with-subtree',
3342
format_registry.register_metadir('dirstate-with-subtree',
2148
3343
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
2149
3344
help='New in 0.15: Fast local operations and improved scaling for '
2150
3345
'network operations. Additionally adds support for versioning nested '
2151
3346
'bzr branches. Incompatible with bzr < 0.15.',
2152
3347
branch_format='bzrlib.branch.BzrBranchFormat6',
2153
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3348
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2154
3349
experimental=True,
2157
register_metadir(controldir.format_registry, 'pack-0.92',
2158
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack1',
3352
format_registry.register_metadir('pack-0.92',
3353
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack1',
2159
3354
help='New in 0.92: Pack-based format with data compatible with '
2160
3355
'dirstate-tags format repositories. Interoperates with '
2161
3356
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3357
'Previously called knitpack-experimental. '
3358
'For more information, see '
3359
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
2163
3360
branch_format='bzrlib.branch.BzrBranchFormat6',
2164
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3361
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2166
register_metadir(controldir.format_registry, 'pack-0.92-subtree',
2167
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack3',
3363
format_registry.register_metadir('pack-0.92-subtree',
3364
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack3',
2168
3365
help='New in 0.92: Pack-based format with data compatible with '
2169
3366
'dirstate-with-subtree format repositories. Interoperates with '
2170
3367
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3368
'Previously called knitpack-experimental. '
3369
'For more information, see '
3370
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
2172
3371
branch_format='bzrlib.branch.BzrBranchFormat6',
2173
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3372
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2175
3374
experimental=True,
2177
register_metadir(controldir.format_registry, 'rich-root-pack',
2178
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack4',
3376
format_registry.register_metadir('rich-root-pack',
3377
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
2179
3378
help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
2180
3379
'(needed for bzr-svn and bzr-git).',
2181
3380
branch_format='bzrlib.branch.BzrBranchFormat6',
2182
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3381
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2185
register_metadir(controldir.format_registry, '1.6',
2186
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack5',
3383
format_registry.register_metadir('1.6',
3384
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
2187
3385
help='A format that allows a branch to indicate that there is another '
2188
3386
'(stacked) repository that should be used to access data that is '
2189
3387
'not present locally.',
2190
3388
branch_format='bzrlib.branch.BzrBranchFormat7',
2191
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3389
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2194
register_metadir(controldir.format_registry, '1.6.1-rich-root',
2195
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack5RichRoot',
3391
format_registry.register_metadir('1.6.1-rich-root',
3392
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
2196
3393
help='A variant of 1.6 that supports rich-root data '
2197
3394
'(needed for bzr-svn and bzr-git).',
2198
3395
branch_format='bzrlib.branch.BzrBranchFormat7',
2199
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3396
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2202
register_metadir(controldir.format_registry, '1.9',
2203
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6',
3398
format_registry.register_metadir('1.9',
3399
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
2204
3400
help='A repository format using B+tree indexes. These indexes '
2205
3401
'are smaller in size, have smarter caching and provide faster '
2206
3402
'performance for most operations.',
2207
3403
branch_format='bzrlib.branch.BzrBranchFormat7',
2208
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3404
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2211
register_metadir(controldir.format_registry, '1.9-rich-root',
2212
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6RichRoot',
3406
format_registry.register_metadir('1.9-rich-root',
3407
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
2213
3408
help='A variant of 1.9 that supports rich-root data '
2214
3409
'(needed for bzr-svn and bzr-git).',
2215
3410
branch_format='bzrlib.branch.BzrBranchFormat7',
2216
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3411
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2219
register_metadir(controldir.format_registry, '1.14',
2220
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6',
3413
format_registry.register_metadir('1.14',
3414
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
2221
3415
help='A working-tree format that supports content filtering.',
2222
3416
branch_format='bzrlib.branch.BzrBranchFormat7',
2223
tree_format='bzrlib.workingtree_4.WorkingTreeFormat5',
3417
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
2225
register_metadir(controldir.format_registry, '1.14-rich-root',
2226
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6RichRoot',
3419
format_registry.register_metadir('1.14-rich-root',
3420
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
2227
3421
help='A variant of 1.14 that supports rich-root data '
2228
3422
'(needed for bzr-svn and bzr-git).',
2229
3423
branch_format='bzrlib.branch.BzrBranchFormat7',
2230
tree_format='bzrlib.workingtree_4.WorkingTreeFormat5',
2232
# The following un-numbered 'development' formats should always just be aliases.
2233
register_metadir(controldir.format_registry, 'development-subtree',
2234
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2aSubtree',
3424
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3426
# The following two formats should always just be aliases.
3427
format_registry.register_metadir('development',
3428
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2',
3429
help='Current development format. Can convert data to and from pack-0.92 '
3430
'(and anything compatible with pack-0.92) format repositories. '
3431
'Repositories and branches in this format can only be read by bzr.dev. '
3433
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3435
branch_format='bzrlib.branch.BzrBranchFormat7',
3436
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3440
format_registry.register_metadir('development-subtree',
3441
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
2235
3442
help='Current development format, subtree variant. Can convert data to and '
2236
3443
'from pack-0.92-subtree (and anything compatible with '
2237
3444
'pack-0.92-subtree) format repositories. Repositories and branches in '
2238
3445
'this format can only be read by bzr.dev. Please read '
2239
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
2241
branch_format='bzrlib.branch.BzrBranchFormat7',
2242
tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
2245
alias=False, # Restore to being an alias when an actual development subtree format is added
2246
# This current non-alias status is simply because we did not introduce a
2247
# chk based subtree format.
2249
register_metadir(controldir.format_registry, 'development5-subtree',
2250
'bzrlib.repofmt.knitpack_repo.RepositoryFormatPackDevelopment2Subtree',
2251
help='Development format, subtree variant. Can convert data to and '
2252
'from pack-0.92-subtree (and anything compatible with '
2253
'pack-0.92-subtree) format repositories. Repositories and branches in '
2254
'this format can only be read by bzr.dev. Please read '
2255
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
2257
branch_format='bzrlib.branch.BzrBranchFormat7',
2258
tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
3446
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3448
branch_format='bzrlib.branch.BzrBranchFormat7',
3449
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2264
3453
# And the development formats above will have aliased one of the following:
2266
# Finally, the current format.
2267
register_metadir(controldir.format_registry, '2a',
2268
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
2269
help='First format for bzr 2.0 series.\n'
2270
'Uses group-compress storage.\n'
2271
'Provides rich roots which are a one-way transition.\n',
2272
# 'storage in packs, 255-way hashed CHK inventory, bencode revision, group compress, '
2273
# 'rich roots. Supported by bzr 1.16 and later.',
2274
branch_format='bzrlib.branch.BzrBranchFormat7',
2275
tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
3454
format_registry.register_metadir('development2',
3455
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2',
3456
help='1.6.1 with B+Tree based index. '
3458
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3460
branch_format='bzrlib.branch.BzrBranchFormat7',
3461
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3465
format_registry.register_metadir('development2-subtree',
3466
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3467
help='1.6.1-subtree with B+Tree based index. '
3469
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3471
branch_format='bzrlib.branch.BzrBranchFormat7',
3472
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3476
# These next two formats should be removed when the gc formats are
3477
# updated to use WorkingTreeFormat6 and are merged into bzr.dev
3478
format_registry.register_metadir('development-wt6',
3479
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3480
help='1.14 with filtered views. '
3482
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3484
branch_format='bzrlib.branch.BzrBranchFormat7',
3485
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3489
format_registry.register_metadir('development-wt6-rich-root',
3490
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3491
help='A variant of development-wt6 that supports rich-root data '
3492
'(needed for bzr-svn and bzr-git).',
3493
branch_format='bzrlib.branch.BzrBranchFormat7',
3494
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
2279
3498
# The following format should be an alias for the rich root equivalent
2280
3499
# of the default format
2281
register_metadir(controldir.format_registry, 'default-rich-root',
2282
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
2283
branch_format='bzrlib.branch.BzrBranchFormat7',
2284
tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
3500
format_registry.register_metadir('default-rich-root',
3501
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3502
help='Default format, rich root variant. (needed for bzr-svn and bzr-git).',
3503
branch_format='bzrlib.branch.BzrBranchFormat6',
3504
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2289
3507
# The current format that is made on 'bzr init'.
2290
format_name = config.GlobalConfig().get_user_option('default_format')
2291
if format_name is None:
2292
controldir.format_registry.set_default('2a')
2294
controldir.format_registry.set_default(format_name)
2296
# XXX 2010-08-20 JRV: There is still a lot of code relying on
2297
# bzrlib.bzrdir.format_registry existing. When BzrDir.create/BzrDir.open/etc
2298
# get changed to ControlDir.create/ControlDir.open/etc this should be removed.
2299
format_registry = controldir.format_registry
3508
format_registry.set_default('pack-0.92')
added
removed
bzrlib/bzrdir.py
