← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
1
 
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
 
 
20
17
import bz2
21
18
 
22
19
from bzrlib import (
24
21
    branch,
25
22
    bzrdir,
26
23
    config,
 
24
    controldir,
27
25
    debug,
28
26
    errors,
29
27
    graph,
 
28
    lock,
30
29
    lockdir,
31
30
    repository,
 
31
    repository as _mod_repository,
32
32
    revision,
33
33
    revision as _mod_revision,
 
34
    static_tuple,
34
35
    symbol_versioning,
35
36
)
36
 
from bzrlib.branch import BranchReferenceFormat
 
37
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
37
38
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
38
 
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
39
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
39
40
from bzrlib.errors import (
40
41
    NoSuchRevision,
41
42
    SmartProtocolError,
43
44
from bzrlib.lockable_files import LockableFiles
44
45
from bzrlib.smart import client, vfs, repository as smart_repo
45
46
from bzrlib.revision import ensure_null, NULL_REVISION
 
47
from bzrlib.repository import RepositoryWriteLockResult
46
48
from bzrlib.trace import mutter, note, warning
47
49
 
48
50
 
61
63
        except errors.ErrorFromSmartServer, err:
62
64
            self._translate_error(err, **err_context)
63
65
 
 
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
 
64
72
    def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
65
73
                                             **err_context):
66
74
        try:
85
93
class RemoteBzrDir(BzrDir, _RpcHelper):
86
94
    """Control directory on a remote server, accessed via bzr:// or similar."""
87
95
 
88
 
    def __init__(self, transport, format, _client=None):
 
96
    def __init__(self, transport, format, _client=None, _force_probe=False):
89
97
        """Construct a RemoteBzrDir.
90
98
 
91
99
        :param _client: Private parameter for testing. Disables probing and the
95
103
        # this object holds a delegated bzrdir that uses file-level operations
96
104
        # to talk to the other side
97
105
        self._real_bzrdir = None
 
106
        self._has_working_tree = None
98
107
        # 1-shot cache for the call pattern 'create_branch; open_branch' - see
99
108
        # create_branch for details.
100
109
        self._next_open_branch_result = None
104
113
            self._client = client._SmartClient(medium)
105
114
        else:
106
115
            self._client = _client
107
 
            return
108
 
 
 
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
109
126
        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):
110
152
        response = self._call('BzrDir.open', path)
111
153
        if response not in [('yes',), ('no',)]:
112
154
            raise errors.UnexpectedSmartServerResponse(response)
113
155
        if response == ('no',):
114
 
            raise errors.NotBranchError(path=transport.base)
 
156
            raise errors.NotBranchError(path=self.root_transport.base)
115
157
 
116
158
    def _ensure_real(self):
117
159
        """Ensure that there is a _real_bzrdir set.
119
161
        Used before calls to self._real_bzrdir.
120
162
        """
121
163
        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()))
122
168
            self._real_bzrdir = BzrDir.open_from_transport(
123
169
                self.root_transport, _server_formats=False)
124
170
            self._format._network_name = \
200
246
        self._ensure_real()
201
247
        self._real_bzrdir.destroy_repository()
202
248
 
203
 
    def create_branch(self):
 
249
    def create_branch(self, name=None):
204
250
        # as per meta1 formats - just delegate to the format object which may
205
251
        # be parameterised.
206
 
        real_branch = self._format.get_branch_format().initialize(self)
 
252
        real_branch = self._format.get_branch_format().initialize(self,
 
253
            name=name)
207
254
        if not isinstance(real_branch, RemoteBranch):
208
 
            result = RemoteBranch(self, self.find_repository(), real_branch)
 
255
            result = RemoteBranch(self, self.find_repository(), real_branch,
 
256
                                  name=name)
209
257
        else:
210
258
            result = real_branch
211
259
        # BzrDir.clone_on_transport() uses the result of create_branch but does
217
265
        self._next_open_branch_result = result
218
266
        return result
219
267
 
220
 
    def destroy_branch(self):
 
268
    def destroy_branch(self, name=None):
221
269
        """See BzrDir.destroy_branch"""
222
270
        self._ensure_real()
223
 
        self._real_bzrdir.destroy_branch()
 
271
        self._real_bzrdir.destroy_branch(name=name)
224
272
        self._next_open_branch_result = None
225
273
 
226
274
    def create_workingtree(self, revision_id=None, from_branch=None):
227
275
        raise errors.NotLocalUrl(self.transport.base)
228
276
 
229
 
    def find_branch_format(self):
 
277
    def find_branch_format(self, name=None):
230
278
        """Find the branch 'format' for this bzrdir.
