/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: Eric Siegerman
  • Date: 2009-03-25 16:53:14 UTC
  • mto: (4204.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 4205.
  • Revision ID: pub08@davor.org-20090325165314-1n3wv0ig2knf44xx
Another broken link.

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
 
    config,
24
25
    debug,
25
26
    errors,
26
27
    graph,
27
 
    lock,
28
28
    lockdir,
 
29
    pack,
29
30
    repository,
30
 
    repository as _mod_repository,
31
31
    revision,
32
 
    revision as _mod_revision,
33
 
    static_tuple,
34
32
    symbol_versioning,
 
33
    urlutils,
35
34
)
36
 
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
 
35
from bzrlib.branch import BranchReferenceFormat
37
36
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
38
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
 
37
from bzrlib.decorators import needs_read_lock, needs_write_lock
39
38
from bzrlib.errors import (
40
39
    NoSuchRevision,
41
40
    SmartProtocolError,
43
42
from bzrlib.lockable_files import LockableFiles
44
43
from bzrlib.smart import client, vfs, repository as smart_repo
45
44
from bzrlib.revision import ensure_null, NULL_REVISION
46
 
from bzrlib.repository import RepositoryWriteLockResult
47
45
from bzrlib.trace import mutter, note, warning
 
46
from bzrlib.util import bencode
48
47
 
49
48
 
50
49
class _RpcHelper(object):
62
61
        except errors.ErrorFromSmartServer, err:
63
62
            self._translate_error(err, **err_context)
64
63
 
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
64
    def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
72
65
                                             **err_context):
73
66
        try:
92
85
class RemoteBzrDir(BzrDir, _RpcHelper):
93
86
    """Control directory on a remote server, accessed via bzr:// or similar."""
94
87
 
95
 
    def __init__(self, transport, format, _client=None, _force_probe=False):
 
88
    def __init__(self, transport, format, _client=None):
96
89
        """Construct a RemoteBzrDir.
97
90
 
98
91
        :param _client: Private parameter for testing. Disables probing and the
102
95
        # this object holds a delegated bzrdir that uses file-level operations
103
96
        # to talk to the other side
104
97
        self._real_bzrdir = None
105
 
        self._has_working_tree = None
106
98
        # 1-shot cache for the call pattern 'create_branch; open_branch' - see
107
99
        # create_branch for details.
108
100
        self._next_open_branch_result = None
112
104
            self._client = client._SmartClient(medium)
113
105
        else:
114
106
            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
 
107
            return
 
108
 
125
109
        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
110
        response = self._call('BzrDir.open', path)
152
111
        if response not in [('yes',), ('no',)]:
153
112
            raise errors.UnexpectedSmartServerResponse(response)
154
113
        if response == ('no',):
155
 
            raise errors.NotBranchError(path=self.root_transport.base)
 
114
            raise errors.NotBranchError(path=transport.base)
156
115
 
157
116
    def _ensure_real(self):
158
117
        """Ensure that there is a _real_bzrdir set.
160
119
        Used before calls to self._real_bzrdir.
161
120
        """
162
121
        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
122
            self._real_bzrdir = BzrDir.open_from_transport(
168
123
                self.root_transport, _server_formats=False)
169
124
            self._format._network_name = \
245
200
        self._ensure_real()
246
201
        self._real_bzrdir.destroy_repository()
247
202
 
248
 
    def create_branch(self, name=None):
 
203
    def create_branch(self):
249
204
        # as per meta1 formats - just delegate to the format object which may
250
205
        # be parameterised.
251
 
        real_branch = self._format.get_branch_format().initialize(self,
252
 
            name=name)
 
206
        real_branch = self._format.get_branch_format().initialize(self)
253
207
        if not isinstance(real_branch, RemoteBranch):
254
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
255
 
                                  name=name)
 
208
            result = RemoteBranch(self, self.find_repository(), real_branch)
256
209
        else:
257
210
            result = real_branch
258
211
        # BzrDir.clone_on_transport() uses the result of create_branch but does
264
217
        self._next_open_branch_result = result
265
218
        return result
266
219
 
267
 
    def destroy_branch(self, name=None):
 
220
    def destroy_branch(self):
268
221
        """See BzrDir.destroy_branch"""
269
222
        self._ensure_real()
270
 
        self._real_bzrdir.destroy_branch(name=name)
 
223
        self._real_bzrdir.destroy_branch()
271
224
        self._next_open_branch_result = None
272
225
 
273
226
    def create_workingtree(self, revision_id=None, from_branch=None):
274
227
        raise errors.NotLocalUrl(self.transport.base)
275
228
 
276
 
    def find_branch_format(self, name=None):
 
229
    def find_branch_format(self):
277
230
        """Find the branch 'format' for this bzrdir.
278
231
 
279
232
        This might be a synthetic object for e.g. RemoteBranch and SVN.
