/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Jelmer Vernooij
  • Date: 2011-11-17 10:59:40 UTC
  • mto: This revision was merged to the branch mainline in revision 6279.
  • Revision ID: jelmer@samba.org-20111117105940-qej6qvokqb44e2ua
Fix tests.

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,
41
41
    SmartProtocolError,
42
42
    )
 
43
from bzrlib.i18n import gettext
43
44
from bzrlib.lockable_files import LockableFiles
44
45
from bzrlib.smart import client, vfs, repository as smart_repo
45
 
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
46
49
from bzrlib.trace import mutter, note, warning
47
50
 
48
51
 
 
52
_DEFAULT_SEARCH_DEPTH = 100
 
53
 
 
54
 
49
55
class _RpcHelper(object):
50
56
    """Mixin class that helps with issuing RPCs."""
51
57
 
86
92
    return format
87
93
 
88
94
 
89
 
# Note: RemoteBzrDirFormat is in bzrdir.py
90
 
 
91
 
class RemoteBzrDir(BzrDir, _RpcHelper):
 
95
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
 
96
# does not have to be imported unless a remote format is involved.
 
97
 
 
98
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
 
99
    """Format representing bzrdirs accessed via a smart server"""
 
100
 
 
101
    supports_workingtrees = False
 
102
 
 
103
    def __init__(self):
 
104
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
 
105
        # XXX: It's a bit ugly that the network name is here, because we'd
 
106
        # like to believe that format objects are stateless or at least
 
107
        # immutable,  However, we do at least avoid mutating the name after
 
108
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
 
109
        self._network_name = None
 
110
 
 
111
    def __repr__(self):
 
112
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
113
            self._network_name)
 
114
 
 
115
    def get_format_description(self):
 
116
        if self._network_name:
 
117
            real_format = controldir.network_format_registry.get(self._network_name)
 
118
            return 'Remote: ' + real_format.get_format_description()
 
119
        return 'bzr remote bzrdir'
 
120
 
 
121
    def get_format_string(self):
 
122
        raise NotImplementedError(self.get_format_string)
 
123
 
 
124
    def network_name(self):
 
125
        if self._network_name:
 
126
            return self._network_name
 
127
        else:
 
128
            raise AssertionError("No network name set.")
 
129
 
 
130
    def initialize_on_transport(self, transport):
 
131
        try:
 
132
            # hand off the request to the smart server
 
133
            client_medium = transport.get_smart_medium()
 
134
        except errors.NoSmartMedium:
 
135
            # TODO: lookup the local format from a server hint.
 
136
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
137
            return local_dir_format.initialize_on_transport(transport)
 
138
        client = _SmartClient(client_medium)
 
139
        path = client.remote_path_from_transport(transport)
 
140
        try:
 
141
            response = client.call('BzrDirFormat.initialize', path)
 
142
        except errors.ErrorFromSmartServer, err:
 
143
            _translate_error(err, path=path)
 
144
        if response[0] != 'ok':
 
145
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
 
146
        format = RemoteBzrDirFormat()
 
147
        self._supply_sub_formats_to(format)
 
148
        return RemoteBzrDir(transport, format)
 
149
 
 
150
    def parse_NoneTrueFalse(self, arg):
 
151
        if not arg:
 
152
            return None
 
153
        if arg == 'False':
 
154
            return False
 
155
        if arg == 'True':
 
156
            return True
 
157
        raise AssertionError("invalid arg %r" % arg)
 
158
 
 
159
    def _serialize_NoneTrueFalse(self, arg):
 
160
        if arg is False:
 
161
            return 'False'
 
162
        if arg:
 
163
            return 'True'
 
164
        return ''
 
165
 
 
166
    def _serialize_NoneString(self, arg):
 
167
        return arg or ''
 
168
 
 
169
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
170
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
171
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
172
        shared_repo=False):
 
173
        try:
 
174
            # hand off the request to the smart server
 
175
            client_medium = transport.get_smart_medium()
 
176
        except errors.NoSmartMedium:
 
177
            do_vfs = True
 
178
        else:
 
179
            # Decline to open it if the server doesn't support our required
 
180
            # version (3) so that the VFS-based transport will do it.
 
181
            if client_medium.should_probe():
 
182
                try:
 
183
                    server_version = client_medium.protocol_version()
 
184
                    if server_version != '2':
 
185
                        do_vfs = True
 
186
                    else:
 
187
                        do_vfs = False
 
188
                except errors.SmartProtocolError:
 
189
                    # Apparently there's no usable smart server there, even though
 
190
                    # the medium supports the smart protocol.
 
191
                    do_vfs = True
 
192
            else:
 
193
                do_vfs = False
 
194
        if not do_vfs:
 
195
            client = _SmartClient(client_medium)
 
196
            path = client.remote_path_from_transport(transport)
 
197
            if client_medium._is_remote_before((1, 16)):
 
198
                do_vfs = True
 
199
        if do_vfs:
 
200
            # TODO: lookup the local format from a server hint.
 
201
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
202
            self._supply_sub_formats_to(local_dir_format)
 
203
            return local_dir_format.initialize_on_transport_ex(transport,
 
204
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
205
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
206
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
207
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
208
                vfs_only=True)
 
209
        return self._initialize_on_transport_ex_rpc(client, path, transport,
 
210
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
211
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
 
212
 
 
213
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
 
214
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
215
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
 
216
        args = []
 
217
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
 
218
        args.append(self._serialize_NoneTrueFalse(create_prefix))
 
219
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
 
220
        args.append(self._serialize_NoneString(stacked_on))
 
221
        # stack_on_pwd is often/usually our transport
 
222
        if stack_on_pwd:
 
223
            try:
 
224
                stack_on_pwd = transport.relpath(stack_on_pwd)
 
225
                if not stack_on_pwd:
 
226
                    stack_on_pwd = '.'
 
227
            except errors.PathNotChild:
 
228
                pass
 
229
        args.append(self._serialize_NoneString(stack_on_pwd))
 
230
        args.append(self._serialize_NoneString(repo_format_name))
 
231
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
 
232
        args.append(self._serialize_NoneTrueFalse(shared_repo))
 
233
        request_network_name = self._network_name or \
 
234
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
 
235
        try:
 
236
            response = client.call('BzrDirFormat.initialize_ex_1.16',
 
237
                request_network_name, path, *args)
 
238
        except errors.UnknownSmartMethod:
 
239
            client._medium._remember_remote_is_before((1,16))
 
240
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
241
            self._supply_sub_formats_to(local_dir_format)
 
242
            return local_dir_format.initialize_on_transport_ex(transport,
 
243
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
244
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
245
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
246
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
247
                vfs_only=True)
 
248
        except errors.ErrorFromSmartServer, err:
 
249
            _translate_error(err, path=path)
 
250
        repo_path = response[0]
 
251
        bzrdir_name = response[6]
 
252
        require_stacking = response[7]
 
253
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
 
254
        format = RemoteBzrDirFormat()
 
255
        format._network_name = bzrdir_name
 
256
        self._supply_sub_formats_to(format)
 
257
        bzrdir = RemoteBzrDir(transport, format, _client=client)
 
258
        if repo_path:
 
259
            repo_format = response_tuple_to_repo_format(response[1:])
 
260
            if repo_path == '.':
 
261
                repo_path = ''
 
262
            if repo_path:
 
263
                repo_bzrdir_format = RemoteBzrDirFormat()
 
264
                repo_bzrdir_format._network_name = response[5]
 
265
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
 
266
                    repo_bzrdir_format)
 
