/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Jelmer Vernooij
  • Date: 2009-04-03 21:50:40 UTC
  • mto: This revision was merged to the branch mainline in revision 4253.
  • Revision ID: jelmer@samba.org-20090403215040-lz70cjc4i8bfg9xd
Review from Aaron: 
- move generic serializer tests to bzrlib.tests.test_serializer.
- fix some formatting
- add NEWS item

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 (
20
 
    bencode,
21
23
    branch,
22
24
    bzrdir,
23
25
    config,
24
26
    debug,
25
27
    errors,
26
28
    graph,
27
 
    lock,
28
29
    lockdir,
 
30
    pack,
29
31
    repository,
30
 
    repository as _mod_repository,
31
32
    revision,
32
 
    revision as _mod_revision,
33
 
    static_tuple,
34
33
    symbol_versioning,
 
34
    urlutils,
35
35
)
36
 
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
 
36
from bzrlib.branch import BranchReferenceFormat
37
37
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
38
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
 
38
from bzrlib.decorators import needs_read_lock, needs_write_lock
39
39
from bzrlib.errors import (
40
40
    NoSuchRevision,
41
41
    SmartProtocolError,
43
43
from bzrlib.lockable_files import LockableFiles
44
44
from bzrlib.smart import client, vfs, repository as smart_repo
45
45
from bzrlib.revision import ensure_null, NULL_REVISION
46
 
from bzrlib.repository import RepositoryWriteLockResult
47
46
from bzrlib.trace import mutter, note, warning
 
47
from bzrlib.util import bencode
48
48
 
49
49
 
50
50
class _RpcHelper(object):
62
62
        except errors.ErrorFromSmartServer, err:
63
63
            self._translate_error(err, **err_context)
64
64
 
65
 
    def _call_with_body_bytes(self, method, args, body_bytes, **err_context):
66
 
        try:
67
 
            return self._client.call_with_body_bytes(method, args, body_bytes)
68
 
        except errors.ErrorFromSmartServer, err:
69
 
            self._translate_error(err, **err_context)
70
 
 
71
65
    def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
72
66
                                             **err_context):
73
67
        try:
92
86
class RemoteBzrDir(BzrDir, _RpcHelper):
93
87
    """Control directory on a remote server, accessed via bzr:// or similar."""
94
88
 
95
 
    def __init__(self, transport, format, _client=None, _force_probe=False):
 
89
    def __init__(self, transport, format, _client=None):
96
90
        """Construct a RemoteBzrDir.
97
91
 
98
92
        :param _client: Private parameter for testing. Disables probing and the
102
96
        # this object holds a delegated bzrdir that uses file-level operations
103
97
        # to talk to the other side
104
98
        self._real_bzrdir = None
105
 
        self._has_working_tree = None
106
99
        # 1-shot cache for the call pattern 'create_branch; open_branch' - see
107
100
        # create_branch for details.
108
101
        self._next_open_branch_result = None
112
105
            self._client = client._SmartClient(medium)
113
106
        else:
114
107
            self._client = _client
115
 
            if not _force_probe:
116
 
                return
117
 
 
118
 
        self._probe_bzrdir()
119
 
 
120
 
    def __repr__(self):
121
 
        return '%s(%r)' % (self.__class__.__name__, self._client)
122
 
 
123
 
    def _probe_bzrdir(self):
124
 
        medium = self._client._medium
 
108
            return
 
109
 
125
110
        path = self._path_for_remote_call(self._client)
126
 
        if medium._is_remote_before((2, 1)):
127
 
            self._rpc_open(path)
128
 
            return
129
 
        try:
130
 
            self._rpc_open_2_1(path)
131
 
            return
132
 
        except errors.UnknownSmartMethod:
133
 
            medium._remember_remote_is_before((2, 1))
134
 
            self._rpc_open(path)
135
 
 
136
 
    def _rpc_open_2_1(self, path):
137
 
        response = self._call('BzrDir.open_2.1', path)
138
 
        if response == ('no',):
139
 
            raise errors.NotBranchError(path=self.root_transport.base)
140
 
        elif response[0] == 'yes':
141
 
            if response[1] == 'yes':
142
 
                self._has_working_tree = True
143
 
            elif response[1] == 'no':
144
 
                self._has_working_tree = False
145
 
            else:
146
 
                raise errors.UnexpectedSmartServerResponse(response)
147
 
        else:
148
 
            raise errors.UnexpectedSmartServerResponse(response)
149
 
 
150
 
    def _rpc_open(self, path):
151
111
        response = self._call('BzrDir.open', path)
152
112
        if response not in [('yes',), ('no',)]:
153
113
            raise errors.UnexpectedSmartServerResponse(response)
154
114
        if response == ('no',):
155
 
            raise errors.NotBranchError(path=self.root_transport.base)
 
115
            raise errors.NotBranchError(path=transport.base)
156
116
 
157
117
    def _ensure_real(self):
158
118
        """Ensure that there is a _real_bzrdir set.
160
120
        Used before calls to self._real_bzrdir.
161
121
        """
162
122
        if not self._real_bzrdir:
163
 
            if 'hpssvfs' in debug.debug_flags:
164
 
                import traceback
165
 
                warning('VFS BzrDir access triggered\n%s',
166
 
                    ''.join(traceback.format_stack()))
167
123
            self._real_bzrdir = BzrDir.open_from_transport(
168
124
                self.root_transport, _server_formats=False)
169
125
            self._format._network_name = \
245
201
        self._ensure_real()
246
202
        self._real_bzrdir.destroy_repository()
247
203
 
248
 
    def create_branch(self, name=None):
 
204
    def create_branch(self):
249
205
        # as per meta1 formats - just delegate to the format object which may
250
206
        # be parameterised.
251
 
        real_branch = self._format.get_branch_format().initialize(self,
252
 
            name=name)
 
207
        real_branch = self._format.get_branch_format().initialize(self)
253
208
        if not isinstance(real_branch, RemoteBranch):
254
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
255
 
                                  name=name)
 
209
            result = RemoteBranch(self, self.find_repository(), real_branch)
256
210
        else:
257
211
            result = real_branch
258
212
        # BzrDir.clone_on_transport() uses the result of create_branch but does
264
218
        self._next_open_branch_result = result
265
219
        return result
266
220
 
267
 
    def destroy_branch(self, name=None):
 
221
    def destroy_branch(self):
268
222
        """See BzrDir.destroy_branch"""
269
223
        self._ensure_real()
270
 
        self._real_bzrdir.destroy_branch(name=name)
 
224
        self._real_bzrdir.destroy_branch()
271
225
        self._next_open_branch_result = None
272
226
 
273
227
    def create_workingtree(self, revision_id=None, from_branch=None):
274
228
        raise errors.NotLocalUrl(self.transport.base)
275
229
 
276
 
    def find_branch_format(self, name=None):
 
230
    def find_branch_format(self):
277
231
        """Find the branch 'format' for this bzrdir.
278
232
 
279
233
        This might be a synthetic object for e.g. RemoteBranch and SVN.
