← 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: 2011-05-24 14:40:29 UTC
  • mfrom: (5609.39.7 2.3)
  • Revision ID: pqm@pqm.ubuntu.com-20110524144029-owqlr788c9s99jv5
(jam) Merge bzr-2.3 into bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2011 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
19
19
from bzrlib import (
20
20
    bencode,
21
21
    branch,
22
 
    bzrdir,
 
22
    bzrdir as _mod_bzrdir,
23
23
    config,
 
24
    controldir,
24
25
    debug,
25
26
    errors,
26
27
    graph,
27
28
    lock,
28
29
    lockdir,
29
 
    repository,
30
 
    revision,
 
30
    repository as _mod_repository,
31
31
    revision as _mod_revision,
 
32
    static_tuple,
32
33
    symbol_versioning,
33
 
)
34
 
from bzrlib.branch import BranchReferenceFormat
35
 
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
 
34
    urlutils,
 
35
    versionedfile,
 
36
    vf_repository,
 
37
    )
 
38
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
36
39
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
37
40
from bzrlib.errors import (
38
41
    NoSuchRevision,
40
43
    )
41
44
from bzrlib.lockable_files import LockableFiles
42
45
from bzrlib.smart import client, vfs, repository as smart_repo
43
 
from bzrlib.revision import ensure_null, NULL_REVISION
 
46
from bzrlib.smart.client import _SmartClient
 
47
from bzrlib.revision import NULL_REVISION
 
48
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
44
49
from bzrlib.trace import mutter, note, warning
45
50
 
46
51
 
84
89
    return format
85
90
 
86
91
 
87
 
# Note: RemoteBzrDirFormat is in bzrdir.py
88
 
 
89
 
class RemoteBzrDir(BzrDir, _RpcHelper):
 
92
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
 
93
# does not have to be imported unless a remote format is involved.
 
94
 
 
95
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
 
96
    """Format representing bzrdirs accessed via a smart server"""
 
97
 
 
98
    supports_workingtrees = False
 
99
 
 
100
    def __init__(self):
 
101
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
 
102
        # XXX: It's a bit ugly that the network name is here, because we'd
 
103
        # like to believe that format objects are stateless or at least
 
104
        # immutable,  However, we do at least avoid mutating the name after
 
105
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
 
106
        self._network_name = None
 
107
 
 
108
    def __repr__(self):
 
109
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
110
            self._network_name)
 
111
 
 
112
    def get_format_description(self):
 
113
        if self._network_name:
 
114
            real_format = controldir.network_format_registry.get(self._network_name)
 
115
            return 'Remote: ' + real_format.get_format_description()
 
116
        return 'bzr remote bzrdir'
 
117
 
 
118
    def get_format_string(self):
 
119
        raise NotImplementedError(self.get_format_string)
 
120
 
 
121
    def network_name(self):
 
122
        if self._network_name:
 
123
            return self._network_name
 
124
        else:
 
125
            raise AssertionError("No network name set.")
 
126
 
 
127
    def initialize_on_transport(self, transport):
 
128
        try:
 
129
            # hand off the request to the smart server
 
130
            client_medium = transport.get_smart_medium()
 
131
        except errors.NoSmartMedium:
 
132
            # TODO: lookup the local format from a server hint.
 
133
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
134
            return local_dir_format.initialize_on_transport(transport)
 
135
        client = _SmartClient(client_medium)
 
136
        path = client.remote_path_from_transport(transport)
 
137
        try:
 
138
            response = client.call('BzrDirFormat.initialize', path)
 
139
        except errors.ErrorFromSmartServer, err:
 
140
            _translate_error(err, path=path)
 
141
        if response[0] != 'ok':
 
142
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
 
143
        format = RemoteBzrDirFormat()
 
144
        self._supply_sub_formats_to(format)
 
145
        return RemoteBzrDir(transport, format)
 
146
 
 
147
    def parse_NoneTrueFalse(self, arg):
 
148
        if not arg:
 
149
            return None
 
150
        if arg == 'False':
 
151
            return False
 
152
        if arg == 'True':
 
153
            return True
 
154
        raise AssertionError("invalid arg %r" % arg)
 
155
 
 
156
    def _serialize_NoneTrueFalse(self, arg):
 
157
        if arg is False:
 
158
            return 'False'
 
159
        if arg:
 
160
            return 'True'
 
161
        return ''
 
162
 
 
163
    def _serialize_NoneString(self, arg):
 
164
        return arg or ''
 
165
 
 
166
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
167
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
168
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
169
        shared_repo=False):
 
170
        try:
 
171
            # hand off the request to the smart server
 
172
            client_medium = transport.get_smart_medium()
 
173
        except errors.NoSmartMedium:
 
174
            do_vfs = True
 
175
        else:
 
176
            # Decline to open it if the server doesn't support our required
 
177
            # version (3) so that the VFS-based transport will do it.
 
178
            if client_medium.should_probe():
 
179
                try:
 
180
                    server_version = client_medium.protocol_version()
 
181
                    if server_version != '2':
 
182
                        do_vfs = True
 
183
                    else:
 
184
                        do_vfs = False
 
185
                except errors.SmartProtocolError:
 
186
                    # Apparently there's no usable smart server there, even though
 
187
                    # the medium supports the smart protocol.
 
188
                    do_vfs = True
 
189
            else:
 
190
                do_vfs = False
 
191
        if not do_vfs:
 
192
            client = _SmartClient(client_medium)
 
193
            path = client.remote_path_from_transport(transport)
 
194
            if client_medium._is_remote_before((1, 16)):
 
195
                do_vfs = True
 
196
        if do_vfs:
 
197
            # TODO: lookup the local format from a server hint.
 
198
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
199
            self._supply_sub_formats_to(local_dir_format)
 
200
            return local_dir_format.initialize_on_transport_ex(transport,
 
201
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
202
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
203
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
204
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
205
                vfs_only=True)
 
