← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: John Arbash Meinel
  • Date: 2009-06-12 18:05:15 UTC
  • mto: (4371.4.5 vila-better-heads)
  • mto: This revision was merged to the branch mainline in revision 4449.
  • Revision ID: john@arbash-meinel.com-20090612180515-t0cwbjsnve094oik
Add a failing test for handling nodes that are in the same linear chain.

It fails because the ancestry skipping causes us to miss the fact that the two nodes
are actually directly related. We could check at the beginning, as the 
code used to do, but I think that will be incomplete for the more-than-two
heads cases.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
# TODO: At some point, handle upgrades by just passing the whole request
 
18
# across to run on the server.
 
19
 
17
20
import bz2
18
21
 
19
22
from bzrlib import (
24
27
    debug,
25
28
    errors,
26
29
    graph,
27
 
    lock,
28
30
    lockdir,
 
31
    pack,
29
32
    repository,
30
 
    repository as _mod_repository,
31
33
    revision,
32
34
    revision as _mod_revision,
33
 
    static_tuple,
34
35
    symbol_versioning,
 
36
    urlutils,
35
37
)
36
38
from bzrlib.branch import BranchReferenceFormat
37
39
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
38
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
 
40
from bzrlib.decorators import needs_read_lock, needs_write_lock
39
41
from bzrlib.errors import (
40
42
    NoSuchRevision,
41
43
    SmartProtocolError,
61
63
        except errors.ErrorFromSmartServer, err:
62
64
            self._translate_error(err, **err_context)
63
65
 
64
 
    def _call_with_body_bytes(self, method, args, body_bytes, **err_context):
65
 
        try:
66
 
            return self._client.call_with_body_bytes(method, args, body_bytes)
67
 
        except errors.ErrorFromSmartServer, err:
68
 
            self._translate_error(err, **err_context)
69
 
 
70
66
    def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
71
67
                                             **err_context):
72
68
        try:
91
87
class RemoteBzrDir(BzrDir, _RpcHelper):
92
88
    """Control directory on a remote server, accessed via bzr:// or similar."""
93
89
 
94
 
    def __init__(self, transport, format, _client=None, _force_probe=False):
 
90
    def __init__(self, transport, format, _client=None):
95
91
        """Construct a RemoteBzrDir.
96
92
 
97
93
        :param _client: Private parameter for testing. Disables probing and the
101
97
        # this object holds a delegated bzrdir that uses file-level operations
102
98
        # to talk to the other side
103
99
        self._real_bzrdir = None
104
 
        self._has_working_tree = None
105
100
        # 1-shot cache for the call pattern 'create_branch; open_branch' - see
106
101
        # create_branch for details.
107
102
        self._next_open_branch_result = None
111
106
            self._client = client._SmartClient(medium)
112
107
        else:
113
108
            self._client = _client
114
 
            if not _force_probe:
115
 
                return
116
 
 
117
 
        self._probe_bzrdir()
118
 
 
119
 
    def __repr__(self):
120
 
        return '%s(%r)' % (self.__class__.__name__, self._client)
121
 
 
122
 
    def _probe_bzrdir(self):
123
 
        medium = self._client._medium
 
109
            return
 
110
 
124
111
        path = self._path_for_remote_call(self._client)
125
 
        if medium._is_remote_before((2, 1)):
126
 
            self._rpc_open(path)
127
 
            return
128
 
        try:
129
 
            self._rpc_open_2_1(path)
130
 
            return
131
 
        except errors.UnknownSmartMethod:
132
 
            medium._remember_remote_is_before((2, 1))
133
 
            self._rpc_open(path)
134
 
 
135
 
    def _rpc_open_2_1(self, path):
136
 
        response = self._call('BzrDir.open_2.1', path)
137
 
        if response == ('no',):
138
 
            raise errors.NotBranchError(path=self.root_transport.base)
139
 
        elif response[0] == 'yes':
140
 
            if response[1] == 'yes':
141
 
                self._has_working_tree = True
142
 
            elif response[1] == 'no':
143
 
                self._has_working_tree = False
144
 
            else:
145
 
                raise errors.UnexpectedSmartServerResponse(response)
146
 
        else:
147
 
            raise errors.UnexpectedSmartServerResponse(response)
148
 
 
149
 
    def _rpc_open(self, path):
150
112
        response = self._call('BzrDir.open', path)
151
113
        if response not in [('yes',), ('no',)]:
152
114
            raise errors.UnexpectedSmartServerResponse(response)
153
115
        if response == ('no',):
154
 
            raise errors.NotBranchError(path=self.root_transport.base)
 
116
            raise errors.NotBranchError(path=transport.base)
155
117
 
156
118
    def _ensure_real(self):
157
119
        """Ensure that there is a _real_bzrdir set.
159
121
        Used before calls to self._real_bzrdir.
