328
349
_mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
352
class RemoteControlStore(_mod_config.IniFileStore):
353
"""Control store which attempts to use HPSS calls to retrieve control store.
355
Note that this is specific to bzr-based formats.
358
def __init__(self, bzrdir):
359
super(RemoteControlStore, self).__init__()
361
self._real_store = None
363
def lock_write(self, token=None):
365
return self._real_store.lock_write(token)
369
return self._real_store.unlock()
373
# We need to be able to override the undecorated implementation
374
self.save_without_locking()
376
def save_without_locking(self):
377
super(RemoteControlStore, self).save()
379
def _ensure_real(self):
380
self.bzrdir._ensure_real()
381
if self._real_store is None:
382
self._real_store = _mod_config.ControlStore(self.bzrdir)
384
def external_url(self):
385
return self.bzrdir.user_url
387
def _load_content(self):
388
medium = self.bzrdir._client._medium
389
path = self.bzrdir._path_for_remote_call(self.bzrdir._client)
391
response, handler = self.bzrdir._call_expecting_body(
392
'BzrDir.get_config_file', path)
393
except errors.UnknownSmartMethod:
395
return self._real_store._load_content()
396
if len(response) and response[0] != 'ok':
397
raise errors.UnexpectedSmartServerResponse(response)
398
return handler.read_body_bytes()
400
def _save_content(self, content):
401
# FIXME JRV 2011-11-22: Ideally this should use a
402
# HPSS call too, but at the moment it is not possible
403
# to write lock control directories.
405
return self._real_store._save_content(content)
331
408
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
332
409
"""Control directory on a remote server, accessed via bzr:// or similar."""
417
494
self._next_open_branch_result = None
418
495
return _mod_bzrdir.BzrDir.break_lock(self)
497
def _vfs_checkout_metadir(self):
499
return self._real_bzrdir.checkout_metadir()
501
def checkout_metadir(self):
502
"""Retrieve the controldir format to use for checkouts of this one.
504
medium = self._client._medium
505
if medium._is_remote_before((2, 5)):
506
return self._vfs_checkout_metadir()
507
path = self._path_for_remote_call(self._client)
509
response = self._client.call('BzrDir.checkout_metadir',
511
except errors.UnknownSmartMethod:
512
medium._remember_remote_is_before((2, 5))
513
return self._vfs_checkout_metadir()
514
if len(response) != 3:
515
raise errors.UnexpectedSmartServerResponse(response)
516
control_name, repo_name, branch_name = response
518
format = controldir.network_format_registry.get(control_name)
520
raise errors.UnknownFormatError(kind='control',
524
repo_format = _mod_repository.network_format_registry.get(
527
raise errors.UnknownFormatError(kind='repository',
529
format.repository_format = repo_format
532
format.set_branch_format(
533
branch.network_format_registry.get(branch_name))
535
raise errors.UnknownFormatError(kind='branch',
420
539
def _vfs_cloning_metadir(self, require_stacking=False):
421
540
self._ensure_real()
422
541
return self._real_bzrdir.cloning_metadir(
1005
1201
for older plugins that don't use e.g. the CommitBuilder
1009
return self._real_repository.commit_write_group()
1204
if self._real_repository:
1206
return self._real_repository.commit_write_group()
1207
if not self.is_in_write_group():
1208
raise errors.BzrError("not in write group")
1209
path = self.bzrdir._path_for_remote_call(self._client)
1210
response = self._call('Repository.commit_write_group', path,
1211
self._lock_token, self._write_group_tokens)
1212
if response != ('ok', ):
1213
raise errors.UnexpectedSmartServerResponse(response)
1214
self._write_group_tokens = None
1215
# Refresh data after writing to the repository.
1011
1218
def resume_write_group(self, tokens):
1013
return self._real_repository.resume_write_group(tokens)
1219
if self._real_repository:
1220
return self._real_repository.resume_write_group(tokens)
1221
path = self.bzrdir._path_for_remote_call(self._client)
1223
response = self._call('Repository.check_write_group', path,
1224
self._lock_token, tokens)
1225
except errors.UnknownSmartMethod:
1227
return self._real_repository.resume_write_group(tokens)
1228
if response != ('ok', ):
1229
raise errors.UnexpectedSmartServerResponse(response)
1230
self._write_group_tokens = tokens
1015
1232
def suspend_write_group(self):
1017
return self._real_repository.suspend_write_group()
1233
if self._real_repository:
1234
return self._real_repository.suspend_write_group()
1235
ret = self._write_group_tokens or []
1236
self._write_group_tokens = None
1019
1239
def get_missing_parent_inventories(self, check_for_missing_texts=True):
1020
1240
self._ensure_real()
1465
1720
raise errors.UnexpectedSmartServerResponse(response)
1467
1723
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,
1724
"""Create a descendent repository for new development.
1726
Unlike clone, this does not copy the settings of the repository.
1728
dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
1472
1729
dest_repo.fetch(self, revision_id=revision_id)
1473
1730
return dest_repo
1732
def _create_sprouting_repo(self, a_bzrdir, shared):
1733
if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
1734
# use target default format.
1735
dest_repo = a_bzrdir.create_repository()
1737
# Most control formats need the repository to be specifically
1738
# created, but on some old all-in-one formats it's not needed
1740
dest_repo = self._format.initialize(a_bzrdir, shared=shared)
1741
except errors.UninitializableFormat:
1742
dest_repo = a_bzrdir.open_repository()
1475
1745
### These methods are just thin shims to the VFS object for now.
1477
1748
def revision_tree(self, revision_id):
1479
return self._real_repository.revision_tree(revision_id)
1749
revision_id = _mod_revision.ensure_null(revision_id)
1750
if revision_id == _mod_revision.NULL_REVISION:
1751
return InventoryRevisionTree(self,
1752
Inventory(root_id=None), _mod_revision.NULL_REVISION)
1754
return list(self.revision_trees([revision_id]))[0]
1481
1756
def get_serializer_format(self):
1483
return self._real_repository.get_serializer_format()
1757
path = self.bzrdir._path_for_remote_call(self._client)
1759
response = self._call('VersionedFileRepository.get_serializer_format',
1761
except errors.UnknownSmartMethod:
1763
return self._real_repository.get_serializer_format()
1764
if response[0] != 'ok':
1765
raise errors.UnexpectedSmartServerResponse(response)
1485
1768
def get_commit_builder(self, branch, parents, config, timestamp=None,
1486
1769
timezone=None, committer=None, revprops=None,
1487
1770
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)
1771
"""Obtain a CommitBuilder for this repository.
1773
:param branch: Branch to commit to.
1774
:param parents: Revision ids of the parents of the new revision.
1775
:param config: Configuration to use.
1776
:param timestamp: Optional timestamp recorded for commit.
1777
:param timezone: Optional timezone for timestamp.
1778
:param committer: Optional committer to set for commit.
1779
:param revprops: Optional dictionary of revision properties.
1780
:param revision_id: Optional revision id.
1781
:param lossy: Whether to discard data that can not be natively
1782
represented, when pushing to a foreign VCS
1784
if self._fallback_repositories and not self._format.supports_chks:
1785
raise errors.BzrError("Cannot commit directly to a stacked branch"
1786
" in pre-2a formats. See "
1787
"https://bugs.launchpad.net/bzr/+bug/375013 for details.")
1788
if self._format.rich_root_data:
1789
commit_builder_kls = vf_repository.VersionedFileRootCommitBuilder
1791
commit_builder_kls = vf_repository.VersionedFileCommitBuilder
1792
result = commit_builder_kls(self, parents, config,
1793
timestamp, timezone, committer, revprops, revision_id,
1795
self.start_write_group()
1498
1798
def add_fallback_repository(self, repository):
1499
1799
"""Add a repository to use for looking up data not held locally.
1543
1844
delta, new_revision_id, parents, basis_inv=basis_inv,
1544
1845
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)
1847
def add_revision(self, revision_id, rev, inv=None):
1848
_mod_revision.check_not_reserved_id(revision_id)
1849
key = (revision_id,)
1850
# check inventory present
1851
if not self.inventories.get_parent_map([key]):
1853
raise errors.WeaveRevisionNotPresent(revision_id,
1856
# yes, this is not suitable for adding with ghosts.
1857
rev.inventory_sha1 = self.add_inventory(revision_id, inv,
1860
rev.inventory_sha1 = self.inventories.get_sha1s([key])[key]
1861
self._add_revision(rev)
1863
def _add_revision(self, rev):
1864
if self._real_repository is not None:
1865
return self._real_repository._add_revision(rev)
1866
text = self._serializer.write_revision_to_string(rev)
1867
key = (rev.revision_id,)
1868
parents = tuple((parent,) for parent in rev.parent_ids)
1869
self._write_group_tokens, missing_keys = self._get_sink().insert_stream(
1870
[('revisions', [FulltextContentFactory(key, parents, None, text)])],
1871
self._format, self._write_group_tokens)
1551
1873
@needs_read_lock
1552
1874
def get_inventory(self, revision_id):
1875
return list(self.iter_inventories([revision_id]))[0]
1877
def _iter_inventories_rpc(self, revision_ids, ordering):
1878
if ordering is None:
1879
ordering = 'unordered'
1880
path = self.bzrdir._path_for_remote_call(self._client)
1881
body = "\n".join(revision_ids)
1882
response_tuple, response_handler = (
1883
self._call_with_body_bytes_expecting_body(
1884
"VersionedFileRepository.get_inventories",
1885
(path, ordering), body))
1886
if response_tuple[0] != "ok":
1887
raise errors.UnexpectedSmartServerResponse(response_tuple)
1888
deserializer = inventory_delta.InventoryDeltaDeserializer()
1889
byte_stream = response_handler.read_streamed_body()
1890
decoded = smart_repo._byte_stream_to_stream(byte_stream)
1892
# no results whatsoever
1894
src_format, stream = decoded
1895
if src_format.network_name() != self._format.network_name():
1896
raise AssertionError(
1897
"Mismatched RemoteRepository and stream src %r, %r" % (
1898
src_format.network_name(), self._format.network_name()))
1899
# ignore the src format, it's not really relevant
1900
prev_inv = Inventory(root_id=None,
1901
revision_id=_mod_revision.NULL_REVISION)
1902
# there should be just one substream, with inventory deltas
1903
substream_kind, substream = stream.next()
1904
if substream_kind != "inventory-deltas":
1905
raise AssertionError(
1906
"Unexpected stream %r received" % substream_kind)
1907
for record in substream:
1908
(parent_id, new_id, versioned_root, tree_references, invdelta) = (
1909
deserializer.parse_text_bytes(record.get_bytes_as("fulltext")))
1910
if parent_id != prev_inv.revision_id:
1911
raise AssertionError("invalid base %r != %r" % (parent_id,
1912
prev_inv.revision_id))
1913
inv = prev_inv.create_by_apply_delta(invdelta, new_id)
1914
yield inv, inv.revision_id
1917
def _iter_inventories_vfs(self, revision_ids, ordering=None):
1553
1918
self._ensure_real()
1554
return self._real_repository.get_inventory(revision_id)
1919
return self._real_repository._iter_inventories(revision_ids, ordering)
1556
1921
def iter_inventories(self, revision_ids, ordering=None):
1558
return self._real_repository.iter_inventories(revision_ids, ordering)
1922
"""Get many inventories by revision_ids.
1924
This will buffer some or all of the texts used in constructing the
1925
inventories in memory, but will only parse a single inventory at a
1928
:param revision_ids: The expected revision ids of the inventories.
1929
:param ordering: optional ordering, e.g. 'topological'. If not
1930
specified, the order of revision_ids will be preserved (by
1931
buffering if necessary).
1932
:return: An iterator of inventories.
1934
if ((None in revision_ids)
1935
or (_mod_revision.NULL_REVISION in revision_ids)):
1936
raise ValueError('cannot get null revision inventory')
1937
for inv, revid in self._iter_inventories(revision_ids, ordering):
1939
raise errors.NoSuchRevision(self, revid)
1942
def _iter_inventories(self, revision_ids, ordering=None):
1943
if len(revision_ids) == 0:
1945
missing = set(revision_ids)
1946
if ordering is None:
1947
order_as_requested = True
1949
order = list(revision_ids)
1951
next_revid = order.pop()
1953
order_as_requested = False
1954
if ordering != 'unordered' and self._fallback_repositories:
1955
raise ValueError('unsupported ordering %r' % ordering)
1956
iter_inv_fns = [self._iter_inventories_rpc] + [
1957
fallback._iter_inventories for fallback in
1958
self._fallback_repositories]
1960
for iter_inv in iter_inv_fns:
1961
request = [revid for revid in revision_ids if revid in missing]
1962
for inv, revid in iter_inv(request, ordering):
1965
missing.remove(inv.revision_id)
1966
if ordering != 'unordered':
1970
if order_as_requested:
1971
# Yield as many results as we can while preserving order.
1972
while next_revid in invs:
1973
inv = invs.pop(next_revid)
1974
yield inv, inv.revision_id
1976
next_revid = order.pop()
1978
# We still want to fully consume the stream, just
1979
# in case it is not actually finished at this point
1982
except errors.UnknownSmartMethod:
1983
for inv, revid in self._iter_inventories_vfs(revision_ids, ordering):
1987
if order_as_requested:
1988
if next_revid is not None:
1989
yield None, next_revid
1992
yield invs.get(revid), revid
1995
yield None, missing.pop()
1560
1997
@needs_read_lock
1561
1998
def get_revision(self, revision_id):
1563
return self._real_repository.get_revision(revision_id)
1999
return self.get_revisions([revision_id])[0]
1565
2001
def get_transaction(self):
1566
2002
self._ensure_real()
1674
2128
return self._real_repository._get_versioned_file_checker(
1675
2129
revisions, revision_versions_cache)
2131
def _iter_files_bytes_rpc(self, desired_files, absent):
2132
path = self.bzrdir._path_for_remote_call(self._client)
2135
for (file_id, revid, identifier) in desired_files:
2136
lines.append("%s\0%s" % (
2137
osutils.safe_file_id(file_id),
2138
osutils.safe_revision_id(revid)))
2139
identifiers.append(identifier)
2140
(response_tuple, response_handler) = (
2141
self._call_with_body_bytes_expecting_body(
2142
"Repository.iter_files_bytes", (path, ), "\n".join(lines)))
2143
if response_tuple != ('ok', ):
2144
response_handler.cancel_read_body()
2145
raise errors.UnexpectedSmartServerResponse(response_tuple)
2146
byte_stream = response_handler.read_streamed_body()
2147
def decompress_stream(start, byte_stream, unused):
2148
decompressor = zlib.decompressobj()
2149
yield decompressor.decompress(start)
2150
while decompressor.unused_data == "":
2152
data = byte_stream.next()
2153
except StopIteration:
2155
yield decompressor.decompress(data)
2156
yield decompressor.flush()
2157
unused.append(decompressor.unused_data)
2160
while not "\n" in unused:
2161
unused += byte_stream.next()
2162
header, rest = unused.split("\n", 1)
2163
args = header.split("\0")
2164
if args[0] == "absent":
2165
absent[identifiers[int(args[3])]] = (args[1], args[2])
2168
elif args[0] == "ok":
2171
raise errors.UnexpectedSmartServerResponse(args)
2173
yield (identifiers[idx],
2174
decompress_stream(rest, byte_stream, unused_chunks))
2175
unused = "".join(unused_chunks)
1677
2177
def iter_files_bytes(self, desired_files):
1678
2178
"""See Repository.iter_file_bytes.
1681
return self._real_repository.iter_files_bytes(desired_files)
2182
for (identifier, bytes_iterator) in self._iter_files_bytes_rpc(
2183
desired_files, absent):
2184
yield identifier, bytes_iterator
2185
for fallback in self._fallback_repositories:
2188
desired_files = [(key[0], key[1], identifier) for
2189
(identifier, key) in absent.iteritems()]
2190
for (identifier, bytes_iterator) in fallback.iter_files_bytes(desired_files):
2191
del absent[identifier]
2192
yield identifier, bytes_iterator
2194
# There may be more missing items, but raise an exception
2196
missing_identifier = absent.keys()[0]
2197
missing_key = absent[missing_identifier]
2198
raise errors.RevisionNotPresent(revision_id=missing_key[1],
2199
file_id=missing_key[0])
2200
except errors.UnknownSmartMethod:
2202
for (identifier, bytes_iterator) in (
2203
self._real_repository.iter_files_bytes(desired_files)):
2204
yield identifier, bytes_iterator
2206
def get_cached_parent_map(self, revision_ids):
2207
"""See bzrlib.CachingParentsProvider.get_cached_parent_map"""
2208
return self._unstacked_provider.get_cached_parent_map(revision_ids)
1683
2210
def get_parent_map(self, revision_ids):
1684
2211
"""See bzrlib.Graph.get_parent_map()."""
1743
2270
if parents_map is None:
1744
2271
# Repository is not locked, so there's no cache.
1745
2272
parents_map = {}
1746
# start_set is all the keys in the cache
1747
start_set = set(parents_map)
1748
# result set is all the references to keys in the cache
1749
result_parents = set()
1750
for parents in parents_map.itervalues():
1751
result_parents.update(parents)
1752
stop_keys = result_parents.difference(start_set)
1753
# We don't need to send ghosts back to the server as a position to
1755
stop_keys.difference_update(self._unstacked_provider.missing_keys)
1756
key_count = len(parents_map)
1757
if (NULL_REVISION in result_parents
1758
and NULL_REVISION in self._unstacked_provider.missing_keys):
1759
# If we pruned NULL_REVISION from the stop_keys because it's also
1760
# in our cache of "missing" keys we need to increment our key count
1761
# by 1, because the reconsitituted SearchResult on the server will
1762
# still consider NULL_REVISION to be an included key.
1764
included_keys = start_set.intersection(result_parents)
1765
start_set.difference_update(included_keys)
2273
if _DEFAULT_SEARCH_DEPTH <= 0:
2274
(start_set, stop_keys,
2275
key_count) = vf_search.search_result_from_parent_map(
2276
parents_map, self._unstacked_provider.missing_keys)
2278
(start_set, stop_keys,
2279
key_count) = vf_search.limited_search_result_from_parent_map(
2280
parents_map, self._unstacked_provider.missing_keys,
2281
keys, depth=_DEFAULT_SEARCH_DEPTH)
1766
2282
recipe = ('manual', start_set, stop_keys, key_count)
1767
2283
body = self._serialise_search_recipe(recipe)
1768
2284
path = self.bzrdir._path_for_remote_call(self._client)
1818
2334
@needs_read_lock
1819
2335
def get_signature_text(self, revision_id):
1821
return self._real_repository.get_signature_text(revision_id)
2336
path = self.bzrdir._path_for_remote_call(self._client)
2338
response_tuple, response_handler = self._call_expecting_body(
2339
'Repository.get_revision_signature_text', path, revision_id)
2340
except errors.UnknownSmartMethod:
2342
return self._real_repository.get_signature_text(revision_id)
2343
except errors.NoSuchRevision, err:
2344
for fallback in self._fallback_repositories:
2346
return fallback.get_signature_text(revision_id)
2347
except errors.NoSuchRevision:
2351
if response_tuple[0] != 'ok':
2352
raise errors.UnexpectedSmartServerResponse(response_tuple)
2353
return response_handler.read_body_bytes()
1823
2355
@needs_read_lock
1824
2356
def _get_inventory_xml(self, revision_id):
2357
# This call is used by older working tree formats,
2358
# which stored a serialized basis inventory.
1825
2359
self._ensure_real()
1826
2360
return self._real_repository._get_inventory_xml(revision_id)
1828
2363
def reconcile(self, other=None, thorough=False):
1830
return self._real_repository.reconcile(other=other, thorough=thorough)
2364
from bzrlib.reconcile import RepoReconciler
2365
path = self.bzrdir._path_for_remote_call(self._client)
2367
response, handler = self._call_expecting_body(
2368
'Repository.reconcile', path, self._lock_token)
2369
except (errors.UnknownSmartMethod, errors.TokenLockingNotSupported):
2371
return self._real_repository.reconcile(other=other, thorough=thorough)
2372
if response != ('ok', ):
2373
raise errors.UnexpectedSmartServerResponse(response)
2374
body = handler.read_body_bytes()
2375
result = RepoReconciler(self)
2376
for line in body.split('\n'):
2379
key, val_text = line.split(':')
2380
if key == "garbage_inventories":
2381
result.garbage_inventories = int(val_text)
2382
elif key == "inconsistent_parents":
2383
result.inconsistent_parents = int(val_text)
2385
mutter("unknown reconcile key %r" % key)
1832
2388
def all_revision_ids(self):
1834
return self._real_repository.all_revision_ids()
2389
path = self.bzrdir._path_for_remote_call(self._client)
2391
response_tuple, response_handler = self._call_expecting_body(
2392
"Repository.all_revision_ids", path)
2393
except errors.UnknownSmartMethod:
2395
return self._real_repository.all_revision_ids()
2396
if response_tuple != ("ok", ):
2397
raise errors.UnexpectedSmartServerResponse(response_tuple)
2398
revids = set(response_handler.read_body_bytes().splitlines())
2399
for fallback in self._fallback_repositories:
2400
revids.update(set(fallback.all_revision_ids()))
2403
def _filtered_revision_trees(self, revision_ids, file_ids):
2404
"""Return Tree for a revision on this branch with only some files.
2406
:param revision_ids: a sequence of revision-ids;
2407
a revision-id may not be None or 'null:'
2408
:param file_ids: if not None, the result is filtered
2409
so that only those file-ids, their parents and their
2410
children are included.
2412
inventories = self.iter_inventories(revision_ids)
2413
for inv in inventories:
2414
# Should we introduce a FilteredRevisionTree class rather
2415
# than pre-filter the inventory here?
2416
filtered_inv = inv.filter(file_ids)
2417
yield InventoryRevisionTree(self, filtered_inv, filtered_inv.revision_id)
1836
2419
@needs_read_lock
1837
2420
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1839
return self._real_repository.get_deltas_for_revisions(revisions,
1840
specific_fileids=specific_fileids)
2421
medium = self._client._medium
2422
if medium._is_remote_before((1, 2)):
2424
for delta in self._real_repository.get_deltas_for_revisions(
2425
revisions, specific_fileids):
2428
# Get the revision-ids of interest
2429
required_trees = set()
2430
for revision in revisions:
2431
required_trees.add(revision.revision_id)
2432
required_trees.update(revision.parent_ids[:1])
2434
# Get the matching filtered trees. Note that it's more
2435
# efficient to pass filtered trees to changes_from() rather
2436
# than doing the filtering afterwards. changes_from() could
2437
# arguably do the filtering itself but it's path-based, not
2438
# file-id based, so filtering before or afterwards is
2440
if specific_fileids is None:
2441
trees = dict((t.get_revision_id(), t) for
2442
t in self.revision_trees(required_trees))
2444
trees = dict((t.get_revision_id(), t) for
2445
t in self._filtered_revision_trees(required_trees,
2448
# Calculate the deltas
2449
for revision in revisions:
2450
if not revision.parent_ids:
2451
old_tree = self.revision_tree(_mod_revision.NULL_REVISION)
2453
old_tree = trees[revision.parent_ids[0]]
2454
yield trees[revision.revision_id].changes_from(old_tree)
1842
2456
@needs_read_lock
1843
2457
def get_revision_delta(self, revision_id, specific_fileids=None):
1845
return self._real_repository.get_revision_delta(revision_id,
1846
specific_fileids=specific_fileids)
2458
r = self.get_revision(revision_id)
2459
return list(self.get_deltas_for_revisions([r],
2460
specific_fileids=specific_fileids))[0]
1848
2462
@needs_read_lock
1849
2463
def revision_trees(self, revision_ids):
1851
return self._real_repository.revision_trees(revision_ids)
2464
inventories = self.iter_inventories(revision_ids)
2465
for inv in inventories:
2466
yield InventoryRevisionTree(self, inv, inv.revision_id)
1853
2468
@needs_read_lock
1854
2469
def get_revision_reconcile(self, revision_id):
1966
2594
self._ensure_real()
1967
2595
return self._real_repository.texts
2597
def _iter_revisions_rpc(self, revision_ids):
2598
body = "\n".join(revision_ids)
2599
path = self.bzrdir._path_for_remote_call(self._client)
2600
response_tuple, response_handler = (
2601
self._call_with_body_bytes_expecting_body(
2602
"Repository.iter_revisions", (path, ), body))
2603
if response_tuple[0] != "ok":
2604
raise errors.UnexpectedSmartServerResponse(response_tuple)
2605
serializer_format = response_tuple[1]
2606
serializer = serializer_format_registry.get(serializer_format)
2607
byte_stream = response_handler.read_streamed_body()
2608
decompressor = zlib.decompressobj()
2610
for bytes in byte_stream:
2611
chunks.append(decompressor.decompress(bytes))
2612
if decompressor.unused_data != "":
2613
chunks.append(decompressor.flush())
2614
yield serializer.read_revision_from_string("".join(chunks))
2615
unused = decompressor.unused_data
2616
decompressor = zlib.decompressobj()
2617
chunks = [decompressor.decompress(unused)]
2618
chunks.append(decompressor.flush())
2619
text = "".join(chunks)
2621
yield serializer.read_revision_from_string("".join(chunks))
1969
2623
@needs_read_lock
1970
2624
def get_revisions(self, revision_ids):
1972
return self._real_repository.get_revisions(revision_ids)
2625
if revision_ids is None:
2626
revision_ids = self.all_revision_ids()
2628
for rev_id in revision_ids:
2629
if not rev_id or not isinstance(rev_id, basestring):
2630
raise errors.InvalidRevisionId(
2631
revision_id=rev_id, branch=self)
2633
missing = set(revision_ids)
2635
for rev in self._iter_revisions_rpc(revision_ids):
2636
missing.remove(rev.revision_id)
2637
revs[rev.revision_id] = rev
2638
except errors.UnknownSmartMethod:
2640
return self._real_repository.get_revisions(revision_ids)
2641
for fallback in self._fallback_repositories:
2644
for revid in list(missing):
2645
# XXX JRV 2011-11-20: It would be nice if there was a
2646
# public method on Repository that could be used to query
2647
# for revision objects *without* failing completely if one
2648
# was missing. There is VersionedFileRepository._iter_revisions,
2649
# but unfortunately that's private and not provided by
2650
# all repository implementations.
2652
revs[revid] = fallback.get_revision(revid)
2653
except errors.NoSuchRevision:
2656
missing.remove(revid)
2658
raise errors.NoSuchRevision(self, list(missing)[0])
2659
return [revs[revid] for revid in revision_ids]
1974
2661
def supports_rich_root(self):
1975
2662
return self._format.rich_root_data
2664
@symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1977
2665
def iter_reverse_revision_history(self, revision_id):
1978
2666
self._ensure_real()
1979
2667
return self._real_repository.iter_reverse_revision_history(revision_id)
1982
2670
def _serializer(self):
1983
2671
return self._format._serializer
1985
2674
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1987
return self._real_repository.store_revision_signature(
1988
gpg_strategy, plaintext, revision_id)
2675
signature = gpg_strategy.sign(plaintext)
2676
self.add_signature_text(revision_id, signature)
1990
2678
def add_signature_text(self, revision_id, signature):
1992
return self._real_repository.add_signature_text(revision_id, signature)
2679
if self._real_repository:
2680
# If there is a real repository the write group will
2681
# be in the real repository as well, so use that:
2683
return self._real_repository.add_signature_text(
2684
revision_id, signature)
2685
path = self.bzrdir._path_for_remote_call(self._client)
2686
response, handler = self._call_with_body_bytes_expecting_body(
2687
'Repository.add_signature_text', (path, self._lock_token,
2688
revision_id) + tuple(self._write_group_tokens), signature)
2689
handler.cancel_read_body()
2691
if response[0] != 'ok':
2692
raise errors.UnexpectedSmartServerResponse(response)
2693
self._write_group_tokens = response[1:]
1994
2695
def has_signature_for_revision_id(self, revision_id):
1996
return self._real_repository.has_signature_for_revision_id(revision_id)
2696
path = self.bzrdir._path_for_remote_call(self._client)
2698
response = self._call('Repository.has_signature_for_revision_id',
2700
except errors.UnknownSmartMethod:
2702
return self._real_repository.has_signature_for_revision_id(
2704
if response[0] not in ('yes', 'no'):
2705
raise SmartProtocolError('unexpected response code %s' % (response,))
2706
if response[0] == 'yes':
2708
for fallback in self._fallback_repositories:
2709
if fallback.has_signature_for_revision_id(revision_id):
2714
def verify_revision_signature(self, revision_id, gpg_strategy):
2715
if not self.has_signature_for_revision_id(revision_id):
2716
return gpg.SIGNATURE_NOT_SIGNED, None
2717
signature = self.get_signature_text(revision_id)
2719
testament = _mod_testament.Testament.from_revision(self, revision_id)
2720
plaintext = testament.as_short_text()
2722
return gpg_strategy.verify(signature, plaintext)
1998
2724
def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1999
2725
self._ensure_real()
3203
class RemoteBranchStore(_mod_config.IniFileStore):
3204
"""Branch store which attempts to use HPSS calls to retrieve branch store.
3206
Note that this is specific to bzr-based formats.
3209
def __init__(self, branch):
3210
super(RemoteBranchStore, self).__init__()
3211
self.branch = branch
3213
self._real_store = None
3215
def lock_write(self, token=None):
3216
return self.branch.lock_write(token)
3219
return self.branch.unlock()
3223
# We need to be able to override the undecorated implementation
3224
self.save_without_locking()
3226
def save_without_locking(self):
3227
super(RemoteBranchStore, self).save()
3229
def external_url(self):
3230
return self.branch.user_url
3232
def _load_content(self):
3233
path = self.branch._remote_path()
3235
response, handler = self.branch._call_expecting_body(
3236
'Branch.get_config_file', path)
3237
except errors.UnknownSmartMethod:
3239
return self._real_store._load_content()
3240
if len(response) and response[0] != 'ok':
3241
raise errors.UnexpectedSmartServerResponse(response)
3242
return handler.read_body_bytes()
3244
def _save_content(self, content):
3245
path = self.branch._remote_path()
3247
response, handler = self.branch._call_with_body_bytes_expecting_body(
3248
'Branch.put_config_file', (path,
3249
self.branch._lock_token, self.branch._repo_lock_token),
3251
except errors.UnknownSmartMethod:
3253
return self._real_store._save_content(content)
3254
handler.cancel_read_body()
3255
if response != ('ok', ):
3256
raise errors.UnexpectedSmartServerResponse(response)
3258
def _ensure_real(self):
3259
self.branch._ensure_real()
3260
if self._real_store is None:
3261
self._real_store = _mod_config.BranchStore(self.branch)
2465
3264
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2466
3265
"""Branch stored on a server accessed by HPSS RPC.
3274
4135
'Missing key %r in context %r', key_err.args[0], context)
3277
if err.error_verb == 'NoSuchRevision':
3278
raise NoSuchRevision(find('branch'), err.error_args[0])
3279
elif err.error_verb == 'nosuchrevision':
3280
raise NoSuchRevision(find('repository'), err.error_args[0])
3281
elif err.error_verb == 'nobranch':
3282
if len(err.error_args) >= 1:
3283
extra = err.error_args[0]
3286
raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
3288
elif err.error_verb == 'norepository':
3289
raise errors.NoRepositoryPresent(find('bzrdir'))
3290
elif err.error_verb == 'UnlockableTransport':
3291
raise errors.UnlockableTransport(find('bzrdir').root_transport)
3292
elif err.error_verb == 'TokenMismatch':
3293
raise errors.TokenMismatch(find('token'), '(remote token)')
3294
elif err.error_verb == 'Diverged':
3295
raise errors.DivergedBranches(find('branch'), find('other_branch'))
3296
elif err.error_verb == 'NotStacked':
3297
raise errors.NotStacked(branch=find('branch'))
3298
elif err.error_verb == 'PermissionDenied':
3300
if len(err.error_args) >= 2:
3301
extra = err.error_args[1]
3304
raise errors.PermissionDenied(path, extra=extra)
3305
elif err.error_verb == 'ReadError':
3307
raise errors.ReadError(path)
3308
elif err.error_verb == 'NoSuchFile':
3310
raise errors.NoSuchFile(path)
3311
_translate_error_without_context(err)
3314
def _translate_error_without_context(err):
3315
"""Translate any ErrorFromSmartServer values that don't require context"""
3316
if err.error_verb == 'IncompatibleRepositories':
3317
raise errors.IncompatibleRepositories(err.error_args[0],
3318
err.error_args[1], err.error_args[2])
3319
elif err.error_verb == 'LockContention':
3320
raise errors.LockContention('(remote lock)')
3321
elif err.error_verb == 'LockFailed':
3322
raise errors.LockFailed(err.error_args[0], err.error_args[1])
3323
elif err.error_verb == 'TipChangeRejected':
3324
raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
3325
elif err.error_verb == 'UnstackableBranchFormat':
3326
raise errors.UnstackableBranchFormat(*err.error_args)
3327
elif err.error_verb == 'UnstackableRepositoryFormat':
3328
raise errors.UnstackableRepositoryFormat(*err.error_args)
3329
elif err.error_verb == 'FileExists':
3330
raise errors.FileExists(err.error_args[0])
3331
elif err.error_verb == 'DirectoryNotEmpty':
3332
raise errors.DirectoryNotEmpty(err.error_args[0])
3333
elif err.error_verb == 'ShortReadvError':
3334
args = err.error_args
3335
raise errors.ShortReadvError(
3336
args[0], int(args[1]), int(args[2]), int(args[3]))
3337
elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
4139
translator = error_translators.get(err.error_verb)
4143
raise translator(err, find, get_path)
4145
translator = no_context_error_translators.get(err.error_verb)
4147
raise errors.UnknownErrorFromSmartServer(err)
4149
raise translator(err)
4152
error_translators.register('NoSuchRevision',
4153
lambda err, find, get_path: NoSuchRevision(
4154
find('branch'), err.error_args[0]))
4155
error_translators.register('nosuchrevision',
4156
lambda err, find, get_path: NoSuchRevision(
4157
find('repository'), err.error_args[0]))
4159
def _translate_nobranch_error(err, find, get_path):
4160
if len(err.error_args) >= 1:
4161
extra = err.error_args[0]
4164
return errors.NotBranchError(path=find('bzrdir').root_transport.base,
4167
error_translators.register('nobranch', _translate_nobranch_error)
4168
error_translators.register('norepository',
4169
lambda err, find, get_path: errors.NoRepositoryPresent(
4171
error_translators.register('UnlockableTransport',
4172
lambda err, find, get_path: errors.UnlockableTransport(
4173
find('bzrdir').root_transport))
4174
error_translators.register('TokenMismatch',
4175
lambda err, find, get_path: errors.TokenMismatch(
4176
find('token'), '(remote token)'))
4177
error_translators.register('Diverged',
4178
lambda err, find, get_path: errors.DivergedBranches(
4179
find('branch'), find('other_branch')))
4180
error_translators.register('NotStacked',
4181
lambda err, find, get_path: errors.NotStacked(branch=find('branch')))
4183
def _translate_PermissionDenied(err, find, get_path):
4185
if len(err.error_args) >= 2:
4186
extra = err.error_args[1]
4189
return errors.PermissionDenied(path, extra=extra)
4191
error_translators.register('PermissionDenied', _translate_PermissionDenied)
4192
error_translators.register('ReadError',
4193
lambda err, find, get_path: errors.ReadError(get_path()))
4194
error_translators.register('NoSuchFile',
4195
lambda err, find, get_path: errors.NoSuchFile(get_path()))
4196
error_translators.register('TokenLockingNotSupported',
4197
lambda err, find, get_path: errors.TokenLockingNotSupported(
4198
find('repository')))
4199
error_translators.register('UnsuspendableWriteGroup',
4200
lambda err, find, get_path: errors.UnsuspendableWriteGroup(
4201
repository=find('repository')))
4202
error_translators.register('UnresumableWriteGroup',
4203
lambda err, find, get_path: errors.UnresumableWriteGroup(
4204
repository=find('repository'), write_groups=err.error_args[0],
4205
reason=err.error_args[1]))
4206
no_context_error_translators.register('IncompatibleRepositories',
4207
lambda err: errors.IncompatibleRepositories(
4208
err.error_args[0], err.error_args[1], err.error_args[2]))
4209
no_context_error_translators.register('LockContention',
4210
lambda err: errors.LockContention('(remote lock)'))
4211
no_context_error_translators.register('LockFailed',
4212
lambda err: errors.LockFailed(err.error_args[0], err.error_args[1]))
4213
no_context_error_translators.register('TipChangeRejected',
4214
lambda err: errors.TipChangeRejected(err.error_args[0].decode('utf8')))
4215
no_context_error_translators.register('UnstackableBranchFormat',
4216
lambda err: errors.UnstackableBranchFormat(*err.error_args))
4217
no_context_error_translators.register('UnstackableRepositoryFormat',
4218
lambda err: errors.UnstackableRepositoryFormat(*err.error_args))
4219
no_context_error_translators.register('FileExists',
4220
lambda err: errors.FileExists(err.error_args[0]))
4221
no_context_error_translators.register('DirectoryNotEmpty',
4222
lambda err: errors.DirectoryNotEmpty(err.error_args[0]))
4224
def _translate_short_readv_error(err):
4225
args = err.error_args
4226
return errors.ShortReadvError(args[0], int(args[1]), int(args[2]),
4229
no_context_error_translators.register('ShortReadvError',
4230
_translate_short_readv_error)
4232
def _translate_unicode_error(err):
3338
4233
encoding = str(err.error_args[0]) # encoding must always be a string
3339
4234
val = err.error_args[1]
3340
4235
start = int(err.error_args[2])
3348
4243
raise UnicodeDecodeError(encoding, val, start, end, reason)
3349
4244
elif err.error_verb == 'UnicodeEncodeError':
3350
4245
raise UnicodeEncodeError(encoding, val, start, end, reason)
3351
elif err.error_verb == 'ReadOnlyError':
3352
raise errors.TransportNotPossible('readonly transport')
3353
elif err.error_verb == 'MemoryError':
3354
raise errors.BzrError("remote server out of memory\n"
3355
"Retry non-remotely, or contact the server admin for details.")
3356
raise errors.UnknownErrorFromSmartServer(err)
4247
no_context_error_translators.register('UnicodeEncodeError',
4248
_translate_unicode_error)
4249
no_context_error_translators.register('UnicodeDecodeError',
4250
_translate_unicode_error)
4251
no_context_error_translators.register('ReadOnlyError',
4252
lambda err: errors.TransportNotPossible('readonly transport'))
4253
no_context_error_translators.register('MemoryError',
4254
lambda err: errors.BzrError("remote server out of memory\n"
4255
"Retry non-remotely, or contact the server admin for details."))
4256
no_context_error_translators.register('RevisionNotPresent',
4257
lambda err: errors.RevisionNotPresent(err.error_args[0], err.error_args[1]))
4259
no_context_error_translators.register('BzrCheckError',
4260
lambda err: errors.BzrCheckError(msg=err.error_args[0]))
added
removed
bzrlib/remote.py