231
279
 
232
280
        This might be a synthetic object for e.g. RemoteBranch and SVN.
233
281
        """
234
 
        b = self.open_branch()
 
282
        b = self.open_branch(name=name)
235
283
        return b._format
236
284
 
237
 
    def get_branch_reference(self):
 
285
    def get_branch_reference(self, name=None):
238
286
        """See BzrDir.get_branch_reference()."""
 
287
        if name is not None:
 
288
            # XXX JRV20100304: Support opening colocated branches
 
289
            raise errors.NoColocatedBranchSupport(self)
239
290
        response = self._get_branch_reference()
240
291
        if response[0] == 'ref':
241
292
            return response[1]
245
296
    def _get_branch_reference(self):
246
297
        path = self._path_for_remote_call(self._client)
247
298
        medium = self._client._medium
248
 
        if not medium._is_remote_before((1, 13)):
 
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
307
            try:
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
                response = self._call(verb, path)
254
309
            except errors.UnknownSmartMethod:
255
 
                medium._remember_remote_is_before((1, 13))
256
 
        response = self._call('BzrDir.open_branch', path)
257
 
        if response[0] != 'ok':
 
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'):
258
323
            raise errors.UnexpectedSmartServerResponse(response)
259
 
        if response[1] != '':
260
 
            return ('ref', response[1])
261
 
        else:
262
 
            return ('branch', '')
 
324
        return response
263
325
 
264
 
    def _get_tree_branch(self):
 
326
    def _get_tree_branch(self, name=None):
265
327
        """See BzrDir._get_tree_branch()."""
266
 
        return None, self.open_branch()
 
328
        return None, self.open_branch(name=name)
267
329
 
268
 
    def open_branch(self, _unsupported=False, ignore_fallbacks=False):
269
 
        if _unsupported:
 
330
    def open_branch(self, name=None, unsupported=False,
 
331
                    ignore_fallbacks=False):
 
332
        if unsupported:
270
333
            raise NotImplementedError('unsupported flag support not implemented yet.')
271
334
        if self._next_open_branch_result is not None:
272
335
            # See create_branch for details.
277
340
        if response[0] == 'ref':
278
341
            # a branch reference, use the existing BranchReference logic.
279
342
            format = BranchReferenceFormat()
280
 
            return format.open(self, _found=True, location=response[1],
281
 
                ignore_fallbacks=ignore_fallbacks)
 
343
            return format.open(self, name=name, _found=True,
 
344
                location=response[1], ignore_fallbacks=ignore_fallbacks)
282
345
        branch_format_name = response[1]
283
346
        if not branch_format_name:
284
347
            branch_format_name = None
285
348
        format = RemoteBranchFormat(network_name=branch_format_name)
286
349
        return RemoteBranch(self, self.find_repository(), format=format,
287
 
            setup_stacking=not ignore_fallbacks)
 
350
            setup_stacking=not ignore_fallbacks, name=name)
288
351
 
289
352
    def _open_repo_v1(self, path):
290
353
        verb = 'BzrDir.find_repository'
351
414
        else:
352
415
            raise errors.NoRepositoryPresent(self)
353
416
 
 
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
 
354
423
    def open_workingtree(self, recommend_upgrade=True):
355
 
        self._ensure_real()
356
 
        if self._real_bzrdir.has_workingtree():
 
424
        if self.has_workingtree():
357
425
            raise errors.NotLocalUrl(self.root_transport)
358
426
        else:
359
427
            raise errors.NoWorkingTree(self.root_transport.base)
362
430
        """Return the path to be used for this bzrdir in a remote call."""
363
431
        return client.remote_path_from_transport(self.root_transport)
364
432
 
365
 
    def get_branch_transport(self, branch_format):
 
433
    def get_branch_transport(self, branch_format, name=None):
366
434
        self._ensure_real()
367
 
        return self._real_bzrdir.get_branch_transport(branch_format)
 
435
        return self._real_bzrdir.get_branch_transport(branch_format, name=name)
368
436
 
369
437
    def get_repository_transport(self, repository_format):
370
438
        self._ensure_real()
422
490
        self._custom_format = None
423
491
        self._network_name = None
424
492
        self._creating_bzrdir = None
 
493
        self._supports_chks = None
425
494
        self._supports_external_lookups = None
426
495
        self._supports_tree_reference = None
427
496
        self._rich_root_data = None
428
497
 
 
498
    def __repr__(self):
 
499
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
500
            self._network_name)
 
501
 
429
502
    @property
430
503
    def fast_deltas(self):
431
504
        self._ensure_real()
439
512
        return self._rich_root_data
440
513
 
441
514
    @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
442
522
    def supports_external_lookups(self):
443
523
        if self._supports_external_lookups is None:
444
524
            self._ensure_real()
545
625
        return self._custom_format._fetch_reconcile
546
626
 
547
627
    def get_format_description(self):
548
 
        return 'bzr remote repository'
 
628
        self._ensure_real()
 
629
        return 'Remote: ' + self._custom_format.get_format_description()
549
630
 
550
631
    def __eq__(self, other):
551
632
        return self.__class__ is other.__class__
552
633
 
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
 
 
562
634
    def network_name(self):
563
635
        if self._network_name:
564
636
            return self._network_name
576
648
        return self._custom_format._serializer
577
649
 
578
650
 
579
 
class RemoteRepository(_RpcHelper):
 
651
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
 
652
    controldir.ControlComponent):
580
653
    """Repository accessed over rpc.