160
122
        """
161
123
        if not self._real_bzrdir:
162
 
            if 'hpssvfs' in debug.debug_flags:
163
 
                import traceback
164
 
                warning('VFS BzrDir access triggered\n%s',
165
 
                    ''.join(traceback.format_stack()))
166
124
            self._real_bzrdir = BzrDir.open_from_transport(
167
125
                self.root_transport, _server_formats=False)
168
126
            self._format._network_name = \
244
202
        self._ensure_real()
245
203
        self._real_bzrdir.destroy_repository()
246
204
 
247
 
    def create_branch(self, name=None):
 
205
    def create_branch(self):
248
206
        # as per meta1 formats - just delegate to the format object which may
249
207
        # be parameterised.
250
 
        real_branch = self._format.get_branch_format().initialize(self,
251
 
            name=name)
 
208
        real_branch = self._format.get_branch_format().initialize(self)
252
209
        if not isinstance(real_branch, RemoteBranch):
253
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
254
 
                                  name=name)
 
210
            result = RemoteBranch(self, self.find_repository(), real_branch)
255
211
        else:
256
212
            result = real_branch
257
213
        # BzrDir.clone_on_transport() uses the result of create_branch but does
263
219
        self._next_open_branch_result = result
264
220
        return result
265
221
 
266
 
    def destroy_branch(self, name=None):
 
222
    def destroy_branch(self):
267
223
        """See BzrDir.destroy_branch"""
268
224
        self._ensure_real()
269
 
        self._real_bzrdir.destroy_branch(name=name)
 
225
        self._real_bzrdir.destroy_branch()
270
226
        self._next_open_branch_result = None
271
227
 
272
228
    def create_workingtree(self, revision_id=None, from_branch=None):
291
247
    def _get_branch_reference(self):
292
248
        path = self._path_for_remote_call(self._client)
293
249
        medium = self._client._medium
294
 
        candidate_calls = [
295
 
            ('BzrDir.open_branchV3', (2, 1)),
296
 
            ('BzrDir.open_branchV2', (1, 13)),
297
 
            ('BzrDir.open_branch', None),
298
 
            ]
299
 
        for verb, required_version in candidate_calls:
300
 
            if required_version and medium._is_remote_before(required_version):
301
 
                continue
 
250
        if not medium._is_remote_before((1, 13)):
302
251
            try:
303
 
                response = self._call(verb, path)
 
252
                response = self._call('BzrDir.open_branchV2', path)
 
253
                if response[0] not in ('ref', 'branch'):
 
254
                    raise errors.UnexpectedSmartServerResponse(response)
 
255
                return response
304
256
            except errors.UnknownSmartMethod:
305
 
                if required_version is None:
306
 
                    raise
307
 
                medium._remember_remote_is_before(required_version)
308
 
            else:
309
 
                break
310
 
        if verb == 'BzrDir.open_branch':
311
 
            if response[0] != 'ok':
312
 
                raise errors.UnexpectedSmartServerResponse(response)
313
 
            if response[1] != '':
314
 
                return ('ref', response[1])
315
 
            else:
316
 
                return ('branch', '')
317
 
        if response[0] not in ('ref', 'branch'):
 
257
                medium._remember_remote_is_before((1, 13))
 
258
        response = self._call('BzrDir.open_branch', path)
 
259
        if response[0] != 'ok':
318
260
            raise errors.UnexpectedSmartServerResponse(response)
319
 
        return response
 
261
        if response[1] != '':
 
262
            return ('ref', response[1])
 
263
        else:
 
264
            return ('branch', '')
320
265
 
321
266
    def _get_tree_branch(self):
322
267
        """See BzrDir._get_tree_branch()."""
323
268
        return None, self.open_branch()
324
269
 
325
 
    def open_branch(self, name=None, unsupported=False,
326
 
                    ignore_fallbacks=False):
327
 
        if unsupported:
 
270
    def open_branch(self, _unsupported=False, ignore_fallbacks=False):
 
271
        if _unsupported:
328
272
            raise NotImplementedError('unsupported flag support not implemented yet.')
329
273
        if self._next_open_branch_result is not None:
330
274
            # See create_branch for details.
335
279
        if response[0] == 'ref':
336
280
            # a branch reference, use the existing BranchReference logic.
337
281
            format = BranchReferenceFormat()
338
 
            return format.open(self, name=name, _found=True,
339
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
 
282
            return format.open(self, _found=True, location=response[1],
 
283
                ignore_fallbacks=ignore_fallbacks)
340
284
        branch_format_name = response[1]
341
285
        if not branch_format_name:
342
286
            branch_format_name = None
343
287
        format = RemoteBranchFormat(network_name=branch_format_name)
344
288
        return RemoteBranch(self, self.find_repository(), format=format,
345
 
            setup_stacking=not ignore_fallbacks, name=name)
 
289
            setup_stacking=not ignore_fallbacks)
346
290
 
347
291
    def _open_repo_v1(self, path):
348
292
        verb = 'BzrDir.find_repository'
409
353
        else:
410
354
            raise errors.NoRepositoryPresent(self)
411
355
 
412
 
    def has_workingtree(self):
413
 
        if self._has_working_tree is None:
414
 
            self._ensure_real()
415
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
416
 
        return self._has_working_tree
417
 
 
418
356
    def open_workingtree(self, recommend_upgrade=True):
419
 
        if self.has_workingtree():
 
357
        self._ensure_real()
 
358
        if self._real_bzrdir.has_workingtree():
420
359
            raise errors.NotLocalUrl(self.root_transport)
421
360
        else:
422
361
            raise errors.NoWorkingTree(self.root_transport.base)
425
364
        """Return the path to be used for this bzrdir in a remote call."""
426
365
        return client.remote_path_from_transport(self.root_transport)
427
366
 
428
 
    def get_branch_transport(self, branch_format, name=None):
 
367
    def get_branch_transport(self, branch_format):
429
368
        self._ensure_real()
430
 
        return self._real_bzrdir.get_branch_transport(branch_format, name=name)
 
369
        return self._real_bzrdir.get_branch_transport(branch_format)
431
370
 
432
371
    def get_repository_transport(self, repository_format):
433
372
        self._ensure_real()
485
424
        self._custom_format = None
486
425
        self._network_name = None
487
426
        self._creating_bzrdir = None
488
 
        self._supports_chks = None
489
427
        self._supports_external_lookups = None
490
428
        self._supports_tree_reference = None
491
429
        self._rich_root_data = None
492
430
 
493
 
    def __repr__(self):
494
 
        return "%s(_network_name=%r)" % (self.__class__.__name__,
495
 
            self._network_name)
496
 
 
497
431
    @property
498
432
    def fast_deltas(self):
499
433
        self._ensure_real()
507
441
        return self._rich_root_data
508
442
 
509
443
    @property
510
 
    def supports_chks(self):
511
 
        if self._supports_chks is None:
512
 
            self._ensure_real()
513
 
            self._supports_chks = self._custom_format.supports_chks
514
 
        return self._supports_chks
515
 
 
516
 
    @property
517
444
    def supports_external_lookups(self):
518
445
        if self._supports_external_lookups is None:
519
446
            self._ensure_real()
620
547
        return self._custom_format._fetch_reconcile
621
548
 
622
549
    def get_format_description(self):
623
 
        self._ensure_real()
624
 
        return 'Remote: ' + self._custom_format.get_format_description()
 
550
        return 'bzr remote repository'
625
551
 
626
552
    def __eq__(self, other):
627
553
        return self.__class__ is other.__class__
628
554
 
 
555
    def check_conversion_target(self, target_format):
 
556
        if self.rich_root_data and not target_format.rich_root_data:
 
557
            raise errors.BadConversionTarget(
 
558
                'Does not support rich root data.', target_format)
 
559
        if (self.supports_tree_reference and
 
560
            not getattr(target_format, 'supports_tree_reference', False)):
 
561
            raise errors.BadConversionTarget(
 
562
                'Does not support nested trees', target_format)
 
563
 
629
564
    def network_name(self):
630
565
        if self._network_name:
631
566
            return self._network_name
633
568
        return self._creating_repo._real_repository._format.network_name()
634
569
 
635
570
    @property
636
 
    def pack_compresses(self):
637
 
        self._ensure_real()
638
 
        return self._custom_format.pack_compresses
639
 
 
640
 
    @property
641
571
    def _serializer(self):
642
572
        self._ensure_real()
643
573
        return self._custom_format._serializer
644
574
 
645
575
 
646
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
647
 
    bzrdir.ControlComponent):
 
576
class RemoteRepository(_RpcHelper):
648
577
    """Repository accessed over rpc.