280
234
        """
281
 
        b = self.open_branch(name=name)
 
235
        b = self.open_branch()
282
236
        return b._format
283
237
 
284
 
    def get_branch_reference(self, name=None):
 
238
    def get_branch_reference(self):
285
239
        """See BzrDir.get_branch_reference()."""
286
 
        if name is not None:
287
 
            # XXX JRV20100304: Support opening colocated branches
288
 
            raise errors.NoColocatedBranchSupport(self)
289
240
        response = self._get_branch_reference()
290
241
        if response[0] == 'ref':
291
242
            return response[1]
295
246
    def _get_branch_reference(self):
296
247
        path = self._path_for_remote_call(self._client)
297
248
        medium = self._client._medium
298
 
        candidate_calls = [
299
 
            ('BzrDir.open_branchV3', (2, 1)),
300
 
            ('BzrDir.open_branchV2', (1, 13)),
301
 
            ('BzrDir.open_branch', None),
302
 
            ]
303
 
        for verb, required_version in candidate_calls:
304
 
            if required_version and medium._is_remote_before(required_version):
305
 
                continue
 
249
        if not medium._is_remote_before((1, 13)):
306
250
            try:
307
 
                response = self._call(verb, path)
 
251
                response = self._call('BzrDir.open_branchV2', path)
 
252
                if response[0] not in ('ref', 'branch'):
 
253
                    raise errors.UnexpectedSmartServerResponse(response)
 
254
                return response
308
255
            except errors.UnknownSmartMethod:
309
 
                if required_version is None:
310
 
                    raise
311
 
                medium._remember_remote_is_before(required_version)
312
 
            else:
313
 
                break
314
 
        if verb == 'BzrDir.open_branch':
315
 
            if response[0] != 'ok':
316
 
                raise errors.UnexpectedSmartServerResponse(response)
317
 
            if response[1] != '':
318
 
                return ('ref', response[1])
319
 
            else:
320
 
                return ('branch', '')
321
 
        if response[0] not in ('ref', 'branch'):
 
256
                medium._remember_remote_is_before((1, 13))
 
257
        response = self._call('BzrDir.open_branch', path)
 
258
        if response[0] != 'ok':
322
259
            raise errors.UnexpectedSmartServerResponse(response)
323
 
        return response
 
260
        if response[1] != '':
 
261
            return ('ref', response[1])
 
262
        else:
 
263
            return ('branch', '')
324
264
 
325
 
    def _get_tree_branch(self, name=None):
 
265
    def _get_tree_branch(self):
326
266
        """See BzrDir._get_tree_branch()."""
327
 
        return None, self.open_branch(name=name)
 
267
        return None, self.open_branch()
328
268
 
329
 
    def open_branch(self, name=None, unsupported=False,
330
 
                    ignore_fallbacks=False):
331
 
        if unsupported:
 
269
    def open_branch(self, _unsupported=False, ignore_fallbacks=False):
 
270
        if _unsupported:
332
271
            raise NotImplementedError('unsupported flag support not implemented yet.')
333
272
        if self._next_open_branch_result is not None:
334
273
            # See create_branch for details.
339
278
        if response[0] == 'ref':
340
279
            # a branch reference, use the existing BranchReference logic.
341
280
            format = BranchReferenceFormat()
342
 
            return format.open(self, name=name, _found=True,
343
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
 
281
            return format.open(self, _found=True, location=response[1],
 
282
                ignore_fallbacks=ignore_fallbacks)
344
283
        branch_format_name = response[1]
345
284
        if not branch_format_name:
346
285
            branch_format_name = None
347
286
        format = RemoteBranchFormat(network_name=branch_format_name)
348
287
        return RemoteBranch(self, self.find_repository(), format=format,
349
 
            setup_stacking=not ignore_fallbacks, name=name)
 
288
            setup_stacking=not ignore_fallbacks)
350
289
 
351
290
    def _open_repo_v1(self, path):
352
291
        verb = 'BzrDir.find_repository'
413
352
        else:
414
353
            raise errors.NoRepositoryPresent(self)
415
354
 
416
 
    def has_workingtree(self):
417
 
        if self._has_working_tree is None:
418
 
            self._ensure_real()
419
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
420
 
        return self._has_working_tree
421
 
 
422
355
    def open_workingtree(self, recommend_upgrade=True):
423
 
        if self.has_workingtree():
 
356
        self._ensure_real()
 
357
        if self._real_bzrdir.has_workingtree():
424
358
            raise errors.NotLocalUrl(self.root_transport)
425
359
        else:
426
360
            raise errors.NoWorkingTree(self.root_transport.base)
429
363
        """Return the path to be used for this bzrdir in a remote call."""
430
364
        return client.remote_path_from_transport(self.root_transport)
431
365
 
432
 
    def get_branch_transport(self, branch_format, name=None):
 
366
    def get_branch_transport(self, branch_format):
433
367
        self._ensure_real()
434
 
        return self._real_bzrdir.get_branch_transport(branch_format, name=name)
 
368
        return self._real_bzrdir.get_branch_transport(branch_format)
435
369
 
436
370
    def get_repository_transport(self, repository_format):
437
371
        self._ensure_real()
458
392
        return self._real_bzrdir.clone(url, revision_id=revision_id,
459
393
            force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
460
394
 
461
 
    def _get_config(self):
462
 
        return RemoteBzrDirConfig(self)
 
395
    def get_config(self):
 
396
        self._ensure_real()
 
397
        return self._real_bzrdir.get_config()
463
398
 
464
399
 
465
400
class RemoteRepositoryFormat(repository.RepositoryFormat):
489
424
        self._custom_format = None
490
425
        self._network_name = None
491
426
        self._creating_bzrdir = None
492
 
        self._supports_chks = None
493
427
        self._supports_external_lookups = None
494
428
        self._supports_tree_reference = None
495
429
        self._rich_root_data = None
496
430
 
497
 
    def __repr__(self):
498
 
        return "%s(_network_name=%r)" % (self.__class__.__name__,
499
 
            self._network_name)
500
 
 
501
431
    @property
502
432
    def fast_deltas(self):
503
433
        self._ensure_real()
511
441
        return self._rich_root_data
512
442
 
513
443
    @property
514
 
    def supports_chks(self):
515
 
        if self._supports_chks is None:
516
 
            self._ensure_real()
517
 
            self._supports_chks = self._custom_format.supports_chks
518
 
        return self._supports_chks
519
 
 
520
 
    @property
521
444
    def supports_external_lookups(self):
522
445
        if self._supports_external_lookups is None:
523
446
            self._ensure_real()
569
492
        # 1) get the network name to use.
570
493
        if self._custom_format:
571
494
            network_name = self._custom_format.network_name()
572
 
        elif self._network_name:
573
 
            network_name = self._network_name
574
495
        else:
575
496
            # Select the current bzrlib default and ask for that.
576
497
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
624
545
        return self._custom_format._fetch_reconcile
625
546
 
626
547
    def get_format_description(self):
627
 
        self._ensure_real()
628
 
        return 'Remote: ' + self._custom_format.get_format_description()
 
548
        return 'bzr remote repository'
629
549
 
630
550
    def __eq__(self, other):
631
551
        return self.__class__ is other.__class__
632
552
 
 
553
    def check_conversion_target(self, target_format):
 
554
        if self.rich_root_data and not target_format.rich_root_data:
 
555
            raise errors.BadConversionTarget(
 
556
                'Does not support rich root data.', target_format)
 
557
        if (self.supports_tree_reference and
 
558
            not getattr(target_format, 'supports_tree_reference', False)):
 
559
            raise errors.BadConversionTarget(
 
560
                'Does not support nested trees', target_format)
 
561
 
633
562
    def network_name(self):
634
563
        if self._network_name:
635
564
            return self._network_name
637
566
        return self._creating_repo._real_repository._format.network_name()
638
567
 
639
568
    @property
640
 
    def pack_compresses(self):
641
 
        self._ensure_real()
642
 
        return self._custom_format.pack_compresses
643
 
 
644
 
    @property
645
569
    def _serializer(self):
646
570
        self._ensure_real()
647
571
        return self._custom_format._serializer
648
572
 
649
573
 
650
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
651
 
    bzrdir.ControlComponent):
 
574
class RemoteRepository(_RpcHelper):
652
575
    """Repository accessed over rpc.
653
576
 
654
577
    For the moment most operations are performed using local transport-backed
680
603
        self._lock_token = None
681
604
        self._lock_count = 0
682
605
        self._leave_lock = False
683
 
        # Cache of revision parents; misses are cached during read locks, and
684
 
        # write locks when no _real_repository has been set.
685
606
        self._unstacked_provider = graph.CachingParentsProvider(
686
607
            get_parent_map=self._get_parent_map_rpc)
687
608
        self._unstacked_provider.disable_cache()
697
618
        # Additional places to query for data.
698
619
        self._fallback_repositories = []
699
620
 
700
 
    @property
701
 
    def user_transport(self):
702
 
        return self.bzrdir.user_transport
703
 
 
704
 
    @property
705
 
    def control_transport(self):
706
 
        # XXX: Normally you shouldn't directly get at the remote repository
707
 
        # transport, but I'm not sure it's worth making this method
708
 
        # optional -- mbp 2010-04-21
709
 
        return self.bzrdir.get_repository_transport(None)
710
 
        
711
621
    def __str__(self):
712
622
        return "%s(%s)" % (self.__class__.__name__, self.base)
713
623
 
716
626
    def abort_write_group(self, suppress_errors=False):
717
627
        """Complete a write group on the decorated repository.
718
628
 
719
 
        Smart methods perform operations in a single step so this API
 
629
        Smart methods peform operations in a single step so this api
720
630
        is not really applicable except as a compatibility thunk
721
631
        for older plugins that don't use e.g. the CommitBuilder
722
632
        facility.
727
637
        return self._real_repository.abort_write_group(
728
638
            suppress_errors=suppress_errors)
729
639
 
730
 
    @property
731
 
    def chk_bytes(self):
732
 
        """Decorate the real repository for now.
733
 
 
734
 
        In the long term a full blown network facility is needed to avoid
735
 
        creating a real repository object locally.
736
 
        """
737
 
        self._ensure_real()
738
 
        return self._real_repository.chk_bytes
739
 
 
740
640
    def commit_write_group(self):
741
641
        """Complete a write group on the decorated repository.
742
642
 
743
 
        Smart methods perform operations in a single step so this API
 
643
        Smart methods peform operations in a single step so this api
744
644
        is not really applicable except as a compatibility thunk
745
645
        for older plugins that don't use e.g. the CommitBuilder
746
646
        facility.
756
656
        self._ensure_real()
757
657
        return self._real_repository.suspend_write_group()
758
658
 
759
 
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
760
 
        self._ensure_real()
761
 
        return self._real_repository.get_missing_parent_inventories(
762
 
            check_for_missing_texts=check_for_missing_texts)
763
 
 
764
 
    def _get_rev_id_for_revno_vfs(self, revno, known_pair):
765
 
        self._ensure_real()
766
 
        return self._real_repository.get_rev_id_for_revno(
767
 
            revno, known_pair)
768
 
 
769
 
    def get_rev_id_for_revno(self, revno, known_pair):
