602
497
format=format).bzrdir
603
498
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.
500
@deprecated_method(deprecated_in((2, 3, 0)))
501
def generate_backup_name(self, base):
502
return self._available_backup_name(base)
504
def _available_backup_name(self, base):
505
"""Find a non-existing backup file name based on base.
507
See bzrlib.osutils.available_backup_name about race conditions.
616
raise NotImplementedError(self.create_workingtree)
509
return osutils.available_backup_name(base, self.root_transport.has)
618
511
def backup_bzrdir(self):
619
512
"""Backup this bzr control directory.
621
514
: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
517
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
519
old_path = self.root_transport.abspath('.bzr')
520
backup_dir = self._available_backup_name('backup.bzr')
639
521
new_path = self.root_transport.abspath(backup_dir)
640
ui.ui_factory.note('making backup of %s\n to %s' % (old_path, new_path,))
522
ui.ui_factory.note('making backup of %s\n to %s'
523
% (old_path, new_path,))
641
524
self.root_transport.copy_tree('.bzr', backup_dir)
642
525
return (old_path, new_path)
1061
841
raise errors.NotBranchError(location)
1062
842
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
844
def _cloning_metadir(self):
1118
845
"""Produce a metadir suitable for cloning with.
1177
904
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.
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
908
def create(cls, base, format=None, possible_transports=None):
909
"""Create a new BzrDir at the url 'base'.
911
:param format: If supplied, the format of branch to create. If not
912
supplied, the default is used.
913
:param possible_transports: If supplied, a list of transports that
914
can be reused to share a remote connection.
916
if cls is not BzrDir:
917
raise AssertionError("BzrDir.create always creates the"
918
"default format, not one of %r" % cls)
919
t = _mod_transport.get_transport(base, possible_transports)
922
format = controldir.ControlDirFormat.get_default_format()
923
return format.initialize_on_transport(t)
925
def get_branch_transport(self, branch_format, name=None):
926
"""Get the transport for use by branch format in this BzrDir.
928
Note that bzr dirs that do not support format strings will raise
929
IncompatibleFormat if the branch format they are given has
930
a format string, and vice versa.
932
If branch_format is None, the transport is returned with no
933
checking. If it is not None, then the returned transport is
934
guaranteed to point to an existing directory ready for use.
936
raise NotImplementedError(self.get_branch_transport)
938
def get_repository_transport(self, repository_format):
939
"""Get the transport for use by repository format in this BzrDir.
941
Note that bzr dirs that do not support format strings will raise
942
IncompatibleFormat if the repository format they are given has
943
a format string, and vice versa.
945
If repository_format is None, the transport is returned with no
946
checking. If it is not None, then the returned transport is
947
guaranteed to point to an existing directory ready for use.
949
raise NotImplementedError(self.get_repository_transport)
951
def get_workingtree_transport(self, tree_format):
952
"""Get the transport for use by workingtree format in this BzrDir.
954
Note that bzr dirs that do not support format strings will raise
955
IncompatibleFormat if the workingtree format they are given has a
956
format string, and vice versa.
958
If workingtree_format is None, the transport is returned with no
959
checking. If it is not None, then the returned transport is
960
guaranteed to point to an existing directory ready for use.
962
raise NotImplementedError(self.get_workingtree_transport)
1367
965
class BzrDirHooks(hooks.Hooks):
1880
1471
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,
1474
class BzrProber(controldir.Prober):
1475
"""Prober for formats that use a .bzr/ control directory."""
1477
formats = registry.FormatRegistry(controldir.network_format_registry)
1478
"""The known .bzr formats."""
1481
@deprecated_method(deprecated_in((2, 4, 0)))
1482
def register_bzrdir_format(klass, format):
1483
klass.formats.register(format.get_format_string(), format)
1486
@deprecated_method(deprecated_in((2, 4, 0)))
1487
def unregister_bzrdir_format(klass, format):
1488
klass.formats.remove(format.get_format_string())
1491
def probe_transport(klass, transport):
1492
"""Return the .bzrdir style format present in a directory."""
1494
format_string = transport.get_bytes(".bzr/branch-format")
1495
except errors.NoSuchFile:
1496
raise errors.NotBranchError(path=transport.base)
1498
return klass.formats.get(format_string)
1500
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1503
controldir.ControlDirFormat.register_prober(BzrProber)
1506
class RemoteBzrProber(controldir.Prober):
1507
"""Prober for remote servers that provide a Bazaar smart server."""
1510
def probe_transport(klass, transport):
1511
"""Return a RemoteBzrDirFormat object if it looks possible."""
1513
medium = transport.get_smart_medium()
1514
except (NotImplementedError, AttributeError,
1515
errors.TransportNotPossible, errors.NoSmartMedium,
1516
errors.SmartProtocolError):
1517
# no smart server, so not a branch for this format type.
1518
raise errors.NotBranchError(path=transport.base)
1520
# Decline to open it if the server doesn't support our required
1521
# version (3) so that the VFS-based transport will do it.
1522
if medium.should_probe():
1524
server_version = medium.protocol_version()
1525
except errors.SmartProtocolError:
1526
# Apparently there's no usable smart server there, even though
1527
# the medium supports the smart protocol.
1528
raise errors.NotBranchError(path=transport.base)
1529
if server_version != '2':
1530
raise errors.NotBranchError(path=transport.base)
1531
return RemoteBzrDirFormat()
1534
class BzrDirFormat(controldir.ControlDirFormat):
1535
"""ControlDirFormat base class for .bzr/ directories.
1891
1537
Formats are placed in a dict by their format string for reference
1892
1538
during bzrdir opening. These should be subclasses of BzrDirFormat
1895
1541
Once a format is deprecated, just deprecate the initialize and open
1896
1542
methods on the format class. Do not deprecate the object, as the
1897
1543
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
1546
_lock_file_name = 'branch-lock'
1922
colocated_branches = False
1923
"""Whether co-located branches are supported for this control dir format.
1926
1548
# _lock_class must be set in subclasses to the lock type, typ.
1927
1549
# 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
1551
def get_format_string(self):
1963
1552
"""Return the ASCII format string that identifies this format."""
1964
1553
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
1555
def initialize_on_transport(self, transport):
1998
1556
"""Initialize a new bzrdir in the base directory of a Transport."""
2147
1705
control_files.unlock()
2148
1706
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
1708
def open(self, transport, _found=False):
2193
1709
"""Return an instance of this format for the dir transport points at.
2195
1711
_found is a private parameter, do not use it.
2198
found_format = BzrDirFormat.find_format(transport)
1714
found_format = controldir.ControlDirFormat.find_format(transport)
2199
1715
if not isinstance(found_format, self.__class__):
2200
1716
raise AssertionError("%s was asked to open %s, but it seems to need "
2217
1733
def register_format(klass, format):
2218
klass._formats[format.get_format_string()] = format
2219
# 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()
1734
"""Register a new BzrDir format.
1736
BzrProber.formats.register(format.get_format_string(), format)
1737
controldir.ControlDirFormat.register_format(format)
1740
def register_lazy_format(klass, format_string, module_name, member_name):
1741
"""Lazily register a new BzrDir format.
1743
:param format_string: Format string
1744
:param module_name: Name of module with the BzrDirFormat subclass
1745
:param member_name: Class name of the BzrDirFormat
1747
BzrProber.formats.register_lazy(format_string, module_name,
1749
controldir.ControlDirFormat.register_lazy_format(
1750
module_name, member_name)
2253
1752
def _supply_sub_formats_to(self, other_format):
2254
1753
"""Give other_format the same values for sub formats as this has.
3485
2956
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':
2959
controldir.ControlDirFormat.register_server_prober(RemoteBzrProber)
3674
2962
class RepositoryAcquisitionPolicy(object):
3828
3116
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()
3119
def register_metadir(registry, key,
3120
repository_format, help, native=True, deprecated=False,
3126
"""Register a metadir subformat.
3128
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
3129
by the Repository/Branch/WorkingTreeformats.
3131
:param repository_format: The fully-qualified repository format class
3133
:param branch_format: Fully-qualified branch format class name as
3135
:param tree_format: Fully-qualified tree format class name as
3138
# This should be expanded to support setting WorkingTree and Branch
3139
# formats, once BzrDirMetaFormat1 supports that.
3140
def _load(full_name):
3141
mod_name, factory_name = full_name.rsplit('.', 1)
3143
factory = pyutils.get_named_object(mod_name, factory_name)
3144
except ImportError, e:
3145
raise ImportError('failed to load %s: %s' % (full_name, e))
3146
except AttributeError:
3147
raise AttributeError('no factory %s in module %r'
3148
% (full_name, sys.modules[mod_name]))
3152
bd = BzrDirMetaFormat1()
3153
if branch_format is not None:
3154
bd.set_branch_format(_load(branch_format))
3155
if tree_format is not None:
3156
bd.workingtree_format = _load(tree_format)
3157
if repository_format is not None:
3158
bd.repository_format = _load(repository_format)
3160
registry.register(key, helper, help, native, deprecated, hidden,
3161
experimental, alias)
3835
3163
# The pre-0.8 formats have their repository format network name registered in
3836
3164
# repository.py. MetaDir formats have their repository format network name
3837
3165
# inferred from their disk format string.
3838
format_registry.register('weave', BzrDirFormat6,
3166
controldir.format_registry.register('weave', BzrDirFormat6,
3839
3167
'Pre-0.8 format. Slower than knit and does not'
3840
3168
' support checkouts or shared repositories.',
3842
3170
deprecated=True)
3843
format_registry.register_metadir('metaweave',
3171
register_metadir(controldir.format_registry, 'metaweave',
3844
3172
'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3845
3173
'Transitional format in 0.8. Slower than knit.',
3846
3174
branch_format='bzrlib.branch.BzrBranchFormat5',
3847
3175
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3849
3177
deprecated=True)
3850
format_registry.register_metadir('knit',
3178
register_metadir(controldir.format_registry, 'knit',
3851
3179
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3852
3180
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
3853
3181
branch_format='bzrlib.branch.BzrBranchFormat5',
3854
3182
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3856
3184
deprecated=True)
3857
format_registry.register_metadir('dirstate',
3185
register_metadir(controldir.format_registry, 'dirstate',
3858
3186
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3859
3187
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
3860
3188
'above when accessed over the network.',
3997
3311
# This current non-alias status is simply because we did not introduce a
3998
3312
# chk based subtree format.
3314
register_metadir(controldir.format_registry, 'development5-subtree',
3315
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3316
help='Development format, subtree variant. Can convert data to and '
3317
'from pack-0.92-subtree (and anything compatible with '
3318
'pack-0.92-subtree) format repositories. Repositories and branches in '
3319
'this format can only be read by bzr.dev. Please read '
3320
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3322
branch_format='bzrlib.branch.BzrBranchFormat7',
3323
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
4001
3329
# 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',
3331
# Finally, the current format.
3332
register_metadir(controldir.format_registry, '2a',
4027
3333
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
4028
3334
help='First format for bzr 2.0 series.\n'
4029
3335
'Uses group-compress storage.\n'
added
removed
bzrlib/bzrdir.py