649
578
 
650
579
    For the moment most operations are performed using local transport-backed
693
622
        # Additional places to query for data.
694
623
        self._fallback_repositories = []
695
624
 
696
 
    @property
697
 
    def user_transport(self):
698
 
        return self.bzrdir.user_transport
699
 
 
700
 
    @property
701
 
    def control_transport(self):
702
 
        # XXX: Normally you shouldn't directly get at the remote repository
703
 
        # transport, but I'm not sure it's worth making this method
704
 
        # optional -- mbp 2010-04-21
705
 
        return self.bzrdir.get_repository_transport(None)
706
 
        
707
625
    def __str__(self):
708
626
        return "%s(%s)" % (self.__class__.__name__, self.base)
709
627
 
757
675
        return self._real_repository.get_missing_parent_inventories(
758
676
            check_for_missing_texts=check_for_missing_texts)
759
677
 
760
 
    def _get_rev_id_for_revno_vfs(self, revno, known_pair):
761
 
        self._ensure_real()
762
 
        return self._real_repository.get_rev_id_for_revno(
763
 
            revno, known_pair)
764
 
 
765
 
    def get_rev_id_for_revno(self, revno, known_pair):
766
 
        """See Repository.get_rev_id_for_revno."""
767
 
        path = self.bzrdir._path_for_remote_call(self._client)
768
 
        try:
769
 
            if self._client._medium._is_remote_before((1, 17)):
770
 
                return self._get_rev_id_for_revno_vfs(revno, known_pair)
771
 
            response = self._call(
772
 
                'Repository.get_rev_id_for_revno', path, revno, known_pair)
773
 
        except errors.UnknownSmartMethod:
774
 
            self._client._medium._remember_remote_is_before((1, 17))
775
 
            return self._get_rev_id_for_revno_vfs(revno, known_pair)
776
 
        if response[0] == 'ok':
777
 
            return True, response[1]
778
 
        elif response[0] == 'history-incomplete':
779
 
            known_pair = response[1:3]
780
 
            for fallback in self._fallback_repositories:
781
 
                found, result = fallback.get_rev_id_for_revno(revno, known_pair)
782
 
                if found:
783
 
                    return True, result
784
 
                else:
785
 
                    known_pair = result
786
 
            # Not found in any fallbacks
787
 
            return False, known_pair
788
 
        else:
789
 
            raise errors.UnexpectedSmartServerResponse(response)
790
 
 
791
678
    def _ensure_real(self):
792
679
        """Ensure that there is a _real_repository set.
793
680
 
802
689
        invocation. If in doubt chat to the bzr network team.
803
690
        """
804
691
        if self._real_repository is None:
805
 
            if 'hpssvfs' in debug.debug_flags:
 
692
            if 'hpss' in debug.debug_flags:
806
693
                import traceback
807
694
                warning('VFS Repository access triggered\n%s',
808
695
                    ''.join(traceback.format_stack()))
892
779
            result.add(_mod_revision.NULL_REVISION)
893
780
        return result
894
781
 
895
 
    def _has_same_fallbacks(self, other_repo):
896
 
        """Returns true if the repositories have the same fallbacks."""
897
 
        # XXX: copied from Repository; it should be unified into a base class
898
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
899
 
        my_fb = self._fallback_repositories
900
 
        other_fb = other_repo._fallback_repositories
901
 
        if len(my_fb) != len(other_fb):
902
 
            return False
903
 
        for f, g in zip(my_fb, other_fb):
904
 
            if not f.has_same_location(g):
905
 
                return False
906
 
        return True
907
 
 
908
782
    def has_same_location(self, other):
909
 
        # TODO: Move to RepositoryBase and unify with the regular Repository
910
 
        # one; unfortunately the tests rely on slightly different behaviour at
911
 
        # present -- mbp 20090710
912
783
        return (self.__class__ is other.__class__ and
913
784
                self.bzrdir.transport.base == other.bzrdir.transport.base)
914
785
 
917
788
        parents_provider = self._make_parents_provider(other_repository)
918
789
        return graph.Graph(parents_provider)
919
790
 
920
 
    @needs_read_lock
921
 
    def get_known_graph_ancestry(self, revision_ids):
922
 
        """Return the known graph for a set of revision ids and their ancestors.
923
 
        """
924
 
        st = static_tuple.StaticTuple
925
 
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
926
 
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
927
 
        return graph.GraphThunkIdsToKeys(known_graph)
928
 
 
929
791
    def gather_stats(self, revid=None, committers=None):
930
792
        """See Repository.gather_stats()."""
931
793
        path = self.bzrdir._path_for_remote_call(self._client)
991
853
    def is_write_locked(self):
992
854
        return self._lock_mode == 'w'
993
855
 
994
 
    def _warn_if_deprecated(self, branch=None):
995
 
        # If we have a real repository, the check will be done there, if we
996
 
        # don't the check will be done remotely.
997
 
        pass
998
 
 
999
856
    def lock_read(self):
1000
857
        # wrong eventually - want a local lock cache context