280
233
        """
281
 
        b = self.open_branch(name=name)
 
234
        b = self.open_branch()
282
235
        return b._format
283
236
 
284
 
    def get_branch_reference(self, name=None):
 
237
    def get_branch_reference(self):
285
238
        """See BzrDir.get_branch_reference()."""
286
 
        if name is not None:
287
 
            # XXX JRV20100304: Support opening colocated branches
288
 
            raise errors.NoColocatedBranchSupport(self)
289
239
        response = self._get_branch_reference()
290
240
        if response[0] == 'ref':
291
241
            return response[1]
295
245
    def _get_branch_reference(self):
296
246
        path = self._path_for_remote_call(self._client)
297
247
        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
 
248
        if not medium._is_remote_before((1, 13)):
306
249
            try:
307
 
                response = self._call(verb, path)
 
250
                response = self._call('BzrDir.open_branchV2', path)
 
251
                if response[0] not in ('ref', 'branch'):
 
252
                    raise errors.UnexpectedSmartServerResponse(response)
 
253
                return response
308
254
            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'):
 
255
                medium._remember_remote_is_before((1, 13))
 
256
        response = self._call('BzrDir.open_branch', path)
 
257
        if response[0] != 'ok':
322
258
            raise errors.UnexpectedSmartServerResponse(response)
323
 
        return response
 
259
        if response[1] != '':
 
260
            return ('ref', response[1])
 
261
        else:
 
262
            return ('branch', '')
324
263
 
325
 
    def _get_tree_branch(self, name=None):
 
264
    def _get_tree_branch(self):
326
265
        """See BzrDir._get_tree_branch()."""
327
 
        return None, self.open_branch(name=name)
 
266
        return None, self.open_branch()
328
267
 
329
 
    def open_branch(self, name=None, unsupported=False,
330
 
                    ignore_fallbacks=False):
331
 
        if unsupported:
 
268
    def open_branch(self, _unsupported=False, ignore_fallbacks=False):
 
269
        if _unsupported:
332
270
            raise NotImplementedError('unsupported flag support not implemented yet.')
333
271
        if self._next_open_branch_result is not None:
334
272
            # See create_branch for details.
339
277
        if response[0] == 'ref':
340
278
            # a branch reference, use the existing BranchReference logic.
341
279
            format = BranchReferenceFormat()
342
 
            return format.open(self, name=name, _found=True,
343
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
 
280
            return format.open(self, _found=True, location=response[1],
 
281
                ignore_fallbacks=ignore_fallbacks)
344
282
        branch_format_name = response[1]
345
283
        if not branch_format_name:
346
284
            branch_format_name = None
347
285
        format = RemoteBranchFormat(network_name=branch_format_name)
348
286
        return RemoteBranch(self, self.find_repository(), format=format,
349
 
            setup_stacking=not ignore_fallbacks, name=name)
 
287
            setup_stacking=not ignore_fallbacks)
350
288
 
351
289
    def _open_repo_v1(self, path):
352
290
        verb = 'BzrDir.find_repository'
413
351
        else:
414
352
            raise errors.NoRepositoryPresent(self)
415
353
 
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
354
    def open_workingtree(self, recommend_upgrade=True):
423
 
        if self.has_workingtree():
 
355
        self._ensure_real()
 
356
        if self._real_bzrdir.has_workingtree():
424
357
            raise errors.NotLocalUrl(self.root_transport)
425
358
        else:
426
359
            raise errors.NoWorkingTree(self.root_transport.base)
429
362
        """Return the path to be used for this bzrdir in a remote call."""
430
363
        return client.remote_path_from_transport(self.root_transport)
431
364
 
432
 
    def get_branch_transport(self, branch_format, name=None):
 
365
    def get_branch_transport(self, branch_format):
433
366
        self._ensure_real()
434
 
        return self._real_bzrdir.get_branch_transport(branch_format, name=name)
 
367
        return self._real_bzrdir.get_branch_transport(branch_format)
435
368
 
436
369
    def get_repository_transport(self, repository_format):
437
370
        self._ensure_real()
458
391
        return self._real_bzrdir.clone(url, revision_id=revision_id,
459
392
            force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
460
393
 
461
 
    def _get_config(self):
462
 
        return RemoteBzrDirConfig(self)
 
394
    def get_config(self):
 
395
        self._ensure_real()
 
396
        return self._real_bzrdir.get_config()
463
397
 
464
398
 
465
399
class RemoteRepositoryFormat(repository.RepositoryFormat):
489
423
        self._custom_format = None
490
424
        self._network_name = None
491
425
        self._creating_bzrdir = None
492
 
        self._supports_chks = None
493
426
        self._supports_external_lookups = None
494
427
        self._supports_tree_reference = None
495
428
        self._rich_root_data = None
496
429
 
497
 
    def __repr__(self):
498
 
        return "%s(_network_name=%r)" % (self.__class__.__name__,
499
 
            self._network_name)
500
 
 
501
430
    @property
502
431
    def fast_deltas(self):
503
432
        self._ensure_real()
511
440
        return self._rich_root_data
512
441
 
513
442
    @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
443
    def supports_external_lookups(self):
522
444
        if self._supports_external_lookups is None:
523
445
            self._ensure_real()
569
491
        # 1) get the network name to use.
570
492
        if self._custom_format:
571
493
            network_name = self._custom_format.network_name()
572
 
        elif self._network_name:
573
 
            network_name = self._network_name
574
494
        else:
575
495
            # Select the current bzrlib default and ask for that.
576
496
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
624
544
        return self._custom_format._fetch_reconcile
625
545
 
626
546
    def get_format_description(self):
627
 
        self._ensure_real()
628
 
        return 'Remote: ' + self._custom_format.get_format_description()
 
547
        return 'bzr remote repository'
629
548
 
630
549
    def __eq__(self, other):
631
550
        return self.__class__ is other.__class__
632
551
 
 
552
    def check_conversion_target(self, target_format):
 
553
        if self.rich_root_data and not target_format.rich_root_data:
 
554
            raise errors.BadConversionTarget(
 
555
                'Does not support rich root data.', target_format)
 
556
        if (self.supports_tree_reference and
 
557
            not getattr(target_format, 'supports_tree_reference', False)):
 
558
            raise errors.BadConversionTarget(
 
559
                'Does not support nested trees', target_format)
 
560
 
633
561
    def network_name(self):
634
562
        if self._network_name:
635
563
            return self._network_name
637
565
        return self._creating_repo._real_repository._format.network_name()
638
566
 
639
567
    @property
640
 
    def pack_compresses(self):
641
 
        self._ensure_real()
642
 
        return self._custom_format.pack_compresses
643
 
 
644
 
    @property
645
568
    def _serializer(self):
646
569
        self._ensure_real()
647
570
        return self._custom_format._serializer
648
571
 
649
572
 
650
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
651
 
    bzrdir.ControlComponent):
 
573
class RemoteRepository(_RpcHelper):
652
574
    """Repository accessed over rpc.
653
575
 
654
576
    For the moment most operations are performed using local transport-backed
680
602
        self._lock_token = None
681
603
        self._lock_count = 0
682
604
        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
605
        self._unstacked_provider = graph.CachingParentsProvider(
686
606
            get_parent_map=self._get_parent_map_rpc)
687
607
        self._unstacked_provider.disable_cache()
697
617
        # Additional places to query for data.
698
618
        self._fallback_repositories = []
699
619
 
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
620
    def __str__(self):
712
621
        return "%s(%s)" % (self.__class__.__name__, self.base)
713
622
 
716
625
    def abort_write_group(self, suppress_errors=False):
717
626
        """Complete a write group on the decorated repository.
718
627
 
719
 
        Smart methods perform operations in a single step so this API
 
628
        Smart methods peform operations in a single step so this api
720
629
        is not really applicable except as a compatibility thunk
721
630
        for older plugins that don't use e.g. the CommitBuilder
722
631
        facility.
727
636
        return self._real_repository.abort_write_group(
728
637
            suppress_errors=suppress_errors)
729
638
 
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
639
    def commit_write_group(self):
741
640
        """Complete a write group on the decorated repository.
742
641
 
743
 
        Smart methods perform operations in a single step so this API
 
642
        Smart methods peform operations in a single step so this api
744
643
        is not really applicable except as a compatibility thunk
745
644
        for older plugins that don't use e.g. the CommitBuilder
746
645
        facility.
756
655
        self._ensure_real()
757
656
        return self._real_repository.suspend_write_group()
758
657
 
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
658
    def _ensure_real(self):
796
659
        """Ensure that there is a _real_repository set.
797
660
 
806
669
        invocation. If in doubt chat to the bzr network team.
807
670
        """
808
671
        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
672
            self.bzrdir._ensure_real()
815
673
            self._set_real_repository(
816
674
                self.bzrdir._real_bzrdir.open_repository())