267
            else:
 
268
                repo_bzr = bzrdir
 
269
            final_stack = response[8] or None
 
270
            final_stack_pwd = response[9] or None
 
271
            if final_stack_pwd:
 
272
                final_stack_pwd = urlutils.join(
 
273
                    transport.base, final_stack_pwd)
 
274
            remote_repo = RemoteRepository(repo_bzr, repo_format)
 
275
            if len(response) > 10:
 
276
                # Updated server verb that locks remotely.
 
277
                repo_lock_token = response[10] or None
 
278
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
 
279
                if repo_lock_token:
 
280
                    remote_repo.dont_leave_lock_in_place()
 
281
            else:
 
282
                remote_repo.lock_write()
 
283
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
 
284
                final_stack_pwd, require_stacking)
 
285
            policy.acquire_repository()
 
286
        else:
 
287
            remote_repo = None
 
288
            policy = None
 
289
        bzrdir._format.set_branch_format(self.get_branch_format())
 
290
        if require_stacking:
 
291
            # The repo has already been created, but we need to make sure that
 
292
            # we'll make a stackable branch.
 
293
            bzrdir._format.require_stacking(_skip_repo=True)
 
294
        return remote_repo, bzrdir, require_stacking, policy
 
295
 
 
296
    def _open(self, transport):
 
297
        return RemoteBzrDir(transport, self)
 
298
 
 
299
    def __eq__(self, other):
 
300
        if not isinstance(other, RemoteBzrDirFormat):
 
301
            return False
 
302
        return self.get_format_description() == other.get_format_description()
 
303
 
 
304
    def __return_repository_format(self):
 
305
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
 
306
        # repository format has been asked for, tell the RemoteRepositoryFormat
 
307
        # that it should use that for init() etc.
 
308
        result = RemoteRepositoryFormat()
 
309
        custom_format = getattr(self, '_repository_format', None)
 
310
        if custom_format:
 
311
            if isinstance(custom_format, RemoteRepositoryFormat):
 
312
                return custom_format
 
313
            else:
 
314
                # We will use the custom format to create repositories over the
 
315
                # wire; expose its details like rich_root_data for code to
 
316
                # query
 
317
                result._custom_format = custom_format
 
318
        return result
 
319
 
 
320
    def get_branch_format(self):
 
321
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
 
322
        if not isinstance(result, RemoteBranchFormat):
 
323
            new_result = RemoteBranchFormat()
 
324
            new_result._custom_format = result
 
325
            # cache the result
 
326
            self.set_branch_format(new_result)
 
327
            result = new_result
 
328
        return result
 