1001
858
        if not self._lock_mode:
1002
 
            self._note_lock('r')
1003
859
            self._lock_mode = 'r'
1004
860
            self._lock_count = 1
1005
861
            self._unstacked_provider.enable_cache(cache_misses=True)
1025
881
 
1026
882
    def lock_write(self, token=None, _skip_rpc=False):
1027
883
        if not self._lock_mode:
1028
 
            self._note_lock('w')
1029
884
            if _skip_rpc:
1030
885
                if self._lock_token is not None:
1031
886
                    if token != self._lock_token:
1134
989
        else:
1135
990
            raise errors.UnexpectedSmartServerResponse(response)
1136
991
 
1137
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
1138
992
    def unlock(self):
1139
993
        if not self._lock_count:
1140
 
            return lock.cant_unlock_not_held(self)
 
994
            raise errors.LockNotHeld(self)
1141
995
        self._lock_count -= 1
1142
996
        if self._lock_count > 0:
1143
997
            return
1240
1094
            # state, so always add a lock here. If a caller passes us a locked
1241
1095
            # repository, they are responsible for unlocking it later.
1242
1096
            repository.lock_read()
1243
 
        self._check_fallback_repository(repository)
1244
1097
        self._fallback_repositories.append(repository)
1245
1098
        # If self._real_repository was parameterised already (e.g. because a
1246
1099
        # _real_branch had its get_stacked_on_url method called), then the
1247
1100
        # repository to be added may already be in the _real_repositories list.
1248
1101
        if self._real_repository is not None:
1249
 
            fallback_locations = [repo.user_url for repo in
 
1102
            fallback_locations = [repo.bzrdir.root_transport.base for repo in
1250
1103
                self._real_repository._fallback_repositories]
1251
 
            if repository.user_url not in fallback_locations:
 
1104
            if repository.bzrdir.root_transport.base not in fallback_locations:
1252
1105
                self._real_repository.add_fallback_repository(repository)
1253
1106
 
1254
 
    def _check_fallback_repository(self, repository):
1255
 
        """Check that this repository can fallback to repository safely.
1256
 
 
1257
 
        Raise an error if not.
1258
 
 
1259
 
        :param repository: A repository to fallback to.
1260
 
        """
1261
 
        return _mod_repository.InterRepository._assert_same_model(
1262
 
            self, repository)
1263
 
 
1264
1107
    def add_inventory(self, revid, inv, parents):
1265
1108
        self._ensure_real()
1266
1109
        return self._real_repository.add_inventory(revid, inv, parents)
1267
1110
 
1268
1111
    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1269
 
            parents, basis_inv=None, propagate_caches=False):
 
1112
                               parents):
1270
1113
        self._ensure_real()
1271
1114
        return self._real_repository.add_inventory_by_delta(basis_revision_id,
1272
 
            delta, new_revision_id, parents, basis_inv=basis_inv,
1273
 
            propagate_caches=propagate_caches)
 
1115
            delta, new_revision_id, parents)
1274
1116
 
1275
1117
    def add_revision(self, rev_id, rev, inv=None, config=None):
1276
1118
        self._ensure_real()
1282
1124
        self._ensure_real()
1283
1125
        return self._real_repository.get_inventory(revision_id)
1284
1126
 
1285
 
    def iter_inventories(self, revision_ids, ordering=None):
 
1127
    def iter_inventories(self, revision_ids):
1286
1128
        self._ensure_real()
1287
 
        return self._real_repository.iter_inventories(revision_ids, ordering)
 
1129
        return self._real_repository.iter_inventories(revision_ids)
1288
1130
 
1289
1131
    @needs_read_lock
1290
1132
    def get_revision(self, revision_id):
1354
1196
            raise errors.InternalBzrError(
1355
1197
                "May not fetch while in a write group.")
1356
1198
        # fast path same-url fetch operations
1357
 
        if (self.has_same_location(source)
1358
 
            and fetch_spec is None
1359
 
            and self._has_same_fallbacks(source)):
 
1199
        if self.has_same_location(source) and fetch_spec is None:
1360
1200
            # check that last_revision is in 'from' and then return a
1361
1201
            # no-operation.