206
        return self._initialize_on_transport_ex_rpc(client, path, transport,
 
207
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
208
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
 
209
 
 
210
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
 
211
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
212
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
 
213
        args = []
 
214
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
 
215
        args.append(self._serialize_NoneTrueFalse(create_prefix))
 
216
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
 
217
        args.append(self._serialize_NoneString(stacked_on))
 
218
        # stack_on_pwd is often/usually our transport
 
219
        if stack_on_pwd:
 
220
            try:
 
221
                stack_on_pwd = transport.relpath(stack_on_pwd)
 
222
                if not stack_on_pwd:
 
223
                    stack_on_pwd = '.'
 
224
            except errors.PathNotChild:
 
225
                pass
 
226
        args.append(self._serialize_NoneString(stack_on_pwd))
 
227
        args.append(self._serialize_NoneString(repo_format_name))
 
228
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
 
229
        args.append(self._serialize_NoneTrueFalse(shared_repo))
 
230
        request_network_name = self._network_name or \
 
231
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
 
232
        try:
 
233
            response = client.call('BzrDirFormat.initialize_ex_1.16',
 
234
                request_network_name, path, *args)
 
235
        except errors.UnknownSmartMethod:
 
236
            client._medium._remember_remote_is_before((1,16))
 
237
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
238
            self._supply_sub_formats_to(local_dir_format)
 
239
            return local_dir_format.initialize_on_transport_ex(transport,
 
240
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
241
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
242
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
243
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
244
                vfs_only=True)
 
245
        except errors.ErrorFromSmartServer, err:
 
246
            _translate_error(err, path=path)
 
247
        repo_path = response[0]
 
248
        bzrdir_name = response[6]
 
249
        require_stacking = response[7]
 
250
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
 
251
        format = RemoteBzrDirFormat()
 
252
        format._network_name = bzrdir_name
 
253
        self._supply_sub_formats_to(format)
 
254
        bzrdir = RemoteBzrDir(transport, format, _client=client)
 
255
        if repo_path:
 
256
            repo_format = response_tuple_to_repo_format(response[1:])
 
257
            if repo_path == '.':
 
258
                repo_path = ''
 
259
            if repo_path:
 
260
                repo_bzrdir_format = RemoteBzrDirFormat()
 
261
                repo_bzrdir_format._network_name = response[5]
 
262
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
 
263
                    repo_bzrdir_format)
 
264
            else:
 
265
                repo_bzr = bzrdir
 
266
            final_stack = response[8] or None
 
267
            final_stack_pwd = response[9] or None
 
268
            if final_stack_pwd:
 
269
                final_stack_pwd = urlutils.join(
 
270
                    transport.base, final_stack_pwd)
 
271
            remote_repo = RemoteRepository(repo_bzr, repo_format)
 
272
            if len(response) > 10:
 
273
                # Updated server verb that locks remotely.
 
274
                repo_lock_token = response[10] or None
 
275
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
 
276
                if repo_lock_token:
 
277
                    remote_repo.dont_leave_lock_in_place()
 
278
            else:
 
279
                remote_repo.lock_write()
 
280
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
 
281
                final_stack_pwd, require_stacking)
 
282
            policy.acquire_repository()
 
283
        else:
 
284
            remote_repo = None
 
285
            policy = None
 
286
        bzrdir._format.set_branch_format(self.get_branch_format())
 
287
        if require_stacking:
 
288
            # The repo has already been created, but we need to make sure that
 
289
            # we'll make a stackable branch.
 
290
            bzrdir._format.require_stacking(_skip_repo=True)
 
291
        return remote_repo, bzrdir, require_stacking, policy
 
292
 
 
293
    def _open(self, transport):
 
294
        return RemoteBzrDir(transport, self)
 
295
 
 
296
    def __eq__(self, other):
 
297
        if not isinstance(other, RemoteBzrDirFormat):
 
298
            return False
 
299
        return self.get_format_description() == other.get_format_description()
 
300
 
 
301
    def __return_repository_format(self):
 
302
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
 
303
        # repository format has been asked for, tell the RemoteRepositoryFormat
 
304
        # that it should use that for init() etc.
 
305
        result = RemoteRepositoryFormat()
 
306
        custom_format = getattr(self, '_repository_format', None)
 
307
        if custom_format:
 
308
            if isinstance(custom_format, RemoteRepositoryFormat):
 
309
                return custom_format
 
310
            else:
 
311
                # We will use the custom format to create repositories over the
 
312
                # wire; expose its details like rich_root_data for code to
 
313
                # query
 
314
                result._custom_format = custom_format
 
315
        return result
 
316
 
 
317
    def get_branch_format(self):
 
318
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
 
319
        if not isinstance(result, RemoteBranchFormat):
 
320
            new_result = RemoteBranchFormat()
 
321
            new_result._custom_format = result
 
322
            # cache the result
 
323
            self.set_branch_format(new_result)
 
324
            result = new_result
 
325
        return result
 