329
 
 
330
    repository_format = property(__return_repository_format,
 
331
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
 
332
 
 
333
 
 
334
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
92
335
    """Control directory on a remote server, accessed via bzr:// or similar."""
93
336
 
94
337
    def __init__(self, transport, format, _client=None, _force_probe=False):
97
340
        :param _client: Private parameter for testing. Disables probing and the
98
341
            use of a real bzrdir.
99
342
        """
100
 
        BzrDir.__init__(self, transport, format)
 
343
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
101
344
        # this object holds a delegated bzrdir that uses file-level operations
102
345
        # to talk to the other side
103
346
        self._real_bzrdir = None
163
406
                import traceback
164
407
                warning('VFS BzrDir access triggered\n%s',
165
408
                    ''.join(traceback.format_stack()))
166
 
            self._real_bzrdir = BzrDir.open_from_transport(
 
409
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
167
410
                self.root_transport, _server_formats=False)
168
411
            self._format._network_name = \
169
412
                self._real_bzrdir._format.network_name()
175
418
        # Prevent aliasing problems in the next_open_branch_result cache.
176
419
        # See create_branch for rationale.
177
420
        self._next_open_branch_result = None
178
 
        return BzrDir.break_lock(self)
 
421
        return _mod_bzrdir.BzrDir.break_lock(self)
179
422
 
180
423
    def _vfs_cloning_metadir(self, require_stacking=False):
181
424
        self._ensure_real()
212
455
        if len(branch_info) != 2:
213
456
            raise errors.UnexpectedSmartServerResponse(response)
214
457
        branch_ref, branch_name = branch_info
215
 
        format = bzrdir.network_format_registry.get(control_name)
 
458
        format = controldir.network_format_registry.get(control_name)
216
459
        if repo_name:
217
 
            format.repository_format = repository.network_format_registry.get(
 
460
            format.repository_format = _mod_repository.network_format_registry.get(
218
461
                repo_name)
219
462
        if branch_ref == 'ref':
220
463
            # XXX: we need possible_transports here to avoid reopening the
221
464
            # connection to the referenced location
222
 
            ref_bzrdir = BzrDir.open(branch_name)
 
465
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
223
466
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
224
467
            format.set_branch_format(branch_format)
225
468
        elif branch_ref == 'branch':
241
484
 
242
485
    def destroy_repository(self):
243
486
        """See BzrDir.destroy_repository"""
244
 
        self._ensure_real()
245
 
        self._real_bzrdir.destroy_repository()
 
487
        path = self._path_for_remote_call(self._client)
 
488
        try:
 
489
            response = self._call('BzrDir.destroy_repository', path)
 
490
        except errors.UnknownSmartMethod:
 
491
            self._ensure_real()
 
492
            self._real_bzrdir.destroy_repository()
 
493
            return
 
494
        if response[0] != 'ok':
 
495
            raise SmartProtocolError('unexpected response code %s' % (response,))
246
496
 
247
 
    def create_branch(self, name=None):
 
497
    def create_branch(self, name=None, repository=None,
 
498
                      append_revisions_only=None):
248
499
        # as per meta1 formats - just delegate to the format object which may
249
500
        # be parameterised.
250
501
        real_branch = self._format.get_branch_format().initialize(self,
251
 
            name=name)
 
502
            name=name, repository=repository,
 
503
            append_revisions_only=append_revisions_only)
252
504
        if not isinstance(real_branch, RemoteBranch):
253
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
254
 
                                  name=name)
 
505
            if not isinstance(repository, RemoteRepository):
 
506
                raise AssertionError(
 
507
                    'need a RemoteRepository to use with RemoteBranch, got %r'
 
508
                    % (repository,))
 
509
            result = RemoteBranch(self, repository, real_branch, name=name)
255
510
        else:
256
511
            result = real_branch
257
512
        # BzrDir.clone_on_transport() uses the result of create_branch but does
269
524
        self._real_bzrdir.destroy_branch(name=name)
270
525
        self._next_open_branch_result = None
271
526
 
272
 
    def create_workingtree(self, revision_id=None, from_branch=None):
 
527
    def create_workingtree(self, revision_id=None, from_branch=None,
 
528
        accelerator_tree=None, hardlink=False):
273
529
        raise errors.NotLocalUrl(self.transport.base)
274
530
 
275
 
    def find_branch_format(self):
 
531
    def find_branch_format(self, name=None):
276
532
        """Find the branch 'format' for this bzrdir.
277
533
 
278
534
        This might be a synthetic object for e.g. RemoteBranch and SVN.
279
535
        """
280
 
        b = self.open_branch()
 
536
        b = self.open_branch(name=name)
281
537
        return b._format
282
538
 
283
 
    def get_branch_reference(self):
 
539
    def get_branch_reference(self, name=None):
284
540
        """See BzrDir.get_branch_reference()."""
 
541
        if name is not None:
 
542
            # XXX JRV20100304: Support opening colocated branches
 
543
            raise errors.NoColocatedBranchSupport(self)
285
544
        response = self._get_branch_reference()
286
545
        if response[0] == 'ref':
287
546
            return response[1]
318
577
            raise errors.UnexpectedSmartServerResponse(response)
319
578
        return response
320
579
 
321
 
    def _get_tree_branch(self):
 
580
    def _get_tree_branch(self, name=None):
322
581
        """See BzrDir._get_tree_branch()."""
323
 
        return None, self.open_branch()
 
582
        return None, self.open_branch(name=name)
324
583
 
325
584
    def open_branch(self, name=None, unsupported=False,
326
585
                    ignore_fallbacks=False):
423
682
 
424
683
    def _path_for_remote_call(self, client):
425
684
        """Return the path to be used for this bzrdir in a remote call."""
426
 
        return client.remote_path_from_transport(self.root_transport)
 
685
        return urlutils.split_segment_parameters_raw(
 
686
            client.remote_path_from_transport(self.root_transport))[0]
427
687
 
428
688
    def get_branch_transport(self, branch_format, name=None):
429
689
        self._ensure_real()
441
701
        """Upgrading of remote bzrdirs is not supported yet."""
442
702
        return False
443
703
 
444
 
    def needs_format_conversion(self, format=None):
 
704
    def needs_format_conversion(self, format):
445
705
        """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
706
        return False
450
707
 
451
708
    def clone(self, url, revision_id=None, force_new_repo=False,
458
715
        return RemoteBzrDirConfig(self)
459
716
 
460
717
 
461
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
718
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
462
719
    """Format for repositories accessed over a _SmartClient.
463
720
 
464
721
    Instances of this repository are represented by RemoteRepository
479
736
    """
480
737
 
481
738
    _matchingbzrdir = RemoteBzrDirFormat()
 
739
    supports_full_versioned_files = True
 
740
    supports_leaving_lock = True
482
741
 
483
742
    def __init__(self):
484
 
        repository.RepositoryFormat.__init__(self)
 
743
        _mod_repository.RepositoryFormat.__init__(self)
485
744
        self._custom_format = None
486
745
        self._network_name = None
487
746
        self._creating_bzrdir = None
 
747
        self._revision_graph_can_have_wrong_parents = None
488
748
        self._supports_chks = None
489
749
        self._supports_external_lookups = None
490
750
        self._supports_tree_reference = None
 
751
        self._supports_funky_characters = None
 
752
        self._supports_nesting_repositories = None
491
753
        self._rich_root_data = None
492
754
 
493
755
    def __repr__(self):
522
784
        return self._supports_external_lookups
523
785
 
524
786
    @property
 
787
    def supports_funky_characters(self):
 
788
        if self._supports_funky_characters is None:
 
789
            self._ensure_real()
 
790
            self._supports_funky_characters = \
 
791
                self._custom_format.supports_funky_characters
 
792
        return self._supports_funky_characters
 
793
 
 
794
    @property
 
795
    def supports_nesting_repositories(self):
 
796
        if self._supports_nesting_repositories is None:
 
797
            self._ensure_real()
 
798
            self._supports_nesting_repositories = \
 
799
                self._custom_format.supports_nesting_repositories
 
800
        return self._supports_nesting_repositories
 
801
 
 
802
    @property
525
803
    def supports_tree_reference(self):
526
804
        if self._supports_tree_reference is None:
527
805
            self._ensure_real()
529
807
                self._custom_format.supports_tree_reference
530
808
        return self._supports_tree_reference
531
809
 
 
810
    @property
 
811
    def revision_graph_can_have_wrong_parents(self):
 
812
        if self._revision_graph_can_have_wrong_parents is None:
 
813
            self._ensure_real()
 
814
            self._revision_graph_can_have_wrong_parents = \
 
815
                self._custom_format.revision_graph_can_have_wrong_parents
 
816
        return self._revision_graph_can_have_wrong_parents
 
817
 
532
818
    def _vfs_initialize(self, a_bzrdir, shared):
533
819
        """Helper for common code in initialize."""
534
820
        if self._custom_format:
569
855
            network_name = self._network_name
570
856
        else:
571
857
            # Select the current bzrlib default and ask for that.
572
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
858
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
573
859
            reference_format = reference_bzrdir_format.repository_format
574
860
            network_name = reference_format.network_name()
575
861
        # 2) try direct creation via RPC
601
887
 
602
888
    def _ensure_real(self):
603
889
        if self._custom_format is None:
604
 
            self._custom_format = repository.network_format_registry.get(
 
890
            self._custom_format = _mod_repository.network_format_registry.get(
605
891
                self._network_name)
606
892
 
607
893
    @property
644
930
 
645
931
 
646
932
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
647
 
    bzrdir.ControlComponent):
 
933
    controldir.ControlComponent):
648
934
    """Repository accessed over rpc.
649
935
 
650
936
    For the moment most operations are performed using local transport-backed
703
989
        # transport, but I'm not sure it's worth making this method
704
990
        # optional -- mbp 2010-04-21
705
991
        return self.bzrdir.get_repository_transport(None)
706
 
        
 
992
 
707
993
    def __str__(self):
708
994
        return "%s(%s)" % (self.__class__.__name__, self.base)
709
995
 
817
1103
    def find_text_key_references(self):
818
1104
        """Find the text key references within the repository.
819
1105
 
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
1106
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
824
1107
            to whether they were referred to by the inventory of the
825
1108
            revision_id that they contain. The inventory texts from all present
843
1126
        """Private method for using with old (< 1.2) servers to fallback."""
844
1127
        if revision_id is None:
845
1128
            revision_id = ''
846
 
        elif revision.is_null(revision_id):
 
1129
        elif _mod_revision.is_null(revision_id):
847
1130
            return {}
848
1131
 
849
1132
        path = self.bzrdir._path_for_remote_call(self._client)
873
1156
        return RemoteStreamSource(self, to_format)
874
1157
 
875
1158
    @needs_read_lock
 
1159
    def get_file_graph(self):
 
1160
        return graph.Graph(self.texts)
 
1161
 
 
1162
    @needs_read_lock
876
1163
    def has_revision(self, revision_id):
877
1164
        """True if this repository has a copy of the revision."""
878
1165
        # Copy of bzrlib.repository.Repository.has_revision
895
1182
    def _has_same_fallbacks(self, other_repo):
896
1183
        """Returns true if the repositories have the same fallbacks."""
897
1184
        # XXX: copied from Repository; it should be unified into a base class
898
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
1185
        # <https://bugs.launchpad.net/bzr/+bug/401622>
899
1186
        my_fb = self._fallback_repositories
900
1187
        other_fb = other_repo._fallback_repositories
901
1188
        if len(my_fb) != len(other_fb):
930
1217
        """See Repository.gather_stats()."""
931
1218
        path = self.bzrdir._path_for_remote_call(self._client)
932
1219
        # revid can be None to indicate no revisions, not just NULL_REVISION
933
 
        if revid is None or revision.is_null(revid):
 
1220
        if revid is None or _mod_revision.is_null(revid):
934
1221
            fmt_revid = ''
935
1222
        else:
936
1223
            fmt_revid = revid
997
1284
        pass
998
1285
 
999
1286
    def lock_read(self):
 
1287
        """Lock the repository for read operations.
 
1288
 
 
1289
        :return: A bzrlib.lock.LogicalLockResult.
 
1290
        """
1000
1291
        # wrong eventually - want a local lock cache context
1001
1292
        if not self._lock_mode:
1002
1293
            self._note_lock('r')
1009
1300
                repo.lock_read()
1010
1301
        else:
1011
1302
            self._lock_count += 1
 
1303
        return lock.LogicalLockResult(self.unlock)
1012
1304
 
1013
1305
    def _remote_lock_write(self, token):
1014
1306
        path = self.bzrdir._path_for_remote_call(self._client)
1054
1346
            raise errors.ReadOnlyError(self)
1055
1347
        else:
1056
1348
            self._lock_count += 1
1057
 
        return self._lock_token or None
 
1349
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
1058
1350
 
1059
1351
    def leave_lock_in_place(self):
1060
1352
        if not self._lock_token:
1214
1506
 
1215
1507
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1216
1508
                           timezone=None, committer=None, revprops=None,
1217
 
                           revision_id=None):
 
