← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Martin von Gagern
  • Date: 2011-09-19 08:49:15 UTC
  • mto: This revision was merged to the branch mainline in revision 6148.
  • Revision ID: martin.vgagern@gmx.net-20110919084915-vbumflqq3xqm1vez
Avoid using deprecated api in the unit tests for bzrlib.missing.

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
30
    repository as _mod_repository,
31
 
    revision,
32
31
    revision as _mod_revision,
33
32
    static_tuple,
34
33
    symbol_versioning,
35
 
)
36
 
from bzrlib.branch import BranchReferenceFormat
37
 
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
 
34
    urlutils,
 
35
    vf_repository,
 
36
    )
 
37
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
38
38
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
39
39
from bzrlib.errors import (
40
40
    NoSuchRevision,
42
42
    )
43
43
from bzrlib.lockable_files import LockableFiles
44
44
from bzrlib.smart import client, vfs, repository as smart_repo
45
 
from bzrlib.revision import ensure_null, NULL_REVISION
 
45
from bzrlib.smart.client import _SmartClient
 
46
from bzrlib.revision import NULL_REVISION
 
47
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
46
48
from bzrlib.trace import mutter, note, warning
47
49
 
48
50
 
 
51
_DEFAULT_SEARCH_DEPTH = 100
 
52
 
 
53
 
49
54
class _RpcHelper(object):
50
55
    """Mixin class that helps with issuing RPCs."""
51
56
 
86
91
    return format
87
92
 
88
93
 
89
 
# Note: RemoteBzrDirFormat is in bzrdir.py
90
 
 
91
 
class RemoteBzrDir(BzrDir, _RpcHelper):
 
94
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
 
95
# does not have to be imported unless a remote format is involved.
 
96
 
 
97
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
 
98
    """Format representing bzrdirs accessed via a smart server"""
 
99
 
 
100
    supports_workingtrees = False
 
101
 
 
102
    def __init__(self):
 
103
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
 
104
        # XXX: It's a bit ugly that the network name is here, because we'd
 
105
        # like to believe that format objects are stateless or at least
 
106
        # immutable,  However, we do at least avoid mutating the name after
 
107
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
 
108
        self._network_name = None
 
109
 
 
110
    def __repr__(self):
 
111
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
112
            self._network_name)
 
113
 
 
114
    def get_format_description(self):
 
115
        if self._network_name:
 
116
            real_format = controldir.network_format_registry.get(self._network_name)
 
117
            return 'Remote: ' + real_format.get_format_description()
 
118
        return 'bzr remote bzrdir'
 
119
 
 
120
    def get_format_string(self):
 
121
        raise NotImplementedError(self.get_format_string)
 
122
 
 
123
    def network_name(self):
 
124
        if self._network_name:
 
125
            return self._network_name
 
126
        else:
 
127
            raise AssertionError("No network name set.")
 
128
 
 
129
    def initialize_on_transport(self, transport):
 
130
        try:
 
131
            # hand off the request to the smart server
 
132
            client_medium = transport.get_smart_medium()
 
133
        except errors.NoSmartMedium:
 
134
            # TODO: lookup the local format from a server hint.
 
135
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
136
            return local_dir_format.initialize_on_transport(transport)
 
137
        client = _SmartClient(client_medium)
 
138
        path = client.remote_path_from_transport(transport)
 
139
        try:
 
140
            response = client.call('BzrDirFormat.initialize', path)
 
141
        except errors.ErrorFromSmartServer, err:
 
142
            _translate_error(err, path=path)
 
143
        if response[0] != 'ok':
 
144
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
 
145
        format = RemoteBzrDirFormat()
 
146
        self._supply_sub_formats_to(format)
 
147
        return RemoteBzrDir(transport, format)
 
148
 
 
149
    def parse_NoneTrueFalse(self, arg):
 
150
        if not arg:
 
151
            return None
 
152
        if arg == 'False':
 
153
            return False
 
154
        if arg == 'True':
 
155
            return True
 
156
        raise AssertionError("invalid arg %r" % arg)
 
157
 
 
158
    def _serialize_NoneTrueFalse(self, arg):
 
159
        if arg is False:
 
160
            return 'False'
 
161
        if arg:
 
162
            return 'True'
 
163
        return ''
 
164
 
 
165
    def _serialize_NoneString(self, arg):
 
166
        return arg or ''
 
167
 
 
168
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
169
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
170
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
171
        shared_repo=False):
 
172
        try:
 
173
            # hand off the request to the smart server
 
174
            client_medium = transport.get_smart_medium()
 
175
        except errors.NoSmartMedium:
 
176
            do_vfs = True
 
177
        else:
 
178
            # Decline to open it if the server doesn't support our required
 
179
            # version (3) so that the VFS-based transport will do it.
 
180
            if client_medium.should_probe():
 
181
                try:
 
182
                    server_version = client_medium.protocol_version()
 
183
                    if server_version != '2':
 
184
                        do_vfs = True
 
185
                    else:
 
186
                        do_vfs = False
 
187
                except errors.SmartProtocolError:
 
188
                    # Apparently there's no usable smart server there, even though
 
189
                    # the medium supports the smart protocol.
 
190
                    do_vfs = True
 
191
            else:
 
192
                do_vfs = False
 
193
        if not do_vfs:
 
194
            client = _SmartClient(client_medium)
 
195
            path = client.remote_path_from_transport(transport)
 
196
            if client_medium._is_remote_before((1, 16)):
 
197
                do_vfs = True
 
198
        if do_vfs:
 
199
            # TODO: lookup the local format from a server hint.
 
200
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
201
            self._supply_sub_formats_to(local_dir_format)
 
202
            return local_dir_format.initialize_on_transport_ex(transport,
 
203
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
204
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
205
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
206
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
207
                vfs_only=True)
 
208
        return self._initialize_on_transport_ex_rpc(client, path, transport,
 
209
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
210
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
 
211
 
 
212
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
 
213
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
214
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
 
215
        args = []
 
216
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
 
217
        args.append(self._serialize_NoneTrueFalse(create_prefix))
 
218
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
 
219
        args.append(self._serialize_NoneString(stacked_on))
 
220
        # stack_on_pwd is often/usually our transport
 
221
        if stack_on_pwd:
 
222
            try:
 
223
                stack_on_pwd = transport.relpath(stack_on_pwd)
 
224
                if not stack_on_pwd:
 
225
                    stack_on_pwd = '.'
 
226
            except errors.PathNotChild:
 
227
                pass
 
228
        args.append(self._serialize_NoneString(stack_on_pwd))
 
229
        args.append(self._serialize_NoneString(repo_format_name))
 
230
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
 
231
        args.append(self._serialize_NoneTrueFalse(shared_repo))
 
232
        request_network_name = self._network_name or \
 
233
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
 
234
        try:
 
235
            response = client.call('BzrDirFormat.initialize_ex_1.16',
 
236
                request_network_name, path, *args)
 
237
        except errors.UnknownSmartMethod:
 
238
            client._medium._remember_remote_is_before((1,16))
 
239
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
240
            self._supply_sub_formats_to(local_dir_format)
 
241
            return local_dir_format.initialize_on_transport_ex(transport,
 
242
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
243
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
244
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
245
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
246
                vfs_only=True)
 
247
        except errors.ErrorFromSmartServer, err:
 
248
            _translate_error(err, path=path)
 
249
        repo_path = response[0]
 
250
        bzrdir_name = response[6]
 
251
        require_stacking = response[7]
 
252
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
 
253
        format = RemoteBzrDirFormat()
 
254
        format._network_name = bzrdir_name
 
255
        self._supply_sub_formats_to(format)
 
256
        bzrdir = RemoteBzrDir(transport, format, _client=client)
 
257
        if repo_path:
 
258
            repo_format = response_tuple_to_repo_format(response[1:])
 
259
            if repo_path == '.':
 
260
                repo_path = ''
 
261
            if repo_path:
 
262
                repo_bzrdir_format = RemoteBzrDirFormat()
 
263
                repo_bzrdir_format._network_name = response[5]
 
264
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
 
265
                    repo_bzrdir_format)
 
