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.
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
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.
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)
932
def get_branch_transport(self, branch_format, name=None):
933
"""Get the transport for use by branch format in this BzrDir.
935
Note that bzr dirs that do not support format strings will raise
936
IncompatibleFormat if the branch format they are given has
937
a format string, and vice versa.
939
If branch_format is None, the transport is returned with no
940
checking. If it is not None, then the returned transport is
941
guaranteed to point to an existing directory ready for use.
943
raise NotImplementedError(self.get_branch_transport)
945
def get_repository_transport(self, repository_format):
946
"""Get the transport for use by repository format in this BzrDir.
948
Note that bzr dirs that do not support format strings will raise
949
IncompatibleFormat if the repository format they are given has
950
a format string, and vice versa.
952
If repository_format is None, the transport is returned with no
953
checking. If it is not None, then the returned transport is
954
guaranteed to point to an existing directory ready for use.
956
raise NotImplementedError(self.get_repository_transport)
958
def get_workingtree_transport(self, tree_format):
959
"""Get the transport for use by workingtree format in this BzrDir.
961
Note that bzr dirs that do not support format strings will raise
962
IncompatibleFormat if the workingtree format they are given has a
963
format string, and vice versa.
965
If workingtree_format is None, the transport is returned with no
966
checking. If it is not None, then the returned transport is
967
guaranteed to point to an existing directory ready for use.
969
raise NotImplementedError(self.get_workingtree_transport)
1367
972
class BzrDirHooks(hooks.Hooks):
1880
1478
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,
1481
class BzrProber(controldir.Prober):
1482
"""Prober for formats that use a .bzr/ control directory."""
1485
"""The known .bzr formats."""
1488
def register_bzrdir_format(klass, format):
1489
klass._formats[format.get_format_string()] = format
1492
def unregister_bzrdir_format(klass, format):
1493
del klass._formats[format.get_format_string()]
1496
def probe_transport(klass, transport):
1497
"""Return the .bzrdir style format present in a directory."""
1499
format_string = transport.get_bytes(".bzr/branch-format")
1500
except errors.NoSuchFile:
1501
raise errors.NotBranchError(path=transport.base)
1503
return klass._formats[format_string]
1505
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1508
controldir.ControlDirFormat.register_prober(BzrProber)
1511
class RemoteBzrProber(controldir.Prober):
1512
"""Prober for remote servers that provide a Bazaar smart server."""
1515
def probe_transport(klass, transport):
1516
"""Return a RemoteBzrDirFormat object if it looks possible."""
1518
medium = transport.get_smart_medium()
1519
except (NotImplementedError, AttributeError,
1520
errors.TransportNotPossible, errors.NoSmartMedium,
1521
errors.SmartProtocolError):
1522
# no smart server, so not a branch for this format type.
1523
raise errors.NotBranchError(path=transport.base)
1525
# Decline to open it if the server doesn't support our required
1526
# version (3) so that the VFS-based transport will do it.
1527
if medium.should_probe():
1529
server_version = medium.protocol_version()
1530
except errors.SmartProtocolError:
1531
# Apparently there's no usable smart server there, even though
1532
# the medium supports the smart protocol.
1533
raise errors.NotBranchError(path=transport.base)
1534
if server_version != '2':
1535
raise errors.NotBranchError(path=transport.base)
1536
return RemoteBzrDirFormat()
1539
class BzrDirFormat(controldir.ControlDirFormat):
1540
"""ControlDirFormat base class for .bzr/ directories.
1891
1542
Formats are placed in a dict by their format string for reference
1892
1543
during bzrdir opening. These should be subclasses of BzrDirFormat
1895
1546
Once a format is deprecated, just deprecate the initialize and open
1896
1547
methods on the format class. Do not deprecate the object, as the
1897
1548
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
1551
_lock_file_name = 'branch-lock'
1922
colocated_branches = False
1923
"""Whether co-located branches are supported for this control dir format.
1926
1553
# _lock_class must be set in subclasses to the lock type, typ.
1927
1554
# 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
1556
def get_format_string(self):
1963
1557
"""Return the ASCII format string that identifies this format."""
1964
1558
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
1560
def initialize_on_transport(self, transport):
1998
1561
"""Initialize a new bzrdir in the base directory of a Transport."""
2147
1710
control_files.unlock()
2148
1711
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
1713
def open(self, transport, _found=False):
2193
1714
"""Return an instance of this format for the dir transport points at.
2195
1716
_found is a private parameter, do not use it.
2198
found_format = BzrDirFormat.find_format(transport)
1719
found_format = controldir.ControlDirFormat.find_format(transport)
2199
1720
if not isinstance(found_format, self.__class__):
2200
1721
raise AssertionError("%s was asked to open %s, but it seems to need "
3485
2943
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':
2946
controldir.ControlDirFormat.register_server_prober(RemoteBzrProber)
3674
2949
class RepositoryAcquisitionPolicy(object):
3828
3103
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()
3106
def register_metadir(registry, key,
3107
repository_format, help, native=True, deprecated=False,
3113
"""Register a metadir subformat.
3115
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
3116
by the Repository/Branch/WorkingTreeformats.
3118
:param repository_format: The fully-qualified repository format class
3120
:param branch_format: Fully-qualified branch format class name as
3122
:param tree_format: Fully-qualified tree format class name as
3125
# This should be expanded to support setting WorkingTree and Branch
3126
# formats, once BzrDirMetaFormat1 supports that.
3127
def _load(full_name):
3128
mod_name, factory_name = full_name.rsplit('.', 1)
3130
factory = pyutils.get_named_object(mod_name, factory_name)
3131
except ImportError, e:
3132
raise ImportError('failed to load %s: %s' % (full_name, e))
3133
except AttributeError:
3134
raise AttributeError('no factory %s in module %r'
3135
% (full_name, sys.modules[mod_name]))
3139
bd = BzrDirMetaFormat1()
3140
if branch_format is not None:
3141
bd.set_branch_format(_load(branch_format))
3142
if tree_format is not None:
3143
bd.workingtree_format = _load(tree_format)
3144
if repository_format is not None:
3145
bd.repository_format = _load(repository_format)
3147
registry.register(key, helper, help, native, deprecated, hidden,
3148
experimental, alias)
3835
3150
# The pre-0.8 formats have their repository format network name registered in
3836
3151
# repository.py. MetaDir formats have their repository format network name
3837
3152
# inferred from their disk format string.
3838
format_registry.register('weave', BzrDirFormat6,
3153
controldir.format_registry.register('weave', BzrDirFormat6,
3839
3154
'Pre-0.8 format. Slower than knit and does not'
3840
3155
' support checkouts or shared repositories.',
3842
3157
deprecated=True)
3843
format_registry.register_metadir('metaweave',
3158
register_metadir(controldir.format_registry, 'metaweave',
3844
3159
'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3845
3160
'Transitional format in 0.8. Slower than knit.',
3846
3161
branch_format='bzrlib.branch.BzrBranchFormat5',
3847
3162
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3849
3164
deprecated=True)
3850
format_registry.register_metadir('knit',
3165
register_metadir(controldir.format_registry, 'knit',
3851
3166
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3852
3167
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
3853
3168
branch_format='bzrlib.branch.BzrBranchFormat5',
3854
3169
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3856
3171
deprecated=True)
3857
format_registry.register_metadir('dirstate',
3172
register_metadir(controldir.format_registry, 'dirstate',
3858
3173
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3859
3174
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
3860
3175
'above when accessed over the network.',
3997
3298
# This current non-alias status is simply because we did not introduce a
3998
3299
# chk based subtree format.
3301
register_metadir(controldir.format_registry, 'development5-subtree',
3302
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3303
help='Development format, subtree variant. Can convert data to and '
3304
'from pack-0.92-subtree (and anything compatible with '
3305
'pack-0.92-subtree) format repositories. Repositories and branches in '
3306
'this format can only be read by bzr.dev. Please read '
3307
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3309
branch_format='bzrlib.branch.BzrBranchFormat7',
3310
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
4001
3316
# 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',
3318
# Finally, the current format.
3319
register_metadir(controldir.format_registry, '2a',
4027
3320
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
4028
3321
help='First format for bzr 2.0 series.\n'
4029
3322
'Uses group-compress storage.\n'
added
removed
bzrlib/bzrdir.py