326
 
 
327
    repository_format = property(__return_repository_format,
 
328
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
 
329
 
 
330
 
 
331
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
90
332
    """Control directory on a remote server, accessed via bzr:// or similar."""
91
333
 
92
334
    def __init__(self, transport, format, _client=None, _force_probe=False):
95
337
        :param _client: Private parameter for testing. Disables probing and the
96
338
            use of a real bzrdir.
97
339
        """
98
 
        BzrDir.__init__(self, transport, format)
 
340
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
99
341
        # this object holds a delegated bzrdir that uses file-level operations
100
342
        # to talk to the other side
101
343
        self._real_bzrdir = None
161
403
                import traceback
162
404
                warning('VFS BzrDir access triggered\n%s',
163
405
                    ''.join(traceback.format_stack()))
164
 
            self._real_bzrdir = BzrDir.open_from_transport(
 
406
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
165
407
                self.root_transport, _server_formats=False)
166
408
            self._format._network_name = \
167
409
                self._real_bzrdir._format.network_name()
173
415
        # Prevent aliasing problems in the next_open_branch_result cache.
174
416
        # See create_branch for rationale.
175
417
        self._next_open_branch_result = None
176
 
        return BzrDir.break_lock(self)
 
418
        return _mod_bzrdir.BzrDir.break_lock(self)
177
419
 
178
420
    def _vfs_cloning_metadir(self, require_stacking=False):
179
421
        self._ensure_real()
210
452
        if len(branch_info) != 2:
211
453
            raise errors.UnexpectedSmartServerResponse(response)
212
454
        branch_ref, branch_name = branch_info
213
 
        format = bzrdir.network_format_registry.get(control_name)
 
455
        format = controldir.network_format_registry.get(control_name)
214
456
        if repo_name:
215
 
            format.repository_format = repository.network_format_registry.get(
 
457
            format.repository_format = _mod_repository.network_format_registry.get(
216
458
                repo_name)
217
459
        if branch_ref == 'ref':
218
460
            # XXX: we need possible_transports here to avoid reopening the
219
461
            # connection to the referenced location
220
 
            ref_bzrdir = BzrDir.open(branch_name)
 
462
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
221
463
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
222
464
            format.set_branch_format(branch_format)
223
465
        elif branch_ref == 'branch':
242
484
        self._ensure_real()
243
485
        self._real_bzrdir.destroy_repository()
244
486
 
245
 
    def create_branch(self, name=None):
 
487
    def create_branch(self, name=None, repository=None):
246
488
        # as per meta1 formats - just delegate to the format object which may
247
489
        # be parameterised.
248
490
        real_branch = self._format.get_branch_format().initialize(self,
249
 
            name=name)
 
491
            name=name, repository=repository)
250
492
        if not isinstance(real_branch, RemoteBranch):
251
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
252
 
                                  name=name)
 
493
            if not isinstance(repository, RemoteRepository):
 
494
                raise AssertionError(
 
495
                    'need a RemoteRepository to use with RemoteBranch, got %r'
 
496
                    % (repository,))
 
497
            result = RemoteBranch(self, repository, real_branch, name=name)
253
498
        else:
254
499
            result = real_branch
255
500
        # BzrDir.clone_on_transport() uses the result of create_branch but does
267
512
        self._real_bzrdir.destroy_branch(name=name)
268
513
        self._next_open_branch_result = None
269
514
 
270
 
    def create_workingtree(self, revision_id=None, from_branch=None):
 
515
    def create_workingtree(self, revision_id=None, from_branch=None,
 
516
        accelerator_tree=None, hardlink=False):
271
517
        raise errors.NotLocalUrl(self.transport.base)
272
518
 
273
 
    def find_branch_format(self):
 
519
    def find_branch_format(self, name=None):
274
520
        """Find the branch 'format' for this bzrdir.
275
521
 
276
522
        This might be a synthetic object for e.g. RemoteBranch and SVN.
277
523
        """
278
 
        b = self.open_branch()
 
524
        b = self.open_branch(name=name)
279
525
        return b._format
280
526
 
281
 
    def get_branch_reference(self):
 
527
    def get_branch_reference(self, name=None):
282
528
        """See BzrDir.get_branch_reference()."""
 
529
        if name is not None:
 
530
            # XXX JRV20100304: Support opening colocated branches
 
531
            raise errors.NoColocatedBranchSupport(self)
283
532
        response = self._get_branch_reference()
284
533
        if response[0] == 'ref':
285
534
            return response[1]
316
565
            raise errors.UnexpectedSmartServerResponse(response)
317
566
        return response
318
567
 
319
 
    def _get_tree_branch(self):
 
568
    def _get_tree_branch(self, name=None):
320
569
        """See BzrDir._get_tree_branch()."""
321
 
        return None, self.open_branch()
 
570
        return None, self.open_branch(name=name)
322
571
 
323
572
    def open_branch(self, name=None, unsupported=False,
324
573
                    ignore_fallbacks=False):
439
688
        """Upgrading of remote bzrdirs is not supported yet."""
440
689
        return False
441
690
 
442
 
    def needs_format_conversion(self, format=None):
 
691
    def needs_format_conversion(self, format):
443
692
        """Upgrading of remote bzrdirs is not supported yet."""
444
 
        if format is None:
445
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
446
 
                % 'needs_format_conversion(format=None)')
447
693
        return False
448
694
 
449
695
    def clone(self, url, revision_id=None, force_new_repo=False,
456
702
        return RemoteBzrDirConfig(self)
457
703
 
458
704
 
459
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
705
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
460
706
    """Format for repositories accessed over a _SmartClient.
461
707
 
462
708
    Instances of this repository are represented by RemoteRepository
477
723
    """
478
724
 
479
725
    _matchingbzrdir = RemoteBzrDirFormat()
 
726
    supports_full_versioned_files = True
 
727
    supports_leaving_lock = True
480
728
 
481
729
    def __init__(self):
482
 
        repository.RepositoryFormat.__init__(self)
 
730
        _mod_repository.RepositoryFormat.__init__(self)
483
731
        self._custom_format = None
484
732
        self._network_name = None
485
733
        self._creating_bzrdir = None
 
734
        self._revision_graph_can_have_wrong_parents = None
486
735
        self._supports_chks = None
487
736
        self._supports_external_lookups = None
488
737
        self._supports_tree_reference = None
 
738
        self._supports_funky_characters = None
489
739
        self._rich_root_data = None
490
740
 
491
741
    def __repr__(self):
520
770
        return self._supports_external_lookups
521
771
 
522
772
    @property
 
773
    def supports_funky_characters(self):
 
774
        if self._supports_funky_characters is None:
 
775
            self._ensure_real()
 
776
            self._supports_funky_characters = \
 
777
                self._custom_format.supports_funky_characters
 
778
        return self._supports_funky_characters
 
779
 
 
780
    @property
523
781
    def supports_tree_reference(self):
524
782
        if self._supports_tree_reference is None:
525
783
            self._ensure_real()
527
785
                self._custom_format.supports_tree_reference
528
786
        return self._supports_tree_reference
529
787
 
 
788
    @property
 
789
    def revision_graph_can_have_wrong_parents(self):
 
790
        if self._revision_graph_can_have_wrong_parents is None:
 
791
            self._ensure_real()
 
792
            self._revision_graph_can_have_wrong_parents = \
 
793
                self._custom_format.revision_graph_can_have_wrong_parents
 
794
        return self._revision_graph_can_have_wrong_parents
 
795
 
530
796
    def _vfs_initialize(self, a_bzrdir, shared):
531
797
        """Helper for common code in initialize."""
532
798
        if self._custom_format:
567
833
            network_name = self._network_name
568
834
        else:
569
835
            # Select the current bzrlib default and ask for that.
570
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
836
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
571
837
            reference_format = reference_bzrdir_format.repository_format
572
838
            network_name = reference_format.network_name()
573
839
        # 2) try direct creation via RPC
599
865
 
600
866
    def _ensure_real(self):
601
867
        if self._custom_format is None:
602
 
            self._custom_format = repository.network_format_registry.get(
 
868
            self._custom_format = _mod_repository.network_format_registry.get(
603
869
                self._network_name)
604
870
 
605
871
    @property
641
907
        return self._custom_format._serializer
642
908
 
643
909
 
644
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin):
 
910
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
 
911
    controldir.ControlComponent):
645
912
    """Repository accessed over rpc.
646
913
 
647
914
    For the moment most operations are performed using local transport-backed
690
957
        # Additional places to query for data.
691
958
        self._fallback_repositories = []
692
959
 
 
960
    @property
 
961
    def user_transport(self):
 
962
        return self.bzrdir.user_transport
 
963
 
 
964
    @property
 
965
    def control_transport(self):
 
966
        # XXX: Normally you shouldn't directly get at the remote repository
 
967
        # transport, but I'm not sure it's worth making this method
 
968
        # optional -- mbp 2010-04-21
 
969
        return self.bzrdir.get_repository_transport(None)
 
970
 
693
971
    def __str__(self):
694
972
        return "%s(%s)" % (self.__class__.__name__, self.base)
695
973
 
803
1081
    def find_text_key_references(self):
804
1082
        """Find the text key references within the repository.
805
1083
 
806
 
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
807
 
        revision_ids. Each altered file-ids has the exact revision_ids that
808
 
        altered it listed explicitly.
809
1084
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
810
1085
            to whether they were referred to by the inventory of the
811
1086
            revision_id that they contain. The inventory texts from all present
829
1104
        """Private method for using with old (< 1.2) servers to fallback."""
830
1105
        if revision_id is None:
831
1106
            revision_id = ''
832
 
        elif revision.is_null(revision_id):
 
1107
        elif _mod_revision.is_null(revision_id):
833
1108
            return {}
834
1109
 
835
1110
        path = self.bzrdir._path_for_remote_call(self._client)
859
1134
        return RemoteStreamSource(self, to_format)
860
1135
 
861
1136
    @needs_read_lock
 
1137
    def get_file_graph(self):
 
1138
        return graph.Graph(self.texts)
 
1139
 
 
1140
    @needs_read_lock
862
1141
    def has_revision(self, revision_id):
863
1142
        """True if this repository has a copy of the revision."""
864
1143
        # Copy of bzrlib.repository.Repository.has_revision
881
1160
    def _has_same_fallbacks(self, other_repo):
882
1161
        """Returns true if the repositories have the same fallbacks."""
883
1162
        # XXX: copied from Repository; it should be unified into a base class
884
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
1163
        # <https://bugs.launchpad.net/bzr/+bug/401622>
885
1164
        my_fb = self._fallback_repositories
886
1165
        other_fb = other_repo._fallback_repositories
887
1166
        if len(my_fb) != len(other_fb):
903
1182
        parents_provider = self._make_parents_provider(other_repository)
904
1183
        return graph.Graph(parents_provider)
905
1184
 
 
1185
    @needs_read_lock
 
1186
    def get_known_graph_ancestry(self, revision_ids):
 
1187
        """Return the known graph for a set of revision ids and their ancestors.
 
1188
        """
 
1189
        st = static_tuple.StaticTuple
 
1190
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
 
1191
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
 
1192
        return graph.GraphThunkIdsToKeys(known_graph)
 
1193
 
906
1194
    def gather_stats(self, revid=None, committers=None):
907
1195
        """See Repository.gather_stats()."""
908
1196
        path = self.bzrdir._path_for_remote_call(self._client)
909
1197
        # revid can be None to indicate no revisions, not just NULL_REVISION
910
 
        if revid is None or revision.is_null(revid):
 
1198
        if revid is None or _mod_revision.is_null(revid):
911
1199
            fmt_revid = ''
912
1200
        else:
913
1201
            fmt_revid = revid
974
1262
        pass
975
1263
 
976
1264
    def lock_read(self):
 
1265
        """Lock the repository for read operations.
 
1266
 
 
1267
        :return: A bzrlib.lock.LogicalLockResult.
 
1268
        """
977
1269
        # wrong eventually - want a local lock cache context
978
1270
        if not self._lock_mode:
979
1271
            self._note_lock('r')
986
1278
                repo.lock_read()
987
1279
        else:
988
1280
            self._lock_count += 1
 
1281
        return lock.LogicalLockResult(self.unlock)
989
1282
 
990
1283
    def _remote_lock_write(self, token):
991
1284
        path = self.bzrdir._path_for_remote_call(self._client)
1031
1324
            raise errors.ReadOnlyError(self)
1032
1325
        else:
1033
1326
            self._lock_count += 1
1034
 
        return self._lock_token or None
 
1327
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
1035
1328
 
1036
1329
    def leave_lock_in_place(self):
1037
1330
        if not self._lock_token:
1191
1484
 
1192
1485
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1193
1486
                           timezone=None, committer=None, revprops=None,
1194
 
                           revision_id=None):
 
1487
                           revision_id=None, lossy=False):
1195
1488
        # FIXME: It ought to be possible to call this without immediately
1196
1489
        # triggering _ensure_real.  For now it's the easiest thing to do.
1197
1490
        self._ensure_real()
1198
1491
        real_repo = self._real_repository
1199
1492
        builder = real_repo.get_commit_builder(branch, parents,
1200
1493
                config, timestamp=timestamp, timezone=timezone,
1201
 
                committer=committer, revprops=revprops, revision_id=revision_id)
 
1494
                committer=committer, revprops=revprops,
 
1495
                revision_id=revision_id, lossy=lossy)
1202
1496
        return builder
1203
1497
 
1204
1498
    def add_fallback_repository(self, repository):
1217
1511
            # state, so always add a lock here. If a caller passes us a locked
1218
1512
            # repository, they are responsible for unlocking it later.
1219
1513
            repository.lock_read()
 
1514
        self._check_fallback_repository(repository)
1220
1515
        self._fallback_repositories.append(repository)
1221
1516
        # If self._real_repository was parameterised already (e.g. because a
1222
1517
        # _real_branch had its get_stacked_on_url method called), then the
1223
1518
        # repository to be added may already be in the _real_repositories list.
1224
1519
        if self._real_repository is not None:
1225
 
            fallback_locations = [repo.bzrdir.root_transport.base for repo in
 
1520
            fallback_locations = [repo.user_url for repo in
1226
1521
                self._real_repository._fallback_repositories]
1227
 
            if repository.bzrdir.root_transport.base not in fallback_locations:
 
1522
            if repository.user_url not in fallback_locations:
1228
1523
                self._real_repository.add_fallback_repository(repository)
1229
1524
 
 
1525
    def _check_fallback_repository(self, repository):
 
1526
        """Check that this repository can fallback to repository safely.
 
1527
 
 
1528
        Raise an error if not.
 
1529
 
 
1530
        :param repository: A repository to fallback to.
 
1531
        """
 
1532
        return _mod_repository.InterRepository._assert_same_model(
 
1533
            self, repository)
 
1534
 
1230
1535
    def add_inventory(self, revid, inv, parents):
1231
1536
        self._ensure_real()
1232
1537
        return self._real_repository.add_inventory(revid, inv, parents)
1272
1577
        return self._real_repository.make_working_trees()
1273
1578
 
1274
1579
    def refresh_data(self):
1275
 
        """Re-read any data needed to to synchronise with disk.
 
1580
        """Re-read any data needed to synchronise with disk.
1276
1581
 
1277
1582
        This method is intended to be called after another repository instance
1278
1583
        (such as one used by a smart server) has inserted data into the
1279
 
        repository. It may not be called during a write group, but may be
1280
 
        called at any other time.
 
1584
        repository. On all repositories this will work outside of write groups.
 
1585
        Some repository formats (pack and newer for bzrlib native formats)
 
1586
        support refresh_data inside write groups. If called inside a write
 
1587
        group on a repository that does not support refreshing in a write group
 
1588
        IsInWriteGroupError will be raised.
1281
1589
        """
1282
 
        if self.is_in_write_group():
1283
 
            raise errors.InternalBzrError(
1284
 
                "May not refresh_data while in a write group.")
1285
1590
        if self._real_repository is not None:
1286
1591
            self._real_repository.refresh_data()
1287
1592
 
1299
1604
        return result
1300
1605
 
1301
1606
    @needs_read_lock
1302
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
1607
    def search_missing_revision_ids(self, other,
 
1608
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
1609
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
1610
            limit=None):
1303
1611
        """Return the revision ids that other has that this does not.
1304
1612
 
1305
1613
        These are returned in topological order.
1306
1614
 
1307
1615
        revision_id: only return revision ids included by revision_id.
1308
1616
        """
1309
 
        return repository.InterRepository.get(
1310
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
1617
        if symbol_versioning.deprecated_passed(revision_id):
 
1618
            symbol_versioning.warn(
 
1619
                'search_missing_revision_ids(revision_id=...) was '
 
1620
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
1621
                DeprecationWarning, stacklevel=2)
 
1622
            if revision_ids is not None:
 
1623
                raise AssertionError(
 
1624
                    'revision_ids is mutually exclusive with revision_id')
 
1625
            if revision_id is not None:
 
1626
                revision_ids = [revision_id]
 
1627
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
1628
        return inter_repo.search_missing_revision_ids(
 
1629
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
1630
            if_present_ids=if_present_ids, limit=limit)
1311
1631
 
1312
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
1632
    def fetch(self, source, revision_id=None, find_ghosts=False,
1313
1633
            fetch_spec=None):
1314
1634
        # No base implementation to use as RemoteRepository is not a subclass
1315
1635
        # of Repository; so this is a copy of Repository.fetch().
1326
1646
            # check that last_revision is in 'from' and then return a
1327
1647
            # no-operation.
1328
1648
            if (revision_id is not None and
1329
 
                not revision.is_null(revision_id)):
 
1649
                not _mod_revision.is_null(revision_id)):
1330
1650
                self.get_revision(revision_id)
1331
1651
            return 0, []
1332
1652
        # if there is no specific appropriate InterRepository, this will get
1333
1653
        # the InterRepository base class, which raises an
1334
1654
        # IncompatibleRepositories when asked to fetch.
1335
 
        inter = repository.InterRepository.get(source, self)
1336
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
1655
        inter = _mod_repository.InterRepository.get(source, self)
 
1656
        return inter.fetch(revision_id=revision_id,
1337
1657
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1338
1658
 
1339
1659
    def create_bundle(self, target, base, fileobj, format=None):
1563
1883
            tmpdir = osutils.mkdtemp()
1564
1884
            try:
1565
1885
                _extract_tar(tar, tmpdir)
1566
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
1886
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1567
1887
                tmp_repo = tmp_bzrdir.open_repository()
1568
1888
                tmp_repo.copy_content_into(destination, revision_id)
1569
1889
            finally:
1585
1905
        return self._real_repository.inventories
1586
1906
 
1587
1907
    @needs_write_lock
1588
 
    def pack(self, hint=None):
 
1908
    def pack(self, hint=None, clean_obsolete_packs=False):
1589
1909
        """Compress the data within the repository.
1590
1910
 
1591
1911
        This is not currently implemented within the smart server.
1592
1912
        """
1593
1913
        self._ensure_real()
1594
 
        return self._real_repository.pack(hint=hint)
 
1914
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
1595
1915
 
1596
1916
    @property
1597
1917
    def revisions(self):
1680
2000
        return self._real_repository.item_keys_introduced_by(revision_ids,
1681
2001
            _files_pb=_files_pb)
1682
2002
 
1683
 
    def revision_graph_can_have_wrong_parents(self):
1684
 
        # The answer depends on the remote repo format.
1685
 
        self._ensure_real()
1686
 
        return self._real_repository.revision_graph_can_have_wrong_parents()
1687
 
 
1688
2003
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1689
2004
        self._ensure_real()
1690
2005
        return self._real_repository._find_inconsistent_revision_parents(
1698
2013
        providers = [self._unstacked_provider]
1699
2014
        if other is not None:
1700
2015
            providers.insert(0, other)
1701
 
        providers.extend(r._make_parents_provider() for r in
1702
 
                         self._fallback_repositories)
1703
 
        return graph.StackedParentsProvider(providers)
 
2016
        return graph.StackedParentsProvider(_LazyListJoin(
 
2017
            providers, self._fallback_repositories))
1704
2018
 
1705
2019
    def _serialise_search_recipe(self, recipe):
1706
2020
        """Serialise a graph search recipe.
1714
2028
        return '\n'.join((start_keys, stop_keys, count))
1715
2029
 
1716
2030
    def _serialise_search_result(self, search_result):
1717
 
        if isinstance(search_result, graph.PendingAncestryResult):
1718
 
            parts = ['ancestry-of']
1719
 
            parts.extend(search_result.heads)
1720
 
        else:
1721
 
            recipe = search_result.get_recipe()
1722
 
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
 
2031
        parts = search_result.get_network_struct()
1723
2032
        return '\n'.join(parts)
1724
2033
 
1725
2034
    def autopack(self):
1735
2044
            raise errors.UnexpectedSmartServerResponse(response)
1736
2045
 
1737
2046
 
1738
 
class RemoteStreamSink(repository.StreamSink):
 
2047
class RemoteStreamSink(vf_repository.StreamSink):
1739
2048
 
1740
2049
    def _insert_real(self, stream, src_format, resume_tokens):
1741
2050
        self.target_repo._ensure_real()
1842
2151
        self._last_substream and self._last_stream so that the stream can be
1843
2152
        resumed by _resume_stream_with_vfs.
1844
2153
        """
1845
 
                    
 
2154
 
1846
2155
        stream_iter = iter(stream)
1847
2156
        for substream_kind, substream in stream_iter:
1848
2157
            if substream_kind == 'inventory-deltas':
1851
2160
                return
1852
2161
            else:
1853
2162
                yield substream_kind, substream
1854
 
            
1855
 
 
1856
 
class RemoteStreamSource(repository.StreamSource):
 
2163
 
 
2164
 
 
2165
class RemoteStreamSource(vf_repository.StreamSource):
1857
2166
    """Stream data from a remote server."""
1858
2167
 
1859
2168
    def get_stream(self, search):
1919
2228
        candidate_verbs = [
1920
2229
            ('Repository.get_stream_1.19', (1, 19)),
1921
2230
            ('Repository.get_stream', (1, 13))]
 
2231
 
1922
2232
        found_verb = False
1923
2233
        for verb, version in candidate_verbs:
1924
2234
            if medium._is_remote_before(version):
1928
2238
                    verb, args, search_bytes)
1929
2239
            except errors.UnknownSmartMethod:
1930
2240
                medium._remember_remote_is_before(version)
 
2241
            except errors.UnknownErrorFromSmartServer, e:
 
2242
                if isinstance(search, graph.EverythingResult):
 
2243
                    error_verb = e.error_from_smart_server.error_verb
 
2244
                    if error_verb == 'BadSearch':
 
2245
                        # Pre-2.4 servers don't support this sort of search.
 
2246
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
2247
                        # good idea in general?  It might provide a little bit
 
2248
                        # of protection against client-side bugs.
 
2249
                        medium._remember_remote_is_before((2, 4))
 
2250
                        break
 
2251
                raise
1931
2252
            else:
1932
2253
                response_tuple, response_handler = response
1933
2254
                found_verb = True
1937
2258
        if response_tuple[0] != 'ok':
1938
2259
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1939
2260
        byte_stream = response_handler.read_streamed_body()
1940
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
2261
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
2262
            self._record_counter)
1941
2263
        if src_format.network_name() != repo._format.network_name():
1942
2264
            raise AssertionError(
1943
2265
                "Mismatched RemoteRepository and stream src %r, %r" % (
2047
2369
                                  name=name)
2048
2370
        return result
2049
2371
 
2050
 
    def initialize(self, a_bzrdir, name=None):
 
2372
    def initialize(self, a_bzrdir, name=None, repository=None):
2051
2373
        # 1) get the network name to use.
2052
2374
        if self._custom_format:
2053
2375
            network_name = self._custom_format.network_name()
2054
2376
        else:
2055
2377
            # Select the current bzrlib default and ask for that.
2056
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
2378
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
2057
2379
            reference_format = reference_bzrdir_format.get_branch_format()
2058
2380
            self._custom_format = reference_format
2059
2381
            network_name = reference_format.network_name()
2081
2403
        # Turn the response into a RemoteRepository object.
2082
2404
        format = RemoteBranchFormat(network_name=response[1])
2083
2405
        repo_format = response_tuple_to_repo_format(response[3:])
2084
 
        if response[2] == '':
2085
 
            repo_bzrdir = a_bzrdir
 
2406
        repo_path = response[2]
 
2407
        if repository is not None:
 
2408
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
 
2409
            url_diff = urlutils.relative_url(repository.user_url,
 
2410
                    remote_repo_url)
 
2411
            if url_diff != '.':
 
2412
                raise AssertionError(
 
2413
                    'repository.user_url %r does not match URL from server '
 
2414
                    'response (%r + %r)'
 
2415
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
 
2416
            remote_repo = repository
2086
2417
        else:
2087
 
            repo_bzrdir = RemoteBzrDir(
2088
 
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2089
 
                a_bzrdir._client)
2090
 
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
2418
            if repo_path == '':
 
2419
                repo_bzrdir = a_bzrdir
 
2420
            else:
 
2421
                repo_bzrdir = RemoteBzrDir(
 
2422
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
2423
                    a_bzrdir._client)
 
2424
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2091
2425
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2092
2426
            format=format, setup_stacking=False, name=name)
2093
2427
        # XXX: We know this is a new branch, so it must have revno 0, revid
2114
2448
        self._ensure_real()
2115
2449
        return self._custom_format.supports_set_append_revisions_only()
2116
2450
 
 
2451
    def _use_default_local_heads_to_fetch(self):
 
2452
        # If the branch format is a metadir format *and* its heads_to_fetch
 
2453
        # implementation is not overridden vs the base class, we can use the
 
2454
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
2455
        # usually cheaper in terms of net round trips, as the last-revision and
 
2456
        # tags info fetched is cached and would be fetched anyway.
 
2457
        self._ensure_real()
 
2458
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
2459
            branch_class = self._custom_format._branch_class()
 
2460
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
2461
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
2462
                return True
 
2463
        return False
2117
2464
 
2118
2465
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2119
2466
    """Branch stored on a server accessed by HPSS RPC.
2159
2506
            self._real_branch = None
2160
2507
        # Fill out expected attributes of branch for bzrlib API users.
2161
2508
        self._clear_cached_state()
2162
 
        self.base = self.bzrdir.root_transport.base
 
2509
        # TODO: deprecate self.base in favor of user_url
 
2510
        self.base = self.bzrdir.user_url
2163
2511
        self._name = name
2164
2512
        self._control_files = None
2165
2513
        self._lock_mode = None
2317
2665
            self._is_stacked = False
2318
2666
        else:
2319
2667
            self._is_stacked = True
2320
 
        
 
2668
 
2321
2669
    def _vfs_get_tags_bytes(self):
2322
2670
        self._ensure_real()
2323
2671
        return self._real_branch._get_tags_bytes()
2324
2672
 
 
2673
    @needs_read_lock
2325
2674
    def _get_tags_bytes(self):
 
2675
        if self._tags_bytes is None:
 
2676
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
2677
        return self._tags_bytes
 
2678
 
 
2679
    def _get_tags_bytes_via_hpss(self):
2326
2680
        medium = self._client._medium
2327
2681
        if medium._is_remote_before((1, 13)):
2328
2682
            return self._vfs_get_tags_bytes()
2338
2692
        return self._real_branch._set_tags_bytes(bytes)
2339
2693
 
2340
2694
    def _set_tags_bytes(self, bytes):
 
2695
        if self.is_locked():
 
2696
            self._tags_bytes = bytes
2341
2697
        medium = self._client._medium
2342
2698
        if medium._is_remote_before((1, 18)):
2343
2699
            self._vfs_set_tags_bytes(bytes)
2352
2708
            self._vfs_set_tags_bytes(bytes)
2353
2709
 
2354
2710
    def lock_read(self):
 
2711
        """Lock the branch for read operations.
 
2712
 
 
2713
        :return: A bzrlib.lock.LogicalLockResult.
 
2714
        """
2355
2715
        self.repository.lock_read()
2356
2716
        if not self._lock_mode:
2357
2717
            self._note_lock('r')
2361
2721
                self._real_branch.lock_read()
2362
2722
        else:
2363
2723
            self._lock_count += 1
 
2724
        return lock.LogicalLockResult(self.unlock)
2364
2725
 
2365
2726
    def _remote_lock_write(self, token):
2366
2727
        if token is None:
2367
2728
            branch_token = repo_token = ''
2368
2729
        else:
2369
2730
            branch_token = token
2370
 
            repo_token = self.repository.lock_write()
 
2731
            repo_token = self.repository.lock_write().repository_token
2371
2732
            self.repository.unlock()
2372
2733
        err_context = {'token': token}
2373
 
        response = self._call(
2374
 
            'Branch.lock_write', self._remote_path(), branch_token,
2375
 
            repo_token or '', **err_context)
 
2734
        try:
 
2735
            response = self._call(
 
2736
                'Branch.lock_write', self._remote_path(), branch_token,
 
2737
                repo_token or '', **err_context)
 
2738
        except errors.LockContention, e:
 
2739
            # The LockContention from the server doesn't have any
 
2740
            # information about the lock_url. We re-raise LockContention
 
2741
            # with valid lock_url.
 
2742
            raise errors.LockContention('(remote lock)',
 
2743
                self.repository.base.split('.bzr/')[0])
2376
2744
        if response[0] != 'ok':
2377
2745
            raise errors.UnexpectedSmartServerResponse(response)
2378
2746
        ok, branch_token, repo_token = response
2399
2767
            self._lock_mode = 'w'
2400
2768
            self._lock_count = 1
2401
2769
        elif self._lock_mode == 'r':
2402
 
            raise errors.ReadOnlyTransaction
 
2770
            raise errors.ReadOnlyError(self)
2403
2771
        else:
2404
2772
            if token is not None:
2405
2773
                # A token was given to lock_write, and we're relocking, so
2410
2778
            self._lock_count += 1
2411
2779
            # Re-lock the repository too.
2412
2780
            self.repository.lock_write(self._repo_lock_token)
2413
 
        return self._lock_token or None
 
2781
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
2414
2782
 
2415
2783
    def _unlock(self, branch_token, repo_token):
2416
2784
        err_context = {'token': str((branch_token, repo_token))}
2485
2853
            missing_parent = parent_map[missing_parent]
2486
2854
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2487
2855
 
2488
 
    def _last_revision_info(self):
 
2856
    def _read_last_revision_info(self):
2489
2857
        response = self._call('Branch.last_revision_info', self._remote_path())
2490
2858
        if response[0] != 'ok':
2491
2859
            raise SmartProtocolError('unexpected response code %s' % (response,))
2554
2922
            raise errors.UnexpectedSmartServerResponse(response)
2555
2923
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2556
2924
 
 
2925
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2557
2926
    @needs_write_lock
2558
2927
    def set_revision_history(self, rev_history):
 
2928
        """See Branch.set_revision_history."""
 
2929
        self._set_revision_history(rev_history)
 
2930
 
 
2931
    @needs_write_lock
 
2932
    def _set_revision_history(self, rev_history):
2559
2933
        # Send just the tip revision of the history; the server will generate
2560
2934
        # the full history from that.  If the revision doesn't exist in this
2561
2935
        # branch, NoSuchRevision will be raised.
2619
2993
            _override_hook_target=self, **kwargs)
2620
2994
 
2621
2995
    @needs_read_lock
2622
 
    def push(self, target, overwrite=False, stop_revision=None):
 
2996
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2623
2997
        self._ensure_real()
2624
2998
        return self._real_branch.push(
2625
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
2999
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2626
3000
            _override_hook_source_branch=self)
2627
3001
 
2628
3002
    def is_locked(self):
2638
3012
        # XXX: These should be returned by the set_last_revision_info verb
2639
3013
        old_revno, old_revid = self.last_revision_info()
2640
3014
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2641
 
        revision_id = ensure_null(revision_id)
 
3015
        if not revision_id or not isinstance(revision_id, basestring):
 
3016
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2642
3017
        try:
2643
3018
            response = self._call('Branch.set_last_revision_info',
2644
3019
                self._remote_path(), self._lock_token, self._repo_lock_token,
2673
3048
            except errors.UnknownSmartMethod:
2674
3049
                medium._remember_remote_is_before((1, 6))
2675
3050
        self._clear_cached_state_of_remote_branch_only()
2676
 
        self.set_revision_history(self._lefthand_history(revision_id,
 
3051
        self._set_revision_history(self._lefthand_history(revision_id,
2677
3052
            last_rev=last_rev,other_branch=other_branch))
2678
3053
 
2679
3054
    def set_push_location(self, location):
2680
3055
        self._ensure_real()
2681
3056
        return self._real_branch.set_push_location(location)
2682
3057
 
 
3058
    def heads_to_fetch(self):
 
3059
        if self._format._use_default_local_heads_to_fetch():
 
3060
            # We recognise this format, and its heads-to-fetch implementation
 
3061
            # is the default one (tip + tags).  In this case it's cheaper to
 
3062
            # just use the default implementation rather than a special RPC as
 
3063
            # the tip and tags data is cached.
 
3064
            return branch.Branch.heads_to_fetch(self)
 
3065
        medium = self._client._medium
 
3066
        if medium._is_remote_before((2, 4)):
 
3067
            return self._vfs_heads_to_fetch()
 
3068
        try:
 
3069
            return self._rpc_heads_to_fetch()
 
3070
        except errors.UnknownSmartMethod:
 
3071
            medium._remember_remote_is_before((2, 4))
 
3072
            return self._vfs_heads_to_fetch()
 
3073
 
 
3074
    def _rpc_heads_to_fetch(self):
 
3075
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3076
        if len(response) != 2:
 
3077
            raise errors.UnexpectedSmartServerResponse(response)
 
3078
        must_fetch, if_present_fetch = response
 
3079
        return set(must_fetch), set(if_present_fetch)
 
3080
 
 
3081
    def _vfs_heads_to_fetch(self):
 
3082
        self._ensure_real()
 
3083
        return self._real_branch.heads_to_fetch()
 
3084
 
2683
3085
 
2684
3086
class RemoteConfig(object):
2685
3087
    """A Config that reads and writes from smart verbs.
2739
3141
        medium = self._branch._client._medium
2740
3142
        if medium._is_remote_before((1, 14)):
2741
3143
            return self._vfs_set_option(value, name, section)
 
3144
        if isinstance(value, dict):
 
3145
            if medium._is_remote_before((2, 2)):
 
3146
                return self._vfs_set_option(value, name, section)
 
3147
            return self._set_config_option_dict(value, name, section)
 
3148
        else:
 
3149
            return self._set_config_option(value, name, section)
 
3150
 
 
3151
    def _set_config_option(self, value, name, section):
2742
3152
        try:
2743
3153
            path = self._branch._remote_path()
2744
3154
            response = self._branch._client.call('Branch.set_config_option',
2745
3155
                path, self._branch._lock_token, self._branch._repo_lock_token,
2746
3156
                value.encode('utf8'), name, section or '')
2747
3157
        except errors.UnknownSmartMethod:
 
3158
            medium = self._branch._client._medium
2748
3159
            medium._remember_remote_is_before((1, 14))
2749
3160
            return self._vfs_set_option(value, name, section)
2750
3161
        if response != ():
2751
3162
            raise errors.UnexpectedSmartServerResponse(response)
2752
3163
 
 
3164
    def _serialize_option_dict(self, option_dict):
 
3165
        utf8_dict = {}
 
3166
        for key, value in option_dict.items():
 
3167
            if isinstance(key, unicode):
 
3168
                key = key.encode('utf8')
 
3169
            if isinstance(value, unicode):
 
3170
                value = value.encode('utf8')
 
3171
            utf8_dict[key] = value
 
3172
        return bencode.bencode(utf8_dict)
 
3173
 
 
3174
    def _set_config_option_dict(self, value, name, section):
 
3175
        try:
 
3176
            path = self._branch._remote_path()
 
3177
            serialised_dict = self._serialize_option_dict(value)
 
3178
            response = self._branch._client.call(
 
3179
                'Branch.set_config_option_dict',
 
3180
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
3181
                serialised_dict, name, section or '')
 
3182
        except errors.UnknownSmartMethod:
 
3183
            medium = self._branch._client._medium
 
3184
            medium._remember_remote_is_before((2, 2))
 
3185
            return self._vfs_set_option(value, name, section)
 
3186
        if response != ():
 
3187
            raise errors.UnexpectedSmartServerResponse(response)
 
3188
 
2753
3189
    def _real_object(self):
2754
3190
        self._branch._ensure_real()
2755
3191
        return self._branch._real_branch
2838
3274
                    'Missing key %r in context %r', key_err.args[0], context)
2839
3275
                raise err
2840
3276
 
2841
 
    if err.error_verb == 'IncompatibleRepositories':
2842
 
        raise errors.IncompatibleRepositories(err.error_args[0],
2843
 
            err.error_args[1], err.error_args[2])
2844
 
    elif err.error_verb == 'NoSuchRevision':
 
3277
    if err.error_verb == 'NoSuchRevision':
2845
3278
        raise NoSuchRevision(find('branch'), err.error_args[0])
2846
3279
    elif err.error_verb == 'nosuchrevision':
2847
3280
        raise NoSuchRevision(find('repository'), err.error_args[0])
2854
3287
            detail=extra)