1509
                           revision_id=None, lossy=False):
1218
1510
        # FIXME: It ought to be possible to call this without immediately
1219
1511
        # triggering _ensure_real.  For now it's the easiest thing to do.
1220
1512
        self._ensure_real()
1221
1513
        real_repo = self._real_repository
1222
1514
        builder = real_repo.get_commit_builder(branch, parents,
1223
1515
                config, timestamp=timestamp, timezone=timezone,
1224
 
                committer=committer, revprops=revprops, revision_id=revision_id)
 
1516
                committer=committer, revprops=revprops,
 
1517
                revision_id=revision_id, lossy=lossy)
1225
1518
        return builder
1226
1519
 
1227
1520
    def add_fallback_repository(self, repository):
1235
1528
        # We need to accumulate additional repositories here, to pass them in
1236
1529
        # on various RPC's.
1237
1530
        #
 
1531
        # Make the check before we lock: this raises an exception.
 
1532
        self._check_fallback_repository(repository)
1238
1533
        if self.is_locked():
1239
1534
            # We will call fallback.unlock() when we transition to the unlocked
1240
1535
            # state, so always add a lock here. If a caller passes us a locked
1241
1536
            # repository, they are responsible for unlocking it later.
1242
1537
            repository.lock_read()
1243
 
        self._check_fallback_repository(repository)
1244
1538
        self._fallback_repositories.append(repository)
1245
1539
        # If self._real_repository was parameterised already (e.g. because a
1246
1540
        # _real_branch had its get_stacked_on_url method called), then the
1306
1600
        return self._real_repository.make_working_trees()
1307
1601
 
1308
1602
    def refresh_data(self):
1309
 
        """Re-read any data needed to to synchronise with disk.
 
1603
        """Re-read any data needed to synchronise with disk.
1310
1604
 
1311
1605
        This method is intended to be called after another repository instance
