← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Jelmer Vernooij
  • Date: 2009-04-06 02:54:14 UTC
  • mfrom: (4253 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4255.
  • Revision ID: jelmer@samba.org-20090406025414-65tpjwcmjp5wa5oj
Merge bzr.dev.

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