1362
1202
            if (revision_id is not None and
1535
1375
        return self._real_repository.get_signature_text(revision_id)
1536
1376
 
1537
1377
    @needs_read_lock
1538
 
    def _get_inventory_xml(self, revision_id):
1539
 
        self._ensure_real()
1540
 
        return self._real_repository._get_inventory_xml(revision_id)
 
1378
    def get_inventory_xml(self, revision_id):
 
1379
        self._ensure_real()
 
1380
        return self._real_repository.get_inventory_xml(revision_id)
 
1381
 
 
1382
    def deserialise_inventory(self, revision_id, xml):
 
1383
        self._ensure_real()
 
1384
        return self._real_repository.deserialise_inventory(revision_id, xml)
1541
1385
 
1542
1386
    def reconcile(self, other=None, thorough=False):
1543
1387
        self._ensure_real()
1570
1414
        return self._real_repository.get_revision_reconcile(revision_id)
1571
1415
 
1572
1416
    @needs_read_lock
1573
 
    def check(self, revision_ids=None, callback_refs=None, check_repo=True):
 
1417
    def check(self, revision_ids=None):
1574
1418
        self._ensure_real()
1575
 
        return self._real_repository.check(revision_ids=revision_ids,
1576
 
            callback_refs=callback_refs, check_repo=check_repo)
 
1419
        return self._real_repository.check(revision_ids=revision_ids)
1577
1420
 
1578
1421
    def copy_content_into(self, destination, revision_id=None):
1579
1422
        self._ensure_real()
1619
1462
        return self._real_repository.inventories
1620
1463
 
1621
1464
    @needs_write_lock
1622
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
1465
    def pack(self):
1623
1466
        """Compress the data within the repository.
1624
1467
 
1625
1468
        This is not currently implemented within the smart server.
1626
1469
        """
1627
1470
        self._ensure_real()
1628
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
1471
        return self._real_repository.pack()
1629
1472
 
1630
1473
    @property
1631
1474
    def revisions(self):
1719
1562
        self._ensure_real()
1720
1563
        return self._real_repository.revision_graph_can_have_wrong_parents()
1721
1564
 
1722
 
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
 
1565
    def _find_inconsistent_revision_parents(self):
1723
1566
        self._ensure_real()
1724
 
        return self._real_repository._find_inconsistent_revision_parents(
1725
 
            revisions_iterator)
 
1567
        return self._real_repository._find_inconsistent_revision_parents()
1726
1568
 
1727
1569
    def _check_for_inconsistent_revision_parents(self):
1728
1570
        self._ensure_real()
1782
1624
    def insert_stream(self, stream, src_format, resume_tokens):
1783
1625
        target = self.target_repo
1784
1626
        target._unstacked_provider.missing_keys.clear()
1785
 
        candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
1786
1627
        if target._lock_token:
1787
 
            candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
1788
 
            lock_args = (target._lock_token or '',)
 
1628
            verb = 'Repository.insert_stream_locked'
 
1629
            extra_args = (target._lock_token or '',)
 
1630
            required_version = (1, 14)
1789
1631
        else:
1790
 
            candidate_calls.append(('Repository.insert_stream', (1, 13)))
1791
 
            lock_args = ()
 
1632
            verb = 'Repository.insert_stream'
 
1633
            extra_args = ()
 
1634
            required_version = (1, 13)
1792
1635
        client = target._client
1793
1636
        medium = client._medium
 
1637
        if medium._is_remote_before(required_version):
 
1638
            # No possible way this can work.
 
1639
            return self._insert_real(stream, src_format, resume_tokens)
1794
1640
        path = target.bzrdir._path_for_remote_call(client)
1795
 
        # Probe for the verb to use with an empty stream before sending the
1796
 
        # real stream to it.  We do this both to avoid the risk of sending a
1797
 
        # large request that is then rejected, and because we don't want to
1798
 
        # implement a way to buffer, rewind, or restart the stream.
1799
 
        found_verb = False
1800
 
        for verb, required_version in candidate_calls:
1801
 
            if medium._is_remote_before(required_version):
1802
 
                continue
1803
 
            if resume_tokens:
1804
 
                # We've already done the probing (and set _is_remote_before) on
1805
 
                # a previous insert.
1806
 
                found_verb = True
1807
 
                break
 
1641
        if not resume_tokens:
 
1642
            # XXX: Ugly but important for correctness, *will* be fixed during
 
1643
            # 1.13 cycle. Pushing a stream that is interrupted results in a
 
1644
            # fallback to the _real_repositories sink *with a partial stream*.
 
1645
            # Thats bad because we insert less data than bzr expected. To avoid
 
1646
            # this we do a trial push to make sure the verb is accessible, and
 
1647
            # do not fallback when actually pushing the stream. A cleanup patch
 
1648
            # is going to look at rewinding/restarting the stream/partial
 
1649
            # buffering etc.
1808
1650
            byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1809
1651
            try:
1810
1652
                response = client.call_with_body_stream(
1811
 
                    (verb, path, '') + lock_args, byte_stream)
 
1653
                    (verb, path, '') + extra_args, byte_stream)
1812
1654
            except errors.UnknownSmartMethod:
1813
1655
                medium._remember_remote_is_before(required_version)
1814
 
            else:
1815
 
                found_verb = True
1816
 
                break
1817
 
        if not found_verb:
1818
 
            # Have to use VFS.
1819
 
            return self._insert_real(stream, src_format, resume_tokens)
1820
 
        self._last_inv_record = None
1821
 
        self._last_substream = None
1822
 
        if required_version < (1, 19):
1823
 
            # Remote side doesn't support inventory deltas.  Wrap the stream to
1824
 
            # make sure we don't send any.  If the stream contains inventory
1825
 
            # deltas we'll interrupt the smart insert_stream request and
1826
 
            # fallback to VFS.
1827
 
            stream = self._stop_stream_if_inventory_delta(stream)
 
1656
                return self._insert_real(stream, src_format, resume_tokens)
1828
1657
        byte_stream = smart_repo._stream_to_byte_stream(
1829
1658
            stream, src_format)
1830
1659
        resume_tokens = ' '.join(resume_tokens)
1831
1660
        response = client.call_with_body_stream(
1832
 
            (verb, path, resume_tokens) + lock_args, byte_stream)
 
1661
            (verb, path, resume_tokens) + extra_args, byte_stream)
1833
1662
        if response[0][0] not in ('ok', 'missing-basis'):
1834
1663
            raise errors.UnexpectedSmartServerResponse(response)
1835
 
        if self._last_substream is not None:
1836
 
            # The stream included an inventory-delta record, but the remote
1837
 
            # side isn't new enough to support them.  So we need to send the
1838
 
            # rest of the stream via VFS.
1839
 
            self.target_repo.refresh_data()
1840
 
            return self._resume_stream_with_vfs(response, src_format)
1841
1664
        if response[0][0] == 'missing-basis':
1842
1665
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1843
1666
            resume_tokens = tokens
1846
1669
            self.target_repo.refresh_data()
1847
1670
            return [], set()
1848
1671
 
1849
 
    def _resume_stream_with_vfs(self, response, src_format):
1850
 
        """Resume sending a stream via VFS, first resending the record and
1851
 
        substream that couldn't be sent via an insert_stream verb.
1852
 
        """
1853
 
        if response[0][0] == 'missing-basis':
1854
 
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1855
 
            # Ignore missing_keys, we haven't finished inserting yet
1856
 
        else:
1857
 
            tokens = []
1858
 
        def resume_substream():
1859
 
            # Yield the substream that was interrupted.
1860
 
            for record in self._last_substream:
1861
 
                yield record
1862
 
            self._last_substream = None
1863
 
        def resume_stream():
1864
 
            # Finish sending the interrupted substream
1865
 
            yield ('inventory-deltas', resume_substream())
1866
 
            # Then simply continue sending the rest of the stream.
1867
 
            for substream_kind, substream in self._last_stream:
1868
 
                yield substream_kind, substream
1869
 
        return self._insert_real(resume_stream(), src_format, tokens)
1870
 
 
1871
 
    def _stop_stream_if_inventory_delta(self, stream):