2855
3288
    elif err.error_verb == 'norepository':
2856
3289
        raise errors.NoRepositoryPresent(find('bzrdir'))
2857
 
    elif err.error_verb == 'LockContention':
2858
 
        raise errors.LockContention('(remote lock)')
2859
3290
    elif err.error_verb == 'UnlockableTransport':
2860
3291
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
2861
 
    elif err.error_verb == 'LockFailed':
2862
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
2863
3292
    elif err.error_verb == 'TokenMismatch':
2864
3293
        raise errors.TokenMismatch(find('token'), '(remote token)')
2865
3294
    elif err.error_verb == 'Diverged':
2866
3295
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
2867
 
    elif err.error_verb == 'TipChangeRejected':
2868
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2869
 
    elif err.error_verb == 'UnstackableBranchFormat':
2870
 
        raise errors.UnstackableBranchFormat(*err.error_args)
2871
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
2872
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2873
3296
    elif err.error_verb == 'NotStacked':
2874
3297
        raise errors.NotStacked(branch=find('branch'))
2875
3298
    elif err.error_verb == 'PermissionDenied':
2885
3308
    elif err.error_verb == 'NoSuchFile':
2886
3309
        path = get_path()
2887
3310
        raise errors.NoSuchFile(path)
 
3311
    _translate_error_without_context(err)
 