581
654
 
582
655
    For the moment most operations are performed using local transport-backed
625
698
        # Additional places to query for data.
626
699
        self._fallback_repositories = []
627
700
 
 
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
        
628
712
    def __str__(self):
629
713
        return "%s(%s)" % (self.__class__.__name__, self.base)
630
714
 
813
897
            result.add(_mod_revision.NULL_REVISION)
814
898
        return result
815
899
 
 
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
 
816
913
    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
817
917
        return (self.__class__ is other.__class__ and
818
918
                self.bzrdir.transport.base == other.bzrdir.transport.base)
819
919
 
822
922
        parents_provider = self._make_parents_provider(other_repository)
823
923
        return graph.Graph(parents_provider)
824
924
 
 
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
 
825
934
    def gather_stats(self, revid=None, committers=None):
826
935
        """See Repository.gather_stats()."""
827
936
        path = self.bzrdir._path_for_remote_call(self._client)
887
996
    def is_write_locked(self):
888
997
        return self._lock_mode == 'w'
889
998
 
 
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
 
890
1004
    def lock_read(self):
 
1005
        """Lock the repository for read operations.
 
1006
 
 
1007
        :return: A bzrlib.lock.LogicalLockResult.
 
1008
        """
891
1009
        # wrong eventually - want a local lock cache context
892
1010
        if not self._lock_mode:
 
1011
            self._note_lock('r')
893
1012
            self._lock_mode = 'r'
894
1013
            self._lock_count = 1
895
1014
            self._unstacked_provider.enable_cache(cache_misses=True)
899
1018
                repo.lock_read()
900
1019
        else:
901
1020
            self._lock_count += 1
 
1021
        return lock.LogicalLockResult(self.unlock)
902
1022
 
903
1023
    def _remote_lock_write(self, token):
904
1024
        path = self.bzrdir._path_for_remote_call(self._client)
915
1035
 
916
1036
    def lock_write(self, token=None, _skip_rpc=False):
917
1037
        if not self._lock_mode:
 
1038
            self._note_lock('w')
918
1039
            if _skip_rpc:
919
1040
                if self._lock_token is not None:
920
1041
                    if token != self._lock_token:
943
1064
            raise errors.ReadOnlyError(self)
944
1065
        else:
945
1066
            self._lock_count += 1
946
 
        return self._lock_token or None
 
1067
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
947
1068
 
948
1069
    def leave_lock_in_place(self):
949
1070
        if not self._lock_token:
1023
1144
        else:
1024
1145
            raise errors.UnexpectedSmartServerResponse(response)
1025
1146
 
 
1147
    @only_raises(errors.LockNotHeld, errors.LockBroken)
1026
1148
    def unlock(self):
1027
1149
        if not self._lock_count:
1028
 
            raise errors.LockNotHeld(self)
 
1150
            return lock.cant_unlock_not_held(self)
1029
1151
        self._lock_count -= 1
1030
1152
        if self._lock_count > 0:
1031
1153
            return
1128
1250
            # state, so always add a lock here. If a caller passes us a locked
1129
1251
            # repository, they are responsible for unlocking it later.
1130
1252
            repository.lock_read()
 
1253
        self._check_fallback_repository(repository)
1131
1254
        self._fallback_repositories.append(repository)
1132
1255
        # If self._real_repository was parameterised already (e.g. because a
1133
1256
        # _real_branch had its get_stacked_on_url method called), then the
1134
1257
        # repository to be added may already be in the _real_repositories list.
1135
1258
        if self._real_repository is not None:
1136
 
            fallback_locations = [repo.bzrdir.root_transport.base for repo in
 
1259
            fallback_locations = [repo.user_url for repo in
1137
1260
                self._real_repository._fallback_repositories]
1138
 
            if repository.bzrdir.root_transport.base not in fallback_locations:
 
1261
            if repository.user_url not in fallback_locations:
1139
1262
                self._real_repository.add_fallback_repository(repository)
1140
1263
 
 
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
 
1141
1274
    def add_inventory(self, revid, inv, parents):
1142
1275
        self._ensure_real()
1143
1276
        return self._real_repository.add_inventory(revid, inv, parents)
1144
1277
 
1145
1278
    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1146
 
                               parents):
 
1279
            parents, basis_inv=None, propagate_caches=False):
1147
1280
        self._ensure_real()
1148
1281
        return self._real_repository.add_inventory_by_delta(basis_revision_id,
1149
 
            delta, new_revision_id, parents)
 
1282
            delta, new_revision_id, parents, basis_inv=basis_inv,
 
1283
            propagate_caches=propagate_caches)
1150
1284
 
1151
1285
    def add_revision(self, rev_id, rev, inv=None, config=None):
1152
1286
        self._ensure_real()
1158
1292
        self._ensure_real()
1159
1293
        return self._real_repository.get_inventory(revision_id)
1160
1294
 
1161
 
    def iter_inventories(self, revision_ids):
 
1295
    def iter_inventories(self, revision_ids, ordering=None):
1162
1296
        self._ensure_real()
1163
 
        return self._real_repository.iter_inventories(revision_ids)
 
1297
        return self._real_repository.iter_inventories(revision_ids, ordering)
1164
1298
 
1165
1299
    @needs_read_lock
1166
1300
    def get_revision(self, revision_id):
1182
1316
        return self._real_repository.make_working_trees()
1183
1317
 
1184
1318
    def refresh_data(self):
1185
 
        """Re-read any data needed to to synchronise with disk.
 
1319
        """Re-read any data needed to synchronise with disk.
1186
1320
 
1187
1321
        This method is intended to be called after another repository instance
1188
1322
        (such as one used by a smart server) has inserted data into the
1189
 
        repository. It may not be called during a write group, but may be
1190
 
        called at any other time.
 
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.
1191
1328
        """
1192
 
        if self.is_in_write_group():
1193
 
            raise errors.InternalBzrError(
1194
 
                "May not refresh_data while in a write group.")
1195
1329
        if self._real_repository is not None:
1196
1330
            self._real_repository.refresh_data()
1197
1331
 
1230
1364
            raise errors.InternalBzrError(
1231
1365
                "May not fetch while in a write group.")
1232
1366
        # fast path same-url fetch operations
1233
 
        if self.has_same_location(source) and fetch_spec is None:
 
1367
        if (self.has_same_location(source)
 
1368
            and fetch_spec is None
 
1369
            and self._has_same_fallbacks(source)):
1234
1370
            # check that last_revision is in 'from' and then return a
1235
1371
            # no-operation.
1236
1372
            if (revision_id is not None and
1409
1545
        return self._real_repository.get_signature_text(revision_id)
1410
1546
 
1411
1547
    @needs_read_lock
1412
 
    def get_inventory_xml(self, revision_id):
1413
 
        self._ensure_real()
1414
 
        return self._real_repository.get_inventory_xml(revision_id)
1415
 
 
1416
 
    def deserialise_inventory(self, revision_id, xml):
1417
 
        self._ensure_real()
1418
 
        return self._real_repository.deserialise_inventory(revision_id, xml)
 
1548
    def _get_inventory_xml(self, revision_id):
 
1549
        self._ensure_real()
 
1550
        return self._real_repository._get_inventory_xml(revision_id)
1419
1551
 
1420
1552
    def reconcile(self, other=None, thorough=False):
1421
1553
        self._ensure_real()
1448
1580
        return self._real_repository.get_revision_reconcile(revision_id)
1449
1581
 
1450
1582
    @needs_read_lock
1451
 
    def check(self, revision_ids=None):
 
1583
    def check(self, revision_ids=None, callback_refs=None, check_repo=True):
1452
1584
        self._ensure_real()
1453
 
        return self._real_repository.check(revision_ids=revision_ids)
 
1585
        return self._real_repository.check(revision_ids=revision_ids,
 
1586
            callback_refs=callback_refs, check_repo=check_repo)
1454
1587
 
1455
1588
    def copy_content_into(self, destination, revision_id=None):
1456
1589
        self._ensure_real()
1496
1629
        return self._real_repository.inventories
1497
1630
 
1498
1631
    @needs_write_lock
1499
 
    def pack(self, hint=None):
 
1632
    def pack(self, hint=None, clean_obsolete_packs=False):
1500
1633
        """Compress the data within the repository.