770
 
        """See Repository.get_rev_id_for_revno."""
771
 
        path = self.bzrdir._path_for_remote_call(self._client)
772
 
        try:
773
 
            if self._client._medium._is_remote_before((1, 17)):
774
 
                return self._get_rev_id_for_revno_vfs(revno, known_pair)
775
 
            response = self._call(
776
 
                'Repository.get_rev_id_for_revno', path, revno, known_pair)
777
 
        except errors.UnknownSmartMethod:
778
 
            self._client._medium._remember_remote_is_before((1, 17))
779
 
            return self._get_rev_id_for_revno_vfs(revno, known_pair)
780
 
        if response[0] == 'ok':
781
 
            return True, response[1]
782
 
        elif response[0] == 'history-incomplete':
783
 
            known_pair = response[1:3]
784
 
            for fallback in self._fallback_repositories:
785
 
                found, result = fallback.get_rev_id_for_revno(revno, known_pair)
786
 
                if found:
787
 
                    return True, result
788
 
                else:
789
 
                    known_pair = result
790
 
            # Not found in any fallbacks
791
 
            return False, known_pair
792
 
        else:
793
 
            raise errors.UnexpectedSmartServerResponse(response)
794
 
 
795
659
    def _ensure_real(self):
796
660
        """Ensure that there is a _real_repository set.
797
661
 
806
670
        invocation. If in doubt chat to the bzr network team.
807
671
        """
808
672
        if self._real_repository is None:
809
 
            if 'hpssvfs' in debug.debug_flags:
810
 
                import traceback
811
 
                warning('VFS Repository access triggered\n%s',
812
 
                    ''.join(traceback.format_stack()))
813
 
            self._unstacked_provider.missing_keys.clear()
814
673
            self.bzrdir._ensure_real()
815
674
            self._set_real_repository(
816
675
                self.bzrdir._real_bzrdir.open_repository())
876
735
        """Return a source for streaming from this repository."""
877
736
        return RemoteStreamSource(self, to_format)
878
737
 
879
 
    @needs_read_lock
880
738
    def has_revision(self, revision_id):
881
 
        """True if this repository has a copy of the revision."""
882
 
        # Copy of bzrlib.repository.Repository.has_revision
883
 
        return revision_id in self.has_revisions((revision_id,))
 
739
        """See Repository.has_revision()."""
 
740
        if revision_id == NULL_REVISION:
 
741
            # The null revision is always present.
 
742
            return True
 
743
        path = self.bzrdir._path_for_remote_call(self._client)
 
744
        response = self._call('Repository.has_revision', path, revision_id)
 
745
        if response[0] not in ('yes', 'no'):
 
746
            raise errors.UnexpectedSmartServerResponse(response)
 
747
        if response[0] == 'yes':
 
748
            return True
 
749
        for fallback_repo in self._fallback_repositories:
 
750
            if fallback_repo.has_revision(revision_id):
 
751
                return True
 
752
        return False
884
753
 
885
 
    @needs_read_lock
886
754
    def has_revisions(self, revision_ids):
887
 
        """Probe to find out the presence of multiple revisions.
888
 
 
889
 
        :param revision_ids: An iterable of revision_ids.
890
 
        :return: A set of the revision_ids that were present.
891
 
        """
892
 
        # Copy of bzrlib.repository.Repository.has_revisions
893
 
        parent_map = self.get_parent_map(revision_ids)
894
 
        result = set(parent_map)
895
 
        if _mod_revision.NULL_REVISION in revision_ids:
896
 
            result.add(_mod_revision.NULL_REVISION)
 
755
        """See Repository.has_revisions()."""
 
756
        # FIXME: This does many roundtrips, particularly when there are
 
757
        # fallback repositories.  -- mbp 20080905
 
758
        result = set()
 
759
        for revision_id in revision_ids:
 
760
            if self.has_revision(revision_id):
 
761
                result.add(revision_id)
897
762
        return result
898
763
 
899
 
    def _has_same_fallbacks(self, other_repo):
900
 
        """Returns true if the repositories have the same fallbacks."""
901
 
        # XXX: copied from Repository; it should be unified into a base class
902
 
        # <https://bugs.launchpad.net/bzr/+bug/401622>
903
 
        my_fb = self._fallback_repositories
904
 
        other_fb = other_repo._fallback_repositories
905
 
        if len(my_fb) != len(other_fb):
906
 
            return False
907
 
        for f, g in zip(my_fb, other_fb):
908
 
            if not f.has_same_location(g):
909
 
                return False
910
 
        return True
911
 
 
912
764
    def has_same_location(self, other):
913
 
        # TODO: Move to RepositoryBase and unify with the regular Repository
914
 
        # one; unfortunately the tests rely on slightly different behaviour at
915
 
        # present -- mbp 20090710
916
765
        return (self.__class__ is other.__class__ and
917
766
                self.bzrdir.transport.base == other.bzrdir.transport.base)
918
767
 
921
770
        parents_provider = self._make_parents_provider(other_repository)
922
771
        return graph.Graph(parents_provider)
923
772
 
924
 
    @needs_read_lock
925
 
    def get_known_graph_ancestry(self, revision_ids):
926
 
        """Return the known graph for a set of revision ids and their ancestors.
927
 
        """
928
 
        st = static_tuple.StaticTuple
929
 
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
930
 
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
931
 
        return graph.GraphThunkIdsToKeys(known_graph)
932
 
 
933
773
    def gather_stats(self, revid=None, committers=None):
934
774
        """See Repository.gather_stats()."""
935
775
        path = self.bzrdir._path_for_remote_call(self._client)
995
835
    def is_write_locked(self):
996
836
        return self._lock_mode == 'w'
997
837
 
998
 
    def _warn_if_deprecated(self, branch=None):
999
 
        # If we have a real repository, the check will be done there, if we
1000
 
        # don't the check will be done remotely.
1001
 
        pass
1002
 
 
1003
838
    def lock_read(self):
1004
 
        """Lock the repository for read operations.
1005
 
 
1006
 
        :return: A bzrlib.lock.LogicalLockResult.
1007
 
        """
1008
839
        # wrong eventually - want a local lock cache context
1009
840
        if not self._lock_mode:
1010
 
            self._note_lock('r')
1011
841
            self._lock_mode = 'r'
1012
842
            self._lock_count = 1
1013
843
            self._unstacked_provider.enable_cache(cache_misses=True)
1014
844
            if self._real_repository is not None:
1015
845
                self._real_repository.lock_read()
1016
 
            for repo in self._fallback_repositories:
1017
 
                repo.lock_read()
1018
846
        else:
1019
847
            self._lock_count += 1
1020
 
        return lock.LogicalLockResult(self.unlock)
 
848
        for repo in self._fallback_repositories:
 
849
            repo.lock_read()
1021
850
 
1022
851
    def _remote_lock_write(self, token):
1023
852
        path = self.bzrdir._path_for_remote_call(self._client)
1034
863
 
1035
864
    def lock_write(self, token=None, _skip_rpc=False):
1036
865
        if not self._lock_mode:
1037
 
            self._note_lock('w')
1038
866
            if _skip_rpc:
1039
867
                if self._lock_token is not None:
1040
868
                    if token != self._lock_token:
1054
882
                self._leave_lock = False
1055
883
            self._lock_mode = 'w'
1056
884
            self._lock_count = 1
1057
 
            cache_misses = self._real_repository is None
1058
 
            self._unstacked_provider.enable_cache(cache_misses=cache_misses)
1059
 
            for repo in self._fallback_repositories:
1060
 
                # Writes don't affect fallback repos
1061
 
                repo.lock_read()
 
885
            self._unstacked_provider.enable_cache(cache_misses=False)
1062
886
        elif self._lock_mode == 'r':
1063
887
            raise errors.ReadOnlyError(self)
1064
888
        else:
1065
889
            self._lock_count += 1
1066
 
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
 
890
        for repo in self._fallback_repositories:
 
891
            # Writes don't affect fallback repos
 
892
            repo.lock_read()
 
893
        return self._lock_token or None
1067
894
 
1068
895
    def leave_lock_in_place(self):
1069
896
        if not self._lock_token:
1090
917
        if isinstance(repository, RemoteRepository):
1091
918
            raise AssertionError()
1092
919
        self._real_repository = repository
1093
 
        # three code paths happen here:
1094
 
        # 1) old servers, RemoteBranch.open() calls _ensure_real before setting
1095
 
        # up stacking. In this case self._fallback_repositories is [], and the
1096
 
        # real repo is already setup. Preserve the real repo and
1097
 
        # RemoteRepository.add_fallback_repository will avoid adding
1098
 
        # duplicates.
1099
 
        # 2) new servers, RemoteBranch.open() sets up stacking, and when
1100
 
        # ensure_real is triggered from a branch, the real repository to
1101
 
        # set already has a matching list with separate instances, but
1102
 
        # as they are also RemoteRepositories we don't worry about making the
1103
 
        # lists be identical.
1104
 
        # 3) new servers, RemoteRepository.ensure_real is triggered before
1105
 
        # RemoteBranch.ensure real, in this case we get a repo with no fallbacks
