30
repository as _mod_repository,
32
31
revision as _mod_revision,
36
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
34
from bzrlib.branch import BranchReferenceFormat
37
35
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
38
36
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
39
37
from bzrlib.errors import (
43
41
from bzrlib.lockable_files import LockableFiles
44
42
from bzrlib.smart import client, vfs, repository as smart_repo
45
43
from bzrlib.revision import ensure_null, NULL_REVISION
46
from bzrlib.repository import RepositoryWriteLockResult
47
44
from bzrlib.trace import mutter, note, warning
245
242
self._ensure_real()
246
243
self._real_bzrdir.destroy_repository()
248
def create_branch(self, name=None):
245
def create_branch(self):
249
246
# as per meta1 formats - just delegate to the format object which may
250
247
# be parameterised.
251
real_branch = self._format.get_branch_format().initialize(self,
248
real_branch = self._format.get_branch_format().initialize(self)
253
249
if not isinstance(real_branch, RemoteBranch):
254
result = RemoteBranch(self, self.find_repository(), real_branch,
250
result = RemoteBranch(self, self.find_repository(), real_branch)
257
252
result = real_branch
258
253
# BzrDir.clone_on_transport() uses the result of create_branch but does
264
259
self._next_open_branch_result = result
267
def destroy_branch(self, name=None):
262
def destroy_branch(self):
268
263
"""See BzrDir.destroy_branch"""
269
264
self._ensure_real()
270
self._real_bzrdir.destroy_branch(name=name)
265
self._real_bzrdir.destroy_branch()
271
266
self._next_open_branch_result = None
273
268
def create_workingtree(self, revision_id=None, from_branch=None):
274
269
raise errors.NotLocalUrl(self.transport.base)
276
def find_branch_format(self, name=None):
271
def find_branch_format(self):
277
272
"""Find the branch 'format' for this bzrdir.
279
274
This might be a synthetic object for e.g. RemoteBranch and SVN.
281
b = self.open_branch(name=name)
276
b = self.open_branch()
284
def get_branch_reference(self, name=None):
279
def get_branch_reference(self):
285
280
"""See BzrDir.get_branch_reference()."""
287
# XXX JRV20100304: Support opening colocated branches
288
raise errors.NoColocatedBranchSupport(self)
289
281
response = self._get_branch_reference()
290
282
if response[0] == 'ref':
291
283
return response[1]
322
314
raise errors.UnexpectedSmartServerResponse(response)
325
def _get_tree_branch(self, name=None):
317
def _get_tree_branch(self):
326
318
"""See BzrDir._get_tree_branch()."""
327
return None, self.open_branch(name=name)
319
return None, self.open_branch()
329
def open_branch(self, name=None, unsupported=False,
330
ignore_fallbacks=False):
321
def open_branch(self, _unsupported=False, ignore_fallbacks=False):
332
323
raise NotImplementedError('unsupported flag support not implemented yet.')
333
324
if self._next_open_branch_result is not None:
334
325
# See create_branch for details.
339
330
if response[0] == 'ref':
340
331
# a branch reference, use the existing BranchReference logic.
341
332
format = BranchReferenceFormat()
342
return format.open(self, name=name, _found=True,
343
location=response[1], ignore_fallbacks=ignore_fallbacks)
333
return format.open(self, _found=True, location=response[1],
334
ignore_fallbacks=ignore_fallbacks)
344
335
branch_format_name = response[1]
345
336
if not branch_format_name:
346
337
branch_format_name = None
347
338
format = RemoteBranchFormat(network_name=branch_format_name)
348
339
return RemoteBranch(self, self.find_repository(), format=format,
349
setup_stacking=not ignore_fallbacks, name=name)
340
setup_stacking=not ignore_fallbacks)
351
342
def _open_repo_v1(self, path):
352
343
verb = 'BzrDir.find_repository'
429
420
"""Return the path to be used for this bzrdir in a remote call."""
430
421
return client.remote_path_from_transport(self.root_transport)
432
def get_branch_transport(self, branch_format, name=None):
423
def get_branch_transport(self, branch_format):
433
424
self._ensure_real()
434
return self._real_bzrdir.get_branch_transport(branch_format, name=name)
425
return self._real_bzrdir.get_branch_transport(branch_format)
436
427
def get_repository_transport(self, repository_format):
437
428
self._ensure_real()
647
638
return self._custom_format._serializer
650
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
651
bzrdir.ControlComponent):
641
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin):
652
642
"""Repository accessed over rpc.
654
644
For the moment most operations are performed using local transport-backed
697
687
# Additional places to query for data.
698
688
self._fallback_repositories = []
701
def user_transport(self):
702
return self.bzrdir.user_transport
705
def control_transport(self):
706
# XXX: Normally you shouldn't directly get at the remote repository
707
# transport, but I'm not sure it's worth making this method
708
# optional -- mbp 2010-04-21
709
return self.bzrdir.get_repository_transport(None)
711
690
def __str__(self):
712
691
return "%s(%s)" % (self.__class__.__name__, self.base)
921
900
parents_provider = self._make_parents_provider(other_repository)
922
901
return graph.Graph(parents_provider)
925
def get_known_graph_ancestry(self, revision_ids):
926
"""Return the known graph for a set of revision ids and their ancestors.
928
st = static_tuple.StaticTuple
929
revision_keys = [st(r_id).intern() for r_id in revision_ids]
930
known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
931
return graph.GraphThunkIdsToKeys(known_graph)
933
903
def gather_stats(self, revid=None, committers=None):
934
904
"""See Repository.gather_stats()."""
935
905
path = self.bzrdir._path_for_remote_call(self._client)
1249
1214
# state, so always add a lock here. If a caller passes us a locked
1250
1215
# repository, they are responsible for unlocking it later.
1251
1216
repository.lock_read()
1252
self._check_fallback_repository(repository)
1253
1217
self._fallback_repositories.append(repository)
1254
1218
# If self._real_repository was parameterised already (e.g. because a
1255
1219
# _real_branch had its get_stacked_on_url method called), then the
1256
1220
# repository to be added may already be in the _real_repositories list.
1257
1221
if self._real_repository is not None:
1258
fallback_locations = [repo.user_url for repo in
1222
fallback_locations = [repo.bzrdir.root_transport.base for repo in
1259
1223
self._real_repository._fallback_repositories]
1260
if repository.user_url not in fallback_locations:
1224
if repository.bzrdir.root_transport.base not in fallback_locations:
1261
1225
self._real_repository.add_fallback_repository(repository)
1263
def _check_fallback_repository(self, repository):
1264
"""Check that this repository can fallback to repository safely.
1266
Raise an error if not.
1268
:param repository: A repository to fallback to.
1270
return _mod_repository.InterRepository._assert_same_model(
1273
1227
def add_inventory(self, revid, inv, parents):
1274
1228
self._ensure_real()
1275
1229
return self._real_repository.add_inventory(revid, inv, parents)
1277
1231
def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1278
parents, basis_inv=None, propagate_caches=False):
1279
1233
self._ensure_real()
1280
1234
return self._real_repository.add_inventory_by_delta(basis_revision_id,
1281
delta, new_revision_id, parents, basis_inv=basis_inv,
1282
propagate_caches=propagate_caches)
1235
delta, new_revision_id, parents)
1284
1237
def add_revision(self, rev_id, rev, inv=None, config=None):
1285
1238
self._ensure_real()
1315
1268
return self._real_repository.make_working_trees()
1317
1270
def refresh_data(self):
1318
"""Re-read any data needed to synchronise with disk.
1271
"""Re-read any data needed to to synchronise with disk.
1320
1273
This method is intended to be called after another repository instance
1321
1274
(such as one used by a smart server) has inserted data into the
1322
repository. On all repositories this will work outside of write groups.
1323
Some repository formats (pack and newer for bzrlib native formats)
1324
support refresh_data inside write groups. If called inside a write
1325
group on a repository that does not support refreshing in a write group
1326
IsInWriteGroupError will be raised.
1275
repository. It may not be called during a write group, but may be
1276
called at any other time.
1278
if self.is_in_write_group():
1279
raise errors.InternalBzrError(
1280
"May not refresh_data while in a write group.")
1328
1281
if self._real_repository is not None:
1329
1282
self._real_repository.refresh_data()
1548
1501
self._ensure_real()
1549
1502
return self._real_repository._get_inventory_xml(revision_id)
1504
def _deserialise_inventory(self, revision_id, xml):
1506
return self._real_repository._deserialise_inventory(revision_id, xml)
1551
1508
def reconcile(self, other=None, thorough=False):
1552
1509
self._ensure_real()
1553
1510
return self._real_repository.reconcile(other=other, thorough=thorough)
1628
1585
return self._real_repository.inventories
1630
1587
@needs_write_lock
1631
def pack(self, hint=None, clean_obsolete_packs=False):
1588
def pack(self, hint=None):
1632
1589
"""Compress the data within the repository.
1634
1591
This is not currently implemented within the smart server.
1636
1593
self._ensure_real()
1637
return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
1594
return self._real_repository.pack(hint=hint)
1640
1597
def revisions(self):
2068
2025
def network_name(self):
2069
2026
return self._network_name
2071
def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2072
return a_bzrdir.open_branch(name=name,
2073
ignore_fallbacks=ignore_fallbacks)
2028
def open(self, a_bzrdir, ignore_fallbacks=False):
2029
return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
2075
def _vfs_initialize(self, a_bzrdir, name):
2031
def _vfs_initialize(self, a_bzrdir):
2076
2032
# Initialisation when using a local bzrdir object, or a non-vfs init
2077
2033
# method is not available on the server.
2078
2034
# self._custom_format is always set - the start of initialize ensures
2080
2036
if isinstance(a_bzrdir, RemoteBzrDir):
2081
2037
a_bzrdir._ensure_real()
2082
result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2038
result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
2085
2040
# We assume the bzrdir is parameterised; it may not be.
2086
result = self._custom_format.initialize(a_bzrdir, name)
2041
result = self._custom_format.initialize(a_bzrdir)
2087
2042
if (isinstance(a_bzrdir, RemoteBzrDir) and
2088
2043
not isinstance(result, RemoteBranch)):
2089
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2044
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
2093
def initialize(self, a_bzrdir, name=None):
2047
def initialize(self, a_bzrdir):
2094
2048
# 1) get the network name to use.
2095
2049
if self._custom_format:
2096
2050
network_name = self._custom_format.network_name()
2102
2056
network_name = reference_format.network_name()
2103
2057
# Being asked to create on a non RemoteBzrDir:
2104
2058
if not isinstance(a_bzrdir, RemoteBzrDir):
2105
return self._vfs_initialize(a_bzrdir, name=name)
2059
return self._vfs_initialize(a_bzrdir)
2106
2060
medium = a_bzrdir._client._medium
2107
2061
if medium._is_remote_before((1, 13)):
2108
return self._vfs_initialize(a_bzrdir, name=name)
2062
return self._vfs_initialize(a_bzrdir)
2109
2063
# Creating on a remote bzr dir.
2110
2064
# 2) try direct creation via RPC
2111
2065
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2112
if name is not None:
2113
# XXX JRV20100304: Support creating colocated branches
2114
raise errors.NoColocatedBranchSupport(self)
2115
2066
verb = 'BzrDir.create_branch'
2117
2068
response = a_bzrdir._call(verb, path, network_name)
2118
2069
except errors.UnknownSmartMethod:
2119
2070
# Fallback - use vfs methods
2120
2071
medium._remember_remote_is_before((1, 13))
2121
return self._vfs_initialize(a_bzrdir, name=name)
2072
return self._vfs_initialize(a_bzrdir)
2122
2073
if response[0] != 'ok':
2123
2074
raise errors.UnexpectedSmartServerResponse(response)
2124
2075
# Turn the response into a RemoteRepository object.
2132
2083
a_bzrdir._client)
2133
2084
remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2134
2085
remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2135
format=format, setup_stacking=False, name=name)
2086
format=format, setup_stacking=False)
2136
2087
# XXX: We know this is a new branch, so it must have revno 0, revid
2137
2088
# NULL_REVISION. Creating the branch locked would make this be unable
2138
2089
# to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2167
2118
def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2168
_client=None, format=None, setup_stacking=True, name=None):
2119
_client=None, format=None, setup_stacking=True):
2169
2120
"""Create a RemoteBranch instance.
2171
2122
:param real_branch: An optional local implementation of the branch
2177
2128
:param setup_stacking: If True make an RPC call to determine the
2178
2129
stacked (or not) status of the branch. If False assume the branch
2179
2130
is not stacked.
2180
:param name: Colocated branch name
2182
2132
# We intentionally don't call the parent class's __init__, because it
2183
2133
# will try to assign to self.tags, which is a property in this subclass.
2202
2152
self._real_branch = None
2203
2153
# Fill out expected attributes of branch for bzrlib API users.
2204
2154
self._clear_cached_state()
2205
# TODO: deprecate self.base in favor of user_url
2206
self.base = self.bzrdir.user_url
2155
self.base = self.bzrdir.root_transport.base
2208
2156
self._control_files = None
2209
2157
self._lock_mode = None
2210
2158
self._lock_token = None
2275
2223
'to use vfs implementation')
2276
2224
self.bzrdir._ensure_real()
2277
2225
self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2278
ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
2226
ignore_fallbacks=self._real_ignore_fallbacks)
2279
2227
if self.repository._real_repository is None:
2280
2228
# Give the remote repository the matching real repo.
2281
2229
real_repo = self._real_branch.repository
2409
2353
self._real_branch.lock_read()
2411
2355
self._lock_count += 1
2412
return lock.LogicalLockResult(self.unlock)
2414
2357
def _remote_lock_write(self, token):
2415
2358
if token is None:
2416
2359
branch_token = repo_token = ''
2418
2361
branch_token = token
2419
repo_token = self.repository.lock_write().repository_token
2362
repo_token = self.repository.lock_write()
2420
2363
self.repository.unlock()
2421
2364
err_context = {'token': token}
2422
2365
response = self._call(
2459
2402
self._lock_count += 1
2460
2403
# Re-lock the repository too.
2461
2404
self.repository.lock_write(self._repo_lock_token)
2462
return BranchWriteLockResult(self.unlock, self._lock_token or None)
2405
return self._lock_token or None
2464
2407
def _unlock(self, branch_token, repo_token):
2465
2408
err_context = {'token': str((branch_token, repo_token))}
added
removed
bzrlib/remote.py