1501
1634
 
1502
1635
        This is not currently implemented within the smart server.
1503
1636
        """
1504
1637
        self._ensure_real()
1505
 
        return self._real_repository.pack(hint=hint)
 
1638
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
1506
1639
 
1507
1640
    @property
1508
1641
    def revisions(self):
1596
1729
        self._ensure_real()
1597
1730
        return self._real_repository.revision_graph_can_have_wrong_parents()
1598
1731
 
1599
 
    def _find_inconsistent_revision_parents(self):
 
1732
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1600
1733
        self._ensure_real()
1601
 
        return self._real_repository._find_inconsistent_revision_parents()
 
1734
        return self._real_repository._find_inconsistent_revision_parents(
 
1735
            revisions_iterator)
1602
1736
 
1603
1737
    def _check_for_inconsistent_revision_parents(self):
1604
1738
        self._ensure_real()
1658
1792
    def insert_stream(self, stream, src_format, resume_tokens):
1659
1793
        target = self.target_repo
1660
1794
        target._unstacked_provider.missing_keys.clear()
 
1795
        candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
1661
1796
        if target._lock_token:
1662
 
            verb = 'Repository.insert_stream_locked'
1663
 
            extra_args = (target._lock_token or '',)
1664
 
            required_version = (1, 14)
 
1797
            candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
 
1798
            lock_args = (target._lock_token or '',)
1665
1799
        else:
1666
 
            verb = 'Repository.insert_stream'
1667
 
            extra_args = ()
1668
 
            required_version = (1, 13)
 
1800
            candidate_calls.append(('Repository.insert_stream', (1, 13)))
 
1801
            lock_args = ()
1669
1802
        client = target._client
1670
1803
        medium = client._medium
1671
 
        if medium._is_remote_before(required_version):
1672
 
            # No possible way this can work.
1673
 
            return self._insert_real(stream, src_format, resume_tokens)
1674
1804
        path = target.bzrdir._path_for_remote_call(client)
1675
 
        if not resume_tokens:
1676
 
            # XXX: Ugly but important for correctness, *will* be fixed during
1677
 
            # 1.13 cycle. Pushing a stream that is interrupted results in a
1678
 
            # fallback to the _real_repositories sink *with a partial stream*.
1679
 
            # Thats bad because we insert less data than bzr expected. To avoid
1680
 
            # this we do a trial push to make sure the verb is accessible, and
1681
 
            # do not fallback when actually pushing the stream. A cleanup patch
1682
 
            # is going to look at rewinding/restarting the stream/partial
1683
 
            # buffering etc.
 
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
1684
1818
            byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1685
1819
            try:
1686
1820
                response = client.call_with_body_stream(
1687
 
                    (verb, path, '') + extra_args, byte_stream)
 
1821
                    (verb, path, '') + lock_args, byte_stream)
1688
1822
            except errors.UnknownSmartMethod:
1689
1823
                medium._remember_remote_is_before(required_version)
1690
 
                return self._insert_real(stream, src_format, resume_tokens)
 
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)
1691
1838
        byte_stream = smart_repo._stream_to_byte_stream(
1692
1839
            stream, src_format)
1693
1840
        resume_tokens = ' '.join(resume_tokens)
1694
1841
        response = client.call_with_body_stream(
1695
 
            (verb, path, resume_tokens) + extra_args, byte_stream)
 
1842
            (verb, path, resume_tokens) + lock_args, byte_stream)
1696
1843
        if response[0][0] not in ('ok', 'missing-basis'):
1697
1844
            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)
1698
1851
        if response[0][0] == 'missing-basis':
1699
1852
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1700
1853
            resume_tokens = tokens
1703
1856
            self.target_repo.refresh_data()
1704
1857
            return [], set()
1705
1858
 
 
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
            
1706
1899
 
1707
1900
class RemoteStreamSource(repository.StreamSource):
1708
1901
    """Stream data from a remote server."""
1711
1904
        if (self.from_repository._fallback_repositories and
1712
1905
            self.to_format._fetch_order == 'topological'):
1713
1906
            return self._real_stream(self.from_repository, search)
1714
 
        return self.missing_parents_chain(search, [self.from_repository] +
1715
 
            self.from_repository._fallback_repositories)
 
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)
1716
1924
 
1717
1925
    def _real_stream(self, repo, search):
1718
1926
        """Get a stream for search from repo.
