331
364
except errors.NoRepositoryPresent:
334
return False, ([], repository)
335
return True, (bzrdir.list_branches(), None)
337
for branches, repo in BzrDir.find_bzrdirs(transport,
367
return False, (None, repository)
369
branch = bzrdir.open_branch()
370
except errors.NotBranchError:
371
return True, (None, None)
373
return True, (branch, None)
375
for branch, repo in BzrDir.find_bzrdirs(transport, evaluate=evaluate):
339
376
if repo is not None:
340
ret.extend(repo.find_branches())
341
if branches is not None:
377
branches.extend(repo.find_branches())
378
if branch is not None:
379
branches.append(branch)
382
def destroy_repository(self):
383
"""Destroy the repository in this BzrDir"""
384
raise NotImplementedError(self.destroy_repository)
386
def create_branch(self):
387
"""Create a branch in this BzrDir.
389
The bzrdir's format will control what branch format is created.
390
For more control see BranchFormatXX.create(a_bzrdir).
392
raise NotImplementedError(self.create_branch)
394
def destroy_branch(self):
395
"""Destroy the branch in this BzrDir"""
396
raise NotImplementedError(self.destroy_branch)
346
399
def create_branch_and_repo(base, force_new_repo=False, format=None):
496
549
format=format).bzrdir
497
550
return bzrdir.create_workingtree()
499
def generate_backup_name(self, base):
500
"""Generate a non-existing backup file name based on base."""
502
name = "%s.~%d~" % (base, counter)
503
while self.root_transport.has(name):
505
name = "%s.~%d~" % (base, counter)
552
def create_workingtree(self, revision_id=None, from_branch=None,
553
accelerator_tree=None, hardlink=False):
554
"""Create a working tree at this BzrDir.
556
:param revision_id: create it as of this revision id.
557
:param from_branch: override bzrdir branch (for lightweight checkouts)
558
:param accelerator_tree: A tree which can be used for retrieving file
559
contents more quickly than the revision tree, i.e. a workingtree.
560
The revision tree will be used for cases where accelerator_tree's
561
content is different.
563
raise NotImplementedError(self.create_workingtree)
508
565
def backup_bzrdir(self):
509
566
"""Backup this bzr control directory.
511
568
:return: Tuple with old path name and new path name
514
backup_dir=self.generate_backup_name('backup.bzr')
515
570
pb = ui.ui_factory.nested_progress_bar()
517
572
# FIXME: bug 300001 -- the backup fails if the backup directory
518
573
# already exists, but it should instead either remove it or make
519
574
# a new backup directory.
576
# FIXME: bug 262450 -- the backup directory should have the same
577
# permissions as the .bzr directory (probably a bug in copy_tree)
521
578
old_path = self.root_transport.abspath('.bzr')
522
new_path = self.root_transport.abspath(backup_dir)
523
ui.ui_factory.note('making backup of %s\n to %s' % (old_path, new_path,))
524
self.root_transport.copy_tree('.bzr', backup_dir)
579
new_path = self.root_transport.abspath('backup.bzr')
580
pb.note('making backup of %s' % (old_path,))
581
pb.note(' to %s' % (new_path,))
582
self.root_transport.copy_tree('.bzr', 'backup.bzr')
525
583
return (old_path, new_path)
841
991
raise errors.NotBranchError(location)
842
992
return tree, branch, branch.repository, relpath
994
def open_repository(self, _unsupported=False):
995
"""Open the repository object at this BzrDir if one is present.
997
This will not follow the Branch object pointer - it's strictly a direct
998
open facility. Most client code should use open_branch().repository to
1001
:param _unsupported: a private parameter, not part of the api.
1002
TODO: static convenience version of this?
1004
raise NotImplementedError(self.open_repository)
1006
def open_workingtree(self, _unsupported=False,
1007
recommend_upgrade=True, from_branch=None):
1008
"""Open the workingtree object at this BzrDir if one is present.
1010
:param recommend_upgrade: Optional keyword parameter, when True (the
1011
default), emit through the ui module a recommendation that the user
1012
upgrade the working tree when the workingtree being opened is old
1013
(but still fully supported).
1014
:param from_branch: override bzrdir branch (for lightweight checkouts)
1016
raise NotImplementedError(self.open_workingtree)
1018
def has_branch(self):
1019
"""Tell if this bzrdir contains a branch.
1021
Note: if you're going to open the branch, you should just go ahead
1022
and try, and not ask permission first. (This method just opens the
1023
branch and discards it, and that's somewhat expensive.)
1028
except errors.NotBranchError:
1031
def has_workingtree(self):
1032
"""Tell if this bzrdir contains a working tree.
1034
This will still raise an exception if the bzrdir has a workingtree that
1035
is remote & inaccessible.
1037
Note: if you're going to open the working tree, you should just go ahead
1038
and try, and not ask permission first. (This method just opens the
1039
workingtree and discards it, and that's somewhat expensive.)
1042
self.open_workingtree(recommend_upgrade=False)
1044
except errors.NoWorkingTree:
844
1047
def _cloning_metadir(self):
845
1048
"""Produce a metadir suitable for cloning with.
904
1107
format.require_stacking()
908
def create(cls, base, format=None, possible_transports=None):
909
"""Create a new BzrDir at the url 'base'.
911
:param format: If supplied, the format of branch to create. If not
912
supplied, the default is used.
913
:param possible_transports: If supplied, a list of transports that
914
can be reused to share a remote connection.
1110
def checkout_metadir(self):
1111
return self.cloning_metadir()
1113
def sprout(self, url, revision_id=None, force_new_repo=False,
1114
recurse='down', possible_transports=None,
1115
accelerator_tree=None, hardlink=False, stacked=False,
1116
source_branch=None, create_tree_if_local=True):
1117
"""Create a copy of this bzrdir prepared for use as a new line of
1120
If url's last component does not exist, it will be created.
1122
Attributes related to the identity of the source branch like
1123
branch nickname will be cleaned, a working tree is created
1124
whether one existed before or not; and a local branch is always
1127
if revision_id is not None, then the clone operation may tune
1128
itself to download less data.
1129
:param accelerator_tree: A tree which can be used for retrieving file
1130
contents more quickly than the revision tree, i.e. a workingtree.
1131
The revision tree will be used for cases where accelerator_tree's
1132
content is different.
1133
:param hardlink: If true, hard-link files from accelerator_tree,
1135
:param stacked: If true, create a stacked branch referring to the
1136
location of this control directory.
1137
:param create_tree_if_local: If true, a working-tree will be created
1138
when working locally.
916
if cls is not BzrDir:
917
raise AssertionError("BzrDir.create always creates the"
918
"default format, not one of %r" % cls)
919
t = get_transport(base, possible_transports)
922
format = controldir.ControlDirFormat.get_default_format()
923
return format.initialize_on_transport(t)
1140
target_transport = get_transport(url, possible_transports)
1141
target_transport.ensure_base()
1142
cloning_format = self.cloning_metadir(stacked)
1143
# Create/update the result branch
1144
result = cloning_format.initialize_on_transport(target_transport)
1145
# if a stacked branch wasn't requested, we don't create one
1146
# even if the origin was stacked
1147
stacked_branch_url = None
1148
if source_branch is not None:
1150
stacked_branch_url = self.root_transport.base
1151
source_repository = source_branch.repository
1154
source_branch = self.open_branch()
1155
source_repository = source_branch.repository
1157
stacked_branch_url = self.root_transport.base
1158
except errors.NotBranchError:
1159
source_branch = None
1161
source_repository = self.open_repository()
1162
except errors.NoRepositoryPresent:
1163
source_repository = None
1164
repository_policy = result.determine_repository_policy(
1165
force_new_repo, stacked_branch_url, require_stacking=stacked)
1166
result_repo, is_new_repo = repository_policy.acquire_repository()
1167
if is_new_repo and revision_id is not None and not stacked:
1168
fetch_spec = graph.PendingAncestryResult(
1169
[revision_id], source_repository)
1172
if source_repository is not None:
1173
# Fetch while stacked to prevent unstacked fetch from
1175
if fetch_spec is None:
1176
result_repo.fetch(source_repository, revision_id=revision_id)
1178
result_repo.fetch(source_repository, fetch_spec=fetch_spec)
1180
if source_branch is None:
1181
# this is for sprouting a bzrdir without a branch; is that
1183
# Not especially, but it's part of the contract.
1184
result_branch = result.create_branch()
1186
result_branch = source_branch.sprout(result,
1187
revision_id=revision_id, repository_policy=repository_policy)
1188
mutter("created new branch %r" % (result_branch,))
1190
# Create/update the result working tree
1191
if (create_tree_if_local and
1192
isinstance(target_transport, local.LocalTransport) and
1193
(result_repo is None or result_repo.make_working_trees())):
1194
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
1198
if wt.path2id('') is None:
1200
wt.set_root_id(self.open_workingtree.get_root_id())
1201
except errors.NoWorkingTree:
1207
if recurse == 'down':
1209
basis = wt.basis_tree()
1211
subtrees = basis.iter_references()
1212
elif result_branch is not None:
1213
basis = result_branch.basis_tree()
1215
subtrees = basis.iter_references()
1216
elif source_branch is not None:
1217
basis = source_branch.basis_tree()
1219
subtrees = basis.iter_references()
1224
for path, file_id in subtrees:
1225
target = urlutils.join(url, urlutils.escape(path))
1226
sublocation = source_branch.reference_parent(file_id, path)
1227
sublocation.bzrdir.sprout(target,
1228
basis.get_reference_revision(file_id, path),
1229
force_new_repo=force_new_repo, recurse=recurse,
1232
if basis is not None:
1236
def push_branch(self, source, revision_id=None, overwrite=False,
1238
"""Push the source branch into this BzrDir."""
1240
# If we can open a branch, use its direct repository, otherwise see
1241
# if there is a repository without a branch.
1243
br_to = self.open_branch()
1244
except errors.NotBranchError:
1245
# Didn't find a branch, can we find a repository?
1246
repository_to = self.find_repository()
1248
# Found a branch, so we must have found a repository
1249
repository_to = br_to.repository
1251
push_result = PushResult()
1252
push_result.source_branch = source
1254
# We have a repository but no branch, copy the revisions, and then
1256
repository_to.fetch(source.repository, revision_id=revision_id)
1257
br_to = source.clone(self, revision_id=revision_id)
1258
if source.get_push_location() is None or remember:
1259
source.set_push_location(br_to.base)
1260
push_result.stacked_on = None
1261
push_result.branch_push_result = None
1262
push_result.old_revno = None
1263
push_result.old_revid = _mod_revision.NULL_REVISION
1264
push_result.target_branch = br_to
1265
push_result.master_branch = None
1266
push_result.workingtree_updated = False
1268
# We have successfully opened the branch, remember if necessary:
1269
if source.get_push_location() is None or remember:
1270
source.set_push_location(br_to.base)
1272
tree_to = self.open_workingtree()
1273
except errors.NotLocalUrl:
1274
push_result.branch_push_result = source.push(br_to,
1275
overwrite, stop_revision=revision_id)
1276
push_result.workingtree_updated = False
1277
except errors.NoWorkingTree:
1278
push_result.branch_push_result = source.push(br_to,
1279
overwrite, stop_revision=revision_id)
1280
push_result.workingtree_updated = None # Not applicable
1282
tree_to.lock_write()
1284
push_result.branch_push_result = source.push(
1285
tree_to.branch, overwrite, stop_revision=revision_id)
1289
push_result.workingtree_updated = True
1290
push_result.old_revno = push_result.branch_push_result.old_revno
1291
push_result.old_revid = push_result.branch_push_result.old_revid
1292
push_result.target_branch = \
1293
push_result.branch_push_result.target_branch
927
1297
class BzrDirHooks(hooks.Hooks):
933
1303
self.create_hook(hooks.HookPoint('pre_open',
934
1304
"Invoked before attempting to open a BzrDir with the transport "
935
1305
"that the open will use.", (1, 14), None))
936
self.create_hook(hooks.HookPoint('post_repo_init',
937
"Invoked after a repository has been initialized. "
938
"post_repo_init is called with a "
939
"bzrlib.bzrdir.RepoInitHookParams.",
942
1307
# install the default hooks
943
1308
BzrDir.hooks = BzrDirHooks()
946
class RepoInitHookParams(object):
947
"""Object holding parameters passed to *_repo_init hooks.
949
There are 4 fields that hooks may wish to access:
951
:ivar repository: Repository created
952
:ivar format: Repository format
953
:ivar bzrdir: The bzrdir for the repository
954
:ivar shared: The repository is shared
957
def __init__(self, repository, format, a_bzrdir, shared):
958
"""Create a group of RepoInitHook parameters.
960
:param repository: Repository created
961
:param format: Repository format
962
:param bzrdir: The bzrdir for the repository
963
:param shared: The repository is shared
965
self.repository = repository
967
self.bzrdir = a_bzrdir
970
def __eq__(self, other):
971
return self.__dict__ == other.__dict__
975
return "<%s for %s>" % (self.__class__.__name__,
978
return "<%s for %s>" % (self.__class__.__name__,
982
1311
class BzrDirPreSplitOut(BzrDir):
983
1312
"""A common class for the all-in-one formats."""
1440
1733
return config.TransportConfig(self.transport, 'control.conf')
1443
class BzrProber(controldir.Prober):
1444
"""Prober for formats that use a .bzr/ control directory."""
1447
"""The known .bzr formats."""
1450
def register_bzrdir_format(klass, format):
1451
klass._formats[format.get_format_string()] = format
1454
def unregister_bzrdir_format(klass, format):
1455
del klass._formats[format.get_format_string()]
1458
def probe_transport(klass, transport):
1459
"""Return the .bzrdir style format present in a directory."""
1461
format_string = transport.get_bytes(".bzr/branch-format")
1462
except errors.NoSuchFile:
1463
raise errors.NotBranchError(path=transport.base)
1465
return klass._formats[format_string]
1467
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1470
controldir.ControlDirFormat.register_prober(BzrProber)
1473
class RemoteBzrProber(controldir.Prober):
1474
"""Prober for remote servers that provide a Bazaar smart server."""
1477
def probe_transport(klass, transport):
1478
"""Return a RemoteBzrDirFormat object if it looks possible."""
1480
medium = transport.get_smart_medium()
1481
except (NotImplementedError, AttributeError,
1482
errors.TransportNotPossible, errors.NoSmartMedium,
1483
errors.SmartProtocolError):
1484
# no smart server, so not a branch for this format type.
1485
raise errors.NotBranchError(path=transport.base)
1487
# Decline to open it if the server doesn't support our required
1488
# version (3) so that the VFS-based transport will do it.
1489
if medium.should_probe():
1491
server_version = medium.protocol_version()
1492
except errors.SmartProtocolError:
1493
# Apparently there's no usable smart server there, even though
1494
# the medium supports the smart protocol.
1495
raise errors.NotBranchError(path=transport.base)
1496
if server_version != '2':
1497
raise errors.NotBranchError(path=transport.base)
1498
return RemoteBzrDirFormat()
1501
class BzrDirFormat(controldir.ControlDirFormat):
1502
"""ControlDirFormat base class for .bzr/ directories.
1736
class BzrDirFormat(object):
1737
"""An encapsulation of the initialization and open routines for a format.
1739
Formats provide three things:
1740
* An initialization routine,
1504
1744
Formats are placed in a dict by their format string for reference
1505
1745
during bzrdir opening. These should be subclasses of BzrDirFormat
1510
1750
object will be created every system load.
1753
_default_format = None
1754
"""The default format used for new .bzr dirs."""
1757
"""The known formats."""
1759
_control_formats = []
1760
"""The registered control formats - .bzr, ....
1762
This is a list of BzrDirFormat objects.
1765
_control_server_formats = []
1766
"""The registered control server formats, e.g. RemoteBzrDirs.
1768
This is a list of BzrDirFormat objects.
1513
1771
_lock_file_name = 'branch-lock'
1515
1773
# _lock_class must be set in subclasses to the lock type, typ.
1516
1774
# TransportLock or LockDir
1777
def find_format(klass, transport, _server_formats=True):
1778
"""Return the format present at transport."""
1780
formats = klass._control_server_formats + klass._control_formats
1782
formats = klass._control_formats
1783
for format in formats:
1785
return format.probe_transport(transport)
1786
except errors.NotBranchError:
1787
# this format does not find a control dir here.
1789
raise errors.NotBranchError(path=transport.base)
1792
def probe_transport(klass, transport):
1793
"""Return the .bzrdir style format present in a directory."""
1795
format_string = transport.get(".bzr/branch-format").read()
1796
except errors.NoSuchFile:
1797
raise errors.NotBranchError(path=transport.base)
1800
return klass._formats[format_string]
1802
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1805
def get_default_format(klass):
1806
"""Return the current default format."""
1807
return klass._default_format
1518
1809
def get_format_string(self):
1519
1810
"""Return the ASCII format string that identifies this format."""
1520
1811
raise NotImplementedError(self.get_format_string)
1813
def get_format_description(self):
1814
"""Return the short description for this format."""
1815
raise NotImplementedError(self.get_format_description)
1817
def get_converter(self, format=None):
1818
"""Return the converter to use to convert bzrdirs needing converts.
1820
This returns a bzrlib.bzrdir.Converter object.
1822
This should return the best upgrader to step this format towards the
1823
current default format. In the case of plugins we can/should provide
1824
some means for them to extend the range of returnable converters.
1826
:param format: Optional format to override the default format of the
1829
raise NotImplementedError(self.get_converter)
1831
def initialize(self, url, possible_transports=None):
1832
"""Create a bzr control dir at this url and return an opened copy.
1834
While not deprecated, this method is very specific and its use will
1835
lead to many round trips to setup a working environment. See
1836
initialize_on_transport_ex for a [nearly] all-in-one method.
1838
Subclasses should typically override initialize_on_transport
1839
instead of this method.
1841
return self.initialize_on_transport(get_transport(url,
1842
possible_transports))
1522
1844
def initialize_on_transport(self, transport):
1523
1845
"""Initialize a new bzrdir in the base directory of a Transport."""
1672
1994
control_files.unlock()
1673
1995
return self.open(transport, _found=True)
1997
def is_supported(self):
1998
"""Is this format supported?
2000
Supported formats must be initializable and openable.
2001
Unsupported formats may not support initialization or committing or
2002
some other features depending on the reason for not being supported.
2006
def network_name(self):
2007
"""A simple byte string uniquely identifying this format for RPC calls.
2009
Bzr control formats use thir disk format string to identify the format
2010
over the wire. Its possible that other control formats have more
2011
complex detection requirements, so we permit them to use any unique and
2012
immutable string they desire.
2014
raise NotImplementedError(self.network_name)
2016
def same_model(self, target_format):
2017
return (self.repository_format.rich_root_data ==
2018
target_format.rich_root_data)
2021
def known_formats(klass):
2022
"""Return all the known formats.
2024
Concrete formats should override _known_formats.
2026
# There is double indirection here to make sure that control
2027
# formats used by more than one dir format will only be probed
2028
# once. This can otherwise be quite expensive for remote connections.
2030
for format in klass._control_formats:
2031
result.update(format._known_formats())
2035
def _known_formats(klass):
2036
"""Return the known format instances for this control format."""
2037
return set(klass._formats.values())
1675
2039
def open(self, transport, _found=False):
1676
2040
"""Return an instance of this format for the dir transport points at.
1678
2042
_found is a private parameter, do not use it.
1681
found_format = controldir.ControlDirFormat.find_format(transport)
2045
found_format = BzrDirFormat.find_format(transport)
1682
2046
if not isinstance(found_format, self.__class__):
1683
2047
raise AssertionError("%s was asked to open %s, but it seems to need "
1700
2064
def register_format(klass, format):
1701
BzrProber.register_bzrdir_format(format)
2065
klass._formats[format.get_format_string()] = format
1702
2066
# bzr native formats have a network name of their format string.
1703
controldir.network_format_registry.register(format.get_format_string(), format.__class__)
1704
controldir.ControlDirFormat.register_format(format)
2067
network_format_registry.register(format.get_format_string(), format.__class__)
2070
def register_control_format(klass, format):
2071
"""Register a format that does not use '.bzr' for its control dir.
2073
TODO: This should be pulled up into a 'ControlDirFormat' base class
2074
which BzrDirFormat can inherit from, and renamed to register_format
2075
there. It has been done without that for now for simplicity of
2078
klass._control_formats.append(format)
2081
def register_control_server_format(klass, format):
2082
"""Register a control format for client-server environments.
2084
These formats will be tried before ones registered with
2085
register_control_format. This gives implementations that decide to the
2086
chance to grab it before anything looks at the contents of the format
2089
klass._control_server_formats.append(format)
2092
def _set_default_format(klass, format):
2093
"""Set default format (for testing behavior of defaults only)"""
2094
klass._default_format = format
2098
return self.get_format_description().rstrip()
1706
2100
def _supply_sub_formats_to(self, other_format):
1707
2101
"""Give other_format the same values for sub formats as this has.
2908
3314
BzrDirMetaFormat1._set_repository_format) #.im_func)
2911
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
if default_realkey is not None:
3461
output += wrapped(default_realkey, '(default) %s' % default_help,
3462
self.get_info('default'))
3463
deprecated_pairs = []
3464
experimental_pairs = []
3465
for key, help in help_pairs:
3466
info = self.get_info(key)
3469
elif info.deprecated:
3470
deprecated_pairs.append((key, help))
3471
elif info.experimental:
3472
experimental_pairs.append((key, help))
3474
output += wrapped(key, help, info)
3475
output += "\nSee ``bzr help formats`` for more about storage formats."
3477
if len(experimental_pairs) > 0:
3478
other_output += "Experimental formats are shown below.\n\n"
3479
for key, help in experimental_pairs:
3480
info = self.get_info(key)
3481
other_output += wrapped(key, help, info)
3484
"No experimental formats are available.\n\n"
3485
if len(deprecated_pairs) > 0:
3486
other_output += "\nDeprecated formats are shown below.\n\n"
3487
for key, help in deprecated_pairs:
3488
info = self.get_info(key)
3489
other_output += wrapped(key, help, info)
3492
"\nNo deprecated formats are available.\n\n"
3494
"\nSee ``bzr help formats`` for more about storage formats."
3496
if topic == 'other-formats':
2914
3502
class RepositoryAcquisitionPolicy(object):
3068
3652
return self._repository, False
3071
def register_metadir(registry, key,
3072
repository_format, help, native=True, deprecated=False,
3078
"""Register a metadir subformat.
3080
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
3081
by the Repository/Branch/WorkingTreeformats.
3083
:param repository_format: The fully-qualified repository format class
3085
:param branch_format: Fully-qualified branch format class name as
3087
:param tree_format: Fully-qualified tree format class name as
3090
# This should be expanded to support setting WorkingTree and Branch
3091
# formats, once BzrDirMetaFormat1 supports that.
3092
def _load(full_name):
3093
mod_name, factory_name = full_name.rsplit('.', 1)
3095
mod = __import__(mod_name, globals(), locals(),
3097
except ImportError, e:
3098
raise ImportError('failed to load %s: %s' % (full_name, e))
3100
factory = getattr(mod, factory_name)
3101
except AttributeError:
3102
raise AttributeError('no factory %s in module %r'
3107
bd = BzrDirMetaFormat1()
3108
if branch_format is not None:
3109
bd.set_branch_format(_load(branch_format))
3110
if tree_format is not None:
3111
bd.workingtree_format = _load(tree_format)
3112
if repository_format is not None:
3113
bd.repository_format = _load(repository_format)
3115
registry.register(key, helper, help, native, deprecated, hidden,
3116
experimental, alias)
3655
# Please register new formats after old formats so that formats
3656
# appear in chronological order and format descriptions can build
3658
format_registry = BzrDirFormatRegistry()
3118
3659
# The pre-0.8 formats have their repository format network name registered in
3119
3660
# repository.py. MetaDir formats have their repository format network name
3120
3661
# inferred from their disk format string.
3121
controldir.format_registry.register('weave', BzrDirFormat6,
3662
format_registry.register('weave', BzrDirFormat6,
3122
3663
'Pre-0.8 format. Slower than knit and does not'
3123
3664
' support checkouts or shared repositories.',
3125
3665
deprecated=True)
3126
register_metadir(controldir.format_registry, 'metaweave',
3666
format_registry.register_metadir('metaweave',
3127
3667
'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3128
3668
'Transitional format in 0.8. Slower than knit.',
3129
3669
branch_format='bzrlib.branch.BzrBranchFormat5',
3130
3670
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3132
3671
deprecated=True)
3133
register_metadir(controldir.format_registry, 'knit',
3672
format_registry.register_metadir('knit',
3134
3673
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3135
3674
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
3136
3675
branch_format='bzrlib.branch.BzrBranchFormat5',
3137
3676
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3139
3677
deprecated=True)
3140
register_metadir(controldir.format_registry, 'dirstate',
3678
format_registry.register_metadir('dirstate',
3141
3679
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3142
3680
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
3143
3681
'above when accessed over the network.',
3145
3683
# this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
3146
3684
# directly from workingtree_4 triggers a circular import.
3147
3685
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3149
3686
deprecated=True)
3150
register_metadir(controldir.format_registry, 'dirstate-tags',
3687
format_registry.register_metadir('dirstate-tags',
3151
3688
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3152
3689
help='New in 0.15: Fast local operations and improved scaling for '
3153
3690
'network operations. Additionally adds support for tags.'
3154
3691
' Incompatible with bzr < 0.15.',
3155
3692
branch_format='bzrlib.branch.BzrBranchFormat6',
3156
3693
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3158
3694
deprecated=True)
3159
register_metadir(controldir.format_registry, 'rich-root',
3695
format_registry.register_metadir('rich-root',
3160
3696
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
3161
3697
help='New in 1.0. Better handling of tree roots. Incompatible with'
3163
3699
branch_format='bzrlib.branch.BzrBranchFormat6',
3164
3700
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3166
3701
deprecated=True)
3167
register_metadir(controldir.format_registry, 'dirstate-with-subtree',
3702
format_registry.register_metadir('dirstate-with-subtree',
3168
3703
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
3169
3704
help='New in 0.15: Fast local operations and improved scaling for '
3170
3705
'network operations. Additionally adds support for versioning nested '
3174
3709
experimental=True,
3177
register_metadir(controldir.format_registry, 'pack-0.92',
3712
format_registry.register_metadir('pack-0.92',
3178
3713
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack1',
3179
3714
help='New in 0.92: Pack-based format with data compatible with '
3180
3715
'dirstate-tags format repositories. Interoperates with '
3181
3716
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3717
'Previously called knitpack-experimental. '
3718
'For more information, see '
3719
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3183
3720
branch_format='bzrlib.branch.BzrBranchFormat6',
3184
3721
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3186
register_metadir(controldir.format_registry, 'pack-0.92-subtree',
3723
format_registry.register_metadir('pack-0.92-subtree',
3187
3724
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack3',
3188
3725
help='New in 0.92: Pack-based format with data compatible with '
3189
3726
'dirstate-with-subtree format repositories. Interoperates with '
3190
3727
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3728
'Previously called knitpack-experimental. '
3729
'For more information, see '
3730
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3192
3731
branch_format='bzrlib.branch.BzrBranchFormat6',
3193
3732
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3195
3734
experimental=True,
3197
register_metadir(controldir.format_registry, 'rich-root-pack',
3736
format_registry.register_metadir('rich-root-pack',
3198
3737
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3199
3738
help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
3200
3739
'(needed for bzr-svn and bzr-git).',
3201
3740
branch_format='bzrlib.branch.BzrBranchFormat6',
3202
3741
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3205
register_metadir(controldir.format_registry, '1.6',
3743
format_registry.register_metadir('1.6',
3206
3744
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
3207
3745
help='A format that allows a branch to indicate that there is another '
3208
3746
'(stacked) repository that should be used to access data that is '
3209
3747
'not present locally.',
3210
3748
branch_format='bzrlib.branch.BzrBranchFormat7',
3211
3749
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3214
register_metadir(controldir.format_registry, '1.6.1-rich-root',
3751
format_registry.register_metadir('1.6.1-rich-root',
3215
3752
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
3216
3753
help='A variant of 1.6 that supports rich-root data '
3217
3754
'(needed for bzr-svn and bzr-git).',
3218
3755
branch_format='bzrlib.branch.BzrBranchFormat7',
3219
3756
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3222
register_metadir(controldir.format_registry, '1.9',
3758
format_registry.register_metadir('1.9',
3223
3759
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3224
3760
help='A repository format using B+tree indexes. These indexes '
3225
3761
'are smaller in size, have smarter caching and provide faster '
3226
3762
'performance for most operations.',
3227
3763
branch_format='bzrlib.branch.BzrBranchFormat7',
3228
3764
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3231
register_metadir(controldir.format_registry, '1.9-rich-root',
3766
format_registry.register_metadir('1.9-rich-root',
3232
3767
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3233
3768
help='A variant of 1.9 that supports rich-root data '
3234
3769
'(needed for bzr-svn and bzr-git).',
3235
3770
branch_format='bzrlib.branch.BzrBranchFormat7',
3236
3771
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3239
register_metadir(controldir.format_registry, '1.14',
3773
format_registry.register_metadir('1.14',
3240
3774
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3241
3775
help='A working-tree format that supports content filtering.',
3242
3776
branch_format='bzrlib.branch.BzrBranchFormat7',
3243
3777
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3245
register_metadir(controldir.format_registry, '1.14-rich-root',
3779
format_registry.register_metadir('1.14-rich-root',
3246
3780
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3247
3781
help='A variant of 1.14 that supports rich-root data '
3248
3782
'(needed for bzr-svn and bzr-git).',
3250
3784
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3252
3786
# The following un-numbered 'development' formats should always just be aliases.
3253
register_metadir(controldir.format_registry, 'development-rich-root',
3787
format_registry.register_metadir('development-rich-root',
3254
3788
'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3255
3789
help='Current development format. Supports rich roots. Can convert data '
3256
3790
'to and from rich-root-pack (and anything compatible with '
3257
3791
'rich-root-pack) format repositories. Repositories and branches in '
3258
3792
'this format can only be read by bzr.dev. Please read '
3259
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3793
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3261
3795
branch_format='bzrlib.branch.BzrBranchFormat7',
3262
3796
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3263
3797
experimental=True,
3267
register_metadir(controldir.format_registry, 'development5-subtree',
3800
format_registry.register_metadir('development-subtree',
3268
3801
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3269
help='Development format, subtree variant. Can convert data to and '
3270
'from pack-0.92-subtree (and anything compatible with '
3271
'pack-0.92-subtree) format repositories. Repositories and branches in '
3272
'this format can only be read by bzr.dev. Please read '
3273
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3275
branch_format='bzrlib.branch.BzrBranchFormat7',
3276
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3283
register_metadir(controldir.format_registry, 'development-subtree',
3284
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2aSubtree',
3285
3802
help='Current development format, subtree variant. Can convert data to and '
3286
3803
'from pack-0.92-subtree (and anything compatible with '
3287
3804
'pack-0.92-subtree) format repositories. Repositories and branches in '
3288
3805
'this format can only be read by bzr.dev. Please read '
3289
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3806
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3291
3808
branch_format='bzrlib.branch.BzrBranchFormat7',
3292
3809
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3293
3810
experimental=True,
3295
3811
alias=False, # Restore to being an alias when an actual development subtree format is added
3296
3812
# This current non-alias status is simply because we did not introduce a
3297
3813
# chk based subtree format.
3300
3816
# And the development formats above will have aliased one of the following:
3301
register_metadir(controldir.format_registry, 'development6-rich-root',
3817
format_registry.register_metadir('development6-rich-root',
3302
3818
'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3303
3819
help='pack-1.9 with 255-way hashed CHK inv, group compress, rich roots '
3305
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3821
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3307
3823
branch_format='bzrlib.branch.BzrBranchFormat7',
3308
3824
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
added
removed
bzrlib/bzrdir.py
