350
371
except errors.NoRepositoryPresent:
353
return False, ([], repository)
354
return True, (bzrdir.list_branches(), None)
356
for branches, repo in BzrDir.find_bzrdirs(transport,
374
return False, (None, repository)
376
branch = bzrdir.open_branch()
377
except errors.NotBranchError:
378
return True, (None, None)
380
return True, (branch, None)
382
for branch, repo in BzrDir.find_bzrdirs(transport, evaluate=evaluate):
358
383
if repo is not None:
359
ret.extend(repo.find_branches())
360
if branches is not None:
384
branches.extend(repo.find_branches())
385
if branch is not None:
386
branches.append(branch)
389
def destroy_repository(self):
390
"""Destroy the repository in this BzrDir"""
391
raise NotImplementedError(self.destroy_repository)
393
def create_branch(self):
394
"""Create a branch in this BzrDir.
396
The bzrdir's format will control what branch format is created.
397
For more control see BranchFormatXX.create(a_bzrdir).
399
raise NotImplementedError(self.create_branch)
401
def destroy_branch(self):
402
"""Destroy the branch in this BzrDir"""
403
raise NotImplementedError(self.destroy_branch)
365
406
def create_branch_and_repo(base, force_new_repo=False, format=None):
515
556
format=format).bzrdir
516
557
return bzrdir.create_workingtree()
518
def generate_backup_name(self, base):
519
"""Generate a non-existing backup file name based on base."""
521
name = "%s.~%d~" % (base, counter)
522
while self.root_transport.has(name):
524
name = "%s.~%d~" % (base, counter)
559
def create_workingtree(self, revision_id=None, from_branch=None,
560
accelerator_tree=None, hardlink=False):
561
"""Create a working tree at this BzrDir.
563
:param revision_id: create it as of this revision id.
564
:param from_branch: override bzrdir branch (for lightweight checkouts)
565
:param accelerator_tree: A tree which can be used for retrieving file
566
contents more quickly than the revision tree, i.e. a workingtree.
567
The revision tree will be used for cases where accelerator_tree's
568
content is different.
570
raise NotImplementedError(self.create_workingtree)
527
572
def backup_bzrdir(self):
528
573
"""Backup this bzr control directory.
530
575
:return: Tuple with old path name and new path name
533
backup_dir=self.generate_backup_name('backup.bzr')
534
577
pb = ui.ui_factory.nested_progress_bar()
536
579
# FIXME: bug 300001 -- the backup fails if the backup directory
537
580
# already exists, but it should instead either remove it or make
538
581
# a new backup directory.
583
# FIXME: bug 262450 -- the backup directory should have the same
584
# permissions as the .bzr directory (probably a bug in copy_tree)
540
585
old_path = self.root_transport.abspath('.bzr')
541
new_path = self.root_transport.abspath(backup_dir)
542
ui.ui_factory.note('making backup of %s\n to %s' % (old_path, new_path,))
543
self.root_transport.copy_tree('.bzr', backup_dir)
586
new_path = self.root_transport.abspath('backup.bzr')
587
pb.note('making backup of %s' % (old_path,))
588
pb.note(' to %s' % (new_path,))
589
self.root_transport.copy_tree('.bzr', 'backup.bzr')
544
590
return (old_path, new_path)
860
998
raise errors.NotBranchError(location)
861
999
return tree, branch, branch.repository, relpath
1001
def open_repository(self, _unsupported=False):
1002
"""Open the repository object at this BzrDir if one is present.
1004
This will not follow the Branch object pointer - it's strictly a direct
1005
open facility. Most client code should use open_branch().repository to
1006
get at a repository.
1008
:param _unsupported: a private parameter, not part of the api.
1009
TODO: static convenience version of this?
1011
raise NotImplementedError(self.open_repository)
1013
def open_workingtree(self, _unsupported=False,
1014
recommend_upgrade=True, from_branch=None):
1015
"""Open the workingtree object at this BzrDir if one is present.
1017
:param recommend_upgrade: Optional keyword parameter, when True (the
1018
default), emit through the ui module a recommendation that the user
1019
upgrade the working tree when the workingtree being opened is old
1020
(but still fully supported).
1021
:param from_branch: override bzrdir branch (for lightweight checkouts)
1023
raise NotImplementedError(self.open_workingtree)
1025
def has_branch(self):
1026
"""Tell if this bzrdir contains a branch.
1028
Note: if you're going to open the branch, you should just go ahead
1029
and try, and not ask permission first. (This method just opens the
1030
branch and discards it, and that's somewhat expensive.)
1035
except errors.NotBranchError:
1038
def has_workingtree(self):
1039
"""Tell if this bzrdir contains a working tree.
1041
This will still raise an exception if the bzrdir has a workingtree that
1042
is remote & inaccessible.
1044
Note: if you're going to open the working tree, you should just go ahead
1045
and try, and not ask permission first. (This method just opens the
1046
workingtree and discards it, and that's somewhat expensive.)
1049
self.open_workingtree(recommend_upgrade=False)
1051
except errors.NoWorkingTree:
863
1054
def _cloning_metadir(self):
864
1055
"""Produce a metadir suitable for cloning with.
923
1114
format.require_stacking()
927
def create(cls, base, format=None, possible_transports=None):
928
"""Create a new BzrDir at the url 'base'.
930
:param format: If supplied, the format of branch to create. If not
931
supplied, the default is used.
932
:param possible_transports: If supplied, a list of transports that
933
can be reused to share a remote connection.
1117
def checkout_metadir(self):
1118
return self.cloning_metadir()
1120
def sprout(self, url, revision_id=None, force_new_repo=False,
1121
recurse='down', possible_transports=None,
1122
accelerator_tree=None, hardlink=False, stacked=False,
1123
source_branch=None, create_tree_if_local=True):
1124
"""Create a copy of this bzrdir prepared for use as a new line of
1127
If url's last component does not exist, it will be created.
1129
Attributes related to the identity of the source branch like
1130
branch nickname will be cleaned, a working tree is created
1131
whether one existed before or not; and a local branch is always
1134
if revision_id is not None, then the clone operation may tune
1135
itself to download less data.
1136
:param accelerator_tree: A tree which can be used for retrieving file
1137
contents more quickly than the revision tree, i.e. a workingtree.
1138
The revision tree will be used for cases where accelerator_tree's
1139
content is different.
1140
:param hardlink: If true, hard-link files from accelerator_tree,
1142
:param stacked: If true, create a stacked branch referring to the
1143
location of this control directory.
1144
:param create_tree_if_local: If true, a working-tree will be created
1145
when working locally.
935
if cls is not BzrDir:
936
raise AssertionError("BzrDir.create always creates the"
937
"default format, not one of %r" % cls)
938
t = get_transport(base, possible_transports)
941
format = controldir.ControlDirFormat.get_default_format()
942
return format.initialize_on_transport(t)
1147
target_transport = get_transport(url, possible_transports)
1148
target_transport.ensure_base()
1149
cloning_format = self.cloning_metadir(stacked)
1150
# Create/update the result branch
1151
result = cloning_format.initialize_on_transport(target_transport)
1152
# if a stacked branch wasn't requested, we don't create one
1153
# even if the origin was stacked
1154
stacked_branch_url = None
1155
if source_branch is not None:
1157
stacked_branch_url = self.root_transport.base
1158
source_repository = source_branch.repository
1161
source_branch = self.open_branch()
1162
source_repository = source_branch.repository
1164
stacked_branch_url = self.root_transport.base
1165
except errors.NotBranchError:
1166
source_branch = None
1168
source_repository = self.open_repository()
1169
except errors.NoRepositoryPresent:
1170
source_repository = None
1171
repository_policy = result.determine_repository_policy(
1172
force_new_repo, stacked_branch_url, require_stacking=stacked)
1173
result_repo, is_new_repo = repository_policy.acquire_repository()
1174
if is_new_repo and revision_id is not None and not stacked:
1175
fetch_spec = graph.PendingAncestryResult(
1176
[revision_id], source_repository)
1179
if source_repository is not None:
1180
# Fetch while stacked to prevent unstacked fetch from
1182
if fetch_spec is None:
1183
result_repo.fetch(source_repository, revision_id=revision_id)
1185
result_repo.fetch(source_repository, fetch_spec=fetch_spec)
1187
if source_branch is None:
1188
# this is for sprouting a bzrdir without a branch; is that
1190
# Not especially, but it's part of the contract.
1191
result_branch = result.create_branch()
1193
result_branch = source_branch.sprout(result,
1194
revision_id=revision_id, repository_policy=repository_policy)
1195
mutter("created new branch %r" % (result_branch,))
1197
# Create/update the result working tree
1198
if (create_tree_if_local and
1199
isinstance(target_transport, local.LocalTransport) and
1200
(result_repo is None or result_repo.make_working_trees())):
1201
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
1205
if wt.path2id('') is None:
1207
wt.set_root_id(self.open_workingtree.get_root_id())
1208
except errors.NoWorkingTree:
1214
if recurse == 'down':
1216
basis = wt.basis_tree()
1218
subtrees = basis.iter_references()
1219
elif result_branch is not None:
1220
basis = result_branch.basis_tree()
1222
subtrees = basis.iter_references()
1223
elif source_branch is not None:
1224
basis = source_branch.basis_tree()
1226
subtrees = basis.iter_references()
1231
for path, file_id in subtrees:
1232
target = urlutils.join(url, urlutils.escape(path))
1233
sublocation = source_branch.reference_parent(file_id, path)
1234
sublocation.bzrdir.sprout(target,
1235
basis.get_reference_revision(file_id, path),
1236
force_new_repo=force_new_repo, recurse=recurse,
1239
if basis is not None:
1243
def push_branch(self, source, revision_id=None, overwrite=False,
1244
remember=False, create_prefix=False):
1245
"""Push the source branch into this BzrDir."""
1247
# If we can open a branch, use its direct repository, otherwise see
1248
# if there is a repository without a branch.
1250
br_to = self.open_branch()
1251
except errors.NotBranchError:
1252
# Didn't find a branch, can we find a repository?
1253
repository_to = self.find_repository()
1255
# Found a branch, so we must have found a repository
1256
repository_to = br_to.repository
1258
push_result = PushResult()
1259
push_result.source_branch = source
1261
# We have a repository but no branch, copy the revisions, and then
1263
repository_to.fetch(source.repository, revision_id=revision_id)
1264
br_to = source.clone(self, revision_id=revision_id)
1265
if source.get_push_location() is None or remember:
1266
source.set_push_location(br_to.base)
1267
push_result.stacked_on = None
1268
push_result.branch_push_result = None
1269
push_result.old_revno = None
1270
push_result.old_revid = _mod_revision.NULL_REVISION
1271
push_result.target_branch = br_to
1272
push_result.master_branch = None
1273
push_result.workingtree_updated = False
1275
# We have successfully opened the branch, remember if necessary:
1276
if source.get_push_location() is None or remember:
1277
source.set_push_location(br_to.base)
1279
tree_to = self.open_workingtree()
1280
except errors.NotLocalUrl:
1281
push_result.branch_push_result = source.push(br_to,
1282
overwrite, stop_revision=revision_id)
1283
push_result.workingtree_updated = False
1284
except errors.NoWorkingTree:
1285
push_result.branch_push_result = source.push(br_to,
1286
overwrite, stop_revision=revision_id)
1287
push_result.workingtree_updated = None # Not applicable
1289
tree_to.lock_write()
1291
push_result.branch_push_result = source.push(
1292
tree_to.branch, overwrite, stop_revision=revision_id)
1296
push_result.workingtree_updated = True
1297
push_result.old_revno = push_result.branch_push_result.old_revno
1298
push_result.old_revid = push_result.branch_push_result.old_revid
1299
push_result.target_branch = \
1300
push_result.branch_push_result.target_branch
946
1304
class BzrDirHooks(hooks.Hooks):
952
1310
self.create_hook(hooks.HookPoint('pre_open',
953
1311
"Invoked before attempting to open a BzrDir with the transport "
954
1312
"that the open will use.", (1, 14), None))
955
self.create_hook(hooks.HookPoint('post_repo_init',
956
"Invoked after a repository has been initialized. "
957
"post_repo_init is called with a "
958
"bzrlib.bzrdir.RepoInitHookParams.",
961
1314
# install the default hooks
962
1315
BzrDir.hooks = BzrDirHooks()
965
class RepoInitHookParams(object):
966
"""Object holding parameters passed to *_repo_init hooks.
968
There are 4 fields that hooks may wish to access:
970
:ivar repository: Repository created
971
:ivar format: Repository format
972
:ivar bzrdir: The bzrdir for the repository
973
:ivar shared: The repository is shared
976
def __init__(self, repository, format, a_bzrdir, shared):
977
"""Create a group of RepoInitHook parameters.
979
:param repository: Repository created
980
:param format: Repository format
981
:param bzrdir: The bzrdir for the repository
982
:param shared: The repository is shared
984
self.repository = repository
986
self.bzrdir = a_bzrdir
989
def __eq__(self, other):
990
return self.__dict__ == other.__dict__
994
return "<%s for %s>" % (self.__class__.__name__,
997
return "<%s for %s>" % (self.__class__.__name__,
1001
1318
class BzrDirPreSplitOut(BzrDir):
1002
1319
"""A common class for the all-in-one formats."""
1459
1745
return config.TransportConfig(self.transport, 'control.conf')
1462
class BzrProber(controldir.Prober):
1463
"""Prober for formats that use a .bzr/ control directory."""
1466
"""The known .bzr formats."""
1469
def register_bzrdir_format(klass, format):
1470
klass._formats[format.get_format_string()] = format
1473
def unregister_bzrdir_format(klass, format):
1474
del klass._formats[format.get_format_string()]
1477
def probe_transport(klass, transport):
1478
"""Return the .bzrdir style format present in a directory."""
1480
format_string = transport.get_bytes(".bzr/branch-format")
1481
except errors.NoSuchFile:
1482
raise errors.NotBranchError(path=transport.base)
1484
return klass._formats[format_string]
1486
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1489
controldir.ControlDirFormat.register_prober(BzrProber)
1492
class RemoteBzrProber(controldir.Prober):
1493
"""Prober for remote servers that provide a Bazaar smart server."""
1496
def probe_transport(klass, transport):
1497
"""Return a RemoteBzrDirFormat object if it looks possible."""
1499
medium = transport.get_smart_medium()
1500
except (NotImplementedError, AttributeError,
1501
errors.TransportNotPossible, errors.NoSmartMedium,
1502
errors.SmartProtocolError):
1503
# no smart server, so not a branch for this format type.
1504
raise errors.NotBranchError(path=transport.base)
1506
# Decline to open it if the server doesn't support our required
1507
# version (3) so that the VFS-based transport will do it.
1508
if medium.should_probe():
1510
server_version = medium.protocol_version()
1511
except errors.SmartProtocolError:
1512
# Apparently there's no usable smart server there, even though
1513
# the medium supports the smart protocol.
1514
raise errors.NotBranchError(path=transport.base)
1515
if server_version != '2':
1516
raise errors.NotBranchError(path=transport.base)
1517
return RemoteBzrDirFormat()
1520
class BzrDirFormat(controldir.ControlDirFormat):
1521
"""ControlDirFormat base class for .bzr/ directories.
1748
class BzrDirFormat(object):
1749
"""An encapsulation of the initialization and open routines for a format.
1751
Formats provide three things:
1752
* An initialization routine,
1523
1756
Formats are placed in a dict by their format string for reference
1524
1757
during bzrdir opening. These should be subclasses of BzrDirFormat
1529
1762
object will be created every system load.
1765
_default_format = None
1766
"""The default format used for new .bzr dirs."""
1769
"""The known formats."""
1771
_control_formats = []
1772
"""The registered control formats - .bzr, ....
1774
This is a list of BzrDirFormat objects.
1777
_control_server_formats = []
1778
"""The registered control server formats, e.g. RemoteBzrDirs.
1780
This is a list of BzrDirFormat objects.
1532
1783
_lock_file_name = 'branch-lock'
1534
1785
# _lock_class must be set in subclasses to the lock type, typ.
1535
1786
# TransportLock or LockDir
1789
def find_format(klass, transport, _server_formats=True):
1790
"""Return the format present at transport."""
1792
formats = klass._control_server_formats + klass._control_formats
1794
formats = klass._control_formats
1795
for format in formats:
1797
return format.probe_transport(transport)
1798
except errors.NotBranchError:
1799
# this format does not find a control dir here.
1801
raise errors.NotBranchError(path=transport.base)
1804
def probe_transport(klass, transport):
1805
"""Return the .bzrdir style format present in a directory."""
1807
format_string = transport.get(".bzr/branch-format").read()
1808
except errors.NoSuchFile:
1809
raise errors.NotBranchError(path=transport.base)
1812
return klass._formats[format_string]
1814
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1817
def get_default_format(klass):
1818
"""Return the current default format."""
1819
return klass._default_format
1537
1821
def get_format_string(self):
1538
1822
"""Return the ASCII format string that identifies this format."""
1539
1823
raise NotImplementedError(self.get_format_string)
1825
def get_format_description(self):
1826
"""Return the short description for this format."""
1827
raise NotImplementedError(self.get_format_description)
1829
def get_converter(self, format=None):
1830
"""Return the converter to use to convert bzrdirs needing converts.
1832
This returns a bzrlib.bzrdir.Converter object.
1834
This should return the best upgrader to step this format towards the
1835
current default format. In the case of plugins we can/should provide
1836
some means for them to extend the range of returnable converters.
1838
:param format: Optional format to override the default format of the
1841
raise NotImplementedError(self.get_converter)
1843
def initialize(self, url, possible_transports=None):
1844
"""Create a bzr control dir at this url and return an opened copy.
1846
While not deprecated, this method is very specific and its use will
1847
lead to many round trips to setup a working environment. See
1848
initialize_on_transport_ex for a [nearly] all-in-one method.
1850
Subclasses should typically override initialize_on_transport
1851
instead of this method.
1853
return self.initialize_on_transport(get_transport(url,
1854
possible_transports))
1541
1856
def initialize_on_transport(self, transport):
1542
1857
"""Initialize a new bzrdir in the base directory of a Transport."""
1691
2006
control_files.unlock()
1692
2007
return self.open(transport, _found=True)
2009
def is_supported(self):
2010
"""Is this format supported?
2012
Supported formats must be initializable and openable.
2013
Unsupported formats may not support initialization or committing or
2014
some other features depending on the reason for not being supported.
2018
def network_name(self):
2019
"""A simple byte string uniquely identifying this format for RPC calls.
2021
Bzr control formats use thir disk format string to identify the format
2022
over the wire. Its possible that other control formats have more
2023
complex detection requirements, so we permit them to use any unique and
2024
immutable string they desire.
2026
raise NotImplementedError(self.network_name)
2028
def same_model(self, target_format):
2029
return (self.repository_format.rich_root_data ==
2030
target_format.rich_root_data)
2033
def known_formats(klass):
2034
"""Return all the known formats.
2036
Concrete formats should override _known_formats.
2038
# There is double indirection here to make sure that control
2039
# formats used by more than one dir format will only be probed
2040
# once. This can otherwise be quite expensive for remote connections.
2042
for format in klass._control_formats:
2043
result.update(format._known_formats())
2047
def _known_formats(klass):
2048
"""Return the known format instances for this control format."""
2049
return set(klass._formats.values())
1694
2051
def open(self, transport, _found=False):
1695
2052
"""Return an instance of this format for the dir transport points at.
1697
2054
_found is a private parameter, do not use it.
1700
found_format = controldir.ControlDirFormat.find_format(transport)
2057
found_format = BzrDirFormat.find_format(transport)
1701
2058
if not isinstance(found_format, self.__class__):
1702
2059
raise AssertionError("%s was asked to open %s, but it seems to need "
2934
3328
BzrDirMetaFormat1._set_repository_format) #.im_func)
2937
controldir.ControlDirFormat.register_server_prober(RemoteBzrProber)
3331
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
3334
class BzrDirFormatInfo(object):
3336
def __init__(self, native, deprecated, hidden, experimental):
3337
self.deprecated = deprecated
3338
self.native = native
3339
self.hidden = hidden
3340
self.experimental = experimental
3343
class BzrDirFormatRegistry(registry.Registry):
3344
"""Registry of user-selectable BzrDir subformats.
3346
Differs from BzrDirFormat._control_formats in that it provides sub-formats,
3347
e.g. BzrDirMeta1 with weave repository. Also, it's more user-oriented.
3351
"""Create a BzrDirFormatRegistry."""
3352
self._aliases = set()
3353
self._registration_order = list()
3354
super(BzrDirFormatRegistry, self).__init__()
3357
"""Return a set of the format names which are aliases."""
3358
return frozenset(self._aliases)
3360
def register_metadir(self, key,
3361
repository_format, help, native=True, deprecated=False,
3367
"""Register a metadir subformat.
3369
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
3370
by the Repository/Branch/WorkingTreeformats.
3372
:param repository_format: The fully-qualified repository format class
3374
:param branch_format: Fully-qualified branch format class name as
3376
:param tree_format: Fully-qualified tree format class name as
3379
# This should be expanded to support setting WorkingTree and Branch
3380
# formats, once BzrDirMetaFormat1 supports that.
3381
def _load(full_name):
3382
mod_name, factory_name = full_name.rsplit('.', 1)
3384
mod = __import__(mod_name, globals(), locals(),
3386
except ImportError, e:
3387
raise ImportError('failed to load %s: %s' % (full_name, e))
3389
factory = getattr(mod, factory_name)
3390
except AttributeError:
3391
raise AttributeError('no factory %s in module %r'
3396
bd = BzrDirMetaFormat1()
3397
if branch_format is not None:
3398
bd.set_branch_format(_load(branch_format))
3399
if tree_format is not None:
3400
bd.workingtree_format = _load(tree_format)
3401
if repository_format is not None:
3402
bd.repository_format = _load(repository_format)
3404
self.register(key, helper, help, native, deprecated, hidden,
3405
experimental, alias)
3407
def register(self, key, factory, help, native=True, deprecated=False,
3408
hidden=False, experimental=False, alias=False):
3409
"""Register a BzrDirFormat factory.
3411
The factory must be a callable that takes one parameter: the key.
3412
It must produce an instance of the BzrDirFormat when called.
3414
This function mainly exists to prevent the info object from being
3417
registry.Registry.register(self, key, factory, help,
3418
BzrDirFormatInfo(native, deprecated, hidden, experimental))
3420
self._aliases.add(key)
3421
self._registration_order.append(key)
3423
def register_lazy(self, key, module_name, member_name, help, native=True,
3424
deprecated=False, hidden=False, experimental=False, alias=False):
3425
registry.Registry.register_lazy(self, key, module_name, member_name,
3426
help, BzrDirFormatInfo(native, deprecated, hidden, experimental))
3428
self._aliases.add(key)
3429
self._registration_order.append(key)
3431
def set_default(self, key):
3432
"""Set the 'default' key to be a clone of the supplied key.
3434
This method must be called once and only once.
3436
registry.Registry.register(self, 'default', self.get(key),
3437
self.get_help(key), info=self.get_info(key))
3438
self._aliases.add('default')
3440
def set_default_repository(self, key):
3441
"""Set the FormatRegistry default and Repository default.
3443
This is a transitional method while Repository.set_default_format
3446
if 'default' in self:
3447
self.remove('default')
3448
self.set_default(key)
3449
format = self.get('default')()
3451
def make_bzrdir(self, key):
3452
return self.get(key)()
3454
def help_topic(self, topic):
3456
default_realkey = None
3457
default_help = self.get_help('default')
3459
for key in self._registration_order:
3460
if key == 'default':
3462
help = self.get_help(key)
3463
if help == default_help:
3464
default_realkey = key
3466
help_pairs.append((key, help))
3468
def wrapped(key, help, info):
3470
help = '(native) ' + help
3471
return ':%s:\n%s\n\n' % (key,
3472
textwrap.fill(help, initial_indent=' ',
3473
subsequent_indent=' ',
3474
break_long_words=False))
3475
if default_realkey is not None:
3476
output += wrapped(default_realkey, '(default) %s' % default_help,
3477
self.get_info('default'))
3478
deprecated_pairs = []
3479
experimental_pairs = []
3480
for key, help in help_pairs:
3481
info = self.get_info(key)
3484
elif info.deprecated:
3485
deprecated_pairs.append((key, help))
3486
elif info.experimental:
3487
experimental_pairs.append((key, help))
3489
output += wrapped(key, help, info)
3490
output += "\nSee ``bzr help formats`` for more about storage formats."
3492
if len(experimental_pairs) > 0:
3493
other_output += "Experimental formats are shown below.\n\n"
3494
for key, help in experimental_pairs:
3495
info = self.get_info(key)
3496
other_output += wrapped(key, help, info)
3499
"No experimental formats are available.\n\n"
3500
if len(deprecated_pairs) > 0:
3501
other_output += "\nDeprecated formats are shown below.\n\n"
3502
for key, help in deprecated_pairs:
3503
info = self.get_info(key)
3504
other_output += wrapped(key, help, info)
3507
"\nNo deprecated formats are available.\n\n"
3509
"\nSee ``bzr help formats`` for more about storage formats."
3511
if topic == 'other-formats':
2940
3517
class RepositoryAcquisitionPolicy(object):
3094
3671
return self._repository, False
3097
def register_metadir(registry, key,
3098
repository_format, help, native=True, deprecated=False,
3104
"""Register a metadir subformat.
3106
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
3107
by the Repository/Branch/WorkingTreeformats.
3109
:param repository_format: The fully-qualified repository format class
3111
:param branch_format: Fully-qualified branch format class name as
3113
:param tree_format: Fully-qualified tree format class name as
3116
# This should be expanded to support setting WorkingTree and Branch
3117
# formats, once BzrDirMetaFormat1 supports that.
3118
def _load(full_name):
3119
mod_name, factory_name = full_name.rsplit('.', 1)
3121
mod = __import__(mod_name, globals(), locals(),
3123
except ImportError, e:
3124
raise ImportError('failed to load %s: %s' % (full_name, e))
3126
factory = getattr(mod, factory_name)
3127
except AttributeError:
3128
raise AttributeError('no factory %s in module %r'
3133
bd = BzrDirMetaFormat1()
3134
if branch_format is not None:
3135
bd.set_branch_format(_load(branch_format))
3136
if tree_format is not None:
3137
bd.workingtree_format = _load(tree_format)
3138
if repository_format is not None:
3139
bd.repository_format = _load(repository_format)
3141
registry.register(key, helper, help, native, deprecated, hidden,
3142
experimental, alias)
3674
# Please register new formats after old formats so that formats
3675
# appear in chronological order and format descriptions can build
3677
format_registry = BzrDirFormatRegistry()
3144
3678
# The pre-0.8 formats have their repository format network name registered in
3145
3679
# repository.py. MetaDir formats have their repository format network name
3146
3680
# inferred from their disk format string.
3147
controldir.format_registry.register('weave', BzrDirFormat6,
3681
format_registry.register('weave', BzrDirFormat6,
3148
3682
'Pre-0.8 format. Slower than knit and does not'
3149
3683
' support checkouts or shared repositories.',
3151
3684
deprecated=True)
3152
register_metadir(controldir.format_registry, 'metaweave',
3685
format_registry.register_metadir('metaweave',
3153
3686
'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3154
3687
'Transitional format in 0.8. Slower than knit.',
3155
3688
branch_format='bzrlib.branch.BzrBranchFormat5',
3156
3689
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3158
3690
deprecated=True)
3159
register_metadir(controldir.format_registry, 'knit',
3691
format_registry.register_metadir('knit',
3160
3692
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3161
3693
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
3162
3694
branch_format='bzrlib.branch.BzrBranchFormat5',
3163
3695
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3165
3696
deprecated=True)
3166
register_metadir(controldir.format_registry, 'dirstate',
3697
format_registry.register_metadir('dirstate',
3167
3698
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3168
3699
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
3169
3700
'above when accessed over the network.',
3171
3702
# this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
3172
3703
# directly from workingtree_4 triggers a circular import.
3173
3704
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3175
3705
deprecated=True)
3176
register_metadir(controldir.format_registry, 'dirstate-tags',
3706
format_registry.register_metadir('dirstate-tags',
3177
3707
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3178
3708
help='New in 0.15: Fast local operations and improved scaling for '
3179
3709
'network operations. Additionally adds support for tags.'
3180
3710
' Incompatible with bzr < 0.15.',
3181
3711
branch_format='bzrlib.branch.BzrBranchFormat6',
3182
3712
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3184
3713
deprecated=True)
3185
register_metadir(controldir.format_registry, 'rich-root',
3714
format_registry.register_metadir('rich-root',
3186
3715
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
3187
3716
help='New in 1.0. Better handling of tree roots. Incompatible with'
3189
3718
branch_format='bzrlib.branch.BzrBranchFormat6',
3190
3719
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3192
3720
deprecated=True)
3193
register_metadir(controldir.format_registry, 'dirstate-with-subtree',
3721
format_registry.register_metadir('dirstate-with-subtree',
3194
3722
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
3195
3723
help='New in 0.15: Fast local operations and improved scaling for '
3196
3724
'network operations. Additionally adds support for versioning nested '
3200
3728
experimental=True,
3203
register_metadir(controldir.format_registry, 'pack-0.92',
3731
format_registry.register_metadir('pack-0.92',
3204
3732
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack1',
3205
3733
help='New in 0.92: Pack-based format with data compatible with '
3206
3734
'dirstate-tags format repositories. Interoperates with '
3207
3735
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3736
'Previously called knitpack-experimental. '
3737
'For more information, see '
3738
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3209
3739
branch_format='bzrlib.branch.BzrBranchFormat6',
3210
3740
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3212
register_metadir(controldir.format_registry, 'pack-0.92-subtree',
3742
format_registry.register_metadir('pack-0.92-subtree',
3213
3743
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack3',
3214
3744
help='New in 0.92: Pack-based format with data compatible with '
3215
3745
'dirstate-with-subtree format repositories. Interoperates with '
3216
3746
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3747
'Previously called knitpack-experimental. '
3748
'For more information, see '
3749
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3218
3750
branch_format='bzrlib.branch.BzrBranchFormat6',
3219
3751
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3221
3753
experimental=True,
3223
register_metadir(controldir.format_registry, 'rich-root-pack',
3755
format_registry.register_metadir('rich-root-pack',
3224
3756
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3225
3757
help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
3226
3758
'(needed for bzr-svn and bzr-git).',
3227
3759
branch_format='bzrlib.branch.BzrBranchFormat6',
3228
3760
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3231
register_metadir(controldir.format_registry, '1.6',
3762
format_registry.register_metadir('1.6',
3232
3763
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
3233
3764
help='A format that allows a branch to indicate that there is another '
3234
3765
'(stacked) repository that should be used to access data that is '
3235
3766
'not present locally.',
3236
3767
branch_format='bzrlib.branch.BzrBranchFormat7',
3237
3768
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3240
register_metadir(controldir.format_registry, '1.6.1-rich-root',
3770
format_registry.register_metadir('1.6.1-rich-root',
3241
3771
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
3242
3772
help='A variant of 1.6 that supports rich-root data '
3243
3773
'(needed for bzr-svn and bzr-git).',
3244
3774
branch_format='bzrlib.branch.BzrBranchFormat7',
3245
3775
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3248
register_metadir(controldir.format_registry, '1.9',
3777
format_registry.register_metadir('1.9',
3249
3778
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3250
3779
help='A repository format using B+tree indexes. These indexes '
3251
3780
'are smaller in size, have smarter caching and provide faster '
3252
3781
'performance for most operations.',
3253
3782
branch_format='bzrlib.branch.BzrBranchFormat7',
3254
3783
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3257
register_metadir(controldir.format_registry, '1.9-rich-root',
3785
format_registry.register_metadir('1.9-rich-root',
3258
3786
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3259
3787
help='A variant of 1.9 that supports rich-root data '
3260
3788
'(needed for bzr-svn and bzr-git).',
3261
3789
branch_format='bzrlib.branch.BzrBranchFormat7',
3262
3790
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3265
register_metadir(controldir.format_registry, '1.14',
3792
format_registry.register_metadir('1.14',
3266
3793
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3267
3794
help='A working-tree format that supports content filtering.',
3268
3795
branch_format='bzrlib.branch.BzrBranchFormat7',
3269
3796
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3271
register_metadir(controldir.format_registry, '1.14-rich-root',
3798
format_registry.register_metadir('1.14-rich-root',
3272
3799
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3273
3800
help='A variant of 1.14 that supports rich-root data '
3274
3801
'(needed for bzr-svn and bzr-git).',
3276
3803
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3278
3805
# The following un-numbered 'development' formats should always just be aliases.
3279
register_metadir(controldir.format_registry, 'development-rich-root',
3806
format_registry.register_metadir('development-rich-root',
3280
3807
'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3281
3808
help='Current development format. Supports rich roots. Can convert data '
3282
3809
'to and from rich-root-pack (and anything compatible with '
3283
3810
'rich-root-pack) format repositories. Repositories and branches in '
3284
3811
'this format can only be read by bzr.dev. Please read '
3285
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3812
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3287
3814
branch_format='bzrlib.branch.BzrBranchFormat7',
3288
3815
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3289
3816
experimental=True,
3293
register_metadir(controldir.format_registry, 'development-subtree',
3819
format_registry.register_metadir('development-subtree',
3294
3820
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3295
3821
help='Current development format, subtree variant. Can convert data to and '
3296
3822
'from pack-0.92-subtree (and anything compatible with '
3297
3823
'pack-0.92-subtree) format repositories. Repositories and branches in '
3298
3824
'this format can only be read by bzr.dev. Please read '
3299
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3825
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3301
3827
branch_format='bzrlib.branch.BzrBranchFormat7',
3302
3828
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3303
3829
experimental=True,
3305
3830
alias=False, # Restore to being an alias when an actual development subtree format is added
3306
3831
# This current non-alias status is simply because we did not introduce a
3307
3832
# chk based subtree format.
3310
3835
# And the development formats above will have aliased one of the following:
3311
register_metadir(controldir.format_registry, 'development6-rich-root',
3836
format_registry.register_metadir('development6-rich-root',
3312
3837
'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3313
3838
help='pack-1.9 with 255-way hashed CHK inv, group compress, rich roots '
3315
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3840
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3317
3842
branch_format='bzrlib.branch.BzrBranchFormat7',
3318
3843
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
added
removed
bzrlib/bzrdir.py
