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(".bzr/branch-format").read()
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
3351
BzrDirMetaFormat1._set_repository_format) #.im_func)
2937
controldir.ControlDirFormat.register_server_prober(RemoteBzrProber)
3354
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
3357
class BzrDirFormatInfo(object):
3359
def __init__(self, native, deprecated, hidden, experimental):
3360
self.deprecated = deprecated
3361
self.native = native
3362
self.hidden = hidden
3363
self.experimental = experimental
3366
class BzrDirFormatRegistry(registry.Registry):
3367
"""Registry of user-selectable BzrDir subformats.
3369
Differs from BzrDirFormat._control_formats in that it provides sub-formats,
3370
e.g. BzrDirMeta1 with weave repository. Also, it's more user-oriented.
3374
"""Create a BzrDirFormatRegistry."""
3375
self._aliases = set()
3376
self._registration_order = list()
3377
super(BzrDirFormatRegistry, self).__init__()
3380
"""Return a set of the format names which are aliases."""
3381
return frozenset(self._aliases)
3383
def register_metadir(self, key,
3384
repository_format, help, native=True, deprecated=False,
3390
"""Register a metadir subformat.
3392
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
3393
by the Repository/Branch/WorkingTreeformats.
3395
:param repository_format: The fully-qualified repository format class
3397
:param branch_format: Fully-qualified branch format class name as
3399
:param tree_format: Fully-qualified tree format class name as
3402
# This should be expanded to support setting WorkingTree and Branch
3403
# formats, once BzrDirMetaFormat1 supports that.
3404
def _load(full_name):
3405
mod_name, factory_name = full_name.rsplit('.', 1)
3407
mod = __import__(mod_name, globals(), locals(),
3409
except ImportError, e:
3410
raise ImportError('failed to load %s: %s' % (full_name, e))
3412
factory = getattr(mod, factory_name)
3413
except AttributeError:
3414
raise AttributeError('no factory %s in module %r'
3419
bd = BzrDirMetaFormat1()
3420
if branch_format is not None:
3421
bd.set_branch_format(_load(branch_format))
3422
if tree_format is not None:
3423
bd.workingtree_format = _load(tree_format)
3424
if repository_format is not None:
3425
bd.repository_format = _load(repository_format)
3427
self.register(key, helper, help, native, deprecated, hidden,
3428
experimental, alias)
3430
def register(self, key, factory, help, native=True, deprecated=False,
3431
hidden=False, experimental=False, alias=False):
3432
"""Register a BzrDirFormat factory.
3434
The factory must be a callable that takes one parameter: the key.
3435
It must produce an instance of the BzrDirFormat when called.
3437
This function mainly exists to prevent the info object from being
3440
registry.Registry.register(self, key, factory, help,
3441
BzrDirFormatInfo(native, deprecated, hidden, experimental))
3443
self._aliases.add(key)
3444
self._registration_order.append(key)
3446
def register_lazy(self, key, module_name, member_name, help, native=True,
3447
deprecated=False, hidden=False, experimental=False, alias=False):
3448
registry.Registry.register_lazy(self, key, module_name, member_name,
3449
help, BzrDirFormatInfo(native, deprecated, hidden, experimental))
3451
self._aliases.add(key)
3452
self._registration_order.append(key)
3454
def set_default(self, key):
3455
"""Set the 'default' key to be a clone of the supplied key.
3457
This method must be called once and only once.
3459
registry.Registry.register(self, 'default', self.get(key),
3460
self.get_help(key), info=self.get_info(key))
3461
self._aliases.add('default')
3463
def set_default_repository(self, key):
3464
"""Set the FormatRegistry default and Repository default.
3466
This is a transitional method while Repository.set_default_format
3469
if 'default' in self:
3470
self.remove('default')
3471
self.set_default(key)
3472
format = self.get('default')()
3474
def make_bzrdir(self, key):
3475
return self.get(key)()
3477
def help_topic(self, topic):
3479
default_realkey = None
3480
default_help = self.get_help('default')
3482
for key in self._registration_order:
3483
if key == 'default':
3485
help = self.get_help(key)
3486
if help == default_help:
3487
default_realkey = key
3489
help_pairs.append((key, help))
3491
def wrapped(key, help, info):
3493
help = '(native) ' + help
3494
return ':%s:\n%s\n\n' % (key,
3495
textwrap.fill(help, initial_indent=' ',
3496
subsequent_indent=' ',
3497
break_long_words=False))
3498
if default_realkey is not None:
3499
output += wrapped(default_realkey, '(default) %s' % default_help,
3500
self.get_info('default'))
3501
deprecated_pairs = []
3502
experimental_pairs = []
3503
for key, help in help_pairs:
3504
info = self.get_info(key)
3507
elif info.deprecated:
3508
deprecated_pairs.append((key, help))
3509
elif info.experimental:
3510
experimental_pairs.append((key, help))
3512
output += wrapped(key, help, info)
3513
output += "\nSee ``bzr help formats`` for more about storage formats."
3515
if len(experimental_pairs) > 0:
3516
other_output += "Experimental formats are shown below.\n\n"
3517
for key, help in experimental_pairs:
3518
info = self.get_info(key)
3519
other_output += wrapped(key, help, info)
3522
"No experimental formats are available.\n\n"
3523
if len(deprecated_pairs) > 0:
3524
other_output += "\nDeprecated formats are shown below.\n\n"
3525
for key, help in deprecated_pairs:
3526
info = self.get_info(key)
3527
other_output += wrapped(key, help, info)
3530
"\nNo deprecated formats are available.\n\n"
3532
"\nSee ``bzr help formats`` for more about storage formats."
3534
if topic == 'other-formats':
2940
3540
class RepositoryAcquisitionPolicy(object):
3094
3694
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)
3697
# Please register new formats after old formats so that formats
3698
# appear in chronological order and format descriptions can build
3700
format_registry = BzrDirFormatRegistry()
3144
3701
# The pre-0.8 formats have their repository format network name registered in
3145
3702
# repository.py. MetaDir formats have their repository format network name
3146
3703
# inferred from their disk format string.
3147
controldir.format_registry.register('weave', BzrDirFormat6,
3704
format_registry.register('weave', BzrDirFormat6,
3148
3705
'Pre-0.8 format. Slower than knit and does not'
3149
3706
' support checkouts or shared repositories.',
3151
3707
deprecated=True)
3152
register_metadir(controldir.format_registry, 'metaweave',
3708
format_registry.register_metadir('metaweave',
3153
3709
'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3154
3710
'Transitional format in 0.8. Slower than knit.',
3155
3711
branch_format='bzrlib.branch.BzrBranchFormat5',
3156
3712
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3158
3713
deprecated=True)
3159
register_metadir(controldir.format_registry, 'knit',
3714
format_registry.register_metadir('knit',
3160
3715
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3161
3716
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
3162
3717
branch_format='bzrlib.branch.BzrBranchFormat5',
3163
3718
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3165
3719
deprecated=True)
3166
register_metadir(controldir.format_registry, 'dirstate',
3720
format_registry.register_metadir('dirstate',
3167
3721
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3168
3722
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
3169
3723
'above when accessed over the network.',
3171
3725
# this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
3172
3726
# directly from workingtree_4 triggers a circular import.
3173
3727
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3175
3728
deprecated=True)
3176
register_metadir(controldir.format_registry, 'dirstate-tags',
3729
format_registry.register_metadir('dirstate-tags',
3177
3730
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3178
3731
help='New in 0.15: Fast local operations and improved scaling for '
3179
3732
'network operations. Additionally adds support for tags.'
3180
3733
' Incompatible with bzr < 0.15.',
3181
3734
branch_format='bzrlib.branch.BzrBranchFormat6',
3182
3735
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3184
3736
deprecated=True)
3185
register_metadir(controldir.format_registry, 'rich-root',
3737
format_registry.register_metadir('rich-root',
3186
3738
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
3187
3739
help='New in 1.0. Better handling of tree roots. Incompatible with'
3189
3741
branch_format='bzrlib.branch.BzrBranchFormat6',
3190
3742
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3192
3743
deprecated=True)
3193
register_metadir(controldir.format_registry, 'dirstate-with-subtree',
3744
format_registry.register_metadir('dirstate-with-subtree',
3194
3745
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
3195
3746
help='New in 0.15: Fast local operations and improved scaling for '
3196
3747
'network operations. Additionally adds support for versioning nested '
3200
3751
experimental=True,
3203
register_metadir(controldir.format_registry, 'pack-0.92',
3754
format_registry.register_metadir('pack-0.92',
3204
3755
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack1',
3205
3756
help='New in 0.92: Pack-based format with data compatible with '
3206
3757
'dirstate-tags format repositories. Interoperates with '
3207
3758
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3759
'Previously called knitpack-experimental. '
3760
'For more information, see '
3761
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3209
3762
branch_format='bzrlib.branch.BzrBranchFormat6',
3210
3763
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3212
register_metadir(controldir.format_registry, 'pack-0.92-subtree',
3765
format_registry.register_metadir('pack-0.92-subtree',
3213
3766
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack3',
3214
3767
help='New in 0.92: Pack-based format with data compatible with '
3215
3768
'dirstate-with-subtree format repositories. Interoperates with '
3216
3769
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3770
'Previously called knitpack-experimental. '
3771
'For more information, see '
3772
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3218
3773
branch_format='bzrlib.branch.BzrBranchFormat6',
3219
3774
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3221
3776
experimental=True,
3223
register_metadir(controldir.format_registry, 'rich-root-pack',
3778
format_registry.register_metadir('rich-root-pack',
3224
3779
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3225
3780
help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
3226
3781
'(needed for bzr-svn and bzr-git).',
3227
3782
branch_format='bzrlib.branch.BzrBranchFormat6',
3228
3783
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3231
register_metadir(controldir.format_registry, '1.6',
3785
format_registry.register_metadir('1.6',
3232
3786
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
3233
3787
help='A format that allows a branch to indicate that there is another '
3234
3788
'(stacked) repository that should be used to access data that is '
3235
3789
'not present locally.',
3236
3790
branch_format='bzrlib.branch.BzrBranchFormat7',
3237
3791
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3240
register_metadir(controldir.format_registry, '1.6.1-rich-root',
3793
format_registry.register_metadir('1.6.1-rich-root',
3241
3794
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
3242
3795
help='A variant of 1.6 that supports rich-root data '
3243
3796
'(needed for bzr-svn and bzr-git).',
3244
3797
branch_format='bzrlib.branch.BzrBranchFormat7',
3245
3798
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3248
register_metadir(controldir.format_registry, '1.9',
3800
format_registry.register_metadir('1.9',
3249
3801
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3250
3802
help='A repository format using B+tree indexes. These indexes '
3251
3803
'are smaller in size, have smarter caching and provide faster '
3252
3804
'performance for most operations.',
3253
3805
branch_format='bzrlib.branch.BzrBranchFormat7',
3254
3806
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3257
register_metadir(controldir.format_registry, '1.9-rich-root',
3808
format_registry.register_metadir('1.9-rich-root',
3258
3809
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3259
3810
help='A variant of 1.9 that supports rich-root data '
3260
3811
'(needed for bzr-svn and bzr-git).',
3261
3812
branch_format='bzrlib.branch.BzrBranchFormat7',
3262
3813
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3265
register_metadir(controldir.format_registry, '1.14',
3815
format_registry.register_metadir('1.14',
3266
3816
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3267
3817
help='A working-tree format that supports content filtering.',
3268
3818
branch_format='bzrlib.branch.BzrBranchFormat7',
3269
3819
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3271
register_metadir(controldir.format_registry, '1.14-rich-root',
3821
format_registry.register_metadir('1.14-rich-root',
3272
3822
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3273
3823
help='A variant of 1.14 that supports rich-root data '
3274
3824
'(needed for bzr-svn and bzr-git).',
3276
3826
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3278
3828
# The following un-numbered 'development' formats should always just be aliases.
3279
register_metadir(controldir.format_registry, 'development-rich-root',
3829
format_registry.register_metadir('development-rich-root',
3280
3830
'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3281
3831
help='Current development format. Supports rich roots. Can convert data '
3282
3832
'to and from rich-root-pack (and anything compatible with '
3283
3833
'rich-root-pack) format repositories. Repositories and branches in '
3284
3834
'this format can only be read by bzr.dev. Please read '
3285
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3835
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3287
3837
branch_format='bzrlib.branch.BzrBranchFormat7',
3288
3838
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3289
3839
experimental=True,
3293
register_metadir(controldir.format_registry, 'development-subtree',
3842
format_registry.register_metadir('development-subtree',
3294
3843
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3295
3844
help='Current development format, subtree variant. Can convert data to and '
3296
3845
'from pack-0.92-subtree (and anything compatible with '
3297
3846
'pack-0.92-subtree) format repositories. Repositories and branches in '
3298
3847
'this format can only be read by bzr.dev. Please read '
3299
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3848
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3301
3850
branch_format='bzrlib.branch.BzrBranchFormat7',
3302
3851
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3303
3852
experimental=True,
3305
3853
alias=False, # Restore to being an alias when an actual development subtree format is added
3306
3854
# This current non-alias status is simply because we did not introduce a
3307
3855
# chk based subtree format.
3310
3858
# And the development formats above will have aliased one of the following:
3311
register_metadir(controldir.format_registry, 'development6-rich-root',
3859
format_registry.register_metadir('development6-rich-root',
3312
3860
'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3313
3861
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 '
3863
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3317
3865
branch_format='bzrlib.branch.BzrBranchFormat7',
3318
3866
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
added
removed
bzrlib/bzrdir.py