876
734
        """Return a source for streaming from this repository."""
877
735
        return RemoteStreamSource(self, to_format)
878
736
 
879
 
    @needs_read_lock
880
737
    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,))
 
738
        """See Repository.has_revision()."""
 
739
        if revision_id == NULL_REVISION:
 
740
            # The null revision is always present.
 
741
            return True
 
742
        path = self.bzrdir._path_for_remote_call(self._client)
 
743
        response = self._call('Repository.has_revision', path, revision_id)
 
744
        if response[0] not in ('yes', 'no'):
 
745
            raise errors.UnexpectedSmartServerResponse(response)
 
746
        if response[0] == 'yes':
 
747
            return True
 
748
        for fallback_repo in self._fallback_repositories:
 
749
            if fallback_repo.has_revision(revision_id):
 
750
                return True
 
751
        return False
884
752
 
885
 
    @needs_read_lock
886
753
    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)
 
754
        """See Repository.has_revisions()."""
 
755
        # FIXME: This does many roundtrips, particularly when there are
 
756
        # fallback repositories.  -- mbp 20080905
 
757
        result = set()
 
758
        for revision_id in revision_ids:
 
759
            if self.has_revision(revision_id):
 
760
                result.add(revision_id)
897
761
        return result
898
762
 
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.edge.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
763
    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
764
        return (self.__class__ is other.__class__ and
917
765
                self.bzrdir.transport.base == other.bzrdir.transport.base)
918
766
 
921
769
        parents_provider = self._make_parents_provider(other_repository)
922
770
        return graph.Graph(parents_provider)
923
771
 
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
772
    def gather_stats(self, revid=None, committers=None):
934
773
        """See Repository.gather_stats()."""
935
774
        path = self.bzrdir._path_for_remote_call(self._client)
995
834
    def is_write_locked(self):
996
835
        return self._lock_mode == 'w'
997
836
 
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
837
    def lock_read(self):
1004
 
        """Lock the repository for read operations.
1005
 
 
1006
 
        :return: A bzrlib.lock.LogicalLockResult.
1007
 
        """
1008
838
        # wrong eventually - want a local lock cache context
1009
839
        if not self._lock_mode:
1010
 
            self._note_lock('r')
1011
840
            self._lock_mode = 'r'
1012
841
            self._lock_count = 1
1013
842
            self._unstacked_provider.enable_cache(cache_misses=True)
1014
843
            if self._real_repository is not None:
1015
844
                self._real_repository.lock_read()
1016
 
            for repo in self._fallback_repositories:
1017
 
                repo.lock_read()
1018
845
        else:
1019
846
            self._lock_count += 1
1020
 
        return lock.LogicalLockResult(self.unlock)
1021
847
 
1022
848
    def _remote_lock_write(self, token):
1023
849
        path = self.bzrdir._path_for_remote_call(self._client)
1034
860
 
1035
861
    def lock_write(self, token=None, _skip_rpc=False):
1036
862
        if not self._lock_mode:
1037
 
            self._note_lock('w')
1038
863
            if _skip_rpc:
1039
864
                if self._lock_token is not None:
1040
865
                    if token != self._lock_token:
1054
879
                self._leave_lock = False
1055
880
            self._lock_mode = 'w'
1056
881
            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()
 
882
            self._unstacked_provider.enable_cache(cache_misses=False)
1062
883
        elif self._lock_mode == 'r':
1063
884
            raise errors.ReadOnlyError(self)
1064
885
        else:
1065
886
            self._lock_count += 1
1066
 
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
 
887
        return self._lock_token or None
1067
888
 
1068
889
    def leave_lock_in_place(self):
1069
890
        if not self._lock_token:
1090
911
        if isinstance(repository, RemoteRepository):
1091
912
            raise AssertionError()
1092
913
        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")
 
914
        # If the _real_repository has _fallback_repositories, clear them out,
 
915
        # because we want it to have the same set as this repository.  This is
 
916
        # reasonable to do because the fallbacks we clear here are from a
 
917
        # "real" branch, and we're about to replace them with the equivalents
 
918
        # from a RemoteBranch.
 
919
        self._real_repository._fallback_repositories = []
1113
920
        for fb in self._fallback_repositories:
1114
921
            self._real_repository.add_fallback_repository(fb)
1115
922
        if self._lock_mode == 'w':
1122
929
    def start_write_group(self):
1123
930
        """Start a write group on the decorated repository.
1124
931
 
1125
 
        Smart methods perform operations in a single step so this API
 
932
        Smart methods peform operations in a single step so this api
1126
933
        is not really applicable except as a compatibility thunk
1127
934
        for older plugins that don't use e.g. the CommitBuilder
1128
935
        facility.
1143
950
        else:
1144
951
            raise errors.UnexpectedSmartServerResponse(response)
1145
952
 
1146
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
1147
953
    def unlock(self):
1148
954
        if not self._lock_count:
1149
 
            return lock.cant_unlock_not_held(self)
 
955
            raise errors.LockNotHeld(self)
1150
956
        self._lock_count -= 1
1151
957
        if self._lock_count > 0:
1152
958
            return
1166
972
            # problem releasing the vfs-based lock.
1167
973
            if old_mode == 'w':
1168
974
                # Only write-locked repositories need to make a remote method
1169
 
                # call to perform the unlock.
 
975
                # call to perfom the unlock.
1170
976
                old_token = self._lock_token
1171
977
                self._lock_token = None
1172
978
                if not self._leave_lock:
1173
979
                    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
980
 
1179
981
    def break_lock(self):
1180
982
        # should hand off to the network
1244
1046
        # We need to accumulate additional repositories here, to pass them in
1245
1047
        # on various RPC's.
1246
1048
        #
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
1049
        self._fallback_repositories.append(repository)
1254
1050
        # If self._real_repository was parameterised already (e.g. because a
1255
1051
        # _real_branch had its get_stacked_on_url method called), then the
1256
1052
        # repository to be added may already be in the _real_repositories list.
1257
1053
        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:
 
1054
            if repository not in self._real_repository._fallback_repositories:
1261
1055
                self._real_repository.add_fallback_repository(repository)
1262
 
 
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)
 
1056
        else:
 
1057
            # They are also seen by the fallback repository.  If it doesn't
 
1058
            # exist yet they'll be added then.  This implicitly copies them.
 
1059
            self._ensure_real()
1272
1060
 
1273
1061
    def add_inventory(self, revid, inv, parents):
1274
1062
        self._ensure_real()
1275
1063
        return self._real_repository.add_inventory(revid, inv, parents)
1276
1064
 
1277
1065
    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1278
 
            parents, basis_inv=None, propagate_caches=False):
 
1066
                               parents):
1279
1067
        self._ensure_real()
1280
1068
        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)
 
1069
            delta, new_revision_id, parents)
1283
1070
 
1284
1071
    def add_revision(self, rev_id, rev, inv=None, config=None):
1285
1072
        self._ensure_real()
1291
1078
        self._ensure_real()
1292
1079
        return self._real_repository.get_inventory(revision_id)
1293
1080
 
1294
 
    def iter_inventories(self, revision_ids, ordering=None):
 
1081
    def iter_inventories(self, revision_ids):
1295
1082
        self._ensure_real()
1296
 
        return self._real_repository.iter_inventories(revision_ids, ordering)
 
1083
        return self._real_repository.iter_inventories(revision_ids)
1297
1084
 
1298
1085
    @needs_read_lock
1299
1086
    def get_revision(self, revision_id):
1315
1102
        return self._real_repository.make_working_trees()
1316
1103
 
1317
1104
    def refresh_data(self):
1318
 
        """Re-read any data needed to synchronise with disk.
 