266
            else:
 
267
                repo_bzr = bzrdir
 
268
            final_stack = response[8] or None
 
269
            final_stack_pwd = response[9] or None
 
270
            if final_stack_pwd:
 
271
                final_stack_pwd = urlutils.join(
 
272
                    transport.base, final_stack_pwd)
 
273
            remote_repo = RemoteRepository(repo_bzr, repo_format)
 
274
            if len(response) > 10:
 
275
                # Updated server verb that locks remotely.
 
276
                repo_lock_token = response[10] or None
 
277
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
 
278
                if repo_lock_token:
 
279
                    remote_repo.dont_leave_lock_in_place()
 
280
            else:
 
281
                remote_repo.lock_write()
 
282
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
 
283
                final_stack_pwd, require_stacking)
 
284
            policy.acquire_repository()
 
285
        else:
 
286
            remote_repo = None
 
287
            policy = None
 
288
        bzrdir._format.set_branch_format(self.get_branch_format())
 
289
        if require_stacking:
 
290
            # The repo has already been created, but we need to make sure that
 
291
            # we'll make a stackable branch.
 
292
            bzrdir._format.require_stacking(_skip_repo=True)
 
293
        return remote_repo, bzrdir, require_stacking, policy
 
294
 
 
295
    def _open(self, transport):
 
296
        return RemoteBzrDir(transport, self)
 
297
 
 
298
    def __eq__(self, other):
 
299
        if not isinstance(other, RemoteBzrDirFormat):
 
300
            return False
 
301
        return self.get_format_description() == other.get_format_description()
 
302
 
 
303
    def __return_repository_format(self):
 
304
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
 
305
        # repository format has been asked for, tell the RemoteRepositoryFormat
 
306
        # that it should use that for init() etc.
 
307
        result = RemoteRepositoryFormat()
 
308
        custom_format = getattr(self, '_repository_format', None)
 
309
        if custom_format:
 
310
            if isinstance(custom_format, RemoteRepositoryFormat):
 
311
                return custom_format
 
312
            else:
 
313
                # We will use the custom format to create repositories over the
 
314
                # wire; expose its details like rich_root_data for code to
 
315
                # query
 
316
                result._custom_format = custom_format
 
317
        return result
 
318
 
 
319
    def get_branch_format(self):
 
320
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
 
321
        if not isinstance(result, RemoteBranchFormat):
 
322
            new_result = RemoteBranchFormat()
 
323
            new_result._custom_format = result
 
324
            # cache the result
 
325
            self.set_branch_format(new_result)
 
326
            result = new_result
 
327
        return result
 
