327
351
_mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
354
class RemoteControlStore(_mod_config.IniFileStore):
355
"""Control store which attempts to use HPSS calls to retrieve control store.
357
Note that this is specific to bzr-based formats.
360
def __init__(self, bzrdir):
361
super(RemoteControlStore, self).__init__()
363
self._real_store = None
365
def lock_write(self, token=None):
367
return self._real_store.lock_write(token)
371
return self._real_store.unlock()
375
# We need to be able to override the undecorated implementation
376
self.save_without_locking()
378
def save_without_locking(self):
379
super(RemoteControlStore, self).save()
381
def _ensure_real(self):
382
self.bzrdir._ensure_real()
383
if self._real_store is None:
384
self._real_store = _mod_config.ControlStore(self.bzrdir)
386
def external_url(self):
387
return self.bzrdir.user_url
389
def _load_content(self):
390
medium = self.bzrdir._client._medium
391
path = self.bzrdir._path_for_remote_call(self.bzrdir._client)
393
response, handler = self.bzrdir._call_expecting_body(
394
'BzrDir.get_config_file', path)
395
except errors.UnknownSmartMethod:
397
return self._real_store._load_content()
398
if len(response) and response[0] != 'ok':
399
raise errors.UnexpectedSmartServerResponse(response)
400
return handler.read_body_bytes()
402
def _save_content(self, content):
403
# FIXME JRV 2011-11-22: Ideally this should use a
404
# HPSS call too, but at the moment it is not possible
405
# to write lock control directories.
407
return self._real_store._save_content(content)
330
410
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
331
411
"""Control directory on a remote server, accessed via bzr:// or similar."""
416
496
self._next_open_branch_result = None
417
497
return _mod_bzrdir.BzrDir.break_lock(self)
499
def _vfs_checkout_metadir(self):
501
return self._real_bzrdir.checkout_metadir()
503
def checkout_metadir(self):
504
"""Retrieve the controldir format to use for checkouts of this one.
506
medium = self._client._medium
507
if medium._is_remote_before((2, 5)):
508
return self._vfs_checkout_metadir()
509
path = self._path_for_remote_call(self._client)
511
response = self._client.call('BzrDir.checkout_metadir',
513
except errors.UnknownSmartMethod:
514
medium._remember_remote_is_before((2, 5))
515
return self._vfs_checkout_metadir()
516
if len(response) != 3:
517
raise errors.UnexpectedSmartServerResponse(response)
518
control_name, repo_name, branch_name = response
520
format = controldir.network_format_registry.get(control_name)
522
raise errors.UnknownFormatError(kind='control',
526
repo_format = _mod_repository.network_format_registry.get(
529
raise errors.UnknownFormatError(kind='repository',
531
format.repository_format = repo_format
534
format.set_branch_format(
535
branch.network_format_registry.get(branch_name))
537
raise errors.UnknownFormatError(kind='branch',
419
541
def _vfs_cloning_metadir(self, require_stacking=False):
420
542
self._ensure_real()
421
543
return self._real_bzrdir.cloning_metadir(
523
687
b = self.open_branch(name=name)
690
def get_branches(self, possible_transports=None, ignore_fallbacks=False):
691
path = self._path_for_remote_call(self._client)
693
response, handler = self._call_expecting_body(
694
'BzrDir.get_branches', path)
695
except errors.UnknownSmartMethod:
697
return self._real_bzrdir.get_branches()
698
if response[0] != "success":
699
raise errors.UnexpectedSmartServerResponse(response)
700
body = bencode.bdecode(handler.read_body_bytes())
702
for (name, value) in body.iteritems():
703
ret[name] = self._open_branch(name, value[0], value[1],
704
possible_transports=possible_transports,
705
ignore_fallbacks=ignore_fallbacks)
708
def set_branch_reference(self, target_branch, name=None):
709
"""See BzrDir.set_branch_reference()."""
711
name = self._get_selected_branch()
713
raise errors.NoColocatedBranchSupport(self)
715
return self._real_bzrdir.set_branch_reference(target_branch, name=name)
526
717
def get_branch_reference(self, name=None):
527
718
"""See BzrDir.get_branch_reference()."""
529
# XXX JRV20100304: Support opening colocated branches
720
name = self._get_selected_branch()
530
722
raise errors.NoColocatedBranchSupport(self)
531
723
response = self._get_branch_reference()
532
724
if response[0] == 'ref':
568
760
"""See BzrDir._get_tree_branch()."""
569
761
return None, self.open_branch(name=name)
571
def open_branch(self, name=None, unsupported=False,
572
ignore_fallbacks=False):
574
raise NotImplementedError('unsupported flag support not implemented yet.')
575
if self._next_open_branch_result is not None:
576
# See create_branch for details.
577
result = self._next_open_branch_result
578
self._next_open_branch_result = None
580
response = self._get_branch_reference()
581
if response[0] == 'ref':
763
def _open_branch(self, name, kind, location_or_format,
764
ignore_fallbacks=False, possible_transports=None):
582
766
# a branch reference, use the existing BranchReference logic.
583
767
format = BranchReferenceFormat()
584
768
return format.open(self, name=name, _found=True,
585
location=response[1], ignore_fallbacks=ignore_fallbacks)
586
branch_format_name = response[1]
769
location=location_or_format, ignore_fallbacks=ignore_fallbacks,
770
possible_transports=possible_transports)
771
branch_format_name = location_or_format
587
772
if not branch_format_name:
588
773
branch_format_name = None
589
774
format = RemoteBranchFormat(network_name=branch_format_name)
590
775
return RemoteBranch(self, self.find_repository(), format=format,
591
setup_stacking=not ignore_fallbacks, name=name)
776
setup_stacking=not ignore_fallbacks, name=name,
777
possible_transports=possible_transports)
779
def open_branch(self, name=None, unsupported=False,
780
ignore_fallbacks=False, possible_transports=None):
782
name = self._get_selected_branch()
784
raise errors.NoColocatedBranchSupport(self)
786
raise NotImplementedError('unsupported flag support not implemented yet.')
787
if self._next_open_branch_result is not None:
788
# See create_branch for details.
789
result = self._next_open_branch_result
790
self._next_open_branch_result = None
792
response = self._get_branch_reference()
793
return self._open_branch(name, response[0], response[1],
794
possible_transports=possible_transports,
795
ignore_fallbacks=ignore_fallbacks)
593
797
def _open_repo_v1(self, path):
594
798
verb = 'BzrDir.find_repository'
1005
1249
for older plugins that don't use e.g. the CommitBuilder
1009
return self._real_repository.commit_write_group()
1252
if self._real_repository:
1254
return self._real_repository.commit_write_group()
1255
if not self.is_in_write_group():
1256
raise errors.BzrError("not in write group")
1257
path = self.bzrdir._path_for_remote_call(self._client)
1258
response = self._call('Repository.commit_write_group', path,
1259
self._lock_token, self._write_group_tokens)
1260
if response != ('ok', ):
1261
raise errors.UnexpectedSmartServerResponse(response)
1262
self._write_group_tokens = None
1263
# Refresh data after writing to the repository.
1011
1266
def resume_write_group(self, tokens):
1013
return self._real_repository.resume_write_group(tokens)
1267
if self._real_repository:
1268
return self._real_repository.resume_write_group(tokens)
1269
path = self.bzrdir._path_for_remote_call(self._client)
1271
response = self._call('Repository.check_write_group', path,
1272
self._lock_token, tokens)
1273
except errors.UnknownSmartMethod:
1275
return self._real_repository.resume_write_group(tokens)
1276
if response != ('ok', ):
1277
raise errors.UnexpectedSmartServerResponse(response)
1278
self._write_group_tokens = tokens
1015
1280
def suspend_write_group(self):
1017
return self._real_repository.suspend_write_group()
1281
if self._real_repository:
1282
return self._real_repository.suspend_write_group()
1283
ret = self._write_group_tokens or []
1284
self._write_group_tokens = None
1019
1287
def get_missing_parent_inventories(self, check_for_missing_texts=True):
1020
1288
self._ensure_real()
1465
1768
raise errors.UnexpectedSmartServerResponse(response)
1467
1771
def sprout(self, to_bzrdir, revision_id=None):
1468
# TODO: Option to control what format is created?
1470
dest_repo = self._real_repository._format.initialize(to_bzrdir,
1772
"""Create a descendent repository for new development.
1774
Unlike clone, this does not copy the settings of the repository.
1776
dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
1472
1777
dest_repo.fetch(self, revision_id=revision_id)
1473
1778
return dest_repo
1780
def _create_sprouting_repo(self, a_bzrdir, shared):
1781
if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
1782
# use target default format.
1783
dest_repo = a_bzrdir.create_repository()
1785
# Most control formats need the repository to be specifically
1786
# created, but on some old all-in-one formats it's not needed
1788
dest_repo = self._format.initialize(a_bzrdir, shared=shared)
1789
except errors.UninitializableFormat:
1790
dest_repo = a_bzrdir.open_repository()
1475
1793
### These methods are just thin shims to the VFS object for now.
1477
1796
def revision_tree(self, revision_id):
1479
return self._real_repository.revision_tree(revision_id)
1797
revision_id = _mod_revision.ensure_null(revision_id)
1798
if revision_id == _mod_revision.NULL_REVISION:
1799
return InventoryRevisionTree(self,
1800
Inventory(root_id=None), _mod_revision.NULL_REVISION)
1802
return list(self.revision_trees([revision_id]))[0]
1481
1804
def get_serializer_format(self):
1483
return self._real_repository.get_serializer_format()
1805
path = self.bzrdir._path_for_remote_call(self._client)
1807
response = self._call('VersionedFileRepository.get_serializer_format',
1809
except errors.UnknownSmartMethod:
1811
return self._real_repository.get_serializer_format()
1812
if response[0] != 'ok':
1813
raise errors.UnexpectedSmartServerResponse(response)
1485
1816
def get_commit_builder(self, branch, parents, config, timestamp=None,
1486
1817
timezone=None, committer=None, revprops=None,
1487
1818
revision_id=None, lossy=False):
1488
# FIXME: It ought to be possible to call this without immediately
1489
# triggering _ensure_real. For now it's the easiest thing to do.
1491
real_repo = self._real_repository
1492
builder = real_repo.get_commit_builder(branch, parents,
1493
config, timestamp=timestamp, timezone=timezone,
1494
committer=committer, revprops=revprops,
1495
revision_id=revision_id, lossy=lossy)
1819
"""Obtain a CommitBuilder for this repository.
1821
:param branch: Branch to commit to.
1822
:param parents: Revision ids of the parents of the new revision.
1823
:param config: Configuration to use.
1824
:param timestamp: Optional timestamp recorded for commit.
1825
:param timezone: Optional timezone for timestamp.
1826
:param committer: Optional committer to set for commit.
1827
:param revprops: Optional dictionary of revision properties.
1828
:param revision_id: Optional revision id.
1829
:param lossy: Whether to discard data that can not be natively
1830
represented, when pushing to a foreign VCS
1832
if self._fallback_repositories and not self._format.supports_chks:
1833
raise errors.BzrError("Cannot commit directly to a stacked branch"
1834
" in pre-2a formats. See "
1835
"https://bugs.launchpad.net/bzr/+bug/375013 for details.")
1836
if self._format.rich_root_data:
1837
commit_builder_kls = vf_repository.VersionedFileRootCommitBuilder
1839
commit_builder_kls = vf_repository.VersionedFileCommitBuilder
1840
result = commit_builder_kls(self, parents, config,
1841
timestamp, timezone, committer, revprops, revision_id,
1843
self.start_write_group()
1498
1846
def add_fallback_repository(self, repository):
1499
1847
"""Add a repository to use for looking up data not held locally.
1543
1892
delta, new_revision_id, parents, basis_inv=basis_inv,
1544
1893
propagate_caches=propagate_caches)
1546
def add_revision(self, rev_id, rev, inv=None, config=None):
1548
return self._real_repository.add_revision(
1549
rev_id, rev, inv=inv, config=config)
1895
def add_revision(self, revision_id, rev, inv=None):
1896
_mod_revision.check_not_reserved_id(revision_id)
1897
key = (revision_id,)
1898
# check inventory present
1899
if not self.inventories.get_parent_map([key]):
1901
raise errors.WeaveRevisionNotPresent(revision_id,
1904
# yes, this is not suitable for adding with ghosts.
1905
rev.inventory_sha1 = self.add_inventory(revision_id, inv,
1908
rev.inventory_sha1 = self.inventories.get_sha1s([key])[key]
1909
self._add_revision(rev)
1911
def _add_revision(self, rev):
1912
if self._real_repository is not None:
1913
return self._real_repository._add_revision(rev)
1914
text = self._serializer.write_revision_to_string(rev)
1915
key = (rev.revision_id,)
1916
parents = tuple((parent,) for parent in rev.parent_ids)
1917
self._write_group_tokens, missing_keys = self._get_sink().insert_stream(
1918
[('revisions', [FulltextContentFactory(key, parents, None, text)])],
1919
self._format, self._write_group_tokens)
1551
1921
@needs_read_lock
1552
1922
def get_inventory(self, revision_id):
1923
return list(self.iter_inventories([revision_id]))[0]
1925
def _iter_inventories_rpc(self, revision_ids, ordering):
1926
if ordering is None:
1927
ordering = 'unordered'
1928
path = self.bzrdir._path_for_remote_call(self._client)
1929
body = "\n".join(revision_ids)
1930
response_tuple, response_handler = (
1931
self._call_with_body_bytes_expecting_body(
1932
"VersionedFileRepository.get_inventories",
1933
(path, ordering), body))
1934
if response_tuple[0] != "ok":
1935
raise errors.UnexpectedSmartServerResponse(response_tuple)
1936
deserializer = inventory_delta.InventoryDeltaDeserializer()
1937
byte_stream = response_handler.read_streamed_body()
1938
decoded = smart_repo._byte_stream_to_stream(byte_stream)
1940
# no results whatsoever
1942
src_format, stream = decoded
1943
if src_format.network_name() != self._format.network_name():
1944
raise AssertionError(
1945
"Mismatched RemoteRepository and stream src %r, %r" % (
1946
src_format.network_name(), self._format.network_name()))
1947
# ignore the src format, it's not really relevant
1948
prev_inv = Inventory(root_id=None,
1949
revision_id=_mod_revision.NULL_REVISION)
1950
# there should be just one substream, with inventory deltas
1951
substream_kind, substream = stream.next()
1952
if substream_kind != "inventory-deltas":
1953
raise AssertionError(
1954
"Unexpected stream %r received" % substream_kind)
1955
for record in substream:
1956
(parent_id, new_id, versioned_root, tree_references, invdelta) = (
1957
deserializer.parse_text_bytes(record.get_bytes_as("fulltext")))
1958
if parent_id != prev_inv.revision_id:
1959
raise AssertionError("invalid base %r != %r" % (parent_id,
1960
prev_inv.revision_id))
1961
inv = prev_inv.create_by_apply_delta(invdelta, new_id)
1962
yield inv, inv.revision_id
1965
def _iter_inventories_vfs(self, revision_ids, ordering=None):
1553
1966
self._ensure_real()
1554
return self._real_repository.get_inventory(revision_id)
1967
return self._real_repository._iter_inventories(revision_ids, ordering)
1556
1969
def iter_inventories(self, revision_ids, ordering=None):
1558
return self._real_repository.iter_inventories(revision_ids, ordering)
1970
"""Get many inventories by revision_ids.
1972
This will buffer some or all of the texts used in constructing the
1973
inventories in memory, but will only parse a single inventory at a
1976
:param revision_ids: The expected revision ids of the inventories.
1977
:param ordering: optional ordering, e.g. 'topological'. If not
1978
specified, the order of revision_ids will be preserved (by
1979
buffering if necessary).
1980
:return: An iterator of inventories.
1982
if ((None in revision_ids)
1983
or (_mod_revision.NULL_REVISION in revision_ids)):
1984
raise ValueError('cannot get null revision inventory')
1985
for inv, revid in self._iter_inventories(revision_ids, ordering):
1987
raise errors.NoSuchRevision(self, revid)
1990
def _iter_inventories(self, revision_ids, ordering=None):
1991
if len(revision_ids) == 0:
1993
missing = set(revision_ids)
1994
if ordering is None:
1995
order_as_requested = True
1997
order = list(revision_ids)
1999
next_revid = order.pop()
2001
order_as_requested = False
2002
if ordering != 'unordered' and self._fallback_repositories:
2003
raise ValueError('unsupported ordering %r' % ordering)
2004
iter_inv_fns = [self._iter_inventories_rpc] + [
2005
fallback._iter_inventories for fallback in
2006
self._fallback_repositories]
2008
for iter_inv in iter_inv_fns:
2009
request = [revid for revid in revision_ids if revid in missing]
2010
for inv, revid in iter_inv(request, ordering):
2013
missing.remove(inv.revision_id)
2014
if ordering != 'unordered':
2018
if order_as_requested:
2019
# Yield as many results as we can while preserving order.
2020
while next_revid in invs:
2021
inv = invs.pop(next_revid)
2022
yield inv, inv.revision_id
2024
next_revid = order.pop()
2026
# We still want to fully consume the stream, just
2027
# in case it is not actually finished at this point
2030
except errors.UnknownSmartMethod:
2031
for inv, revid in self._iter_inventories_vfs(revision_ids, ordering):
2035
if order_as_requested:
2036
if next_revid is not None:
2037
yield None, next_revid
2040
yield invs.get(revid), revid
2043
yield None, missing.pop()
1560
2045
@needs_read_lock
1561
2046
def get_revision(self, revision_id):
1563
return self._real_repository.get_revision(revision_id)
2047
return self.get_revisions([revision_id])[0]
1565
2049
def get_transaction(self):
1566
2050
self._ensure_real()
1676
2176
return self._real_repository._get_versioned_file_checker(
1677
2177
revisions, revision_versions_cache)
2179
def _iter_files_bytes_rpc(self, desired_files, absent):
2180
path = self.bzrdir._path_for_remote_call(self._client)
2183
for (file_id, revid, identifier) in desired_files:
2184
lines.append("%s\0%s" % (
2185
osutils.safe_file_id(file_id),
2186
osutils.safe_revision_id(revid)))
2187
identifiers.append(identifier)
2188
(response_tuple, response_handler) = (
2189
self._call_with_body_bytes_expecting_body(
2190
"Repository.iter_files_bytes", (path, ), "\n".join(lines)))
2191
if response_tuple != ('ok', ):
2192
response_handler.cancel_read_body()
2193
raise errors.UnexpectedSmartServerResponse(response_tuple)
2194
byte_stream = response_handler.read_streamed_body()
2195
def decompress_stream(start, byte_stream, unused):
2196
decompressor = zlib.decompressobj()
2197
yield decompressor.decompress(start)
2198
while decompressor.unused_data == "":
2200
data = byte_stream.next()
2201
except StopIteration:
2203
yield decompressor.decompress(data)
2204
yield decompressor.flush()
2205
unused.append(decompressor.unused_data)
2208
while not "\n" in unused:
2209
unused += byte_stream.next()
2210
header, rest = unused.split("\n", 1)
2211
args = header.split("\0")
2212
if args[0] == "absent":
2213
absent[identifiers[int(args[3])]] = (args[1], args[2])
2216
elif args[0] == "ok":
2219
raise errors.UnexpectedSmartServerResponse(args)
2221
yield (identifiers[idx],
2222
decompress_stream(rest, byte_stream, unused_chunks))
2223
unused = "".join(unused_chunks)
1679
2225
def iter_files_bytes(self, desired_files):
1680
2226
"""See Repository.iter_file_bytes.
1683
return self._real_repository.iter_files_bytes(desired_files)
2230
for (identifier, bytes_iterator) in self._iter_files_bytes_rpc(
2231
desired_files, absent):
2232
yield identifier, bytes_iterator
2233
for fallback in self._fallback_repositories:
2236
desired_files = [(key[0], key[1], identifier) for
2237
(identifier, key) in absent.iteritems()]
2238
for (identifier, bytes_iterator) in fallback.iter_files_bytes(desired_files):
2239
del absent[identifier]
2240
yield identifier, bytes_iterator
2242
# There may be more missing items, but raise an exception
2244
missing_identifier = absent.keys()[0]
2245
missing_key = absent[missing_identifier]
2246
raise errors.RevisionNotPresent(revision_id=missing_key[1],
2247
file_id=missing_key[0])
2248
except errors.UnknownSmartMethod:
2250
for (identifier, bytes_iterator) in (
2251
self._real_repository.iter_files_bytes(desired_files)):
2252
yield identifier, bytes_iterator
2254
def get_cached_parent_map(self, revision_ids):
2255
"""See bzrlib.CachingParentsProvider.get_cached_parent_map"""
2256
return self._unstacked_provider.get_cached_parent_map(revision_ids)
1685
2258
def get_parent_map(self, revision_ids):
1686
2259
"""See bzrlib.Graph.get_parent_map()."""
1745
2318
if parents_map is None:
1746
2319
# Repository is not locked, so there's no cache.
1747
2320
parents_map = {}
1748
# start_set is all the keys in the cache
1749
start_set = set(parents_map)
1750
# result set is all the references to keys in the cache
1751
result_parents = set()
1752
for parents in parents_map.itervalues():
1753
result_parents.update(parents)
1754
stop_keys = result_parents.difference(start_set)
1755
# We don't need to send ghosts back to the server as a position to
1757
stop_keys.difference_update(self._unstacked_provider.missing_keys)
1758
key_count = len(parents_map)
1759
if (NULL_REVISION in result_parents
1760
and NULL_REVISION in self._unstacked_provider.missing_keys):
1761
# If we pruned NULL_REVISION from the stop_keys because it's also
1762
# in our cache of "missing" keys we need to increment our key count
1763
# by 1, because the reconsitituted SearchResult on the server will
1764
# still consider NULL_REVISION to be an included key.
1766
included_keys = start_set.intersection(result_parents)
1767
start_set.difference_update(included_keys)
2321
if _DEFAULT_SEARCH_DEPTH <= 0:
2322
(start_set, stop_keys,
2323
key_count) = vf_search.search_result_from_parent_map(
2324
parents_map, self._unstacked_provider.missing_keys)
2326
(start_set, stop_keys,
2327
key_count) = vf_search.limited_search_result_from_parent_map(
2328
parents_map, self._unstacked_provider.missing_keys,
2329
keys, depth=_DEFAULT_SEARCH_DEPTH)
1768
2330
recipe = ('manual', start_set, stop_keys, key_count)
1769
2331
body = self._serialise_search_recipe(recipe)
1770
2332
path = self.bzrdir._path_for_remote_call(self._client)
1820
2382
@needs_read_lock
1821
2383
def get_signature_text(self, revision_id):
1823
return self._real_repository.get_signature_text(revision_id)
2384
path = self.bzrdir._path_for_remote_call(self._client)
2386
response_tuple, response_handler = self._call_expecting_body(
2387
'Repository.get_revision_signature_text', path, revision_id)
2388
except errors.UnknownSmartMethod:
2390
return self._real_repository.get_signature_text(revision_id)
2391
except errors.NoSuchRevision, err:
2392
for fallback in self._fallback_repositories:
2394
return fallback.get_signature_text(revision_id)
2395
except errors.NoSuchRevision:
2399
if response_tuple[0] != 'ok':
2400
raise errors.UnexpectedSmartServerResponse(response_tuple)
2401
return response_handler.read_body_bytes()
1825
2403
@needs_read_lock
1826
2404
def _get_inventory_xml(self, revision_id):
2405
# This call is used by older working tree formats,
2406
# which stored a serialized basis inventory.
1827
2407
self._ensure_real()
1828
2408
return self._real_repository._get_inventory_xml(revision_id)
1830
2411
def reconcile(self, other=None, thorough=False):
1832
return self._real_repository.reconcile(other=other, thorough=thorough)
2412
from bzrlib.reconcile import RepoReconciler
2413
path = self.bzrdir._path_for_remote_call(self._client)
2415
response, handler = self._call_expecting_body(
2416
'Repository.reconcile', path, self._lock_token)
2417
except (errors.UnknownSmartMethod, errors.TokenLockingNotSupported):
2419
return self._real_repository.reconcile(other=other, thorough=thorough)
2420
if response != ('ok', ):
2421
raise errors.UnexpectedSmartServerResponse(response)
2422
body = handler.read_body_bytes()
2423
result = RepoReconciler(self)
2424
for line in body.split('\n'):
2427
key, val_text = line.split(':')
2428
if key == "garbage_inventories":
2429
result.garbage_inventories = int(val_text)
2430
elif key == "inconsistent_parents":
2431
result.inconsistent_parents = int(val_text)
2433
mutter("unknown reconcile key %r" % key)
1834
2436
def all_revision_ids(self):
1836
return self._real_repository.all_revision_ids()
2437
path = self.bzrdir._path_for_remote_call(self._client)
2439
response_tuple, response_handler = self._call_expecting_body(
2440
"Repository.all_revision_ids", path)
2441
except errors.UnknownSmartMethod:
2443
return self._real_repository.all_revision_ids()
2444
if response_tuple != ("ok", ):
2445
raise errors.UnexpectedSmartServerResponse(response_tuple)
2446
revids = set(response_handler.read_body_bytes().splitlines())
2447
for fallback in self._fallback_repositories:
2448
revids.update(set(fallback.all_revision_ids()))
2451
def _filtered_revision_trees(self, revision_ids, file_ids):
2452
"""Return Tree for a revision on this branch with only some files.
2454
:param revision_ids: a sequence of revision-ids;
2455
a revision-id may not be None or 'null:'
2456
:param file_ids: if not None, the result is filtered
2457
so that only those file-ids, their parents and their
2458
children are included.
2460
inventories = self.iter_inventories(revision_ids)
2461
for inv in inventories:
2462
# Should we introduce a FilteredRevisionTree class rather
2463
# than pre-filter the inventory here?
2464
filtered_inv = inv.filter(file_ids)
2465
yield InventoryRevisionTree(self, filtered_inv, filtered_inv.revision_id)
1838
2467
@needs_read_lock
1839
2468
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1841
return self._real_repository.get_deltas_for_revisions(revisions,
1842
specific_fileids=specific_fileids)
2469
medium = self._client._medium
2470
if medium._is_remote_before((1, 2)):
2472
for delta in self._real_repository.get_deltas_for_revisions(
2473
revisions, specific_fileids):
2476
# Get the revision-ids of interest
2477
required_trees = set()
2478
for revision in revisions:
2479
required_trees.add(revision.revision_id)
2480
required_trees.update(revision.parent_ids[:1])
2482
# Get the matching filtered trees. Note that it's more
2483
# efficient to pass filtered trees to changes_from() rather
2484
# than doing the filtering afterwards. changes_from() could
2485
# arguably do the filtering itself but it's path-based, not
2486
# file-id based, so filtering before or afterwards is
2488
if specific_fileids is None:
2489
trees = dict((t.get_revision_id(), t) for
2490
t in self.revision_trees(required_trees))
2492
trees = dict((t.get_revision_id(), t) for
2493
t in self._filtered_revision_trees(required_trees,
2496
# Calculate the deltas
2497
for revision in revisions:
2498
if not revision.parent_ids:
2499
old_tree = self.revision_tree(_mod_revision.NULL_REVISION)
2501
old_tree = trees[revision.parent_ids[0]]
2502
yield trees[revision.revision_id].changes_from(old_tree)
1844
2504
@needs_read_lock
1845
2505
def get_revision_delta(self, revision_id, specific_fileids=None):
1847
return self._real_repository.get_revision_delta(revision_id,
1848
specific_fileids=specific_fileids)
2506
r = self.get_revision(revision_id)
2507
return list(self.get_deltas_for_revisions([r],
2508
specific_fileids=specific_fileids))[0]
1850
2510
@needs_read_lock
1851
2511
def revision_trees(self, revision_ids):
1853
return self._real_repository.revision_trees(revision_ids)
2512
inventories = self.iter_inventories(revision_ids)
2513
for inv in inventories:
2514
yield InventoryRevisionTree(self, inv, inv.revision_id)
1855
2516
@needs_read_lock
1856
2517
def get_revision_reconcile(self, revision_id):
1968
2642
self._ensure_real()
1969
2643
return self._real_repository.texts
2645
def _iter_revisions_rpc(self, revision_ids):
2646
body = "\n".join(revision_ids)
2647
path = self.bzrdir._path_for_remote_call(self._client)
2648
response_tuple, response_handler = (
2649
self._call_with_body_bytes_expecting_body(
2650
"Repository.iter_revisions", (path, ), body))
2651
if response_tuple[0] != "ok":
2652
raise errors.UnexpectedSmartServerResponse(response_tuple)
2653
serializer_format = response_tuple[1]
2654
serializer = serializer_format_registry.get(serializer_format)
2655
byte_stream = response_handler.read_streamed_body()
2656
decompressor = zlib.decompressobj()
2658
for bytes in byte_stream:
2659
chunks.append(decompressor.decompress(bytes))
2660
if decompressor.unused_data != "":
2661
chunks.append(decompressor.flush())
2662
yield serializer.read_revision_from_string("".join(chunks))
2663
unused = decompressor.unused_data
2664
decompressor = zlib.decompressobj()
2665
chunks = [decompressor.decompress(unused)]
2666
chunks.append(decompressor.flush())
2667
text = "".join(chunks)
2669
yield serializer.read_revision_from_string("".join(chunks))
1971
2671
@needs_read_lock
1972
2672
def get_revisions(self, revision_ids):
1974
return self._real_repository.get_revisions(revision_ids)
2673
if revision_ids is None:
2674
revision_ids = self.all_revision_ids()
2676
for rev_id in revision_ids:
2677
if not rev_id or not isinstance(rev_id, basestring):
2678
raise errors.InvalidRevisionId(
2679
revision_id=rev_id, branch=self)
2681
missing = set(revision_ids)
2683
for rev in self._iter_revisions_rpc(revision_ids):
2684
missing.remove(rev.revision_id)
2685
revs[rev.revision_id] = rev
2686
except errors.UnknownSmartMethod:
2688
return self._real_repository.get_revisions(revision_ids)
2689
for fallback in self._fallback_repositories:
2692
for revid in list(missing):
2693
# XXX JRV 2011-11-20: It would be nice if there was a
2694
# public method on Repository that could be used to query
2695
# for revision objects *without* failing completely if one
2696
# was missing. There is VersionedFileRepository._iter_revisions,
2697
# but unfortunately that's private and not provided by
2698
# all repository implementations.
2700
revs[revid] = fallback.get_revision(revid)
2701
except errors.NoSuchRevision:
2704
missing.remove(revid)
2706
raise errors.NoSuchRevision(self, list(missing)[0])
2707
return [revs[revid] for revid in revision_ids]
1976
2709
def supports_rich_root(self):
1977
2710
return self._format.rich_root_data
1985
2718
def _serializer(self):
1986
2719
return self._format._serializer
1988
2722
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1990
return self._real_repository.store_revision_signature(
1991
gpg_strategy, plaintext, revision_id)
2723
signature = gpg_strategy.sign(plaintext)
2724
self.add_signature_text(revision_id, signature)
1993
2726
def add_signature_text(self, revision_id, signature):
1995
return self._real_repository.add_signature_text(revision_id, signature)
2727
if self._real_repository:
2728
# If there is a real repository the write group will
2729
# be in the real repository as well, so use that:
2731
return self._real_repository.add_signature_text(
2732
revision_id, signature)
2733
path = self.bzrdir._path_for_remote_call(self._client)
2734
response, handler = self._call_with_body_bytes_expecting_body(
2735
'Repository.add_signature_text', (path, self._lock_token,
2736
revision_id) + tuple(self._write_group_tokens), signature)
2737
handler.cancel_read_body()
2739
if response[0] != 'ok':
2740
raise errors.UnexpectedSmartServerResponse(response)
2741
self._write_group_tokens = response[1:]
1997
2743
def has_signature_for_revision_id(self, revision_id):
1999
return self._real_repository.has_signature_for_revision_id(revision_id)
2744
path = self.bzrdir._path_for_remote_call(self._client)
2746
response = self._call('Repository.has_signature_for_revision_id',
2748
except errors.UnknownSmartMethod:
2750
return self._real_repository.has_signature_for_revision_id(
2752
if response[0] not in ('yes', 'no'):
2753
raise SmartProtocolError('unexpected response code %s' % (response,))
2754
if response[0] == 'yes':
2756
for fallback in self._fallback_repositories:
2757
if fallback.has_signature_for_revision_id(revision_id):
2762
def verify_revision_signature(self, revision_id, gpg_strategy):
2763
if not self.has_signature_for_revision_id(revision_id):
2764
return gpg.SIGNATURE_NOT_SIGNED, None
2765
signature = self.get_signature_text(revision_id)
2767
testament = _mod_testament.Testament.from_revision(self, revision_id)
2768
plaintext = testament.as_short_text()
2770
return gpg_strategy.verify(signature, plaintext)
2001
2772
def item_keys_introduced_by(self, revision_ids, _files_pb=None):
2002
2773
self._ensure_real()
3253
class RemoteBranchStore(_mod_config.IniFileStore):
3254
"""Branch store which attempts to use HPSS calls to retrieve branch store.
3256
Note that this is specific to bzr-based formats.
3259
def __init__(self, branch):
3260
super(RemoteBranchStore, self).__init__()
3261
self.branch = branch
3263
self._real_store = None
3265
def lock_write(self, token=None):
3266
return self.branch.lock_write(token)
3269
return self.branch.unlock()
3273
# We need to be able to override the undecorated implementation
3274
self.save_without_locking()
3276
def save_without_locking(self):
3277
super(RemoteBranchStore, self).save()
3279
def external_url(self):
3280
return self.branch.user_url
3282
def _load_content(self):
3283
path = self.branch._remote_path()
3285
response, handler = self.branch._call_expecting_body(
3286
'Branch.get_config_file', path)
3287
except errors.UnknownSmartMethod:
3289
return self._real_store._load_content()
3290
if len(response) and response[0] != 'ok':
3291
raise errors.UnexpectedSmartServerResponse(response)
3292
return handler.read_body_bytes()
3294
def _save_content(self, content):
3295
path = self.branch._remote_path()
3297
response, handler = self.branch._call_with_body_bytes_expecting_body(
3298
'Branch.put_config_file', (path,
3299
self.branch._lock_token, self.branch._repo_lock_token),
3301
except errors.UnknownSmartMethod:
3303
return self._real_store._save_content(content)
3304
handler.cancel_read_body()
3305
if response != ('ok', ):
3306
raise errors.UnexpectedSmartServerResponse(response)
3308
def _ensure_real(self):
3309
self.branch._ensure_real()
3310
if self._real_store is None:
3311
self._real_store = _mod_config.BranchStore(self.branch)
2468
3314
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2469
3315
"""Branch stored on a server accessed by HPSS RPC.
3287
4186
'Missing key %r in context %r', key_err.args[0], context)
3290
if err.error_verb == 'NoSuchRevision':
3291
raise NoSuchRevision(find('branch'), err.error_args[0])
3292
elif err.error_verb == 'nosuchrevision':
3293
raise NoSuchRevision(find('repository'), err.error_args[0])
3294
elif err.error_verb == 'nobranch':
3295
if len(err.error_args) >= 1:
3296
extra = err.error_args[0]
3299
raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
3301
elif err.error_verb == 'norepository':
3302
raise errors.NoRepositoryPresent(find('bzrdir'))
3303
elif err.error_verb == 'UnlockableTransport':
3304
raise errors.UnlockableTransport(find('bzrdir').root_transport)
3305
elif err.error_verb == 'TokenMismatch':
3306
raise errors.TokenMismatch(find('token'), '(remote token)')
3307
elif err.error_verb == 'Diverged':
3308
raise errors.DivergedBranches(find('branch'), find('other_branch'))
3309
elif err.error_verb == 'NotStacked':
3310
raise errors.NotStacked(branch=find('branch'))
3311
elif err.error_verb == 'PermissionDenied':
3313
if len(err.error_args) >= 2:
3314
extra = err.error_args[1]
3317
raise errors.PermissionDenied(path, extra=extra)
3318
elif err.error_verb == 'ReadError':
3320
raise errors.ReadError(path)
3321
elif err.error_verb == 'NoSuchFile':
3323
raise errors.NoSuchFile(path)
3324
_translate_error_without_context(err)
3327
def _translate_error_without_context(err):
3328
"""Translate any ErrorFromSmartServer values that don't require context"""
3329
if err.error_verb == 'IncompatibleRepositories':
3330
raise errors.IncompatibleRepositories(err.error_args[0],
3331
err.error_args[1], err.error_args[2])
3332
elif err.error_verb == 'LockContention':
3333
raise errors.LockContention('(remote lock)')
3334
elif err.error_verb == 'LockFailed':
3335
raise errors.LockFailed(err.error_args[0], err.error_args[1])
3336
elif err.error_verb == 'TipChangeRejected':
3337
raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
3338
elif err.error_verb == 'UnstackableBranchFormat':
3339
raise errors.UnstackableBranchFormat(*err.error_args)
3340
elif err.error_verb == 'UnstackableRepositoryFormat':
3341
raise errors.UnstackableRepositoryFormat(*err.error_args)
3342
elif err.error_verb == 'FileExists':
3343
raise errors.FileExists(err.error_args[0])
3344
elif err.error_verb == 'DirectoryNotEmpty':
3345
raise errors.DirectoryNotEmpty(err.error_args[0])
3346
elif err.error_verb == 'ShortReadvError':
3347
args = err.error_args
3348
raise errors.ShortReadvError(
3349
args[0], int(args[1]), int(args[2]), int(args[3]))
3350
elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
4190
translator = error_translators.get(err.error_verb)
4194
raise translator(err, find, get_path)
4196
translator = no_context_error_translators.get(err.error_verb)
4198
raise errors.UnknownErrorFromSmartServer(err)
4200
raise translator(err)
4203
error_translators.register('NoSuchRevision',
4204
lambda err, find, get_path: NoSuchRevision(
4205
find('branch'), err.error_args[0]))
4206
error_translators.register('nosuchrevision',
4207
lambda err, find, get_path: NoSuchRevision(
4208
find('repository'), err.error_args[0]))
4210
def _translate_nobranch_error(err, find, get_path):
4211
if len(err.error_args) >= 1:
4212
extra = err.error_args[0]
4215
return errors.NotBranchError(path=find('bzrdir').root_transport.base,
4218
error_translators.register('nobranch', _translate_nobranch_error)
4219
error_translators.register('norepository',
4220
lambda err, find, get_path: errors.NoRepositoryPresent(
4222
error_translators.register('UnlockableTransport',
4223
lambda err, find, get_path: errors.UnlockableTransport(
4224
find('bzrdir').root_transport))
4225
error_translators.register('TokenMismatch',
4226
lambda err, find, get_path: errors.TokenMismatch(
4227
find('token'), '(remote token)'))
4228
error_translators.register('Diverged',
4229
lambda err, find, get_path: errors.DivergedBranches(
4230
find('branch'), find('other_branch')))
4231
error_translators.register('NotStacked',
4232
lambda err, find, get_path: errors.NotStacked(branch=find('branch')))
4234
def _translate_PermissionDenied(err, find, get_path):
4236
if len(err.error_args) >= 2:
4237
extra = err.error_args[1]
4240
return errors.PermissionDenied(path, extra=extra)
4242
error_translators.register('PermissionDenied', _translate_PermissionDenied)
4243
error_translators.register('ReadError',
4244
lambda err, find, get_path: errors.ReadError(get_path()))
4245
error_translators.register('NoSuchFile',
4246
lambda err, find, get_path: errors.NoSuchFile(get_path()))
4247
error_translators.register('TokenLockingNotSupported',
4248
lambda err, find, get_path: errors.TokenLockingNotSupported(
4249
find('repository')))
4250
error_translators.register('UnsuspendableWriteGroup',
4251
lambda err, find, get_path: errors.UnsuspendableWriteGroup(
4252
repository=find('repository')))
4253
error_translators.register('UnresumableWriteGroup',
4254
lambda err, find, get_path: errors.UnresumableWriteGroup(
4255
repository=find('repository'), write_groups=err.error_args[0],
4256
reason=err.error_args[1]))
4257
no_context_error_translators.register('IncompatibleRepositories',
4258
lambda err: errors.IncompatibleRepositories(
4259
err.error_args[0], err.error_args[1], err.error_args[2]))
4260
no_context_error_translators.register('LockContention',
4261
lambda err: errors.LockContention('(remote lock)'))
4262
no_context_error_translators.register('LockFailed',
4263
lambda err: errors.LockFailed(err.error_args[0], err.error_args[1]))
4264
no_context_error_translators.register('TipChangeRejected',
4265
lambda err: errors.TipChangeRejected(err.error_args[0].decode('utf8')))
4266
no_context_error_translators.register('UnstackableBranchFormat',
4267
lambda err: errors.UnstackableBranchFormat(*err.error_args))
4268
no_context_error_translators.register('UnstackableRepositoryFormat',
4269
lambda err: errors.UnstackableRepositoryFormat(*err.error_args))
4270
no_context_error_translators.register('FileExists',
4271
lambda err: errors.FileExists(err.error_args[0]))
4272
no_context_error_translators.register('DirectoryNotEmpty',
4273
lambda err: errors.DirectoryNotEmpty(err.error_args[0]))
4275
def _translate_short_readv_error(err):
4276
args = err.error_args
4277
return errors.ShortReadvError(args[0], int(args[1]), int(args[2]),
4280
no_context_error_translators.register('ShortReadvError',
4281
_translate_short_readv_error)
4283
def _translate_unicode_error(err):
3351
4284
encoding = str(err.error_args[0]) # encoding must always be a string
3352
4285
val = err.error_args[1]
3353
4286
start = int(err.error_args[2])
3361
4294
raise UnicodeDecodeError(encoding, val, start, end, reason)
3362
4295
elif err.error_verb == 'UnicodeEncodeError':
3363
4296
raise UnicodeEncodeError(encoding, val, start, end, reason)
3364
elif err.error_verb == 'ReadOnlyError':
3365
raise errors.TransportNotPossible('readonly transport')
3366
elif err.error_verb == 'MemoryError':
3367
raise errors.BzrError("remote server out of memory\n"
3368
"Retry non-remotely, or contact the server admin for details.")
3369
raise errors.UnknownErrorFromSmartServer(err)
4298
no_context_error_translators.register('UnicodeEncodeError',
4299
_translate_unicode_error)
4300
no_context_error_translators.register('UnicodeDecodeError',
4301
_translate_unicode_error)
4302
no_context_error_translators.register('ReadOnlyError',
4303
lambda err: errors.TransportNotPossible('readonly transport'))
4304
no_context_error_translators.register('MemoryError',
4305
lambda err: errors.BzrError("remote server out of memory\n"
4306
"Retry non-remotely, or contact the server admin for details."))
4307
no_context_error_translators.register('RevisionNotPresent',
4308
lambda err: errors.RevisionNotPresent(err.error_args[0], err.error_args[1]))
4310
no_context_error_translators.register('BzrCheckError',
4311
lambda err: errors.BzrCheckError(msg=err.error_args[0]))
added
removed
bzrlib/remote.py