1105
        """Re-read any data needed to to synchronise with disk.
1319
1106
 
1320
1107
        This method is intended to be called after another repository instance
1321
1108
        (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.
 
1109
        repository. It may not be called during a write group, but may be
 
1110
        called at any other time.
1327
1111
        """
 
1112
        if self.is_in_write_group():
 
1113
            raise errors.InternalBzrError(
 
1114
                "May not refresh_data while in a write group.")
1328
1115
        if self._real_repository is not None:
1329
1116
            self._real_repository.refresh_data()
1330
1117
 
1363
1150
            raise errors.InternalBzrError(
1364
1151
                "May not fetch while in a write group.")
1365
1152
        # 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)):
 
1153
        if self.has_same_location(source) and fetch_spec is None:
1369
1154
            # check that last_revision is in 'from' and then return a
1370
1155
            # no-operation.
1371
1156
            if (revision_id is not None and
1420
1205
            # in one go, and the user probably will have seen a warning about
1421
1206
            # the server being old anyhow.
1422
1207
            rg = self._get_revision_graph(None)
1423
 
            # There is an API discrepancy between get_parent_map and
 
1208
            # There is an api discrepency between get_parent_map and
1424
1209
            # get_revision_graph. Specifically, a "key:()" pair in
1425
1210
            # get_revision_graph just means a node has no parents. For
1426
1211
            # "get_parent_map" it means the node is a ghost. So fix up the
1476
1261
        # We don't need to send ghosts back to the server as a position to
1477
1262
        # stop either.
1478
1263
        stop_keys.difference_update(self._unstacked_provider.missing_keys)
1479
 
        key_count = len(parents_map)
1480
 
        if (NULL_REVISION in result_parents
1481
 
            and NULL_REVISION in self._unstacked_provider.missing_keys):
1482
 
            # If we pruned NULL_REVISION from the stop_keys because it's also
1483
 
            # in our cache of "missing" keys we need to increment our key count
1484
 
            # by 1, because the reconsitituted SearchResult on the server will
1485
 
            # still consider NULL_REVISION to be an included key.
1486
 
            key_count += 1
1487
1264
        included_keys = start_set.intersection(result_parents)
1488
1265
        start_set.difference_update(included_keys)
1489
 
        recipe = ('manual', start_set, stop_keys, key_count)
 
1266
        recipe = ('manual', start_set, stop_keys, len(parents_map))
1490
1267
        body = self._serialise_search_recipe(recipe)
1491
1268
        path = self.bzrdir._path_for_remote_call(self._client)
1492
1269
        for key in keys:
1544
1321
        return self._real_repository.get_signature_text(revision_id)
1545
1322
 
1546
1323
    @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)
 
1324
    def get_inventory_xml(self, revision_id):
 
1325
        self._ensure_real()
 
1326
        return self._real_repository.get_inventory_xml(revision_id)
 
1327
 
 
1328
    def deserialise_inventory(self, revision_id, xml):
 
1329
        self._ensure_real()
 
1330
        return self._real_repository.deserialise_inventory(revision_id, xml)
1550
1331
 
1551
1332
    def reconcile(self, other=None, thorough=False):
1552
1333
        self._ensure_real()
1579
1360
        return self._real_repository.get_revision_reconcile(revision_id)
1580
1361
 
1581
1362
    @needs_read_lock
1582
 
    def check(self, revision_ids=None, callback_refs=None, check_repo=True):
 
1363
    def check(self, revision_ids=None):
1583
1364
        self._ensure_real()
1584
 
        return self._real_repository.check(revision_ids=revision_ids,
1585
 
            callback_refs=callback_refs, check_repo=check_repo)
 
1365
        return self._real_repository.check(revision_ids=revision_ids)
1586
1366
 
1587
1367
    def copy_content_into(self, destination, revision_id=None):
1588
1368
        self._ensure_real()
1628
1408
        return self._real_repository.inventories
1629
1409
 
1630
1410
    @needs_write_lock
1631
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
1411
    def pack(self):
1632
1412
        """Compress the data within the repository.
1633
1413
 
1634
1414
        This is not currently implemented within the smart server.
1635
1415
        """
1636
1416
        self._ensure_real()
1637
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
1417
        return self._real_repository.pack()
1638
1418
 
1639
1419
    @property
1640
1420
    def revisions(self):
1728
1508
        self._ensure_real()
1729
1509
        return self._real_repository.revision_graph_can_have_wrong_parents()
1730
1510
 
1731
 
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
 
1511
    def _find_inconsistent_revision_parents(self):
1732
1512
        self._ensure_real()
1733
 
        return self._real_repository._find_inconsistent_revision_parents(
1734
 
            revisions_iterator)
 
1513
        return self._real_repository._find_inconsistent_revision_parents()
1735
1514
 
1736
1515
    def _check_for_inconsistent_revision_parents(self):
1737
1516
        self._ensure_real()
1743
1522
            providers.insert(0, other)
1744
1523
        providers.extend(r._make_parents_provider() for r in
1745
1524
                         self._fallback_repositories)
1746
 
        return graph.StackedParentsProvider(providers)
 
1525
        return graph._StackedParentsProvider(providers)
1747
1526
 
1748
1527
    def _serialise_search_recipe(self, recipe):