1106
 
        # and need to populate it.
1107
 
        if (self._fallback_repositories and
1108
 
            len(self._real_repository._fallback_repositories) !=
1109
 
            len(self._fallback_repositories)):
1110
 
            if len(self._real_repository._fallback_repositories):
1111
 
                raise AssertionError(
1112
 
                    "cannot cleanly remove existing _fallback_repositories")
 
920
        # If the _real_repository has _fallback_repositories, clear them out,
 
921
        # because we want it to have the same set as this repository.  This is
 
922
        # reasonable to do because the fallbacks we clear here are from a
 
923
        # "real" branch, and we're about to replace them with the equivalents
 
924
        # from a RemoteBranch.
 
925
        self._real_repository._fallback_repositories = []
1113
926
        for fb in self._fallback_repositories:
1114
927
            self._real_repository.add_fallback_repository(fb)
1115
928
        if self._lock_mode == 'w':
1122
935
    def start_write_group(self):
1123
936
        """Start a write group on the decorated repository.
1124
937
 
1125
 
        Smart methods perform operations in a single step so this API
 
938
        Smart methods peform operations in a single step so this api
1126
939
        is not really applicable except as a compatibility thunk
1127
940
        for older plugins that don't use e.g. the CommitBuilder
1128
941
        facility.
1143
956
        else:
1144
957
            raise errors.UnexpectedSmartServerResponse(response)
1145
958
 
1146
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
1147
959
    def unlock(self):
1148
960
        if not self._lock_count:
1149
 
            return lock.cant_unlock_not_held(self)
 
961
            raise errors.LockNotHeld(self)
1150
962
        self._lock_count -= 1
1151
963
        if self._lock_count > 0:
1152
964
            return
1166
978
            # problem releasing the vfs-based lock.
1167
979
            if old_mode == 'w':
1168
980
                # Only write-locked repositories need to make a remote method
1169
 
                # call to perform the unlock.
 
981
                # call to perfom the unlock.
1170
982
                old_token = self._lock_token
1171
983
                self._lock_token = None
1172
984
                if not self._leave_lock:
1173
985
                    self._unlock(old_token)
1174
 
        # Fallbacks are always 'lock_read()' so we don't pay attention to
1175
 
        # self._leave_lock
1176
 
        for repo in self._fallback_repositories:
1177
 
            repo.unlock()
1178
986
 
1179
987
    def break_lock(self):
1180
988
        # should hand off to the network
1244
1052
        # We need to accumulate additional repositories here, to pass them in
1245
1053
        # on various RPC's.
1246
1054
        #
1247
 
        if self.is_locked():
1248
 
            # We will call fallback.unlock() when we transition to the unlocked
1249
 
            # state, so always add a lock here. If a caller passes us a locked
1250
 
            # repository, they are responsible for unlocking it later.
1251
 
            repository.lock_read()
1252
 
        self._check_fallback_repository(repository)
1253
1055
        self._fallback_repositories.append(repository)
1254
1056
        # If self._real_repository was parameterised already (e.g. because a
1255
1057
        # _real_branch had its get_stacked_on_url method called), then the
1256
1058
        # repository to be added may already be in the _real_repositories list.
1257
1059
        if self._real_repository is not None:
1258
 
            fallback_locations = [repo.user_url for repo in
1259
 
                self._real_repository._fallback_repositories]
1260
 
            if repository.user_url not in fallback_locations:
 
1060
            if repository not in self._real_repository._fallback_repositories:
1261
1061
                self._real_repository.add_fallback_repository(repository)
1262
1062
 
1263
 
    def _check_fallback_repository(self, repository):
1264
 
        """Check that this repository can fallback to repository safely.
1265
 
 
1266
 
        Raise an error if not.
1267
 
 
1268
 
        :param repository: A repository to fallback to.
1269
 
        """
1270
 
        return _mod_repository.InterRepository._assert_same_model(
1271
 
            self, repository)
1272
 
 
1273
1063
    def add_inventory(self, revid, inv, parents):
1274
1064
        self._ensure_real()
1275
1065
        return self._real_repository.add_inventory(revid, inv, parents)
1276
1066
 
1277
1067
    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1278
 
            parents, basis_inv=None, propagate_caches=False):
 
1068
                               parents):
1279
1069
        self._ensure_real()
1280
1070
        return self._real_repository.add_inventory_by_delta(basis_revision_id,
1281
 
            delta, new_revision_id, parents, basis_inv=basis_inv,
1282
 
            propagate_caches=propagate_caches)
 
1071
            delta, new_revision_id, parents)
1283
1072
 
1284
1073
    def add_revision(self, rev_id, rev, inv=None, config=None):
1285
1074
        self._ensure_real()
1291
1080
        self._ensure_real()
1292
1081
        return self._real_repository.get_inventory(revision_id)
1293
1082
 
1294
 
    def iter_inventories(self, revision_ids, ordering=None):
 
1083
    def iter_inventories(self, revision_ids):
1295
1084
        self._ensure_real()
1296
 
        return self._real_repository.iter_inventories(revision_ids, ordering)
 
1085
        return self._real_repository.iter_inventories(revision_ids)
1297
1086
 
1298
1087
    @needs_read_lock
1299
1088
    def get_revision(self, revision_id):
1315
1104
        return self._real_repository.make_working_trees()
1316
1105
 
1317
1106
    def refresh_data(self):
1318
 
        """Re-read any data needed to synchronise with disk.
 
1107
        """Re-read any data needed to to synchronise with disk.
1319
1108
 
1320
1109
        This method is intended to be called after another repository instance
1321
1110
        (such as one used by a smart server) has inserted data into the
1322
 
        repository. On all repositories this will work outside of write groups.
1323
 
        Some repository formats (pack and newer for bzrlib native formats)
1324
 
        support refresh_data inside write groups. If called inside a write
1325
 
        group on a repository that does not support refreshing in a write group
1326
 
        IsInWriteGroupError will be raised.
 
1111
        repository. It may not be called during a write group, but may be
 
1112
        called at any other time.
1327
1113
        """
 
1114
        if self.is_in_write_group():
 
1115
            raise errors.InternalBzrError(
 
1116
                "May not refresh_data while in a write group.")
1328
1117
        if self._real_repository is not None:
1329
1118
            self._real_repository.refresh_data()
1330
1119
 
1363
1152
            raise errors.InternalBzrError(
1364
1153
                "May not fetch while in a write group.")
1365
1154
        # fast path same-url fetch operations
1366
 
        if (self.has_same_location(source)
1367
 
            and fetch_spec is None
1368
 
            and self._has_same_fallbacks(source)):
 
1155
        if self.has_same_location(source) and fetch_spec is None:
1369
1156
            # check that last_revision is in 'from' and then return a
1370
1157
            # no-operation.