1312
1606
        (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.
 
1607
        repository. On all repositories this will work outside of write groups.
 
1608
        Some repository formats (pack and newer for bzrlib native formats)
 
1609
        support refresh_data inside write groups. If called inside a write
 
1610
        group on a repository that does not support refreshing in a write group
 
1611
        IsInWriteGroupError will be raised.
1315
1612
        """
1316
 
        if self.is_in_write_group():
1317
 
            raise errors.InternalBzrError(
1318
 
                "May not refresh_data while in a write group.")
1319
1613
        if self._real_repository is not None:
1320
1614
            self._real_repository.refresh_data()
1321
1615
 
1333
1627
        return result
1334
1628
 
1335
1629
    @needs_read_lock
1336
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
1630
    def search_missing_revision_ids(self, other,
 
1631
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
1632
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
1633
            limit=None):
1337
1634
        """Return the revision ids that other has that this does not.
1338
1635
 
1339
1636
        These are returned in topological order.
1340
1637
 
1341
1638
        revision_id: only return revision ids included by revision_id.
1342
1639
        """
1343
 
        return repository.InterRepository.get(
1344
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
1640
        if symbol_versioning.deprecated_passed(revision_id):
 
1641
            symbol_versioning.warn(
 
1642
                'search_missing_revision_ids(revision_id=...) was '
 
1643
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
1644
                DeprecationWarning, stacklevel=2)
 
1645
            if revision_ids is not None:
 
1646
                raise AssertionError(
 
1647
                    'revision_ids is mutually exclusive with revision_id')
 
1648
            if revision_id is not None:
 
1649
                revision_ids = [revision_id]
 
1650
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
1651
        return inter_repo.search_missing_revision_ids(
 
1652
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
1653
            if_present_ids=if_present_ids, limit=limit)
1345
1654
 
1346
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
1655
    def fetch(self, source, revision_id=None, find_ghosts=False,
1347
1656
            fetch_spec=None):
1348
1657
        # No base implementation to use as RemoteRepository is not a subclass
1349
1658
        # of Repository; so this is a copy of Repository.fetch().
1360
1669
            # check that last_revision is in 'from' and then return a
1361
1670
            # no-operation.
1362
1671
            if (revision_id is not None and
1363
 
                not revision.is_null(revision_id)):
 
1672
                not _mod_revision.is_null(revision_id)):
1364
1673
                self.get_revision(revision_id)
1365
1674
            return 0, []
1366
1675
        # if there is no specific appropriate InterRepository, this will get
1367
1676
        # the InterRepository base class, which raises an
1368
1677
        # IncompatibleRepositories when asked to fetch.
1369
 
        inter = repository.InterRepository.get(source, self)
1370
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
1678
        inter = _mod_repository.InterRepository.get(source, self)
 
1679
        return inter.fetch(revision_id=revision_id,
1371
1680
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1372
1681
 
1373
1682
    def create_bundle(self, target, base, fileobj, format=None):
1375
1684
        self._real_repository.create_bundle(target, base, fileobj, format)
1376
1685
 
1377
1686
    @needs_read_lock
 
1687
    @symbol_versioning.deprecated_method(
 
1688
        symbol_versioning.deprecated_in((2, 4, 0)))
1378
1689
    def get_ancestry(self, revision_id, topo_sorted=True):
1379
1690
        self._ensure_real()
1380
1691
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1394
1705
        self._ensure_real()
1395
1706
        return self._real_repository.iter_files_bytes(desired_files)
1396
1707
 
 
1708
    def get_cached_parent_map(self, revision_ids):
 
1709
        """See bzrlib.CachingParentsProvider.get_cached_parent_map"""
 
1710
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
 
1711
 
1397
1712
    def get_parent_map(self, revision_ids):
1398
1713
        """See bzrlib.Graph.get_parent_map()."""
1399
1714
        return self._make_parents_provider().get_parent_map(revision_ids)
1457
1772
        if parents_map is None:
1458
1773
            # Repository is not locked, so there's no cache.
1459
1774
            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)
 
1775
        if _DEFAULT_SEARCH_DEPTH <= 0:
 
1776
            (start_set, stop_keys,
 
1777
             key_count) = graph.search_result_from_parent_map(
 
1778
                parents_map, self._unstacked_provider.missing_keys)
 
1779
        else:
 
1780
            (start_set, stop_keys,
 
1781
             key_count) = graph.limited_search_result_from_parent_map(
 
1782
                parents_map, self._unstacked_provider.missing_keys,
 
1783
                keys, depth=_DEFAULT_SEARCH_DEPTH)
1480
1784
        recipe = ('manual', start_set, stop_keys, key_count)
1481
1785
        body = self._serialise_search_recipe(recipe)
1482
1786
        path = self.bzrdir._path_for_remote_call(self._client)
1586
1890
        from bzrlib import osutils
1587
1891
        import tarfile
1588
1892
        # TODO: Maybe a progress bar while streaming the tarball?
1589
 
        note("Copying repository content as tarball...")
 
1893
        note(gettext("Copying repository content as tarball..."))
1590
1894
        tar_file = self._get_tarball('bz2')
1591
1895
        if tar_file is None:
1592
1896
            return None
1597
1901
            tmpdir = osutils.mkdtemp()
1598
1902
            try:
1599
1903
                _extract_tar(tar, tmpdir)
1600
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
1904
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1601
1905
                tmp_repo = tmp_bzrdir.open_repository()
1602
1906
                tmp_repo.copy_content_into(destination, revision_id)
1603
1907
            finally:
1688
1992
    def supports_rich_root(self):
1689
1993
        return self._format.rich_root_data
1690
1994
 
 
1995
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1691
1996
    def iter_reverse_revision_history(self, revision_id):
1692
1997
        self._ensure_real()
1693
1998
        return self._real_repository.iter_reverse_revision_history(revision_id)
1709
2014
        self._ensure_real()
1710
2015
        return self._real_repository.has_signature_for_revision_id(revision_id)
1711
2016
 
 
2017
    def verify_revision_signature(self, revision_id, gpg_strategy):
 
2018
        self._ensure_real()
 
2019
        return self._real_repository.verify_revision_signature(
 
2020
            revision_id, gpg_strategy)
 
2021
 
1712
2022
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1713
2023
        self._ensure_real()
1714
2024
        return self._real_repository.item_keys_introduced_by(revision_ids,
1715
2025
            _files_pb=_files_pb)
1716
2026
 
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
2027
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1723
2028
        self._ensure_real()
1724
2029
        return self._real_repository._find_inconsistent_revision_parents(
1732
2037
        providers = [self._unstacked_provider]
1733
2038
        if other is not None:
1734
2039
            providers.insert(0, other)
1735
 
        providers.extend(r._make_parents_provider() for r in
1736
 
                         self._fallback_repositories)
1737
 
        return graph.StackedParentsProvider(providers)
 
2040
        return graph.StackedParentsProvider(_LazyListJoin(
 
2041
            providers, self._fallback_repositories))
1738
2042
 
1739
2043
    def _serialise_search_recipe(self, recipe):
1740
2044
        """Serialise a graph search recipe.
1748
2052
        return '\n'.join((start_keys, stop_keys, count))
1749
2053
 
1750
2054
    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)]
 
2055
        parts = search_result.get_network_struct()
1757
2056
        return '\n'.join(parts)
1758
2057
 
1759
2058
    def autopack(self):
1769
2068
            raise errors.UnexpectedSmartServerResponse(response)
1770
2069
 
1771
2070
 
1772
 
class RemoteStreamSink(repository.StreamSink):
 
2071
class RemoteStreamSink(vf_repository.StreamSink):
1773
2072
 
1774
2073
    def _insert_real(self, stream, src_format, resume_tokens):
1775
2074
        self.target_repo._ensure_real()
1876
2175
        self._last_substream and self._last_stream so that the stream can be
1877
2176
        resumed by _resume_stream_with_vfs.
