17
17
# TODO: At some point, handle upgrades by just passing the whole request
18
18
# across to run on the server.
21
20
from cStringIO import StringIO
23
22
from bzrlib import (
33
from bzrlib.branch import BranchReferenceFormat
28
from bzrlib.branch import Branch, BranchReferenceFormat
34
29
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
35
30
from bzrlib.config import BranchConfig, TreeConfig
36
31
from bzrlib.decorators import needs_read_lock, needs_write_lock
37
from bzrlib.errors import (
32
from bzrlib.errors import NoSuchRevision
41
33
from bzrlib.lockable_files import LockableFiles
42
from bzrlib.pack import ContainerPushParser
34
from bzrlib.pack import ContainerReader
35
from bzrlib.revision import NULL_REVISION
43
36
from bzrlib.smart import client, vfs
44
37
from bzrlib.symbol_versioning import (
48
from bzrlib.revision import ensure_null, NULL_REVISION
49
from bzrlib.trace import mutter, note, warning
41
from bzrlib.trace import note
52
43
# Note: RemoteBzrDirFormat is in bzrdir.py
162
136
def open_repository(self):
163
137
path = self._path_for_remote_call(self._client)
164
verb = 'BzrDir.find_repositoryV2'
167
response = self._client.call(verb, path)
168
except errors.UnknownSmartMethod:
169
verb = 'BzrDir.find_repository'
170
response = self._client.call(verb, path)
171
except errors.ErrorFromSmartServer, err:
172
self._translate_error(err)
173
if response[0] != 'ok':
174
raise errors.UnexpectedSmartServerResponse(response)
175
if verb == 'BzrDir.find_repository':
176
# servers that don't support the V2 method don't support external
178
response = response + ('no', )
179
if not (len(response) == 5):
180
raise SmartProtocolError('incorrect response length %s' % (response,))
138
response = self._client.call('BzrDir.find_repository', path)
139
assert response[0] in ('ok', 'norepository'), \
140
'unexpected response code %s' % (response,)
141
if response[0] == 'norepository':
142
raise errors.NoRepositoryPresent(self)
143
assert len(response) == 4, 'incorrect response length %s' % (response,)
181
144
if response[1] == '':
182
145
format = RemoteRepositoryFormat()
183
146
format.rich_root_data = (response[2] == 'yes')
184
147
format.supports_tree_reference = (response[3] == 'yes')
185
# No wire format to check this yet.
186
format.supports_external_lookups = (response[4] == 'yes')
187
# Used to support creating a real format instance when needed.
188
format._creating_bzrdir = self
189
148
return RemoteRepository(self, format)
191
150
raise errors.NoRepositoryPresent(self)
238
192
Instances of this repository are represented by RemoteRepository
241
The RemoteRepositoryFormat is parameterized during construction
195
The RemoteRepositoryFormat is parameterised during construction
242
196
to reflect the capabilities of the real, remote format. Specifically
243
197
the attributes rich_root_data and supports_tree_reference are set
244
198
on a per instance basis, and are not set (and should not be) at
248
_matchingbzrdir = RemoteBzrDirFormat()
202
_matchingbzrdir = RemoteBzrDirFormat
250
204
def initialize(self, a_bzrdir, shared=False):
251
if not isinstance(a_bzrdir, RemoteBzrDir):
252
prior_repo = self._creating_bzrdir.open_repository()
253
prior_repo._ensure_real()
254
return prior_repo._real_repository._format.initialize(
255
a_bzrdir, shared=shared)
205
assert isinstance(a_bzrdir, RemoteBzrDir), \
206
'%r is not a RemoteBzrDir' % (a_bzrdir,)
256
207
return a_bzrdir.create_repository(shared=shared)
258
209
def open(self, a_bzrdir):
259
if not isinstance(a_bzrdir, RemoteBzrDir):
260
raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
210
assert isinstance(a_bzrdir, RemoteBzrDir)
261
211
return a_bzrdir.open_repository()
263
213
def get_format_description(self):
361
300
#self._real_repository = self.bzrdir._real_bzrdir.open_repository()
362
301
self._set_real_repository(self.bzrdir._real_bzrdir.open_repository())
364
def _translate_error(self, err, **context):
365
self.bzrdir._translate_error(err, repository=self, **context)
367
def find_text_key_references(self):
368
"""Find the text key references within the repository.
370
:return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
371
revision_ids. Each altered file-ids has the exact revision_ids that
372
altered it listed explicitly.
373
:return: A dictionary mapping text keys ((fileid, revision_id) tuples)
374
to whether they were referred to by the inventory of the
375
revision_id that they contain. The inventory texts from all present
376
revision ids are assessed to generate this report.
379
return self._real_repository.find_text_key_references()
381
def _generate_text_key_index(self):
382
"""Generate a new text key index for the repository.
384
This is an expensive function that will take considerable time to run.
386
:return: A dict mapping (file_id, revision_id) tuples to a list of
387
parents, also (file_id, revision_id) tuples.
390
return self._real_repository._generate_text_key_index()
392
@symbol_versioning.deprecated_method(symbol_versioning.one_four)
393
303
def get_revision_graph(self, revision_id=None):
394
304
"""See Repository.get_revision_graph()."""
395
return self._get_revision_graph(revision_id)
397
def _get_revision_graph(self, revision_id):
398
"""Private method for using with old (< 1.2) servers to fallback."""
399
305
if revision_id is None:
401
elif revision.is_null(revision_id):
307
elif revision_id == NULL_REVISION:
404
310
path = self.bzrdir._path_for_remote_call(self._client)
406
response = self._client.call_expecting_body(
407
'Repository.get_revision_graph', path, revision_id)
408
except errors.ErrorFromSmartServer, err:
409
self._translate_error(err)
410
response_tuple, response_handler = response
411
if response_tuple[0] != 'ok':
412
raise errors.UnexpectedSmartServerResponse(response_tuple)
413
coded = response_handler.read_body_bytes()
415
# no revisions in this repository!
417
lines = coded.split('\n')
420
d = tuple(line.split())
421
revision_graph[d[0]] = d[1:]
423
return revision_graph
311
assert type(revision_id) is str
312
response = self._client.call_expecting_body(
313
'Repository.get_revision_graph', path, revision_id)
314
if response[0][0] not in ['ok', 'nosuchrevision']:
315
raise errors.UnexpectedSmartServerResponse(response[0])
316
if response[0][0] == 'ok':
317
coded = response[1].read_body_bytes()
319
# no revisions in this repository!
321
lines = coded.split('\n')
324
d = tuple(line.split())
325
revision_graph[d[0]] = d[1:]
327
return revision_graph
329
response_body = response[1].read_body_bytes()
330
assert response_body == ''
331
raise NoSuchRevision(self, revision_id)
425
333
def has_revision(self, revision_id):
426
334
"""See Repository.has_revision()."""
427
if revision_id == NULL_REVISION:
335
if revision_id is None:
428
336
# The null revision is always present.
430
338
path = self.bzrdir._path_for_remote_call(self._client)
431
response = self._client.call(
432
'Repository.has_revision', path, revision_id)
433
if response[0] not in ('yes', 'no'):
434
raise errors.UnexpectedSmartServerResponse(response)
339
response = self._client.call('Repository.has_revision', path, revision_id)
340
assert response[0] in ('yes', 'no'), 'unexpected response code %s' % (response,)
435
341
return response[0] == 'yes'
437
def has_revisions(self, revision_ids):
438
"""See Repository.has_revisions()."""
440
for revision_id in revision_ids:
441
if self.has_revision(revision_id):
442
result.add(revision_id)
445
343
def has_same_location(self, other):
446
344
return (self.__class__ == other.__class__ and
447
345
self.bzrdir.transport.base == other.bzrdir.transport.base)
449
347
def get_graph(self, other_repository=None):
450
348
"""Return the graph for this repository format"""
451
parents_provider = self
452
if (other_repository is not None and
453
other_repository.bzrdir.transport.base !=
454
self.bzrdir.transport.base):
455
parents_provider = graph._StackedParentsProvider(
456
[parents_provider, other_repository._make_parents_provider()])
457
return graph.Graph(parents_provider)
350
return self._real_repository.get_graph(other_repository)
459
352
def gather_stats(self, revid=None, committers=None):
460
353
"""See Repository.gather_stats()."""
461
354
path = self.bzrdir._path_for_remote_call(self._client)
462
# revid can be None to indicate no revisions, not just NULL_REVISION
463
if revid is None or revision.is_null(revid):
355
if revid in (None, NULL_REVISION):
466
358
fmt_revid = revid
538
418
path = self.bzrdir._path_for_remote_call(self._client)
539
419
if token is None:
542
response = self._client.call('Repository.lock_write', path, token)
543
except errors.ErrorFromSmartServer, err:
544
self._translate_error(err, token=token)
421
response = self._client.call('Repository.lock_write', path, token)
546
422
if response[0] == 'ok':
547
423
ok, token = response
425
elif response[0] == 'LockContention':
426
raise errors.LockContention('(remote lock)')
427
elif response[0] == 'UnlockableTransport':
428
raise errors.UnlockableTransport(self.bzrdir.root_transport)
429
elif response[0] == 'LockFailed':
430
raise errors.LockFailed(response[1], response[2])
550
432
raise errors.UnexpectedSmartServerResponse(response)
552
434
def lock_write(self, token=None):
553
435
if not self._lock_mode:
554
436
self._lock_token = self._remote_lock_write(token)
555
# if self._lock_token is None, then this is something like packs or
556
# svn where we don't get to lock the repo, or a weave style repository
557
# where we cannot lock it over the wire and attempts to do so will
437
assert self._lock_token, 'Remote server did not return a token!'
559
438
if self._real_repository is not None:
560
439
self._real_repository.lock_write(token=self._lock_token)
561
440
if token is not None:
706
573
builder = self._real_repository.get_commit_builder(branch, parents,
707
574
config, timestamp=timestamp, timezone=timezone,
708
575
committer=committer, revprops=revprops, revision_id=revision_id)
576
# Make the builder use this RemoteRepository rather than the real one.
577
builder.repository = self
711
def add_fallback_repository(self, repository):
712
"""Add a repository to use for looking up data not held locally.
714
:param repository: A repository.
716
if not self._format.supports_external_lookups:
717
raise errors.UnstackableRepositoryFormat(self._format, self.base)
718
# We need to accumulate additional repositories here, to pass them in
720
self._fallback_repositories.append(repository)
722
581
def add_inventory(self, revid, inv, parents):
723
582
self._ensure_real()
724
583
return self._real_repository.add_inventory(revid, inv, parents)
726
586
def add_revision(self, rev_id, rev, inv=None, config=None):
727
587
self._ensure_real()
728
588
return self._real_repository.add_revision(
752
613
return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
754
615
def make_working_trees(self):
755
"""See Repository.make_working_trees"""
757
return self._real_repository.make_working_trees()
759
def revision_ids_to_search_result(self, result_set):
760
"""Convert a set of revision ids to a graph SearchResult."""
761
result_parents = set()
762
for parents in self.get_graph().get_parent_map(
763
result_set).itervalues():
764
result_parents.update(parents)
765
included_keys = result_set.intersection(result_parents)
766
start_keys = result_set.difference(included_keys)
767
exclude_keys = result_parents.difference(result_set)
768
result = graph.SearchResult(start_keys, exclude_keys,
769
len(result_set), result_set)
773
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
774
"""Return the revision ids that other has that this does not.
776
These are returned in topological order.
778
revision_id: only return revision ids included by revision_id.
780
return repository.InterRepository.get(
781
other, self).search_missing_revision_ids(revision_id, find_ghosts)
616
"""RemoteRepositories never create working trees by default."""
783
619
def fetch(self, source, revision_id=None, pb=None):
784
620
if self.has_same_location(source):
785
621
# check that last_revision is in 'from' and then return a
787
623
if (revision_id is not None and
788
not revision.is_null(revision_id)):
624
not _mod_revision.is_null(revision_id)):
789
625
self.get_revision(revision_id)
791
627
self._ensure_real()
816
662
self._ensure_real()
817
663
return self._real_repository.iter_files_bytes(desired_files)
820
def _fetch_order(self):
821
"""Decorate the real repository for now.
823
In the long term getting this back from the remote repository as part
824
of open would be more efficient.
827
return self._real_repository._fetch_order
830
def _fetch_uses_deltas(self):
831
"""Decorate the real repository for now.
833
In the long term getting this back from the remote repository as part
834
of open would be more efficient.
837
return self._real_repository._fetch_uses_deltas
840
def _fetch_reconcile(self):
841
"""Decorate the real repository for now.
843
In the long term getting this back from the remote repository as part
844
of open would be more efficient.
847
return self._real_repository._fetch_reconcile
849
def get_parent_map(self, keys):
850
"""See bzrlib.Graph.get_parent_map()."""
851
# Hack to build up the caching logic.
852
ancestry = self._parents_map
854
# Repository is not locked, so there's no cache.
855
missing_revisions = set(keys)
858
missing_revisions = set(key for key in keys if key not in ancestry)
859
if missing_revisions:
860
parent_map = self._get_parent_map(missing_revisions)
861
if 'hpss' in debug.debug_flags:
862
mutter('retransmitted revisions: %d of %d',
863
len(set(ancestry).intersection(parent_map)),
865
ancestry.update(parent_map)
866
present_keys = [k for k in keys if k in ancestry]
867
if 'hpss' in debug.debug_flags:
868
if self._requested_parents is not None and len(ancestry) != 0:
869
self._requested_parents.update(present_keys)
870
mutter('Current RemoteRepository graph hit rate: %d%%',
871
100.0 * len(self._requested_parents) / len(ancestry))
872
return dict((k, ancestry[k]) for k in present_keys)
874
def _get_parent_map(self, keys):
875
"""Helper for get_parent_map that performs the RPC."""
876
medium = self._client._medium
877
if medium._is_remote_before((1, 2)):
878
# We already found out that the server can't understand
879
# Repository.get_parent_map requests, so just fetch the whole
881
# XXX: Note that this will issue a deprecation warning. This is ok
882
# :- its because we're working with a deprecated server anyway, and
883
# the user will almost certainly have seen a warning about the
884
# server version already.
885
rg = self.get_revision_graph()
886
# There is an api discrepency between get_parent_map and
887
# get_revision_graph. Specifically, a "key:()" pair in
888
# get_revision_graph just means a node has no parents. For
889
# "get_parent_map" it means the node is a ghost. So fix up the
890
# graph to correct this.
891
# https://bugs.launchpad.net/bzr/+bug/214894
892
# There is one other "bug" which is that ghosts in
893
# get_revision_graph() are not returned at all. But we won't worry
894
# about that for now.
895
for node_id, parent_ids in rg.iteritems():
897
rg[node_id] = (NULL_REVISION,)
898
rg[NULL_REVISION] = ()
903
raise ValueError('get_parent_map(None) is not valid')
904
if NULL_REVISION in keys:
905
keys.discard(NULL_REVISION)
906
found_parents = {NULL_REVISION:()}
911
# TODO(Needs analysis): We could assume that the keys being requested
912
# from get_parent_map are in a breadth first search, so typically they
913
# will all be depth N from some common parent, and we don't have to
914
# have the server iterate from the root parent, but rather from the
915
# keys we're searching; and just tell the server the keyspace we
916
# already have; but this may be more traffic again.
918
# Transform self._parents_map into a search request recipe.
919
# TODO: Manage this incrementally to avoid covering the same path
920
# repeatedly. (The server will have to on each request, but the less
921
# work done the better).
922
parents_map = self._parents_map
923
if parents_map is None:
924
# Repository is not locked, so there's no cache.
926
start_set = set(parents_map)
927
result_parents = set()
928
for parents in parents_map.itervalues():
929
result_parents.update(parents)
930
stop_keys = result_parents.difference(start_set)
931
included_keys = start_set.intersection(result_parents)
932
start_set.difference_update(included_keys)
933
recipe = (start_set, stop_keys, len(parents_map))
934
body = self._serialise_search_recipe(recipe)
935
path = self.bzrdir._path_for_remote_call(self._client)
937
if type(key) is not str:
939
"key %r not a plain string" % (key,))
940
verb = 'Repository.get_parent_map'
941
args = (path,) + tuple(keys)
943
response = self._client.call_with_body_bytes_expecting_body(
944
verb, args, self._serialise_search_recipe(recipe))
945
except errors.UnknownSmartMethod:
946
# Server does not support this method, so get the whole graph.
947
# Worse, we have to force a disconnection, because the server now
948
# doesn't realise it has a body on the wire to consume, so the
949
# only way to recover is to abandon the connection.
951
'Server is too old for fast get_parent_map, reconnecting. '
952
'(Upgrade the server to Bazaar 1.2 to avoid this)')
954
# To avoid having to disconnect repeatedly, we keep track of the
955
# fact the server doesn't understand remote methods added in 1.2.
956
medium._remember_remote_is_before((1, 2))
957
return self.get_revision_graph(None)
958
response_tuple, response_handler = response
959
if response_tuple[0] not in ['ok']:
960
response_handler.cancel_read_body()
961
raise errors.UnexpectedSmartServerResponse(response_tuple)
962
if response_tuple[0] == 'ok':
963
coded = bz2.decompress(response_handler.read_body_bytes())
967
lines = coded.split('\n')
970
d = tuple(line.split())
972
revision_graph[d[0]] = d[1:]
974
# No parents - so give the Graph result (NULL_REVISION,).
975
revision_graph[d[0]] = (NULL_REVISION,)
976
return revision_graph
979
666
def get_signature_text(self, revision_id):
980
667
self._ensure_real()
981
668
return self._real_repository.get_signature_text(revision_id)
984
@symbol_versioning.deprecated_method(symbol_versioning.one_three)
985
671
def get_revision_graph_with_ghosts(self, revision_ids=None):
986
672
self._ensure_real()
987
673
return self._real_repository.get_revision_graph_with_ghosts(
1145
790
return self._real_repository.store_revision_signature(
1146
791
gpg_strategy, plaintext, revision_id)
1148
def add_signature_text(self, revision_id, signature):
1150
return self._real_repository.add_signature_text(revision_id, signature)
1152
793
def has_signature_for_revision_id(self, revision_id):
1153
794
self._ensure_real()
1154
795
return self._real_repository.has_signature_for_revision_id(revision_id)
797
def get_data_stream(self, revision_ids):
798
path = self.bzrdir._path_for_remote_call(self._client)
799
response, protocol = self._client.call_expecting_body(
800
'Repository.stream_knit_data_for_revisions', path, *revision_ids)
801
if response == ('ok',):
802
return self._deserialise_stream(protocol)
803
elif (response == ('error', "Generic bzr smart protocol error: "
804
"bad request 'Repository.stream_knit_data_for_revisions'") or
805
response == ('error', "Generic bzr smart protocol error: "
806
"bad request u'Repository.stream_knit_data_for_revisions'")):
807
protocol.cancel_read_body()
809
return self._real_repository.get_data_stream(revision_ids)
811
raise errors.UnexpectedSmartServerResponse(response)
813
def _deserialise_stream(self, protocol):
814
buffer = StringIO(protocol.read_body_bytes())
815
reader = ContainerReader(buffer)
816
for record_names, read_bytes in reader.iter_records():
818
# These records should have only one name, and that name
819
# should be a one-element tuple.
820
[name_tuple] = record_names
822
raise errors.SmartProtocolError(
823
'Repository data stream had invalid record name %r'
825
yield name_tuple, read_bytes(None)
827
def insert_data_stream(self, stream):
829
self._real_repository.insert_data_stream(stream)
1156
831
def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1157
832
self._ensure_real()
1158
833
return self._real_repository.item_keys_introduced_by(revision_ids,
1313
982
if self._lock_mode == 'r':
1314
983
self._real_branch.lock_read()
1316
def _translate_error(self, err, **context):
1317
self.repository._translate_error(err, branch=self, **context)
1319
def _clear_cached_state(self):
1320
super(RemoteBranch, self)._clear_cached_state()
1321
if self._real_branch is not None:
1322
self._real_branch._clear_cached_state()
1324
def _clear_cached_state_of_remote_branch_only(self):
1325
"""Like _clear_cached_state, but doesn't clear the cache of
1328
This is useful when falling back to calling a method of
1329
self._real_branch that changes state. In that case the underlying
1330
branch changes, so we need to invalidate this RemoteBranch's cache of
1331
it. However, there's no need to invalidate the _real_branch's cache
1332
too, in fact doing so might harm performance.
1334
super(RemoteBranch, self)._clear_cached_state()
1337
986
def control_files(self):
1338
987
# Defer actually creating RemoteBranchLockableFiles until its needed,
1381
1018
repo_token = self.repository.lock_write()
1382
1019
self.repository.unlock()
1383
1020
path = self.bzrdir._path_for_remote_call(self._client)
1385
response = self._client.call(
1386
'Branch.lock_write', path, branch_token, repo_token or '')
1387
except errors.ErrorFromSmartServer, err:
1388
self._translate_error(err, token=token)
1389
if response[0] != 'ok':
1021
response = self._client.call('Branch.lock_write', path, branch_token,
1023
if response[0] == 'ok':
1024
ok, branch_token, repo_token = response
1025
return branch_token, repo_token
1026
elif response[0] == 'LockContention':
1027
raise errors.LockContention('(remote lock)')
1028
elif response[0] == 'TokenMismatch':
1029
raise errors.TokenMismatch(token, '(remote token)')
1030
elif response[0] == 'UnlockableTransport':
1031
raise errors.UnlockableTransport(self.bzrdir.root_transport)
1032
elif response[0] == 'ReadOnlyError':
1033
raise errors.ReadOnlyError(self)
1034
elif response[0] == 'LockFailed':
1035
raise errors.LockFailed(response[1], response[2])
1390
1037
raise errors.UnexpectedSmartServerResponse(response)
1391
ok, branch_token, repo_token = response
1392
return branch_token, repo_token
1394
1039
def lock_write(self, token=None):
1395
1040
if not self._lock_mode:
1396
1041
remote_tokens = self._remote_lock_write(token)
1397
1042
self._lock_token, self._repo_lock_token = remote_tokens
1398
if not self._lock_token:
1399
raise SmartProtocolError('Remote server did not return a token!')
1043
assert self._lock_token, 'Remote server did not return a token!'
1400
1044
# TODO: We really, really, really don't want to call _ensure_real
1401
1045
# here, but it's the easiest way to ensure coherency between the
1402
1046
# state of the RemoteBranch and RemoteRepository objects and the
1495
1134
def _gen_revision_history(self):
1496
1135
"""See Branch._gen_revision_history()."""
1497
1136
path = self.bzrdir._path_for_remote_call(self._client)
1498
response_tuple, response_handler = self._client.call_expecting_body(
1137
response = self._client.call_expecting_body(
1499
1138
'Branch.revision_history', path)
1500
if response_tuple[0] != 'ok':
1501
raise errors.UnexpectedSmartServerResponse(response_tuple)
1502
result = response_handler.read_body_bytes().split('\x00')
1139
assert response[0][0] == 'ok', ('unexpected response code %s'
1141
result = response[1].read_body_bytes().split('\x00')
1503
1142
if result == ['']:
1507
def _set_last_revision_descendant(self, revision_id, other_branch,
1508
allow_diverged=False, allow_overwrite_descendant=False):
1509
path = self.bzrdir._path_for_remote_call(self._client)
1511
response = self._client.call('Branch.set_last_revision_ex',
1512
path, self._lock_token, self._repo_lock_token, revision_id,
1513
int(allow_diverged), int(allow_overwrite_descendant))
1514
except errors.ErrorFromSmartServer, err:
1515
self._translate_error(err, other_branch=other_branch)
1516
self._clear_cached_state()
1517
if len(response) != 3 and response[0] != 'ok':
1518
raise errors.UnexpectedSmartServerResponse(response)
1519
new_revno, new_revision_id = response[1:]
1520
self._last_revision_info_cache = new_revno, new_revision_id
1521
self._real_branch._last_revision_info_cache = new_revno, new_revision_id
1523
def _set_last_revision(self, revision_id):
1524
path = self.bzrdir._path_for_remote_call(self._client)
1525
self._clear_cached_state()
1527
response = self._client.call('Branch.set_last_revision',
1528
path, self._lock_token, self._repo_lock_token, revision_id)
1529
except errors.ErrorFromSmartServer, err:
1530
self._translate_error(err)
1531
if response != ('ok',):
1532
raise errors.UnexpectedSmartServerResponse(response)
1534
1146
@needs_write_lock
1535
1147
def set_revision_history(self, rev_history):
1536
1148
# Send just the tip revision of the history; the server will generate
1537
1149
# the full history from that. If the revision doesn't exist in this
1538
1150
# branch, NoSuchRevision will be raised.
1151
path = self.bzrdir._path_for_remote_call(self._client)
1539
1152
if rev_history == []:
1540
1153
rev_id = 'null:'
1542
1155
rev_id = rev_history[-1]
1543
self._set_last_revision(rev_id)
1156
self._clear_cached_state()
1157
response = self._client.call('Branch.set_last_revision',
1158
path, self._lock_token, self._repo_lock_token, rev_id)
1159
if response[0] == 'NoSuchRevision':
1160
raise NoSuchRevision(self, rev_id)
1162
assert response == ('ok',), (
1163
'unexpected response code %r' % (response,))
1544
1164
self._cache_revision_history(rev_history)
1546
1166
def get_parent(self):
1592
1207
def is_locked(self):
1593
1208
return self._lock_count >= 1
1596
def revision_id_to_revno(self, revision_id):
1598
return self._real_branch.revision_id_to_revno(revision_id)
1601
1210
def set_last_revision_info(self, revno, revision_id):
1602
revision_id = ensure_null(revision_id)
1603
path = self.bzrdir._path_for_remote_call(self._client)
1605
response = self._client.call('Branch.set_last_revision_info',
1606
path, self._lock_token, self._repo_lock_token, str(revno), revision_id)
1607
except errors.UnknownSmartMethod:
1609
self._clear_cached_state_of_remote_branch_only()
1610
self._real_branch.set_last_revision_info(revno, revision_id)
1611
self._last_revision_info_cache = revno, revision_id
1613
except errors.ErrorFromSmartServer, err:
1614
self._translate_error(err)
1615
if response == ('ok',):
1616
self._clear_cached_state()
1617
self._last_revision_info_cache = revno, revision_id
1618
# Update the _real_branch's cache too.
1619
if self._real_branch is not None:
1620
cache = self._last_revision_info_cache
1621
self._real_branch._last_revision_info_cache = cache
1623
raise errors.UnexpectedSmartServerResponse(response)
1212
self._clear_cached_state()
1213
return self._real_branch.set_last_revision_info(revno, revision_id)
1626
1215
def generate_revision_history(self, revision_id, last_rev=None,
1627
1216
other_branch=None):
1628
medium = self._client._medium
1629
if not medium._is_remote_before((1, 6)):
1631
self._set_last_revision_descendant(revision_id, other_branch,
1632
allow_diverged=True, allow_overwrite_descendant=True)
1634
except errors.UnknownSmartMethod:
1635
medium._remember_remote_is_before((1, 6))
1636
self._clear_cached_state_of_remote_branch_only()
1637
1217
self._ensure_real()
1638
self._real_branch.generate_revision_history(
1218
return self._real_branch.generate_revision_history(
1639
1219
revision_id, last_rev=last_rev, other_branch=other_branch)
1647
1227
self._ensure_real()
1648
1228
return self._real_branch.set_push_location(location)
1651
def update_revisions(self, other, stop_revision=None, overwrite=False,
1653
"""See Branch.update_revisions."""
1656
if stop_revision is None:
1657
stop_revision = other.last_revision()
1658
if revision.is_null(stop_revision):
1659
# if there are no commits, we're done.
1661
self.fetch(other, stop_revision)
1664
# Just unconditionally set the new revision. We don't care if
1665
# the branches have diverged.
1666
self._set_last_revision(stop_revision)
1668
medium = self._client._medium
1669
if not medium._is_remote_before((1, 6)):
1671
self._set_last_revision_descendant(stop_revision, other)
1673
except errors.UnknownSmartMethod:
1674
medium._remember_remote_is_before((1, 6))
1675
# Fallback for pre-1.6 servers: check for divergence
1676
# client-side, then do _set_last_revision.
1677
last_rev = revision.ensure_null(self.last_revision())
1679
graph = self.repository.get_graph()
1680
if self._check_if_descendant_or_diverged(
1681
stop_revision, last_rev, graph, other):
1682
# stop_revision is a descendant of last_rev, but we aren't
1683
# overwriting, so we're done.
1685
self._set_last_revision(stop_revision)
1230
def update_revisions(self, other, stop_revision=None):
1232
return self._real_branch.update_revisions(
1233
other, stop_revision=stop_revision)
1236
class RemoteBranchConfig(BranchConfig):
1239
self.branch._ensure_real()
1240
return self.branch._real_branch.get_config().username()
1242
def _get_branch_data_config(self):
1243
self.branch._ensure_real()
1244
if self._branch_data_config is None:
1245
self._branch_data_config = TreeConfig(self.branch._real_branch)
1246
return self._branch_data_config
1690
1249
def _extract_tar(tar, to_dir):
1695
1254
for tarinfo in tar:
1696
1255
tar.extract(tarinfo, to_dir)
1699
def _translate_error(err, **context):
1700
"""Translate an ErrorFromSmartServer into a more useful error.
1702
Possible context keys:
1711
return context[name]
1712
except KeyError, keyErr:
1713
mutter('Missing key %r in context %r', keyErr.args[0], context)
1715
if err.error_verb == 'NoSuchRevision':
1716
raise NoSuchRevision(find('branch'), err.error_args[0])
1717
elif err.error_verb == 'nosuchrevision':
1718
raise NoSuchRevision(find('repository'), err.error_args[0])
1719
elif err.error_tuple == ('nobranch',):
1720
raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
1721
elif err.error_verb == 'norepository':
1722
raise errors.NoRepositoryPresent(find('bzrdir'))
1723
elif err.error_verb == 'LockContention':
1724
raise errors.LockContention('(remote lock)')
1725
elif err.error_verb == 'UnlockableTransport':
1726
raise errors.UnlockableTransport(find('bzrdir').root_transport)
1727
elif err.error_verb == 'LockFailed':
1728
raise errors.LockFailed(err.error_args[0], err.error_args[1])
1729
elif err.error_verb == 'TokenMismatch':
1730
raise errors.TokenMismatch(find('token'), '(remote token)')
1731
elif err.error_verb == 'Diverged':
1732
raise errors.DivergedBranches(find('branch'), find('other_branch'))
1733
elif err.error_verb == 'TipChangeRejected':
1734
raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
added
removed
bzrlib/remote.py