1749
1528
        """Serialise a graph search recipe.
1790
1569
 
1791
1570
    def insert_stream(self, stream, src_format, resume_tokens):
1792
1571
        target = self.target_repo
1793
 
        target._unstacked_provider.missing_keys.clear()
1794
 
        candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
1795
1572
        if target._lock_token:
1796
 
            candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
1797
 
            lock_args = (target._lock_token or '',)
 
1573
            verb = 'Repository.insert_stream_locked'
 
1574
            extra_args = (target._lock_token or '',)
 
1575
            required_version = (1, 14)
1798
1576
        else:
1799
 
            candidate_calls.append(('Repository.insert_stream', (1, 13)))
1800
 
            lock_args = ()
 
1577
            verb = 'Repository.insert_stream'
 
1578
            extra_args = ()
 
1579
            required_version = (1, 13)
1801
1580
        client = target._client
1802
1581
        medium = client._medium
 
1582
        if medium._is_remote_before(required_version):
 
1583
            # No possible way this can work.
 
1584
            return self._insert_real(stream, src_format, resume_tokens)
1803
1585
        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
 
1586
        if not resume_tokens:
 
1587
            # XXX: Ugly but important for correctness, *will* be fixed during
 
1588
            # 1.13 cycle. Pushing a stream that is interrupted results in a
 
1589
            # fallback to the _real_repositories sink *with a partial stream*.
 
1590
            # Thats bad because we insert less data than bzr expected. To avoid
 
1591
            # this we do a trial push to make sure the verb is accessible, and
 
1592
            # do not fallback when actually pushing the stream. A cleanup patch
 
1593
            # is going to look at rewinding/restarting the stream/partial
 
1594
            # buffering etc.
1817
1595
            byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1818
1596
            try:
1819
1597
                response = client.call_with_body_stream(
1820
 
                    (verb, path, '') + lock_args, byte_stream)
 
1598
                    (verb, path, '') + extra_args, byte_stream)
1821
1599
            except errors.UnknownSmartMethod:
1822
1600
                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)
 
1601
                return self._insert_real(stream, src_format, resume_tokens)
1837
1602
        byte_stream = smart_repo._stream_to_byte_stream(
1838
1603
            stream, src_format)
1839
1604
        resume_tokens = ' '.join(resume_tokens)
1840
1605
        response = client.call_with_body_stream(
1841
 
            (verb, path, resume_tokens) + lock_args, byte_stream)
 
1606
            (verb, path, resume_tokens) + extra_args, byte_stream)
1842
1607
        if response[0][0] not in ('ok', 'missing-basis'):
1843
1608
            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
1609
        if response[0][0] == 'missing-basis':
1851
1610
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1852
1611
            resume_tokens = tokens
1853
 
            return resume_tokens, set(missing_keys)
 
1612
            return resume_tokens, missing_keys
1854
1613
        else:
1855
1614
            self.target_repo.refresh_data()
1856
1615
            return [], set()
1857
1616
 
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
1617
 
1899
1618
class RemoteStreamSource(repository.StreamSource):
1900
1619
    """Stream data from a remote server."""
1903
1622
        if (self.from_repository._fallback_repositories and
1904
1623
            self.to_format._fetch_order == 'topological'):
1905
1624
            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)
 
1625
        return self.missing_parents_chain(search, [self.from_repository] +
 
1626
            self.from_repository._fallback_repositories)
1923
1627
 
1924
1628
    def _real_stream(self, repo, search):
1925
1629
        """Get a stream for search from repo.
1932
1636
        """
1933
1637
        source = repo._get_source(self.to_format)
1934
1638
        if isinstance(source, RemoteStreamSource):
1935
 
            repo._ensure_real()
1936
 
            source = repo._real_repository._get_source(self.to_format)
 
1639
            return repository.StreamSource.get_stream(source, search)
1937
1640
        return source.get_stream(search)
1938
1641
 
1939
1642
    def _get_stream(self, repo, search):
1956
1659
            return self._real_stream(repo, search)
1957
1660
        client = repo._client
1958
1661
        medium = client._medium
 
1662
        if medium._is_remote_before((1, 13)):
 
1663
            # streaming was added in 1.13
 
1664
            return self._real_stream(repo, search)
1959
1665
        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:
 
1666
        try:
 
1667
            search_bytes = repo._serialise_search_result(search)
 
1668
            response = repo._call_with_body_bytes_expecting_body(
 
1669
                'Repository.get_stream',
 
1670
                (path, self.to_format.network_name()), search_bytes)
 
1671
            response_tuple, response_handler = response
 
1672
        except errors.UnknownSmartMethod:
 
1673
            medium._remember_remote_is_before((1,13))
1979
1674
            return self._real_stream(repo, search)
1980
1675
        if response_tuple[0] != 'ok':
1981
1676
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1993
1688
        :param search: The overall search to satisfy with streams.
1994
1689
        :param sources: A list of Repository objects to query.
1995
1690
        """
1996
 
        self.from_serialiser = self.from_repository._format._serializer
 
1691
        self.serialiser = self.to_format._serializer
1997
1692
        self.seen_revs = set()
1998
1693
        self.referenced_revs = set()
1999
1694
        # If there are heads in the search, or the key count is > 0, we are not
2016
1711
    def missing_parents_rev_handler(self, substream):
2017
1712
        for content in substream:
2018
1713
            revision_bytes = content.get_bytes_as('fulltext')
2019
 
            revision = self.from_serialiser.read_revision_from_string(
2020
 
                revision_bytes)
 
1714
            revision = self.serialiser.read_revision_from_string(revision_bytes)
2021
1715
            self.seen_revs.add(content.key[-1])
2022
1716
            self.referenced_revs.update(revision.parent_ids)
2023
1717
            yield content
2062
1756
                self._network_name)
2063
1757
 
2064
1758
    def get_format_description(self):
2065
 
        self._ensure_real()
2066
 
        return 'Remote: ' + self._custom_format.get_format_description()
 
1759
        return 'Remote BZR Branch'
2067
1760
 
2068
1761
    def network_name(self):
2069
1762
        return self._network_name
2070
1763
 
2071
 
    def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2072
 
        return a_bzrdir.open_branch(name=name, 
2073
 
            ignore_fallbacks=ignore_fallbacks)
 
1764
    def open(self, a_bzrdir, ignore_fallbacks=False):
 
1765
        return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
2074
1766
 
2075
 
    def _vfs_initialize(self, a_bzrdir, name):
 
1767
    def _vfs_initialize(self, a_bzrdir):
2076
1768
        # Initialisation when using a local bzrdir object, or a non-vfs init
2077
1769
        # method is not available on the server.
2078
1770
        # self._custom_format is always set - the start of initialize ensures
2079
1771
        # that.
2080
1772
        if isinstance(a_bzrdir, RemoteBzrDir):
2081
1773
            a_bzrdir._ensure_real()
2082
 
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2083
 
                name)
 
1774
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
2084
1775
        else:
2085
1776
            # We assume the bzrdir is parameterised; it may not be.
2086
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
1777
            result = self._custom_format.initialize(a_bzrdir)
2087
1778
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2088
1779
            not isinstance(result, RemoteBranch)):
2089
 
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2090
 
                                  name=name)
 
1780
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
2091
1781
        return result
2092
1782
 
2093
 
    def initialize(self, a_bzrdir, name=None):
 
1783
    def initialize(self, a_bzrdir):
2094
1784
        # 1) get the network name to use.
2095
1785
        if self._custom_format:
2096
1786
            network_name = self._custom_format.network_name()