1371
1158
            if (revision_id is not None and
1420
1207
            # in one go, and the user probably will have seen a warning about
1421
1208
            # the server being old anyhow.
1422
1209
            rg = self._get_revision_graph(None)
1423
 
            # There is an API discrepancy between get_parent_map and
 
1210
            # There is an api discrepency between get_parent_map and
1424
1211
            # get_revision_graph. Specifically, a "key:()" pair in
1425
1212
            # get_revision_graph just means a node has no parents. For
1426
1213
            # "get_parent_map" it means the node is a ghost. So fix up the
1544
1331
        return self._real_repository.get_signature_text(revision_id)
1545
1332
 
1546
1333
    @needs_read_lock
1547
 
    def _get_inventory_xml(self, revision_id):
1548
 
        self._ensure_real()
1549
 
        return self._real_repository._get_inventory_xml(revision_id)
 
1334
    def get_inventory_xml(self, revision_id):
 
1335
        self._ensure_real()
 
1336
        return self._real_repository.get_inventory_xml(revision_id)
 
1337
 
 
1338
    def deserialise_inventory(self, revision_id, xml):
 
1339
        self._ensure_real()
 
1340
        return self._real_repository.deserialise_inventory(revision_id, xml)
1550
1341
 
1551
1342
    def reconcile(self, other=None, thorough=False):
1552
1343
        self._ensure_real()
1579
1370
        return self._real_repository.get_revision_reconcile(revision_id)
1580
1371
 
1581
1372
    @needs_read_lock
1582
 
    def check(self, revision_ids=None, callback_refs=None, check_repo=True):
 
1373
    def check(self, revision_ids=None):
1583
1374
        self._ensure_real()
1584
 
        return self._real_repository.check(revision_ids=revision_ids,
1585
 
            callback_refs=callback_refs, check_repo=check_repo)
 
1375
        return self._real_repository.check(revision_ids=revision_ids)
1586
1376
 
1587
1377
    def copy_content_into(self, destination, revision_id=None):
1588
1378
        self._ensure_real()
1628
1418
        return self._real_repository.inventories
1629
1419
 
1630
1420
    @needs_write_lock
1631
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
1421
    def pack(self):
1632
1422
        """Compress the data within the repository.
1633
1423
 
1634
1424
        This is not currently implemented within the smart server.
1635
1425
        """
1636
1426
        self._ensure_real()
1637
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
1427
        return self._real_repository.pack()
1638
1428
 
1639
1429
    @property
1640
1430
    def revisions(self):
1728
1518
        self._ensure_real()
1729
1519
        return self._real_repository.revision_graph_can_have_wrong_parents()
1730
1520
 
1731
 
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
 
1521
    def _find_inconsistent_revision_parents(self):
1732
1522
        self._ensure_real()
1733
 
        return self._real_repository._find_inconsistent_revision_parents(
1734
 
            revisions_iterator)
 
1523
        return self._real_repository._find_inconsistent_revision_parents()
1735
1524
 
1736
1525
    def _check_for_inconsistent_revision_parents(self):
1737
1526
        self._ensure_real()
1743
1532
            providers.insert(0, other)
1744
1533
        providers.extend(r._make_parents_provider() for r in
1745
1534
                         self._fallback_repositories)
1746
 
        return graph.StackedParentsProvider(providers)
 
1535
        return graph._StackedParentsProvider(providers)
1747
1536
 
1748
1537
    def _serialise_search_recipe(self, recipe):
1749
1538
        """Serialise a graph search recipe.
1790
1579
 
1791
1580
    def insert_stream(self, stream, src_format, resume_tokens):
1792
1581
        target = self.target_repo
1793
 
        target._unstacked_provider.missing_keys.clear()
1794
 
        candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
1795
1582
        if target._lock_token:
1796
 
            candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
1797
 
            lock_args = (target._lock_token or '',)
 
1583
            verb = 'Repository.insert_stream_locked'
 
1584
            extra_args = (target._lock_token or '',)
 
1585
            required_version = (1, 14)
1798
1586
        else:
1799
 
            candidate_calls.append(('Repository.insert_stream', (1, 13)))
1800
 
            lock_args = ()
 
1587
            verb = 'Repository.insert_stream'
 
1588
            extra_args = ()
 
1589
            required_version = (1, 13)
1801
1590
        client = target._client
1802
1591
        medium = client._medium
 
1592
        if medium._is_remote_before(required_version):
 
1593
            # No possible way this can work.
 
1594
            return self._insert_real(stream, src_format, resume_tokens)
1803
1595
        path = target.bzrdir._path_for_remote_call(client)
1804
 
        # Probe for the verb to use with an empty stream before sending the
1805
 
        # real stream to it.  We do this both to avoid the risk of sending a
1806
 
        # large request that is then rejected, and because we don't want to
1807
 
        # implement a way to buffer, rewind, or restart the stream.
1808
 
        found_verb = False
1809
 
        for verb, required_version in candidate_calls:
1810
 
            if medium._is_remote_before(required_version):
1811
 
                continue
1812
 
            if resume_tokens:
1813
 
                # We've already done the probing (and set _is_remote_before) on
1814
 
                # a previous insert.
1815
 
                found_verb = True
1816
 
                break
 
1596
        if not resume_tokens:
 
1597
            # XXX: Ugly but important for correctness, *will* be fixed during
 
1598
            # 1.13 cycle. Pushing a stream that is interrupted results in a
 
1599
            # fallback to the _real_repositories sink *with a partial stream*.
 
1600
            # Thats bad because we insert less data than bzr expected. To avoid
 
1601
            # this we do a trial push to make sure the verb is accessible, and
 
1602
            # do not fallback when actually pushing the stream. A cleanup patch
 
1603
            # is going to look at rewinding/restarting the stream/partial
 
1604
            # buffering etc.
1817
1605
            byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1818
1606
            try:
1819
1607
                response = client.call_with_body_stream(
1820
 
                    (verb, path, '') + lock_args, byte_stream)
 
1608
                    (verb, path, '') + extra_args, byte_stream)
1821
1609
            except errors.UnknownSmartMethod:
1822
1610
                medium._remember_remote_is_before(required_version)
1823
 
            else:
1824
 
                found_verb = True
1825
 
                break
1826
 
        if not found_verb:
1827
 
            # Have to use VFS.
1828
 
            return self._insert_real(stream, src_format, resume_tokens)
1829
 
        self._last_inv_record = None
1830
 
        self._last_substream = None
1831
 
        if required_version < (1, 19):
1832
 
            # Remote side doesn't support inventory deltas.  Wrap the stream to
1833
 
            # make sure we don't send any.  If the stream contains inventory
1834
 
            # deltas we'll interrupt the smart insert_stream request and
1835
 
            # fallback to VFS.
1836
 
            stream = self._stop_stream_if_inventory_delta(stream)
 
1611
                return self._insert_real(stream, src_format, resume_tokens)
1837
1612
        byte_stream = smart_repo._stream_to_byte_stream(
1838
1613
            stream, src_format)
1839
1614
        resume_tokens = ' '.join(resume_tokens)
1840
1615
        response = client.call_with_body_stream(
1841
 
            (verb, path, resume_tokens) + lock_args, byte_stream)
 
1616
            (verb, path, resume_tokens) + extra_args, byte_stream)
1842
1617
        if response[0][0] not in ('ok', 'missing-basis'):
1843
1618
            raise errors.UnexpectedSmartServerResponse(response)
1844
 
        if self._last_substream is not None:
1845
 
            # The stream included an inventory-delta record, but the remote
1846
 
            # side isn't new enough to support them.  So we need to send the
1847
 
            # rest of the stream via VFS.
1848
 
            self.target_repo.refresh_data()
1849
 
            return self._resume_stream_with_vfs(response, src_format)
1850
1619
        if response[0][0] == 'missing-basis':
1851
1620
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1852
1621
            resume_tokens = tokens
1853
 
            return resume_tokens, set(missing_keys)
 
1622
            return resume_tokens, missing_keys
1854
1623
        else:
1855
1624
            self.target_repo.refresh_data()
1856
1625
            return [], set()
1857
1626
 
1858
 
    def _resume_stream_with_vfs(self, response, src_format):
1859
 
        """Resume sending a stream via VFS, first resending the record and
1860
 
        substream that couldn't be sent via an insert_stream verb.
1861
 
        """
1862
 
        if response[0][0] == 'missing-basis':
1863
 
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1864
 
            # Ignore missing_keys, we haven't finished inserting yet
1865
 
        else:
1866
 
            tokens = []
1867
 
        def resume_substream():
1868
 
            # Yield the substream that was interrupted.
1869
 
            for record in self._last_substream:
1870
 
                yield record
1871
 
            self._last_substream = None
1872
 
        def resume_stream():
1873
 
            # Finish sending the interrupted substream
1874
 
            yield ('inventory-deltas', resume_substream())
1875
 
            # Then simply continue sending the rest of the stream.
1876
 
            for substream_kind, substream in self._last_stream:
1877
 
                yield substream_kind, substream
1878
 
        return self._insert_real(resume_stream(), src_format, tokens)
1879
 
 
1880
 
    def _stop_stream_if_inventory_delta(self, stream):
1881
 
        """Normally this just lets the original stream pass-through unchanged.
1882
 
 
1883
 
        However if any 'inventory-deltas' substream occurs it will stop
1884
 
        streaming, and store the interrupted substream and stream in
1885
 
        self._last_substream and self._last_stream so that the stream can be
1886
 
        resumed by _resume_stream_with_vfs.
1887
 
        """
1888
 
                    
1889
 
        stream_iter = iter(stream)
1890
 
        for substream_kind, substream in stream_iter:
1891
 
            if substream_kind == 'inventory-deltas':
1892
 
                self._last_substream = substream
1893
 
                self._last_stream = stream_iter
1894
 
                return
1895
 
            else:
1896
 
                yield substream_kind, substream
1897
 
            
1898
1627
 
1899
1628
class RemoteStreamSource(repository.StreamSource):
1900
1629
    """Stream data from a remote server."""
1903
1632
        if (self.from_repository._fallback_repositories and
1904
1633
            self.to_format._fetch_order == 'topological'):
1905
1634
            return self._real_stream(self.from_repository, search)
1906
 
        sources = []
1907
 
        seen = set()
1908
 
        repos = [self.from_repository]
1909
 
        while repos:
1910
 
            repo = repos.pop(0)
1911
 
            if repo in seen:
1912
 
                continue
1913
 
            seen.add(repo)
1914
 
            repos.extend(repo._fallback_repositories)
1915
 
            sources.append(repo)
1916
 
        return self.missing_parents_chain(search, sources)
1917
 
 
1918
 
    def get_stream_for_missing_keys(self, missing_keys):
1919
 
        self.from_repository._ensure_real()
1920
 
        real_repo = self.from_repository._real_repository
1921
 
        real_source = real_repo._get_source(self.to_format)
1922
 
        return real_source.get_stream_for_missing_keys(missing_keys)
 
1635
        return self.missing_parents_chain(search, [self.from_repository] +
 
1636
            self.from_repository._fallback_repositories)
1923
1637
 
1924
1638
    def _real_stream(self, repo, search):
1925
1639
        """Get a stream for search from repo.
1932
1646
        """
1933
1647
        source = repo._get_source(self.to_format)
1934
1648
        if isinstance(source, RemoteStreamSource):
1935
 
            repo._ensure_real()
1936
 
            source = repo._real_repository._get_source(self.to_format)
 
1649
            return repository.StreamSource.get_stream(source, search)
1937
1650
        return source.get_stream(search)
1938
1651
 
1939
1652
    def _get_stream(self, repo, search):
1956
1669
            return self._real_stream(repo, search)
1957
1670
        client = repo._client
1958
1671
        medium = client._medium
 
1672
        if medium._is_remote_before((1, 13)):
 
1673
            # streaming was added in 1.13
 
1674
            return self._real_stream(repo, search)
1959
1675
        path = repo.bzrdir._path_for_remote_call(client)
1960
 
        search_bytes = repo._serialise_search_result(search)
1961
 
        args = (path, self.to_format.network_name())
1962
 
        candidate_verbs = [
1963
 
            ('Repository.get_stream_1.19', (1, 19)),
1964
 
            ('Repository.get_stream', (1, 13))]
1965
 
        found_verb = False
1966
 
        for verb, version in candidate_verbs:
1967
 
            if medium._is_remote_before(version):
1968
 
                continue
1969
 
            try:
1970
 
                response = repo._call_with_body_bytes_expecting_body(
1971
 
                    verb, args, search_bytes)
1972
 
            except errors.UnknownSmartMethod:
1973
 
                medium._remember_remote_is_before(version)
1974
 
            else:
1975
 
                response_tuple, response_handler = response
1976
 
                found_verb = True
1977
 
                break
1978
 
        if not found_verb:
 
1676
        try:
 
1677
            search_bytes = repo._serialise_search_result(search)
 
1678
            response = repo._call_with_body_bytes_expecting_body(
 
1679
                'Repository.get_stream',
 
1680
                (path, self.to_format.network_name()), search_bytes)
 
1681
            response_tuple, response_handler = response
 
1682
        except errors.UnknownSmartMethod:
 
1683
            medium._remember_remote_is_before((1,13))
1979
1684
            return self._real_stream(repo, search)
1980
1685
        if response_tuple[0] != 'ok':
1981
1686
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1982
1687
        byte_stream = response_handler.read_streamed_body()
1983
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
1984
 
            self._record_counter)
 
1688
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1985
1689
        if src_format.network_name() != repo._format.network_name():
1986
1690
            raise AssertionError(
1987
1691
                "Mismatched RemoteRepository and stream src %r, %r" % (
1994
1698
        :param search: The overall search to satisfy with streams.
1995
1699
        :param sources: A list of Repository objects to query.
1996
1700
        """
1997
 
        self.from_serialiser = self.from_repository._format._serializer
 
1701
        self.serialiser = self.to_format._serializer
1998
1702
        self.seen_revs = set()
1999
1703
        self.referenced_revs = set()
2000
1704
        # If there are heads in the search, or the key count is > 0, we are not
2017
1721
    def missing_parents_rev_handler(self, substream):
2018
1722
        for content in substream:
2019
1723
            revision_bytes = content.get_bytes_as('fulltext')
2020
 
            revision = self.from_serialiser.read_revision_from_string(
2021
 
                revision_bytes)
 
1724
            revision = self.serialiser.read_revision_from_string(revision_bytes)
2022
1725
            self.seen_revs.add(content.key[-1])
2023
1726
            self.referenced_revs.update(revision.parent_ids)
2024
1727
            yield content
2063
1766
                self._network_name)
