17
17
# TODO: At some point, handle upgrades by just passing the whole request
18
18
# across to run on the server.
20
21
from cStringIO import StringIO
22
23
from bzrlib import (
28
from bzrlib.branch import Branch, BranchReferenceFormat
33
from bzrlib.branch import BranchReferenceFormat
29
34
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
30
35
from bzrlib.config import BranchConfig, TreeConfig
31
36
from bzrlib.decorators import needs_read_lock, needs_write_lock
32
from bzrlib.errors import NoSuchRevision
37
from bzrlib.errors import (
33
41
from bzrlib.lockable_files import LockableFiles
34
from bzrlib.pack import ContainerReader
35
from bzrlib.revision import NULL_REVISION
42
from bzrlib.pack import ContainerPushParser
36
43
from bzrlib.smart import client, vfs
37
44
from bzrlib.symbol_versioning import (
41
from bzrlib.trace import note
48
from bzrlib.revision import ensure_null, NULL_REVISION
49
from bzrlib.trace import mutter, note, warning
43
52
# Note: RemoteBzrDirFormat is in bzrdir.py
136
162
def open_repository(self):
137
163
path = self._path_for_remote_call(self._client)
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,)
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,))
144
181
if response[1] == '':
145
182
format = RemoteRepositoryFormat()
146
183
format.rich_root_data = (response[2] == 'yes')
147
184
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
148
189
return RemoteRepository(self, format)
150
191
raise errors.NoRepositoryPresent(self)
192
238
Instances of this repository are represented by RemoteRepository
195
The RemoteRepositoryFormat is parameterised during construction
241
The RemoteRepositoryFormat is parameterized during construction
196
242
to reflect the capabilities of the real, remote format. Specifically
197
243
the attributes rich_root_data and supports_tree_reference are set
198
244
on a per instance basis, and are not set (and should not be) at
202
_matchingbzrdir = RemoteBzrDirFormat
248
_matchingbzrdir = RemoteBzrDirFormat()
204
250
def initialize(self, a_bzrdir, shared=False):
205
assert isinstance(a_bzrdir, RemoteBzrDir), \
206
'%r is not a RemoteBzrDir' % (a_bzrdir,)
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)
207
256
return a_bzrdir.create_repository(shared=shared)
209
258
def open(self, a_bzrdir):
210
assert isinstance(a_bzrdir, RemoteBzrDir)
259
if not isinstance(a_bzrdir, RemoteBzrDir):
260
raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
211
261
return a_bzrdir.open_repository()
213
263
def get_format_description(self):
300
361
#self._real_repository = self.bzrdir._real_bzrdir.open_repository()
301
362
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)
303
393
def get_revision_graph(self, revision_id=None):
304
394
"""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."""
305
399
if revision_id is None:
307
elif revision_id == NULL_REVISION:
401
elif revision.is_null(revision_id):
310
404
path = self.bzrdir._path_for_remote_call(self._client)
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)
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
333
425
def has_revision(self, revision_id):
334
426
"""See Repository.has_revision()."""
335
if revision_id is None:
427
if revision_id == NULL_REVISION:
336
428
# The null revision is always present.
338
430
path = self.bzrdir._path_for_remote_call(self._client)
339
response = self._client.call('Repository.has_revision', path, revision_id)
340
assert response[0] in ('yes', 'no'), 'unexpected response code %s' % (response,)
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)
341
435
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)
343
445
def has_same_location(self, other):
344
446
return (self.__class__ == other.__class__ and
345
447
self.bzrdir.transport.base == other.bzrdir.transport.base)
347
449
def get_graph(self, other_repository=None):
348
450
"""Return the graph for this repository format"""
350
return self._real_repository.get_graph(other_repository)
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)
352
459
def gather_stats(self, revid=None, committers=None):
353
460
"""See Repository.gather_stats()."""
354
461
path = self.bzrdir._path_for_remote_call(self._client)
355
if revid in (None, NULL_REVISION):
462
# revid can be None to indicate no revisions, not just NULL_REVISION
463
if revid is None or revision.is_null(revid):
358
466
fmt_revid = revid
418
538
path = self.bzrdir._path_for_remote_call(self._client)
419
539
if token is None:
421
response = self._client.call('Repository.lock_write', path, token)
542
response = self._client.call('Repository.lock_write', path, token)
543
except errors.ErrorFromSmartServer, err:
544
self._translate_error(err, token=token)
422
546
if response[0] == 'ok':
423
547
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])
432
550
raise errors.UnexpectedSmartServerResponse(response)
434
552
def lock_write(self, token=None):
435
553
if not self._lock_mode:
436
554
self._lock_token = self._remote_lock_write(token)
437
assert self._lock_token, 'Remote server did not return a 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
438
559
if self._real_repository is not None:
439
560
self._real_repository.lock_write(token=self._lock_token)
440
561
if token is not None:
573
706
builder = self._real_repository.get_commit_builder(branch, parents,
574
707
config, timestamp=timestamp, timezone=timezone,
575
708
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)
581
722
def add_inventory(self, revid, inv, parents):
582
723
self._ensure_real()
583
724
return self._real_repository.add_inventory(revid, inv, parents)
586
726
def add_revision(self, rev_id, rev, inv=None, config=None):
587
727
self._ensure_real()
588
728
return self._real_repository.add_revision(
613
752
return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
615
754
def make_working_trees(self):
616
"""RemoteRepositories never create working trees by default."""
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)
619
783
def fetch(self, source, revision_id=None, pb=None):
620
784
if self.has_same_location(source):
621
785
# check that last_revision is in 'from' and then return a
623
787
if (revision_id is not None and
624
not _mod_revision.is_null(revision_id)):
788
not revision.is_null(revision_id)):
625
789
self.get_revision(revision_id)
627
791
self._ensure_real()
662
816
self._ensure_real()
663
817
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
666
979
def get_signature_text(self, revision_id):
667
980
self._ensure_real()
668
981
return self._real_repository.get_signature_text(revision_id)
984
@symbol_versioning.deprecated_method(symbol_versioning.one_three)
671
985
def get_revision_graph_with_ghosts(self, revision_ids=None):
672
986
self._ensure_real()
673
987
return self._real_repository.get_revision_graph_with_ghosts(
790
1145
return self._real_repository.store_revision_signature(
791
1146
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)
793
1152
def has_signature_for_revision_id(self, revision_id):
794
1153
self._ensure_real()
795
1154
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)
831
1156
def item_keys_introduced_by(self, revision_ids, _files_pb=None):
832
1157
self._ensure_real()
833
1158
return self._real_repository.item_keys_introduced_by(revision_ids,
982
1313
if self._lock_mode == 'r':
983
1314
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()
986
1337
def control_files(self):
987
1338
# Defer actually creating RemoteBranchLockableFiles until its needed,
1018
1381
repo_token = self.repository.lock_write()
1019
1382
self.repository.unlock()
1020
1383
path = self.bzrdir._path_for_remote_call(self._client)
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])
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':
1037
1390
raise errors.UnexpectedSmartServerResponse(response)
1391
ok, branch_token, repo_token = response
1392
return branch_token, repo_token
1039
1394
def lock_write(self, token=None):
1040
1395
if not self._lock_mode:
1041
1396
remote_tokens = self._remote_lock_write(token)
1042
1397
self._lock_token, self._repo_lock_token = remote_tokens
1043
assert self._lock_token, 'Remote server did not return a token!'
1398
if not self._lock_token:
1399
raise SmartProtocolError('Remote server did not return a token!')
1044
1400
# TODO: We really, really, really don't want to call _ensure_real
1045
1401
# here, but it's the easiest way to ensure coherency between the
1046
1402
# state of the RemoteBranch and RemoteRepository objects and the
1134
1495
def _gen_revision_history(self):
1135
1496
"""See Branch._gen_revision_history()."""
1136
1497
path = self.bzrdir._path_for_remote_call(self._client)
1137
response = self._client.call_expecting_body(
1498
response_tuple, response_handler = self._client.call_expecting_body(
1138
1499
'Branch.revision_history', path)
1139
assert response[0][0] == 'ok', ('unexpected response code %s'
1141
result = response[1].read_body_bytes().split('\x00')
1500
if response_tuple[0] != 'ok':
1501
raise errors.UnexpectedSmartServerResponse(response_tuple)
1502
result = response_handler.read_body_bytes().split('\x00')
1142
1503
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)
1146
1534
@needs_write_lock
1147
1535
def set_revision_history(self, rev_history):
1148
1536
# Send just the tip revision of the history; the server will generate
1149
1537
# the full history from that. If the revision doesn't exist in this
1150
1538
# branch, NoSuchRevision will be raised.
1151
path = self.bzrdir._path_for_remote_call(self._client)
1152
1539
if rev_history == []:
1153
1540
rev_id = 'null:'
1155
1542
rev_id = rev_history[-1]
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,))
1543
self._set_last_revision(rev_id)
1164
1544
self._cache_revision_history(rev_history)
1166
1546
def get_parent(self):
1207
1592
def is_locked(self):
1208
1593
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)
1210
1601
def set_last_revision_info(self, revno, revision_id):
1212
self._clear_cached_state()
1213
return self._real_branch.set_last_revision_info(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)
1215
1626
def generate_revision_history(self, revision_id, last_rev=None,
1216
1627
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()
1217
1637
self._ensure_real()
1218
return self._real_branch.generate_revision_history(
1638
self._real_branch.generate_revision_history(
1219
1639
revision_id, last_rev=last_rev, other_branch=other_branch)
1227
1647
self._ensure_real()
1228
1648
return self._real_branch.set_push_location(location)
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
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)
1249
1690
def _extract_tar(tar, to_dir):
1254
1695
for tarinfo in tar:
1255
1696
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