2102
1792
            network_name = reference_format.network_name()
2103
1793
        # Being asked to create on a non RemoteBzrDir:
2104
1794
        if not isinstance(a_bzrdir, RemoteBzrDir):
2105
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
1795
            return self._vfs_initialize(a_bzrdir)
2106
1796
        medium = a_bzrdir._client._medium
2107
1797
        if medium._is_remote_before((1, 13)):
2108
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
1798
            return self._vfs_initialize(a_bzrdir)
2109
1799
        # Creating on a remote bzr dir.
2110
1800
        # 2) try direct creation via RPC
2111
1801
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2112
 
        if name is not None:
2113
 
            # XXX JRV20100304: Support creating colocated branches
2114
 
            raise errors.NoColocatedBranchSupport(self)
2115
1802
        verb = 'BzrDir.create_branch'
2116
1803
        try:
2117
1804
            response = a_bzrdir._call(verb, path, network_name)
2118
1805
        except errors.UnknownSmartMethod:
2119
1806
            # Fallback - use vfs methods
2120
1807
            medium._remember_remote_is_before((1, 13))
2121
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
1808
            return self._vfs_initialize(a_bzrdir)
2122
1809
        if response[0] != 'ok':
2123
1810
            raise errors.UnexpectedSmartServerResponse(response)
2124
1811
        # Turn the response into a RemoteRepository object.
2132
1819
                a_bzrdir._client)
2133
1820
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2134
1821
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2135
 
            format=format, setup_stacking=False, name=name)
 
1822
            format=format, setup_stacking=False)
2136
1823
        # XXX: We know this is a new branch, so it must have revno 0, revid
2137
1824
        # NULL_REVISION. Creating the branch locked would make this be unable
2138
1825
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2153
1840
        self._ensure_real()
2154
1841
        return self._custom_format.supports_stacking()
2155
1842
 
2156
 
    def supports_set_append_revisions_only(self):
2157
 
        self._ensure_real()
2158
 
        return self._custom_format.supports_set_append_revisions_only()
2159
 
 
2160
 
 
2161
 
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
 
1843
 
 
1844
class RemoteBranch(branch.Branch, _RpcHelper):
2162
1845
    """Branch stored on a server accessed by HPSS RPC.
2163
1846
 
2164
1847
    At the moment most operations are mapped down to simple file operations.
2165
1848
    """
2166
1849
 
2167
1850
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2168
 
        _client=None, format=None, setup_stacking=True, name=None):
 
1851
        _client=None, format=None, setup_stacking=True):
2169
1852
        """Create a RemoteBranch instance.
2170
1853
 
2171
1854
        :param real_branch: An optional local implementation of the branch
2177
1860
        :param setup_stacking: If True make an RPC call to determine the
2178
1861
            stacked (or not) status of the branch. If False assume the branch
2179
1862
            is not stacked.
2180
 
        :param name: Colocated branch name
2181
1863
        """
2182
1864
        # We intentionally don't call the parent class's __init__, because it
2183
1865
        # will try to assign to self.tags, which is a property in this subclass.
2184
1866
        # And the parent's __init__ doesn't do much anyway.
 
1867
        self._revision_id_to_revno_cache = None
 
1868
        self._partial_revision_id_to_revno_cache = {}
 
1869
        self._revision_history_cache = None
 
1870
        self._last_revision_info_cache = None
 
1871
        self._merge_sorted_revisions_cache = None
2185
1872
        self.bzrdir = remote_bzrdir
2186
1873
        if _client is not None:
2187
1874
            self._client = _client
2200
1887
            self._real_branch.repository = self.repository
2201
1888
        else:
2202
1889
            self._real_branch = None
2203
 
        # Fill out expected attributes of branch for bzrlib API users.
2204
 
        self._clear_cached_state()
2205
 
        # TODO: deprecate self.base in favor of user_url
2206
 
        self.base = self.bzrdir.user_url
2207
 
        self._name = name
 
1890
        # Fill out expected attributes of branch for bzrlib api users.
 
1891
        self.base = self.bzrdir.root_transport.base
2208
1892
        self._control_files = None
2209
1893
        self._lock_mode = None
2210
1894
        self._lock_token = None
2221
1905
                    self._real_branch._format.network_name()
2222
1906
        else:
2223
1907
            self._format = format
2224
 
        # when we do _ensure_real we may need to pass ignore_fallbacks to the
2225
 
        # branch.open_branch method.
2226
 
        self._real_ignore_fallbacks = not setup_stacking
2227
1908
        if not self._format._network_name:
2228
1909
            # Did not get from open_branchV2 - old server.
2229
1910
            self._ensure_real()
2234
1915
        hooks = branch.Branch.hooks['open']
2235
1916
        for hook in hooks:
2236
1917
            hook(self)
2237
 
        self._is_stacked = False
2238
1918
        if setup_stacking:
2239
1919
            self._setup_stacking()
2240
1920
 
2246
1926
        except (errors.NotStacked, errors.UnstackableBranchFormat,
2247
1927
            errors.UnstackableRepositoryFormat), e:
2248
1928
            return
2249
 
        self._is_stacked = True
2250
 
        self._activate_fallback_location(fallback_url)
2251
 
 
2252
 
    def _get_config(self):
2253
 
        return RemoteBranchConfig(self)
 
1929
        # it's relative to this branch...
 
1930
        fallback_url = urlutils.join(self.base, fallback_url)
 
1931
        transports = [self.bzrdir.root_transport]
 
1932
        stacked_on = branch.Branch.open(fallback_url,
 
1933
                                        possible_transports=transports)
 
1934
        self.repository.add_fallback_repository(stacked_on.repository)
2254
1935
 
2255
1936
    def _get_real_transport(self):
2256
1937
        # if we try vfs access, return the real branch's vfs transport
2274
1955
                raise AssertionError('smart server vfs must be enabled '
2275
1956
                    'to use vfs implementation')
2276
1957
            self.bzrdir._ensure_real()
2277
 
            self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2278
 
                ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
 
1958
            self._real_branch = self.bzrdir._real_bzrdir.open_branch()
2279
1959
            if self.repository._real_repository is None:
2280
1960
                # Give the remote repository the matching real repo.
2281
1961
                real_repo = self._real_branch.repository
2355
2035
            raise errors.UnexpectedSmartServerResponse(response)
2356
2036
        return response[1]
2357
2037
 
2358
 
    def set_stacked_on_url(self, url):
2359
 
        branch.Branch.set_stacked_on_url(self, url)
2360
 
        if not url:
2361
 
            self._is_stacked = False
2362
 
        else:
2363
 
            self._is_stacked = True
2364
 
        
2365
2038
    def _vfs_get_tags_bytes(self):
2366
2039
        self._ensure_real()
2367
2040
        return self._real_branch._get_tags_bytes()
2377
2050
            return self._vfs_get_tags_bytes()