328
 
 
329
    repository_format = property(__return_repository_format,
 
330
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
 
331
 
 
332
 
 
333
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
92
334
    """Control directory on a remote server, accessed via bzr:// or similar."""
93
335
 
94
336
    def __init__(self, transport, format, _client=None, _force_probe=False):
97
339
        :param _client: Private parameter for testing. Disables probing and the
98
340
            use of a real bzrdir.
99
341
        """
100
 
        BzrDir.__init__(self, transport, format)
 
342
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
101
343
        # this object holds a delegated bzrdir that uses file-level operations
102
344
        # to talk to the other side
103
345
        self._real_bzrdir = None
163
405
                import traceback
164
406
                warning('VFS BzrDir access triggered\n%s',
165
407
                    ''.join(traceback.format_stack()))
166
 
            self._real_bzrdir = BzrDir.open_from_transport(
 
408
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
167
409
                self.root_transport, _server_formats=False)
168
410
            self._format._network_name = \
169
411
                self._real_bzrdir._format.network_name()
175
417
        # Prevent aliasing problems in the next_open_branch_result cache.
176
418
        # See create_branch for rationale.
177
419
        self._next_open_branch_result = None
178
 
        return BzrDir.break_lock(self)
 
420
        return _mod_bzrdir.BzrDir.break_lock(self)
179
421
 
180
422
    def _vfs_cloning_metadir(self, require_stacking=False):
181
423
        self._ensure_real()
212
454
        if len(branch_info) != 2:
213
455
            raise errors.UnexpectedSmartServerResponse(response)
214
456
        branch_ref, branch_name = branch_info
215
 
        format = bzrdir.network_format_registry.get(control_name)
 
457
        format = controldir.network_format_registry.get(control_name)
216
458
        if repo_name:
217
 
            format.repository_format = repository.network_format_registry.get(
 
459
            format.repository_format = _mod_repository.network_format_registry.get(
218
460
                repo_name)
219
461
        if branch_ref == 'ref':
220
462
            # XXX: we need possible_transports here to avoid reopening the
221
463
            # connection to the referenced location
222
 
            ref_bzrdir = BzrDir.open(branch_name)
 
464
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
223
465
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
224
466
            format.set_branch_format(branch_format)
225
467
        elif branch_ref == 'branch':
244
486
        self._ensure_real()
245
487
        self._real_bzrdir.destroy_repository()
246
488
 
247
 
    def create_branch(self, name=None):
 
489
    def create_branch(self, name=None, repository=None,
 
490
                      append_revisions_only=None):
248
491
        # as per meta1 formats - just delegate to the format object which may
249
492
        # be parameterised.
250
493
        real_branch = self._format.get_branch_format().initialize(self,
251
 
            name=name)
 
494
            name=name, repository=repository,
 
495
            append_revisions_only=append_revisions_only)
252
496
        if not isinstance(real_branch, RemoteBranch):
253
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
254
 
                                  name=name)
 
497
            if not isinstance(repository, RemoteRepository):
 
498
                raise AssertionError(
 
499
                    'need a RemoteRepository to use with RemoteBranch, got %r'
 
500
                    % (repository,))
 
501
            result = RemoteBranch(self, repository, real_branch, name=name)
255
502
        else:
256
503
            result = real_branch
257
504
        # BzrDir.clone_on_transport() uses the result of create_branch but does
269
516
        self._real_bzrdir.destroy_branch(name=name)
270
517
        self._next_open_branch_result = None
271
518
 
272
 
    def create_workingtree(self, revision_id=None, from_branch=None):
 
519
    def create_workingtree(self, revision_id=None, from_branch=None,
 
520
        accelerator_tree=None, hardlink=False):
273
521
        raise errors.NotLocalUrl(self.transport.base)
274
522
 
275
 
    def find_branch_format(self):
 
523
    def find_branch_format(self, name=None):
276
524
        """Find the branch 'format' for this bzrdir.
277
525
 
278
526
        This might be a synthetic object for e.g. RemoteBranch and SVN.
279
527
        """
280
 
        b = self.open_branch()
 
528
        b = self.open_branch(name=name)
281
529
        return b._format
282
530
 
283
 
    def get_branch_reference(self):
 
531
    def get_branch_reference(self, name=None):
284
532
        """See BzrDir.get_branch_reference()."""
 
533
        if name is not None:
 
534
            # XXX JRV20100304: Support opening colocated branches
 
535
            raise errors.NoColocatedBranchSupport(self)
285
536
        response = self._get_branch_reference()
286
537
        if response[0] == 'ref':
287
538
            return response[1]
318
569
            raise errors.UnexpectedSmartServerResponse(response)
319
570
        return response
320
571
 
321
 
    def _get_tree_branch(self):
 
572
    def _get_tree_branch(self, name=None):
322
573
        """See BzrDir._get_tree_branch()."""
323
 
        return None, self.open_branch()
 
574
        return None, self.open_branch(name=name)
324
575
 
325
576
    def open_branch(self, name=None, unsupported=False,
326
577
                    ignore_fallbacks=False):
423
674
 
424
675
    def _path_for_remote_call(self, client):
425
676
        """Return the path to be used for this bzrdir in a remote call."""
426
 
        return client.remote_path_from_transport(self.root_transport)
 
677
        return urlutils.split_segment_parameters_raw(
 
678
            client.remote_path_from_transport(self.root_transport))[0]
427
679
 
428
680
    def get_branch_transport(self, branch_format, name=None):
429
681
        self._ensure_real()
441
693
        """Upgrading of remote bzrdirs is not supported yet."""
442
694
        return False
443
695
 
444
 
    def needs_format_conversion(self, format=None):
 
696
    def needs_format_conversion(self, format):
445
697
        """Upgrading of remote bzrdirs is not supported yet."""
446
 
        if format is None:
447
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
448
 
                % 'needs_format_conversion(format=None)')
449
698
        return False
450
699
 
451
700
    def clone(self, url, revision_id=None, force_new_repo=False,
458
707
        return RemoteBzrDirConfig(self)
459
708
 
460
709
 
461
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
710
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
462
711
    """Format for repositories accessed over a _SmartClient.
463
712
 
464
713
    Instances of this repository are represented by RemoteRepository
479
728
    """
480
729
 
481
730
    _matchingbzrdir = RemoteBzrDirFormat()
 
731
    supports_full_versioned_files = True
 
732
    supports_leaving_lock = True
482
733
 
483
734
    def __init__(self):
484
 
        repository.RepositoryFormat.__init__(self)
 
735
        _mod_repository.RepositoryFormat.__init__(self)
485
736
        self._custom_format = None
486
737
        self._network_name = None
487
738
        self._creating_bzrdir = None
 
739
        self._revision_graph_can_have_wrong_parents = None
488
740
        self._supports_chks = None
489
741
        self._supports_external_lookups = None
490
742
        self._supports_tree_reference = None
 
743
        self._supports_funky_characters = None
491
744
        self._rich_root_data = None
492
745
 
493
746
    def __repr__(self):
522
775
        return self._supports_external_lookups
523
776
 
524
777
    @property
 
778
    def supports_funky_characters(self):
 
779
        if self._supports_funky_characters is None:
 
780
            self._ensure_real()
 
781
            self._supports_funky_characters = \
 
782
                self._custom_format.supports_funky_characters
 
783
        return self._supports_funky_characters
 
784
 
 
785
    @property
525
786
    def supports_tree_reference(self):
526
787
        if self._supports_tree_reference is None:
527
788
            self._ensure_real()
529
790
                self._custom_format.supports_tree_reference
530
791
        return self._supports_tree_reference
531
792
 
 
793
    @property
 
794
    def revision_graph_can_have_wrong_parents(self):
 
795
        if self._revision_graph_can_have_wrong_parents is None:
 
796
            self._ensure_real()
 
797
            self._revision_graph_can_have_wrong_parents = \
 
798
                self._custom_format.revision_graph_can_have_wrong_parents
 
799
        return self._revision_graph_can_have_wrong_parents
 
800
 
532
801
    def _vfs_initialize(self, a_bzrdir, shared):
533
802
        """Helper for common code in initialize."""
534
803
        if self._custom_format:
569
838
            network_name = self._network_name
570
839
        else:
571
840
            # Select the current bzrlib default and ask for that.
572
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
841
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
573
842
            reference_format = reference_bzrdir_format.repository_format
574
843
            network_name = reference_format.network_name()
575
844
        # 2) try direct creation via RPC
601
870
 
602
871
    def _ensure_real(self):
603
872
        if self._custom_format is None:
604
 
            self._custom_format = repository.network_format_registry.get(
 
873
            self._custom_format = _mod_repository.network_format_registry.get(
605
874
                self._network_name)
606
875
 
607
876
    @property
644
913
 
645
914
 
646
915
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
647
 
    bzrdir.ControlComponent):
 
916
    controldir.ControlComponent):
648
917
    """Repository accessed over rpc.
649
918
 
650
919
    For the moment most operations are performed using local transport-backed
703
972
        # transport, but I'm not sure it's worth making this method
704
973
        # optional -- mbp 2010-04-21
705
974
        return self.bzrdir.get_repository_transport(None)
706
 
        
 
975
 
707
976
    def __str__(self):
708
977
        return "%s(%s)" % (self.__class__.__name__, self.base)
709
978
 
817
1086
    def find_text_key_references(self):
818
1087
        """Find the text key references within the repository.
819
1088
 
820
 
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
821
 
        revision_ids. Each altered file-ids has the exact revision_ids that
822
 
        altered it listed explicitly.
823
1089
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
824
1090
            to whether they were referred to by the inventory of the
825
1091
            revision_id that they contain. The inventory texts from all present
843
1109
        """Private method for using with old (< 1.2) servers to fallback."""
844
1110
        if revision_id is None:
845
1111
            revision_id = ''
846
 
        elif revision.is_null(revision_id):
 
1112
        elif _mod_revision.is_null(revision_id):
847
1113
            return {}
848
1114
 
849
1115
        path = self.bzrdir._path_for_remote_call(self._client)
873
1139
        return RemoteStreamSource(self, to_format)
874
1140
 
875
1141
    @needs_read_lock
 
1142
    def get_file_graph(self):
 
1143
        return graph.Graph(self.texts)
 
1144
 
 
1145
    @needs_read_lock
876
1146
    def has_revision(self, revision_id):
877
1147
        """True if this repository has a copy of the revision."""
878
1148
        # Copy of bzrlib.repository.Repository.has_revision
895
1165
    def _has_same_fallbacks(self, other_repo):
896
1166
        """Returns true if the repositories have the same fallbacks."""
897
1167
        # XXX: copied from Repository; it should be unified into a base class
898
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
1168
        # <https://bugs.launchpad.net/bzr/+bug/401622>
899
1169
        my_fb = self._fallback_repositories
900
1170
        other_fb = other_repo._fallback_repositories
901
1171
        if len(my_fb) != len(other_fb):
930
1200
        """See Repository.gather_stats()."""
931
1201
        path = self.bzrdir._path_for_remote_call(self._client)
932
1202
        # revid can be None to indicate no revisions, not just NULL_REVISION
933
 
        if revid is None or revision.is_null(revid):
 
1203
        if revid is None or _mod_revision.is_null(revid):
934
1204
            fmt_revid = ''
935
1205
        else:
936
1206
            fmt_revid = revid
997
1267
        pass
998
1268
 
999
1269
    def lock_read(self):
 
1270
        """Lock the repository for read operations.
 
1271
 
 
1272
        :return: A bzrlib.lock.LogicalLockResult.
 
1273
        """
1000
1274
        # wrong eventually - want a local lock cache context
1001
1275
        if not self._lock_mode:
1002
1276
            self._note_lock('r')
1009
1283
                repo.lock_read()
1010
1284
        else:
1011
1285
            self._lock_count += 1
 
1286
        return lock.LogicalLockResult(self.unlock)
1012
1287
 
1013
1288
    def _remote_lock_write(self, token):
1014
1289
        path = self.bzrdir._path_for_remote_call(self._client)
1054
1329
            raise errors.ReadOnlyError(self)
1055
1330
        else:
1056
1331
            self._lock_count += 1
1057
 
        return self._lock_token or None
 
1332
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
1058
1333
 
1059
1334
    def leave_lock_in_place(self):
1060
1335
        if not self._lock_token:
1214
1489
 
1215
1490
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1216
1491
                           timezone=None, committer=None, revprops=None,
1217
 
                           revision_id=None):
 
1492
                           revision_id=None, lossy=False):
1218
1493
        # FIXME: It ought to be possible to call this without immediately
1219
1494
        # triggering _ensure_real.  For now it's the easiest thing to do.
1220
1495
        self._ensure_real()
1221
1496
        real_repo = self._real_repository
1222
1497
        builder = real_repo.get_commit_builder(branch, parents,
1223
1498
                config, timestamp=timestamp, timezone=timezone,
1224
 
                committer=committer, revprops=revprops, revision_id=revision_id)
 
1499
                committer=committer, revprops=revprops,
 
1500
                revision_id=revision_id, lossy=lossy)
1225
1501
        return builder
1226
1502
 
1227
1503
    def add_fallback_repository(self, repository):
1235
1511
        # We need to accumulate additional repositories here, to pass them in
1236
1512
        # on various RPC's.
1237
1513
        #
 
1514
        # Make the check before we lock: this raises an exception.
 
1515
        self._check_fallback_repository(repository)
1238
1516
        if self.is_locked():
1239
1517
            # We will call fallback.unlock() when we transition to the unlocked
1240
1518
            # state, so always add a lock here. If a caller passes us a locked
1241
1519
            # repository, they are responsible for unlocking it later.
1242
1520
            repository.lock_read()
1243
 
        self._check_fallback_repository(repository)
1244
1521
        self._fallback_repositories.append(repository)
1245
1522
        # If self._real_repository was parameterised already (e.g. because a
1246
1523
        # _real_branch had its get_stacked_on_url method called), then the
1306
1583
        return self._real_repository.make_working_trees()
1307
1584
 
1308
1585
    def refresh_data(self):
1309
 
        """Re-read any data needed to to synchronise with disk.
 
1586
        """Re-read any data needed to synchronise with disk.
1310
1587
 
1311
1588
        This method is intended to be called after another repository instance
1312
1589
        (such as one used by a smart server) has inserted data into the
1313
 
        repository. It may not be called during a write group, but may be
1314
 
        called at any other time.
 
1590
        repository. On all repositories this will work outside of write groups.
 
1591
        Some repository formats (pack and newer for bzrlib native formats)
 
1592
        support refresh_data inside write groups. If called inside a write
 
1593
        group on a repository that does not support refreshing in a write group
 
1594
        IsInWriteGroupError will be raised.
1315
1595
        """
1316
 
        if self.is_in_write_group():
1317
 
            raise errors.InternalBzrError(
1318
 
                "May not refresh_data while in a write group.")
1319
1596
        if self._real_repository is not None:
1320
1597
            self._real_repository.refresh_data()
1321
1598
 
1333
1610
        return result
1334
1611
 
1335
1612
    @needs_read_lock
1336
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
1613
    def search_missing_revision_ids(self, other,
 
1614
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
1615
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
1616
            limit=None):
1337
1617
        """Return the revision ids that other has that this does not.
1338
1618
 
1339
1619
        These are returned in topological order.
1340
1620
 
1341
1621
        revision_id: only return revision ids included by revision_id.
1342
1622
        """
1343
 
        return repository.InterRepository.get(
1344
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
1623
        if symbol_versioning.deprecated_passed(revision_id):
 
1624
            symbol_versioning.warn(
 
1625
                'search_missing_revision_ids(revision_id=...) was '
 
1626
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
1627
                DeprecationWarning, stacklevel=2)
 
1628
            if revision_ids is not None:
 
1629
                raise AssertionError(
 
1630
                    'revision_ids is mutually exclusive with revision_id')
 
1631
            if revision_id is not None:
 
1632
                revision_ids = [revision_id]
 
1633
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
1634
        return inter_repo.search_missing_revision_ids(
 
1635
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
1636
            if_present_ids=if_present_ids, limit=limit)
1345
1637
 
1346
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
1638
    def fetch(self, source, revision_id=None, find_ghosts=False,
1347
1639
            fetch_spec=None):
1348
1640
        # No base implementation to use as RemoteRepository is not a subclass
1349
1641
        # of Repository; so this is a copy of Repository.fetch().
1360
1652
            # check that last_revision is in 'from' and then return a
1361
1653
            # no-operation.
1362
1654
            if (revision_id is not None and
1363
 
                not revision.is_null(revision_id)):
 
1655
                not _mod_revision.is_null(revision_id)):
1364
1656
                self.get_revision(revision_id)
1365
1657
            return 0, []
1366
1658
        # if there is no specific appropriate InterRepository, this will get
1367
1659
        # the InterRepository base class, which raises an
1368
1660
        # IncompatibleRepositories when asked to fetch.
1369
 
        inter = repository.InterRepository.get(source, self)
1370
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
1661
        inter = _mod_repository.InterRepository.get(source, self)
 
1662
        return inter.fetch(revision_id=revision_id,
1371
1663
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1372
1664
 
1373
1665
    def create_bundle(self, target, base, fileobj, format=None):
1375
1667
        self._real_repository.create_bundle(target, base, fileobj, format)
1376
1668
 
1377
1669
    @needs_read_lock
 
1670
    @symbol_versioning.deprecated_method(
 
1671
        symbol_versioning.deprecated_in((2, 4, 0)))
1378
1672
    def get_ancestry(self, revision_id, topo_sorted=True):
1379
1673
        self._ensure_real()
1380
1674
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1394
1688
        self._ensure_real()
1395
1689
        return self._real_repository.iter_files_bytes(desired_files)
1396
1690
 
 
1691
    def get_cached_parent_map(self, revision_ids):
 
1692
        """See bzrlib.CachingParentsProvider.get_cached_parent_map"""
 
1693
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
 
1694
 
1397
1695
    def get_parent_map(self, revision_ids):
1398
1696
        """See bzrlib.Graph.get_parent_map()."""
1399
1697
        return self._make_parents_provider().get_parent_map(revision_ids)
1457
1755
        if parents_map is None:
1458
1756
            # Repository is not locked, so there's no cache.
1459
1757
            parents_map = {}
1460
 
        # start_set is all the keys in the cache
1461
 
        start_set = set(parents_map)
1462
 
        # result set is all the references to keys in the cache
1463
 
        result_parents = set()
1464
 
        for parents in parents_map.itervalues():
1465
 
            result_parents.update(parents)
1466
 
        stop_keys = result_parents.difference(start_set)
1467
 
        # We don't need to send ghosts back to the server as a position to
1468
 
        # stop either.
1469
 
        stop_keys.difference_update(self._unstacked_provider.missing_keys)
1470
 
        key_count = len(parents_map)
1471
 
        if (NULL_REVISION in result_parents
1472
 
            and NULL_REVISION in self._unstacked_provider.missing_keys):
1473
 
            # If we pruned NULL_REVISION from the stop_keys because it's also
1474
 
            # in our cache of "missing" keys we need to increment our key count
1475
 
            # by 1, because the reconsitituted SearchResult on the server will
1476
 
            # still consider NULL_REVISION to be an included key.
1477
 
            key_count += 1
1478
 
        included_keys = start_set.intersection(result_parents)
1479
 
        start_set.difference_update(included_keys)
 
1758
        if _DEFAULT_SEARCH_DEPTH <= 0:
 
1759
            (start_set, stop_keys,
 
1760
             key_count) = graph.search_result_from_parent_map(
 
1761
                parents_map, self._unstacked_provider.missing_keys)
 
1762
        else:
 
1763
            (start_set, stop_keys,
 
1764
             key_count) = graph.limited_search_result_from_parent_map(
 
1765
                parents_map, self._unstacked_provider.missing_keys,
 
1766
                keys, depth=_DEFAULT_SEARCH_DEPTH)
1480
1767
        recipe = ('manual', start_set, stop_keys, key_count)
1481
1768
        body = self._serialise_search_recipe(recipe)
1482
1769
        path = self.bzrdir._path_for_remote_call(self._client)
1597
1884
            tmpdir = osutils.mkdtemp()
1598
1885
            try:
1599
1886
                _extract_tar(tar, tmpdir)
1600
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
1887
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1601
1888
                tmp_repo = tmp_bzrdir.open_repository()
1602
1889
                tmp_repo.copy_content_into(destination, revision_id)
1603
1890
            finally:
1688
1975
    def supports_rich_root(self):
1689
1976
        return self._format.rich_root_data
1690
1977
 
 
1978
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1691
1979
    def iter_reverse_revision_history(self, revision_id):
1692
1980
        self._ensure_real()
1693
1981
        return self._real_repository.iter_reverse_revision_history(revision_id)
1714
2002
        return self._real_repository.item_keys_introduced_by(revision_ids,
1715
2003
            _files_pb=_files_pb)
1716
2004
 
1717
 
    def revision_graph_can_have_wrong_parents(self):
1718
 
        # The answer depends on the remote repo format.
1719
 
        self._ensure_real()
1720
 
        return self._real_repository.revision_graph_can_have_wrong_parents()
1721
 
 
1722
2005
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1723
2006
        self._ensure_real()
1724
2007
        return self._real_repository._find_inconsistent_revision_parents(
1732
2015
        providers = [self._unstacked_provider]
1733
2016
        if other is not None:
1734
2017
            providers.insert(0, other)
1735
 
        providers.extend(r._make_parents_provider() for r in
1736
 
                         self._fallback_repositories)
1737
 
        return graph.StackedParentsProvider(providers)
 
2018
        return graph.StackedParentsProvider(_LazyListJoin(
 
2019
            providers, self._fallback_repositories))
1738
2020
 
1739
2021
    def _serialise_search_recipe(self, recipe):
1740
2022
        """Serialise a graph search recipe.
1748
2030
        return '\n'.join((start_keys, stop_keys, count))
1749
2031
 
1750
2032
    def _serialise_search_result(self, search_result):
1751
 
        if isinstance(search_result, graph.PendingAncestryResult):
1752
 
            parts = ['ancestry-of']
1753
 
            parts.extend(search_result.heads)
1754
 
        else:
1755
 
            recipe = search_result.get_recipe()
1756
 
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
 
2033
        parts = search_result.get_network_struct()
1757
2034
        return '\n'.join(parts)
1758
2035
 
1759
2036
    def autopack(self):
1769
2046
            raise errors.UnexpectedSmartServerResponse(response)
1770
2047
 
1771
2048
 
1772
 
class RemoteStreamSink(repository.StreamSink):
 
2049
class RemoteStreamSink(vf_repository.StreamSink):
1773
2050
 
1774
2051
    def _insert_real(self, stream, src_format, resume_tokens):
1775
2052
        self.target_repo._ensure_real()
1876
2153
        self._last_substream and self._last_stream so that the stream can be
1877
2154
        resumed by _resume_stream_with_vfs.
1878
2155
        """
1879
 
                    
 
2156
 
1880
2157
        stream_iter = iter(stream)
1881
2158
        for substream_kind, substream in stream_iter:
1882
2159
            if substream_kind == 'inventory-deltas':
1885
2162
                return
1886
2163
            else:
1887
2164
                yield substream_kind, substream
1888
 
            
1889
 
 
1890
 
class RemoteStreamSource(repository.StreamSource):
 
2165
 
 
2166
 
 
2167
class RemoteStreamSource(vf_repository.StreamSource):
1891
2168
    """Stream data from a remote server."""
1892
2169
 
1893
2170
    def get_stream(self, search):
1953
2230
        candidate_verbs = [
1954
2231
            ('Repository.get_stream_1.19', (1, 19)),
1955
2232
            ('Repository.get_stream', (1, 13))]
 
2233
 
1956
2234
        found_verb = False
1957
2235
        for verb, version in candidate_verbs:
1958
2236
            if medium._is_remote_before(version):
1962
2240
                    verb, args, search_bytes)
1963
2241
            except errors.UnknownSmartMethod:
1964
2242
                medium._remember_remote_is_before(version)
 
2243
            except errors.UnknownErrorFromSmartServer, e:
 
2244
                if isinstance(search, graph.EverythingResult):
 
2245
                    error_verb = e.error_from_smart_server.error_verb
 
2246
                    if error_verb == 'BadSearch':
 
2247
                        # Pre-2.4 servers don't support this sort of search.
 
2248
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
2249
                        # good idea in general?  It might provide a little bit
 
2250
                        # of protection against client-side bugs.
 
2251
                        medium._remember_remote_is_before((2, 4))
 
2252
                        break
 
2253
                raise
1965
2254
            else:
1966
2255
                response_tuple, response_handler = response
1967
2256
                found_verb = True
1971
2260
        if response_tuple[0] != 'ok':
1972
2261
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1973
2262
        byte_stream = response_handler.read_streamed_body()
1974
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
2263
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
2264
            self._record_counter)
1975
2265
        if src_format.network_name() != repo._format.network_name():
1976
2266
            raise AssertionError(
1977
2267
                "Mismatched RemoteRepository and stream src %r, %r" % (
2063
2353
        return a_bzrdir.open_branch(name=name, 
2064
2354
            ignore_fallbacks=ignore_fallbacks)
2065
2355
 
2066
 
    def _vfs_initialize(self, a_bzrdir, name):
 
2356
    def _vfs_initialize(self, a_bzrdir, name, append_revisions_only):
2067
2357
        # Initialisation when using a local bzrdir object, or a non-vfs init
2068
2358
        # method is not available on the server.
2069
2359
        # self._custom_format is always set - the start of initialize ensures
2071
2361
        if isinstance(a_bzrdir, RemoteBzrDir):
2072
2362
            a_bzrdir._ensure_real()
2073
2363
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2074
 
                name)
 
2364
                name, append_revisions_only=append_revisions_only)
2075
2365
        else:
2076
2366
            # We assume the bzrdir is parameterised; it may not be.
2077
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
2367
            result = self._custom_format.initialize(a_bzrdir, name,
 
2368
                append_revisions_only=append_revisions_only)
2078
2369
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2079
2370
            not isinstance(result, RemoteBranch)):