1878
2177
        """
1879
 
                    
 
2178
 
1880
2179
        stream_iter = iter(stream)
1881
2180
        for substream_kind, substream in stream_iter:
1882
2181
            if substream_kind == 'inventory-deltas':
1885
2184
                return
1886
2185
            else:
1887
2186
                yield substream_kind, substream
1888
 
            
1889
 
 
1890
 
class RemoteStreamSource(repository.StreamSource):
 
2187
 
 
2188
 
 
2189
class RemoteStreamSource(vf_repository.StreamSource):
1891
2190
    """Stream data from a remote server."""
1892
2191
 
1893
2192
    def get_stream(self, search):
1953
2252
        candidate_verbs = [
1954
2253
            ('Repository.get_stream_1.19', (1, 19)),
1955
2254
            ('Repository.get_stream', (1, 13))]
 
2255
 
1956
2256
        found_verb = False
1957
2257
        for verb, version in candidate_verbs:
1958
2258
            if medium._is_remote_before(version):
1962
2262
                    verb, args, search_bytes)
1963
2263
            except errors.UnknownSmartMethod:
1964
2264
                medium._remember_remote_is_before(version)
 
2265
            except errors.UnknownErrorFromSmartServer, e:
 
2266
                if isinstance(search, graph.EverythingResult):
 
2267
                    error_verb = e.error_from_smart_server.error_verb
 
2268
                    if error_verb == 'BadSearch':
 
2269
                        # Pre-2.4 servers don't support this sort of search.
 
2270
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
2271
                        # good idea in general?  It might provide a little bit
 
2272
                        # of protection against client-side bugs.
 
2273
                        medium._remember_remote_is_before((2, 4))
 
2274
                        break
 
2275
                raise
1965
2276
            else:
1966
2277
                response_tuple, response_handler = response
1967
2278
                found_verb = True
1971
2282
        if response_tuple[0] != 'ok':
1972
2283
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1973
2284
        byte_stream = response_handler.read_streamed_body()
1974
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
2285
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
2286
            self._record_counter)
1975
2287
        if src_format.network_name() != repo._format.network_name():
1976
2288
            raise AssertionError(
1977
2289
                "Mismatched RemoteRepository and stream src %r, %r" % (
2063
2375
        return a_bzrdir.open_branch(name=name, 
2064
2376
            ignore_fallbacks=ignore_fallbacks)
2065
2377
 
2066
 
    def _vfs_initialize(self, a_bzrdir, name):
 
2378
    def _vfs_initialize(self, a_bzrdir, name, append_revisions_only):
2067
2379
        # Initialisation when using a local bzrdir object, or a non-vfs init
2068
2380
        # method is not available on the server.
2069
2381
        # self._custom_format is always set - the start of initialize ensures
2071
2383
        if isinstance(a_bzrdir, RemoteBzrDir):
2072
2384
            a_bzrdir._ensure_real()
2073
2385
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2074
 
                name)
 
2386
                name, append_revisions_only=append_revisions_only)
2075
2387
        else:
2076
2388
            # We assume the bzrdir is parameterised; it may not be.
2077
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
2389
            result = self._custom_format.initialize(a_bzrdir, name,
 
2390
                append_revisions_only=append_revisions_only)
2078
2391
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2079
2392
            not isinstance(result, RemoteBranch)):
2080
2393
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2081
2394
                                  name=name)
2082
2395
        return result
2083
2396
 
2084
 
    def initialize(self, a_bzrdir, name=None):
 
2397
    def initialize(self, a_bzrdir, name=None, repository=None,
 
2398
                   append_revisions_only=None):
2085
2399
        # 1) get the network name to use.
2086
2400
        if self._custom_format:
2087
2401
            network_name = self._custom_format.network_name()
2088
2402
        else:
2089
2403
            # Select the current bzrlib default and ask for that.
2090
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
2404
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
2091
2405
            reference_format = reference_bzrdir_format.get_branch_format()
2092
2406
            self._custom_format = reference_format
2093
2407
            network_name = reference_format.network_name()
2094
2408
        # Being asked to create on a non RemoteBzrDir:
2095
2409
        if not isinstance(a_bzrdir, RemoteBzrDir):
2096
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2410
            return self._vfs_initialize(a_bzrdir, name=name,
 
2411
                append_revisions_only=append_revisions_only)
2097
2412
        medium = a_bzrdir._client._medium
2098
2413
        if medium._is_remote_before((1, 13)):
2099
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2414
            return self._vfs_initialize(a_bzrdir, name=name,
 
2415
                append_revisions_only=append_revisions_only)
2100
2416
        # Creating on a remote bzr dir.
2101
2417
        # 2) try direct creation via RPC
2102
2418
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2109
2425
        except errors.UnknownSmartMethod:
2110
2426
            # Fallback - use vfs methods
2111
2427
            medium._remember_remote_is_before((1, 13))
2112
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2428
            return self._vfs_initialize(a_bzrdir, name=name,
 
2429
                    append_revisions_only=append_revisions_only)
2113
2430
        if response[0] != 'ok':
2114
2431
            raise errors.UnexpectedSmartServerResponse(response)
2115
2432
        # Turn the response into a RemoteRepository object.
2116
2433
        format = RemoteBranchFormat(network_name=response[1])
2117
2434
        repo_format = response_tuple_to_repo_format(response[3:])
2118
 
        if response[2] == '':
2119
 
            repo_bzrdir = a_bzrdir
 
2435
        repo_path = response[2]
 
2436
        if repository is not None:
 
2437
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
 
2438
            url_diff = urlutils.relative_url(repository.user_url,
 
2439
                    remote_repo_url)
 
2440
            if url_diff != '.':
 
2441
                raise AssertionError(
 
2442
                    'repository.user_url %r does not match URL from server '
 
2443
                    'response (%r + %r)'
 
2444
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
 
2445
            remote_repo = repository
2120
2446
        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)
 
2447
            if repo_path == '':
 
2448
                repo_bzrdir = a_bzrdir
 
2449
            else:
 
2450
                repo_bzrdir = RemoteBzrDir(
 
2451
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
2452
                    a_bzrdir._client)
 
2453
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2125
2454
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2126
2455
            format=format, setup_stacking=False, name=name)
 
2456
        if append_revisions_only:
 
2457
            remote_branch.set_append_revisions_only(append_revisions_only)
2127
2458
        # XXX: We know this is a new branch, so it must have revno 0, revid
2128
2459
        # NULL_REVISION. Creating the branch locked would make this be unable
2129
2460
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2148
2479
        self._ensure_real()
2149
2480
        return self._custom_format.supports_set_append_revisions_only()
2150
2481
 
 
2482
    def _use_default_local_heads_to_fetch(self):
 
2483
        # If the branch format is a metadir format *and* its heads_to_fetch
 
2484
        # implementation is not overridden vs the base class, we can use the
 
2485
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
2486
        # usually cheaper in terms of net round trips, as the last-revision and
 
2487
        # tags info fetched is cached and would be fetched anyway.
 
2488
        self._ensure_real()
 
2489
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
2490
            branch_class = self._custom_format._branch_class()
 
2491
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
2492
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
2493
                return True
 
2494
        return False
2151
2495
 
2152
2496
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2153
2497
    """Branch stored on a server accessed by HPSS RPC.
2311
2655
                self.bzrdir, self._client)
2312
2656
        return self._control_files
2313
2657
 
2314
 
    def _get_checkout_format(self):
 
2658
    def _get_checkout_format(self, lightweight=False):
2315
2659
        self._ensure_real()
2316
 
        return self._real_branch._get_checkout_format()
 
2660
        if lightweight:
 
2661
            format = RemoteBzrDirFormat()
 
2662
            self.bzrdir._format._supply_sub_formats_to(format)
 
2663
            format.workingtree_format = self._real_branch._get_checkout_format(
 
2664
                lightweight=lightweight).workingtree_format
 
2665
            return format
 
2666
        else:
 
2667
            return self._real_branch._get_checkout_format(lightweight=False)
2317
2668
 
2318
2669
    def get_physical_lock_status(self):
2319
2670
        """See Branch.get_physical_lock_status()."""
2352
2703
            self._is_stacked = False
2353
2704
        else:
2354
2705
            self._is_stacked = True
2355
 
        
 
2706
 
2356
2707
    def _vfs_get_tags_bytes(self):
2357
2708
        self._ensure_real()
2358
2709
        return self._real_branch._get_tags_bytes()
2359
2710
 
 
2711
    @needs_read_lock
2360
2712
    def _get_tags_bytes(self):
 
2713
        if self._tags_bytes is None:
 
2714
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
2715
        return self._tags_bytes
 
2716
 
 
2717
    def _get_tags_bytes_via_hpss(self):
2361
2718
        medium = self._client._medium
2362
2719
        if medium._is_remote_before((1, 13)):
2363
2720
            return self._vfs_get_tags_bytes()
2373
2730
        return self._real_branch._set_tags_bytes(bytes)