1725
1933
        """
1726
1934
        source = repo._get_source(self.to_format)
1727
1935
        if isinstance(source, RemoteStreamSource):
1728
 
            return repository.StreamSource.get_stream(source, search)
 
1936
            repo._ensure_real()
 
1937
            source = repo._real_repository._get_source(self.to_format)
1729
1938
        return source.get_stream(search)
1730
1939
 
1731
1940
    def _get_stream(self, repo, search):
1748
1957
            return self._real_stream(repo, search)
1749
1958
        client = repo._client
1750
1959
        medium = client._medium
1751
 
        if medium._is_remote_before((1, 13)):
1752
 
            # streaming was added in 1.13
1753
 
            return self._real_stream(repo, search)
1754
1960
        path = repo.bzrdir._path_for_remote_call(client)
1755
 
        try:
1756
 
            search_bytes = repo._serialise_search_result(search)
1757
 
            response = repo._call_with_body_bytes_expecting_body(
1758
 
                'Repository.get_stream',
1759
 
                (path, self.to_format.network_name()), search_bytes)
1760
 
            response_tuple, response_handler = response
1761
 
        except errors.UnknownSmartMethod:
1762
 
            medium._remember_remote_is_before((1,13))
 
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:
1763
1980
            return self._real_stream(repo, search)
1764
1981
        if response_tuple[0] != 'ok':
1765
1982
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1766
1983
        byte_stream = response_handler.read_streamed_body()
1767
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
1984
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
1985
            self._record_counter)
1768
1986
        if src_format.network_name() != repo._format.network_name():
1769
1987
            raise AssertionError(
1770
1988
                "Mismatched RemoteRepository and stream src %r, %r" % (
1777
1995
        :param search: The overall search to satisfy with streams.
1778
1996
        :param sources: A list of Repository objects to query.
1779
1997
        """
1780
 
        self.serialiser = self.to_format._serializer
 
1998
        self.from_serialiser = self.from_repository._format._serializer
1781
1999
        self.seen_revs = set()
1782
2000
        self.referenced_revs = set()
1783
2001
        # If there are heads in the search, or the key count is > 0, we are not
1800
2018
    def missing_parents_rev_handler(self, substream):
1801
2019
        for content in substream:
1802
2020
            revision_bytes = content.get_bytes_as('fulltext')
1803
 
            revision = self.serialiser.read_revision_from_string(revision_bytes)
 
2021
            revision = self.from_serialiser.read_revision_from_string(
 
2022
                revision_bytes)
1804
2023
            self.seen_revs.add(content.key[-1])
1805
2024
            self.referenced_revs.update(revision.parent_ids)
1806
2025
            yield content
1845
2064
                self._network_name)
1846
2065
 
1847
2066
    def get_format_description(self):
1848
 
        return 'Remote BZR Branch'
 
2067
        self._ensure_real()
 
2068
        return 'Remote: ' + self._custom_format.get_format_description()
1849
2069
 
1850
2070
    def network_name(self):
1851
2071
        return self._network_name
1852
2072
 
1853
 
    def open(self, a_bzrdir, ignore_fallbacks=False):
1854
 
        return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
 
2073
    def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
 
2074
        return a_bzrdir.open_branch(name=name, 
 
2075
            ignore_fallbacks=ignore_fallbacks)
1855
2076
 
1856
 
    def _vfs_initialize(self, a_bzrdir):
 
2077
    def _vfs_initialize(self, a_bzrdir, name):
1857
2078
        # Initialisation when using a local bzrdir object, or a non-vfs init
1858
2079
        # method is not available on the server.
1859
2080
        # self._custom_format is always set - the start of initialize ensures
1860
2081
        # that.
1861
2082
        if isinstance(a_bzrdir, RemoteBzrDir):
1862
2083
            a_bzrdir._ensure_real()
1863
 
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
 
2084
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
 
2085
                name)
1864
2086
        else:
1865
2087
            # We assume the bzrdir is parameterised; it may not be.
1866
 
            result = self._custom_format.initialize(a_bzrdir)
 
2088
            result = self._custom_format.initialize(a_bzrdir, name)
1867
2089
        if (isinstance(a_bzrdir, RemoteBzrDir) and
1868
2090
            not isinstance(result, RemoteBranch)):
1869
 
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
 
2091
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
 
2092
                                  name=name)
1870
2093
        return result
1871
2094
 
1872
 
    def initialize(self, a_bzrdir):
 
2095
    def initialize(self, a_bzrdir, name=None):
1873
2096
        # 1) get the network name to use.
1874
2097
        if self._custom_format:
1875
2098
            network_name = self._custom_format.network_name()
1881
2104
            network_name = reference_format.network_name()
1882
2105
        # Being asked to create on a non RemoteBzrDir:
1883
2106
        if not isinstance(a_bzrdir, RemoteBzrDir):
1884
 
            return self._vfs_initialize(a_bzrdir)
 
2107
            return self._vfs_initialize(a_bzrdir, name=name)
1885
2108
        medium = a_bzrdir._client._medium
1886
2109
        if medium._is_remote_before((1, 13)):
1887
 
            return self._vfs_initialize(a_bzrdir)
 
2110
            return self._vfs_initialize(a_bzrdir, name=name)
1888
2111
        # Creating on a remote bzr dir.
1889
2112
        # 2) try direct creation via RPC
1890
2113
        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)
1891
2117
        verb = 'BzrDir.create_branch'
1892
2118
        try:
1893
2119
            response = a_bzrdir._call(verb, path, network_name)
1894
2120
        except errors.UnknownSmartMethod:
1895
2121
            # Fallback - use vfs methods
1896
2122
            medium._remember_remote_is_before((1, 13))
1897
 
            return self._vfs_initialize(a_bzrdir)
 
2123
            return self._vfs_initialize(a_bzrdir, name=name)
1898
2124
        if response[0] != 'ok':
1899
2125
            raise errors.UnexpectedSmartServerResponse(response)
1900
2126
        # Turn the response into a RemoteRepository object.
1908
2134
                a_bzrdir._client)
1909
2135
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
1910
2136
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
1911
 
            format=format, setup_stacking=False)
 
2137
            format=format, setup_stacking=False, name=name)
1912
2138
        # XXX: We know this is a new branch, so it must have revno 0, revid
1913
2139
        # NULL_REVISION. Creating the branch locked would make this be unable
1914
2140
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
1934
2160
        return self._custom_format.supports_set_append_revisions_only()
1935
2161
 
1936
2162
 
1937
 
class RemoteBranch(branch.Branch, _RpcHelper):
 
2163
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
1938
2164
    """Branch stored on a server accessed by HPSS RPC.
1939
2165
 
1940
2166
    At the moment most operations are mapped down to simple file operations.
1941
2167
    """
1942
2168
 
1943
2169
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
1944
 
        _client=None, format=None, setup_stacking=True):
 
2170
        _client=None, format=None, setup_stacking=True, name=None):
1945
2171
        """Create a RemoteBranch instance.
1946
2172
 
1947
2173
        :param real_branch: An optional local implementation of the branch
1953
2179
        :param setup_stacking: If True make an RPC call to determine the
1954
2180
            stacked (or not) status of the branch. If False assume the branch
1955
2181
            is not stacked.
 
2182
        :param name: Colocated branch name
1956
2183
        """
1957
2184
        # We intentionally don't call the parent class's __init__, because it
1958
2185
        # will try to assign to self.tags, which is a property in this subclass.
1977
2204
            self._real_branch = None
1978
2205
        # Fill out expected attributes of branch for bzrlib API users.
1979
2206
        self._clear_cached_state()
1980
 
        self.base = self.bzrdir.root_transport.base
 
2207
        # TODO: deprecate self.base in favor of user_url
 
2208
        self.base = self.bzrdir.user_url
 
2209
        self._name = name
1981
2210
        self._control_files = None
1982
2211
        self._lock_mode = None
1983
2212
        self._lock_token = None
1994
2223
                    self._real_branch._format.network_name()
1995
2224
        else:
1996
2225
            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
1997
2229
        if not self._format._network_name:
1998
2230
            # Did not get from open_branchV2 - old server.
1999
2231
            self._ensure_real()
2044
2276
                raise AssertionError('smart server vfs must be enabled '
2045
2277
                    'to use vfs implementation')
2046
2278
            self.bzrdir._ensure_real()
2047
 
            self._real_branch = self.bzrdir._real_bzrdir.open_branch()
 