2080
2371
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2081
2372
                                  name=name)
2082
2373
        return result
2083
2374
 
2084
 
    def initialize(self, a_bzrdir, name=None):
 
2375
    def initialize(self, a_bzrdir, name=None, repository=None,
 
2376
                   append_revisions_only=None):
2085
2377
        # 1) get the network name to use.
2086
2378
        if self._custom_format:
2087
2379
            network_name = self._custom_format.network_name()
2088
2380
        else:
2089
2381
            # Select the current bzrlib default and ask for that.
2090
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
2382
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
2091
2383
            reference_format = reference_bzrdir_format.get_branch_format()
2092
2384
            self._custom_format = reference_format
2093
2385
            network_name = reference_format.network_name()
2094
2386
        # Being asked to create on a non RemoteBzrDir:
2095
2387
        if not isinstance(a_bzrdir, RemoteBzrDir):
2096
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2388
            return self._vfs_initialize(a_bzrdir, name=name,
 
2389
                append_revisions_only=append_revisions_only)
2097
2390
        medium = a_bzrdir._client._medium
2098
2391
        if medium._is_remote_before((1, 13)):
2099
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2392
            return self._vfs_initialize(a_bzrdir, name=name,
 
2393
                append_revisions_only=append_revisions_only)
2100
2394
        # Creating on a remote bzr dir.