2064
1767
 
2065
1768
    def get_format_description(self):
2066
 
        self._ensure_real()
2067
 
        return 'Remote: ' + self._custom_format.get_format_description()
 
1769
        return 'Remote BZR Branch'
2068
1770
 
2069
1771
    def network_name(self):
2070
1772
        return self._network_name
2071
1773
 
2072
 
    def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2073
 
        return a_bzrdir.open_branch(name=name, 
2074
 
            ignore_fallbacks=ignore_fallbacks)
 
1774
    def open(self, a_bzrdir, ignore_fallbacks=False):
 
1775
        return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
2075
1776
 
2076
 
    def _vfs_initialize(self, a_bzrdir, name):
 
1777
    def _vfs_initialize(self, a_bzrdir):
2077
1778
        # Initialisation when using a local bzrdir object, or a non-vfs init
2078
1779
        # method is not available on the server.
2079
1780
        # self._custom_format is always set - the start of initialize ensures
2080
1781
        # that.
2081
1782
        if isinstance(a_bzrdir, RemoteBzrDir):
2082
1783
            a_bzrdir._ensure_real()
2083
 
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2084
 
                name)
 
1784
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
2085
1785
        else:
2086
1786
            # We assume the bzrdir is parameterised; it may not be.
2087
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
1787
            result = self._custom_format.initialize(a_bzrdir)
2088
1788
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2089
1789
            not isinstance(result, RemoteBranch)):
2090
 
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2091
 
                                  name=name)
 
1790
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
2092
1791
        return result
2093
1792
 
2094
 
    def initialize(self, a_bzrdir, name=None):
 
1793
    def initialize(self, a_bzrdir):
2095
1794
        # 1) get the network name to use.
2096
1795
        if self._custom_format:
2097
1796
            network_name = self._custom_format.network_name()
2103
1802
            network_name = reference_format.network_name()
2104
1803
        # Being asked to create on a non RemoteBzrDir:
2105
1804
        if not isinstance(a_bzrdir, RemoteBzrDir):
2106
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
1805
            return self._vfs_initialize(a_bzrdir)
2107
1806
        medium = a_bzrdir._client._medium
2108
1807
        if medium._is_remote_before((1, 13)):
2109
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
1808
            return self._vfs_initialize(a_bzrdir)
2110
1809
        # Creating on a remote bzr dir.
2111
1810
        # 2) try direct creation via RPC
2112
1811
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2113
 
        if name is not None:
2114
 
            # XXX JRV20100304: Support creating colocated branches
2115
 
            raise errors.NoColocatedBranchSupport(self)
2116
1812
        verb = 'BzrDir.create_branch'
2117
1813
        try:
2118
1814
            response = a_bzrdir._call(verb, path, network_name)
2119
1815
        except errors.UnknownSmartMethod:
2120
1816
            # Fallback - use vfs methods
2121
1817
            medium._remember_remote_is_before((1, 13))
2122
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
1818
            return self._vfs_initialize(a_bzrdir)
2123
1819
        if response[0] != 'ok':
2124
1820
            raise errors.UnexpectedSmartServerResponse(response)
2125
1821
        # Turn the response into a RemoteRepository object.
2133
1829
                a_bzrdir._client)
2134
1830
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2135
1831
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2136
 
            format=format, setup_stacking=False, name=name)
 
1832
            format=format, setup_stacking=False)
2137
1833
        # XXX: We know this is a new branch, so it must have revno 0, revid
2138
1834
        # NULL_REVISION. Creating the branch locked would make this be unable
2139
1835
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2154
1850
        self._ensure_real()
2155
1851
        return self._custom_format.supports_stacking()
2156
1852
 
2157
 
    def supports_set_append_revisions_only(self):
2158
 
        self._ensure_real()
2159
 
        return self._custom_format.supports_set_append_revisions_only()
2160
 
 
2161
 
 
2162
 
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
 
1853
 
 
1854
class RemoteBranch(branch.Branch, _RpcHelper):
2163
1855
    """Branch stored on a server accessed by HPSS RPC.
2164
1856
 
2165
1857
    At the moment most operations are mapped down to simple file operations.
2166
1858
    """
2167
1859
 
2168
1860
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2169
 
        _client=None, format=None, setup_stacking=True, name=None):
 
1861
        _client=None, format=None, setup_stacking=True):
2170
1862
        """Create a RemoteBranch instance.
2171
1863
 
2172
1864
        :param real_branch: An optional local implementation of the branch
2178
1870
        :param setup_stacking: If True make an RPC call to determine the
2179
1871
            stacked (or not) status of the branch. If False assume the branch
2180
1872
            is not stacked.
2181
 
        :param name: Colocated branch name
2182
1873
        """
2183
1874
        # We intentionally don't call the parent class's __init__, because it
2184
1875
        # will try to assign to self.tags, which is a property in this subclass.
2185
1876
        # And the parent's __init__ doesn't do much anyway.
 
1877
        self._revision_id_to_revno_cache = None
 
1878
        self._partial_revision_id_to_revno_cache = {}
 
1879
        self._revision_history_cache = None
 
1880
        self._last_revision_info_cache = None
 
1881
        self._merge_sorted_revisions_cache = None
2186
1882
        self.bzrdir = remote_bzrdir
2187
1883
        if _client is not None:
2188
1884
            self._client = _client
2201
1897
            self._real_branch.repository = self.repository
2202
1898
        else:
2203
1899
            self._real_branch = None
2204
 
        # Fill out expected attributes of branch for bzrlib API users.
2205
 
        self._clear_cached_state()
2206
 
        # TODO: deprecate self.base in favor of user_url
2207
 
        self.base = self.bzrdir.user_url
2208
 
        self._name = name
 
1900
        # Fill out expected attributes of branch for bzrlib api users.
 
1901
        self.base = self.bzrdir.root_transport.base
2209
1902
        self._control_files = None
2210
1903
        self._lock_mode = None