2279
            self._real_branch = self.bzrdir._real_bzrdir.open_branch(
 
2280
                ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
2048
2281
            if self.repository._real_repository is None:
2049
2282
                # Give the remote repository the matching real repo.
2050
2283
                real_repo = self._real_branch.repository
2146
2379
            return self._vfs_get_tags_bytes()
2147
2380
        return response[0]
2148
2381
 
 
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
 
2149
2400
    def lock_read(self):
 
2401
        """Lock the branch for read operations.
 
2402
 
 
2403
        :return: A bzrlib.lock.LogicalLockResult.
 
2404
        """
2150
2405
        self.repository.lock_read()
2151
2406
        if not self._lock_mode:
 
2407
            self._note_lock('r')
2152
2408
            self._lock_mode = 'r'
2153
2409
            self._lock_count = 1
2154
2410
            if self._real_branch is not None:
2155
2411
                self._real_branch.lock_read()
2156
2412
        else:
2157
2413
            self._lock_count += 1
 
2414
        return lock.LogicalLockResult(self.unlock)
2158
2415
 
2159
2416
    def _remote_lock_write(self, token):
2160
2417
        if token is None:
2161
2418
            branch_token = repo_token = ''
2162
2419
        else:
2163
2420
            branch_token = token
2164
 
            repo_token = self.repository.lock_write()
 
2421
            repo_token = self.repository.lock_write().repository_token
2165
2422
            self.repository.unlock()
2166
2423
        err_context = {'token': token}
2167
 
        response = self._call(
2168
 
            'Branch.lock_write', self._remote_path(), branch_token,
2169
 
            repo_token or '', **err_context)
 
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])
2170
2434
        if response[0] != 'ok':
2171
2435
            raise errors.UnexpectedSmartServerResponse(response)
2172
2436
        ok, branch_token, repo_token = response
2174
2438
 
2175
2439
    def lock_write(self, token=None):
2176
2440
        if not self._lock_mode:
 
2441
            self._note_lock('w')
2177
2442
            # Lock the branch and repo in one remote call.
2178
2443
            remote_tokens = self._remote_lock_write(token)
2179
2444
            self._lock_token, self._repo_lock_token = remote_tokens
2192
2457
            self._lock_mode = 'w'
2193
2458
            self._lock_count = 1
2194
2459
        elif self._lock_mode == 'r':
2195
 
            raise errors.ReadOnlyTransaction
 
2460
            raise errors.ReadOnlyError(self)
2196
2461
        else:
2197
2462
            if token is not None:
2198
2463
                # A token was given to lock_write, and we're relocking, so
2203
2468
            self._lock_count += 1
2204
2469
            # Re-lock the repository too.
2205
2470
            self.repository.lock_write(self._repo_lock_token)
2206
 
        return self._lock_token or None
2207
 
 
2208
 
    def _set_tags_bytes(self, bytes):
2209
 
        self._ensure_real()
2210
 
        return self._real_branch._set_tags_bytes(bytes)
 
2471
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
2211
2472
 
2212
2473
    def _unlock(self, branch_token, repo_token):
2213
2474
        err_context = {'token': str((branch_token, repo_token))}
2218
2479
            return
2219
2480
        raise errors.UnexpectedSmartServerResponse(response)
2220
2481
 
 
2482
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2221
2483
    def unlock(self):
2222
2484
        try:
2223
2485
            self._lock_count -= 1
2263
2525
            raise NotImplementedError(self.dont_leave_lock_in_place)
2264
2526
        self._leave_lock = False
2265
2527
 
 
2528
    @needs_read_lock
2266
2529
    def get_rev_id(self, revno, history=None):
2267
2530
        if revno == 0:
2268
2531
            return _mod_revision.NULL_REVISION
2534
2797
        medium = self._branch._client._medium
2535
2798
        if medium._is_remote_before((1, 14)):
2536
2799
            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):
2537
2808
        try:
2538
2809
            path = self._branch._remote_path()
2539
2810
            response = self._branch._client.call('Branch.set_config_option',
2540
2811
                path, self._branch._lock_token, self._branch._repo_lock_token,
2541
2812
                value.encode('utf8'), name, section or '')
2542
2813
        except errors.UnknownSmartMethod:
 
2814
            medium = self._branch._client._medium
2543
2815
            medium._remember_remote_is_before((1, 14))
2544
2816
            return self._vfs_set_option(value, name, section)
2545
2817
        if response != ():
2546
2818
            raise errors.UnexpectedSmartServerResponse(response)
2547
2819
 
 
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
 
2548
2845
    def _real_object(self):
2549
2846
        self._branch._ensure_real()
2550
2847
        return self._branch._real_branch
2633
2930
                    'Missing key %r in context %r', key_err.args[0], context)
2634
2931
                raise err
2635
2932
 
2636
 
    if err.error_verb == 'NoSuchRevision':
 
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':
2637
2937
        raise NoSuchRevision(find('branch'), err.error_args[0])
2638
2938
    elif err.error_verb == 'nosuchrevision':
2639
2939
        raise NoSuchRevision(find('repository'), err.error_args[0])
2640
 
    elif err.error_tuple == ('nobranch',):
2641
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
 
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)
2642
2947
    elif err.error_verb == 'norepository':
2643
2948
        raise errors.NoRepositoryPresent(find('bzrdir'))
2644
2949
    elif err.error_verb == 'LockContention':