2101
2395
        # 2) try direct creation via RPC
2102
2396
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2109
2403
        except errors.UnknownSmartMethod:
2110
2404
            # Fallback - use vfs methods
2111
2405
            medium._remember_remote_is_before((1, 13))
2112
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2406
            return self._vfs_initialize(a_bzrdir, name=name,
 
2407
                    append_revisions_only=append_revisions_only)
2113
2408
        if response[0] != 'ok':
2114
2409
            raise errors.UnexpectedSmartServerResponse(response)
2115
2410
        # Turn the response into a RemoteRepository object.
2116
2411
        format = RemoteBranchFormat(network_name=response[1])
2117
2412
        repo_format = response_tuple_to_repo_format(response[3:])
2118
 
        if response[2] == '':
2119
 
            repo_bzrdir = a_bzrdir
 
2413
        repo_path = response[2]
 
2414
        if repository is not None:
 
2415
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
 
2416
            url_diff = urlutils.relative_url(repository.user_url,
 
2417
                    remote_repo_url)
 
2418
            if url_diff != '.':
 
2419
                raise AssertionError(
 
2420
                    'repository.user_url %r does not match URL from server '
 
2421
                    'response (%r + %r)'
 
2422
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
 
2423
            remote_repo = repository
2120
2424
        else:
2121
 
            repo_bzrdir = RemoteBzrDir(
2122
 
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2123
 
                a_bzrdir._client)
2124
 
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
2425
            if repo_path == '':
 
2426
                repo_bzrdir = a_bzrdir
 
2427
            else:
 
2428
                repo_bzrdir = RemoteBzrDir(
 
2429
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
2430
                    a_bzrdir._client)
 
2431
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2125
2432
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2126
2433
            format=format, setup_stacking=False, name=name)
 