2211
1904
        self._lock_token = None
2222
1915
                    self._real_branch._format.network_name()
2223
1916
        else:
2224
1917
            self._format = format
2225
 
        # when we do _ensure_real we may need to pass ignore_fallbacks to the
2226
 
        # branch.open_branch method.
2227
 
        self._real_ignore_fallbacks = not setup_stacking
2228
1918
        if not self._format._network_name:
2229
1919
            # Did not get from open_branchV2 - old server.
2230
1920
            self._ensure_real()
2235
1925
        hooks = branch.Branch.hooks['open']
2236
1926
        for hook in hooks:
2237
1927
            hook(self)
2238
 
        self._is_stacked = False
2239
1928
        if setup_stacking:
2240
1929
            self._setup_stacking()
2241
1930
 
2247
1936
        except (errors.NotStacked, errors.UnstackableBranchFormat,
2248
1937
            errors.UnstackableRepositoryFormat), e:
2249
1938
            return
2250
 
        self._is_stacked = True
2251
1939
        self._activate_fallback_location(fallback_url)
2252
1940
 
2253
1941
    def _get_config(self):
2275
1963
                raise AssertionError('smart server vfs must be enabled '
2276
1964
                    'to use vfs implementation')
2277
1965
            self.bzrdir._ensure_real()
2278
 
            self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2279
 
                ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
 
1966
            self._real_branch = self.bzrdir._real_bzrdir.open_branch()
2280
1967
            if self.repository._real_repository is None:
2281
1968
                # Give the remote repository the matching real repo.
2282
1969
                real_repo = self._real_branch.repository
2356
2043
            raise errors.UnexpectedSmartServerResponse(response)
2357
2044
        return response[1]
2358
2045
 
2359
 
    def set_stacked_on_url(self, url):
2360
 
        branch.Branch.set_stacked_on_url(self, url)
2361
 
        if not url:
2362
 
            self._is_stacked = False
2363
 
        else:
2364
 
            self._is_stacked = True
2365
 
        
2366
2046
    def _vfs_get_tags_bytes(self):
2367
2047
        self._ensure_real()
2368
2048
        return self._real_branch._get_tags_bytes()
2378
2058
            return self._vfs_get_tags_bytes()
2379
2059
        return response[0]
2380
2060
 
2381
 
    def _vfs_set_tags_bytes(self, bytes):
2382
 
        self._ensure_real()
2383
 
        return self._real_branch._set_tags_bytes(bytes)
2384
 
 
2385
 
    def _set_tags_bytes(self, bytes):
2386
 
        medium = self._client._medium
2387
 
        if medium._is_remote_before((1, 18)):
2388
 
            self._vfs_set_tags_bytes(bytes)
2389
 
            return
2390
 
        try:
2391
 
            args = (
2392
 
                self._remote_path(), self._lock_token, self._repo_lock_token)
2393
 
            response = self._call_with_body_bytes(
2394
 
                'Branch.set_tags_bytes', args, bytes)
2395
 
        except errors.UnknownSmartMethod:
2396
 
            medium._remember_remote_is_before((1, 18))
2397
 
            self._vfs_set_tags_bytes(bytes)
2398
 
 
2399
2061
    def lock_read(self):
2400
 
        """Lock the branch for read operations.
2401
 
 
2402
 
        :return: A bzrlib.lock.LogicalLockResult.
2403
 
        """
2404
2062
        self.repository.lock_read()
2405
2063
        if not self._lock_mode:
2406
 
            self._note_lock('r')
2407
2064
            self._lock_mode = 'r'
2408
2065
            self._lock_count = 1
2409
2066
            if self._real_branch is not None:
2410
2067
                self._real_branch.lock_read()
2411
2068
        else:
2412
2069
            self._lock_count += 1
2413
 
        return lock.LogicalLockResult(self.unlock)
2414
2070
 
2415
2071
    def _remote_lock_write(self, token):
2416
2072
        if token is None:
2417
2073
            branch_token = repo_token = ''
2418
2074
        else:
2419
2075
            branch_token = token
2420
 
            repo_token = self.repository.lock_write().repository_token
 
2076
            repo_token = self.repository.lock_write()
2421
2077
            self.repository.unlock()
2422
2078
        err_context = {'token': token}