3312
 
 
3313
 
 
3314
def _translate_error_without_context(err):
 
3315
    """Translate any ErrorFromSmartServer values that don't require context"""
 
3316
    if err.error_verb == 'IncompatibleRepositories':
 
3317
        raise errors.IncompatibleRepositories(err.error_args[0],
 
3318
            err.error_args[1], err.error_args[2])
 
3319
    elif err.error_verb == 'LockContention':
 
3320
        raise errors.LockContention('(remote lock)')
 
3321
    elif err.error_verb == 'LockFailed':
 
3322
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
 
3323
    elif err.error_verb == 'TipChangeRejected':
 
3324
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
 
3325
    elif err.error_verb == 'UnstackableBranchFormat':
 
3326
        raise errors.UnstackableBranchFormat(*err.error_args)
 
3327
    elif err.error_verb == 'UnstackableRepositoryFormat':
 
3328
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2888
3329
    elif err.error_verb == 'FileExists':
2889
3330
        raise errors.FileExists(err.error_args[0])
2890
3331
    elif err.error_verb == 'DirectoryNotEmpty':
2909
3350
            raise UnicodeEncodeError(encoding, val, start, end, reason)
2910
3351
    elif err.error_verb == 'ReadOnlyError':
2911
3352
        raise errors.TransportNotPossible('readonly transport')
 
3353
    elif err.error_verb == 'MemoryError':
 
3354
        raise errors.BzrError("remote server out of memory\n"
 
3355
            "Retry non-remotely, or contact the server admin for details.")
2912
3356
    raise errors.UnknownErrorFromSmartServer(err)