202
172
format.get_format_description(),
205
def clone(self, url, revision_id=None, force_new_repo=False,
206
preserve_stacking=False):
207
"""Clone this bzrdir and its contents to url verbatim.
209
:param url: The url create the clone at. If url's last component does
210
not exist, it will be created.
211
:param revision_id: The tip revision-id to use for any branch or
212
working tree. If not None, then the clone operation may tune
213
itself to download less data.
214
:param force_new_repo: Do not use a shared repository for the target
215
even if one is available.
216
:param preserve_stacking: When cloning a stacked branch, stack the
217
new branch on top of the other branch's stacked-on branch.
219
return self.clone_on_transport(get_transport(url),
220
revision_id=revision_id,
221
force_new_repo=force_new_repo,
222
preserve_stacking=preserve_stacking)
224
175
def clone_on_transport(self, transport, revision_id=None,
225
176
force_new_repo=False, preserve_stacking=False, stacked_on=None,
226
create_prefix=False, use_existing_dir=True):
177
create_prefix=False, use_existing_dir=True, no_tree=False):
227
178
"""Clone this bzrdir and its contents to transport verbatim.
229
180
:param transport: The transport for the location to produce the clone
602
504
format=format).bzrdir
603
505
return bzrdir.create_workingtree()
605
def create_workingtree(self, revision_id=None, from_branch=None,
606
accelerator_tree=None, hardlink=False):
607
"""Create a working tree at this BzrDir.
609
:param revision_id: create it as of this revision id.
610
:param from_branch: override bzrdir branch (for lightweight checkouts)
611
:param accelerator_tree: A tree which can be used for retrieving file
612
contents more quickly than the revision tree, i.e. a workingtree.
613
The revision tree will be used for cases where accelerator_tree's
614
content is different.
507
@deprecated_method(deprecated_in((2, 3, 0)))
508
def generate_backup_name(self, base):
509
return self._available_backup_name(base)
511
def _available_backup_name(self, base):
512
"""Find a non-existing backup file name based on base.
514
See bzrlib.osutils.available_backup_name about race conditions.
616
raise NotImplementedError(self.create_workingtree)
516
return osutils.available_backup_name(base, self.root_transport.has)
618
518
def backup_bzrdir(self):
619
519
"""Backup this bzr control directory.
621
521
:return: Tuple with old path name and new path name
623
def name_gen(base='backup.bzr'):
625
name = "%s.~%d~" % (base, counter)
626
while self.root_transport.has(name):
628
name = "%s.~%d~" % (base, counter)
631
backup_dir=name_gen()
632
524
pb = ui.ui_factory.nested_progress_bar()
634
# FIXME: bug 300001 -- the backup fails if the backup directory
635
# already exists, but it should instead either remove it or make
636
# a new backup directory.
638
526
old_path = self.root_transport.abspath('.bzr')
527
backup_dir = self._available_backup_name('backup.bzr')
639
528
new_path = self.root_transport.abspath(backup_dir)
640
ui.ui_factory.note('making backup of %s\n to %s' % (old_path, new_path,))
529
ui.ui_factory.note('making backup of %s\n to %s'
530
% (old_path, new_path,))
641
531
self.root_transport.copy_tree('.bzr', backup_dir)
642
532
return (old_path, new_path)
1061
848
raise errors.NotBranchError(location)
1062
849
return tree, branch, branch.repository, relpath
1064
def open_repository(self, _unsupported=False):
1065
"""Open the repository object at this BzrDir if one is present.
1067
This will not follow the Branch object pointer - it's strictly a direct
1068
open facility. Most client code should use open_branch().repository to
1069
get at a repository.
1071
:param _unsupported: a private parameter, not part of the api.
1072
TODO: static convenience version of this?
1074
raise NotImplementedError(self.open_repository)
1076
def open_workingtree(self, _unsupported=False,
1077
recommend_upgrade=True, from_branch=None):
1078
"""Open the workingtree object at this BzrDir if one is present.
1080
:param recommend_upgrade: Optional keyword parameter, when True (the
1081
default), emit through the ui module a recommendation that the user
1082
upgrade the working tree when the workingtree being opened is old
1083
(but still fully supported).
1084
:param from_branch: override bzrdir branch (for lightweight checkouts)
1086
raise NotImplementedError(self.open_workingtree)
1088
def has_branch(self, name=None):
1089
"""Tell if this bzrdir contains a branch.
1091
Note: if you're going to open the branch, you should just go ahead
1092
and try, and not ask permission first. (This method just opens the
1093
branch and discards it, and that's somewhat expensive.)
1096
self.open_branch(name)
1098
except errors.NotBranchError:
1101
def has_workingtree(self):
1102
"""Tell if this bzrdir contains a working tree.
1104
This will still raise an exception if the bzrdir has a workingtree that
1105
is remote & inaccessible.
1107
Note: if you're going to open the working tree, you should just go ahead
1108
and try, and not ask permission first. (This method just opens the
1109
workingtree and discards it, and that's somewhat expensive.)
1112
self.open_workingtree(recommend_upgrade=False)
1114
except errors.NoWorkingTree:
1117
851
def _cloning_metadir(self):
1118
852
"""Produce a metadir suitable for cloning with.
1177
911
format.require_stacking()
1180
def checkout_metadir(self):
1181
return self.cloning_metadir()
1183
def sprout(self, url, revision_id=None, force_new_repo=False,
1184
recurse='down', possible_transports=None,
1185
accelerator_tree=None, hardlink=False, stacked=False,
1186
source_branch=None, create_tree_if_local=True):
1187
"""Create a copy of this bzrdir prepared for use as a new line of
1190
If url's last component does not exist, it will be created.
1192
Attributes related to the identity of the source branch like
1193
branch nickname will be cleaned, a working tree is created
1194
whether one existed before or not; and a local branch is always
1197
if revision_id is not None, then the clone operation may tune
1198
itself to download less data.
1199
:param accelerator_tree: A tree which can be used for retrieving file
1200
contents more quickly than the revision tree, i.e. a workingtree.
1201
The revision tree will be used for cases where accelerator_tree's
1202
content is different.
1203
:param hardlink: If true, hard-link files from accelerator_tree,
1205
:param stacked: If true, create a stacked branch referring to the
1206
location of this control directory.
1207
:param create_tree_if_local: If true, a working-tree will be created
1208
when working locally.
915
def create(cls, base, format=None, possible_transports=None):
916
"""Create a new BzrDir at the url 'base'.
918
:param format: If supplied, the format of branch to create. If not
919
supplied, the default is used.
920
:param possible_transports: If supplied, a list of transports that
921
can be reused to share a remote connection.
1210
target_transport = get_transport(url, possible_transports)
1211
target_transport.ensure_base()
1212
cloning_format = self.cloning_metadir(stacked)
1213
# Create/update the result branch
1214
result = cloning_format.initialize_on_transport(target_transport)
1215
# if a stacked branch wasn't requested, we don't create one
1216
# even if the origin was stacked
1217
stacked_branch_url = None
1218
if source_branch is not None:
1220
stacked_branch_url = self.root_transport.base
1221
source_repository = source_branch.repository
1224
source_branch = self.open_branch()
1225
source_repository = source_branch.repository
1227
stacked_branch_url = self.root_transport.base
1228
except errors.NotBranchError:
1229
source_branch = None
1231
source_repository = self.open_repository()
1232
except errors.NoRepositoryPresent:
1233
source_repository = None
1234
repository_policy = result.determine_repository_policy(
1235
force_new_repo, stacked_branch_url, require_stacking=stacked)
1236
result_repo, is_new_repo = repository_policy.acquire_repository()
1237
if is_new_repo and revision_id is not None and not stacked:
1238
fetch_spec = graph.PendingAncestryResult(
1239
[revision_id], source_repository)
1242
if source_repository is not None:
1243
# Fetch while stacked to prevent unstacked fetch from
1245
if fetch_spec is None:
1246
result_repo.fetch(source_repository, revision_id=revision_id)
1248
result_repo.fetch(source_repository, fetch_spec=fetch_spec)
1250
if source_branch is None:
1251
# this is for sprouting a bzrdir without a branch; is that
1253
# Not especially, but it's part of the contract.
1254
result_branch = result.create_branch()
1256
result_branch = source_branch.sprout(result,
1257
revision_id=revision_id, repository_policy=repository_policy)
1258
mutter("created new branch %r" % (result_branch,))
1260
# Create/update the result working tree
1261
if (create_tree_if_local and
1262
isinstance(target_transport, local.LocalTransport) and
1263
(result_repo is None or result_repo.make_working_trees())):
1264
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
1268
if wt.path2id('') is None:
1270
wt.set_root_id(self.open_workingtree.get_root_id())
1271
except errors.NoWorkingTree:
1277
if recurse == 'down':
1279
basis = wt.basis_tree()
1281
subtrees = basis.iter_references()
1282
elif result_branch is not None:
1283
basis = result_branch.basis_tree()
1285
subtrees = basis.iter_references()
1286
elif source_branch is not None:
1287
basis = source_branch.basis_tree()
1289
subtrees = basis.iter_references()
1294
for path, file_id in subtrees:
1295
target = urlutils.join(url, urlutils.escape(path))
1296
sublocation = source_branch.reference_parent(file_id, path)
1297
sublocation.bzrdir.sprout(target,
1298
basis.get_reference_revision(file_id, path),
1299
force_new_repo=force_new_repo, recurse=recurse,
1302
if basis is not None:
1306
def push_branch(self, source, revision_id=None, overwrite=False,
1307
remember=False, create_prefix=False):
1308
"""Push the source branch into this BzrDir."""
1310
# If we can open a branch, use its direct repository, otherwise see
1311
# if there is a repository without a branch.
1313
br_to = self.open_branch()
1314
except errors.NotBranchError:
1315
# Didn't find a branch, can we find a repository?
1316
repository_to = self.find_repository()
1318
# Found a branch, so we must have found a repository
1319
repository_to = br_to.repository
1321
push_result = PushResult()
1322
push_result.source_branch = source
1324
# We have a repository but no branch, copy the revisions, and then
1326
repository_to.fetch(source.repository, revision_id=revision_id)
1327
br_to = source.clone(self, revision_id=revision_id)
1328
if source.get_push_location() is None or remember:
1329
source.set_push_location(br_to.base)
1330
push_result.stacked_on = None
1331
push_result.branch_push_result = None
1332
push_result.old_revno = None
1333
push_result.old_revid = _mod_revision.NULL_REVISION
1334
push_result.target_branch = br_to
1335
push_result.master_branch = None
1336
push_result.workingtree_updated = False
1338
# We have successfully opened the branch, remember if necessary:
1339
if source.get_push_location() is None or remember:
1340
source.set_push_location(br_to.base)
1342
tree_to = self.open_workingtree()
1343
except errors.NotLocalUrl:
1344
push_result.branch_push_result = source.push(br_to,
1345
overwrite, stop_revision=revision_id)
1346
push_result.workingtree_updated = False
1347
except errors.NoWorkingTree:
1348
push_result.branch_push_result = source.push(br_to,
1349
overwrite, stop_revision=revision_id)
1350
push_result.workingtree_updated = None # Not applicable
1352
tree_to.lock_write()
1354
push_result.branch_push_result = source.push(
1355
tree_to.branch, overwrite, stop_revision=revision_id)
1359
push_result.workingtree_updated = True
1360
push_result.old_revno = push_result.branch_push_result.old_revno
1361
push_result.old_revid = push_result.branch_push_result.old_revid
1362
push_result.target_branch = \
1363
push_result.branch_push_result.target_branch
923
if cls is not BzrDir:
924
raise AssertionError("BzrDir.create always creates the"
925
"default format, not one of %r" % cls)
926
t = _mod_transport.get_transport(base, possible_transports)
929
format = controldir.ControlDirFormat.get_default_format()
930
return format.initialize_on_transport(t)
1367
933
class BzrDirHooks(hooks.Hooks):
1880
1439
return config.TransportConfig(self.transport, 'control.conf')
1883
class BzrDirFormat(object):
1884
"""An encapsulation of the initialization and open routines for a format.
1886
Formats provide three things:
1887
* An initialization routine,
1442
class BzrProber(controldir.Prober):
1443
"""Prober for formats that use a .bzr/ control directory."""
1446
"""The known .bzr formats."""
1449
def register_bzrdir_format(klass, format):
1450
klass._formats[format.get_format_string()] = format
1453
def unregister_bzrdir_format(klass, format):
1454
del klass._formats[format.get_format_string()]
1457
def probe_transport(klass, transport):
1458
"""Return the .bzrdir style format present in a directory."""
1460
format_string = transport.get_bytes(".bzr/branch-format")
1461
except errors.NoSuchFile:
1462
raise errors.NotBranchError(path=transport.base)
1464
return klass._formats[format_string]
1466
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1469
controldir.ControlDirFormat.register_prober(BzrProber)
1472
class RemoteBzrProber(controldir.Prober):
1473
"""Prober for remote servers that provide a Bazaar smart server."""
1476
def probe_transport(klass, transport):
1477
"""Return a RemoteBzrDirFormat object if it looks possible."""
1479
medium = transport.get_smart_medium()
1480
except (NotImplementedError, AttributeError,
1481
errors.TransportNotPossible, errors.NoSmartMedium,
1482
errors.SmartProtocolError):
1483
# no smart server, so not a branch for this format type.
1484
raise errors.NotBranchError(path=transport.base)
1486
# Decline to open it if the server doesn't support our required
1487
# version (3) so that the VFS-based transport will do it.
1488
if medium.should_probe():
1490
server_version = medium.protocol_version()
1491
except errors.SmartProtocolError:
1492
# Apparently there's no usable smart server there, even though
1493
# the medium supports the smart protocol.
1494
raise errors.NotBranchError(path=transport.base)
1495
if server_version != '2':
1496
raise errors.NotBranchError(path=transport.base)
1497
return RemoteBzrDirFormat()
1500
class BzrDirFormat(controldir.ControlDirFormat):
1501
"""ControlDirFormat base class for .bzr/ directories.
1891
1503
Formats are placed in a dict by their format string for reference
1892
1504
during bzrdir opening. These should be subclasses of BzrDirFormat
1895
1507
Once a format is deprecated, just deprecate the initialize and open
1896
1508
methods on the format class. Do not deprecate the object, as the
1897
1509
object will be created every system load.
1899
:cvar colocated_branches: Whether this formats supports colocated branches.
1902
_default_format = None
1903
"""The default format used for new .bzr dirs."""
1906
"""The known formats."""
1908
_control_formats = []
1909
"""The registered control formats - .bzr, ....
1911
This is a list of BzrDirFormat objects.
1914
_control_server_formats = []
1915
"""The registered control server formats, e.g. RemoteBzrDirs.
1917
This is a list of BzrDirFormat objects.
1920
1512
_lock_file_name = 'branch-lock'
1922
colocated_branches = False
1923
"""Whether co-located branches are supported for this control dir format.
1926
1514
# _lock_class must be set in subclasses to the lock type, typ.
1927
1515
# TransportLock or LockDir
1930
def find_format(klass, transport, _server_formats=True):
1931
"""Return the format present at transport."""
1933
formats = klass._control_server_formats + klass._control_formats
1935
formats = klass._control_formats
1936
for format in formats:
1938
return format.probe_transport(transport)
1939
except errors.NotBranchError:
1940
# this format does not find a control dir here.
1942
raise errors.NotBranchError(path=transport.base)
1945
def probe_transport(klass, transport):
1946
"""Return the .bzrdir style format present in a directory."""
1948
format_string = transport.get_bytes(".bzr/branch-format")
1949
except errors.NoSuchFile:
1950
raise errors.NotBranchError(path=transport.base)
1953
return klass._formats[format_string]
1955
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1958
def get_default_format(klass):
1959
"""Return the current default format."""
1960
return klass._default_format
1962
1517
def get_format_string(self):
1963
1518
"""Return the ASCII format string that identifies this format."""
1964
1519
raise NotImplementedError(self.get_format_string)
1966
def get_format_description(self):
1967
"""Return the short description for this format."""
1968
raise NotImplementedError(self.get_format_description)
1970
def get_converter(self, format=None):
1971
"""Return the converter to use to convert bzrdirs needing converts.
1973
This returns a bzrlib.bzrdir.Converter object.
1975
This should return the best upgrader to step this format towards the
1976
current default format. In the case of plugins we can/should provide
1977
some means for them to extend the range of returnable converters.
1979
:param format: Optional format to override the default format of the
1982
raise NotImplementedError(self.get_converter)
1984
def initialize(self, url, possible_transports=None):
1985
"""Create a bzr control dir at this url and return an opened copy.
1987
While not deprecated, this method is very specific and its use will
1988
lead to many round trips to setup a working environment. See
1989
initialize_on_transport_ex for a [nearly] all-in-one method.
1991
Subclasses should typically override initialize_on_transport
1992
instead of this method.
1994
return self.initialize_on_transport(get_transport(url,
1995
possible_transports))
1997
1521
def initialize_on_transport(self, transport):
1998
1522
"""Initialize a new bzrdir in the base directory of a Transport."""
2147
1671
control_files.unlock()
2148
1672
return self.open(transport, _found=True)
2150
def is_supported(self):
2151
"""Is this format supported?
2153
Supported formats must be initializable and openable.
2154
Unsupported formats may not support initialization or committing or
2155
some other features depending on the reason for not being supported.
2159
def network_name(self):
2160
"""A simple byte string uniquely identifying this format for RPC calls.
2162
Bzr control formats use thir disk format string to identify the format
2163
over the wire. Its possible that other control formats have more
2164
complex detection requirements, so we permit them to use any unique and
2165
immutable string they desire.
2167
raise NotImplementedError(self.network_name)
2169
def same_model(self, target_format):
2170
return (self.repository_format.rich_root_data ==
2171
target_format.rich_root_data)
2174
def known_formats(klass):
2175
"""Return all the known formats.
2177
Concrete formats should override _known_formats.
2179
# There is double indirection here to make sure that control
2180
# formats used by more than one dir format will only be probed
2181
# once. This can otherwise be quite expensive for remote connections.
2183
for format in klass._control_formats:
2184
result.update(format._known_formats())
2188
def _known_formats(klass):
2189
"""Return the known format instances for this control format."""
2190
return set(klass._formats.values())
2192
1674
def open(self, transport, _found=False):
2193
1675
"""Return an instance of this format for the dir transport points at.
2195
1677
_found is a private parameter, do not use it.
2198
found_format = BzrDirFormat.find_format(transport)
1680
found_format = controldir.ControlDirFormat.find_format(transport)
2199
1681
if not isinstance(found_format, self.__class__):
2200
1682
raise AssertionError("%s was asked to open %s, but it seems to need "
2217
1699
def register_format(klass, format):
2218
klass._formats[format.get_format_string()] = format
1700
BzrProber.register_bzrdir_format(format)
2219
1701
# bzr native formats have a network name of their format string.
2220
network_format_registry.register(format.get_format_string(), format.__class__)
2223
def register_control_format(klass, format):
2224
"""Register a format that does not use '.bzr' for its control dir.
2226
TODO: This should be pulled up into a 'ControlDirFormat' base class
2227
which BzrDirFormat can inherit from, and renamed to register_format
2228
there. It has been done without that for now for simplicity of
2231
klass._control_formats.append(format)
2234
def register_control_server_format(klass, format):
2235
"""Register a control format for client-server environments.
2237
These formats will be tried before ones registered with
2238
register_control_format. This gives implementations that decide to the
2239
chance to grab it before anything looks at the contents of the format
2242
klass._control_server_formats.append(format)
2245
def _set_default_format(klass, format):
2246
"""Set default format (for testing behavior of defaults only)"""
2247
klass._default_format = format
2251
return self.get_format_description().rstrip()
1702
controldir.network_format_registry.register(format.get_format_string(), format.__class__)
1703
controldir.ControlDirFormat.register_format(format)
2253
1705
def _supply_sub_formats_to(self, other_format):
2254
1706
"""Give other_format the same values for sub formats as this has.
3485
2904
BzrDirMetaFormat1._set_repository_format) #.im_func)
3488
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
3491
class BzrDirFormatInfo(object):
3493
def __init__(self, native, deprecated, hidden, experimental):
3494
self.deprecated = deprecated
3495
self.native = native
3496
self.hidden = hidden
3497
self.experimental = experimental
3500
class BzrDirFormatRegistry(registry.Registry):
3501
"""Registry of user-selectable BzrDir subformats.
3503
Differs from BzrDirFormat._control_formats in that it provides sub-formats,
3504
e.g. BzrDirMeta1 with weave repository. Also, it's more user-oriented.
3508
"""Create a BzrDirFormatRegistry."""
3509
self._aliases = set()
3510
self._registration_order = list()
3511
super(BzrDirFormatRegistry, self).__init__()
3514
"""Return a set of the format names which are aliases."""
3515
return frozenset(self._aliases)
3517
def register_metadir(self, key,
3518
repository_format, help, native=True, deprecated=False,
3524
"""Register a metadir subformat.
3526
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
3527
by the Repository/Branch/WorkingTreeformats.
3529
:param repository_format: The fully-qualified repository format class
3531
:param branch_format: Fully-qualified branch format class name as
3533
:param tree_format: Fully-qualified tree format class name as
3536
# This should be expanded to support setting WorkingTree and Branch
3537
# formats, once BzrDirMetaFormat1 supports that.
3538
def _load(full_name):
3539
mod_name, factory_name = full_name.rsplit('.', 1)
3541
mod = __import__(mod_name, globals(), locals(),
3543
except ImportError, e:
3544
raise ImportError('failed to load %s: %s' % (full_name, e))
3546
factory = getattr(mod, factory_name)
3547
except AttributeError:
3548
raise AttributeError('no factory %s in module %r'
3553
bd = BzrDirMetaFormat1()
3554
if branch_format is not None:
3555
bd.set_branch_format(_load(branch_format))
3556
if tree_format is not None:
3557
bd.workingtree_format = _load(tree_format)
3558
if repository_format is not None:
3559
bd.repository_format = _load(repository_format)
3561
self.register(key, helper, help, native, deprecated, hidden,
3562
experimental, alias)
3564
def register(self, key, factory, help, native=True, deprecated=False,
3565
hidden=False, experimental=False, alias=False):
3566
"""Register a BzrDirFormat factory.
3568
The factory must be a callable that takes one parameter: the key.
3569
It must produce an instance of the BzrDirFormat when called.
3571
This function mainly exists to prevent the info object from being
3574
registry.Registry.register(self, key, factory, help,
3575
BzrDirFormatInfo(native, deprecated, hidden, experimental))
3577
self._aliases.add(key)
3578
self._registration_order.append(key)
3580
def register_lazy(self, key, module_name, member_name, help, native=True,
3581
deprecated=False, hidden=False, experimental=False, alias=False):
3582
registry.Registry.register_lazy(self, key, module_name, member_name,
3583
help, BzrDirFormatInfo(native, deprecated, hidden, experimental))
3585
self._aliases.add(key)
3586
self._registration_order.append(key)
3588
def set_default(self, key):
3589
"""Set the 'default' key to be a clone of the supplied key.
3591
This method must be called once and only once.
3593
registry.Registry.register(self, 'default', self.get(key),
3594
self.get_help(key), info=self.get_info(key))
3595
self._aliases.add('default')
3597
def set_default_repository(self, key):
3598
"""Set the FormatRegistry default and Repository default.
3600
This is a transitional method while Repository.set_default_format
3603
if 'default' in self:
3604
self.remove('default')
3605
self.set_default(key)
3606
format = self.get('default')()
3608
def make_bzrdir(self, key):
3609
return self.get(key)()
3611
def help_topic(self, topic):
3613
default_realkey = None
3614
default_help = self.get_help('default')
3616
for key in self._registration_order:
3617
if key == 'default':
3619
help = self.get_help(key)
3620
if help == default_help:
3621
default_realkey = key
3623
help_pairs.append((key, help))
3625
def wrapped(key, help, info):
3627
help = '(native) ' + help
3628
return ':%s:\n%s\n\n' % (key,
3629
textwrap.fill(help, initial_indent=' ',
3630
subsequent_indent=' ',
3631
break_long_words=False))
3632
if default_realkey is not None:
3633
output += wrapped(default_realkey, '(default) %s' % default_help,
3634
self.get_info('default'))
3635
deprecated_pairs = []
3636
experimental_pairs = []
3637
for key, help in help_pairs:
3638
info = self.get_info(key)
3641
elif info.deprecated:
3642
deprecated_pairs.append((key, help))
3643
elif info.experimental:
3644
experimental_pairs.append((key, help))
3646
output += wrapped(key, help, info)
3647
output += "\nSee :doc:`formats-help` for more about storage formats."
3649
if len(experimental_pairs) > 0:
3650
other_output += "Experimental formats are shown below.\n\n"
3651
for key, help in experimental_pairs:
3652
info = self.get_info(key)
3653
other_output += wrapped(key, help, info)
3656
"No experimental formats are available.\n\n"
3657
if len(deprecated_pairs) > 0:
3658
other_output += "\nDeprecated formats are shown below.\n\n"
3659
for key, help in deprecated_pairs:
3660
info = self.get_info(key)
3661
other_output += wrapped(key, help, info)
3664
"\nNo deprecated formats are available.\n\n"
3666
"\nSee :doc:`formats-help` for more about storage formats."
3668
if topic == 'other-formats':
2907
controldir.ControlDirFormat.register_server_prober(RemoteBzrProber)
3674
2910
class RepositoryAcquisitionPolicy(object):
3828
3064
return self._repository, False
3831
# Please register new formats after old formats so that formats
3832
# appear in chronological order and format descriptions can build
3834
format_registry = BzrDirFormatRegistry()
3067
def register_metadir(registry, key,
3068
repository_format, help, native=True, deprecated=False,
3074
"""Register a metadir subformat.
3076
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
3077
by the Repository/Branch/WorkingTreeformats.
3079
:param repository_format: The fully-qualified repository format class
3081
:param branch_format: Fully-qualified branch format class name as
3083
:param tree_format: Fully-qualified tree format class name as
3086
# This should be expanded to support setting WorkingTree and Branch
3087
# formats, once BzrDirMetaFormat1 supports that.
3088
def _load(full_name):
3089
mod_name, factory_name = full_name.rsplit('.', 1)
3091
factory = pyutils.get_named_object(mod_name, factory_name)
3092
except ImportError, e:
3093
raise ImportError('failed to load %s: %s' % (full_name, e))
3094
except AttributeError:
3095
raise AttributeError('no factory %s in module %r'
3096
% (full_name, sys.modules[mod_name]))
3100
bd = BzrDirMetaFormat1()
3101
if branch_format is not None:
3102
bd.set_branch_format(_load(branch_format))
3103
if tree_format is not None:
3104
bd.workingtree_format = _load(tree_format)
3105
if repository_format is not None:
3106
bd.repository_format = _load(repository_format)
3108
registry.register(key, helper, help, native, deprecated, hidden,
3109
experimental, alias)
3835
3111
# The pre-0.8 formats have their repository format network name registered in
3836
3112
# repository.py. MetaDir formats have their repository format network name
3837
3113
# inferred from their disk format string.
3838
format_registry.register('weave', BzrDirFormat6,
3114
controldir.format_registry.register('weave', BzrDirFormat6,
3839
3115
'Pre-0.8 format. Slower than knit and does not'
3840
3116
' support checkouts or shared repositories.',
3842
3118
deprecated=True)
3843
format_registry.register_metadir('metaweave',
3119
register_metadir(controldir.format_registry, 'metaweave',
3844
3120
'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3845
3121
'Transitional format in 0.8. Slower than knit.',
3846
3122
branch_format='bzrlib.branch.BzrBranchFormat5',
3847
3123
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3849
3125
deprecated=True)
3850
format_registry.register_metadir('knit',
3126
register_metadir(controldir.format_registry, 'knit',
3851
3127
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3852
3128
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
3853
3129
branch_format='bzrlib.branch.BzrBranchFormat5',
3854
3130
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3856
3132
deprecated=True)
3857
format_registry.register_metadir('dirstate',
3133
register_metadir(controldir.format_registry, 'dirstate',
3858
3134
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3859
3135
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
3860
3136
'above when accessed over the network.',
3997
3259
# This current non-alias status is simply because we did not introduce a
3998
3260
# chk based subtree format.
3262
register_metadir(controldir.format_registry, 'development5-subtree',
3263
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3264
help='Development format, subtree variant. Can convert data to and '
3265
'from pack-0.92-subtree (and anything compatible with '
3266
'pack-0.92-subtree) format repositories. Repositories and branches in '
3267
'this format can only be read by bzr.dev. Please read '
3268
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3270
branch_format='bzrlib.branch.BzrBranchFormat7',
3271
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
4001
3277
# And the development formats above will have aliased one of the following:
4002
format_registry.register_metadir('development6-rich-root',
4003
'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
4004
help='pack-1.9 with 255-way hashed CHK inv, group compress, rich roots '
4006
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
4008
branch_format='bzrlib.branch.BzrBranchFormat7',
4009
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
4014
format_registry.register_metadir('development7-rich-root',
4015
'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK2',
4016
help='pack-1.9 with 255-way hashed CHK inv, bencode revision, group compress, '
4017
'rich roots. Please read '
4018
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
4020
branch_format='bzrlib.branch.BzrBranchFormat7',
4021
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
4026
format_registry.register_metadir('2a',
3279
# Finally, the current format.
3280
register_metadir(controldir.format_registry, '2a',
4027
3281
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
4028
3282
help='First format for bzr 2.0 series.\n'
4029
3283
'Uses group-compress storage.\n'
added
removed
bzrlib/bzrdir.py