2434
        if append_revisions_only:
 
2435
            remote_branch.set_append_revisions_only(append_revisions_only)
2127
2436
        # XXX: We know this is a new branch, so it must have revno 0, revid
2128
2437
        # NULL_REVISION. Creating the branch locked would make this be unable
2129
2438
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2148
2457
        self._ensure_real()
2149
2458
        return self._custom_format.supports_set_append_revisions_only()
2150
2459
 
 
2460
    def _use_default_local_heads_to_fetch(self):
 
2461
        # If the branch format is a metadir format *and* its heads_to_fetch
 
2462
        # implementation is not overridden vs the base class, we can use the
 
2463
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
2464
        # usually cheaper in terms of net round trips, as the last-revision and
 
2465
        # tags info fetched is cached and would be fetched anyway.
 
2466
        self._ensure_real()
 
2467
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
2468
            branch_class = self._custom_format._branch_class()
 
2469
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
2470
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
2471
                return True
 
2472
        return False
2151
2473
 
2152
2474
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2153
2475
    """Branch stored on a server accessed by HPSS RPC.
2311
2633
                self.bzrdir, self._client)
2312
2634
        return self._control_files
2313
2635
 
2314
 
    def _get_checkout_format(self):
 
2636
    def _get_checkout_format(self, lightweight=False):
2315
2637
        self._ensure_real()
2316
 
        return self._real_branch._get_checkout_format()
 
2638
        if lightweight:
 
2639
            format = RemoteBzrDirFormat()
 
2640
            self.bzrdir._format._supply_sub_formats_to(format)
 
2641
            format.workingtree_format = self._real_branch._get_checkout_format(
 
2642
                lightweight=lightweight).workingtree_format
 
2643
            return format
 
2644
        else:
 
2645
            return self._real_branch._get_checkout_format(lightweight=False)
2317
2646
 
2318
2647
    def get_physical_lock_status(self):
2319
2648
        """See Branch.get_physical_lock_status()."""
2352
2681
            self._is_stacked = False
2353
2682
        else:
2354
2683
            self._is_stacked = True
2355
 
        
 
2684
 
2356
2685
    def _vfs_get_tags_bytes(self):
2357
2686
        self._ensure_real()
2358
2687
        return self._real_branch._get_tags_bytes()
2359
2688
 
 
2689
    @needs_read_lock
2360
2690
    def _get_tags_bytes(self):
 
2691
        if self._tags_bytes is None:
 
2692
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
2693
        return self._tags_bytes
 
2694
 
 
2695
    def _get_tags_bytes_via_hpss(self):
2361
2696
        medium = self._client._medium
2362
2697
        if medium._is_remote_before((1, 13)):
2363
2698
            return self._vfs_get_tags_bytes()
2373
2708
        return self._real_branch._set_tags_bytes(bytes)
2374
2709
 
2375
2710
    def _set_tags_bytes(self, bytes):
 
2711
        if self.is_locked():
 
2712
            self._tags_bytes = bytes
2376
2713
        medium = self._client._medium
2377
2714
        if medium._is_remote_before((1, 18)):
2378
2715
            self._vfs_set_tags_bytes(bytes)
2387
2724
            self._vfs_set_tags_bytes(bytes)
2388
2725
 
2389
2726
    def lock_read(self):
 
2727
        """Lock the branch for read operations.
 