2423
2079
        response = self._call(
2430
2086
 
2431
2087
    def lock_write(self, token=None):
2432
2088
        if not self._lock_mode:
2433
 
            self._note_lock('w')
2434
2089
            # Lock the branch and repo in one remote call.
2435
2090
            remote_tokens = self._remote_lock_write(token)
2436
2091
            self._lock_token, self._repo_lock_token = remote_tokens
2449
2104
            self._lock_mode = 'w'
2450
2105
            self._lock_count = 1
2451
2106
        elif self._lock_mode == 'r':
2452
 
            raise errors.ReadOnlyError(self)
 
2107
            raise errors.ReadOnlyTransaction
2453
2108
        else:
2454
2109
            if token is not None:
2455
2110
                # A token was given to lock_write, and we're relocking, so
2460
2115
            self._lock_count += 1
2461
2116
            # Re-lock the repository too.
2462
2117
            self.repository.lock_write(self._repo_lock_token)
2463
 
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
 
2118
        return self._lock_token or None
 
2119
 
 
2120
    def _set_tags_bytes(self, bytes):
 
2121
        self._ensure_real()
 
2122
        return self._real_branch._set_tags_bytes(bytes)
2464
2123
 
2465
2124
    def _unlock(self, branch_token, repo_token):
2466
2125
        err_context = {'token': str((branch_token, repo_token))}
2471
2130
            return
2472
2131
        raise errors.UnexpectedSmartServerResponse(response)
2473
2132
 
2474
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2475
2133
    def unlock(self):
2476
2134
        try:
2477
2135
            self._lock_count -= 1
2490
2148
                    self._real_branch.unlock()
2491
2149
                if mode != 'w':
2492
2150
                    # Only write-locked branched need to make a remote method
2493
 
                    # call to perform the unlock.
 
2151
                    # call to perfom the unlock.
2494
2152
                    return
2495
2153
                if not self._lock_token:
2496
2154
                    raise AssertionError('Locked, but no token!')
2517
2175
            raise NotImplementedError(self.dont_leave_lock_in_place)
2518
2176
        self._leave_lock = False
2519
2177
 
2520
 
    @needs_read_lock
2521
 
    def get_rev_id(self, revno, history=None):
2522
 
        if revno == 0:
2523
 
            return _mod_revision.NULL_REVISION
2524
 
        last_revision_info = self.last_revision_info()
2525
 
        ok, result = self.repository.get_rev_id_for_revno(
2526
 
            revno, last_revision_info)
2527
 
        if ok:
2528
 
            return result
2529
 
        missing_parent = result[1]
2530
 
        # Either the revision named by the server is missing, or its parent
2531
 
        # is.  Call get_parent_map to determine which, so that we report a
2532
 
        # useful error.
2533
 
        parent_map = self.repository.get_parent_map([missing_parent])
2534
 
        if missing_parent in parent_map:
2535
 
            missing_parent = parent_map[missing_parent]
2536
 
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2537
 
 
2538
2178
    def _last_revision_info(self):
2539
2179
        response = self._call('Branch.last_revision_info', self._remote_path())
2540
2180
        if response[0] != 'ok':
2545
2185
 
2546
2186
    def _gen_revision_history(self):
2547
2187
        """See Branch._gen_revision_history()."""
2548
 
        if self._is_stacked:
2549
 
            self._ensure_real()
2550
 
            return self._real_branch._gen_revision_history()
2551
2188
        response_tuple, response_handler = self._call_expecting_body(
2552
2189
            'Branch.revision_history', self._remote_path())
2553
2190
        if response_tuple[0] != 'ok':
2638
2275
        self._ensure_real()
2639
2276
        return self._real_branch._get_parent_location()
2640
2277
 
 
2278
    def set_parent(self, url):
 
2279
        self._ensure_real()
 
2280
        return self._real_branch.set_parent(url)
 
2281
 
2641
2282
    def _set_parent_location(self, url):
2642
 
        medium = self._client._medium
2643
 
        if medium._is_remote_before((1, 15)):
2644
 
            return self._vfs_set_parent_location(url)
2645
 
        try:
2646
 
            call_url = url or ''
2647
 
            if type(call_url) is not str:
2648
 
                raise AssertionError('url must be a str or None (%s)' % url)
2649
 
            response = self._call('Branch.set_parent_location',
2650
 
                self._remote_path(), self._lock_token, self._repo_lock_token,
2651
 
                call_url)
2652
 
        except errors.UnknownSmartMethod:
2653
 
            medium._remember_remote_is_before((1, 15))
2654
 
            return self._vfs_set_parent_location(url)
2655
 
        if response != ():
2656
 
            raise errors.UnexpectedSmartServerResponse(response)
2657
 
 
2658
 
    def _vfs_set_parent_location(self, url):
2659
 
        self._ensure_real()
2660
 
        return self._real_branch._set_parent_location(url)
 
2283
        # Used by tests, to poke bad urls into branch configurations
 
2284
        if url is None:
 
2285
            self.set_parent(url)
 
2286
        else:
 
2287
            self._ensure_real()
 
2288
            return self._real_branch._set_parent_location(url)
2661
2289
 
2662
2290
    @needs_write_lock
2663
2291
    def pull(self, source, overwrite=False, stop_revision=None,
2731
2359
        return self._real_branch.set_push_location(location)
2732
2360
 
2733
2361
 
2734
 
class RemoteConfig(object):
2735
 
    """A Config that reads and writes from smart verbs.
 
2362
class RemoteBranchConfig(object):
 
2363
    """A Config that reads from a smart branch and writes via smart methods.
2736
2364
 
2737
2365
    It is a low-level object that considers config data to be name/value pairs
2738
2366
    that may be associated with a section. Assigning meaning to the these
2739
2367
    values is done at higher levels like bzrlib.config.TreeConfig.
2740
2368
    """
2741
2369
 
 
2370
    def __init__(self, branch):
 
2371
        self._branch = branch
 
2372
 
2742
2373
    def get_option(self, name, section=None, default=None):
2743
2374
        """Return the value associated with a named option.
2744
2375
 
2747
2378
        :param default: The value to return if the value is not set
2748
2379
        :return: The value or default value
2749
2380
        """
2750
 
        try:
2751
 
            configobj = self._get_configobj()
2752
 
            if section is None:
2753
 
                section_obj = configobj
2754
 
            else:
2755
 
                try:
2756
 
                    section_obj = configobj[section]
2757
 
                except KeyError:
2758
 
                    return default
2759
 
            return section_obj.get(name, default)
2760
 
        except errors.UnknownSmartMethod:
2761
 
            return self._vfs_get_option(name, section, default)
2762
 
 
2763
 
    def _response_to_configobj(self, response):
2764
 
        if len(response[0]) and response[0][0] != 'ok':
2765
 
            raise errors.UnexpectedSmartServerResponse(response)
2766
 
        lines = response[1].read_body_bytes().splitlines()
2767
 
        return config.ConfigObj(lines, encoding='utf-8')
2768
 
 
2769
 
 
2770
 
class RemoteBranchConfig(RemoteConfig):
2771
 
    """A RemoteConfig for Branches."""
2772
 
 
2773
 
    def __init__(self, branch):
2774
 
        self._branch = branch
 
2381
        configobj = self._get_configobj()
 
2382
        if section is None:
 
2383
            section_obj = configobj
 
2384
        else:
 
2385
            try:
 
2386
                section_obj = configobj[section]
 
2387
            except KeyError:
 
2388
                return default
 
2389
        return section_obj.get(name, default)
2775
2390
 
2776
2391
    def _get_configobj(self):
2777
 
        path = self._branch._remote_path()
 
2392
        path = self._branch.bzrdir._path_for_remote_call(
 
2393
            self._branch._client)
2778
2394
        response = self._branch._client.call_expecting_body(
2779
2395
            'Branch.get_config_file', path)
2780
 
        return self._response_to_configobj(response)
 
2396
        if response[0][0] != 'ok':
 
2397
            raise UnexpectedSmartServerResponse(response)
 
2398
        bytes = response[1].read_body_bytes()
 
2399
        return config.ConfigObj([bytes], encoding='utf-8')
2781
2400
 
2782
2401
    def set_option(self, value, name, section=None):
2783
2402
        """Set the value associated with a named option.
2786
2405
        :param name: The name of the value to set
2787
2406
        :param section: The section the option is in (if any)
2788
2407
        """
2789
 
        medium = self._branch._client._medium
2790
 
        if medium._is_remote_before((1, 14)):
2791
 
            return self._vfs_set_option(value, name, section)
2792
 
        if isinstance(value, dict):
2793
 
            if medium._is_remote_before((2, 2)):
2794
 
                return self._vfs_set_option(value, name, section)
2795
 
            return self._set_config_option_dict(value, name, section)
2796
 
        else:
2797
 
            return self._set_config_option(value, name, section)
2798
 
 
2799
 
    def _set_config_option(self, value, name, section):
2800
 
        try:
2801
 
            path = self._branch._remote_path()
2802
 
            response = self._branch._client.call('Branch.set_config_option',
2803
 
                path, self._branch._lock_token, self._branch._repo_lock_token,
2804
 
                value.encode('utf8'), name, section or '')
2805
 
        except errors.UnknownSmartMethod:
2806
 
            medium = self._branch._client._medium
2807
 
            medium._remember_remote_is_before((1, 14))
2808
 
            return self._vfs_set_option(value, name, section)
2809
 
        if response != ():
2810
 
            raise errors.UnexpectedSmartServerResponse(response)
2811
 
 
2812
 
    def _serialize_option_dict(self, option_dict):
2813
 
        utf8_dict = {}
2814
 
        for key, value in option_dict.items():
2815
 
            if isinstance(key, unicode):
2816
 
                key = key.encode('utf8')
2817
 
            if isinstance(value, unicode):
2818
 
                value = value.encode('utf8')
2819
 
            utf8_dict[key] = value
2820
 
        return bencode.bencode(utf8_dict)
2821
 
 
2822
 
    def _set_config_option_dict(self, value, name, section):
2823
 
        try:
2824
 
            path = self._branch._remote_path()
2825
 
            serialised_dict = self._serialize_option_dict(value)
2826
 
            response = self._branch._client.call(
2827
 
                'Branch.set_config_option_dict',
2828
 
                path, self._branch._lock_token, self._branch._repo_lock_token,
2829
 
                serialised_dict, name, section or '')
2830
 
        except errors.UnknownSmartMethod:
2831
 
            medium = self._branch._client._medium
2832
 
            medium._remember_remote_is_before((2, 2))
2833
 
            return self._vfs_set_option(value, name, section)
2834
 
        if response != ():
2835
 
            raise errors.UnexpectedSmartServerResponse(response)
2836
 
 
2837
 
    def _real_object(self):
 
2408
        return self._vfs_set_option(value, name, section)
 
2409
 
 
2410
    def _vfs_set_option(self, value, name, section=None):
2838
2411
        self._branch._ensure_real()
2839
 
        return self._branch._real_branch
2840
 
 
2841
 
    def _vfs_set_option(self, value, name, section=None):
2842
 
        return self._real_object()._get_config().set_option(
2843
 
            value, name, section)
2844
 
 
2845
 
 
2846
 
class RemoteBzrDirConfig(RemoteConfig):
2847
 
    """A RemoteConfig for BzrDirs."""
2848
 
 
2849
 
    def __init__(self, bzrdir):
2850
 
        self._bzrdir = bzrdir
2851
 
 
2852
 
    def _get_configobj(self):
2853
 
        medium = self._bzrdir._client._medium
2854
 
        verb = 'BzrDir.get_config_file'
2855
 
        if medium._is_remote_before((1, 15)):
2856
 
            raise errors.UnknownSmartMethod(verb)
2857
 
        path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
2858
 
        response = self._bzrdir._call_expecting_body(
2859
 
            verb, path)
2860
 
        return self._response_to_configobj(response)
2861
 
 
2862
 
    def _vfs_get_option(self, name, section, default):
2863
 
        return self._real_object()._get_config().get_option(
2864
 
            name, section, default)
2865
 
 
2866
 
    def set_option(self, value, name, section=None):
2867
 
        """Set the value associated with a named option.
2868
 
 
2869
 
        :param value: The value to set
2870
 
        :param name: The name of the value to set
2871
 
        :param section: The section the option is in (if any)
2872
 
        """
2873
 
        return self._real_object()._get_config().set_option(
2874
 
            value, name, section)
2875
 
 
2876
 
    def _real_object(self):
2877
 
        self._bzrdir._ensure_real()
2878
 
        return self._bzrdir._real_bzrdir
2879
 
 
 
2412
        return self._branch._real_branch._get_config().set_option(
 
2413
            value, name, section)
2880
2414
 
2881
2415
 
2882
2416
def _extract_tar(tar, to_dir):
2922
2456
                    'Missing key %r in context %r', key_err.args[0], context)
2923
2457
                raise err
2924
2458
 
2925
 
    if err.error_verb == 'IncompatibleRepositories':
2926
 
        raise errors.IncompatibleRepositories(err.error_args[0],
2927
 
            err.error_args[1], err.error_args[2])
2928
 
    elif err.error_verb == 'NoSuchRevision':
 
2459
    if err.error_verb == 'NoSuchRevision':
2929
2460
        raise NoSuchRevision(find('branch'), err.error_args[0])
2930
2461
    elif err.error_verb == 'nosuchrevision':
2931
2462
        raise NoSuchRevision(find('repository'), err.error_args[0])
2932
 
    elif err.error_verb == 'nobranch':
2933
 
        if len(err.error_args) >= 1:
2934
 
            extra = err.error_args[0]
2935
 
        else:
2936
 
            extra = None
2937
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
2938
 
            detail=extra)
 
2463
    elif err.error_tuple == ('nobranch',):
 
2464
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
2939
2465
    elif err.error_verb == 'norepository':
2940
2466
        raise errors.NoRepositoryPresent(find('bzrdir'))
2941
2467
    elif err.error_verb == 'LockContention':