1872
 
        """Normally this just lets the original stream pass-through unchanged.
1873
 
 
1874
 
        However if any 'inventory-deltas' substream occurs it will stop
1875
 
        streaming, and store the interrupted substream and stream in
1876
 
        self._last_substream and self._last_stream so that the stream can be
1877
 
        resumed by _resume_stream_with_vfs.
1878
 
        """
1879
 
                    
1880
 
        stream_iter = iter(stream)
1881
 
        for substream_kind, substream in stream_iter:
1882
 
            if substream_kind == 'inventory-deltas':
1883
 
                self._last_substream = substream
1884
 
                self._last_stream = stream_iter
1885
 
                return
1886
 
            else:
1887
 
                yield substream_kind, substream
1888
 
            
1889
1672
 
1890
1673
class RemoteStreamSource(repository.StreamSource):
1891
1674
    """Stream data from a remote server."""
1894
1677
        if (self.from_repository._fallback_repositories and
1895
1678
            self.to_format._fetch_order == 'topological'):
1896
1679
            return self._real_stream(self.from_repository, search)
1897
 
        sources = []
1898
 
        seen = set()
1899
 
        repos = [self.from_repository]
1900
 
        while repos:
1901
 
            repo = repos.pop(0)
1902
 
            if repo in seen:
1903
 
                continue
1904
 
            seen.add(repo)
1905
 
            repos.extend(repo._fallback_repositories)
1906
 
            sources.append(repo)
1907
 
        return self.missing_parents_chain(search, sources)
1908
 
 
1909
 
    def get_stream_for_missing_keys(self, missing_keys):
1910
 
        self.from_repository._ensure_real()
1911
 
        real_repo = self.from_repository._real_repository
1912
 
        real_source = real_repo._get_source(self.to_format)
1913
 
        return real_source.get_stream_for_missing_keys(missing_keys)
 
1680
        return self.missing_parents_chain(search, [self.from_repository] +
 
1681
            self.from_repository._fallback_repositories)
1914
1682
 
1915
1683
    def _real_stream(self, repo, search):
1916
1684
        """Get a stream for search from repo.
1923
1691
        """
1924
1692
        source = repo._get_source(self.to_format)
1925
1693
        if isinstance(source, RemoteStreamSource):
1926
 
            repo._ensure_real()
1927
 
            source = repo._real_repository._get_source(self.to_format)
 
1694
            return repository.StreamSource.get_stream(source, search)
1928
1695
        return source.get_stream(search)
1929
1696
 
1930
1697
    def _get_stream(self, repo, search):
1947
1714
            return self._real_stream(repo, search)
1948
1715
        client = repo._client
1949
1716
        medium = client._medium
 
1717
        if medium._is_remote_before((1, 13)):
 
1718
            # streaming was added in 1.13
 
1719
            return self._real_stream(repo, search)
1950
1720
        path = repo.bzrdir._path_for_remote_call(client)
1951
 
        search_bytes = repo._serialise_search_result(search)
1952
 
        args = (path, self.to_format.network_name())
1953
 
        candidate_verbs = [
1954
 
            ('Repository.get_stream_1.19', (1, 19)),
1955
 
            ('Repository.get_stream', (1, 13))]
1956
 
        found_verb = False
1957
 
        for verb, version in candidate_verbs:
1958
 
            if medium._is_remote_before(version):
1959
 
                continue
1960
 
            try:
1961
 
                response = repo._call_with_body_bytes_expecting_body(
1962
 
                    verb, args, search_bytes)
1963
 
            except errors.UnknownSmartMethod:
1964
 
                medium._remember_remote_is_before(version)
1965
 
            else:
1966
 
                response_tuple, response_handler = response
1967
 
                found_verb = True
1968
 
                break
1969
 
        if not found_verb:
 
1721
        try:
 
1722
            search_bytes = repo._serialise_search_result(search)
 
1723
            response = repo._call_with_body_bytes_expecting_body(
 
1724
                'Repository.get_stream',
 
1725
                (path, self.to_format.network_name()), search_bytes)
 
1726
            response_tuple, response_handler = response
 
1727
        except errors.UnknownSmartMethod:
 
1728
            medium._remember_remote_is_before((1,13))
1970
1729
            return self._real_stream(repo, search)
1971
1730
        if response_tuple[0] != 'ok':
1972
1731
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1984
1743
        :param search: The overall search to satisfy with streams.
1985
1744
        :param sources: A list of Repository objects to query.