2728
 
 
2729
        :return: A bzrlib.lock.LogicalLockResult.
 
2730
        """
2390
2731
        self.repository.lock_read()
2391
2732
        if not self._lock_mode:
2392
2733
            self._note_lock('r')
2396
2737
                self._real_branch.lock_read()
2397
2738
        else:
2398
2739
            self._lock_count += 1
 
2740
        return lock.LogicalLockResult(self.unlock)
2399
2741
 
2400
2742
    def _remote_lock_write(self, token):
2401
2743
        if token is None:
2402
2744
            branch_token = repo_token = ''
2403
2745
        else:
2404
2746
            branch_token = token
2405
 
            repo_token = self.repository.lock_write()
 
2747
            repo_token = self.repository.lock_write().repository_token
2406
2748
            self.repository.unlock()
2407
2749
        err_context = {'token': token}
2408
 
        response = self._call(
2409
 
            'Branch.lock_write', self._remote_path(), branch_token,
2410
 
            repo_token or '', **err_context)
 
2750
        try:
 
2751
            response = self._call(
 
2752
                'Branch.lock_write', self._remote_path(), branch_token,
 
2753
                repo_token or '', **err_context)
 
2754
        except errors.LockContention, e:
 
2755
            # The LockContention from the server doesn't have any
 
2756
            # information about the lock_url. We re-raise LockContention
 
2757
            # with valid lock_url.
 
2758
            raise errors.LockContention('(remote lock)',
 
2759
                self.repository.base.split('.bzr/')[0])
2411
2760
        if response[0] != 'ok':
2412
2761
            raise errors.UnexpectedSmartServerResponse(response)
2413
2762
        ok, branch_token, repo_token = response
2434
2783
            self._lock_mode = 'w'
2435
2784
            self._lock_count = 1
2436
2785
        elif self._lock_mode == 'r':
2437
 
            raise errors.ReadOnlyTransaction
 
2786
            raise errors.ReadOnlyError(self)
2438
2787
        else:
2439
2788
            if token is not None:
2440
2789
                # A token was given to lock_write, and we're relocking, so
2445
2794
            self._lock_count += 1
2446
2795
            # Re-lock the repository too.
2447
2796
            self.repository.lock_write(self._repo_lock_token)
2448
 
        return self._lock_token or None
 
2797
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
2449
2798
 
2450
2799
    def _unlock(self, branch_token, repo_token):
2451
2800
        err_context = {'token': str((branch_token, repo_token))}
2520
2869
            missing_parent = parent_map[missing_parent]
2521
2870
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2522
2871
 
2523
 
    def _last_revision_info(self):
 
2872
    def _read_last_revision_info(self):
2524
2873
        response = self._call('Branch.last_revision_info', self._remote_path())
2525
2874
        if response[0] != 'ok':
2526
2875
            raise SmartProtocolError('unexpected response code %s' % (response,))
2589
2938
            raise errors.UnexpectedSmartServerResponse(response)
2590
2939
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2591
2940
 
 
2941
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2592
2942
    @needs_write_lock
2593
2943
    def set_revision_history(self, rev_history):
 
2944
        """See Branch.set_revision_history."""
 
2945
        self._set_revision_history(rev_history)
 
2946
 
 
2947
    @needs_write_lock
 
2948
    def _set_revision_history(self, rev_history):
2594
2949
        # Send just the tip revision of the history; the server will generate
2595
2950
        # the full history from that.  If the revision doesn't exist in this
2596
2951
        # branch, NoSuchRevision will be raised.
2654
3009
            _override_hook_target=self, **kwargs)
2655
3010
 
2656
3011
    @needs_read_lock
2657
 
    def push(self, target, overwrite=False, stop_revision=None):
 
3012
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2658
3013
        self._ensure_real()
2659
3014
        return self._real_branch.push(
2660
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
3015
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2661
3016
            _override_hook_source_branch=self)
2662
3017
 
2663
3018
    def is_locked(self):
2673
3028
        # XXX: These should be returned by the set_last_revision_info verb
2674
3029
        old_revno, old_revid = self.last_revision_info()
2675
3030
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2676
 
        revision_id = ensure_null(revision_id)
 
3031
        if not revision_id or not isinstance(revision_id, basestring):
 
3032
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2677
3033
        try:
2678
3034
            response = self._call('Branch.set_last_revision_info',
2679
3035
                self._remote_path(), self._lock_token, self._repo_lock_token,
2708
3064
            except errors.UnknownSmartMethod:
2709
3065
                medium._remember_remote_is_before((1, 6))
2710
3066
        self._clear_cached_state_of_remote_branch_only()
2711
 
        self.set_revision_history(self._lefthand_history(revision_id,
 
3067
        self._set_revision_history(self._lefthand_history(revision_id,
2712
3068
            last_rev=last_rev,other_branch=other_branch))
2713
3069
 
2714
3070
    def set_push_location(self, location):
2715
3071
        self._ensure_real()
2716
3072
        return self._real_branch.set_push_location(location)
2717
3073
 
 
3074
    def heads_to_fetch(self):
 
3075
        if self._format._use_default_local_heads_to_fetch():
 
3076
            # We recognise this format, and its heads-to-fetch implementation
 
3077
            # is the default one (tip + tags).  In this case it's cheaper to
 
3078
            # just use the default implementation rather than a special RPC as
 
3079
            # the tip and tags data is cached.
 
3080
            return branch.Branch.heads_to_fetch(self)
 
3081
        medium = self._client._medium
 
3082
        if medium._is_remote_before((2, 4)):
 
3083
            return self._vfs_heads_to_fetch()
 
3084
        try:
 
3085
            return self._rpc_heads_to_fetch()
 
3086
        except errors.UnknownSmartMethod:
 
3087
            medium._remember_remote_is_before((2, 4))
 
3088
            return self._vfs_heads_to_fetch()
 
3089
 
 
3090
    def _rpc_heads_to_fetch(self):
 
3091
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3092
        if len(response) != 2:
 
3093
            raise errors.UnexpectedSmartServerResponse(response)
 
3094
        must_fetch, if_present_fetch = response
 
3095
        return set(must_fetch), set(if_present_fetch)
 
3096
 
 
3097
    def _vfs_heads_to_fetch(self):
 
3098
        self._ensure_real()
 
3099
        return self._real_branch.heads_to_fetch()
 
3100
 
2718
3101
 
2719
3102
class RemoteConfig(object):
2720
3103
    """A Config that reads and writes from smart verbs.
