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)
586
new_path = self.root_transport.abspath('backup.bzr')
542
587
ui.ui_factory.note('making backup of %s\n to %s' % (old_path, new_path,))
543
self.root_transport.copy_tree('.bzr', backup_dir)
588
self.root_transport.copy_tree('.bzr', 'backup.bzr')
544
589
return (old_path, new_path)
860
997
raise errors.NotBranchError(location)
861
998
return tree, branch, branch.repository, relpath
1000
def open_repository(self, _unsupported=False):
1001
"""Open the repository object at this BzrDir if one is present.
1003
This will not follow the Branch object pointer - it's strictly a direct
1004
open facility. Most client code should use open_branch().repository to
1005
get at a repository.
1007
:param _unsupported: a private parameter, not part of the api.
1008
TODO: static convenience version of this?
1010
raise NotImplementedError(self.open_repository)
1012
def open_workingtree(self, _unsupported=False,
1013
recommend_upgrade=True, from_branch=None):
1014
"""Open the workingtree object at this BzrDir if one is present.
1016
:param recommend_upgrade: Optional keyword parameter, when True (the
1017
default), emit through the ui module a recommendation that the user
1018
upgrade the working tree when the workingtree being opened is old
1019
(but still fully supported).
1020
:param from_branch: override bzrdir branch (for lightweight checkouts)
1022
raise NotImplementedError(self.open_workingtree)
1024
def has_branch(self):
1025
"""Tell if this bzrdir contains a branch.
1027
Note: if you're going to open the branch, you should just go ahead
1028
and try, and not ask permission first. (This method just opens the
1029
branch and discards it, and that's somewhat expensive.)
1034
except errors.NotBranchError:
1037
def has_workingtree(self):
1038
"""Tell if this bzrdir contains a working tree.
1040
This will still raise an exception if the bzrdir has a workingtree that
1041
is remote & inaccessible.
1043
Note: if you're going to open the working tree, you should just go ahead
1044
and try, and not ask permission first. (This method just opens the
1045
workingtree and discards it, and that's somewhat expensive.)
1048
self.open_workingtree(recommend_upgrade=False)
1050
except errors.NoWorkingTree:
863
1053
def _cloning_metadir(self):
864
1054
"""Produce a metadir suitable for cloning with.
923
1113
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.
1116
def checkout_metadir(self):
1117
return self.cloning_metadir()
1119
def sprout(self, url, revision_id=None, force_new_repo=False,
1120
recurse='down', possible_transports=None,
1121
accelerator_tree=None, hardlink=False, stacked=False,
1122
source_branch=None, create_tree_if_local=True):
1123
"""Create a copy of this bzrdir prepared for use as a new line of
1126
If url's last component does not exist, it will be created.
1128
Attributes related to the identity of the source branch like
1129
branch nickname will be cleaned, a working tree is created
1130
whether one existed before or not; and a local branch is always
1133
if revision_id is not None, then the clone operation may tune
1134
itself to download less data.
1135
:param accelerator_tree: A tree which can be used for retrieving file
1136
contents more quickly than the revision tree, i.e. a workingtree.
1137
The revision tree will be used for cases where accelerator_tree's
1138
content is different.
1139
:param hardlink: If true, hard-link files from accelerator_tree,
1141
:param stacked: If true, create a stacked branch referring to the
1142
location of this control directory.
1143
:param create_tree_if_local: If true, a working-tree will be created
1144
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)
1146
target_transport = get_transport(url, possible_transports)
1147
target_transport.ensure_base()
1148
cloning_format = self.cloning_metadir(stacked)
1149
# Create/update the result branch
1150
result = cloning_format.initialize_on_transport(target_transport)
1151
# if a stacked branch wasn't requested, we don't create one
1152
# even if the origin was stacked
1153
stacked_branch_url = None
1154
if source_branch is not None:
1156
stacked_branch_url = self.root_transport.base
1157
source_repository = source_branch.repository
1160
source_branch = self.open_branch()
1161
source_repository = source_branch.repository
1163
stacked_branch_url = self.root_transport.base
1164
except errors.NotBranchError:
1165
source_branch = None
1167
source_repository = self.open_repository()
1168
except errors.NoRepositoryPresent:
1169
source_repository = None
1170
repository_policy = result.determine_repository_policy(
1171
force_new_repo, stacked_branch_url, require_stacking=stacked)
1172
result_repo, is_new_repo = repository_policy.acquire_repository()
1173
if is_new_repo and revision_id is not None and not stacked:
1174
fetch_spec = graph.PendingAncestryResult(
1175
[revision_id], source_repository)
1178
if source_repository is not None:
1179
# Fetch while stacked to prevent unstacked fetch from
1181
if fetch_spec is None:
1182
result_repo.fetch(source_repository, revision_id=revision_id)
1184
result_repo.fetch(source_repository, fetch_spec=fetch_spec)
1186
if source_branch is None:
1187
# this is for sprouting a bzrdir without a branch; is that
1189
# Not especially, but it's part of the contract.
1190
result_branch = result.create_branch()
1192
result_branch = source_branch.sprout(result,
1193
revision_id=revision_id, repository_policy=repository_policy)
1194
mutter("created new branch %r" % (result_branch,))
1196
# Create/update the result working tree
1197
if (create_tree_if_local and
1198
isinstance(target_transport, local.LocalTransport) and
1199
(result_repo is None or result_repo.make_working_trees())):
1200
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
1204
if wt.path2id('') is None:
1206
wt.set_root_id(self.open_workingtree.get_root_id())
1207
except errors.NoWorkingTree:
1213
if recurse == 'down':
1215
basis = wt.basis_tree()
1217
subtrees = basis.iter_references()
1218
elif result_branch is not None:
1219
basis = result_branch.basis_tree()
1221
subtrees = basis.iter_references()
1222
elif source_branch is not None:
1223
basis = source_branch.basis_tree()
1225
subtrees = basis.iter_references()
1230
for path, file_id in subtrees:
1231
target = urlutils.join(url, urlutils.escape(path))
1232
sublocation = source_branch.reference_parent(file_id, path)
1233
sublocation.bzrdir.sprout(target,
1234
basis.get_reference_revision(file_id, path),
1235
force_new_repo=force_new_repo, recurse=recurse,
1238
if basis is not None:
1242
def push_branch(self, source, revision_id=None, overwrite=False,
1243
remember=False, create_prefix=False):
1244
"""Push the source branch into this BzrDir."""
1246
# If we can open a branch, use its direct repository, otherwise see
1247
# if there is a repository without a branch.
1249
br_to = self.open_branch()
1250
except errors.NotBranchError:
1251
# Didn't find a branch, can we find a repository?
1252
repository_to = self.find_repository()
1254
# Found a branch, so we must have found a repository
1255
repository_to = br_to.repository
1257
push_result = PushResult()
1258
push_result.source_branch = source
1260
# We have a repository but no branch, copy the revisions, and then
1262
repository_to.fetch(source.repository, revision_id=revision_id)
1263
br_to = source.clone(self, revision_id=revision_id)
1264
if source.get_push_location() is None or remember:
1265
source.set_push_location(br_to.base)
1266
push_result.stacked_on = None
1267
push_result.branch_push_result = None
1268
push_result.old_revno = None
1269
push_result.old_revid = _mod_revision.NULL_REVISION
1270
push_result.target_branch = br_to
1271
push_result.master_branch = None
1272
push_result.workingtree_updated = False
1274
# We have successfully opened the branch, remember if necessary:
1275
if source.get_push_location() is None or remember:
1276
source.set_push_location(br_to.base)
1278
tree_to = self.open_workingtree()
1279
except errors.NotLocalUrl:
1280
push_result.branch_push_result = source.push(br_to,
1281
overwrite, stop_revision=revision_id)
1282
push_result.workingtree_updated = False
1283
except errors.NoWorkingTree:
1284
push_result.branch_push_result = source.push(br_to,
1285
overwrite, stop_revision=revision_id)
1286
push_result.workingtree_updated = None # Not applicable
1288
tree_to.lock_write()
1290
push_result.branch_push_result = source.push(
1291
tree_to.branch, overwrite, stop_revision=revision_id)
1295
push_result.workingtree_updated = True
1296
push_result.old_revno = push_result.branch_push_result.old_revno
1297
push_result.old_revid = push_result.branch_push_result.old_revid
1298
push_result.target_branch = \
1299
push_result.branch_push_result.target_branch
946
1303
class BzrDirHooks(hooks.Hooks):
952
1309
self.create_hook(hooks.HookPoint('pre_open',
953
1310
"Invoked before attempting to open a BzrDir with the transport "
954
1311
"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
1313
# install the default hooks
962
1314
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
1317
class BzrDirPreSplitOut(BzrDir):
1002
1318
"""A common class for the all-in-one formats."""
1459
1768
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.
1771
class BzrDirFormat(object):
1772
"""An encapsulation of the initialization and open routines for a format.
1774
Formats provide three things:
1775
* An initialization routine,
1523
1779
Formats are placed in a dict by their format string for reference
1524
1780
during bzrdir opening. These should be subclasses of BzrDirFormat
1529
1785
object will be created every system load.
1788
_default_format = None
1789
"""The default format used for new .bzr dirs."""
1792
"""The known formats."""
1794
_control_formats = []
1795
"""The registered control formats - .bzr, ....
1797
This is a list of BzrDirFormat objects.
1800
_control_server_formats = []
1801
"""The registered control server formats, e.g. RemoteBzrDirs.
1803
This is a list of BzrDirFormat objects.
1532
1806
_lock_file_name = 'branch-lock'
1534
1808
# _lock_class must be set in subclasses to the lock type, typ.
1535
1809
# TransportLock or LockDir
1812
def find_format(klass, transport, _server_formats=True):
1813
"""Return the format present at transport."""
1815
formats = klass._control_server_formats + klass._control_formats
1817
formats = klass._control_formats
1818
for format in formats:
1820
return format.probe_transport(transport)
1821
except errors.NotBranchError:
1822
# this format does not find a control dir here.
1824
raise errors.NotBranchError(path=transport.base)
1827
def probe_transport(klass, transport):
1828
"""Return the .bzrdir style format present in a directory."""
1830
format_string = transport.get_bytes(".bzr/branch-format")
1831
except errors.NoSuchFile:
1832
raise errors.NotBranchError(path=transport.base)
1835
return klass._formats[format_string]
1837
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1840
def get_default_format(klass):
1841
"""Return the current default format."""
1842
return klass._default_format
1537
1844
def get_format_string(self):
1538
1845
"""Return the ASCII format string that identifies this format."""
1539
1846
raise NotImplementedError(self.get_format_string)
1848
def get_format_description(self):
1849
"""Return the short description for this format."""
1850
raise NotImplementedError(self.get_format_description)
1852
def get_converter(self, format=None):
1853
"""Return the converter to use to convert bzrdirs needing converts.
1855
This returns a bzrlib.bzrdir.Converter object.
1857
This should return the best upgrader to step this format towards the
1858
current default format. In the case of plugins we can/should provide
1859
some means for them to extend the range of returnable converters.
1861
:param format: Optional format to override the default format of the
1864
raise NotImplementedError(self.get_converter)
1866
def initialize(self, url, possible_transports=None):
1867
"""Create a bzr control dir at this url and return an opened copy.
1869
While not deprecated, this method is very specific and its use will
1870
lead to many round trips to setup a working environment. See
1871
initialize_on_transport_ex for a [nearly] all-in-one method.
1873
Subclasses should typically override initialize_on_transport
1874
instead of this method.
1876
return self.initialize_on_transport(get_transport(url,
1877
possible_transports))
1541
1879
def initialize_on_transport(self, transport):
1542
1880
"""Initialize a new bzrdir in the base directory of a Transport."""
1691
2029
control_files.unlock()
1692
2030
return self.open(transport, _found=True)
2032
def is_supported(self):
2033
"""Is this format supported?
2035
Supported formats must be initializable and openable.
2036
Unsupported formats may not support initialization or committing or
2037
some other features depending on the reason for not being supported.
2041
def network_name(self):
2042
"""A simple byte string uniquely identifying this format for RPC calls.
2044
Bzr control formats use thir disk format string to identify the format
2045
over the wire. Its possible that other control formats have more
2046
complex detection requirements, so we permit them to use any unique and
2047
immutable string they desire.
2049
raise NotImplementedError(self.network_name)
2051
def same_model(self, target_format):
2052
return (self.repository_format.rich_root_data ==
2053
target_format.rich_root_data)
2056
def known_formats(klass):
2057
"""Return all the known formats.
2059
Concrete formats should override _known_formats.
2061
# There is double indirection here to make sure that control
2062
# formats used by more than one dir format will only be probed
2063
# once. This can otherwise be quite expensive for remote connections.
2065
for format in klass._control_formats:
2066
result.update(format._known_formats())
2070
def _known_formats(klass):
2071
"""Return the known format instances for this control format."""
2072
return set(klass._formats.values())
1694
2074
def open(self, transport, _found=False):
1695
2075
"""Return an instance of this format for the dir transport points at.
1697
2077
_found is a private parameter, do not use it.
1700
found_format = controldir.ControlDirFormat.find_format(transport)
2080
found_format = BzrDirFormat.find_format(transport)
1701
2081
if not isinstance(found_format, self.__class__):
1702
2082
raise AssertionError("%s was asked to open %s, but it seems to need "
2934
3354
BzrDirMetaFormat1._set_repository_format) #.im_func)
2937
controldir.ControlDirFormat.register_server_prober(RemoteBzrProber)
3357
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
3360
class BzrDirFormatInfo(object):
3362
def __init__(self, native, deprecated, hidden, experimental):
3363
self.deprecated = deprecated
3364
self.native = native
3365
self.hidden = hidden
3366
self.experimental = experimental
3369
class BzrDirFormatRegistry(registry.Registry):
3370
"""Registry of user-selectable BzrDir subformats.
3372
Differs from BzrDirFormat._control_formats in that it provides sub-formats,
3373
e.g. BzrDirMeta1 with weave repository. Also, it's more user-oriented.
3377
"""Create a BzrDirFormatRegistry."""
3378
self._aliases = set()
3379
self._registration_order = list()
3380
super(BzrDirFormatRegistry, self).__init__()
3383
"""Return a set of the format names which are aliases."""
3384
return frozenset(self._aliases)
3386
def register_metadir(self, key,
3387
repository_format, help, native=True, deprecated=False,
3393
"""Register a metadir subformat.
3395
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
3396
by the Repository/Branch/WorkingTreeformats.
3398
:param repository_format: The fully-qualified repository format class
3400
:param branch_format: Fully-qualified branch format class name as
3402
:param tree_format: Fully-qualified tree format class name as
3405
# This should be expanded to support setting WorkingTree and Branch
3406
# formats, once BzrDirMetaFormat1 supports that.
3407
def _load(full_name):
3408
mod_name, factory_name = full_name.rsplit('.', 1)
3410
mod = __import__(mod_name, globals(), locals(),
3412
except ImportError, e:
3413
raise ImportError('failed to load %s: %s' % (full_name, e))
3415
factory = getattr(mod, factory_name)
3416
except AttributeError:
3417
raise AttributeError('no factory %s in module %r'
3422
bd = BzrDirMetaFormat1()
3423
if branch_format is not None:
3424
bd.set_branch_format(_load(branch_format))
3425
if tree_format is not None:
3426
bd.workingtree_format = _load(tree_format)
3427
if repository_format is not None:
3428
bd.repository_format = _load(repository_format)
3430
self.register(key, helper, help, native, deprecated, hidden,
3431
experimental, alias)
3433
def register(self, key, factory, help, native=True, deprecated=False,
3434
hidden=False, experimental=False, alias=False):
3435
"""Register a BzrDirFormat factory.
3437
The factory must be a callable that takes one parameter: the key.
3438
It must produce an instance of the BzrDirFormat when called.
3440
This function mainly exists to prevent the info object from being
3443
registry.Registry.register(self, key, factory, help,
3444
BzrDirFormatInfo(native, deprecated, hidden, experimental))
3446
self._aliases.add(key)
3447
self._registration_order.append(key)
3449
def register_lazy(self, key, module_name, member_name, help, native=True,
3450
deprecated=False, hidden=False, experimental=False, alias=False):
3451
registry.Registry.register_lazy(self, key, module_name, member_name,
3452
help, BzrDirFormatInfo(native, deprecated, hidden, experimental))
3454
self._aliases.add(key)
3455
self._registration_order.append(key)
3457
def set_default(self, key):
3458
"""Set the 'default' key to be a clone of the supplied key.
3460
This method must be called once and only once.
3462
registry.Registry.register(self, 'default', self.get(key),
3463
self.get_help(key), info=self.get_info(key))
3464
self._aliases.add('default')
3466
def set_default_repository(self, key):
3467
"""Set the FormatRegistry default and Repository default.
3469
This is a transitional method while Repository.set_default_format
3472
if 'default' in self:
3473
self.remove('default')
3474
self.set_default(key)
3475
format = self.get('default')()
3477
def make_bzrdir(self, key):
3478
return self.get(key)()
3480
def help_topic(self, topic):
3482
default_realkey = None
3483
default_help = self.get_help('default')
3485
for key in self._registration_order:
3486
if key == 'default':
3488
help = self.get_help(key)
3489
if help == default_help:
3490
default_realkey = key
3492
help_pairs.append((key, help))
3494
def wrapped(key, help, info):
3496
help = '(native) ' + help
3497
return ':%s:\n%s\n\n' % (key,
3498
textwrap.fill(help, initial_indent=' ',
3499
subsequent_indent=' ',
3500
break_long_words=False))
3501
if default_realkey is not None:
3502
output += wrapped(default_realkey, '(default) %s' % default_help,
3503
self.get_info('default'))
3504
deprecated_pairs = []
3505
experimental_pairs = []
3506
for key, help in help_pairs:
3507
info = self.get_info(key)
3510
elif info.deprecated:
3511
deprecated_pairs.append((key, help))
3512
elif info.experimental:
3513
experimental_pairs.append((key, help))
3515
output += wrapped(key, help, info)
3516
output += "\nSee ``bzr help formats`` for more about storage formats."
3518
if len(experimental_pairs) > 0:
3519
other_output += "Experimental formats are shown below.\n\n"
3520
for key, help in experimental_pairs:
3521
info = self.get_info(key)
3522
other_output += wrapped(key, help, info)
3525
"No experimental formats are available.\n\n"
3526
if len(deprecated_pairs) > 0:
3527
other_output += "\nDeprecated formats are shown below.\n\n"
3528
for key, help in deprecated_pairs:
3529
info = self.get_info(key)
3530
other_output += wrapped(key, help, info)
3533
"\nNo deprecated formats are available.\n\n"
3535
"\nSee ``bzr help formats`` for more about storage formats."
3537
if topic == 'other-formats':
2940
3543
class RepositoryAcquisitionPolicy(object):
3094
3697
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)
3700
# Please register new formats after old formats so that formats
3701
# appear in chronological order and format descriptions can build
3703
format_registry = BzrDirFormatRegistry()
3144
3704
# The pre-0.8 formats have their repository format network name registered in
3145
3705
# repository.py. MetaDir formats have their repository format network name
3146
3706
# inferred from their disk format string.
3147
controldir.format_registry.register('weave', BzrDirFormat6,
3707
format_registry.register('weave', BzrDirFormat6,
3148
3708
'Pre-0.8 format. Slower than knit and does not'
3149
3709
' support checkouts or shared repositories.',
3151
3710
deprecated=True)
3152
register_metadir(controldir.format_registry, 'metaweave',
3711
format_registry.register_metadir('metaweave',
3153
3712
'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3154
3713
'Transitional format in 0.8. Slower than knit.',
3155
3714
branch_format='bzrlib.branch.BzrBranchFormat5',
3156
3715
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3158
3716
deprecated=True)
3159
register_metadir(controldir.format_registry, 'knit',
3717
format_registry.register_metadir('knit',
3160
3718
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3161
3719
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
3162
3720
branch_format='bzrlib.branch.BzrBranchFormat5',
3163
3721
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3165
3722
deprecated=True)
3166
register_metadir(controldir.format_registry, 'dirstate',
3723
format_registry.register_metadir('dirstate',
3167
3724
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3168
3725
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
3169
3726
'above when accessed over the network.',
3171
3728
# this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
3172
3729
# directly from workingtree_4 triggers a circular import.
3173
3730
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3175
3731
deprecated=True)
3176
register_metadir(controldir.format_registry, 'dirstate-tags',
3732
format_registry.register_metadir('dirstate-tags',
3177
3733
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3178
3734
help='New in 0.15: Fast local operations and improved scaling for '
3179
3735
'network operations. Additionally adds support for tags.'
3180
3736
' Incompatible with bzr < 0.15.',
3181
3737
branch_format='bzrlib.branch.BzrBranchFormat6',
3182
3738
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3184
3739
deprecated=True)
3185
register_metadir(controldir.format_registry, 'rich-root',
3740
format_registry.register_metadir('rich-root',
3186
3741
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
3187
3742
help='New in 1.0. Better handling of tree roots. Incompatible with'
3189
3744
branch_format='bzrlib.branch.BzrBranchFormat6',
3190
3745
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3192
3746
deprecated=True)
3193
register_metadir(controldir.format_registry, 'dirstate-with-subtree',
3747
format_registry.register_metadir('dirstate-with-subtree',
3194
3748
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
3195
3749
help='New in 0.15: Fast local operations and improved scaling for '
3196
3750
'network operations. Additionally adds support for versioning nested '
3200
3754
experimental=True,
3203
register_metadir(controldir.format_registry, 'pack-0.92',
3757
format_registry.register_metadir('pack-0.92',
3204
3758
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack1',
3205
3759
help='New in 0.92: Pack-based format with data compatible with '
3206
3760
'dirstate-tags format repositories. Interoperates with '
3207
3761
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3762
'Previously called knitpack-experimental. '
3763
'For more information, see '
3764
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3209
3765
branch_format='bzrlib.branch.BzrBranchFormat6',
3210
3766
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3212
register_metadir(controldir.format_registry, 'pack-0.92-subtree',
3768
format_registry.register_metadir('pack-0.92-subtree',
3213
3769
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack3',
3214
3770
help='New in 0.92: Pack-based format with data compatible with '
3215
3771
'dirstate-with-subtree format repositories. Interoperates with '
3216
3772
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3773
'Previously called knitpack-experimental. '
3774
'For more information, see '
3775
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3218
3776
branch_format='bzrlib.branch.BzrBranchFormat6',
3219
3777
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3221
3779
experimental=True,
3223
register_metadir(controldir.format_registry, 'rich-root-pack',
3781
format_registry.register_metadir('rich-root-pack',
3224
3782
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3225
3783
help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
3226
3784
'(needed for bzr-svn and bzr-git).',
3227
3785
branch_format='bzrlib.branch.BzrBranchFormat6',
3228
3786
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3231
register_metadir(controldir.format_registry, '1.6',
3788
format_registry.register_metadir('1.6',
3232
3789
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
3233
3790
help='A format that allows a branch to indicate that there is another '
3234
3791
'(stacked) repository that should be used to access data that is '
3235
3792
'not present locally.',
3236
3793
branch_format='bzrlib.branch.BzrBranchFormat7',
3237
3794
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3240
register_metadir(controldir.format_registry, '1.6.1-rich-root',
3796
format_registry.register_metadir('1.6.1-rich-root',
3241
3797
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
3242
3798
help='A variant of 1.6 that supports rich-root data '
3243
3799
'(needed for bzr-svn and bzr-git).',
3244
3800
branch_format='bzrlib.branch.BzrBranchFormat7',
3245
3801
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3248
register_metadir(controldir.format_registry, '1.9',
3803
format_registry.register_metadir('1.9',
3249
3804
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3250
3805
help='A repository format using B+tree indexes. These indexes '
3251
3806
'are smaller in size, have smarter caching and provide faster '
3252
3807
'performance for most operations.',
3253
3808
branch_format='bzrlib.branch.BzrBranchFormat7',
3254
3809
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3257
register_metadir(controldir.format_registry, '1.9-rich-root',
3811
format_registry.register_metadir('1.9-rich-root',
3258
3812
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3259
3813
help='A variant of 1.9 that supports rich-root data '
3260
3814
'(needed for bzr-svn and bzr-git).',
3261
3815
branch_format='bzrlib.branch.BzrBranchFormat7',
3262
3816
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3265
register_metadir(controldir.format_registry, '1.14',
3818
format_registry.register_metadir('1.14',
3266
3819
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3267
3820
help='A working-tree format that supports content filtering.',
3268
3821
branch_format='bzrlib.branch.BzrBranchFormat7',
3269
3822
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3271
register_metadir(controldir.format_registry, '1.14-rich-root',
3824
format_registry.register_metadir('1.14-rich-root',
3272
3825
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3273
3826
help='A variant of 1.14 that supports rich-root data '
3274
3827
'(needed for bzr-svn and bzr-git).',
3276
3829
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3278
3831
# The following un-numbered 'development' formats should always just be aliases.
3279
register_metadir(controldir.format_registry, 'development-rich-root',
3832
format_registry.register_metadir('development-rich-root',
3280
3833
'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3281
3834
help='Current development format. Supports rich roots. Can convert data '
3282
3835
'to and from rich-root-pack (and anything compatible with '
3283
3836
'rich-root-pack) format repositories. Repositories and branches in '
3284
3837
'this format can only be read by bzr.dev. Please read '
3285
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3838
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3287
3840
branch_format='bzrlib.branch.BzrBranchFormat7',
3288
3841
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3289
3842
experimental=True,
3293
register_metadir(controldir.format_registry, 'development-subtree',
3845
format_registry.register_metadir('development-subtree',
3294
3846
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3295
3847
help='Current development format, subtree variant. Can convert data to and '
3296
3848
'from pack-0.92-subtree (and anything compatible with '
3297
3849
'pack-0.92-subtree) format repositories. Repositories and branches in '
3298
3850
'this format can only be read by bzr.dev. Please read '
3299
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3851
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3301
3853
branch_format='bzrlib.branch.BzrBranchFormat7',
3302
3854
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3303
3855
experimental=True,
3305
3856
alias=False, # Restore to being an alias when an actual development subtree format is added
3306
3857
# This current non-alias status is simply because we did not introduce a
3307
3858
# chk based subtree format.
3310
3861
# And the development formats above will have aliased one of the following:
3311
register_metadir(controldir.format_registry, 'development6-rich-root',
3862
format_registry.register_metadir('development6-rich-root',
3312
3863
'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3313
3864
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 '
3866
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3317
3868
branch_format='bzrlib.branch.BzrBranchFormat7',
3318
3869
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
added
removed
bzrlib/bzrdir.py
