350
363
except errors.NoRepositoryPresent:
353
return False, ([], repository)
354
return True, (bzrdir.list_branches(), None)
356
for branches, repo in BzrDir.find_bzrdirs(transport,
366
return False, (None, repository)
368
branch = bzrdir.open_branch()
369
except errors.NotBranchError:
370
return True, (None, None)
372
return True, (branch, None)
374
for branch, repo in BzrDir.find_bzrdirs(transport, evaluate=evaluate):
358
375
if repo is not None:
359
ret.extend(repo.find_branches())
360
if branches is not None:
376
branches.extend(repo.find_branches())
377
if branch is not None:
378
branches.append(branch)
381
def destroy_repository(self):
382
"""Destroy the repository in this BzrDir"""
383
raise NotImplementedError(self.destroy_repository)
385
def create_branch(self):
386
"""Create a branch in this BzrDir.
388
The bzrdir's format will control what branch format is created.
389
For more control see BranchFormatXX.create(a_bzrdir).
391
raise NotImplementedError(self.create_branch)
393
def destroy_branch(self):
394
"""Destroy the branch in this BzrDir"""
395
raise NotImplementedError(self.destroy_branch)
365
398
def create_branch_and_repo(base, force_new_repo=False, format=None):
515
548
format=format).bzrdir
516
549
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)
551
def create_workingtree(self, revision_id=None, from_branch=None,
552
accelerator_tree=None, hardlink=False):
553
"""Create a working tree at this BzrDir.
555
:param revision_id: create it as of this revision id.
556
:param from_branch: override bzrdir branch (for lightweight checkouts)
557
:param accelerator_tree: A tree which can be used for retrieving file
558
contents more quickly than the revision tree, i.e. a workingtree.
559
The revision tree will be used for cases where accelerator_tree's
560
content is different.
562
raise NotImplementedError(self.create_workingtree)
527
564
def backup_bzrdir(self):
528
565
"""Backup this bzr control directory.
530
567
:return: Tuple with old path name and new path name
533
backup_dir=self.generate_backup_name('backup.bzr')
534
569
pb = ui.ui_factory.nested_progress_bar()
536
571
# FIXME: bug 300001 -- the backup fails if the backup directory
537
572
# already exists, but it should instead either remove it or make
538
573
# a new backup directory.
575
# FIXME: bug 262450 -- the backup directory should have the same
576
# permissions as the .bzr directory (probably a bug in copy_tree)
540
577
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)
578
new_path = self.root_transport.abspath('backup.bzr')
579
pb.note('making backup of %s' % (old_path,))
580
pb.note(' to %s' % (new_path,))
581
self.root_transport.copy_tree('.bzr', 'backup.bzr')
544
582
return (old_path, new_path)
860
990
raise errors.NotBranchError(location)
861
991
return tree, branch, branch.repository, relpath
993
def open_repository(self, _unsupported=False):
994
"""Open the repository object at this BzrDir if one is present.
996
This will not follow the Branch object pointer - it's strictly a direct
997
open facility. Most client code should use open_branch().repository to
1000
:param _unsupported: a private parameter, not part of the api.
1001
TODO: static convenience version of this?
1003
raise NotImplementedError(self.open_repository)
1005
def open_workingtree(self, _unsupported=False,
1006
recommend_upgrade=True, from_branch=None):
1007
"""Open the workingtree object at this BzrDir if one is present.
1009
:param recommend_upgrade: Optional keyword parameter, when True (the
1010
default), emit through the ui module a recommendation that the user
1011
upgrade the working tree when the workingtree being opened is old
1012
(but still fully supported).
1013
:param from_branch: override bzrdir branch (for lightweight checkouts)
1015
raise NotImplementedError(self.open_workingtree)
1017
def has_branch(self):
1018
"""Tell if this bzrdir contains a branch.
1020
Note: if you're going to open the branch, you should just go ahead
1021
and try, and not ask permission first. (This method just opens the
1022
branch and discards it, and that's somewhat expensive.)
1027
except errors.NotBranchError:
1030
def has_workingtree(self):
1031
"""Tell if this bzrdir contains a working tree.
1033
This will still raise an exception if the bzrdir has a workingtree that
1034
is remote & inaccessible.
1036
Note: if you're going to open the working tree, you should just go ahead
1037
and try, and not ask permission first. (This method just opens the
1038
workingtree and discards it, and that's somewhat expensive.)
1041
self.open_workingtree(recommend_upgrade=False)
1043
except errors.NoWorkingTree:
863
1046
def _cloning_metadir(self):
864
1047
"""Produce a metadir suitable for cloning with.
923
1106
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.
1109
def checkout_metadir(self):
1110
return self.cloning_metadir()
1112
def sprout(self, url, revision_id=None, force_new_repo=False,
1113
recurse='down', possible_transports=None,
1114
accelerator_tree=None, hardlink=False, stacked=False,
1115
source_branch=None, create_tree_if_local=True):
1116
"""Create a copy of this bzrdir prepared for use as a new line of
1119
If url's last component does not exist, it will be created.
1121
Attributes related to the identity of the source branch like
1122
branch nickname will be cleaned, a working tree is created
1123
whether one existed before or not; and a local branch is always
1126
if revision_id is not None, then the clone operation may tune
1127
itself to download less data.
1128
:param accelerator_tree: A tree which can be used for retrieving file
1129
contents more quickly than the revision tree, i.e. a workingtree.
1130
The revision tree will be used for cases where accelerator_tree's
1131
content is different.
1132
:param hardlink: If true, hard-link files from accelerator_tree,
1134
:param stacked: If true, create a stacked branch referring to the
1135
location of this control directory.
1136
:param create_tree_if_local: If true, a working-tree will be created
1137
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)
1139
target_transport = get_transport(url, possible_transports)
1140
target_transport.ensure_base()
1141
cloning_format = self.cloning_metadir(stacked)
1142
# Create/update the result branch
1143
result = cloning_format.initialize_on_transport(target_transport)
1144
# if a stacked branch wasn't requested, we don't create one
1145
# even if the origin was stacked
1146
stacked_branch_url = None
1147
if source_branch is not None:
1149
stacked_branch_url = self.root_transport.base
1150
source_repository = source_branch.repository
1153
source_branch = self.open_branch()
1154
source_repository = source_branch.repository
1156
stacked_branch_url = self.root_transport.base
1157
except errors.NotBranchError:
1158
source_branch = None
1160
source_repository = self.open_repository()
1161
except errors.NoRepositoryPresent:
1162
source_repository = None
1163
repository_policy = result.determine_repository_policy(
1164
force_new_repo, stacked_branch_url, require_stacking=stacked)
1165
result_repo, is_new_repo = repository_policy.acquire_repository()
1166
if is_new_repo and revision_id is not None and not stacked:
1167
fetch_spec = graph.PendingAncestryResult(
1168
[revision_id], source_repository)
1171
if source_repository is not None:
1172
# Fetch while stacked to prevent unstacked fetch from
1174
if fetch_spec is None:
1175
result_repo.fetch(source_repository, revision_id=revision_id)
1177
result_repo.fetch(source_repository, fetch_spec=fetch_spec)
1179
if source_branch is None:
1180
# this is for sprouting a bzrdir without a branch; is that
1182
# Not especially, but it's part of the contract.
1183
result_branch = result.create_branch()
1185
result_branch = source_branch.sprout(result,
1186
revision_id=revision_id, repository_policy=repository_policy)
1187
mutter("created new branch %r" % (result_branch,))
1189
# Create/update the result working tree
1190
if (create_tree_if_local and
1191
isinstance(target_transport, local.LocalTransport) and
1192
(result_repo is None or result_repo.make_working_trees())):
1193
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
1197
if wt.path2id('') is None:
1199
wt.set_root_id(self.open_workingtree.get_root_id())
1200
except errors.NoWorkingTree:
1206
if recurse == 'down':
1208
basis = wt.basis_tree()
1210
subtrees = basis.iter_references()
1211
elif result_branch is not None:
1212
basis = result_branch.basis_tree()
1214
subtrees = basis.iter_references()
1215
elif source_branch is not None:
1216
basis = source_branch.basis_tree()
1218
subtrees = basis.iter_references()
1223
for path, file_id in subtrees:
1224
target = urlutils.join(url, urlutils.escape(path))
1225
sublocation = source_branch.reference_parent(file_id, path)
1226
sublocation.bzrdir.sprout(target,
1227
basis.get_reference_revision(file_id, path),
1228
force_new_repo=force_new_repo, recurse=recurse,
1231
if basis is not None:
1235
def push_branch(self, source, revision_id=None, overwrite=False,
1236
remember=False, create_prefix=False):
1237
"""Push the source branch into this BzrDir."""
1239
# If we can open a branch, use its direct repository, otherwise see
1240
# if there is a repository without a branch.
1242
br_to = self.open_branch()
1243
except errors.NotBranchError:
1244
# Didn't find a branch, can we find a repository?
1245
repository_to = self.find_repository()
1247
# Found a branch, so we must have found a repository
1248
repository_to = br_to.repository
1250
push_result = PushResult()
1251
push_result.source_branch = source
1253
# We have a repository but no branch, copy the revisions, and then
1255
repository_to.fetch(source.repository, revision_id=revision_id)
1256
br_to = source.clone(self, revision_id=revision_id)
1257
if source.get_push_location() is None or remember:
1258
source.set_push_location(br_to.base)
1259
push_result.stacked_on = None
1260
push_result.branch_push_result = None
1261
push_result.old_revno = None
1262
push_result.old_revid = _mod_revision.NULL_REVISION
1263
push_result.target_branch = br_to
1264
push_result.master_branch = None
1265
push_result.workingtree_updated = False
1267
# We have successfully opened the branch, remember if necessary:
1268
if source.get_push_location() is None or remember:
1269
source.set_push_location(br_to.base)
1271
tree_to = self.open_workingtree()
1272
except errors.NotLocalUrl:
1273
push_result.branch_push_result = source.push(br_to,
1274
overwrite, stop_revision=revision_id)
1275
push_result.workingtree_updated = False
1276
except errors.NoWorkingTree:
1277
push_result.branch_push_result = source.push(br_to,
1278
overwrite, stop_revision=revision_id)
1279
push_result.workingtree_updated = None # Not applicable
1281
tree_to.lock_write()
1283
push_result.branch_push_result = source.push(
1284
tree_to.branch, overwrite, stop_revision=revision_id)
1288
push_result.workingtree_updated = True
1289
push_result.old_revno = push_result.branch_push_result.old_revno
1290
push_result.old_revid = push_result.branch_push_result.old_revid
1291
push_result.target_branch = \
1292
push_result.branch_push_result.target_branch
946
1296
class BzrDirHooks(hooks.Hooks):
952
1302
self.create_hook(hooks.HookPoint('pre_open',
953
1303
"Invoked before attempting to open a BzrDir with the transport "
954
1304
"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
1306
# install the default hooks
962
1307
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
1310
class BzrDirPreSplitOut(BzrDir):
1002
1311
"""A common class for the all-in-one formats."""
1459
1732
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.
1735
class BzrDirFormat(object):
1736
"""An encapsulation of the initialization and open routines for a format.
1738
Formats provide three things:
1739
* An initialization routine,
1523
1743
Formats are placed in a dict by their format string for reference
1524
1744
during bzrdir opening. These should be subclasses of BzrDirFormat
1529
1749
object will be created every system load.
1752
_default_format = None
1753
"""The default format used for new .bzr dirs."""
1756
"""The known formats."""
1758
_control_formats = []
1759
"""The registered control formats - .bzr, ....
1761
This is a list of BzrDirFormat objects.
1764
_control_server_formats = []
1765
"""The registered control server formats, e.g. RemoteBzrDirs.
1767
This is a list of BzrDirFormat objects.
1532
1770
_lock_file_name = 'branch-lock'
1534
1772
# _lock_class must be set in subclasses to the lock type, typ.
1535
1773
# TransportLock or LockDir
1776
def find_format(klass, transport, _server_formats=True):
1777
"""Return the format present at transport."""
1779
formats = klass._control_server_formats + klass._control_formats
1781
formats = klass._control_formats
1782
for format in formats:
1784
return format.probe_transport(transport)
1785
except errors.NotBranchError:
1786
# this format does not find a control dir here.
1788
raise errors.NotBranchError(path=transport.base)
1791
def probe_transport(klass, transport):
1792
"""Return the .bzrdir style format present in a directory."""
1794
format_string = transport.get(".bzr/branch-format").read()
1795
except errors.NoSuchFile:
1796
raise errors.NotBranchError(path=transport.base)
1799
return klass._formats[format_string]
1801
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1804
def get_default_format(klass):
1805
"""Return the current default format."""
1806
return klass._default_format
1537
1808
def get_format_string(self):
1538
1809
"""Return the ASCII format string that identifies this format."""
1539
1810
raise NotImplementedError(self.get_format_string)
1812
def get_format_description(self):
1813
"""Return the short description for this format."""
1814
raise NotImplementedError(self.get_format_description)
1816
def get_converter(self, format=None):
1817
"""Return the converter to use to convert bzrdirs needing converts.
1819
This returns a bzrlib.bzrdir.Converter object.
1821
This should return the best upgrader to step this format towards the
1822
current default format. In the case of plugins we can/should provide
1823
some means for them to extend the range of returnable converters.
1825
:param format: Optional format to override the default format of the
1828
raise NotImplementedError(self.get_converter)
1830
def initialize(self, url, possible_transports=None):
1831
"""Create a bzr control dir at this url and return an opened copy.
1833
While not deprecated, this method is very specific and its use will
1834
lead to many round trips to setup a working environment. See
1835
initialize_on_transport_ex for a [nearly] all-in-one method.
1837
Subclasses should typically override initialize_on_transport
1838
instead of this method.
1840
return self.initialize_on_transport(get_transport(url,
1841
possible_transports))
1541
1843
def initialize_on_transport(self, transport):
1542
1844
"""Initialize a new bzrdir in the base directory of a Transport."""
1691
1993
control_files.unlock()
1692
1994
return self.open(transport, _found=True)
1996
def is_supported(self):
1997
"""Is this format supported?
1999
Supported formats must be initializable and openable.
2000
Unsupported formats may not support initialization or committing or
2001
some other features depending on the reason for not being supported.
2005
def network_name(self):
2006
"""A simple byte string uniquely identifying this format for RPC calls.
2008
Bzr control formats use thir disk format string to identify the format
2009
over the wire. Its possible that other control formats have more
2010
complex detection requirements, so we permit them to use any unique and
2011
immutable string they desire.
2013
raise NotImplementedError(self.network_name)
2015
def same_model(self, target_format):
2016
return (self.repository_format.rich_root_data ==
2017
target_format.rich_root_data)
2020
def known_formats(klass):
2021
"""Return all the known formats.
2023
Concrete formats should override _known_formats.
2025
# There is double indirection here to make sure that control
2026
# formats used by more than one dir format will only be probed
2027
# once. This can otherwise be quite expensive for remote connections.
2029
for format in klass._control_formats:
2030
result.update(format._known_formats())
2034
def _known_formats(klass):
2035
"""Return the known format instances for this control format."""
2036
return set(klass._formats.values())
1694
2038
def open(self, transport, _found=False):
1695
2039
"""Return an instance of this format for the dir transport points at.
1697
2041
_found is a private parameter, do not use it.
1700
found_format = controldir.ControlDirFormat.find_format(transport)
2044
found_format = BzrDirFormat.find_format(transport)
1701
2045
if not isinstance(found_format, self.__class__):
1702
2046
raise AssertionError("%s was asked to open %s, but it seems to need "
2934
3314
BzrDirMetaFormat1._set_repository_format) #.im_func)
2937
controldir.ControlDirFormat.register_server_prober(RemoteBzrProber)
3317
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
3320
class BzrDirFormatInfo(object):
3322
def __init__(self, native, deprecated, hidden, experimental):
3323
self.deprecated = deprecated
3324
self.native = native
3325
self.hidden = hidden
3326
self.experimental = experimental
3329
class BzrDirFormatRegistry(registry.Registry):
3330
"""Registry of user-selectable BzrDir subformats.
3332
Differs from BzrDirFormat._control_formats in that it provides sub-formats,
3333
e.g. BzrDirMeta1 with weave repository. Also, it's more user-oriented.
3337
"""Create a BzrDirFormatRegistry."""
3338
self._aliases = set()
3339
self._registration_order = list()
3340
super(BzrDirFormatRegistry, self).__init__()
3343
"""Return a set of the format names which are aliases."""
3344
return frozenset(self._aliases)
3346
def register_metadir(self, key,
3347
repository_format, help, native=True, deprecated=False,
3353
"""Register a metadir subformat.
3355
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
3356
by the Repository/Branch/WorkingTreeformats.
3358
:param repository_format: The fully-qualified repository format class
3360
:param branch_format: Fully-qualified branch format class name as
3362
:param tree_format: Fully-qualified tree format class name as
3365
# This should be expanded to support setting WorkingTree and Branch
3366
# formats, once BzrDirMetaFormat1 supports that.
3367
def _load(full_name):
3368
mod_name, factory_name = full_name.rsplit('.', 1)
3370
mod = __import__(mod_name, globals(), locals(),
3372
except ImportError, e:
3373
raise ImportError('failed to load %s: %s' % (full_name, e))
3375
factory = getattr(mod, factory_name)
3376
except AttributeError:
3377
raise AttributeError('no factory %s in module %r'
3382
bd = BzrDirMetaFormat1()
3383
if branch_format is not None:
3384
bd.set_branch_format(_load(branch_format))
3385
if tree_format is not None:
3386
bd.workingtree_format = _load(tree_format)
3387
if repository_format is not None:
3388
bd.repository_format = _load(repository_format)
3390
self.register(key, helper, help, native, deprecated, hidden,
3391
experimental, alias)
3393
def register(self, key, factory, help, native=True, deprecated=False,
3394
hidden=False, experimental=False, alias=False):
3395
"""Register a BzrDirFormat factory.
3397
The factory must be a callable that takes one parameter: the key.
3398
It must produce an instance of the BzrDirFormat when called.
3400
This function mainly exists to prevent the info object from being
3403
registry.Registry.register(self, key, factory, help,
3404
BzrDirFormatInfo(native, deprecated, hidden, experimental))
3406
self._aliases.add(key)
3407
self._registration_order.append(key)
3409
def register_lazy(self, key, module_name, member_name, help, native=True,
3410
deprecated=False, hidden=False, experimental=False, alias=False):
3411
registry.Registry.register_lazy(self, key, module_name, member_name,
3412
help, BzrDirFormatInfo(native, deprecated, hidden, experimental))
3414
self._aliases.add(key)
3415
self._registration_order.append(key)
3417
def set_default(self, key):
3418
"""Set the 'default' key to be a clone of the supplied key.
3420
This method must be called once and only once.
3422
registry.Registry.register(self, 'default', self.get(key),
3423
self.get_help(key), info=self.get_info(key))
3424
self._aliases.add('default')
3426
def set_default_repository(self, key):
3427
"""Set the FormatRegistry default and Repository default.
3429
This is a transitional method while Repository.set_default_format
3432
if 'default' in self:
3433
self.remove('default')
3434
self.set_default(key)
3435
format = self.get('default')()
3437
def make_bzrdir(self, key):
3438
return self.get(key)()
3440
def help_topic(self, topic):
3442
default_realkey = None
3443
default_help = self.get_help('default')
3445
for key in self._registration_order:
3446
if key == 'default':
3448
help = self.get_help(key)
3449
if help == default_help:
3450
default_realkey = key
3452
help_pairs.append((key, help))
3454
def wrapped(key, help, info):
3456
help = '(native) ' + help
3457
return ':%s:\n%s\n\n' % (key,
3458
textwrap.fill(help, initial_indent=' ',
3459
subsequent_indent=' ',
3460
break_long_words=False))
3461
if default_realkey is not None:
3462
output += wrapped(default_realkey, '(default) %s' % default_help,
3463
self.get_info('default'))
3464
deprecated_pairs = []
3465
experimental_pairs = []
3466
for key, help in help_pairs:
3467
info = self.get_info(key)
3470
elif info.deprecated:
3471
deprecated_pairs.append((key, help))
3472
elif info.experimental:
3473
experimental_pairs.append((key, help))
3475
output += wrapped(key, help, info)
3476
output += "\nSee ``bzr help formats`` for more about storage formats."
3478
if len(experimental_pairs) > 0:
3479
other_output += "Experimental formats are shown below.\n\n"
3480
for key, help in experimental_pairs:
3481
info = self.get_info(key)
3482
other_output += wrapped(key, help, info)
3485
"No experimental formats are available.\n\n"
3486
if len(deprecated_pairs) > 0:
3487
other_output += "\nDeprecated formats are shown below.\n\n"
3488
for key, help in deprecated_pairs:
3489
info = self.get_info(key)
3490
other_output += wrapped(key, help, info)
3493
"\nNo deprecated formats are available.\n\n"
3495
"\nSee ``bzr help formats`` for more about storage formats."
3497
if topic == 'other-formats':
2940
3503
class RepositoryAcquisitionPolicy(object):
3094
3653
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)
3656
# Please register new formats after old formats so that formats
3657
# appear in chronological order and format descriptions can build
3659
format_registry = BzrDirFormatRegistry()
3144
3660
# The pre-0.8 formats have their repository format network name registered in
3145
3661
# repository.py. MetaDir formats have their repository format network name
3146
3662
# inferred from their disk format string.
3147
controldir.format_registry.register('weave', BzrDirFormat6,
3663
format_registry.register('weave', BzrDirFormat6,
3148
3664
'Pre-0.8 format. Slower than knit and does not'
3149
3665
' support checkouts or shared repositories.',
3151
3666
deprecated=True)
3152
register_metadir(controldir.format_registry, 'metaweave',
3667
format_registry.register_metadir('metaweave',
3153
3668
'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3154
3669
'Transitional format in 0.8. Slower than knit.',
3155
3670
branch_format='bzrlib.branch.BzrBranchFormat5',
3156
3671
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3158
3672
deprecated=True)
3159
register_metadir(controldir.format_registry, 'knit',
3673
format_registry.register_metadir('knit',
3160
3674
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3161
3675
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
3162
3676
branch_format='bzrlib.branch.BzrBranchFormat5',
3163
3677
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3165
3678
deprecated=True)
3166
register_metadir(controldir.format_registry, 'dirstate',
3679
format_registry.register_metadir('dirstate',
3167
3680
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3168
3681
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
3169
3682
'above when accessed over the network.',
3171
3684
# this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
3172
3685
# directly from workingtree_4 triggers a circular import.
3173
3686
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3175
3687
deprecated=True)
3176
register_metadir(controldir.format_registry, 'dirstate-tags',
3688
format_registry.register_metadir('dirstate-tags',
3177
3689
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3178
3690
help='New in 0.15: Fast local operations and improved scaling for '
3179
3691
'network operations. Additionally adds support for tags.'
3180
3692
' Incompatible with bzr < 0.15.',
3181
3693
branch_format='bzrlib.branch.BzrBranchFormat6',
3182
3694
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3184
3695
deprecated=True)
3185
register_metadir(controldir.format_registry, 'rich-root',
3696
format_registry.register_metadir('rich-root',
3186
3697
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
3187
3698
help='New in 1.0. Better handling of tree roots. Incompatible with'
3189
3700
branch_format='bzrlib.branch.BzrBranchFormat6',
3190
3701
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3192
3702
deprecated=True)
3193
register_metadir(controldir.format_registry, 'dirstate-with-subtree',
3703
format_registry.register_metadir('dirstate-with-subtree',
3194
3704
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
3195
3705
help='New in 0.15: Fast local operations and improved scaling for '
3196
3706
'network operations. Additionally adds support for versioning nested '
3200
3710
experimental=True,
3203
register_metadir(controldir.format_registry, 'pack-0.92',
3713
format_registry.register_metadir('pack-0.92',
3204
3714
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack1',
3205
3715
help='New in 0.92: Pack-based format with data compatible with '
3206
3716
'dirstate-tags format repositories. Interoperates with '
3207
3717
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3718
'Previously called knitpack-experimental. '
3719
'For more information, see '
3720
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3209
3721
branch_format='bzrlib.branch.BzrBranchFormat6',
3210
3722
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3212
register_metadir(controldir.format_registry, 'pack-0.92-subtree',
3724
format_registry.register_metadir('pack-0.92-subtree',
3213
3725
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack3',
3214
3726
help='New in 0.92: Pack-based format with data compatible with '
3215
3727
'dirstate-with-subtree format repositories. Interoperates with '
3216
3728
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3729
'Previously called knitpack-experimental. '
3730
'For more information, see '
3731
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3218
3732
branch_format='bzrlib.branch.BzrBranchFormat6',
3219
3733
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3221
3735
experimental=True,
3223
register_metadir(controldir.format_registry, 'rich-root-pack',
3737
format_registry.register_metadir('rich-root-pack',
3224
3738
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3225
3739
help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
3226
3740
'(needed for bzr-svn and bzr-git).',
3227
3741
branch_format='bzrlib.branch.BzrBranchFormat6',
3228
3742
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3231
register_metadir(controldir.format_registry, '1.6',
3744
format_registry.register_metadir('1.6',
3232
3745
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
3233
3746
help='A format that allows a branch to indicate that there is another '
3234
3747
'(stacked) repository that should be used to access data that is '
3235
3748
'not present locally.',
3236
3749
branch_format='bzrlib.branch.BzrBranchFormat7',
3237
3750
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3240
register_metadir(controldir.format_registry, '1.6.1-rich-root',
3752
format_registry.register_metadir('1.6.1-rich-root',
3241
3753
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
3242
3754
help='A variant of 1.6 that supports rich-root data '
3243
3755
'(needed for bzr-svn and bzr-git).',
3244
3756
branch_format='bzrlib.branch.BzrBranchFormat7',
3245
3757
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3248
register_metadir(controldir.format_registry, '1.9',
3759
format_registry.register_metadir('1.9',
3249
3760
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3250
3761
help='A repository format using B+tree indexes. These indexes '
3251
3762
'are smaller in size, have smarter caching and provide faster '
3252
3763
'performance for most operations.',
3253
3764
branch_format='bzrlib.branch.BzrBranchFormat7',
3254
3765
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3257
register_metadir(controldir.format_registry, '1.9-rich-root',
3767
format_registry.register_metadir('1.9-rich-root',
3258
3768
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3259
3769
help='A variant of 1.9 that supports rich-root data '
3260
3770
'(needed for bzr-svn and bzr-git).',
3261
3771
branch_format='bzrlib.branch.BzrBranchFormat7',
3262
3772
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3265
register_metadir(controldir.format_registry, '1.14',
3774
format_registry.register_metadir('1.14',
3266
3775
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3267
3776
help='A working-tree format that supports content filtering.',
3268
3777
branch_format='bzrlib.branch.BzrBranchFormat7',
3269
3778
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3271
register_metadir(controldir.format_registry, '1.14-rich-root',
3780
format_registry.register_metadir('1.14-rich-root',
3272
3781
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3273
3782
help='A variant of 1.14 that supports rich-root data '
3274
3783
'(needed for bzr-svn and bzr-git).',
3276
3785
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3278
3787
# The following un-numbered 'development' formats should always just be aliases.
3279
register_metadir(controldir.format_registry, 'development-rich-root',
3788
format_registry.register_metadir('development-rich-root',
3280
3789
'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3281
3790
help='Current development format. Supports rich roots. Can convert data '
3282
3791
'to and from rich-root-pack (and anything compatible with '
3283
3792
'rich-root-pack) format repositories. Repositories and branches in '
3284
3793
'this format can only be read by bzr.dev. Please read '
3285
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3794
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3287
3796
branch_format='bzrlib.branch.BzrBranchFormat7',
3288
3797
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3289
3798
experimental=True,
3293
register_metadir(controldir.format_registry, 'development-subtree',
3801
format_registry.register_metadir('development-subtree',
3294
3802
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3295
3803
help='Current development format, subtree variant. Can convert data to and '
3296
3804
'from pack-0.92-subtree (and anything compatible with '
3297
3805
'pack-0.92-subtree) format repositories. Repositories and branches in '
3298
3806
'this format can only be read by bzr.dev. Please read '
3299
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3807
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3301
3809
branch_format='bzrlib.branch.BzrBranchFormat7',
3302
3810
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3303
3811
experimental=True,
3305
3812
alias=False, # Restore to being an alias when an actual development subtree format is added
3306
3813
# This current non-alias status is simply because we did not introduce a
3307
3814
# chk based subtree format.
3310
3817
# And the development formats above will have aliased one of the following:
3311
register_metadir(controldir.format_registry, 'development6-rich-root',
3818
format_registry.register_metadir('development6-rich-root',
3312
3819
'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3313
3820
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 '
3822
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3317
3824
branch_format='bzrlib.branch.BzrBranchFormat7',
3318
3825
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
added
removed
bzrlib/bzrdir.py