1986
1745
        """
1987
 
        self.from_serialiser = self.from_repository._format._serializer
 
1746
        self.serialiser = self.to_format._serializer
1988
1747
        self.seen_revs = set()
1989
1748
        self.referenced_revs = set()
1990
1749
        # If there are heads in the search, or the key count is > 0, we are not
2007
1766
    def missing_parents_rev_handler(self, substream):
2008
1767
        for content in substream:
2009
1768
            revision_bytes = content.get_bytes_as('fulltext')
2010
 
            revision = self.from_serialiser.read_revision_from_string(
2011
 
                revision_bytes)
 
1769
            revision = self.serialiser.read_revision_from_string(revision_bytes)
2012
1770
            self.seen_revs.add(content.key[-1])
2013
1771
            self.referenced_revs.update(revision.parent_ids)
2014
1772
            yield content
2053
1811
                self._network_name)
2054
1812
 
2055
1813
    def get_format_description(self):
2056
 
        self._ensure_real()
2057
 
        return 'Remote: ' + self._custom_format.get_format_description()
 
1814
        return 'Remote BZR Branch'
2058
1815
 
2059
1816
    def network_name(self):
2060
1817
        return self._network_name
2061
1818
 
2062
 
    def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2063
 
        return a_bzrdir.open_branch(name=name, 
2064
 
            ignore_fallbacks=ignore_fallbacks)
 
1819
    def open(self, a_bzrdir, ignore_fallbacks=False):
 
1820
        return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
2065
1821
 
2066
 
    def _vfs_initialize(self, a_bzrdir, name):
 
1822
    def _vfs_initialize(self, a_bzrdir):
2067
1823
        # Initialisation when using a local bzrdir object, or a non-vfs init
2068
1824
        # method is not available on the server.
2069
1825
        # self._custom_format is always set - the start of initialize ensures
2070
1826
        # that.
2071
1827
        if isinstance(a_bzrdir, RemoteBzrDir):
2072
1828
            a_bzrdir._ensure_real()
2073
 
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2074
 
                name)
 
1829
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
2075
1830
        else:
2076
1831
            # We assume the bzrdir is parameterised; it may not be.
2077
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
1832
            result = self._custom_format.initialize(a_bzrdir)
2078
1833
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2079
1834
            not isinstance(result, RemoteBranch)):
2080
 
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2081
 
                                  name=name)
 
1835
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
2082
1836
        return result
2083
1837
 
2084
 
    def initialize(self, a_bzrdir, name=None):
 
1838
    def initialize(self, a_bzrdir):
2085
1839
        # 1) get the network name to use.
2086
1840
        if self._custom_format:
2087
1841
            network_name = self._custom_format.network_name()
2093
1847
            network_name = reference_format.network_name()
2094
1848
        # Being asked to create on a non RemoteBzrDir:
2095
1849
        if not isinstance(a_bzrdir, RemoteBzrDir):
2096
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
1850
            return self._vfs_initialize(a_bzrdir)
2097
1851
        medium = a_bzrdir._client._medium
2098
1852
        if medium._is_remote_before((1, 13)):
2099
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
1853
            return self._vfs_initialize(a_bzrdir)
2100
1854
        # Creating on a remote bzr dir.
2101
1855
        # 2) try direct creation via RPC
2102
1856
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2103
 
        if name is not None:
2104
 
            # XXX JRV20100304: Support creating colocated branches
2105
 
            raise errors.NoColocatedBranchSupport(self)
2106
1857
        verb = 'BzrDir.create_branch'
2107
1858
        try:
2108
1859
            response = a_bzrdir._call(verb, path, network_name)
2109
1860
        except errors.UnknownSmartMethod:
2110
1861
            # Fallback - use vfs methods
2111
1862
            medium._remember_remote_is_before((1, 13))
2112
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
1863
            return self._vfs_initialize(a_bzrdir)
2113
1864
        if response[0] != 'ok':
2114
1865
            raise errors.UnexpectedSmartServerResponse(response)
2115
1866
        # Turn the response into a RemoteRepository object.
2123
1874
                a_bzrdir._client)
2124
1875
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2125
1876
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2126
 
            format=format, setup_stacking=False, name=name)
 
1877
            format=format, setup_stacking=False)
2127
1878
        # XXX: We know this is a new branch, so it must have revno 0, revid
2128
1879
        # NULL_REVISION. Creating the branch locked would make this be unable
2129
1880
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2144
1895
        self._ensure_real()
2145
1896
        return self._custom_format.supports_stacking()
2146
1897
 
2147
 
    def supports_set_append_revisions_only(self):
2148
 
        self._ensure_real()
2149
 
        return self._custom_format.supports_set_append_revisions_only()
2150
 
 
2151
 
 
2152
 
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
 
1898
 
 
1899
class RemoteBranch(branch.Branch, _RpcHelper):
2153
1900
    """Branch stored on a server accessed by HPSS RPC.
2154
1901
 
2155
1902
    At the moment most operations are mapped down to simple file operations.
2156
1903
    """
2157
1904
 
2158
1905
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2159
 
        _client=None, format=None, setup_stacking=True, name=None):
 
1906
        _client=None, format=None, setup_stacking=True):
2160
1907
        """Create a RemoteBranch instance.
2161
1908
 
2162
1909
        :param real_branch: An optional local implementation of the branch
2168
1915
        :param setup_stacking: If True make an RPC call to determine the
2169
1916
            stacked (or not) status of the branch. If False assume the branch
2170
1917
            is not stacked.
2171
 
        :param name: Colocated branch name