2734
3117
        """
2735
3118
        try:
2736
3119
            configobj = self._get_configobj()
 
3120
            section_obj = None
2737
3121
            if section is None:
2738
3122
                section_obj = configobj
2739
3123
            else:
2740
3124
                try:
2741
3125
                    section_obj = configobj[section]
2742
3126
                except KeyError:
2743
 
                    return default
2744
 
            return section_obj.get(name, default)
 
3127
                    pass
 
3128
            if section_obj is None:
 
3129
                value = default
 
3130
            else:
 
3131
                value = section_obj.get(name, default)
2745
3132
        except errors.UnknownSmartMethod:
2746
 
            return self._vfs_get_option(name, section, default)
 
3133
            value = self._vfs_get_option(name, section, default)
 
3134
        for hook in config.OldConfigHooks['get']:
 
3135
            hook(self, name, value)
 
3136
        return value
2747
3137
 
2748
3138
    def _response_to_configobj(self, response):
2749
3139
        if len(response[0]) and response[0][0] != 'ok':
2750
3140
            raise errors.UnexpectedSmartServerResponse(response)
2751
3141
        lines = response[1].read_body_bytes().splitlines()
2752
 
        return config.ConfigObj(lines, encoding='utf-8')
 
3142
        conf = config.ConfigObj(lines, encoding='utf-8')
 
3143
        for hook in config.OldConfigHooks['load']:
 
3144
            hook(self)
 
3145
        return conf
2753
3146
 
2754
3147
 
2755
3148
class RemoteBranchConfig(RemoteConfig):
2774
3167
        medium = self._branch._client._medium
2775
3168
        if medium._is_remote_before((1, 14)):
2776
3169
            return self._vfs_set_option(value, name, section)
 
3170
        if isinstance(value, dict):
 
3171
            if medium._is_remote_before((2, 2)):
 
3172
                return self._vfs_set_option(value, name, section)
 
3173
            return self._set_config_option_dict(value, name, section)
 
3174
        else:
 
3175
            return self._set_config_option(value, name, section)
 
3176
 
 
3177
    def _set_config_option(self, value, name, section):
2777
3178
        try:
2778
3179
            path = self._branch._remote_path()
2779
3180
            response = self._branch._client.call('Branch.set_config_option',
2780
3181
                path, self._branch._lock_token, self._branch._repo_lock_token,
2781
3182
                value.encode('utf8'), name, section or '')
2782
3183
        except errors.UnknownSmartMethod:
 
3184
            medium = self._branch._client._medium
2783
3185
            medium._remember_remote_is_before((1, 14))
2784
3186
            return self._vfs_set_option(value, name, section)
2785
3187
        if response != ():
2786
3188
            raise errors.UnexpectedSmartServerResponse(response)
2787
3189
 
 
3190
    def _serialize_option_dict(self, option_dict):
 
3191
        utf8_dict = {}
 
3192
        for key, value in option_dict.items():
 
3193
            if isinstance(key, unicode):
 
3194
                key = key.encode('utf8')
 
3195
            if isinstance(value, unicode):
 
3196
                value = value.encode('utf8')
 
3197
            utf8_dict[key] = value
 
3198
        return bencode.bencode(utf8_dict)
 
3199
 
 
3200
    def _set_config_option_dict(self, value, name, section):
 
3201
        try:
 
3202
            path = self._branch._remote_path()
 
3203
            serialised_dict = self._serialize_option_dict(value)
 
3204
            response = self._branch._client.call(
 
3205
                'Branch.set_config_option_dict',
 
3206
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
3207
                serialised_dict, name, section or '')
 
3208
        except errors.UnknownSmartMethod:
 
3209
            medium = self._branch._client._medium
 
3210
            medium._remember_remote_is_before((2, 2))
 
3211
            return self._vfs_set_option(value, name, section)
 
3212
        if response != ():
 
3213
            raise errors.UnexpectedSmartServerResponse(response)
 
3214
 
2788
3215
    def _real_object(self):
2789
3216
        self._branch._ensure_real()
2790
3217
        return self._branch._real_branch
2873
3300
                    'Missing key %r in context %r', key_err.args[0], context)
2874
3301
                raise err
2875
3302
 
2876
 
    if err.error_verb == 'IncompatibleRepositories':
2877
 
        raise errors.IncompatibleRepositories(err.error_args[0],
2878
 
            err.error_args[1], err.error_args[2])
2879
 
    elif err.error_verb == 'NoSuchRevision':
 
3303
    if err.error_verb == 'NoSuchRevision':
2880
3304
        raise NoSuchRevision(find('branch'), err.error_args[0])
2881
3305
    elif err.error_verb == 'nosuchrevision':
2882
3306
        raise NoSuchRevision(find('repository'), err.error_args[0])
2889
3313
            detail=extra)
2890
3314
    elif err.error_verb == 'norepository':
2891
3315
        raise errors.NoRepositoryPresent(find('bzrdir'))
2892
 
    elif err.error_verb == 'LockContention':
2893
 
        raise errors.LockContention('(remote lock)')
2894
3316
    elif err.error_verb == 'UnlockableTransport':
2895
3317
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
2896
 
    elif err.error_verb == 'LockFailed':
2897
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
2898
3318
    elif err.error_verb == 'TokenMismatch':
2899
3319
        raise errors.TokenMismatch(find('token'), '(remote token)')
2900
3320
    elif err.error_verb == 'Diverged':
2901
3321
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
2902
 
    elif err.error_verb == 'TipChangeRejected':
2903
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2904
 
    elif err.error_verb == 'UnstackableBranchFormat':
2905
 
        raise errors.UnstackableBranchFormat(*err.error_args)
2906
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
2907
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2908
3322
    elif err.error_verb == 'NotStacked':
2909
3323
        raise errors.NotStacked(branch=find('branch'))
2910
3324
    elif err.error_verb == 'PermissionDenied':
2920
3334
    elif err.error_verb == 'NoSuchFile':
2921
3335
        path = get_path()
2922
3336
        raise errors.NoSuchFile(path)
 
3337
    _translate_error_without_context(err)
 
3338
 
 
3339
 
 
3340
def _translate_error_without_context(err):
 
3341
    """Translate any ErrorFromSmartServer values that don't require context"""
 
3342
    if err.error_verb == 'IncompatibleRepositories':
 
3343
        raise errors.IncompatibleRepositories(err.error_args[0],
 
3344
            err.error_args[1], err.error_args[2])
 
3345
    elif err.error_verb == 'LockContention':
 
3346
        raise errors.LockContention('(remote lock)')
 
3347
    elif err.error_verb == 'LockFailed':
 
3348
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
 
3349
    elif err.error_verb == 'TipChangeRejected':
 
3350
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
 
3351
    elif err.error_verb == 'UnstackableBranchFormat':
 
3352
        raise errors.UnstackableBranchFormat(*err.error_args)
 
3353
    elif err.error_verb == 'UnstackableRepositoryFormat':
 
3354
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2923
3355
    elif err.error_verb == 'FileExists':
2924
3356
        raise errors.FileExists(err.error_args[0])
2925
3357
    elif err.error_verb == 'DirectoryNotEmpty':
2944
3376
            raise UnicodeEncodeError(encoding, val, start, end, reason)
2945
3377
    elif err.error_verb == 'ReadOnlyError':
2946
3378
        raise errors.TransportNotPossible('readonly transport')
 
3379
    elif err.error_verb == 'MemoryError':
 
3380
        raise errors.BzrError("remote server out of memory\n"
 
3381
            "Retry non-remotely, or contact the server admin for details.")
2947
3382
    raise errors.UnknownErrorFromSmartServer(err)