2378
2051
        return response[0]
2379
2052
 
2380
 
    def _vfs_set_tags_bytes(self, bytes):
2381
 
        self._ensure_real()
2382
 
        return self._real_branch._set_tags_bytes(bytes)
2383
 
 
2384
 
    def _set_tags_bytes(self, bytes):
2385
 
        medium = self._client._medium
2386
 
        if medium._is_remote_before((1, 18)):
2387
 
            self._vfs_set_tags_bytes(bytes)
2388
 
            return
2389
 
        try:
2390
 
            args = (
2391
 
                self._remote_path(), self._lock_token, self._repo_lock_token)
2392
 
            response = self._call_with_body_bytes(
2393
 
                'Branch.set_tags_bytes', args, bytes)
2394
 
        except errors.UnknownSmartMethod:
2395
 
            medium._remember_remote_is_before((1, 18))
2396
 
            self._vfs_set_tags_bytes(bytes)
2397
 
 
2398
2053
    def lock_read(self):
2399
 
        """Lock the branch for read operations.
2400
 
 
2401
 
        :return: A bzrlib.lock.LogicalLockResult.
2402
 
        """
2403
2054
        self.repository.lock_read()
2404
2055
        if not self._lock_mode:
2405
 
            self._note_lock('r')
2406
2056
            self._lock_mode = 'r'
2407
2057
            self._lock_count = 1
2408
2058
            if self._real_branch is not None:
2409
2059
                self._real_branch.lock_read()
2410
2060
        else:
2411
2061
            self._lock_count += 1
2412
 
        return lock.LogicalLockResult(self.unlock)
2413
2062
 
2414
2063
    def _remote_lock_write(self, token):
2415
2064
        if token is None:
2416
2065
            branch_token = repo_token = ''
2417
2066
        else:
2418
2067
            branch_token = token
2419
 
            repo_token = self.repository.lock_write().repository_token
 
2068
            repo_token = self.repository.lock_write()
2420
2069
            self.repository.unlock()
2421
2070
        err_context = {'token': token}