2172
1918
        """
2173
1919
        # We intentionally don't call the parent class's __init__, because it
2174
1920
        # will try to assign to self.tags, which is a property in this subclass.
2175
1921
        # And the parent's __init__ doesn't do much anyway.
 
1922
        self._revision_id_to_revno_cache = None
 
1923
        self._partial_revision_id_to_revno_cache = {}
 
1924
        self._revision_history_cache = None
 
1925
        self._last_revision_info_cache = None
 
1926
        self._merge_sorted_revisions_cache = None
2176
1927
        self.bzrdir = remote_bzrdir
2177
1928
        if _client is not None:
2178
1929
            self._client = _client
2192
1943
        else:
2193
1944
            self._real_branch = None
2194
1945
        # Fill out expected attributes of branch for bzrlib API users.
2195
 
        self._clear_cached_state()
2196
 
        # TODO: deprecate self.base in favor of user_url
2197
 
        self.base = self.bzrdir.user_url
2198
 
        self._name = name
 
1946
        self.base = self.bzrdir.root_transport.base
2199
1947
        self._control_files = None
2200
1948
        self._lock_mode = None
2201
1949
        self._lock_token = None
2212
1960
                    self._real_branch._format.network_name()
2213
1961
        else:
2214
1962
            self._format = format
2215
 
        # when we do _ensure_real we may need to pass ignore_fallbacks to the
2216
 
        # branch.open_branch method.
2217
 
        self._real_ignore_fallbacks = not setup_stacking
2218
1963
        if not self._format._network_name:
2219
1964
            # Did not get from open_branchV2 - old server.
2220
1965
            self._ensure_real()
2225
1970
        hooks = branch.Branch.hooks['open']
2226
1971
        for hook in hooks:
2227
1972
            hook(self)
2228
 
        self._is_stacked = False
2229
1973
        if setup_stacking:
2230
1974
            self._setup_stacking()
2231
1975
 
2237
1981
        except (errors.NotStacked, errors.UnstackableBranchFormat,
2238
1982
            errors.UnstackableRepositoryFormat), e:
2239
1983
            return
2240
 
        self._is_stacked = True
2241
1984
        self._activate_fallback_location(fallback_url)
2242
1985
 
2243
1986
    def _get_config(self):
2265
2008
                raise AssertionError('smart server vfs must be enabled '
2266
2009
                    'to use vfs implementation')
2267
2010
            self.bzrdir._ensure_real()
2268
 
            self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2269
 
                ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
 
2011
            self._real_branch = self.bzrdir._real_bzrdir.open_branch()
2270
2012
            if self.repository._real_repository is None:
2271
2013
                # Give the remote repository the matching real repo.
2272
2014
                real_repo = self._real_branch.repository
2346
2088
            raise errors.UnexpectedSmartServerResponse(response)
2347
2089
        return response[1]
2348
2090
 
2349
 
    def set_stacked_on_url(self, url):
2350
 
        branch.Branch.set_stacked_on_url(self, url)
2351
 
        if not url:
2352
 
            self._is_stacked = False
2353
 
        else:
2354
 
            self._is_stacked = True
2355
 
        
2356
2091
    def _vfs_get_tags_bytes(self):
2357
2092
        self._ensure_real()
2358
2093
        return self._real_branch._get_tags_bytes()
2368
2103
            return self._vfs_get_tags_bytes()
2369
2104
        return response[0]
2370
2105
 
2371
 
    def _vfs_set_tags_bytes(self, bytes):
2372
 
        self._ensure_real()
2373
 
        return self._real_branch._set_tags_bytes(bytes)
2374
 
 
2375
 
    def _set_tags_bytes(self, bytes):
2376
 
        medium = self._client._medium
2377
 
        if medium._is_remote_before((1, 18)):
2378
 
            self._vfs_set_tags_bytes(bytes)
2379
 
            return
2380
 
        try:
2381
 
            args = (
2382
 
                self._remote_path(), self._lock_token, self._repo_lock_token)
2383
 
            response = self._call_with_body_bytes(
2384
 
                'Branch.set_tags_bytes', args, bytes)
2385
 
        except errors.UnknownSmartMethod:
2386
 
            medium._remember_remote_is_before((1, 18))
2387
 
            self._vfs_set_tags_bytes(bytes)
2388
 
 
2389
2106
    def lock_read(self):
2390
2107
        self.repository.lock_read()
2391
2108
        if not self._lock_mode:
2392
 
            self._note_lock('r')
2393
2109
            self._lock_mode = 'r'
2394
2110
            self._lock_count = 1
2395
2111
            if self._real_branch is not None:
2415
2131
 
2416
2132
    def lock_write(self, token=None):
2417
2133
        if not self._lock_mode:
2418
 
            self._note_lock('w')
2419
2134
            # Lock the branch and repo in one remote call.
2420
2135
            remote_tokens = self._remote_lock_write(token)
2421
2136
            self._lock_token, self._repo_lock_token = remote_tokens
2447
2162
            self.repository.lock_write(self._repo_lock_token)
2448
2163
        return self._lock_token or None
2449
2164
 
 
2165
    def _set_tags_bytes(self, bytes):
 
2166
        self._ensure_real()
 
2167
        return self._real_branch._set_tags_bytes(bytes)
 
2168
 
2450
2169
    def _unlock(self, branch_token, repo_token):
2451
2170
        err_context = {'token': str((branch_token, repo_token))}
2452
2171
        response = self._call(
2456
2175
            return
2457
2176
        raise errors.UnexpectedSmartServerResponse(response)
2458
2177
 
2459
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2460
2178
    def unlock(self):
2461
2179
        try:
2462
2180
            self._lock_count -= 1
2502
2220
            raise NotImplementedError(self.dont_leave_lock_in_place)
2503
2221
        self._leave_lock = False
2504
2222
 
2505
 
    @needs_read_lock
2506
 
    def get_rev_id(self, revno, history=None):
2507
 
        if revno == 0:
2508
 
            return _mod_revision.NULL_REVISION
2509
 
        last_revision_info = self.last_revision_info()
2510
 
        ok, result = self.repository.get_rev_id_for_revno(
2511
 
            revno, last_revision_info)
2512
 
        if ok:
2513
 
            return result
2514
 
        missing_parent = result[1]
2515
 
        # Either the revision named by the server is missing, or its parent
2516
 
        # is.  Call get_parent_map to determine which, so that we report a
2517
 
        # useful error.
2518
 
        parent_map = self.repository.get_parent_map([missing_parent])
2519
 
        if missing_parent in parent_map:
2520
 
            missing_parent = parent_map[missing_parent]
2521
 
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2522
 
 
2523
2223
    def _last_revision_info(self):
2524
2224
        response = self._call('Branch.last_revision_info', self._remote_path())
2525
2225
        if response[0] != 'ok':
2530
2230
 
2531
2231
    def _gen_revision_history(self):
2532
2232
        """See Branch._gen_revision_history()."""
2533
 
        if self._is_stacked:
2534
 
            self._ensure_real()
2535
 
            return self._real_branch._gen_revision_history()
2536
2233
        response_tuple, response_handler = self._call_expecting_body(
2537
2234
            'Branch.revision_history', self._remote_path())
2538
2235
        if response_tuple[0] != 'ok':
2873
2570
                    'Missing key %r in context %r', key_err.args[0], context)
2874
2571
                raise err
2875
2572
 
2876
 
    if err.error_verb == 'IncompatibleRepositories':
2877
 
        raise errors.IncompatibleRepositories(err.error_args[0],
2878
 
            err.error_args[1], err.error_args[2])
2879
 
    elif err.error_verb == 'NoSuchRevision':
 
2573
    if err.error_verb == 'NoSuchRevision':
2880
2574
        raise NoSuchRevision(find('branch'), err.error_args[0])
2881
2575
    elif err.error_verb == 'nosuchrevision':
2882
2576
        raise NoSuchRevision(find('repository'), err.error_args[0])
2883
 
    elif err.error_verb == 'nobranch':
2884
 
        if len(err.error_args) >= 1:
2885
 
            extra = err.error_args[0]
2886
 
        else:
2887
 
            extra = None
2888
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
2889
 
            detail=extra)
 
2577
    elif err.error_tuple == ('nobranch',):
 
2578
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
2890
2579
    elif err.error_verb == 'norepository':
2891
2580
        raise errors.NoRepositoryPresent(find('bzrdir'))
2892
2581
    elif err.error_verb == 'LockContention':