860
1071
raise errors.NotBranchError(location)
861
1072
return tree, branch, branch.repository, relpath
1074
def open_repository(self, _unsupported=False):
1075
"""Open the repository object at this BzrDir if one is present.
1077
This will not follow the Branch object pointer - it's strictly a direct
1078
open facility. Most client code should use open_branch().repository to
1079
get at a repository.
1081
:param _unsupported: a private parameter, not part of the api.
1082
TODO: static convenience version of this?
1084
raise NotImplementedError(self.open_repository)
1086
def open_workingtree(self, _unsupported=False,
1087
recommend_upgrade=True, from_branch=None):
1088
"""Open the workingtree object at this BzrDir if one is present.
1090
:param recommend_upgrade: Optional keyword parameter, when True (the
1091
default), emit through the ui module a recommendation that the user
1092
upgrade the working tree when the workingtree being opened is old
1093
(but still fully supported).
1094
:param from_branch: override bzrdir branch (for lightweight checkouts)
1096
raise NotImplementedError(self.open_workingtree)
1098
def has_branch(self, name=None):
1099
"""Tell if this bzrdir contains a branch.
1101
Note: if you're going to open the branch, you should just go ahead
1102
and try, and not ask permission first. (This method just opens the
1103
branch and discards it, and that's somewhat expensive.)
1106
self.open_branch(name)
1108
except errors.NotBranchError:
1111
def has_workingtree(self):
1112
"""Tell if this bzrdir contains a working tree.
1114
This will still raise an exception if the bzrdir has a workingtree that
1115
is remote & inaccessible.
1117
Note: if you're going to open the working tree, you should just go ahead
1118
and try, and not ask permission first. (This method just opens the
1119
workingtree and discards it, and that's somewhat expensive.)
1122
self.open_workingtree(recommend_upgrade=False)
1124
except errors.NoWorkingTree:
863
1127
def _cloning_metadir(self):
864
1128
"""Produce a metadir suitable for cloning with.
923
1187
format.require_stacking()
927
def create(cls, base, format=None, possible_transports=None):
928
"""Create a new BzrDir at the url 'base'.
930
:param format: If supplied, the format of branch to create. If not
931
supplied, the default is used.
932
:param possible_transports: If supplied, a list of transports that
933
can be reused to share a remote connection.
1190
def checkout_metadir(self):
1191
return self.cloning_metadir()
1193
def sprout(self, url, revision_id=None, force_new_repo=False,
1194
recurse='down', possible_transports=None,
1195
accelerator_tree=None, hardlink=False, stacked=False,
1196
source_branch=None, create_tree_if_local=True):
1197
"""Create a copy of this bzrdir prepared for use as a new line of
1200
If url's last component does not exist, it will be created.
1202
Attributes related to the identity of the source branch like
1203
branch nickname will be cleaned, a working tree is created
1204
whether one existed before or not; and a local branch is always
1207
if revision_id is not None, then the clone operation may tune
1208
itself to download less data.
1209
:param accelerator_tree: A tree which can be used for retrieving file
1210
contents more quickly than the revision tree, i.e. a workingtree.
1211
The revision tree will be used for cases where accelerator_tree's
1212
content is different.
1213
:param hardlink: If true, hard-link files from accelerator_tree,
1215
:param stacked: If true, create a stacked branch referring to the
1216
location of this control directory.
1217
:param create_tree_if_local: If true, a working-tree will be created
1218
when working locally.
935
if cls is not BzrDir:
936
raise AssertionError("BzrDir.create always creates the"
937
"default format, not one of %r" % cls)
938
t = get_transport(base, possible_transports)
941
format = controldir.ControlDirFormat.get_default_format()
942
return format.initialize_on_transport(t)
1220
target_transport = get_transport(url, possible_transports)
1221
target_transport.ensure_base()
1222
cloning_format = self.cloning_metadir(stacked)
1223
# Create/update the result branch
1224
result = cloning_format.initialize_on_transport(target_transport)
1225
# if a stacked branch wasn't requested, we don't create one
1226
# even if the origin was stacked
1227
stacked_branch_url = None
1228
if source_branch is not None:
1230
stacked_branch_url = self.root_transport.base
1231
source_repository = source_branch.repository
1234
source_branch = self.open_branch()
1235
source_repository = source_branch.repository
1237
stacked_branch_url = self.root_transport.base
1238
except errors.NotBranchError:
1239
source_branch = None
1241
source_repository = self.open_repository()
1242
except errors.NoRepositoryPresent:
1243
source_repository = None
1244
repository_policy = result.determine_repository_policy(
1245
force_new_repo, stacked_branch_url, require_stacking=stacked)
1246
result_repo, is_new_repo = repository_policy.acquire_repository()
1247
if is_new_repo and revision_id is not None and not stacked:
1248
fetch_spec = graph.PendingAncestryResult(
1249
[revision_id], source_repository)
1252
if source_repository is not None:
1253
# Fetch while stacked to prevent unstacked fetch from
1255
if fetch_spec is None:
1256
result_repo.fetch(source_repository, revision_id=revision_id)
1258
result_repo.fetch(source_repository, fetch_spec=fetch_spec)
1260
if source_branch is None:
1261
# this is for sprouting a bzrdir without a branch; is that
1263
# Not especially, but it's part of the contract.
1264
result_branch = result.create_branch()
1266
result_branch = source_branch.sprout(result,
1267
revision_id=revision_id, repository_policy=repository_policy)
1268
mutter("created new branch %r" % (result_branch,))
1270
# Create/update the result working tree
1271
if (create_tree_if_local and
1272
isinstance(target_transport, local.LocalTransport) and
1273
(result_repo is None or result_repo.make_working_trees())):
1274
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
1278
if wt.path2id('') is None:
1280
wt.set_root_id(self.open_workingtree.get_root_id())
1281
except errors.NoWorkingTree:
1287
if recurse == 'down':
1289
basis = wt.basis_tree()
1291
subtrees = basis.iter_references()
1292
elif result_branch is not None:
1293
basis = result_branch.basis_tree()
1295
subtrees = basis.iter_references()
1296
elif source_branch is not None:
1297
basis = source_branch.basis_tree()
1299
subtrees = basis.iter_references()
1304
for path, file_id in subtrees:
1305
target = urlutils.join(url, urlutils.escape(path))
1306
sublocation = source_branch.reference_parent(file_id, path)
1307
sublocation.bzrdir.sprout(target,
1308
basis.get_reference_revision(file_id, path),
1309
force_new_repo=force_new_repo, recurse=recurse,
1312
if basis is not None:
1316
def push_branch(self, source, revision_id=None, overwrite=False,
1317
remember=False, create_prefix=False):
1318
"""Push the source branch into this BzrDir."""
1320
# If we can open a branch, use its direct repository, otherwise see
1321
# if there is a repository without a branch.
1323
br_to = self.open_branch()
1324
except errors.NotBranchError:
1325
# Didn't find a branch, can we find a repository?
1326
repository_to = self.find_repository()
1328
# Found a branch, so we must have found a repository
1329
repository_to = br_to.repository
1331
push_result = PushResult()
1332
push_result.source_branch = source
1334
# We have a repository but no branch, copy the revisions, and then
1336
repository_to.fetch(source.repository, revision_id=revision_id)
1337
br_to = source.clone(self, revision_id=revision_id)
1338
if source.get_push_location() is None or remember:
1339
source.set_push_location(br_to.base)
1340
push_result.stacked_on = None
1341
push_result.branch_push_result = None
1342
push_result.old_revno = None
1343
push_result.old_revid = _mod_revision.NULL_REVISION
1344
push_result.target_branch = br_to
1345
push_result.master_branch = None
1346
push_result.workingtree_updated = False
1348
# We have successfully opened the branch, remember if necessary:
1349
if source.get_push_location() is None or remember:
1350
source.set_push_location(br_to.base)
1352
tree_to = self.open_workingtree()
1353
except errors.NotLocalUrl:
1354
push_result.branch_push_result = source.push(br_to,
1355
overwrite, stop_revision=revision_id)
1356
push_result.workingtree_updated = False
1357
except errors.NoWorkingTree:
1358
push_result.branch_push_result = source.push(br_to,
1359
overwrite, stop_revision=revision_id)
1360
push_result.workingtree_updated = None # Not applicable
1362
tree_to.lock_write()
1364
push_result.branch_push_result = source.push(
1365
tree_to.branch, overwrite, stop_revision=revision_id)
1369
push_result.workingtree_updated = True
1370
push_result.old_revno = push_result.branch_push_result.old_revno
1371
push_result.old_revid = push_result.branch_push_result.old_revid
1372
push_result.target_branch = \
1373
push_result.branch_push_result.target_branch
946
1377
class BzrDirHooks(hooks.Hooks):
1459
1890
return config.TransportConfig(self.transport, 'control.conf')
1462
class BzrProber(controldir.Prober):
1463
"""Prober for formats that use a .bzr/ control directory."""
1466
"""The known .bzr formats."""
1469
def register_bzrdir_format(klass, format):
1470
klass._formats[format.get_format_string()] = format
1473
def unregister_bzrdir_format(klass, format):
1474
del klass._formats[format.get_format_string()]
1477
def probe_transport(klass, transport):
1478
"""Return the .bzrdir style format present in a directory."""
1480
format_string = transport.get_bytes(".bzr/branch-format")
1481
except errors.NoSuchFile:
1482
raise errors.NotBranchError(path=transport.base)
1484
return klass._formats[format_string]
1486
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1489
controldir.ControlDirFormat.register_prober(BzrProber)
1492
class RemoteBzrProber(controldir.Prober):
1493
"""Prober for remote servers that provide a Bazaar smart server."""
1496
def probe_transport(klass, transport):
1497
"""Return a RemoteBzrDirFormat object if it looks possible."""
1499
medium = transport.get_smart_medium()
1500
except (NotImplementedError, AttributeError,
1501
errors.TransportNotPossible, errors.NoSmartMedium,
1502
errors.SmartProtocolError):
1503
# no smart server, so not a branch for this format type.
1504
raise errors.NotBranchError(path=transport.base)
1506
# Decline to open it if the server doesn't support our required
1507
# version (3) so that the VFS-based transport will do it.
1508
if medium.should_probe():
1510
server_version = medium.protocol_version()
1511
except errors.SmartProtocolError:
1512
# Apparently there's no usable smart server there, even though
1513
# the medium supports the smart protocol.
1514
raise errors.NotBranchError(path=transport.base)
1515
if server_version != '2':
1516
raise errors.NotBranchError(path=transport.base)
1517
return RemoteBzrDirFormat()
1520
class BzrDirFormat(controldir.ControlDirFormat):
1521
"""ControlDirFormat base class for .bzr/ directories.
1893
class BzrDirFormat(object):
1894
"""An encapsulation of the initialization and open routines for a format.
1896
Formats provide three things:
1897
* An initialization routine,
1523
1901
Formats are placed in a dict by their format string for reference
1524
1902
during bzrdir opening. These should be subclasses of BzrDirFormat
1527
1905
Once a format is deprecated, just deprecate the initialize and open
1528
1906
methods on the format class. Do not deprecate the object, as the
1529
1907
object will be created every system load.
1909
:cvar colocated_branches: Whether this formats supports colocated branches.
1912
_default_format = None
1913
"""The default format used for new .bzr dirs."""
1916
"""The known formats."""
1918
_control_formats = []
1919
"""The registered control formats - .bzr, ....
1921
This is a list of BzrDirFormat objects.
1924
_control_server_formats = []
1925
"""The registered control server formats, e.g. RemoteBzrDirs.
1927
This is a list of BzrDirFormat objects.
1532
1930
_lock_file_name = 'branch-lock'
1932
colocated_branches = False
1933
"""Whether co-located branches are supported for this control dir format.
1534
1936
# _lock_class must be set in subclasses to the lock type, typ.
1535
1937
# TransportLock or LockDir
1940
def find_format(klass, transport, _server_formats=True):
1941
"""Return the format present at transport."""
1943
formats = klass._control_server_formats + klass._control_formats
1945
formats = klass._control_formats
1946
for format in formats:
1948
return format.probe_transport(transport)
1949
except errors.NotBranchError:
1950
# this format does not find a control dir here.
1952
raise errors.NotBranchError(path=transport.base)
1955
def probe_transport(klass, transport):
1956
"""Return the .bzrdir style format present in a directory."""
1958
format_string = transport.get_bytes(".bzr/branch-format")
1959
except errors.NoSuchFile:
1960
raise errors.NotBranchError(path=transport.base)
1963
return klass._formats[format_string]
1965
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1968
def get_default_format(klass):
1969
"""Return the current default format."""
1970
return klass._default_format
1537
1972
def get_format_string(self):
1538
1973
"""Return the ASCII format string that identifies this format."""
1539
1974
raise NotImplementedError(self.get_format_string)
1976
def get_format_description(self):
1977
"""Return the short description for this format."""
1978
raise NotImplementedError(self.get_format_description)
1980
def get_converter(self, format=None):
1981
"""Return the converter to use to convert bzrdirs needing converts.
1983
This returns a bzrlib.bzrdir.Converter object.
1985
This should return the best upgrader to step this format towards the
1986
current default format. In the case of plugins we can/should provide
1987
some means for them to extend the range of returnable converters.
1989
:param format: Optional format to override the default format of the
1992
raise NotImplementedError(self.get_converter)
1994
def initialize(self, url, possible_transports=None):
1995
"""Create a bzr control dir at this url and return an opened copy.
1997
While not deprecated, this method is very specific and its use will
1998
lead to many round trips to setup a working environment. See
1999
initialize_on_transport_ex for a [nearly] all-in-one method.
2001
Subclasses should typically override initialize_on_transport
2002
instead of this method.
2004
return self.initialize_on_transport(get_transport(url,
2005
possible_transports))
1541
2007
def initialize_on_transport(self, transport):
1542
2008
"""Initialize a new bzrdir in the base directory of a Transport."""
1691
2157
control_files.unlock()
1692
2158
return self.open(transport, _found=True)
2160
def is_supported(self):
2161
"""Is this format supported?
2163
Supported formats must be initializable and openable.
2164
Unsupported formats may not support initialization or committing or
2165
some other features depending on the reason for not being supported.
2169
def network_name(self):
2170
"""A simple byte string uniquely identifying this format for RPC calls.
2172
Bzr control formats use thir disk format string to identify the format
2173
over the wire. Its possible that other control formats have more
2174
complex detection requirements, so we permit them to use any unique and
2175
immutable string they desire.
2177
raise NotImplementedError(self.network_name)
2179
def same_model(self, target_format):
2180
return (self.repository_format.rich_root_data ==
2181
target_format.rich_root_data)
2184
def known_formats(klass):
2185
"""Return all the known formats.
2187
Concrete formats should override _known_formats.
2189
# There is double indirection here to make sure that control
2190
# formats used by more than one dir format will only be probed
2191
# once. This can otherwise be quite expensive for remote connections.
2193
for format in klass._control_formats:
2194
result.update(format._known_formats())
2198
def _known_formats(klass):
2199
"""Return the known format instances for this control format."""
2200
return set(klass._formats.values())
1694
2202
def open(self, transport, _found=False):
1695
2203
"""Return an instance of this format for the dir transport points at.
1697
2205
_found is a private parameter, do not use it.
1700
found_format = controldir.ControlDirFormat.find_format(transport)
2208
found_format = BzrDirFormat.find_format(transport)
1701
2209
if not isinstance(found_format, self.__class__):
1702
2210
raise AssertionError("%s was asked to open %s, but it seems to need "
2934
3495
BzrDirMetaFormat1._set_repository_format) #.im_func)
2937
controldir.ControlDirFormat.register_server_prober(RemoteBzrProber)
3498
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
3501
class BzrDirFormatInfo(object):
3503
def __init__(self, native, deprecated, hidden, experimental):
3504
self.deprecated = deprecated
3505
self.native = native
3506
self.hidden = hidden
3507
self.experimental = experimental
3510
class BzrDirFormatRegistry(registry.Registry):
3511
"""Registry of user-selectable BzrDir subformats.
3513
Differs from BzrDirFormat._control_formats in that it provides sub-formats,
3514
e.g. BzrDirMeta1 with weave repository. Also, it's more user-oriented.
3518
"""Create a BzrDirFormatRegistry."""
3519
self._aliases = set()
3520
self._registration_order = list()
3521
super(BzrDirFormatRegistry, self).__init__()
3524
"""Return a set of the format names which are aliases."""
3525
return frozenset(self._aliases)
3527
def register_metadir(self, key,
3528
repository_format, help, native=True, deprecated=False,
3534
"""Register a metadir subformat.
3536
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
3537
by the Repository/Branch/WorkingTreeformats.
3539
:param repository_format: The fully-qualified repository format class
3541
:param branch_format: Fully-qualified branch format class name as
3543
:param tree_format: Fully-qualified tree format class name as
3546
# This should be expanded to support setting WorkingTree and Branch
3547
# formats, once BzrDirMetaFormat1 supports that.
3548
def _load(full_name):
3549
mod_name, factory_name = full_name.rsplit('.', 1)
3551
mod = __import__(mod_name, globals(), locals(),
3553
except ImportError, e:
3554
raise ImportError('failed to load %s: %s' % (full_name, e))
3556
factory = getattr(mod, factory_name)
3557
except AttributeError:
3558
raise AttributeError('no factory %s in module %r'
3563
bd = BzrDirMetaFormat1()
3564
if branch_format is not None:
3565
bd.set_branch_format(_load(branch_format))
3566
if tree_format is not None:
3567
bd.workingtree_format = _load(tree_format)
3568
if repository_format is not None:
3569
bd.repository_format = _load(repository_format)
3571
self.register(key, helper, help, native, deprecated, hidden,
3572
experimental, alias)
3574
def register(self, key, factory, help, native=True, deprecated=False,
3575
hidden=False, experimental=False, alias=False):
3576
"""Register a BzrDirFormat factory.
3578
The factory must be a callable that takes one parameter: the key.
3579
It must produce an instance of the BzrDirFormat when called.
3581
This function mainly exists to prevent the info object from being
3584
registry.Registry.register(self, key, factory, help,
3585
BzrDirFormatInfo(native, deprecated, hidden, experimental))
3587
self._aliases.add(key)
3588
self._registration_order.append(key)
3590
def register_lazy(self, key, module_name, member_name, help, native=True,
3591
deprecated=False, hidden=False, experimental=False, alias=False):
3592
registry.Registry.register_lazy(self, key, module_name, member_name,
3593
help, BzrDirFormatInfo(native, deprecated, hidden, experimental))
3595
self._aliases.add(key)
3596
self._registration_order.append(key)
3598
def set_default(self, key):
3599
"""Set the 'default' key to be a clone of the supplied key.
3601
This method must be called once and only once.
3603
registry.Registry.register(self, 'default', self.get(key),
3604
self.get_help(key), info=self.get_info(key))
3605
self._aliases.add('default')
3607
def set_default_repository(self, key):
3608
"""Set the FormatRegistry default and Repository default.
3610
This is a transitional method while Repository.set_default_format
3613
if 'default' in self:
3614
self.remove('default')
3615
self.set_default(key)
3616
format = self.get('default')()
3618
def make_bzrdir(self, key):
3619
return self.get(key)()
3621
def help_topic(self, topic):
3623
default_realkey = None
3624
default_help = self.get_help('default')
3626
for key in self._registration_order:
3627
if key == 'default':
3629
help = self.get_help(key)
3630
if help == default_help:
3631
default_realkey = key
3633
help_pairs.append((key, help))
3635
def wrapped(key, help, info):
3637
help = '(native) ' + help
3638
return ':%s:\n%s\n\n' % (key,
3639
textwrap.fill(help, initial_indent=' ',
3640
subsequent_indent=' ',
3641
break_long_words=False))
3642
if default_realkey is not None:
3643
output += wrapped(default_realkey, '(default) %s' % default_help,
3644
self.get_info('default'))
3645
deprecated_pairs = []
3646
experimental_pairs = []
3647
for key, help in help_pairs:
3648
info = self.get_info(key)
3651
elif info.deprecated:
3652
deprecated_pairs.append((key, help))
3653
elif info.experimental:
3654
experimental_pairs.append((key, help))
3656
output += wrapped(key, help, info)
3657
output += "\nSee :doc:`formats-help` for more about storage formats."
3659
if len(experimental_pairs) > 0:
3660
other_output += "Experimental formats are shown below.\n\n"
3661
for key, help in experimental_pairs:
3662
info = self.get_info(key)
3663
other_output += wrapped(key, help, info)
3666
"No experimental formats are available.\n\n"
3667
if len(deprecated_pairs) > 0:
3668
other_output += "\nDeprecated formats are shown below.\n\n"
3669
for key, help in deprecated_pairs:
3670
info = self.get_info(key)
3671
other_output += wrapped(key, help, info)
3674
"\nNo deprecated formats are available.\n\n"
3676
"\nSee :doc:`formats-help` for more about storage formats."
3678
if topic == 'other-formats':
2940
3684
class RepositoryAcquisitionPolicy(object):
3094
3838
return self._repository, False
3097
def register_metadir(registry, key,
3098
repository_format, help, native=True, deprecated=False,
3104
"""Register a metadir subformat.
3106
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
3107
by the Repository/Branch/WorkingTreeformats.
3109
:param repository_format: The fully-qualified repository format class
3111
:param branch_format: Fully-qualified branch format class name as
3113
:param tree_format: Fully-qualified tree format class name as
3116
# This should be expanded to support setting WorkingTree and Branch
3117
# formats, once BzrDirMetaFormat1 supports that.
3118
def _load(full_name):
3119
mod_name, factory_name = full_name.rsplit('.', 1)
3121
mod = __import__(mod_name, globals(), locals(),
3123
except ImportError, e:
3124
raise ImportError('failed to load %s: %s' % (full_name, e))
3126
factory = getattr(mod, factory_name)
3127
except AttributeError:
3128
raise AttributeError('no factory %s in module %r'
3133
bd = BzrDirMetaFormat1()
3134
if branch_format is not None:
3135
bd.set_branch_format(_load(branch_format))
3136
if tree_format is not None:
3137
bd.workingtree_format = _load(tree_format)
3138
if repository_format is not None:
3139
bd.repository_format = _load(repository_format)
3141
registry.register(key, helper, help, native, deprecated, hidden,
3142
experimental, alias)
3841
# Please register new formats after old formats so that formats
3842
# appear in chronological order and format descriptions can build
3844
format_registry = BzrDirFormatRegistry()
3144
3845
# The pre-0.8 formats have their repository format network name registered in
3145
3846
# repository.py. MetaDir formats have their repository format network name
3146
3847
# inferred from their disk format string.
3147
controldir.format_registry.register('weave', BzrDirFormat6,
3848
format_registry.register('weave', BzrDirFormat6,
3148
3849
'Pre-0.8 format. Slower than knit and does not'
3149
3850
' support checkouts or shared repositories.',
3151
3852
deprecated=True)
3152
register_metadir(controldir.format_registry, 'metaweave',
3853
format_registry.register_metadir('metaweave',
3153
3854
'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3154
3855
'Transitional format in 0.8. Slower than knit.',
3155
3856
branch_format='bzrlib.branch.BzrBranchFormat5',
3156
3857
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3158
3859
deprecated=True)
3159
register_metadir(controldir.format_registry, 'knit',
3860
format_registry.register_metadir('knit',
3160
3861
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3161
3862
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
3162
3863
branch_format='bzrlib.branch.BzrBranchFormat5',
3163
3864
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3165
3866
deprecated=True)
3166
register_metadir(controldir.format_registry, 'dirstate',
3867
format_registry.register_metadir('dirstate',
3167
3868
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3168
3869
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
3169
3870
'above when accessed over the network.',
added
removed
bzrlib/bzrdir.py
