202
170
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
173
def clone_on_transport(self, transport, revision_id=None,
225
174
force_new_repo=False, preserve_stacking=False, stacked_on=None,
226
create_prefix=False, use_existing_dir=True):
175
create_prefix=False, use_existing_dir=True, no_tree=False):
227
176
"""Clone this bzrdir and its contents to transport verbatim.
229
178
:param transport: The transport for the location to produce the clone
602
501
format=format).bzrdir
603
502
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.
504
@deprecated_method(deprecated_in((2, 3, 0)))
505
def generate_backup_name(self, base):
506
return self._available_backup_name(base)
508
def _available_backup_name(self, base):
509
"""Find a non-existing backup file name based on base.
511
See bzrlib.osutils.available_backup_name about race conditions.
616
raise NotImplementedError(self.create_workingtree)
513
return osutils.available_backup_name(base, self.root_transport.has)
618
515
def backup_bzrdir(self):
619
516
"""Backup this bzr control directory.
621
518
: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
521
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
523
old_path = self.root_transport.abspath('.bzr')
524
backup_dir = self._available_backup_name('backup.bzr')
639
525
new_path = self.root_transport.abspath(backup_dir)
640
ui.ui_factory.note('making backup of %s\n to %s' % (old_path, new_path,))
526
ui.ui_factory.note('making backup of %s\n to %s'
527
% (old_path, new_path,))
641
528
self.root_transport.copy_tree('.bzr', backup_dir)
642
529
return (old_path, new_path)
1061
845
raise errors.NotBranchError(location)
1062
846
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
848
def _cloning_metadir(self):
1118
849
"""Produce a metadir suitable for cloning with.
1177
908
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.
912
def create(cls, base, format=None, possible_transports=None):
913
"""Create a new BzrDir at the url 'base'.
915
:param format: If supplied, the format of branch to create. If not
916
supplied, the default is used.
917
:param possible_transports: If supplied, a list of transports that
918
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
920
if cls is not BzrDir:
921
raise AssertionError("BzrDir.create always creates the"
922
"default format, not one of %r" % cls)
923
t = get_transport(base, possible_transports)
926
format = controldir.ControlDirFormat.get_default_format()
927
return format.initialize_on_transport(t)
1367
931
class BzrDirHooks(hooks.Hooks):
1880
1447
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,
1450
class BzrProber(controldir.Prober):
1451
"""Prober for formats that use a .bzr/ control directory."""
1454
"""The known .bzr formats."""
1457
def register_bzrdir_format(klass, format):
1458
klass._formats[format.get_format_string()] = format
1461
def unregister_bzrdir_format(klass, format):
1462
del klass._formats[format.get_format_string()]
1465
def probe_transport(klass, transport):
1466
"""Return the .bzrdir style format present in a directory."""
1468
format_string = transport.get_bytes(".bzr/branch-format")
1469
except errors.NoSuchFile:
1470
raise errors.NotBranchError(path=transport.base)
1472
return klass._formats[format_string]
1474
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1477
controldir.ControlDirFormat.register_prober(BzrProber)
1480
class RemoteBzrProber(controldir.Prober):
1481
"""Prober for remote servers that provide a Bazaar smart server."""
1484
def probe_transport(klass, transport):
1485
"""Return a RemoteBzrDirFormat object if it looks possible."""
1487
medium = transport.get_smart_medium()
1488
except (NotImplementedError, AttributeError,
1489
errors.TransportNotPossible, errors.NoSmartMedium,
1490
errors.SmartProtocolError):
1491
# no smart server, so not a branch for this format type.
1492
raise errors.NotBranchError(path=transport.base)
1494
# Decline to open it if the server doesn't support our required
1495
# version (3) so that the VFS-based transport will do it.
1496
if medium.should_probe():
1498
server_version = medium.protocol_version()
1499
except errors.SmartProtocolError:
1500
# Apparently there's no usable smart server there, even though
1501
# the medium supports the smart protocol.
1502
raise errors.NotBranchError(path=transport.base)
1503
if server_version != '2':
1504
raise errors.NotBranchError(path=transport.base)
1505
return RemoteBzrDirFormat()
1508
class BzrDirFormat(controldir.ControlDirFormat):
1509
"""ControlDirFormat base class for .bzr/ directories.
1891
1511
Formats are placed in a dict by their format string for reference
1892
1512
during bzrdir opening. These should be subclasses of BzrDirFormat
1895
1515
Once a format is deprecated, just deprecate the initialize and open
1896
1516
methods on the format class. Do not deprecate the object, as the
1897
1517
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
1520
_lock_file_name = 'branch-lock'
1922
colocated_branches = False
1923
"""Whether co-located branches are supported for this control dir format.
1926
1522
# _lock_class must be set in subclasses to the lock type, typ.
1927
1523
# 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
1525
def get_format_string(self):
1963
1526
"""Return the ASCII format string that identifies this format."""
1964
1527
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
1529
def initialize_on_transport(self, transport):
1998
1530
"""Initialize a new bzrdir in the base directory of a Transport."""
2147
1679
control_files.unlock()
2148
1680
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
1682
def open(self, transport, _found=False):
2193
1683
"""Return an instance of this format for the dir transport points at.
2195
1685
_found is a private parameter, do not use it.
2198
found_format = BzrDirFormat.find_format(transport)
1688
found_format = controldir.ControlDirFormat.find_format(transport)
2199
1689
if not isinstance(found_format, self.__class__):
2200
1690
raise AssertionError("%s was asked to open %s, but it seems to need "
2217
1707
def register_format(klass, format):
2218
klass._formats[format.get_format_string()] = format
1708
BzrProber.register_bzrdir_format(format)
2219
1709
# 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()
1710
controldir.network_format_registry.register(format.get_format_string(), format.__class__)
1711
controldir.ControlDirFormat.register_format(format)
2253
1713
def _supply_sub_formats_to(self, other_format):
2254
1714
"""Give other_format the same values for sub formats as this has.
3485
2915
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':
2918
controldir.ControlDirFormat.register_server_prober(RemoteBzrProber)
3674
2921
class RepositoryAcquisitionPolicy(object):
3828
3075
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()
3078
def register_metadir(registry, key,
3079
repository_format, help, native=True, deprecated=False,
3085
"""Register a metadir subformat.
3087
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
3088
by the Repository/Branch/WorkingTreeformats.
3090
:param repository_format: The fully-qualified repository format class
3092
:param branch_format: Fully-qualified branch format class name as
3094
:param tree_format: Fully-qualified tree format class name as
3097
# This should be expanded to support setting WorkingTree and Branch
3098
# formats, once BzrDirMetaFormat1 supports that.
3099
def _load(full_name):
3100
mod_name, factory_name = full_name.rsplit('.', 1)
3102
factory = pyutils.get_named_object(mod_name, factory_name)
3103
except ImportError, e:
3104
raise ImportError('failed to load %s: %s' % (full_name, e))
3105
except AttributeError:
3106
raise AttributeError('no factory %s in module %r'
3107
% (full_name, sys.modules[mod_name]))
3111
bd = BzrDirMetaFormat1()
3112
if branch_format is not None:
3113
bd.set_branch_format(_load(branch_format))
3114
if tree_format is not None:
3115
bd.workingtree_format = _load(tree_format)
3116
if repository_format is not None:
3117
bd.repository_format = _load(repository_format)
3119
registry.register(key, helper, help, native, deprecated, hidden,
3120
experimental, alias)
3835
3122
# The pre-0.8 formats have their repository format network name registered in
3836
3123
# repository.py. MetaDir formats have their repository format network name
3837
3124
# inferred from their disk format string.
3838
format_registry.register('weave', BzrDirFormat6,
3125
controldir.format_registry.register('weave', BzrDirFormat6,
3839
3126
'Pre-0.8 format. Slower than knit and does not'
3840
3127
' support checkouts or shared repositories.',
3842
3129
deprecated=True)
3843
format_registry.register_metadir('metaweave',
3130
register_metadir(controldir.format_registry, 'metaweave',
3844
3131
'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3845
3132
'Transitional format in 0.8. Slower than knit.',
3846
3133
branch_format='bzrlib.branch.BzrBranchFormat5',
3847
3134
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3849
3136
deprecated=True)
3850
format_registry.register_metadir('knit',
3137
register_metadir(controldir.format_registry, 'knit',
3851
3138
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3852
3139
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
3853
3140
branch_format='bzrlib.branch.BzrBranchFormat5',
3854
3141
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3856
3143
deprecated=True)
3857
format_registry.register_metadir('dirstate',
3144
register_metadir(controldir.format_registry, 'dirstate',
3858
3145
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3859
3146
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
3860
3147
'above when accessed over the network.',
added
removed
bzrlib/bzrdir.py