2374
2731
 
2375
2732
    def _set_tags_bytes(self, bytes):
 
2733
        if self.is_locked():
 
2734
            self._tags_bytes = bytes
2376
2735
        medium = self._client._medium
2377
2736
        if medium._is_remote_before((1, 18)):
2378
2737
            self._vfs_set_tags_bytes(bytes)
2387
2746
            self._vfs_set_tags_bytes(bytes)
2388
2747
 
2389
2748
    def lock_read(self):
 
2749
        """Lock the branch for read operations.
 
2750
 
 
2751
        :return: A bzrlib.lock.LogicalLockResult.
 
2752
        """
2390
2753
        self.repository.lock_read()
2391
2754
        if not self._lock_mode:
2392
2755
            self._note_lock('r')
2396
2759
                self._real_branch.lock_read()
2397
2760
        else:
2398
2761
            self._lock_count += 1
 
2762
        return lock.LogicalLockResult(self.unlock)
2399
2763
 
2400
2764
    def _remote_lock_write(self, token):
2401
2765
        if token is None:
2402
2766
            branch_token = repo_token = ''
2403
2767
        else:
2404
2768
            branch_token = token
2405
 
            repo_token = self.repository.lock_write()
 
2769
            repo_token = self.repository.lock_write().repository_token
2406
2770
            self.repository.unlock()
2407
2771
        err_context = {'token': token}
2408
 
        response = self._call(
2409
 
            'Branch.lock_write', self._remote_path(), branch_token,
2410
 
            repo_token or '', **err_context)
 
2772
        try:
 
2773
            response = self._call(
 
2774
                'Branch.lock_write', self._remote_path(), branch_token,
 
2775
                repo_token or '', **err_context)
 
2776
        except errors.LockContention, e:
 
2777
            # The LockContention from the server doesn't have any
 
2778
            # information about the lock_url. We re-raise LockContention
 
2779
            # with valid lock_url.
 
2780
            raise errors.LockContention('(remote lock)',
 
2781
                self.repository.base.split('.bzr/')[0])
2411
2782
        if response[0] != 'ok':
2412
2783
            raise errors.UnexpectedSmartServerResponse(response)
2413
2784
        ok, branch_token, repo_token = response
2434
2805
            self._lock_mode = 'w'
2435
2806
            self._lock_count = 1
2436
2807
        elif self._lock_mode == 'r':
2437
 
            raise errors.ReadOnlyTransaction
 
2808
            raise errors.ReadOnlyError(self)
2438
2809
        else:
2439
2810
            if token is not None:
2440
2811
                # A token was given to lock_write, and we're relocking, so
2445
2816
            self._lock_count += 1
2446
2817
            # Re-lock the repository too.
2447
2818
            self.repository.lock_write(self._repo_lock_token)
2448
 
        return self._lock_token or None
 
2819
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
2449
2820
 
2450
2821
    def _unlock(self, branch_token, repo_token):
2451
2822
        err_context = {'token': str((branch_token, repo_token))}
2520
2891
            missing_parent = parent_map[missing_parent]
2521
2892
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2522
2893
 
2523
 
    def _last_revision_info(self):
 
2894
    def _read_last_revision_info(self):
2524
2895
        response = self._call('Branch.last_revision_info', self._remote_path())
2525
2896
        if response[0] != 'ok':
2526
2897
            raise SmartProtocolError('unexpected response code %s' % (response,))
2589
2960
            raise errors.UnexpectedSmartServerResponse(response)
2590
2961
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2591
2962
 
 
2963
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2592
2964
    @needs_write_lock
2593
2965
    def set_revision_history(self, rev_history):
 
2966
        """See Branch.set_revision_history."""
 
2967
        self._set_revision_history(rev_history)
 
2968
 
 
2969
    @needs_write_lock
 
2970
    def _set_revision_history(self, rev_history):
2594
2971
        # Send just the tip revision of the history; the server will generate
2595
2972
        # the full history from that.  If the revision doesn't exist in this
2596
2973
        # branch, NoSuchRevision will be raised.
2654
3031
            _override_hook_target=self, **kwargs)
2655
3032
 
2656
3033
    @needs_read_lock
2657
 
    def push(self, target, overwrite=False, stop_revision=None):
 
3034
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2658
3035
        self._ensure_real()
2659
3036
        return self._real_branch.push(
2660
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
3037
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2661
3038
            _override_hook_source_branch=self)
2662
3039
 
2663
3040
    def is_locked(self):
2673
3050
        # XXX: These should be returned by the set_last_revision_info verb
2674
3051
        old_revno, old_revid = self.last_revision_info()
2675
3052
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2676
 
        revision_id = ensure_null(revision_id)
 
3053
        if not revision_id or not isinstance(revision_id, basestring):
 
3054
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2677
3055
        try:
2678
3056
            response = self._call('Branch.set_last_revision_info',
2679
3057
                self._remote_path(), self._lock_token, self._repo_lock_token,
2708
3086
            except errors.UnknownSmartMethod:
2709
3087
                medium._remember_remote_is_before((1, 6))
2710
3088
        self._clear_cached_state_of_remote_branch_only()
2711
 
        self.set_revision_history(self._lefthand_history(revision_id,
 
3089
        self._set_revision_history(self._lefthand_history(revision_id,
2712
3090
            last_rev=last_rev,other_branch=other_branch))
2713
3091
 
2714
3092
    def set_push_location(self, location):
2715
3093
        self._ensure_real()
2716
3094
        return self._real_branch.set_push_location(location)
2717
3095
 
 
3096
    def heads_to_fetch(self):
 
3097
        if self._format._use_default_local_heads_to_fetch():
 
3098
            # We recognise this format, and its heads-to-fetch implementation
 
3099
            # is the default one (tip + tags).  In this case it's cheaper to
 
3100
            # just use the default implementation rather than a special RPC as
 
3101
            # the tip and tags data is cached.
 
3102
            return branch.Branch.heads_to_fetch(self)
 
3103
        medium = self._client._medium
 
3104
        if medium._is_remote_before((2, 4)):
 
3105
            return self._vfs_heads_to_fetch()
 
3106
        try:
 
3107
            return self._rpc_heads_to_fetch()
 
3108
        except errors.UnknownSmartMethod:
 
3109
            medium._remember_remote_is_before((2, 4))
 
3110
            return self._vfs_heads_to_fetch()
 
3111
 
 
3112
    def _rpc_heads_to_fetch(self):
 
3113
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3114
        if len(response) != 2:
 
3115
            raise errors.UnexpectedSmartServerResponse(response)
 
3116
        must_fetch, if_present_fetch = response
 
3117
        return set(must_fetch), set(if_present_fetch)
 
3118
 
 
3119
    def _vfs_heads_to_fetch(self):
 
3120
        self._ensure_real()
 
3121
        return self._real_branch.heads_to_fetch()
 
3122
 
2718
3123
 
2719
3124
class RemoteConfig(object):
2720
3125
    """A Config that reads and writes from smart verbs.
2734
3139
        """
2735
3140
        try:
2736
3141
            configobj = self._get_configobj()
 
3142
            section_obj = None
2737
3143
            if section is None:
2738
3144
                section_obj = configobj
2739
3145
            else:
2740
3146
                try:
2741
3147
                    section_obj = configobj[section]
2742
3148
                except KeyError:
2743
 
                    return default
2744
 
            return section_obj.get(name, default)
 
3149
                    pass
 
3150
            if section_obj is None:
 
3151
                value = default
 
3152
            else:
 
3153
                value = section_obj.get(name, default)
2745
3154
        except errors.UnknownSmartMethod:
2746
 
            return self._vfs_get_option(name, section, default)
 
3155
            value = self._vfs_get_option(name, section, default)
 
3156
        for hook in config.OldConfigHooks['get']:
 
3157
            hook(self, name, value)
 
3158
        return value
2747
3159
 
2748
3160
    def _response_to_configobj(self, response):
2749
3161
        if len(response[0]) and response[0][0] != 'ok':
2750
3162
            raise errors.UnexpectedSmartServerResponse(response)
2751
3163
        lines = response[1].read_body_bytes().splitlines()
2752
 
        return config.ConfigObj(lines, encoding='utf-8')
 
3164
        conf = config.ConfigObj(lines, encoding='utf-8')
 
3165
        for hook in config.OldConfigHooks['load']:
 
3166
            hook(self)
 
3167
        return conf
2753
3168
 
2754
3169
 
2755
3170
class RemoteBranchConfig(RemoteConfig):
2774
3189
        medium = self._branch._client._medium
2775
3190
        if medium._is_remote_before((1, 14)):
2776
3191
            return self._vfs_set_option(value, name, section)
 
3192
        if isinstance(value, dict):
 
3193
            if medium._is_remote_before((2, 2)):
 
3194
                return self._vfs_set_option(value, name, section)
 
3195
            return self._set_config_option_dict(value, name, section)
 
3196
        else:
 
3197
            return self._set_config_option(value, name, section)
 
3198
 
 
3199
    def _set_config_option(self, value, name, section):
2777
3200
        try:
2778
3201
            path = self._branch._remote_path()
2779
3202
            response = self._branch._client.call('Branch.set_config_option',
2780
3203
                path, self._branch._lock_token, self._branch._repo_lock_token,
2781
3204
                value.encode('utf8'), name, section or '')
2782
3205
        except errors.UnknownSmartMethod:
 
3206
            medium = self._branch._client._medium
2783
3207
            medium._remember_remote_is_before((1, 14))
2784
3208
            return self._vfs_set_option(value, name, section)
2785
3209
        if response != ():
2786
3210
            raise errors.UnexpectedSmartServerResponse(response)
2787
3211
 
 
3212
    def _serialize_option_dict(self, option_dict):
 
3213
        utf8_dict = {}
 
3214
        for key, value in option_dict.items():
 
3215
            if isinstance(key, unicode):
 
3216
                key = key.encode('utf8')
 
3217
            if isinstance(value, unicode):
 
3218
                value = value.encode('utf8')
 
3219
            utf8_dict[key] = value
 
3220
        return bencode.bencode(utf8_dict)
 
3221
 
 
3222
    def _set_config_option_dict(self, value, name, section):
 
3223
        try:
 
3224
            path = self._branch._remote_path()
 
3225
            serialised_dict = self._serialize_option_dict(value)
 
3226
            response = self._branch._client.call(
 
3227
                'Branch.set_config_option_dict',
 
3228
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
3229
                serialised_dict, name, section or '')
 
3230
        except errors.UnknownSmartMethod:
 
3231
            medium = self._branch._client._medium
 
3232
            medium._remember_remote_is_before((2, 2))
 
3233
            return self._vfs_set_option(value, name, section)
 
3234
        if response != ():
 
3235
            raise errors.UnexpectedSmartServerResponse(response)
 
3236
 
2788
3237
    def _real_object(self):
2789
3238
        self._branch._ensure_real()
2790
3239
        return self._branch._real_branch
2873
3322
                    'Missing key %r in context %r', key_err.args[0], context)
2874
3323
                raise err
2875
3324
 
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':
 
3325
    if err.error_verb == 'NoSuchRevision':
2880
3326
        raise NoSuchRevision(find('branch'), err.error_args[0])
2881
3327
    elif err.error_verb == 'nosuchrevision':
2882
3328
        raise NoSuchRevision(find('repository'), err.error_args[0])
2889
3335
            detail=extra)
2890
3336
    elif err.error_verb == 'norepository':
2891
3337
        raise errors.NoRepositoryPresent(find('bzrdir'))
2892
 
    elif err.error_verb == 'LockContention':
2893
 
        raise errors.LockContention('(remote lock)')
2894
3338
    elif err.error_verb == 'UnlockableTransport':
2895
3339
        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
3340
    elif err.error_verb == 'TokenMismatch':
2899
3341
        raise errors.TokenMismatch(find('token'), '(remote token)')
2900
3342
    elif err.error_verb == 'Diverged':
2901
3343
        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
3344
    elif err.error_verb == 'NotStacked':
2909
3345
        raise errors.NotStacked(branch=find('branch'))
2910
3346
    elif err.error_verb == 'PermissionDenied':
2920
3356
    elif err.error_verb == 'NoSuchFile':
2921
3357
        path = get_path()
2922
3358
        raise errors.NoSuchFile(path)
 
3359
    _translate_error_without_context(err)
 
3360
 
 
3361
 
 
3362
def _translate_error_without_context(err):
 
3363
    """Translate any ErrorFromSmartServer values that don't require context"""
 
3364
    if err.error_verb == 'IncompatibleRepositories':
 
3365
        raise errors.IncompatibleRepositories(err.error_args[0],
 
3366
            err.error_args[1], err.error_args[2])
 
3367
    elif err.error_verb == 'LockContention':
 
3368
        raise errors.LockContention('(remote lock)')
 
3369
    elif err.error_verb == 'LockFailed':
 
3370
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
 
3371
    elif err.error_verb == 'TipChangeRejected':
 
3372
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
 
3373
    elif err.error_verb == 'UnstackableBranchFormat':
 
3374
        raise errors.UnstackableBranchFormat(*err.error_args)
 
3375
    elif err.error_verb == 'UnstackableRepositoryFormat':
 
3376
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2923
3377
    elif err.error_verb == 'FileExists':
2924
3378
        raise errors.FileExists(err.error_args[0])
2925
3379
    elif err.error_verb == 'DirectoryNotEmpty':
2944
3398
            raise UnicodeEncodeError(encoding, val, start, end, reason)
2945
3399
    elif err.error_verb == 'ReadOnlyError':
2946
3400
        raise errors.TransportNotPossible('readonly transport')
 
3401
    elif err.error_verb == 'MemoryError':
 
3402
        raise errors.BzrError("remote server out of memory\n"
 
3403
            "Retry non-remotely, or contact the server admin for details.")
2947
3404
    raise errors.UnknownErrorFromSmartServer(err)