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
29
from bzrlib.branch import Branch, BranchReferenceFormat
34
30
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
35
31
from bzrlib.config import BranchConfig, TreeConfig
36
32
from bzrlib.decorators import needs_read_lock, needs_write_lock
37
from bzrlib.errors import (
33
from bzrlib.errors import NoSuchRevision
41
34
from bzrlib.lockable_files import LockableFiles
42
from bzrlib.pack import ContainerPushParser
35
from bzrlib.pack import ContainerReader
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
141
def open_repository(self):
163
142
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,))
143
response = self._client.call('BzrDir.find_repository', path)
144
assert response[0] in ('ok', 'norepository'), \
145
'unexpected response code %s' % (response,)
146
if response[0] == 'norepository':
147
raise errors.NoRepositoryPresent(self)
148
assert len(response) == 4, 'incorrect response length %s' % (response,)
181
149
if response[1] == '':
182
150
format = RemoteRepositoryFormat()
183
151
format.rich_root_data = (response[2] == 'yes')
184
152
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
153
return RemoteRepository(self, format)
191
155
raise errors.NoRepositoryPresent(self)
389
335
self._ensure_real()
390
336
return self._real_repository._generate_text_key_index()
392
@symbol_versioning.deprecated_method(symbol_versioning.one_four)
393
338
def get_revision_graph(self, revision_id=None):
394
339
"""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
340
if revision_id is None:
401
342
elif revision.is_null(revision_id):
404
345
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
346
assert type(revision_id) is str
347
response = self._client.call_expecting_body(
348
'Repository.get_revision_graph', path, revision_id)
349
if response[0][0] not in ['ok', 'nosuchrevision']:
350
raise errors.UnexpectedSmartServerResponse(response[0])
351
if response[0][0] == 'ok':
352
coded = response[1].read_body_bytes()
354
# no revisions in this repository!
356
lines = coded.split('\n')
359
d = tuple(line.split())
360
revision_graph[d[0]] = d[1:]
362
return revision_graph
364
response_body = response[1].read_body_bytes()
365
assert response_body == ''
366
raise NoSuchRevision(self, revision_id)
425
368
def has_revision(self, revision_id):
426
369
"""See Repository.has_revision()."""
427
if revision_id == NULL_REVISION:
370
if revision_id is None:
428
371
# The null revision is always present.
430
373
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)
374
response = self._client.call('Repository.has_revision', path, revision_id)
375
assert response[0] in ('yes', 'no'), 'unexpected response code %s' % (response,)
435
376
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
378
def has_same_location(self, other):
446
379
return (self.__class__ == other.__class__ and
447
380
self.bzrdir.transport.base == other.bzrdir.transport.base)
449
382
def get_graph(self, other_repository=None):
450
383
"""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)
385
return self._real_repository.get_graph(other_repository)
459
387
def gather_stats(self, revid=None, committers=None):
460
388
"""See Repository.gather_stats()."""
752
658
return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
754
660
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)
661
"""RemoteRepositories never create working trees by default."""
783
664
def fetch(self, source, revision_id=None, pb=None):
784
665
if self.has_same_location(source):
816
707
self._ensure_real()
817
708
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
711
def get_signature_text(self, revision_id):
980
712
self._ensure_real()
981
713
return self._real_repository.get_signature_text(revision_id)
984
@symbol_versioning.deprecated_method(symbol_versioning.one_three)
985
716
def get_revision_graph_with_ghosts(self, revision_ids=None):
986
717
self._ensure_real()
987
718
return self._real_repository.get_revision_graph_with_ghosts(
1154
843
self._ensure_real()
1155
844
return self._real_repository.has_signature_for_revision_id(revision_id)
846
def get_data_stream(self, revision_ids):
847
path = self.bzrdir._path_for_remote_call(self._client)
848
response, protocol = self._client.call_expecting_body(
849
'Repository.stream_knit_data_for_revisions', path, *revision_ids)
850
if response == ('ok',):
851
return self._deserialise_stream(protocol)
852
elif (response == ('error', "Generic bzr smart protocol error: "
853
"bad request 'Repository.stream_knit_data_for_revisions'") or
854
response == ('error', "Generic bzr smart protocol error: "
855
"bad request u'Repository.stream_knit_data_for_revisions'")):
856
protocol.cancel_read_body()
858
return self._real_repository.get_data_stream(revision_ids)
860
raise errors.UnexpectedSmartServerResponse(response)
862
def _deserialise_stream(self, protocol):
863
buffer = StringIO(protocol.read_body_bytes())
864
reader = ContainerReader(buffer)
865
for record_names, read_bytes in reader.iter_records():
867
# These records should have only one name, and that name
868
# should be a one-element tuple.
869
[name_tuple] = record_names
871
raise errors.SmartProtocolError(
872
'Repository data stream had invalid record name %r'
874
yield name_tuple, read_bytes(None)
876
def insert_data_stream(self, stream):
878
self._real_repository.insert_data_stream(stream)
1157
880
def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1158
881
self._ensure_real()
1159
882
return self._real_repository.item_keys_introduced_by(revision_ids,
1314
1036
if self._lock_mode == 'r':
1315
1037
self._real_branch.lock_read()
1317
def _translate_error(self, err, **context):
1318
self.repository._translate_error(err, branch=self, **context)
1320
def _clear_cached_state(self):
1321
super(RemoteBranch, self)._clear_cached_state()
1322
if self._real_branch is not None:
1323
self._real_branch._clear_cached_state()
1325
def _clear_cached_state_of_remote_branch_only(self):
1326
"""Like _clear_cached_state, but doesn't clear the cache of
1329
This is useful when falling back to calling a method of
1330
self._real_branch that changes state. In that case the underlying
1331
branch changes, so we need to invalidate this RemoteBranch's cache of
1332
it. However, there's no need to invalidate the _real_branch's cache
1333
too, in fact doing so might harm performance.
1335
super(RemoteBranch, self)._clear_cached_state()
1338
1040
def control_files(self):
1339
1041
# Defer actually creating RemoteBranchLockableFiles until its needed,
1382
1072
repo_token = self.repository.lock_write()
1383
1073
self.repository.unlock()
1384
1074
path = self.bzrdir._path_for_remote_call(self._client)
1386
response = self._client.call(
1387
'Branch.lock_write', path, branch_token, repo_token or '')
1388
except errors.ErrorFromSmartServer, err:
1389
self._translate_error(err, token=token)
1390
if response[0] != 'ok':
1075
response = self._client.call('Branch.lock_write', path, branch_token,
1077
if response[0] == 'ok':
1078
ok, branch_token, repo_token = response
1079
return branch_token, repo_token
1080
elif response[0] == 'LockContention':
1081
raise errors.LockContention('(remote lock)')
1082
elif response[0] == 'TokenMismatch':
1083
raise errors.TokenMismatch(token, '(remote token)')
1084
elif response[0] == 'UnlockableTransport':
1085
raise errors.UnlockableTransport(self.bzrdir.root_transport)
1086
elif response[0] == 'ReadOnlyError':
1087
raise errors.ReadOnlyError(self)
1088
elif response[0] == 'LockFailed':
1089
raise errors.LockFailed(response[1], response[2])
1391
1091
raise errors.UnexpectedSmartServerResponse(response)
1392
ok, branch_token, repo_token = response
1393
return branch_token, repo_token
1395
1093
def lock_write(self, token=None):
1396
1094
if not self._lock_mode:
1397
1095
remote_tokens = self._remote_lock_write(token)
1398
1096
self._lock_token, self._repo_lock_token = remote_tokens
1399
if not self._lock_token:
1400
raise SmartProtocolError('Remote server did not return a token!')
1097
assert self._lock_token, 'Remote server did not return a token!'
1401
1098
# TODO: We really, really, really don't want to call _ensure_real
1402
1099
# here, but it's the easiest way to ensure coherency between the
1403
1100
# state of the RemoteBranch and RemoteRepository objects and the
1496
1193
def _gen_revision_history(self):
1497
1194
"""See Branch._gen_revision_history()."""
1498
1195
path = self.bzrdir._path_for_remote_call(self._client)
1499
response_tuple, response_handler = self._client.call_expecting_body(
1196
response = self._client.call_expecting_body(
1500
1197
'Branch.revision_history', path)
1501
if response_tuple[0] != 'ok':
1502
raise errors.UnexpectedSmartServerResponse(response_tuple)
1503
result = response_handler.read_body_bytes().split('\x00')
1198
assert response[0][0] == 'ok', ('unexpected response code %s'
1200
result = response[1].read_body_bytes().split('\x00')
1504
1201
if result == ['']:
1508
def _set_last_revision_descendant(self, revision_id, other_branch,
1509
allow_diverged=False, allow_overwrite_descendant=False):
1510
path = self.bzrdir._path_for_remote_call(self._client)
1512
response = self._client.call('Branch.set_last_revision_ex',
1513
path, self._lock_token, self._repo_lock_token, revision_id,
1514
int(allow_diverged), int(allow_overwrite_descendant))
1515
except errors.ErrorFromSmartServer, err:
1516
self._translate_error(err, other_branch=other_branch)
1517
self._clear_cached_state()
1518
if len(response) != 3 and response[0] != 'ok':
1519
raise errors.UnexpectedSmartServerResponse(response)
1520
new_revno, new_revision_id = response[1:]
1521
self._last_revision_info_cache = new_revno, new_revision_id
1522
self._real_branch._last_revision_info_cache = new_revno, new_revision_id
1524
def _set_last_revision(self, revision_id):
1525
path = self.bzrdir._path_for_remote_call(self._client)
1526
self._clear_cached_state()
1528
response = self._client.call('Branch.set_last_revision',
1529
path, self._lock_token, self._repo_lock_token, revision_id)
1530
except errors.ErrorFromSmartServer, err:
1531
self._translate_error(err)
1532
if response != ('ok',):
1533
raise errors.UnexpectedSmartServerResponse(response)
1535
1205
@needs_write_lock
1536
1206
def set_revision_history(self, rev_history):
1537
1207
# Send just the tip revision of the history; the server will generate
1538
1208
# the full history from that. If the revision doesn't exist in this
1539
1209
# branch, NoSuchRevision will be raised.
1210
path = self.bzrdir._path_for_remote_call(self._client)
1540
1211
if rev_history == []:
1541
1212
rev_id = 'null:'
1543
1214
rev_id = rev_history[-1]
1544
self._set_last_revision(rev_id)
1215
self._clear_cached_state()
1216
response = self._client.call('Branch.set_last_revision',
1217
path, self._lock_token, self._repo_lock_token, rev_id)
1218
if response[0] == 'NoSuchRevision':
1219
raise NoSuchRevision(self, rev_id)
1221
assert response == ('ok',), (
1222
'unexpected response code %r' % (response,))
1545
1223
self._cache_revision_history(rev_history)
1547
1225
def get_parent(self):
1593
1267
def is_locked(self):
1594
1268
return self._lock_count >= 1
1597
def revision_id_to_revno(self, revision_id):
1599
return self._real_branch.revision_id_to_revno(revision_id)
1602
1270
def set_last_revision_info(self, revno, revision_id):
1603
revision_id = ensure_null(revision_id)
1604
path = self.bzrdir._path_for_remote_call(self._client)
1606
response = self._client.call('Branch.set_last_revision_info',
1607
path, self._lock_token, self._repo_lock_token, str(revno), revision_id)
1608
except errors.UnknownSmartMethod:
1610
self._clear_cached_state_of_remote_branch_only()
1611
self._real_branch.set_last_revision_info(revno, revision_id)
1612
self._last_revision_info_cache = revno, revision_id
1614
except errors.ErrorFromSmartServer, err:
1615
self._translate_error(err)
1616
if response == ('ok',):
1617
self._clear_cached_state()
1618
self._last_revision_info_cache = revno, revision_id
1619
# Update the _real_branch's cache too.
1620
if self._real_branch is not None:
1621
cache = self._last_revision_info_cache
1622
self._real_branch._last_revision_info_cache = cache
1624
raise errors.UnexpectedSmartServerResponse(response)
1272
self._clear_cached_state()
1273
return self._real_branch.set_last_revision_info(revno, revision_id)
1627
1275
def generate_revision_history(self, revision_id, last_rev=None,
1628
1276
other_branch=None):
1629
medium = self._client._medium
1630
if not medium._is_remote_before((1, 6)):
1632
self._set_last_revision_descendant(revision_id, other_branch,
1633
allow_diverged=True, allow_overwrite_descendant=True)
1635
except errors.UnknownSmartMethod:
1636
medium._remember_remote_is_before((1, 6))
1637
self._clear_cached_state_of_remote_branch_only()
1638
1277
self._ensure_real()
1639
self._real_branch.generate_revision_history(
1278
return self._real_branch.generate_revision_history(
1640
1279
revision_id, last_rev=last_rev, other_branch=other_branch)
1648
1287
self._ensure_real()
1649
1288
return self._real_branch.set_push_location(location)
1652
def update_revisions(self, other, stop_revision=None, overwrite=False,
1654
"""See Branch.update_revisions."""
1657
if stop_revision is None:
1658
stop_revision = other.last_revision()
1659
if revision.is_null(stop_revision):
1660
# if there are no commits, we're done.
1662
self.fetch(other, stop_revision)
1665
# Just unconditionally set the new revision. We don't care if
1666
# the branches have diverged.
1667
self._set_last_revision(stop_revision)
1669
medium = self._client._medium
1670
if not medium._is_remote_before((1, 6)):
1672
self._set_last_revision_descendant(stop_revision, other)
1674
except errors.UnknownSmartMethod:
1675
medium._remember_remote_is_before((1, 6))
1676
# Fallback for pre-1.6 servers: check for divergence
1677
# client-side, then do _set_last_revision.
1678
last_rev = revision.ensure_null(self.last_revision())
1680
graph = self.repository.get_graph()
1681
if self._check_if_descendant_or_diverged(
1682
stop_revision, last_rev, graph, other):
1683
# stop_revision is a descendant of last_rev, but we aren't
1684
# overwriting, so we're done.
1686
self._set_last_revision(stop_revision)
1290
def update_revisions(self, other, stop_revision=None, overwrite=False):
1292
return self._real_branch.update_revisions(
1293
other, stop_revision=stop_revision, overwrite=overwrite)
1296
class RemoteBranchConfig(BranchConfig):
1299
self.branch._ensure_real()
1300
return self.branch._real_branch.get_config().username()
1302
def _get_branch_data_config(self):
1303
self.branch._ensure_real()
1304
if self._branch_data_config is None:
1305
self._branch_data_config = TreeConfig(self.branch._real_branch)
1306
return self._branch_data_config
1691
1309
def _extract_tar(tar, to_dir):
1696
1314
for tarinfo in tar:
1697
1315
tar.extract(tarinfo, to_dir)
1700
def _translate_error(err, **context):
1701
"""Translate an ErrorFromSmartServer into a more useful error.
1703
Possible context keys:
1712
return context[name]
1713
except KeyError, keyErr:
1714
mutter('Missing key %r in context %r', keyErr.args[0], context)
1716
if err.error_verb == 'NoSuchRevision':
1717
raise NoSuchRevision(find('branch'), err.error_args[0])
1718
elif err.error_verb == 'nosuchrevision':
1719
raise NoSuchRevision(find('repository'), err.error_args[0])
1720
elif err.error_tuple == ('nobranch',):
1721
raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
1722
elif err.error_verb == 'norepository':
1723
raise errors.NoRepositoryPresent(find('bzrdir'))
1724
elif err.error_verb == 'LockContention':
1725
raise errors.LockContention('(remote lock)')
1726
elif err.error_verb == 'UnlockableTransport':
1727
raise errors.UnlockableTransport(find('bzrdir').root_transport)
1728
elif err.error_verb == 'LockFailed':
1729
raise errors.LockFailed(err.error_args[0], err.error_args[1])
1730
elif err.error_verb == 'TokenMismatch':
1731
raise errors.TokenMismatch(find('token'), '(remote token)')
1732
elif err.error_verb == 'Diverged':
1733
raise errors.DivergedBranches(find('branch'), find('other_branch'))
1734
elif err.error_verb == 'TipChangeRejected':
1735
raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
added
removed
bzrlib/remote.py