2422
2071
        response = self._call(
2429
2078
 
2430
2079
    def lock_write(self, token=None):
2431
2080
        if not self._lock_mode:
2432
 
            self._note_lock('w')
2433
2081
            # Lock the branch and repo in one remote call.
2434
2082
            remote_tokens = self._remote_lock_write(token)
2435
2083
            self._lock_token, self._repo_lock_token = remote_tokens
2459
2107
            self._lock_count += 1
2460
2108
            # Re-lock the repository too.
2461
2109
            self.repository.lock_write(self._repo_lock_token)
2462
 
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
 
2110
        return self._lock_token or None
 
2111
 
 
2112
    def _set_tags_bytes(self, bytes):
 
2113
        self._ensure_real()
 
2114
        return self._real_branch._set_tags_bytes(bytes)
2463
2115
 
2464
2116
    def _unlock(self, branch_token, repo_token):
2465
2117
        err_context = {'token': str((branch_token, repo_token))}
2470
2122
            return
2471
2123
        raise errors.UnexpectedSmartServerResponse(response)
2472
2124
 
2473
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2474
2125
    def unlock(self):
2475
2126
        try:
2476
2127
            self._lock_count -= 1
2489
2140
                    self._real_branch.unlock()
2490
2141
                if mode != 'w':
2491
2142
                    # Only write-locked branched need to make a remote method
2492
 
                    # call to perform the unlock.
 
2143
                    # call to perfom the unlock.
2493
2144
                    return
2494
2145
                if not self._lock_token:
2495
2146
                    raise AssertionError('Locked, but no token!')
2516
2167
            raise NotImplementedError(self.dont_leave_lock_in_place)
2517
2168
        self._leave_lock = False
2518
2169
 
2519
 
    @needs_read_lock
2520
 
    def get_rev_id(self, revno, history=None):
2521
 
        if revno == 0:
2522
 
            return _mod_revision.NULL_REVISION
2523
 
        last_revision_info = self.last_revision_info()
2524
 
        ok, result = self.repository.get_rev_id_for_revno(
2525
 
            revno, last_revision_info)
2526
 
        if ok:
2527
 
            return result
2528
 
        missing_parent = result[1]
2529
 
        # Either the revision named by the server is missing, or its parent
2530
 
        # is.  Call get_parent_map to determine which, so that we report a
2531
 
        # useful error.
2532
 
        parent_map = self.repository.get_parent_map([missing_parent])
2533
 
        if missing_parent in parent_map:
2534
 
            missing_parent = parent_map[missing_parent]
2535
 
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2536
 
 
2537
2170
    def _last_revision_info(self):
2538
2171
        response = self._call('Branch.last_revision_info', self._remote_path())
2539
2172
        if response[0] != 'ok':
2544
2177
 
2545
2178
    def _gen_revision_history(self):
2546
2179
        """See Branch._gen_revision_history()."""
2547
 
        if self._is_stacked:
2548
 
            self._ensure_real()
2549
 
            return self._real_branch._gen_revision_history()
2550
2180
        response_tuple, response_handler = self._call_expecting_body(
2551
2181
            'Branch.revision_history', self._remote_path())
2552
2182
        if response_tuple[0] != 'ok':
2637
2267
        self._ensure_real()
2638
2268
        return self._real_branch._get_parent_location()
2639
2269
 
 
2270
    def set_parent(self, url):
 
2271
        self._ensure_real()
 
2272
        return self._real_branch.set_parent(url)
 
2273
 
2640
2274
    def _set_parent_location(self, url):
2641
 
        medium = self._client._medium
2642
 
        if medium._is_remote_before((1, 15)):
2643
 
            return self._vfs_set_parent_location(url)
2644
 
        try:
2645
 
            call_url = url or ''
2646
 
            if type(call_url) is not str:
2647
 
                raise AssertionError('url must be a str or None (%s)' % url)
2648
 
            response = self._call('Branch.set_parent_location',
2649
 
                self._remote_path(), self._lock_token, self._repo_lock_token,
2650
 
                call_url)
2651
 
        except errors.UnknownSmartMethod:
2652
 
            medium._remember_remote_is_before((1, 15))
2653
 
            return self._vfs_set_parent_location(url)
2654
 
        if response != ():
2655
 
            raise errors.UnexpectedSmartServerResponse(response)
2656
 
 
2657
 
    def _vfs_set_parent_location(self, url):
 
2275
        # Used by tests, to poke bad urls into branch configurations
 
2276
        if url is None:
 
2277
            self.set_parent(url)
 
2278
        else:
 
2279
            self._ensure_real()
 
2280
            return self._real_branch._set_parent_location(url)
 
2281
 
 
2282
    def set_stacked_on_url(self, stacked_location):
 
2283
        """Set the URL this branch is stacked against.
 
2284
 
 
2285
        :raises UnstackableBranchFormat: If the branch does not support
 
2286
            stacking.
 
2287
        :raises UnstackableRepositoryFormat: If the repository does not support
 
2288
            stacking.
 
2289
        """
2658
2290
        self._ensure_real()
2659
 
        return self._real_branch._set_parent_location(url)
 
2291
        return self._real_branch.set_stacked_on_url(stacked_location)
2660
2292
 
2661
2293
    @needs_write_lock
2662
2294
    def pull(self, source, overwrite=False, stop_revision=None,
2730
2362
        return self._real_branch.set_push_location(location)
2731
2363
 
2732
2364
 
2733
 
class RemoteConfig(object):
2734
 
    """A Config that reads and writes from smart verbs.
2735
 
 
2736
 
    It is a low-level object that considers config data to be name/value pairs
2737
 
    that may be associated with a section. Assigning meaning to the these
2738
 
    values is done at higher levels like bzrlib.config.TreeConfig.
2739
 
    """
2740
 
 
2741
 
    def get_option(self, name, section=None, default=None):
2742
 
        """Return the value associated with a named option.
2743
 
 
2744
 
        :param name: The name of the value
2745
 
        :param section: The section the option is in (if any)
2746
 
        :param default: The value to return if the value is not set
2747
 
        :return: The value or default value
2748
 
        """
2749
 
        try:
2750
 
            configobj = self._get_configobj()
2751
 
            if section is None:
2752
 
                section_obj = configobj
2753
 
            else:
2754
 
                try:
2755
 
                    section_obj = configobj[section]
2756
 
                except KeyError:
2757
 
                    return default
2758
 
            return section_obj.get(name, default)
2759
 
        except errors.UnknownSmartMethod:
2760
 
            return self._vfs_get_option(name, section, default)
2761
 
 
2762
 
    def _response_to_configobj(self, response):
2763
 
        if len(response[0]) and response[0][0] != 'ok':
2764
 
            raise errors.UnexpectedSmartServerResponse(response)
2765
 
        lines = response[1].read_body_bytes().splitlines()
2766
 
        return config.ConfigObj(lines, encoding='utf-8')
2767
 
 
2768
 
 
2769
 
class RemoteBranchConfig(RemoteConfig):
2770
 
    """A RemoteConfig for Branches."""
2771
 
 
2772
 
    def __init__(self, branch):
2773
 
        self._branch = branch
2774
 
 
2775
 
    def _get_configobj(self):
2776
 
        path = self._branch._remote_path()
2777
 
        response = self._branch._client.call_expecting_body(
2778
 
            'Branch.get_config_file', path)
2779
 
        return self._response_to_configobj(response)
2780
 
 
2781
 
    def set_option(self, value, name, section=None):
2782
 
        """Set the value associated with a named option.
2783
 
 
2784
 
        :param value: The value to set
2785
 
        :param name: The name of the value to set
2786
 
        :param section: The section the option is in (if any)
2787
 
        """
2788
 
        medium = self._branch._client._medium
2789
 
        if medium._is_remote_before((1, 14)):
2790
 
            return self._vfs_set_option(value, name, section)
2791
 
        try:
2792
 
            path = self._branch._remote_path()
2793
 
            response = self._branch._client.call('Branch.set_config_option',
2794
 
                path, self._branch._lock_token, self._branch._repo_lock_token,
2795
 
                value.encode('utf8'), name, section or '')
2796
 
        except errors.UnknownSmartMethod:
2797
 
            medium._remember_remote_is_before((1, 14))
2798
 
            return self._vfs_set_option(value, name, section)
2799
 
        if response != ():
2800
 
            raise errors.UnexpectedSmartServerResponse(response)
2801
 
 
2802
 
    def _real_object(self):
2803
 
        self._branch._ensure_real()
2804
 
        return self._branch._real_branch
2805
 
 
2806
 
    def _vfs_set_option(self, value, name, section=None):
2807
 
        return self._real_object()._get_config().set_option(
2808
 
            value, name, section)
2809
 
 
2810
 
 
2811
 
class RemoteBzrDirConfig(RemoteConfig):
2812
 
    """A RemoteConfig for BzrDirs."""
2813
 
 
2814
 
    def __init__(self, bzrdir):
2815
 
        self._bzrdir = bzrdir
2816
 
 
2817
 
    def _get_configobj(self):
2818
 
        medium = self._bzrdir._client._medium
2819
 
        verb = 'BzrDir.get_config_file'
2820
 
        if medium._is_remote_before((1, 15)):
2821
 
            raise errors.UnknownSmartMethod(verb)
2822
 
        path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
2823
 
        response = self._bzrdir._call_expecting_body(
2824
 
            verb, path)
2825
 
        return self._response_to_configobj(response)
2826
 
 
2827
 
    def _vfs_get_option(self, name, section, default):
2828
 
        return self._real_object()._get_config().get_option(
2829
 
            name, section, default)
2830
 
 
2831
 
    def set_option(self, value, name, section=None):
2832
 
        """Set the value associated with a named option.
2833
 
 
2834
 
        :param value: The value to set
2835
 
        :param name: The name of the value to set
2836
 
        :param section: The section the option is in (if any)
2837
 
        """
2838
 
        return self._real_object()._get_config().set_option(
2839
 
            value, name, section)
2840
 
 
2841
 
    def _real_object(self):
2842
 
        self._bzrdir._ensure_real()
2843
 
        return self._bzrdir._real_bzrdir
2844
 
 
2845
 
 
2846
 
 
2847
2365
def _extract_tar(tar, to_dir):
2848
2366
    """Extract all the contents of a tarfile object.
2849
2367
 
2887
2405
                    'Missing key %r in context %r', key_err.args[0], context)
2888
2406
                raise err
2889
2407
 
2890
 
    if err.error_verb == 'IncompatibleRepositories':
2891
 
        raise errors.IncompatibleRepositories(err.error_args[0],
2892
 
            err.error_args[1], err.error_args[2])
2893
 
    elif err.error_verb == 'NoSuchRevision':
 
2408
    if err.error_verb == 'NoSuchRevision':
2894
2409
        raise NoSuchRevision(find('branch'), err.error_args[0])
2895
2410
    elif err.error_verb == 'nosuchrevision':
2896
2411
        raise NoSuchRevision(find('repository'), err.error_args[0])
2897
 
    elif err.error_verb == 'nobranch':
2898
 
        if len(err.error_args) >= 1:
2899
 
            extra = err.error_args[0]
2900
 
        else:
2901
 
            extra = None
2902
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
2903
 
            detail=extra)
 
2412
    elif err.error_tuple == ('nobranch',):
 
2413
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
2904
2414
    elif err.error_verb == 'norepository':
2905
2415
        raise errors.NoRepositoryPresent(find('bzrdir'))
2906
2416
    elif err.error_verb == 'LockContention':