1061
938
raise errors.NotBranchError(location)
1062
939
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
941
def _cloning_metadir(self):
1118
942
"""Produce a metadir suitable for cloning with.
1177
1001
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
1367
1005
class BzrDirHooks(hooks.Hooks):
1368
1006
"""Hooks for BzrDir operations."""
1880
1518
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,
1521
class BzrProber(Prober):
1524
"""The known .bzr formats."""
1527
def register_bzrdir_format(klass, format):
1528
klass._formats[format.get_format_string()] = format
1531
def unregister_format(klass, format):
1532
del klass._formats[format.get_format_string()]
1535
def probe_transport(klass, transport):
1536
"""Return the .bzrdir style format present in a directory."""
1538
format_string = transport.get_bytes(".bzr/branch-format")
1539
except errors.NoSuchFile:
1540
raise errors.NotBranchError(path=transport.base)
1542
return klass._formats[format_string]
1544
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1547
class RemoteBzrProber(Prober):
1550
def probe_transport(klass, transport):
1551
"""Return a RemoteBzrDirFormat object if it looks possible."""
1553
medium = transport.get_smart_medium()
1554
except (NotImplementedError, AttributeError,
1555
errors.TransportNotPossible, errors.NoSmartMedium,
1556
errors.SmartProtocolError):
1557
# no smart server, so not a branch for this format type.
1558
raise errors.NotBranchError(path=transport.base)
1560
# Decline to open it if the server doesn't support our required
1561
# version (3) so that the VFS-based transport will do it.
1562
if medium.should_probe():
1564
server_version = medium.protocol_version()
1565
except errors.SmartProtocolError:
1566
# Apparently there's no usable smart server there, even though
1567
# the medium supports the smart protocol.
1568
raise errors.NotBranchError(path=transport.base)
1569
if server_version != '2':
1570
raise errors.NotBranchError(path=transport.base)
1576
class BzrDirFormat(ControlDirFormat):
1577
"""ControlDirFormat base class for .bzr/ directories.
1891
1579
Formats are placed in a dict by their format string for reference
1892
1580
during bzrdir opening. These should be subclasses of BzrDirFormat
1895
1583
Once a format is deprecated, just deprecate the initialize and open
1896
1584
methods on the format class. Do not deprecate the object, as the
1897
1585
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
1588
_lock_file_name = 'branch-lock'
1922
colocated_branches = False
1923
"""Whether co-located branches are supported for this control dir format.
1926
1590
# _lock_class must be set in subclasses to the lock type, typ.
1927
1591
# 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
1593
def get_format_string(self):
1963
1594
"""Return the ASCII format string that identifies this format."""
1964
1595
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
1597
def initialize_on_transport(self, transport):
1998
1598
"""Initialize a new bzrdir in the base directory of a Transport."""
2147
1747
control_files.unlock()
2148
1748
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
1750
def open(self, transport, _found=False):
2193
1751
"""Return an instance of this format for the dir transport points at.
2195
1753
_found is a private parameter, do not use it.
2198
found_format = BzrDirFormat.find_format(transport)
1756
found_format = ControlDirFormat.find_format(transport)
2199
1757
if not isinstance(found_format, self.__class__):
2200
1758
raise AssertionError("%s was asked to open %s, but it seems to need "
2217
1775
def register_format(klass, format):
2218
klass._formats[format.get_format_string()] = format
1776
BzrProber.register_bzrdir_format(format)
2219
1777
# bzr native formats have a network name of their format string.
2220
1778
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()
1779
ControlDirFormat.register_format(format)
2253
1781
def _supply_sub_formats_to(self, other_format):
2254
1782
"""Give other_format the same values for sub formats as this has.
added
removed
bzrlib/bzrdir.py
