171
215
errors.UnstackableRepositoryFormat,
172
216
errors.NotStacked):
174
# Bug: We create a metadir without knowing if it can support stacking,
175
# we should look up the policy needs first, or just use it as a hint,
178
make_working_trees = local_repo.make_working_trees() and not no_tree
179
want_shared = local_repo.is_shared()
180
repo_format_name = format.repository_format.network_name()
182
make_working_trees = False
184
repo_format_name = None
186
result_repo, result, require_stacking, repository_policy = \
187
format.initialize_on_transport_ex(transport,
188
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
189
force_new_repo=force_new_repo, stacked_on=stacked_on,
190
stack_on_pwd=self.root_transport.base,
191
repo_format_name=repo_format_name,
192
make_working_trees=make_working_trees, shared_repo=want_shared)
195
# If the result repository is in the same place as the
196
# resulting bzr dir, it will have no content, further if the
197
# result is not stacked then we know all content should be
198
# copied, and finally if we are copying up to a specific
199
# revision_id then we can use the pending-ancestry-result which
200
# does not require traversing all of history to describe it.
201
if (result_repo.user_url == result.user_url
202
and not require_stacking and
203
revision_id is not None):
204
fetch_spec = graph.PendingAncestryResult(
205
[revision_id], local_repo)
206
result_repo.fetch(local_repo, fetch_spec=fetch_spec)
208
result_repo.fetch(local_repo, revision_id=revision_id)
212
if result_repo is not None:
213
raise AssertionError('result_repo not None(%r)' % result_repo)
220
# may need to copy content in
221
repository_policy = result.determine_repository_policy(
222
force_new_repo, stacked_on, self.root_transport.base,
223
require_stacking=require_stacking)
224
make_working_trees = local_repo.make_working_trees()
225
result_repo = repository_policy.acquire_repository(
226
make_working_trees, local_repo.is_shared())
227
result_repo.fetch(local_repo, revision_id=revision_id)
214
230
# 1 if there is a branch present
215
231
# make sure its content is available in the target repository
217
233
if local_branch is not None:
218
result_branch = local_branch.clone(result, revision_id=revision_id,
219
repository_policy=repository_policy)
221
# Cheaper to check if the target is not local, than to try making
223
result.root_transport.local_abspath('.')
224
if result_repo is None or result_repo.make_working_trees():
234
result_branch = local_branch.clone(result, revision_id=revision_id)
235
if repository_policy is not None:
236
repository_policy.configure_branch(result_branch)
237
if result_repo is None or result_repo.make_working_trees():
225
239
self.open_workingtree().clone(result)
226
except (errors.NoWorkingTree, errors.NotLocalUrl):
240
except (errors.NoWorkingTree, errors.NotLocalUrl):
230
244
# TODO: This should be given a Transport, and should chdir up; otherwise
231
245
# this will open a new connection.
232
246
def _make_tail(self, url):
233
t = _mod_transport.get_transport(url)
247
t = get_transport(url)
251
def create(cls, base, format=None, possible_transports=None):
252
"""Create a new BzrDir at the url 'base'.
254
:param format: If supplied, the format of branch to create. If not
255
supplied, the default is used.
256
:param possible_transports: If supplied, a list of transports that
257
can be reused to share a remote connection.
259
if cls is not BzrDir:
260
raise AssertionError("BzrDir.create always creates the default"
261
" format, not one of %r" % cls)
262
t = get_transport(base, possible_transports)
265
format = BzrDirFormat.get_default_format()
266
return format.initialize_on_transport(t)
237
269
def find_bzrdirs(transport, evaluate=None, list_current=None):
388
440
def _find_or_create_repository(self, force_new_repo):
389
441
"""Create a new repository if needed, returning the repository."""
390
442
policy = self.determine_repository_policy(force_new_repo)
391
return policy.acquire_repository()[0]
393
def _find_source_repo(self, add_cleanup, source_branch):
394
"""Find the source branch and repo for a sprout operation.
396
This is helper intended for use by _sprout.
398
:returns: (source_branch, source_repository). Either or both may be
399
None. If not None, they will be read-locked (and their unlock(s)
400
scheduled via the add_cleanup param).
402
if source_branch is not None:
403
add_cleanup(source_branch.lock_read().unlock)
404
return source_branch, source_branch.repository
406
source_branch = self.open_branch()
407
source_repository = source_branch.repository
408
except errors.NotBranchError:
411
source_repository = self.open_repository()
412
except errors.NoRepositoryPresent:
413
source_repository = None
415
add_cleanup(source_repository.lock_read().unlock)
417
add_cleanup(source_branch.lock_read().unlock)
418
return source_branch, source_repository
420
def sprout(self, url, revision_id=None, force_new_repo=False,
421
recurse='down', possible_transports=None,
422
accelerator_tree=None, hardlink=False, stacked=False,
423
source_branch=None, create_tree_if_local=True):
424
"""Create a copy of this controldir prepared for use as a new line of
427
If url's last component does not exist, it will be created.
429
Attributes related to the identity of the source branch like
430
branch nickname will be cleaned, a working tree is created
431
whether one existed before or not; and a local branch is always
434
if revision_id is not None, then the clone operation may tune
435
itself to download less data.
437
:param accelerator_tree: A tree which can be used for retrieving file
438
contents more quickly than the revision tree, i.e. a workingtree.
439
The revision tree will be used for cases where accelerator_tree's
440
content is different.
441
:param hardlink: If true, hard-link files from accelerator_tree,
443
:param stacked: If true, create a stacked branch referring to the
444
location of this control directory.
445
:param create_tree_if_local: If true, a working-tree will be created
446
when working locally.
448
operation = cleanup.OperationWithCleanups(self._sprout)
449
return operation.run(url, revision_id=revision_id,
450
force_new_repo=force_new_repo, recurse=recurse,
451
possible_transports=possible_transports,
452
accelerator_tree=accelerator_tree, hardlink=hardlink,
453
stacked=stacked, source_branch=source_branch,
454
create_tree_if_local=create_tree_if_local)
456
def _sprout(self, op, url, revision_id=None, force_new_repo=False,
457
recurse='down', possible_transports=None,
458
accelerator_tree=None, hardlink=False, stacked=False,
459
source_branch=None, create_tree_if_local=True):
460
add_cleanup = op.add_cleanup
461
fetch_spec_factory = fetch.FetchSpecFactory()
462
if revision_id is not None:
463
fetch_spec_factory.add_revision_ids([revision_id])
464
fetch_spec_factory.source_branch_stop_revision_id = revision_id
465
target_transport = _mod_transport.get_transport(url,
467
target_transport.ensure_base()
468
cloning_format = self.cloning_metadir(stacked)
469
# Create/update the result branch
470
result = cloning_format.initialize_on_transport(target_transport)
471
source_branch, source_repository = self._find_source_repo(
472
add_cleanup, source_branch)
473
fetch_spec_factory.source_branch = source_branch
474
# if a stacked branch wasn't requested, we don't create one
475
# even if the origin was stacked
476
if stacked and source_branch is not None:
477
stacked_branch_url = self.root_transport.base
479
stacked_branch_url = None
480
repository_policy = result.determine_repository_policy(
481
force_new_repo, stacked_branch_url, require_stacking=stacked)
482
result_repo, is_new_repo = repository_policy.acquire_repository()
483
add_cleanup(result_repo.lock_write().unlock)
484
fetch_spec_factory.source_repo = source_repository
485
fetch_spec_factory.target_repo = result_repo
486
if stacked or (len(result_repo._fallback_repositories) != 0):
487
target_repo_kind = fetch.TargetRepoKinds.STACKED
489
target_repo_kind = fetch.TargetRepoKinds.EMPTY
491
target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
492
fetch_spec_factory.target_repo_kind = target_repo_kind
493
if source_repository is not None:
494
fetch_spec = fetch_spec_factory.make_fetch_spec()
495
result_repo.fetch(source_repository, fetch_spec=fetch_spec)
497
if source_branch is None:
498
# this is for sprouting a controldir without a branch; is that
500
# Not especially, but it's part of the contract.
501
result_branch = result.create_branch()
503
result_branch = source_branch.sprout(result,
504
revision_id=revision_id, repository_policy=repository_policy,
505
repository=result_repo)
506
mutter("created new branch %r" % (result_branch,))
508
# Create/update the result working tree
509
if (create_tree_if_local and
510
isinstance(target_transport, local.LocalTransport) and
511
(result_repo is None or result_repo.make_working_trees())):
512
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
513
hardlink=hardlink, from_branch=result_branch)
516
if wt.path2id('') is None:
518
wt.set_root_id(self.open_workingtree.get_root_id())
519
except errors.NoWorkingTree:
525
if recurse == 'down':
528
basis = wt.basis_tree()
529
elif result_branch is not None:
530
basis = result_branch.basis_tree()
531
elif source_branch is not None:
532
basis = source_branch.basis_tree()
533
if basis is not None:
534
add_cleanup(basis.lock_read().unlock)
535
subtrees = basis.iter_references()
538
for path, file_id in subtrees:
539
target = urlutils.join(url, urlutils.escape(path))
540
sublocation = source_branch.reference_parent(file_id, path)
541
sublocation.bzrdir.sprout(target,
542
basis.get_reference_revision(file_id, path),
543
force_new_repo=force_new_repo, recurse=recurse,
443
return policy.acquire_repository()
548
446
def create_branch_convenience(base, force_new_repo=False,
1009
1036
format, repository = self._cloning_metadir()
1010
1037
if format._workingtree_format is None:
1012
1038
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
1040
tree_format = repository._format._matchingbzrdir.workingtree_format
1018
1041
format.workingtree_format = tree_format.__class__()
1042
if (require_stacking and not
1043
format.get_branch_format().supports_stacking()):
1044
# We need to make a stacked branch, but the default format for the
1045
# target doesn't support stacking. So force a branch that *can*
1047
from bzrlib.branch import BzrBranchFormat7
1048
format._branch_format = BzrBranchFormat7()
1049
mutter("using %r for stacking" % (format._branch_format,))
1050
from bzrlib.repofmt import pack_repo
1051
if format.repository_format.rich_root_data:
1052
bzrdir_format_name = '1.6.1-rich-root'
1053
repo_format = pack_repo.RepositoryFormatKnitPack5RichRoot()
1055
bzrdir_format_name = '1.6'
1056
repo_format = pack_repo.RepositoryFormatKnitPack5()
1057
note('Source format does not support stacking, using format:'
1059
bzrdir_format_name, repo_format.get_format_description())
1060
format.repository_format = repo_format
1063
def checkout_metadir(self):
1064
return self.cloning_metadir()
1066
def sprout(self, url, revision_id=None, force_new_repo=False,
1067
recurse='down', possible_transports=None,
1068
accelerator_tree=None, hardlink=False, stacked=False):
1069
"""Create a copy of this bzrdir prepared for use as a new line of
1072
If url's last component does not exist, it will be created.
1074
Attributes related to the identity of the source branch like
1075
branch nickname will be cleaned, a working tree is created
1076
whether one existed before or not; and a local branch is always
1079
if revision_id is not None, then the clone operation may tune
1080
itself to download less data.
1081
:param accelerator_tree: A tree which can be used for retrieving file
1082
contents more quickly than the revision tree, i.e. a workingtree.
1083
The revision tree will be used for cases where accelerator_tree's
1084
content is different.
1085
:param hardlink: If true, hard-link files from accelerator_tree,
1087
:param stacked: If true, create a stacked branch referring to the
1088
location of this control directory.
1090
target_transport = get_transport(url, possible_transports)
1091
target_transport.ensure_base()
1092
cloning_format = self.cloning_metadir(stacked)
1093
# Create/update the result branch
1094
result = cloning_format.initialize_on_transport(target_transport)
1096
source_branch = self.open_branch()
1097
source_repository = source_branch.repository
1099
stacked_branch_url = self.root_transport.base
1101
# if a stacked branch wasn't requested, we don't create one
1102
# even if the origin was stacked
1103
stacked_branch_url = None
1104
except errors.NotBranchError:
1105
source_branch = None
1107
source_repository = self.open_repository()
1108
except errors.NoRepositoryPresent:
1109
source_repository = None
1110
stacked_branch_url = None
1111
repository_policy = result.determine_repository_policy(
1112
force_new_repo, stacked_branch_url, require_stacking=stacked)
1113
result_repo = repository_policy.acquire_repository()
1114
if source_repository is not None:
1115
# Fetch while stacked to prevent unstacked fetch from
1117
result_repo.fetch(source_repository, revision_id=revision_id)
1119
if source_branch is None:
1120
# this is for sprouting a bzrdir without a branch; is that
1122
# Not especially, but it's part of the contract.
1123
result_branch = result.create_branch()
1125
# Force NULL revision to avoid using repository before stacking
1127
result_branch = source_branch.sprout(
1128
result, revision_id=_mod_revision.NULL_REVISION)
1129
parent_location = result_branch.get_parent()
1130
mutter("created new branch %r" % (result_branch,))
1131
repository_policy.configure_branch(result_branch)
1132
if source_branch is not None:
1133
source_branch.copy_content_into(result_branch, revision_id)
1134
# Override copy_content_into
1135
result_branch.set_parent(parent_location)
1137
# Create/update the result working tree
1138
if isinstance(target_transport, LocalTransport) and (
1139
result_repo is None or result_repo.make_working_trees()):
1140
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
1144
if wt.path2id('') is None:
1146
wt.set_root_id(self.open_workingtree.get_root_id())
1147
except errors.NoWorkingTree:
1153
if recurse == 'down':
1155
basis = wt.basis_tree()
1157
subtrees = basis.iter_references()
1158
elif source_branch is not None:
1159
basis = source_branch.basis_tree()
1161
subtrees = basis.iter_references()
1166
for path, file_id in subtrees:
1167
target = urlutils.join(url, urlutils.escape(path))
1168
sublocation = source_branch.reference_parent(file_id, path)
1169
sublocation.bzrdir.sprout(target,
1170
basis.get_reference_revision(file_id, path),
1171
force_new_repo=force_new_repo, recurse=recurse,
1174
if basis is not None:
1179
class BzrDirPreSplitOut(BzrDir):
1180
"""A common class for the all-in-one formats."""
1182
def __init__(self, _transport, _format):
1183
"""See BzrDir.__init__."""
1184
super(BzrDirPreSplitOut, self).__init__(_transport, _format)
1185
self._control_files = lockable_files.LockableFiles(
1186
self.get_branch_transport(None),
1187
self._format._lock_file_name,
1188
self._format._lock_class)
1190
def break_lock(self):
1191
"""Pre-splitout bzrdirs do not suffer from stale locks."""
1192
raise NotImplementedError(self.break_lock)
1194
def cloning_metadir(self, require_stacking=False):
1195
"""Produce a metadir suitable for cloning with."""
1019
1196
if require_stacking:
1020
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.
1197
return format_registry.make_bzrdir('1.6')
1198
return self._format.__class__()
1200
def clone(self, url, revision_id=None, force_new_repo=False,
1201
preserve_stacking=False):
1202
"""See BzrDir.clone().
1204
force_new_repo has no effect, since this family of formats always
1205
require a new repository.
1206
preserve_stacking has no effect, since no source branch using this
1207
family of formats can be stacked, so there is no stacking to preserve.
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)
1209
self._make_tail(url)
1210
result = self._format._initialize_for_clone(url)
1211
self.open_repository().clone(result, revision_id=revision_id)
1212
from_branch = self.open_branch()
1213
from_branch.clone(result, revision_id=revision_id)
1215
tree = self.open_workingtree()
1216
except errors.NotLocalUrl:
1217
# make a new one, this format always has to have one.
1218
result._init_workingtree()
1223
def create_branch(self):
1224
"""See BzrDir.create_branch."""
1225
return self._format.get_branch_format().initialize(self)
1227
def destroy_branch(self):
1228
"""See BzrDir.destroy_branch."""
1229
raise errors.UnsupportedOperation(self.destroy_branch, self)
1231
def create_repository(self, shared=False):
1232
"""See BzrDir.create_repository."""
1234
raise errors.IncompatibleFormat('shared repository', self._format)
1235
return self.open_repository()
1237
def destroy_repository(self):
1238
"""See BzrDir.destroy_repository."""
1239
raise errors.UnsupportedOperation(self.destroy_repository, self)
1241
def create_workingtree(self, revision_id=None, from_branch=None,
1242
accelerator_tree=None, hardlink=False):
1243
"""See BzrDir.create_workingtree."""
1244
# The workingtree is sometimes created when the bzrdir is created,
1245
# but not when cloning.
1247
# this looks buggy but is not -really-
1248
# because this format creates the workingtree when the bzrdir is
1250
# clone and sprout will have set the revision_id
1251
# and that will have set it for us, its only
1252
# specific uses of create_workingtree in isolation
1253
# that can do wonky stuff here, and that only
1254
# happens for creating checkouts, which cannot be
1255
# done on this format anyway. So - acceptable wart.
1257
result = self.open_workingtree(recommend_upgrade=False)
1258
except errors.NoSuchFile:
1259
result = self._init_workingtree()
1260
if revision_id is not None:
1261
if revision_id == _mod_revision.NULL_REVISION:
1262
result.set_parent_ids([])
1264
result.set_parent_ids([revision_id])
1267
def _init_workingtree(self):
1268
from bzrlib.workingtree import WorkingTreeFormat2
1270
return WorkingTreeFormat2().initialize(self)
1271
except errors.NotLocalUrl:
1272
# Even though we can't access the working tree, we need to
1273
# create its control files.
1274
return WorkingTreeFormat2()._stub_initialize_on_transport(
1275
self.transport, self._control_files._file_mode)
1277
def destroy_workingtree(self):
1278
"""See BzrDir.destroy_workingtree."""
1279
raise errors.UnsupportedOperation(self.destroy_workingtree, self)
1281
def destroy_workingtree_metadata(self):
1282
"""See BzrDir.destroy_workingtree_metadata."""
1283
raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
1286
def get_branch_transport(self, branch_format):
1287
"""See BzrDir.get_branch_transport()."""
1288
if branch_format is None:
1289
return self.transport
1291
branch_format.get_format_string()
1292
except NotImplementedError:
1293
return self.transport
1294
raise errors.IncompatibleFormat(branch_format, self._format)
1296
def get_repository_transport(self, repository_format):
1297
"""See BzrDir.get_repository_transport()."""
1298
if repository_format is None:
1299
return self.transport
1301
repository_format.get_format_string()
1302
except NotImplementedError:
1303
return self.transport
1304
raise errors.IncompatibleFormat(repository_format, self._format)
1306
def get_workingtree_transport(self, workingtree_format):
1307
"""See BzrDir.get_workingtree_transport()."""
1308
if workingtree_format is None:
1309
return self.transport
1311
workingtree_format.get_format_string()
1312
except NotImplementedError:
1313
return self.transport
1314
raise errors.IncompatibleFormat(workingtree_format, self._format)
1316
def needs_format_conversion(self, format=None):
1317
"""See BzrDir.needs_format_conversion()."""
1318
# if the format is not the same as the system default,
1319
# an upgrade is needed.
1037
1320
if format is None:
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)
1081
class BzrDirHooks(hooks.Hooks):
1082
"""Hooks for BzrDir operations."""
1085
"""Create the default hooks."""
1086
hooks.Hooks.__init__(self, "bzrlib.bzrdir", "BzrDir.hooks")
1087
self.add_hook('pre_open',
1088
"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.",
1096
# install the default hooks
1097
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
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__,
1132
return "<%s for %s>" % (self.__class__.__name__,
1321
format = BzrDirFormat.get_default_format()
1322
return not isinstance(self._format, format.__class__)
1324
def open_branch(self, unsupported=False):
1325
"""See BzrDir.open_branch."""
1326
from bzrlib.branch import BzrBranchFormat4
1327
format = BzrBranchFormat4()
1328
self._check_supported(format, unsupported)
1329
return format.open(self, _found=True)
1331
def sprout(self, url, revision_id=None, force_new_repo=False,
1332
possible_transports=None, accelerator_tree=None,
1333
hardlink=False, stacked=False):
1334
"""See BzrDir.sprout()."""
1336
raise errors.UnstackableBranchFormat(
1337
self._format, self.root_transport.base)
1338
from bzrlib.workingtree import WorkingTreeFormat2
1339
self._make_tail(url)
1340
result = self._format._initialize_for_clone(url)
1342
self.open_repository().clone(result, revision_id=revision_id)
1343
except errors.NoRepositoryPresent:
1346
self.open_branch().sprout(result, revision_id=revision_id)
1347
except errors.NotBranchError:
1349
# we always want a working tree
1350
WorkingTreeFormat2().initialize(result,
1351
accelerator_tree=accelerator_tree,
1356
class BzrDir4(BzrDirPreSplitOut):
1357
"""A .bzr version 4 control object.
1359
This is a deprecated format and may be removed after sept 2006.
1362
def create_repository(self, shared=False):
1363
"""See BzrDir.create_repository."""
1364
return self._format.repository_format.initialize(self, shared)
1366
def needs_format_conversion(self, format=None):
1367
"""Format 4 dirs are always in need of conversion."""
1370
def open_repository(self):
1371
"""See BzrDir.open_repository."""
1372
from bzrlib.repofmt.weaverepo import RepositoryFormat4
1373
return RepositoryFormat4().open(self, _found=True)
1376
class BzrDir5(BzrDirPreSplitOut):
1377
"""A .bzr version 5 control object.
1379
This is a deprecated format and may be removed after sept 2006.
1382
def open_repository(self):
1383
"""See BzrDir.open_repository."""
1384
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1385
return RepositoryFormat5().open(self, _found=True)
1387
def open_workingtree(self, _unsupported=False,
1388
recommend_upgrade=True):
1389
"""See BzrDir.create_workingtree."""
1390
from bzrlib.workingtree import WorkingTreeFormat2
1391
wt_format = WorkingTreeFormat2()
1392
# we don't warn here about upgrades; that ought to be handled for the
1394
return wt_format.open(self, _found=True)
1397
class BzrDir6(BzrDirPreSplitOut):
1398
"""A .bzr version 6 control object.
1400
This is a deprecated format and may be removed after sept 2006.
1403
def open_repository(self):
1404
"""See BzrDir.open_repository."""
1405
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1406
return RepositoryFormat6().open(self, _found=True)
1408
def open_workingtree(self, _unsupported=False,
1409
recommend_upgrade=True):
1410
"""See BzrDir.create_workingtree."""
1411
# we don't warn here about upgrades; that ought to be handled for the
1413
from bzrlib.workingtree import WorkingTreeFormat2
1414
return WorkingTreeFormat2().open(self, _found=True)
1136
1417
class BzrDirMeta1(BzrDir):
1137
1418
"""A .bzr meta version 1 control object.
1139
This is the first control object where the
1420
This is the first control object where the
1140
1421
individual aspects are really split out: there are separate repository,
1141
1422
workingtree and branch subdirectories and any subset of the three can be
1142
1423
present within a BzrDir.
1315
1573
"""See BzrDir.open_workingtree."""
1316
1574
from bzrlib.workingtree import WorkingTreeFormat
1317
1575
format = WorkingTreeFormat.find_format(self)
1318
format.check_support_status(unsupported, recommend_upgrade,
1576
self._check_supported(format, unsupported,
1319
1578
basedir=self.root_transport.base)
1320
1579
return format.open(self, _found=True)
1322
1581
def _get_config(self):
1323
return config.TransportConfig(self.transport, 'control.conf')
1326
class BzrProber(controldir.Prober):
1327
"""Prober for formats that use a .bzr/ control directory."""
1329
formats = registry.FormatRegistry(controldir.network_format_registry)
1330
"""The known .bzr formats."""
1333
@deprecated_method(deprecated_in((2, 4, 0)))
1334
def register_bzrdir_format(klass, format):
1335
klass.formats.register(format.get_format_string(), format)
1338
@deprecated_method(deprecated_in((2, 4, 0)))
1339
def unregister_bzrdir_format(klass, format):
1340
klass.formats.remove(format.get_format_string())
1343
def probe_transport(klass, transport):
1344
"""Return the .bzrdir style format present in a directory."""
1346
format_string = transport.get_bytes(".bzr/branch-format")
1347
except errors.NoSuchFile:
1348
raise errors.NotBranchError(path=transport.base)
1350
return klass.formats.get(format_string)
1352
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1355
def known_formats(cls):
1357
for name, format in cls.formats.iteritems():
1358
if callable(format):
1364
controldir.ControlDirFormat.register_prober(BzrProber)
1367
class RemoteBzrProber(controldir.Prober):
1368
"""Prober for remote servers that provide a Bazaar smart server."""
1371
def probe_transport(klass, transport):
1372
"""Return a RemoteBzrDirFormat object if it looks possible."""
1374
medium = transport.get_smart_medium()
1375
except (NotImplementedError, AttributeError,
1376
errors.TransportNotPossible, errors.NoSmartMedium,
1377
errors.SmartProtocolError):
1378
# no smart server, so not a branch for this format type.
1379
raise errors.NotBranchError(path=transport.base)
1381
# Decline to open it if the server doesn't support our required
1382
# version (3) so that the VFS-based transport will do it.
1383
if medium.should_probe():
1385
server_version = medium.protocol_version()
1386
except errors.SmartProtocolError:
1387
# Apparently there's no usable smart server there, even though
1388
# the medium supports the smart protocol.
1389
raise errors.NotBranchError(path=transport.base)
1390
if server_version != '2':
1391
raise errors.NotBranchError(path=transport.base)
1392
from bzrlib.remote import RemoteBzrDirFormat
1393
return RemoteBzrDirFormat()
1396
def known_formats(cls):
1397
from bzrlib.remote import RemoteBzrDirFormat
1398
return set([RemoteBzrDirFormat()])
1401
class BzrDirFormat(controldir.ControlDirFormat):
1402
"""ControlDirFormat base class for .bzr/ directories.
1404
Formats are placed in a dict by their format string for reference
1582
return config.BzrDirConfig(self.transport)
1585
class BzrDirFormat(object):
1586
"""An encapsulation of the initialization and open routines for a format.
1588
Formats provide three things:
1589
* An initialization routine,
1593
Formats are placed in a dict by their format string for reference
1405
1594
during bzrdir opening. These should be subclasses of BzrDirFormat
1406
1595
for consistency.
1408
1597
Once a format is deprecated, just deprecate the initialize and open
1409
methods on the format class. Do not deprecate the object, as the
1598
methods on the format class. Do not deprecate the object, as the
1410
1599
object will be created every system load.
1602
_default_format = None
1603
"""The default format used for new .bzr dirs."""
1606
"""The known formats."""
1608
_control_formats = []
1609
"""The registered control formats - .bzr, ....
1611
This is a list of BzrDirFormat objects.
1614
_control_server_formats = []
1615
"""The registered control server formats, e.g. RemoteBzrDirs.
1617
This is a list of BzrDirFormat objects.
1413
1620
_lock_file_name = 'branch-lock'
1415
1622
# _lock_class must be set in subclasses to the lock type, typ.
1416
1623
# TransportLock or LockDir
1419
def get_format_string(cls):
1626
def find_format(klass, transport, _server_formats=True):
1627
"""Return the format present at transport."""
1629
formats = klass._control_server_formats + klass._control_formats
1631
formats = klass._control_formats
1632
for format in formats:
1634
return format.probe_transport(transport)
1635
except errors.NotBranchError:
1636
# this format does not find a control dir here.
1638
raise errors.NotBranchError(path=transport.base)
1641
def probe_transport(klass, transport):
1642
"""Return the .bzrdir style format present in a directory."""
1644
format_string = transport.get(".bzr/branch-format").read()
1645
except errors.NoSuchFile:
1646
raise errors.NotBranchError(path=transport.base)
1649
return klass._formats[format_string]
1651
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1654
def get_default_format(klass):
1655
"""Return the current default format."""
1656
return klass._default_format
1658
def get_format_string(self):
1420
1659
"""Return the ASCII format string that identifies this format."""
1421
raise NotImplementedError(cls.get_format_string)
1660
raise NotImplementedError(self.get_format_string)
1662
def get_format_description(self):
1663
"""Return the short description for this format."""
1664
raise NotImplementedError(self.get_format_description)
1666
def get_converter(self, format=None):
1667
"""Return the converter to use to convert bzrdirs needing converts.
1669
This returns a bzrlib.bzrdir.Converter object.
1671
This should return the best upgrader to step this format towards the
1672
current default format. In the case of plugins we can/should provide
1673
some means for them to extend the range of returnable converters.
1675
:param format: Optional format to override the default format of the
1678
raise NotImplementedError(self.get_converter)
1680
def initialize(self, url, possible_transports=None):
1681
"""Create a bzr control dir at this url and return an opened copy.
1683
Subclasses should typically override initialize_on_transport
1684
instead of this method.
1686
return self.initialize_on_transport(get_transport(url,
1687
possible_transports))
1423
1689
def initialize_on_transport(self, transport):
1424
1690
"""Initialize a new bzrdir in the base directory of a Transport."""
1426
# can we hand off the request to the smart server rather than using
1428
client_medium = transport.get_smart_medium()
1429
except errors.NoSmartMedium:
1430
return self._initialize_on_transport_vfs(transport)
1432
# Current RPC's only know how to create bzr metadir1 instances, so
1433
# we still delegate to vfs methods if the requested format is not a
1435
if type(self) != BzrDirMetaFormat1:
1436
return self._initialize_on_transport_vfs(transport)
1437
from bzrlib.remote import RemoteBzrDirFormat
1438
remote_format = RemoteBzrDirFormat()
1439
self._supply_sub_formats_to(remote_format)
1440
return remote_format.initialize_on_transport(transport)
1442
def initialize_on_transport_ex(self, transport, use_existing_dir=False,
1443
create_prefix=False, force_new_repo=False, stacked_on=None,
1444
stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
1445
shared_repo=False, vfs_only=False):
1446
"""Create this format on transport.
1448
The directory to initialize will be created.
1450
:param force_new_repo: Do not use a shared repository for the target,
1451
even if one is available.
1452
:param create_prefix: Create any missing directories leading up to
1454
:param use_existing_dir: Use an existing directory if one exists.
1455
:param stacked_on: A url to stack any created branch on, None to follow
1456
any target stacking policy.
1457
:param stack_on_pwd: If stack_on is relative, the location it is
1459
:param repo_format_name: If non-None, a repository will be
1460
made-or-found. Should none be found, or if force_new_repo is True
1461
the repo_format_name is used to select the format of repository to
1463
:param make_working_trees: Control the setting of make_working_trees
1464
for a new shared repository when one is made. None to use whatever
1465
default the format has.
1466
:param shared_repo: Control whether made repositories are shared or
1468
:param vfs_only: If True do not attempt to use a smart server
1469
:return: repo, bzrdir, require_stacking, repository_policy. repo is
1470
None if none was created or found, bzrdir is always valid.
1471
require_stacking is the result of examining the stacked_on
1472
parameter and any stacking policy found for the target.
1475
# Try to hand off to a smart server
1477
client_medium = transport.get_smart_medium()
1478
except errors.NoSmartMedium:
1481
from bzrlib.remote import RemoteBzrDirFormat
1482
# TODO: lookup the local format from a server hint.
1483
remote_dir_format = RemoteBzrDirFormat()
1484
remote_dir_format._network_name = self.network_name()
1485
self._supply_sub_formats_to(remote_dir_format)
1486
return remote_dir_format.initialize_on_transport_ex(transport,
1487
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
1488
force_new_repo=force_new_repo, stacked_on=stacked_on,
1489
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
1490
make_working_trees=make_working_trees, shared_repo=shared_repo)
1491
# XXX: Refactor the create_prefix/no_create_prefix code into a
1492
# common helper function
1493
# The destination may not exist - if so make it according to policy.
1494
def make_directory(transport):
1495
transport.mkdir('.')
1497
def redirected(transport, e, redirection_notice):
1498
note(redirection_notice)
1499
return transport._redirected_to(e.source, e.target)
1501
transport = do_catching_redirections(make_directory, transport,
1503
except errors.FileExists:
1504
if not use_existing_dir:
1506
except errors.NoSuchFile:
1507
if not create_prefix:
1509
transport.create_prefix()
1511
require_stacking = (stacked_on is not None)
1512
# Now the target directory exists, but doesn't have a .bzr
1513
# directory. So we need to create it, along with any work to create
1514
# all of the dependent branches, etc.
1516
result = self.initialize_on_transport(transport)
1517
if repo_format_name:
1519
# use a custom format
1520
result._format.repository_format = \
1521
repository.network_format_registry.get(repo_format_name)
1522
except AttributeError:
1523
# The format didn't permit it to be set.
1525
# A repository is desired, either in-place or shared.
1526
repository_policy = result.determine_repository_policy(
1527
force_new_repo, stacked_on, stack_on_pwd,
1528
require_stacking=require_stacking)
1529
result_repo, is_new_repo = repository_policy.acquire_repository(
1530
make_working_trees, shared_repo)
1531
if not require_stacking and repository_policy._require_stacking:
1532
require_stacking = True
1533
result._format.require_stacking()
1534
result_repo.lock_write()
1537
repository_policy = None
1538
return result_repo, result, require_stacking, repository_policy
1540
def _initialize_on_transport_vfs(self, transport):
1541
"""Initialize a new bzrdir using VFS calls.
1543
:param transport: The transport to create the .bzr directory in.
1546
# Since we are creating a .bzr directory, inherit the
1691
# Since we don't have a .bzr directory, inherit the
1547
1692
# mode from the root directory
1548
1693
temp_control = lockable_files.LockableFiles(transport,
1549
1694
'', lockable_files.TransportLock)
1600
1774
raise NotImplementedError(self._open)
1602
def _supply_sub_formats_to(self, other_format):
1603
"""Give other_format the same values for sub formats as this has.
1605
This method is expected to be used when parameterising a
1606
RemoteBzrDirFormat instance with the parameters from a
1607
BzrDirMetaFormat1 instance.
1609
:param other_format: other_format is a format which should be
1610
compatible with whatever sub formats are supported by self.
1777
def register_format(klass, format):
1778
klass._formats[format.get_format_string()] = format
1781
def register_control_format(klass, format):
1782
"""Register a format that does not use '.bzr' for its control dir.
1784
TODO: This should be pulled up into a 'ControlDirFormat' base class
1785
which BzrDirFormat can inherit from, and renamed to register_format
1786
there. It has been done without that for now for simplicity of
1789
klass._control_formats.append(format)
1792
def register_control_server_format(klass, format):
1793
"""Register a control format for client-server environments.
1795
These formats will be tried before ones registered with
1796
register_control_format. This gives implementations that decide to the
1797
chance to grab it before anything looks at the contents of the format
1800
klass._control_server_formats.append(format)
1803
def _set_default_format(klass, format):
1804
"""Set default format (for testing behavior of defaults only)"""
1805
klass._default_format = format
1809
return self.get_format_string().rstrip()
1812
def unregister_format(klass, format):
1813
del klass._formats[format.get_format_string()]
1816
def unregister_control_format(klass, format):
1817
klass._control_formats.remove(format)
1820
class BzrDirFormat4(BzrDirFormat):
1821
"""Bzr dir format 4.
1823
This format is a combined format for working tree, branch and repository.
1825
- Format 1 working trees [always]
1826
- Format 4 branches [always]
1827
- Format 4 repositories [always]
1829
This format is deprecated: it indexes texts using a text it which is
1830
removed in format 5; write support for this format has been removed.
1833
_lock_class = lockable_files.TransportLock
1835
def get_format_string(self):
1836
"""See BzrDirFormat.get_format_string()."""
1837
return "Bazaar-NG branch, format 0.0.4\n"
1839
def get_format_description(self):
1840
"""See BzrDirFormat.get_format_description()."""
1841
return "All-in-one format 4"
1843
def get_converter(self, format=None):
1844
"""See BzrDirFormat.get_converter()."""
1845
# there is one and only one upgrade path here.
1846
return ConvertBzrDir4To5()
1848
def initialize_on_transport(self, transport):
1849
"""Format 4 branches cannot be created."""
1850
raise errors.UninitializableFormat(self)
1852
def is_supported(self):
1853
"""Format 4 is not supported.
1855
It is not supported because the model changed from 4 to 5 and the
1856
conversion logic is expensive - so doing it on the fly was not
1861
def _open(self, transport):
1862
"""See BzrDirFormat._open."""
1863
return BzrDir4(transport, self)
1865
def __return_repository_format(self):
1866
"""Circular import protection."""
1867
from bzrlib.repofmt.weaverepo import RepositoryFormat4
1868
return RepositoryFormat4()
1869
repository_format = property(__return_repository_format)
1872
class BzrDirFormat5(BzrDirFormat):
1873
"""Bzr control format 5.
1875
This format is a combined format for working tree, branch and repository.
1877
- Format 2 working trees [always]
1878
- Format 4 branches [always]
1879
- Format 5 repositories [always]
1880
Unhashed stores in the repository.
1883
_lock_class = lockable_files.TransportLock
1885
def get_format_string(self):
1886
"""See BzrDirFormat.get_format_string()."""
1887
return "Bazaar-NG branch, format 5\n"
1889
def get_branch_format(self):
1890
from bzrlib import branch
1891
return branch.BzrBranchFormat4()
1893
def get_format_description(self):
1894
"""See BzrDirFormat.get_format_description()."""
1895
return "All-in-one format 5"
1897
def get_converter(self, format=None):
1898
"""See BzrDirFormat.get_converter()."""
1899
# there is one and only one upgrade path here.
1900
return ConvertBzrDir5To6()
1902
def _initialize_for_clone(self, url):
1903
return self.initialize_on_transport(get_transport(url), _cloning=True)
1905
def initialize_on_transport(self, transport, _cloning=False):
1906
"""Format 5 dirs always have working tree, branch and repository.
1908
Except when they are being cloned.
1910
from bzrlib.branch import BzrBranchFormat4
1911
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1912
result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
1913
RepositoryFormat5().initialize(result, _internal=True)
1915
branch = BzrBranchFormat4().initialize(result)
1916
result._init_workingtree()
1919
def _open(self, transport):
1920
"""See BzrDirFormat._open."""
1921
return BzrDir5(transport, self)
1923
def __return_repository_format(self):
1924
"""Circular import protection."""
1925
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1926
return RepositoryFormat5()
1927
repository_format = property(__return_repository_format)
1930
class BzrDirFormat6(BzrDirFormat):
1931
"""Bzr control format 6.
1933
This format is a combined format for working tree, branch and repository.
1935
- Format 2 working trees [always]
1936
- Format 4 branches [always]
1937
- Format 6 repositories [always]
1940
_lock_class = lockable_files.TransportLock
1942
def get_format_string(self):
1943
"""See BzrDirFormat.get_format_string()."""
1944
return "Bazaar-NG branch, format 6\n"
1946
def get_format_description(self):
1947
"""See BzrDirFormat.get_format_description()."""
1948
return "All-in-one format 6"
1950
def get_branch_format(self):
1951
from bzrlib import branch
1952
return branch.BzrBranchFormat4()
1954
def get_converter(self, format=None):
1955
"""See BzrDirFormat.get_converter()."""
1956
# there is one and only one upgrade path here.
1957
return ConvertBzrDir6ToMeta()
1959
def _initialize_for_clone(self, url):
1960
return self.initialize_on_transport(get_transport(url), _cloning=True)
1962
def initialize_on_transport(self, transport, _cloning=False):
1963
"""Format 6 dirs always have working tree, branch and repository.
1965
Except when they are being cloned.
1967
from bzrlib.branch import BzrBranchFormat4
1968
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1969
result = super(BzrDirFormat6, self).initialize_on_transport(transport)
1970
RepositoryFormat6().initialize(result, _internal=True)
1972
branch = BzrBranchFormat4().initialize(result)
1973
result._init_workingtree()
1976
def _open(self, transport):
1977
"""See BzrDirFormat._open."""
1978
return BzrDir6(transport, self)
1980
def __return_repository_format(self):
1981
"""Circular import protection."""
1982
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1983
return RepositoryFormat6()
1984
repository_format = property(__return_repository_format)
1615
1987
class BzrDirMetaFormat1(BzrDirFormat):
1649
2016
def get_branch_format(self):
1650
2017
if self._branch_format is None:
1651
from bzrlib.branch import format_registry as branch_format_registry
1652
self._branch_format = branch_format_registry.get_default()
2018
from bzrlib.branch import BranchFormat
2019
self._branch_format = BranchFormat.get_default_format()
1653
2020
return self._branch_format
1655
2022
def set_branch_format(self, format):
1656
2023
self._branch_format = format
1658
def require_stacking(self, stack_on=None, possible_transports=None,
1660
"""We have a request to stack, try to ensure the formats support it.
1662
:param stack_on: If supplied, it is the URL to a branch that we want to
1663
stack on. Check to see if that format supports stacking before
1666
# Stacking is desired. requested by the target, but does the place it
1667
# points at support stacking? If it doesn't then we should
1668
# not implicitly upgrade. We check this here.
1669
new_repo_format = None
1670
new_branch_format = None
1672
# a bit of state for get_target_branch so that we don't try to open it
1673
# 2 times, for both repo *and* branch
1674
target = [None, False, None] # target_branch, checked, upgrade anyway
1675
def get_target_branch():
1677
# We've checked, don't check again
1679
if stack_on is None:
1680
# No target format, that means we want to force upgrading
1681
target[:] = [None, True, True]
1684
target_dir = BzrDir.open(stack_on,
1685
possible_transports=possible_transports)
1686
except errors.NotBranchError:
1687
# Nothing there, don't change formats
1688
target[:] = [None, True, False]
1690
except errors.JailBreak:
1691
# JailBreak, JFDI and upgrade anyway
1692
target[:] = [None, True, True]
1695
target_branch = target_dir.open_branch()
1696
except errors.NotBranchError:
1697
# No branch, don't upgrade formats
1698
target[:] = [None, True, False]
1700
target[:] = [target_branch, True, False]
1703
if (not _skip_repo and
1704
not self.repository_format.supports_external_lookups):
1705
# We need to upgrade the Repository.
1706
target_branch, _, do_upgrade = get_target_branch()
1707
if target_branch is None:
1708
# We don't have a target branch, should we upgrade anyway?
1710
# stack_on is inaccessible, JFDI.
1711
# TODO: bad monkey, hard-coded formats...
1712
if self.repository_format.rich_root_data:
1713
new_repo_format = knitpack_repo.RepositoryFormatKnitPack5RichRoot()
1715
new_repo_format = knitpack_repo.RepositoryFormatKnitPack5()
1717
# If the target already supports stacking, then we know the
1718
# project is already able to use stacking, so auto-upgrade
1720
new_repo_format = target_branch.repository._format
1721
if not new_repo_format.supports_external_lookups:
1722
# target doesn't, source doesn't, so don't auto upgrade
1724
new_repo_format = None
1725
if new_repo_format is not None:
1726
self.repository_format = new_repo_format
1727
note(gettext('Source repository format does not support stacking,'
1728
' using format:\n %s'),
1729
new_repo_format.get_format_description())
1731
if not self.get_branch_format().supports_stacking():
1732
# We just checked the repo, now lets check if we need to
1733
# upgrade the branch format
1734
target_branch, _, do_upgrade = get_target_branch()
1735
if target_branch is None:
1737
# TODO: bad monkey, hard-coded formats...
1738
from bzrlib.branch import BzrBranchFormat7
1739
new_branch_format = BzrBranchFormat7()
1741
new_branch_format = target_branch._format
1742
if not new_branch_format.supports_stacking():
1743
new_branch_format = None
1744
if new_branch_format is not None:
1745
# Does support stacking, use its format.
1746
self.set_branch_format(new_branch_format)
1747
note(gettext('Source branch format does not support stacking,'
1748
' using format:\n %s'),
1749
new_branch_format.get_format_description())
1751
2025
def get_converter(self, format=None):
1752
2026
"""See BzrDirFormat.get_converter()."""
1753
2027
if format is None:
1825
2069
__set_workingtree_format)
2072
# Register bzr control format
2073
BzrDirFormat.register_control_format(BzrDirFormat)
1828
2075
# Register bzr formats
1829
BzrProber.formats.register(BzrDirMetaFormat1.get_format_string(),
1831
controldir.ControlDirFormat._default_format = BzrDirMetaFormat1()
1834
class ConvertMetaToMeta(controldir.Converter):
2076
BzrDirFormat.register_format(BzrDirFormat4())
2077
BzrDirFormat.register_format(BzrDirFormat5())
2078
BzrDirFormat.register_format(BzrDirFormat6())
2079
__default_format = BzrDirMetaFormat1()
2080
BzrDirFormat.register_format(__default_format)
2081
BzrDirFormat._default_format = __default_format
2084
class Converter(object):
2085
"""Converts a disk format object from one format to another."""
2087
def convert(self, to_convert, pb):
2088
"""Perform the conversion of to_convert, giving feedback via pb.
2090
:param to_convert: The disk object to convert.
2091
:param pb: a progress bar to use for progress information.
2094
def step(self, message):
2095
"""Update the pb by a step."""
2097
self.pb.update(message, self.count, self.total)
2100
class ConvertBzrDir4To5(Converter):
2101
"""Converts format 4 bzr dirs to format 5."""
2104
super(ConvertBzrDir4To5, self).__init__()
2105
self.converted_revs = set()
2106
self.absent_revisions = set()
2110
def convert(self, to_convert, pb):
2111
"""See Converter.convert()."""
2112
self.bzrdir = to_convert
2114
self.pb.note('starting upgrade from format 4 to 5')
2115
if isinstance(self.bzrdir.transport, LocalTransport):
2116
self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
2117
self._convert_to_weaves()
2118
return BzrDir.open(self.bzrdir.root_transport.base)
2120
def _convert_to_weaves(self):
2121
self.pb.note('note: upgrade may be faster if all store files are ungzipped first')
2124
stat = self.bzrdir.transport.stat('weaves')
2125
if not S_ISDIR(stat.st_mode):
2126
self.bzrdir.transport.delete('weaves')
2127
self.bzrdir.transport.mkdir('weaves')
2128
except errors.NoSuchFile:
2129
self.bzrdir.transport.mkdir('weaves')
2130
# deliberately not a WeaveFile as we want to build it up slowly.
2131
self.inv_weave = Weave('inventory')
2132
# holds in-memory weaves for all files
2133
self.text_weaves = {}
2134
self.bzrdir.transport.delete('branch-format')
2135
self.branch = self.bzrdir.open_branch()
2136
self._convert_working_inv()
2137
rev_history = self.branch.revision_history()
2138
# to_read is a stack holding the revisions we still need to process;
2139
# appending to it adds new highest-priority revisions
2140
self.known_revisions = set(rev_history)
2141
self.to_read = rev_history[-1:]
2143
rev_id = self.to_read.pop()
2144
if (rev_id not in self.revisions
2145
and rev_id not in self.absent_revisions):
2146
self._load_one_rev(rev_id)
2148
to_import = self._make_order()
2149
for i, rev_id in enumerate(to_import):
2150
self.pb.update('converting revision', i, len(to_import))
2151
self._convert_one_rev(rev_id)
2153
self._write_all_weaves()
2154
self._write_all_revs()
2155
self.pb.note('upgraded to weaves:')
2156
self.pb.note(' %6d revisions and inventories', len(self.revisions))
2157
self.pb.note(' %6d revisions not present', len(self.absent_revisions))
2158
self.pb.note(' %6d texts', self.text_count)
2159
self._cleanup_spare_files_after_format4()
2160
self.branch._transport.put_bytes(
2162
BzrDirFormat5().get_format_string(),
2163
mode=self.bzrdir._get_file_mode())
2165
def _cleanup_spare_files_after_format4(self):
2166
# FIXME working tree upgrade foo.
2167
for n in 'merged-patches', 'pending-merged-patches':
2169
## assert os.path.getsize(p) == 0
2170
self.bzrdir.transport.delete(n)
2171
except errors.NoSuchFile:
2173
self.bzrdir.transport.delete_tree('inventory-store')
2174
self.bzrdir.transport.delete_tree('text-store')
2176
def _convert_working_inv(self):
2177
inv = xml4.serializer_v4.read_inventory(
2178
self.branch._transport.get('inventory'))
2179
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv, working=True)
2180
self.branch._transport.put_bytes('inventory', new_inv_xml,
2181
mode=self.bzrdir._get_file_mode())
2183
def _write_all_weaves(self):
2184
controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
2185
weave_transport = self.bzrdir.transport.clone('weaves')
2186
weaves = WeaveStore(weave_transport, prefixed=False)
2187
transaction = WriteTransaction()
2191
for file_id, file_weave in self.text_weaves.items():
2192
self.pb.update('writing weave', i, len(self.text_weaves))
2193
weaves._put_weave(file_id, file_weave, transaction)
2195
self.pb.update('inventory', 0, 1)
2196
controlweaves._put_weave('inventory', self.inv_weave, transaction)
2197
self.pb.update('inventory', 1, 1)
2201
def _write_all_revs(self):
2202
"""Write all revisions out in new form."""
2203
self.bzrdir.transport.delete_tree('revision-store')
2204
self.bzrdir.transport.mkdir('revision-store')
2205
revision_transport = self.bzrdir.transport.clone('revision-store')
2207
from bzrlib.xml5 import serializer_v5
2208
from bzrlib.repofmt.weaverepo import RevisionTextStore
2209
revision_store = RevisionTextStore(revision_transport,
2210
serializer_v5, False, versionedfile.PrefixMapper(),
2211
lambda:True, lambda:True)
2213
for i, rev_id in enumerate(self.converted_revs):
2214
self.pb.update('write revision', i, len(self.converted_revs))
2215
text = serializer_v5.write_revision_to_string(
2216
self.revisions[rev_id])
2218
revision_store.add_lines(key, None, osutils.split_lines(text))
2222
def _load_one_rev(self, rev_id):
2223
"""Load a revision object into memory.
2225
Any parents not either loaded or abandoned get queued to be
2227
self.pb.update('loading revision',
2228
len(self.revisions),
2229
len(self.known_revisions))
2230
if not self.branch.repository.has_revision(rev_id):
2232
self.pb.note('revision {%s} not present in branch; '
2233
'will be converted as a ghost',
2235
self.absent_revisions.add(rev_id)
2237
rev = self.branch.repository.get_revision(rev_id)
2238
for parent_id in rev.parent_ids:
2239
self.known_revisions.add(parent_id)
2240
self.to_read.append(parent_id)
2241
self.revisions[rev_id] = rev
2243
def _load_old_inventory(self, rev_id):
2244
old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
2245
inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
2246
inv.revision_id = rev_id
2247
rev = self.revisions[rev_id]
2250
def _load_updated_inventory(self, rev_id):
2251
inv_xml = self.inv_weave.get_text(rev_id)
2252
inv = xml5.serializer_v5.read_inventory_from_string(inv_xml, rev_id)
2255
def _convert_one_rev(self, rev_id):
2256
"""Convert revision and all referenced objects to new format."""
2257
rev = self.revisions[rev_id]
2258
inv = self._load_old_inventory(rev_id)
2259
present_parents = [p for p in rev.parent_ids
2260
if p not in self.absent_revisions]
2261
self._convert_revision_contents(rev, inv, present_parents)
2262
self._store_new_inv(rev, inv, present_parents)
2263
self.converted_revs.add(rev_id)
2265
def _store_new_inv(self, rev, inv, present_parents):
2266
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
2267
new_inv_sha1 = sha_string(new_inv_xml)
2268
self.inv_weave.add_lines(rev.revision_id,
2270
new_inv_xml.splitlines(True))
2271
rev.inventory_sha1 = new_inv_sha1
2273
def _convert_revision_contents(self, rev, inv, present_parents):
2274
"""Convert all the files within a revision.
2276
Also upgrade the inventory to refer to the text revision ids."""
2277
rev_id = rev.revision_id
2278
mutter('converting texts of revision {%s}',
2280
parent_invs = map(self._load_updated_inventory, present_parents)
2281
entries = inv.iter_entries()
2283
for path, ie in entries:
2284
self._convert_file_version(rev, ie, parent_invs)
2286
def _convert_file_version(self, rev, ie, parent_invs):
2287
"""Convert one version of one file.
2289
The file needs to be added into the weave if it is a merge
2290
of >=2 parents or if it's changed from its parent.
2292
file_id = ie.file_id
2293
rev_id = rev.revision_id
2294
w = self.text_weaves.get(file_id)
2297
self.text_weaves[file_id] = w
2298
text_changed = False
2299
parent_candiate_entries = ie.parent_candidates(parent_invs)
2300
heads = graph.Graph(self).heads(parent_candiate_entries.keys())
2301
# XXX: Note that this is unordered - and this is tolerable because
2302
# the previous code was also unordered.
2303
previous_entries = dict((head, parent_candiate_entries[head]) for head
2305
self.snapshot_ie(previous_entries, ie, w, rev_id)
2308
@symbol_versioning.deprecated_method(symbol_versioning.one_one)
2309
def get_parents(self, revision_ids):
2310
for revision_id in revision_ids:
2311
yield self.revisions[revision_id].parent_ids
2313
def get_parent_map(self, revision_ids):
2314
"""See graph._StackedParentsProvider.get_parent_map"""
2315
return dict((revision_id, self.revisions[revision_id])
2316
for revision_id in revision_ids
2317
if revision_id in self.revisions)
2319
def snapshot_ie(self, previous_revisions, ie, w, rev_id):
2320
# TODO: convert this logic, which is ~= snapshot to
2321
# a call to:. This needs the path figured out. rather than a work_tree
2322
# a v4 revision_tree can be given, or something that looks enough like
2323
# one to give the file content to the entry if it needs it.
2324
# and we need something that looks like a weave store for snapshot to
2326
#ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
2327
if len(previous_revisions) == 1:
2328
previous_ie = previous_revisions.values()[0]
2329
if ie._unchanged(previous_ie):
2330
ie.revision = previous_ie.revision
2333
text = self.branch.repository._text_store.get(ie.text_id)
2334
file_lines = text.readlines()
2335
w.add_lines(rev_id, previous_revisions, file_lines)
2336
self.text_count += 1
2338
w.add_lines(rev_id, previous_revisions, [])
2339
ie.revision = rev_id
2341
def _make_order(self):
2342
"""Return a suitable order for importing revisions.
2344
The order must be such that an revision is imported after all
2345
its (present) parents.
2347
todo = set(self.revisions.keys())
2348
done = self.absent_revisions.copy()
2351
# scan through looking for a revision whose parents
2353
for rev_id in sorted(list(todo)):
2354
rev = self.revisions[rev_id]
2355
parent_ids = set(rev.parent_ids)
2356
if parent_ids.issubset(done):
2357
# can take this one now
2358
order.append(rev_id)
2364
class ConvertBzrDir5To6(Converter):
2365
"""Converts format 5 bzr dirs to format 6."""
2367
def convert(self, to_convert, pb):
2368
"""See Converter.convert()."""
2369
self.bzrdir = to_convert
2371
self.pb.note('starting upgrade from format 5 to 6')
2372
self._convert_to_prefixed()
2373
return BzrDir.open(self.bzrdir.root_transport.base)
2375
def _convert_to_prefixed(self):
2376
from bzrlib.store import TransportStore
2377
self.bzrdir.transport.delete('branch-format')
2378
for store_name in ["weaves", "revision-store"]:
2379
self.pb.note("adding prefixes to %s" % store_name)
2380
store_transport = self.bzrdir.transport.clone(store_name)
2381
store = TransportStore(store_transport, prefixed=True)
2382
for urlfilename in store_transport.list_dir('.'):
2383
filename = urlutils.unescape(urlfilename)
2384
if (filename.endswith(".weave") or
2385
filename.endswith(".gz") or
2386
filename.endswith(".sig")):
2387
file_id, suffix = os.path.splitext(filename)
2391
new_name = store._mapper.map((file_id,)) + suffix
2392
# FIXME keep track of the dirs made RBC 20060121
2394
store_transport.move(filename, new_name)
2395
except errors.NoSuchFile: # catches missing dirs strangely enough
2396
store_transport.mkdir(osutils.dirname(new_name))
2397
store_transport.move(filename, new_name)
2398
self.bzrdir.transport.put_bytes(
2400
BzrDirFormat6().get_format_string(),
2401
mode=self.bzrdir._get_file_mode())
2404
class ConvertBzrDir6ToMeta(Converter):
2405
"""Converts format 6 bzr dirs to metadirs."""
2407
def convert(self, to_convert, pb):
2408
"""See Converter.convert()."""
2409
from bzrlib.repofmt.weaverepo import RepositoryFormat7
2410
from bzrlib.branch import BzrBranchFormat5
2411
self.bzrdir = to_convert
2414
self.total = 20 # the steps we know about
2415
self.garbage_inventories = []
2416
self.dir_mode = self.bzrdir._get_dir_mode()
2417
self.file_mode = self.bzrdir._get_file_mode()
2419
self.pb.note('starting upgrade from format 6 to metadir')
2420
self.bzrdir.transport.put_bytes(
2422
"Converting to format 6",
2423
mode=self.file_mode)
2424
# its faster to move specific files around than to open and use the apis...
2425
# first off, nuke ancestry.weave, it was never used.
2427
self.step('Removing ancestry.weave')
2428
self.bzrdir.transport.delete('ancestry.weave')
2429
except errors.NoSuchFile:
2431
# find out whats there
2432
self.step('Finding branch files')
2433
last_revision = self.bzrdir.open_branch().last_revision()
2434
bzrcontents = self.bzrdir.transport.list_dir('.')
2435
for name in bzrcontents:
2436
if name.startswith('basis-inventory.'):
2437
self.garbage_inventories.append(name)
2438
# create new directories for repository, working tree and branch
2439
repository_names = [('inventory.weave', True),
2440
('revision-store', True),
2442
self.step('Upgrading repository ')
2443
self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
2444
self.make_lock('repository')
2445
# we hard code the formats here because we are converting into
2446
# the meta format. The meta format upgrader can take this to a
2447
# future format within each component.
2448
self.put_format('repository', RepositoryFormat7())
2449
for entry in repository_names:
2450
self.move_entry('repository', entry)
2452
self.step('Upgrading branch ')
2453
self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
2454
self.make_lock('branch')
2455
self.put_format('branch', BzrBranchFormat5())
2456
branch_files = [('revision-history', True),
2457
('branch-name', True),
2459
for entry in branch_files:
2460
self.move_entry('branch', entry)
2462
checkout_files = [('pending-merges', True),
2463
('inventory', True),
2464
('stat-cache', False)]
2465
# If a mandatory checkout file is not present, the branch does not have
2466
# a functional checkout. Do not create a checkout in the converted
2468
for name, mandatory in checkout_files:
2469
if mandatory and name not in bzrcontents:
2470
has_checkout = False
2474
if not has_checkout:
2475
self.pb.note('No working tree.')
2476
# If some checkout files are there, we may as well get rid of them.
2477
for name, mandatory in checkout_files:
2478
if name in bzrcontents:
2479
self.bzrdir.transport.delete(name)
2481
from bzrlib.workingtree import WorkingTreeFormat3
2482
self.step('Upgrading working tree')
2483
self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
2484
self.make_lock('checkout')
2486
'checkout', WorkingTreeFormat3())
2487
self.bzrdir.transport.delete_multi(
2488
self.garbage_inventories, self.pb)
2489
for entry in checkout_files:
2490
self.move_entry('checkout', entry)
2491
if last_revision is not None:
2492
self.bzrdir.transport.put_bytes(
2493
'checkout/last-revision', last_revision)
2494
self.bzrdir.transport.put_bytes(
2496
BzrDirMetaFormat1().get_format_string(),
2497
mode=self.file_mode)
2498
return BzrDir.open(self.bzrdir.root_transport.base)
2500
def make_lock(self, name):
2501
"""Make a lock for the new control dir name."""
2502
self.step('Make %s lock' % name)
2503
ld = lockdir.LockDir(self.bzrdir.transport,
2505
file_modebits=self.file_mode,
2506
dir_modebits=self.dir_mode)
2509
def move_entry(self, new_dir, entry):
2510
"""Move then entry name into new_dir."""
2512
mandatory = entry[1]
2513
self.step('Moving %s' % name)
2515
self.bzrdir.transport.move(name, '%s/%s' % (new_dir, name))
2516
except errors.NoSuchFile:
2520
def put_format(self, dirname, format):
2521
self.bzrdir.transport.put_bytes('%s/format' % dirname,
2522
format.get_format_string(),
2526
class ConvertMetaToMeta(Converter):
1835
2527
"""Converts the components of metadirs."""
1837
2529
def __init__(self, target_format):
1891
2582
# TODO: conversions of Branch and Tree should be done by
1892
2583
# InterXFormat lookups
1893
if (isinstance(tree, workingtree_3.WorkingTree3) and
1894
not isinstance(tree, workingtree_4.DirStateWorkingTree) and
2584
if (isinstance(tree, workingtree.WorkingTree3) and
2585
not isinstance(tree, workingtree_4.WorkingTree4) and
1895
2586
isinstance(self.target_format.workingtree_format,
1896
workingtree_4.DirStateWorkingTreeFormat)):
2587
workingtree_4.WorkingTreeFormat4)):
1897
2588
workingtree_4.Converter3to4().convert(tree)
1898
if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
1899
not isinstance(tree, workingtree_4.WorkingTree5) and
1900
isinstance(self.target_format.workingtree_format,
1901
workingtree_4.WorkingTreeFormat5)):
1902
workingtree_4.Converter4to5().convert(tree)
1903
if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
1904
not isinstance(tree, workingtree_4.WorkingTree6) and
1905
isinstance(self.target_format.workingtree_format,
1906
workingtree_4.WorkingTreeFormat6)):
1907
workingtree_4.Converter4or5to6().convert(tree)
1909
2589
return to_convert
1912
controldir.ControlDirFormat.register_server_prober(RemoteBzrProber)
2592
# This is not in remote.py because it's small, and needs to be registered.
2593
# Putting it in remote.py creates a circular import problem.
2594
# we can make it a lazy object if the control formats is turned into something
2596
class RemoteBzrDirFormat(BzrDirMetaFormat1):
2597
"""Format representing bzrdirs accessed via a smart server"""
2599
def get_format_description(self):
2600
return 'bzr remote bzrdir'
2603
def probe_transport(klass, transport):
2604
"""Return a RemoteBzrDirFormat object if it looks possible."""
2606
medium = transport.get_smart_medium()
2607
except (NotImplementedError, AttributeError,
2608
errors.TransportNotPossible, errors.NoSmartMedium,
2609
errors.SmartProtocolError):
2610
# no smart server, so not a branch for this format type.
2611
raise errors.NotBranchError(path=transport.base)
2613
# Decline to open it if the server doesn't support our required
2614
# version (3) so that the VFS-based transport will do it.
2615
if medium.should_probe():
2617
server_version = medium.protocol_version()
2618
except errors.SmartProtocolError:
2619
# Apparently there's no usable smart server there, even though
2620
# the medium supports the smart protocol.
2621
raise errors.NotBranchError(path=transport.base)
2622
if server_version != '2':
2623
raise errors.NotBranchError(path=transport.base)
2626
def initialize_on_transport(self, transport):
2628
# hand off the request to the smart server
2629
client_medium = transport.get_smart_medium()
2630
except errors.NoSmartMedium:
2631
# TODO: lookup the local format from a server hint.
2632
local_dir_format = BzrDirMetaFormat1()
2633
return local_dir_format.initialize_on_transport(transport)
2634
client = _SmartClient(client_medium)
2635
path = client.remote_path_from_transport(transport)
2636
response = client.call('BzrDirFormat.initialize', path)
2637
if response[0] != 'ok':
2638
raise errors.SmartProtocolError('unexpected response code %s' % (response,))
2639
return remote.RemoteBzrDir(transport)
2641
def _open(self, transport):
2642
return remote.RemoteBzrDir(transport)
2644
def __eq__(self, other):
2645
if not isinstance(other, RemoteBzrDirFormat):
2647
return self.get_format_description() == other.get_format_description()
2650
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
2653
class BzrDirFormatInfo(object):
2655
def __init__(self, native, deprecated, hidden, experimental):
2656
self.deprecated = deprecated
2657
self.native = native
2658
self.hidden = hidden
2659
self.experimental = experimental
2662
class BzrDirFormatRegistry(registry.Registry):
2663
"""Registry of user-selectable BzrDir subformats.
2665
Differs from BzrDirFormat._control_formats in that it provides sub-formats,
2666
e.g. BzrDirMeta1 with weave repository. Also, it's more user-oriented.
2670
"""Create a BzrDirFormatRegistry."""
2671
self._aliases = set()
2672
super(BzrDirFormatRegistry, self).__init__()
2675
"""Return a set of the format names which are aliases."""
2676
return frozenset(self._aliases)
2678
def register_metadir(self, key,
2679
repository_format, help, native=True, deprecated=False,
2685
"""Register a metadir subformat.
2687
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
2688
by the Repository format.
2690
:param repository_format: The fully-qualified repository format class
2692
:param branch_format: Fully-qualified branch format class name as
2694
:param tree_format: Fully-qualified tree format class name as
2697
# This should be expanded to support setting WorkingTree and Branch
2698
# formats, once BzrDirMetaFormat1 supports that.
2699
def _load(full_name):
2700
mod_name, factory_name = full_name.rsplit('.', 1)
2702
mod = __import__(mod_name, globals(), locals(),
2704
except ImportError, e:
2705
raise ImportError('failed to load %s: %s' % (full_name, e))
2707
factory = getattr(mod, factory_name)
2708
except AttributeError:
2709
raise AttributeError('no factory %s in module %r'
2714
bd = BzrDirMetaFormat1()
2715
if branch_format is not None:
2716
bd.set_branch_format(_load(branch_format))
2717
if tree_format is not None:
2718
bd.workingtree_format = _load(tree_format)
2719
if repository_format is not None:
2720
bd.repository_format = _load(repository_format)
2722
self.register(key, helper, help, native, deprecated, hidden,
2723
experimental, alias)
2725
def register(self, key, factory, help, native=True, deprecated=False,
2726
hidden=False, experimental=False, alias=False):
2727
"""Register a BzrDirFormat factory.
2729
The factory must be a callable that takes one parameter: the key.
2730
It must produce an instance of the BzrDirFormat when called.
2732
This function mainly exists to prevent the info object from being
2735
registry.Registry.register(self, key, factory, help,
2736
BzrDirFormatInfo(native, deprecated, hidden, experimental))
2738
self._aliases.add(key)
2740
def register_lazy(self, key, module_name, member_name, help, native=True,
2741
deprecated=False, hidden=False, experimental=False, alias=False):
2742
registry.Registry.register_lazy(self, key, module_name, member_name,
2743
help, BzrDirFormatInfo(native, deprecated, hidden, experimental))
2745
self._aliases.add(key)
2747
def set_default(self, key):
2748
"""Set the 'default' key to be a clone of the supplied key.
2750
This method must be called once and only once.
2752
registry.Registry.register(self, 'default', self.get(key),
2753
self.get_help(key), info=self.get_info(key))
2754
self._aliases.add('default')
2756
def set_default_repository(self, key):
2757
"""Set the FormatRegistry default and Repository default.
2759
This is a transitional method while Repository.set_default_format
2762
if 'default' in self:
2763
self.remove('default')
2764
self.set_default(key)
2765
format = self.get('default')()
2767
def make_bzrdir(self, key):
2768
return self.get(key)()
2770
def help_topic(self, topic):
2771
output = textwrap.dedent("""\
2772
These formats can be used for creating branches, working trees, and
2776
default_realkey = None
2777
default_help = self.get_help('default')
2779
for key in self.keys():
2780
if key == 'default':
2782
help = self.get_help(key)
2783
if help == default_help:
2784
default_realkey = key
2786
help_pairs.append((key, help))
2788
def wrapped(key, help, info):
2790
help = '(native) ' + help
2791
return ':%s:\n%s\n\n' % (key,
2792
textwrap.fill(help, initial_indent=' ',
2793
subsequent_indent=' '))
2794
if default_realkey is not None:
2795
output += wrapped(default_realkey, '(default) %s' % default_help,
2796
self.get_info('default'))
2797
deprecated_pairs = []
2798
experimental_pairs = []
2799
for key, help in help_pairs:
2800
info = self.get_info(key)
2803
elif info.deprecated:
2804
deprecated_pairs.append((key, help))
2805
elif info.experimental:
2806
experimental_pairs.append((key, help))
2808
output += wrapped(key, help, info)
2809
if len(experimental_pairs) > 0:
2810
output += "Experimental formats are shown below.\n\n"
2811
for key, help in experimental_pairs:
2812
info = self.get_info(key)
2813
output += wrapped(key, help, info)
2814
if len(deprecated_pairs) > 0:
2815
output += "Deprecated formats are shown below.\n\n"
2816
for key, help in deprecated_pairs:
2817
info = self.get_info(key)
2818
output += wrapped(key, help, info)
1915
2823
class RepositoryAcquisitionPolicy(object):
2063
2946
def acquire_repository(self, make_working_trees=None, shared=False):
2064
2947
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
2066
Returns an existing repository to use.
2949
Returns an existing repository to use
2068
self._add_fallback(self._repository,
2069
possible_transports=[self._repository.bzrdir.transport])
2070
return self._repository, False
2073
def register_metadir(registry, key,
2074
repository_format, help, native=True, deprecated=False,
2080
"""Register a metadir subformat.
2082
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
2083
by the Repository/Branch/WorkingTreeformats.
2085
:param repository_format: The fully-qualified repository format class
2087
:param branch_format: Fully-qualified branch format class name as
2089
:param tree_format: Fully-qualified tree format class name as
2092
# This should be expanded to support setting WorkingTree and Branch
2093
# formats, once BzrDirMetaFormat1 supports that.
2094
def _load(full_name):
2095
mod_name, factory_name = full_name.rsplit('.', 1)
2097
factory = pyutils.get_named_object(mod_name, factory_name)
2098
except ImportError, e:
2099
raise ImportError('failed to load %s: %s' % (full_name, e))
2100
except AttributeError:
2101
raise AttributeError('no factory %s in module %r'
2102
% (full_name, sys.modules[mod_name]))
2106
bd = BzrDirMetaFormat1()
2107
if branch_format is not None:
2108
bd.set_branch_format(_load(branch_format))
2109
if tree_format is not None:
2110
bd.workingtree_format = _load(tree_format)
2111
if repository_format is not None:
2112
bd.repository_format = _load(repository_format)
2114
registry.register(key, helper, help, native, deprecated, hidden,
2115
experimental, alias)
2117
register_metadir(controldir.format_registry, 'knit',
2951
self._add_fallback(self._repository)
2952
return self._repository
2955
format_registry = BzrDirFormatRegistry()
2956
format_registry.register('weave', BzrDirFormat6,
2957
'Pre-0.8 format. Slower than knit and does not'
2958
' support checkouts or shared repositories.',
2960
format_registry.register_metadir('knit',
2118
2961
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2119
2962
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
2120
2963
branch_format='bzrlib.branch.BzrBranchFormat5',
2121
tree_format='bzrlib.workingtree_3.WorkingTreeFormat3',
2964
tree_format='bzrlib.workingtree.WorkingTreeFormat3')
2965
format_registry.register_metadir('metaweave',
2966
'bzrlib.repofmt.weaverepo.RepositoryFormat7',
2967
'Transitional format in 0.8. Slower than knit.',
2968
branch_format='bzrlib.branch.BzrBranchFormat5',
2969
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
2123
2970
deprecated=True)
2124
register_metadir(controldir.format_registry, 'dirstate',
2971
format_registry.register_metadir('dirstate',
2125
2972
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2126
2973
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
2127
2974
'above when accessed over the network.',
2128
2975
branch_format='bzrlib.branch.BzrBranchFormat5',
2129
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2132
register_metadir(controldir.format_registry, 'dirstate-tags',
2976
# this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
2977
# directly from workingtree_4 triggers a circular import.
2978
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2980
format_registry.register_metadir('dirstate-tags',
2133
2981
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2134
2982
help='New in 0.15: Fast local operations and improved scaling for '
2135
2983
'network operations. Additionally adds support for tags.'
2136
2984
' Incompatible with bzr < 0.15.',
2137
2985
branch_format='bzrlib.branch.BzrBranchFormat6',
2138
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2141
register_metadir(controldir.format_registry, 'rich-root',
2986
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2988
format_registry.register_metadir('rich-root',
2142
2989
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
2143
2990
help='New in 1.0. Better handling of tree roots. Incompatible with'
2145
2992
branch_format='bzrlib.branch.BzrBranchFormat6',
2146
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2149
register_metadir(controldir.format_registry, 'dirstate-with-subtree',
2993
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2995
format_registry.register_metadir('dirstate-with-subtree',
2150
2996
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
2151
2997
help='New in 0.15: Fast local operations and improved scaling for '
2152
2998
'network operations. Additionally adds support for versioning nested '
2153
2999
'bzr branches. Incompatible with bzr < 0.15.',
2154
3000
branch_format='bzrlib.branch.BzrBranchFormat6',
2155
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3001
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2156
3002
experimental=True,
2159
register_metadir(controldir.format_registry, 'pack-0.92',
2160
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack1',
3005
format_registry.register_metadir('pack-0.92',
3006
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack1',
2161
3007
help='New in 0.92: Pack-based format with data compatible with '
2162
3008
'dirstate-tags format repositories. Interoperates with '
2163
3009
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3010
'Previously called knitpack-experimental. '
3011
'For more information, see '
3012
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
2165
3013
branch_format='bzrlib.branch.BzrBranchFormat6',
2166
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3014
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2168
register_metadir(controldir.format_registry, 'pack-0.92-subtree',
2169
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack3',
3016
format_registry.register_metadir('pack-0.92-subtree',
3017
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack3',
2170
3018
help='New in 0.92: Pack-based format with data compatible with '
2171
3019
'dirstate-with-subtree format repositories. Interoperates with '
2172
3020
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
2174
branch_format='bzrlib.branch.BzrBranchFormat6',
2175
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2179
register_metadir(controldir.format_registry, 'rich-root-pack',
2180
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack4',
2181
help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
2182
'(needed for bzr-svn and bzr-git).',
2183
branch_format='bzrlib.branch.BzrBranchFormat6',
2184
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2187
register_metadir(controldir.format_registry, '1.6',
2188
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack5',
2189
help='A format that allows a branch to indicate that there is another '
2190
'(stacked) repository that should be used to access data that is '
2191
'not present locally.',
2192
branch_format='bzrlib.branch.BzrBranchFormat7',
2193
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2196
register_metadir(controldir.format_registry, '1.6.1-rich-root',
2197
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack5RichRoot',
2198
help='A variant of 1.6 that supports rich-root data '
2199
'(needed for bzr-svn and bzr-git).',
2200
branch_format='bzrlib.branch.BzrBranchFormat7',
2201
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2204
register_metadir(controldir.format_registry, '1.9',
2205
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6',
2206
help='A repository format using B+tree indexes. These indexes '
2207
'are smaller in size, have smarter caching and provide faster '
2208
'performance for most operations.',
2209
branch_format='bzrlib.branch.BzrBranchFormat7',
2210
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2213
register_metadir(controldir.format_registry, '1.9-rich-root',
2214
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6RichRoot',
2215
help='A variant of 1.9 that supports rich-root data '
2216
'(needed for bzr-svn and bzr-git).',
2217
branch_format='bzrlib.branch.BzrBranchFormat7',
2218
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2221
register_metadir(controldir.format_registry, '1.14',
2222
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6',
2223
help='A working-tree format that supports content filtering.',
2224
branch_format='bzrlib.branch.BzrBranchFormat7',
2225
tree_format='bzrlib.workingtree_4.WorkingTreeFormat5',
2227
register_metadir(controldir.format_registry, '1.14-rich-root',
2228
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6RichRoot',
2229
help='A variant of 1.14 that supports rich-root data '
2230
'(needed for bzr-svn and bzr-git).',
2231
branch_format='bzrlib.branch.BzrBranchFormat7',
2232
tree_format='bzrlib.workingtree_4.WorkingTreeFormat5',
2234
# The following un-numbered 'development' formats should always just be aliases.
2235
register_metadir(controldir.format_registry, 'development-subtree',
2236
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2aSubtree',
3021
'Previously called knitpack-experimental. '
3022
'For more information, see '
3023
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3024
branch_format='bzrlib.branch.BzrBranchFormat6',
3025
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3029
format_registry.register_metadir('rich-root-pack',
3030
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3031
help='New in 1.0: Pack-based format with data compatible with '
3032
'rich-root format repositories. Incompatible with'
3034
branch_format='bzrlib.branch.BzrBranchFormat6',
3035
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3037
format_registry.register_metadir('1.6',
3038
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
3039
help='A branch and pack based repository that supports stacking. ',
3040
branch_format='bzrlib.branch.BzrBranchFormat7',
3041
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3043
format_registry.register_metadir('1.6.1-rich-root',
3044
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
3045
help='A branch and pack based repository that supports stacking '
3046
'and rich root data (needed for bzr-svn). ',
3047
branch_format='bzrlib.branch.BzrBranchFormat7',
3048
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3050
# The following two formats should always just be aliases.
3051
format_registry.register_metadir('development',
3052
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment1',
3053
help='Current development format. Can convert data to and from pack-0.92 '
3054
'(and anything compatible with pack-0.92) format repositories. '
3055
'Repositories and branches in this format can only be read by bzr.dev. '
3057
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3059
branch_format='bzrlib.branch.BzrBranchFormat7',
3060
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3064
format_registry.register_metadir('development-subtree',
3065
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment1Subtree',
2237
3066
help='Current development format, subtree variant. Can convert data to and '
2238
3067
'from pack-0.92-subtree (and anything compatible with '
2239
3068
'pack-0.92-subtree) format repositories. Repositories and branches in '
2240
3069
'this format can only be read by bzr.dev. Please read '
2241
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
2243
branch_format='bzrlib.branch.BzrBranchFormat7',
2244
tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
2247
alias=False, # Restore to being an alias when an actual development subtree format is added
2248
# This current non-alias status is simply because we did not introduce a
2249
# chk based subtree format.
2251
register_metadir(controldir.format_registry, 'development5-subtree',
2252
'bzrlib.repofmt.knitpack_repo.RepositoryFormatPackDevelopment2Subtree',
2253
help='Development format, subtree variant. Can convert data to and '
2254
'from pack-0.92-subtree (and anything compatible with '
2255
'pack-0.92-subtree) format repositories. Repositories and branches in '
2256
'this format can only be read by bzr.dev. Please read '
2257
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
2259
branch_format='bzrlib.branch.BzrBranchFormat7',
2260
tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
2266
# And the development formats above will have aliased one of the following:
2268
# Finally, the current format.
2269
register_metadir(controldir.format_registry, '2a',
2270
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
2271
help='First format for bzr 2.0 series.\n'
2272
'Uses group-compress storage.\n'
2273
'Provides rich roots which are a one-way transition.\n',
2274
# 'storage in packs, 255-way hashed CHK inventory, bencode revision, group compress, '
2275
# 'rich roots. Supported by bzr 1.16 and later.',
2276
branch_format='bzrlib.branch.BzrBranchFormat7',
2277
tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
2281
# The following format should be an alias for the rich root equivalent
2282
# of the default format
2283
register_metadir(controldir.format_registry, 'default-rich-root',
2284
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
2285
branch_format='bzrlib.branch.BzrBranchFormat7',
2286
tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
3070
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3072
branch_format='bzrlib.branch.BzrBranchFormat7',
3073
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3077
# And the development formats which the will have aliased one of follow:
3078
format_registry.register_metadir('development1',
3079
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment1',
3080
help='A branch and pack based repository that supports stacking. '
3082
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3084
branch_format='bzrlib.branch.BzrBranchFormat7',
3085
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3089
format_registry.register_metadir('development1-subtree',
3090
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment1Subtree',
3091
help='A branch and pack based repository that supports stacking. '
3093
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3095
branch_format='bzrlib.branch.BzrBranchFormat7',
3096
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2291
3100
# The current format that is made on 'bzr init'.
2292
format_name = config.GlobalStack().get('default_format')
2293
controldir.format_registry.set_default(format_name)
2295
# XXX 2010-08-20 JRV: There is still a lot of code relying on
2296
# bzrlib.bzrdir.format_registry existing. When BzrDir.create/BzrDir.open/etc
2297
# get changed to ControlDir.create/ControlDir.open/etc this should be removed.
2298
format_registry = controldir.format_registry
3101
format_registry.set_default('pack-0.92')
added
removed
bzrlib/bzrdir.py
