/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-21 17:07:19 UTC
  • mto: This revision was merged to the branch mainline in revision 6318.
  • Revision ID: jelmer@samba.org-20111121170719-jm3gv00ubzbopttm
Fix NoSuchFile error message, method name of Repository.iter_file_bytes.

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
 
44
from bzrlib.inventory import Inventory
43
45
from bzrlib.lockable_files import LockableFiles
44
46
from bzrlib.smart import client, vfs, repository as smart_repo
45
 
from bzrlib.revision import ensure_null, NULL_REVISION
 
47
from bzrlib.smart.client import _SmartClient
 
48
from bzrlib.revision import NULL_REVISION
 
49
from bzrlib.revisiontree import InventoryRevisionTree
 
50
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
46
51
from bzrlib.trace import mutter, note, warning
47
52
 
48
53
 
 
54
_DEFAULT_SEARCH_DEPTH = 100
 
55
 
 
56
 
49
57
class _RpcHelper(object):
50
58
    """Mixin class that helps with issuing RPCs."""
51
59
 
86
94
    return format
87
95
 
88
96
 
89
 
# Note: RemoteBzrDirFormat is in bzrdir.py
90
 
 
91
 
class RemoteBzrDir(BzrDir, _RpcHelper):
 
97
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
 
98
# does not have to be imported unless a remote format is involved.
 
99
 
 
100
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
 
101
    """Format representing bzrdirs accessed via a smart server"""
 
102
 
 
103
    supports_workingtrees = False
 
104
 
 
105
    def __init__(self):
 
106
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
 
107
        # XXX: It's a bit ugly that the network name is here, because we'd
 
108
        # like to believe that format objects are stateless or at least
 
109
        # immutable,  However, we do at least avoid mutating the name after
 
110
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
 
111
        self._network_name = None
 
112
 
 
113
    def __repr__(self):
 
114
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
115
            self._network_name)
 
116
 
 
117
    def get_format_description(self):
 
118
        if self._network_name:
 
119
            real_format = controldir.network_format_registry.get(self._network_name)
 
120
            return 'Remote: ' + real_format.get_format_description()
 
121
        return 'bzr remote bzrdir'
 
122
 
 
123
    def get_format_string(self):
 
124
        raise NotImplementedError(self.get_format_string)
 
125
 
 
126
    def network_name(self):
 
127
        if self._network_name:
 
128
            return self._network_name
 
129
        else:
 
130
            raise AssertionError("No network name set.")
 
131
 
 
132
    def initialize_on_transport(self, transport):
 
133
        try:
 
134
            # hand off the request to the smart server
 
135
            client_medium = transport.get_smart_medium()
 
136
        except errors.NoSmartMedium:
 
137
            # TODO: lookup the local format from a server hint.
 
138
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
139
            return local_dir_format.initialize_on_transport(transport)
 
140
        client = _SmartClient(client_medium)
 
141
        path = client.remote_path_from_transport(transport)
 
142
        try:
 
143
            response = client.call('BzrDirFormat.initialize', path)
 
144
        except errors.ErrorFromSmartServer, err:
 
145
            _translate_error(err, path=path)
 
146
        if response[0] != 'ok':
 
147
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
 
148
        format = RemoteBzrDirFormat()
 
149
        self._supply_sub_formats_to(format)
 
150
        return RemoteBzrDir(transport, format)
 
151
 
 
152
    def parse_NoneTrueFalse(self, arg):
 
153
        if not arg:
 
154
            return None
 
155
        if arg == 'False':
 
156
            return False
 
157
        if arg == 'True':
 
158
            return True
 
159
        raise AssertionError("invalid arg %r" % arg)
 
160
 
 
161
    def _serialize_NoneTrueFalse(self, arg):
 
162
        if arg is False:
 
163
            return 'False'
 
164
        if arg:
 
165
            return 'True'
 
166
        return ''
 
167
 
 
168
    def _serialize_NoneString(self, arg):
 
169
        return arg or ''
 
170
 
 
171
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
172
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
173
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
174
        shared_repo=False):
 
175
        try:
 
176
            # hand off the request to the smart server
 
177
            client_medium = transport.get_smart_medium()
 
178
        except errors.NoSmartMedium:
 
179
            do_vfs = True
 
180
        else:
 
181
            # Decline to open it if the server doesn't support our required
 
182
            # version (3) so that the VFS-based transport will do it.
 
183
            if client_medium.should_probe():
 
184
                try:
 
185
                    server_version = client_medium.protocol_version()
 
186
                    if server_version != '2':
 
187
                        do_vfs = True
 
188
                    else:
 
189
                        do_vfs = False
 
190
                except errors.SmartProtocolError:
 
191
                    # Apparently there's no usable smart server there, even though
 
192
                    # the medium supports the smart protocol.
 
193
                    do_vfs = True
 
194
            else:
 
195
                do_vfs = False
 
196
        if not do_vfs:
 
197
            client = _SmartClient(client_medium)
 
198
            path = client.remote_path_from_transport(transport)
 
199
            if client_medium._is_remote_before((1, 16)):
 
200
                do_vfs = True
 
201
        if do_vfs:
 
202
            # TODO: lookup the local format from a server hint.
 
203
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
204
            self._supply_sub_formats_to(local_dir_format)
 
205
            return local_dir_format.initialize_on_transport_ex(transport,
 
206
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
207
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
208
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
209
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
210
                vfs_only=True)
 
211
        return self._initialize_on_transport_ex_rpc(client, path, transport,
 
212
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
213
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
 
214
 
 
215
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
 
216
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
217
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
 
218
        args = []
 
219
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
 
220
        args.append(self._serialize_NoneTrueFalse(create_prefix))
 
221
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
 
222
        args.append(self._serialize_NoneString(stacked_on))
 
223
        # stack_on_pwd is often/usually our transport
 
224
        if stack_on_pwd:
 
225
            try:
 
226
                stack_on_pwd = transport.relpath(stack_on_pwd)
 
227
                if not stack_on_pwd:
 
228
                    stack_on_pwd = '.'
 
229
            except errors.PathNotChild:
 
230
                pass
 
231
        args.append(self._serialize_NoneString(stack_on_pwd))
 
232
        args.append(self._serialize_NoneString(repo_format_name))
 
233
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
 
234
        args.append(self._serialize_NoneTrueFalse(shared_repo))
 
235
        request_network_name = self._network_name or \
 
236
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
 
237
        try:
 
238
            response = client.call('BzrDirFormat.initialize_ex_1.16',
 
239
                request_network_name, path, *args)
 
240
        except errors.UnknownSmartMethod:
 
241
            client._medium._remember_remote_is_before((1,16))
 
242
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
243
            self._supply_sub_formats_to(local_dir_format)
 
244
            return local_dir_format.initialize_on_transport_ex(transport,
 
245
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
246
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
247
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
248
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
249
                vfs_only=True)
 
250
        except errors.ErrorFromSmartServer, err:
 
251
            _translate_error(err, path=path)
 
252
        repo_path = response[0]
 
253
        bzrdir_name = response[6]
 
254
        require_stacking = response[7]
 
255
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
 
256
        format = RemoteBzrDirFormat()
 
257
        format._network_name = bzrdir_name
 
258
        self._supply_sub_formats_to(format)
 
259
        bzrdir = RemoteBzrDir(transport, format, _client=client)
 
260
        if repo_path:
 
261
            repo_format = response_tuple_to_repo_format(response[1:])
 
262
            if repo_path == '.':
 
263
                repo_path = ''
 
264
            if repo_path:
 
265
                repo_bzrdir_format = RemoteBzrDirFormat()
 
266
                repo_bzrdir_format._network_name = response[5]
 
267
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
 
268
                    repo_bzrdir_format)
 
269
            else:
 
270
                repo_bzr = bzrdir
 
271
            final_stack = response[8] or None
 
272
            final_stack_pwd = response[9] or None
 
273
            if final_stack_pwd:
 
274
                final_stack_pwd = urlutils.join(
 
275
                    transport.base, final_stack_pwd)
 
276
            remote_repo = RemoteRepository(repo_bzr, repo_format)
 
277
            if len(response) > 10:
 
278
                # Updated server verb that locks remotely.
 
279
                repo_lock_token = response[10] or None
 
280
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
 
281
                if repo_lock_token:
 
282
                    remote_repo.dont_leave_lock_in_place()
 
283
            else:
 
284
                remote_repo.lock_write()
 
285
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
 
286
                final_stack_pwd, require_stacking)
 
287
            policy.acquire_repository()
 
288
        else:
 
289
            remote_repo = None
 
290
            policy = None
 
291
        bzrdir._format.set_branch_format(self.get_branch_format())
 
292
        if require_stacking:
 
293
            # The repo has already been created, but we need to make sure that
 
294
            # we'll make a stackable branch.
 
295
            bzrdir._format.require_stacking(_skip_repo=True)
 
296
        return remote_repo, bzrdir, require_stacking, policy
 
297
 
 
298
    def _open(self, transport):
 
299
        return RemoteBzrDir(transport, self)
 
300
 
 
301
    def __eq__(self, other):
 
302
        if not isinstance(other, RemoteBzrDirFormat):
 
303
            return False
 
304
        return self.get_format_description() == other.get_format_description()
 
305
 
 
306
    def __return_repository_format(self):
 
307
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
 
308
        # repository format has been asked for, tell the RemoteRepositoryFormat
 
309
        # that it should use that for init() etc.
 
310
        result = RemoteRepositoryFormat()
 
311
        custom_format = getattr(self, '_repository_format', None)
 
312
        if custom_format:
 
313
            if isinstance(custom_format, RemoteRepositoryFormat):
 
314
                return custom_format
 
315
            else:
 
316
                # We will use the custom format to create repositories over the
 
317
                # wire; expose its details like rich_root_data for code to
 
318
                # query
 
319
                result._custom_format = custom_format
 
320
        return result
 
321
 
 
322
    def get_branch_format(self):
 
323
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
 
324
        if not isinstance(result, RemoteBranchFormat):
 
325
            new_result = RemoteBranchFormat()
 
326
            new_result._custom_format = result
 
327
            # cache the result
 
328
            self.set_branch_format(new_result)
 
329
            result = new_result
 
330
        return result
 
331
 
 
332
    repository_format = property(__return_repository_format,
 
333
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
 
334
 
 
335
 
 
336
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
92
337
    """Control directory on a remote server, accessed via bzr:// or similar."""
93
338
 
94
339
    def __init__(self, transport, format, _client=None, _force_probe=False):
97
342
        :param _client: Private parameter for testing. Disables probing and the
98
343
            use of a real bzrdir.
99
344
        """
100
 
        BzrDir.__init__(self, transport, format)
 
345
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
101
346
        # this object holds a delegated bzrdir that uses file-level operations
102
347
        # to talk to the other side
103
348
        self._real_bzrdir = None
163
408
                import traceback
164
409
                warning('VFS BzrDir access triggered\n%s',
165
410
                    ''.join(traceback.format_stack()))
166
 
            self._real_bzrdir = BzrDir.open_from_transport(
 
411
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
167
412
                self.root_transport, _server_formats=False)
168
413
            self._format._network_name = \
169
414
                self._real_bzrdir._format.network_name()
175
420
        # Prevent aliasing problems in the next_open_branch_result cache.
176
421
        # See create_branch for rationale.
177
422
        self._next_open_branch_result = None
178
 
        return BzrDir.break_lock(self)
 
423
        return _mod_bzrdir.BzrDir.break_lock(self)
179
424
 
180
425
    def _vfs_cloning_metadir(self, require_stacking=False):
181
426
        self._ensure_real()
212
457
        if len(branch_info) != 2:
213
458
            raise errors.UnexpectedSmartServerResponse(response)
214
459
        branch_ref, branch_name = branch_info
215
 
        format = bzrdir.network_format_registry.get(control_name)
 
460
        format = controldir.network_format_registry.get(control_name)
216
461
        if repo_name:
217
 
            format.repository_format = repository.network_format_registry.get(
 
462
            format.repository_format = _mod_repository.network_format_registry.get(
218
463
                repo_name)
219
464
        if branch_ref == 'ref':
220
465
            # XXX: we need possible_transports here to avoid reopening the
221
466
            # connection to the referenced location
222
 
            ref_bzrdir = BzrDir.open(branch_name)
 
467
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
223
468
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
224
469
            format.set_branch_format(branch_format)
225
470
        elif branch_ref == 'branch':
241
486
 
242
487
    def destroy_repository(self):
243
488
        """See BzrDir.destroy_repository"""
244
 
        self._ensure_real()
245
 
        self._real_bzrdir.destroy_repository()
 
489
        path = self._path_for_remote_call(self._client)
 
490
        try:
 
491
            response = self._call('BzrDir.destroy_repository', path)
 
492
        except errors.UnknownSmartMethod:
 
493
            self._ensure_real()
 
494
            self._real_bzrdir.destroy_repository()
 
495
            return
 
496
        if response[0] != 'ok':
 
497
            raise SmartProtocolError('unexpected response code %s' % (response,))
246
498
 
247
 
    def create_branch(self, name=None):
 
499
    def create_branch(self, name=None, repository=None,
 
500
                      append_revisions_only=None):
248
501
        # as per meta1 formats - just delegate to the format object which may
249
502
        # be parameterised.
250
503
        real_branch = self._format.get_branch_format().initialize(self,
251
 
            name=name)
 
504
            name=name, repository=repository,
 
505
            append_revisions_only=append_revisions_only)
252
506
        if not isinstance(real_branch, RemoteBranch):
253
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
254
 
                                  name=name)
 
507
            if not isinstance(repository, RemoteRepository):
 
508
                raise AssertionError(
 
509
                    'need a RemoteRepository to use with RemoteBranch, got %r'
 
510
                    % (repository,))
 
511
            result = RemoteBranch(self, repository, real_branch, name=name)
255
512
        else:
256
513
            result = real_branch
257
514
        # BzrDir.clone_on_transport() uses the result of create_branch but does
269
526
        self._real_bzrdir.destroy_branch(name=name)
270
527
        self._next_open_branch_result = None
271
528
 
272
 
    def create_workingtree(self, revision_id=None, from_branch=None):
 
529
    def create_workingtree(self, revision_id=None, from_branch=None,
 
530
        accelerator_tree=None, hardlink=False):
273
531
        raise errors.NotLocalUrl(self.transport.base)
274
532
 
275
 
    def find_branch_format(self):
 
533
    def find_branch_format(self, name=None):
276
534
        """Find the branch 'format' for this bzrdir.
277
535
 
278
536
        This might be a synthetic object for e.g. RemoteBranch and SVN.
279
537
        """
280
 
        b = self.open_branch()
 
538
        b = self.open_branch(name=name)
281
539
        return b._format
282
540
 
283
 
    def get_branch_reference(self):
 
541
    def get_branch_reference(self, name=None):
284
542
        """See BzrDir.get_branch_reference()."""
 
543
        if name is not None:
 
544
            # XXX JRV20100304: Support opening colocated branches
 
545
            raise errors.NoColocatedBranchSupport(self)
285
546
        response = self._get_branch_reference()
286
547
        if response[0] == 'ref':
287
548
            return response[1]
318
579
            raise errors.UnexpectedSmartServerResponse(response)
319
580
        return response
320
581
 
321
 
    def _get_tree_branch(self):
 
582
    def _get_tree_branch(self, name=None):
322
583
        """See BzrDir._get_tree_branch()."""
323
 
        return None, self.open_branch()
 
584
        return None, self.open_branch(name=name)
324
585
 
325
586
    def open_branch(self, name=None, unsupported=False,
326
587
                    ignore_fallbacks=False):
411
672
 
412
673
    def has_workingtree(self):
413
674
        if self._has_working_tree is None:
414
 
            self._ensure_real()
415
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
 
675
            path = self._path_for_remote_call(self._client)
 
676
            try:
 
677
                response = self._call('BzrDir.has_workingtree', path)
 
678
            except errors.UnknownSmartMethod:
 
679
                self._ensure_real()
 
680
                self._has_working_tree = self._real_bzrdir.has_workingtree()
 
681
            else:
 
682
                if response[0] not in ('yes', 'no'):
 
683
                    raise SmartProtocolError('unexpected response code %s' % (response,))
 
684
                self._has_working_tree = (response[0] == 'yes')
416
685
        return self._has_working_tree
417
686
 
418
687
    def open_workingtree(self, recommend_upgrade=True):
423
692
 
424
693
    def _path_for_remote_call(self, client):
425
694
        """Return the path to be used for this bzrdir in a remote call."""
426
 
        return client.remote_path_from_transport(self.root_transport)
 
695
        return urlutils.split_segment_parameters_raw(
 
696
            client.remote_path_from_transport(self.root_transport))[0]
427
697
 
428
698
    def get_branch_transport(self, branch_format, name=None):
429
699
        self._ensure_real()
441
711
        """Upgrading of remote bzrdirs is not supported yet."""
442
712
        return False
443
713
 
444
 
    def needs_format_conversion(self, format=None):
 
714
    def needs_format_conversion(self, format):
445
715
        """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
716
        return False
450
717
 
451
 
    def clone(self, url, revision_id=None, force_new_repo=False,
452
 
              preserve_stacking=False):
453
 
        self._ensure_real()
454
 
        return self._real_bzrdir.clone(url, revision_id=revision_id,
455
 
            force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
456
 
 
457
718
    def _get_config(self):
458
719
        return RemoteBzrDirConfig(self)
459
720
 
460
721
 
461
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
722
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
462
723
    """Format for repositories accessed over a _SmartClient.
463
724
 
464
725
    Instances of this repository are represented by RemoteRepository
479
740
    """
480
741
 
481
742
    _matchingbzrdir = RemoteBzrDirFormat()
 
743
    supports_full_versioned_files = True
 
744
    supports_leaving_lock = True
482
745
 
483
746
    def __init__(self):
484
 
        repository.RepositoryFormat.__init__(self)
 
747
        _mod_repository.RepositoryFormat.__init__(self)
485
748
        self._custom_format = None
486
749
        self._network_name = None
487
750
        self._creating_bzrdir = None
 
751
        self._revision_graph_can_have_wrong_parents = None
488
752
        self._supports_chks = None
489
753
        self._supports_external_lookups = None
490
754
        self._supports_tree_reference = None
 
755
        self._supports_funky_characters = None
 
756
        self._supports_nesting_repositories = None
491
757
        self._rich_root_data = None
492
758
 
493
759
    def __repr__(self):
522
788
        return self._supports_external_lookups
523
789
 
524
790
    @property
 
791
    def supports_funky_characters(self):
 
792
        if self._supports_funky_characters is None:
 
793
            self._ensure_real()
 
794
            self._supports_funky_characters = \
 
795
                self._custom_format.supports_funky_characters
 
796
        return self._supports_funky_characters
 
797
 
 
798
    @property
 
799
    def supports_nesting_repositories(self):
 
800
        if self._supports_nesting_repositories is None:
 
801
            self._ensure_real()
 
802
            self._supports_nesting_repositories = \
 
803
                self._custom_format.supports_nesting_repositories
 
804
        return self._supports_nesting_repositories
 
805
 
 
806
    @property
525
807
    def supports_tree_reference(self):
526
808
        if self._supports_tree_reference is None:
527
809
            self._ensure_real()
529
811
                self._custom_format.supports_tree_reference
530
812
        return self._supports_tree_reference
531
813
 
 
814
    @property
 
815
    def revision_graph_can_have_wrong_parents(self):
 
816
        if self._revision_graph_can_have_wrong_parents is None:
 
817
            self._ensure_real()
 
818
            self._revision_graph_can_have_wrong_parents = \
 
819
                self._custom_format.revision_graph_can_have_wrong_parents
 
820
        return self._revision_graph_can_have_wrong_parents
 
821
 
532
822
    def _vfs_initialize(self, a_bzrdir, shared):
533
823
        """Helper for common code in initialize."""
534
824
        if self._custom_format:
569
859
            network_name = self._network_name
570
860
        else:
571
861
            # Select the current bzrlib default and ask for that.
572
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
862
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
573
863
            reference_format = reference_bzrdir_format.repository_format
574
864
            network_name = reference_format.network_name()
575
865
        # 2) try direct creation via RPC
601
891
 
602
892
    def _ensure_real(self):
603
893
        if self._custom_format is None:
604
 
            self._custom_format = repository.network_format_registry.get(
 
894
            self._custom_format = _mod_repository.network_format_registry.get(
605
895
                self._network_name)
606
896
 
607
897
    @property
644
934
 
645
935
 
646
936
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
647
 
    bzrdir.ControlComponent):
 
937
    controldir.ControlComponent):
648
938
    """Repository accessed over rpc.
649
939
 
650
940
    For the moment most operations are performed using local transport-backed
703
993
        # transport, but I'm not sure it's worth making this method
704
994
        # optional -- mbp 2010-04-21
705
995
        return self.bzrdir.get_repository_transport(None)
706
 
        
 
996
 
707
997
    def __str__(self):
708
998
        return "%s(%s)" % (self.__class__.__name__, self.base)
709
999
 
817
1107
    def find_text_key_references(self):
818
1108
        """Find the text key references within the repository.
819
1109
 
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
1110
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
824
1111
            to whether they were referred to by the inventory of the
825
1112
            revision_id that they contain. The inventory texts from all present
843
1130
        """Private method for using with old (< 1.2) servers to fallback."""
844
1131
        if revision_id is None:
845
1132
            revision_id = ''
846
 
        elif revision.is_null(revision_id):
 
1133
        elif _mod_revision.is_null(revision_id):
847
1134
            return {}
848
1135
 
849
1136
        path = self.bzrdir._path_for_remote_call(self._client)
873
1160
        return RemoteStreamSource(self, to_format)
874
1161
 
875
1162
    @needs_read_lock
 
1163
    def get_file_graph(self):
 
1164
        return graph.Graph(self.texts)
 
1165
 
 
1166
    @needs_read_lock
876
1167
    def has_revision(self, revision_id):
877
1168
        """True if this repository has a copy of the revision."""
878
1169
        # Copy of bzrlib.repository.Repository.has_revision
895
1186
    def _has_same_fallbacks(self, other_repo):
896
1187
        """Returns true if the repositories have the same fallbacks."""
897
1188
        # XXX: copied from Repository; it should be unified into a base class
898
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
1189
        # <https://bugs.launchpad.net/bzr/+bug/401622>
899
1190
        my_fb = self._fallback_repositories
900
1191
        other_fb = other_repo._fallback_repositories
901
1192
        if len(my_fb) != len(other_fb):
930
1221
        """See Repository.gather_stats()."""
931
1222
        path = self.bzrdir._path_for_remote_call(self._client)
932
1223
        # revid can be None to indicate no revisions, not just NULL_REVISION
933
 
        if revid is None or revision.is_null(revid):
 
1224
        if revid is None or _mod_revision.is_null(revid):
934
1225
            fmt_revid = ''
935
1226
        else:
936
1227
            fmt_revid = revid
997
1288
        pass
998
1289
 
999
1290
    def lock_read(self):
 
1291
        """Lock the repository for read operations.
 
1292
 
 
1293
        :return: A bzrlib.lock.LogicalLockResult.
 
1294
        """
1000
1295
        # wrong eventually - want a local lock cache context
1001
1296
        if not self._lock_mode:
1002
1297
            self._note_lock('r')
1009
1304
                repo.lock_read()
1010
1305
        else:
1011
1306
            self._lock_count += 1
 
1307
        return lock.LogicalLockResult(self.unlock)
1012
1308
 
1013
1309
    def _remote_lock_write(self, token):
1014
1310
        path = self.bzrdir._path_for_remote_call(self._client)
1054
1350
            raise errors.ReadOnlyError(self)
1055
1351
        else:
1056
1352
            self._lock_count += 1
1057
 
        return self._lock_token or None
 
1353
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
1058
1354
 
1059
1355
    def leave_lock_in_place(self):
1060
1356
        if not self._lock_token:
1194
1490
            return t
1195
1491
        raise errors.UnexpectedSmartServerResponse(response)
1196
1492
 
 
1493
    @needs_read_lock
1197
1494
    def sprout(self, to_bzrdir, revision_id=None):
1198
 
        # TODO: Option to control what format is created?
1199
 
        self._ensure_real()
1200
 
        dest_repo = self._real_repository._format.initialize(to_bzrdir,
1201
 
                                                             shared=False)
 
1495
        """Create a descendent repository for new development.
 
1496
 
 
1497
        Unlike clone, this does not copy the settings of the repository.
 
1498
        """
 
1499
        dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
1202
1500
        dest_repo.fetch(self, revision_id=revision_id)
1203
1501
        return dest_repo
1204
1502
 
 
1503
    def _create_sprouting_repo(self, a_bzrdir, shared):
 
1504
        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
 
1505
            # use target default format.
 
1506
            dest_repo = a_bzrdir.create_repository()
 
1507
        else:
 
1508
            # Most control formats need the repository to be specifically
 
1509
            # created, but on some old all-in-one formats it's not needed
 
1510
            try:
 
1511
                dest_repo = self._format.initialize(a_bzrdir, shared=shared)
 
1512
            except errors.UninitializableFormat:
 
1513
                dest_repo = a_bzrdir.open_repository()
 
1514
        return dest_repo
 
1515
 
1205
1516
    ### These methods are just thin shims to the VFS object for now.
1206
1517
 
 
1518
    @needs_read_lock
1207
1519
    def revision_tree(self, revision_id):
1208
 
        self._ensure_real()
1209
 
        return self._real_repository.revision_tree(revision_id)
 
1520
        revision_id = _mod_revision.ensure_null(revision_id)
 
1521
        if revision_id == _mod_revision.NULL_REVISION:
 
1522
            return InventoryRevisionTree(self,
 
1523
                Inventory(root_id=None), _mod_revision.NULL_REVISION)
 
1524
        else:
 
1525
            return list(self.revision_trees([revision_id]))[0]
1210
1526
 
1211
1527
    def get_serializer_format(self):
1212
1528
        self._ensure_real()
1214
1530
 
1215
1531
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1216
1532
                           timezone=None, committer=None, revprops=None,
1217
 
                           revision_id=None):
 
1533
                           revision_id=None, lossy=False):
1218
1534
        # FIXME: It ought to be possible to call this without immediately
1219
1535
        # triggering _ensure_real.  For now it's the easiest thing to do.
1220
1536
        self._ensure_real()
1221
1537
        real_repo = self._real_repository
1222
1538
        builder = real_repo.get_commit_builder(branch, parents,
1223
1539
                config, timestamp=timestamp, timezone=timezone,
1224
 
                committer=committer, revprops=revprops, revision_id=revision_id)
 
1540
                committer=committer, revprops=revprops,
 
1541
                revision_id=revision_id, lossy=lossy)
1225
1542
        return builder
1226
1543
 
1227
1544
    def add_fallback_repository(self, repository):
1235
1552
        # We need to accumulate additional repositories here, to pass them in
1236
1553
        # on various RPC's.
1237
1554
        #
 
1555
        # Make the check before we lock: this raises an exception.
 
1556
        self._check_fallback_repository(repository)
1238
1557
        if self.is_locked():
1239
1558
            # We will call fallback.unlock() when we transition to the unlocked
1240
1559
            # state, so always add a lock here. If a caller passes us a locked
1241
1560
            # repository, they are responsible for unlocking it later.
1242
1561
            repository.lock_read()
1243
 
        self._check_fallback_repository(repository)
1244
1562
        self._fallback_repositories.append(repository)
1245
1563
        # If self._real_repository was parameterised already (e.g. because a
1246
1564
        # _real_branch had its get_stacked_on_url method called), then the
1279
1597
 
1280
1598
    @needs_read_lock
1281
1599
    def get_inventory(self, revision_id):
1282
 
        self._ensure_real()
1283
 
        return self._real_repository.get_inventory(revision_id)
 
1600
        return list(self.iter_inventories([revision_id]))[0]
1284
1601
 
1285
1602
    def iter_inventories(self, revision_ids, ordering=None):
1286
1603
        self._ensure_real()
1288
1605
 
1289
1606
    @needs_read_lock
1290
1607
    def get_revision(self, revision_id):
1291
 
        self._ensure_real()
1292
 
        return self._real_repository.get_revision(revision_id)
 
1608
        return self.get_revisions([revision_id])[0]
1293
1609
 
1294
1610
    def get_transaction(self):
1295
1611
        self._ensure_real()
1297
1613
 
1298
1614
    @needs_read_lock
1299
1615
    def clone(self, a_bzrdir, revision_id=None):
1300
 
        self._ensure_real()
1301
 
        return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
 
1616
        dest_repo = self._create_sprouting_repo(
 
1617
            a_bzrdir, shared=self.is_shared())
 
1618
        self.copy_content_into(dest_repo, revision_id)
 
1619
        return dest_repo
1302
1620
 
1303
1621
    def make_working_trees(self):
1304
1622
        """See Repository.make_working_trees"""
1305
 
        self._ensure_real()
1306
 
        return self._real_repository.make_working_trees()
 
1623
        path = self.bzrdir._path_for_remote_call(self._client)
 
1624
        try:
 
1625
            response = self._call('Repository.make_working_trees', path)
 
1626
        except errors.UnknownSmartMethod:
 
1627
            self._ensure_real()
 
1628
            return self._real_repository.make_working_trees()
 
1629
        if response[0] not in ('yes', 'no'):
 
1630
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
1631
        return response[0] == 'yes'
1307
1632
 
1308
1633
    def refresh_data(self):
1309
 
        """Re-read any data needed to to synchronise with disk.
 
1634
        """Re-read any data needed to synchronise with disk.
1310
1635
 
1311
1636
        This method is intended to be called after another repository instance
1312
1637
        (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.
 
1638
        repository. On all repositories this will work outside of write groups.
 
1639
        Some repository formats (pack and newer for bzrlib native formats)
 
1640
        support refresh_data inside write groups. If called inside a write
 
1641
        group on a repository that does not support refreshing in a write group
 
1642
        IsInWriteGroupError will be raised.
1315
1643
        """
1316
 
        if self.is_in_write_group():
1317
 
            raise errors.InternalBzrError(
1318
 
                "May not refresh_data while in a write group.")
1319
1644
        if self._real_repository is not None:
1320
1645
            self._real_repository.refresh_data()
1321
1646
 
1333
1658
        return result
1334
1659
 
1335
1660
    @needs_read_lock
1336
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
1661
    def search_missing_revision_ids(self, other,
 
1662
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
1663
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
1664
            limit=None):
1337
1665
        """Return the revision ids that other has that this does not.
1338
1666
 
1339
1667
        These are returned in topological order.
1340
1668
 
1341
1669
        revision_id: only return revision ids included by revision_id.
1342
1670
        """
1343
 
        return repository.InterRepository.get(
1344
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
1671
        if symbol_versioning.deprecated_passed(revision_id):
 
1672
            symbol_versioning.warn(
 
1673
                'search_missing_revision_ids(revision_id=...) was '
 
1674
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
1675
                DeprecationWarning, stacklevel=2)
 
1676
            if revision_ids is not None:
 
1677
                raise AssertionError(
 
1678
                    'revision_ids is mutually exclusive with revision_id')
 
1679
            if revision_id is not None:
 
1680
                revision_ids = [revision_id]
 
1681
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
1682
        return inter_repo.search_missing_revision_ids(
 
1683
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
1684
            if_present_ids=if_present_ids, limit=limit)
1345
1685
 
1346
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
1686
    def fetch(self, source, revision_id=None, find_ghosts=False,
1347
1687
            fetch_spec=None):
1348
1688
        # No base implementation to use as RemoteRepository is not a subclass
1349
1689
        # of Repository; so this is a copy of Repository.fetch().
1360
1700
            # check that last_revision is in 'from' and then return a
1361
1701
            # no-operation.
1362
1702
            if (revision_id is not None and
1363
 
                not revision.is_null(revision_id)):
 
1703
                not _mod_revision.is_null(revision_id)):
1364
1704
                self.get_revision(revision_id)
1365
1705
            return 0, []
1366
1706
        # if there is no specific appropriate InterRepository, this will get
1367
1707
        # the InterRepository base class, which raises an
1368
1708
        # IncompatibleRepositories when asked to fetch.
1369
 
        inter = repository.InterRepository.get(source, self)
1370
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
1709
        inter = _mod_repository.InterRepository.get(source, self)
 
1710
        return inter.fetch(revision_id=revision_id,
1371
1711
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1372
1712
 
1373
1713
    def create_bundle(self, target, base, fileobj, format=None):
1375
1715
        self._real_repository.create_bundle(target, base, fileobj, format)
1376
1716
 
1377
1717
    @needs_read_lock
 
1718
    @symbol_versioning.deprecated_method(
 
1719
        symbol_versioning.deprecated_in((2, 4, 0)))
1378
1720
    def get_ancestry(self, revision_id, topo_sorted=True):
1379
1721
        self._ensure_real()
1380
1722
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1388
1730
        return self._real_repository._get_versioned_file_checker(
1389
1731
            revisions, revision_versions_cache)
1390
1732
 
 
1733
    def _iter_files_bytes_rpc(self, desired_files, absent):
 
1734
        path = self.bzrdir._path_for_remote_call(self._client)
 
1735
        lines = []
 
1736
        identifiers = []
 
1737
        for (file_id, revid, identifier) in desired_files:
 
1738
            lines.append("%s\0%s" % (file_id, revid))
 
1739
            identifiers.append(identifier)
 
1740
        (response_tuple, response_handler) = (
 
1741
            self._call_with_body_bytes_expecting_body(
 
1742
            "Repository.iter_files_bytes_bz2", (path, ), "\n".join(lines)))
 
1743
        if response_tuple != ('ok', ):
 
1744
            response_handler.cancel_read_body()
 
1745
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
1746
        byte_stream = response_handler.read_streamed_body()
 
1747
        def decompress_stream(start, byte_stream, unused):
 
1748
            decompressor = bz2.BZ2Decompressor()
 
1749
            yield decompressor.decompress(start)
 
1750
            while decompressor.unused_data == "":
 
1751
                try:
 
1752
                    data = byte_stream.next()
 
1753
                except StopIteration:
 
1754
                    break
 
1755
                try:
 
1756
                    yield decompressor.decompress(data)
 
1757
                except EOFError:
 
1758
                    unused.extend([decompressor.unused_data, data])
 
1759
            unused.append(decompressor.unused_data)
 
1760
        unused = ""
 
1761
        while True:
 
1762
            while not "\n" in unused:
 
1763
                unused += byte_stream.next()
 
1764
            header, rest = unused.split("\n", 1)
 
1765
            args = header.split("\0")
 
1766
            if args[0] == "absent":
 
1767
                absent[identifiers[int(args[3])]] = (args[1], args[2])
 
1768
                unused = rest
 
1769
                continue
 
1770
            elif args[0] == "ok":
 
1771
                idx = int(args[1])
 
1772
            else:
 
1773
                raise errors.UnexpectedSmartServerResponse(args)
 
1774
            unused = []
 
1775
            yield (identifiers[idx],
 
1776
                decompress_stream(rest, byte_stream, unused))
 
1777
            unused = "".join(unused)
 
1778
 
1391
1779
    def iter_files_bytes(self, desired_files):
1392
1780
        """See Repository.iter_file_bytes.
1393
1781
        """
1394
 
        self._ensure_real()
1395
 
        return self._real_repository.iter_files_bytes(desired_files)
 
1782
        try:
 
1783
            absent = {}
 
1784
            for (identifier, bytes_iterator) in self._iter_files_bytes_rpc(
 
1785
                    desired_files, absent):
 
1786
                yield identifier, bytes_iterator
 
1787
            for fallback in self._fallback_repositories:
 
1788
                if not absent:
 
1789
                    break
 
1790
                desired_files = [(key[0], key[1], identifier) for
 
1791
                    (identifier, key) in absent.iteritems()]
 
1792
                for (identifier, bytes_iterator) in fallback.iter_files_bytes(absent):
 
1793
                    del absent[identifier]
 
1794
                    yield identifier, bytes_iterator
 
1795
            if absent:
 
1796
                # There may be more missing items, but raise an exception
 
1797
                # for just one.
 
1798
                missing_identifier = absent.keys()[0]
 
1799
                missing_key = absent[missing_identifier]
 
1800
                raise errors.RevisionNotPresent(missing_key[1], missing_key[0])
 
1801
        except errors.UnknownSmartMethod:
 
1802
            self._ensure_real()
 
1803
            for (identifier, bytes_iterator) in (
 
1804
                self._real_repository.iter_files_bytes(desired_files)):
 
1805
                yield identifier, bytes_iterator
 
1806
 
 
1807
    def get_cached_parent_map(self, revision_ids):
 
1808
        """See bzrlib.CachingParentsProvider.get_cached_parent_map"""
 
1809
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
1396
1810
 
1397
1811
    def get_parent_map(self, revision_ids):
1398
1812
        """See bzrlib.Graph.get_parent_map()."""
1457
1871
        if parents_map is None:
1458
1872
            # Repository is not locked, so there's no cache.
1459
1873
            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)
 
1874
        if _DEFAULT_SEARCH_DEPTH <= 0:
 
1875
            (start_set, stop_keys,
 
1876
             key_count) = graph.search_result_from_parent_map(
 
1877
                parents_map, self._unstacked_provider.missing_keys)
 
1878
        else:
 
1879
            (start_set, stop_keys,
 
1880
             key_count) = graph.limited_search_result_from_parent_map(
 
1881
                parents_map, self._unstacked_provider.missing_keys,
 
1882
                keys, depth=_DEFAULT_SEARCH_DEPTH)
1480
1883
        recipe = ('manual', start_set, stop_keys, key_count)
1481
1884
        body = self._serialise_search_recipe(recipe)
1482
1885
        path = self.bzrdir._path_for_remote_call(self._client)
1555
1958
 
1556
1959
    @needs_read_lock
1557
1960
    def get_revision_delta(self, revision_id, specific_fileids=None):
1558
 
        self._ensure_real()
1559
 
        return self._real_repository.get_revision_delta(revision_id,
1560
 
            specific_fileids=specific_fileids)
 
1961
        r = self.get_revision(revision_id)
 
1962
        return list(self.get_deltas_for_revisions([r],
 
1963
            specific_fileids=specific_fileids))[0]
1561
1964
 
1562
1965
    @needs_read_lock
1563
1966
    def revision_trees(self, revision_ids):
1564
 
        self._ensure_real()
1565
 
        return self._real_repository.revision_trees(revision_ids)
 
1967
        inventories = self.iter_inventories(revision_ids)
 
1968
        for inv in inventories:
 
1969
            yield InventoryRevisionTree(self, inv, inv.revision_id)
1566
1970
 
1567
1971
    @needs_read_lock
1568
1972
    def get_revision_reconcile(self, revision_id):
1576
1980
            callback_refs=callback_refs, check_repo=check_repo)
1577
1981
 
1578
1982
    def copy_content_into(self, destination, revision_id=None):
1579
 
        self._ensure_real()
1580
 
        return self._real_repository.copy_content_into(
1581
 
            destination, revision_id=revision_id)
 
1983
        """Make a complete copy of the content in self into destination.
 
1984
 
 
1985
        This is a destructive operation! Do not use it on existing
 
1986
        repositories.
 
1987
        """
 
1988
        interrepo = _mod_repository.InterRepository.get(self, destination)
 
1989
        return interrepo.copy_content(revision_id)
1582
1990
 
1583
1991
    def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1584
1992
        # get a tarball of the remote repository, and copy from that into the
1586
1994
        from bzrlib import osutils
1587
1995
        import tarfile
1588
1996
        # TODO: Maybe a progress bar while streaming the tarball?
1589
 
        note("Copying repository content as tarball...")
 
1997
        note(gettext("Copying repository content as tarball..."))
1590
1998
        tar_file = self._get_tarball('bz2')
1591
1999
        if tar_file is None:
1592
2000
            return None
1597
2005
            tmpdir = osutils.mkdtemp()
1598
2006
            try:
1599
2007
                _extract_tar(tar, tmpdir)
1600
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
2008
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1601
2009
                tmp_repo = tmp_bzrdir.open_repository()
1602
2010
                tmp_repo.copy_content_into(destination, revision_id)
1603
2011
            finally:
1631
2039
    def revisions(self):
1632
2040
        """Decorate the real repository for now.
1633
2041
 
1634
 
        In the short term this should become a real object to intercept graph
1635
 
        lookups.
1636
 
 
1637
2042
        In the long term a full blown network facility is needed.
1638
2043
        """
1639
2044
        self._ensure_real()
1688
2093
    def supports_rich_root(self):
1689
2094
        return self._format.rich_root_data
1690
2095
 
 
2096
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1691
2097
    def iter_reverse_revision_history(self, revision_id):
1692
2098
        self._ensure_real()
1693
2099
        return self._real_repository.iter_reverse_revision_history(revision_id)
1696
2102
    def _serializer(self):
1697
2103
        return self._format._serializer
1698
2104
 
 
2105
    @needs_write_lock
1699
2106
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1700
 
        self._ensure_real()
1701
 
        return self._real_repository.store_revision_signature(
1702
 
            gpg_strategy, plaintext, revision_id)
 
2107
        signature = gpg_strategy.sign(plaintext)
 
2108
        self.add_signature_text(revision_id, signature)
1703
2109
 
1704
2110
    def add_signature_text(self, revision_id, signature):
1705
2111
        self._ensure_real()
1706
2112
        return self._real_repository.add_signature_text(revision_id, signature)
1707
2113
 
1708
2114
    def has_signature_for_revision_id(self, revision_id):
 
2115
        path = self.bzrdir._path_for_remote_call(self._client)
 
2116
        try:
 
2117
            response = self._call('Repository.has_signature_for_revision_id',
 
2118
                path, revision_id)
 
2119
        except errors.UnknownSmartMethod:
 
2120
            self._ensure_real()
 
2121
            return self._real_repository.has_signature_for_revision_id(
 
2122
                revision_id)
 
2123
        if response[0] not in ('yes', 'no'):
 
2124
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2125
        return (response[0] == 'yes')
 
2126
 
 
2127
    def verify_revision_signature(self, revision_id, gpg_strategy):
1709
2128
        self._ensure_real()
1710
 
        return self._real_repository.has_signature_for_revision_id(revision_id)
 
2129
        return self._real_repository.verify_revision_signature(
 
2130
            revision_id, gpg_strategy)
1711
2131
 
1712
2132
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1713
2133
        self._ensure_real()
1714
2134
        return self._real_repository.item_keys_introduced_by(revision_ids,
1715
2135
            _files_pb=_files_pb)
1716
2136
 
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
2137
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1723
2138
        self._ensure_real()
1724
2139
        return self._real_repository._find_inconsistent_revision_parents(
1732
2147
        providers = [self._unstacked_provider]
1733
2148
        if other is not None:
1734
2149
            providers.insert(0, other)
1735
 
        providers.extend(r._make_parents_provider() for r in
1736
 
                         self._fallback_repositories)
1737
 
        return graph.StackedParentsProvider(providers)
 
2150
        return graph.StackedParentsProvider(_LazyListJoin(
 
2151
            providers, self._fallback_repositories))
1738
2152
 
1739
2153
    def _serialise_search_recipe(self, recipe):
1740
2154
        """Serialise a graph search recipe.
1748
2162
        return '\n'.join((start_keys, stop_keys, count))
1749
2163
 
1750
2164
    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)]
 
2165
        parts = search_result.get_network_struct()
1757
2166
        return '\n'.join(parts)
1758
2167
 
1759
2168
    def autopack(self):
1769
2178
            raise errors.UnexpectedSmartServerResponse(response)
1770
2179
 
1771
2180
 
1772
 
class RemoteStreamSink(repository.StreamSink):
 
2181
class RemoteStreamSink(vf_repository.StreamSink):
1773
2182
 
1774
2183
    def _insert_real(self, stream, src_format, resume_tokens):
1775
2184
        self.target_repo._ensure_real()
1876
2285
        self._last_substream and self._last_stream so that the stream can be
1877
2286
        resumed by _resume_stream_with_vfs.
1878
2287
        """
1879
 
                    
 
2288
 
1880
2289
        stream_iter = iter(stream)
1881
2290
        for substream_kind, substream in stream_iter:
1882
2291
            if substream_kind == 'inventory-deltas':
1885
2294
                return
1886
2295
            else:
1887
2296
                yield substream_kind, substream
1888
 
            
1889
 
 
1890
 
class RemoteStreamSource(repository.StreamSource):
 
2297
 
 
2298
 
 
2299
class RemoteStreamSource(vf_repository.StreamSource):
1891
2300
    """Stream data from a remote server."""
1892
2301
 
1893
2302
    def get_stream(self, search):
1953
2362
        candidate_verbs = [
1954
2363
            ('Repository.get_stream_1.19', (1, 19)),
1955
2364
            ('Repository.get_stream', (1, 13))]
 
2365
 
1956
2366
        found_verb = False
1957
2367
        for verb, version in candidate_verbs:
1958
2368
            if medium._is_remote_before(version):
1962
2372
                    verb, args, search_bytes)
1963
2373
            except errors.UnknownSmartMethod:
1964
2374
                medium._remember_remote_is_before(version)
 
2375
            except errors.UnknownErrorFromSmartServer, e:
 
2376
                if isinstance(search, graph.EverythingResult):
 
2377
                    error_verb = e.error_from_smart_server.error_verb
 
2378
                    if error_verb == 'BadSearch':
 
2379
                        # Pre-2.4 servers don't support this sort of search.
 
2380
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
2381
                        # good idea in general?  It might provide a little bit
 
2382
                        # of protection against client-side bugs.
 
2383
                        medium._remember_remote_is_before((2, 4))
 
2384
                        break
 
2385
                raise
1965
2386
            else:
1966
2387
                response_tuple, response_handler = response
1967
2388
                found_verb = True
1971
2392
        if response_tuple[0] != 'ok':
1972
2393
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1973
2394
        byte_stream = response_handler.read_streamed_body()
1974
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
2395
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
2396
            self._record_counter)
1975
2397
        if src_format.network_name() != repo._format.network_name():
1976
2398
            raise AssertionError(
1977
2399
                "Mismatched RemoteRepository and stream src %r, %r" % (
2063
2485
        return a_bzrdir.open_branch(name=name, 
2064
2486
            ignore_fallbacks=ignore_fallbacks)
2065
2487
 
2066
 
    def _vfs_initialize(self, a_bzrdir, name):
 
2488
    def _vfs_initialize(self, a_bzrdir, name, append_revisions_only):
2067
2489
        # Initialisation when using a local bzrdir object, or a non-vfs init
2068
2490
        # method is not available on the server.
2069
2491
        # self._custom_format is always set - the start of initialize ensures
2071
2493
        if isinstance(a_bzrdir, RemoteBzrDir):
2072
2494
            a_bzrdir._ensure_real()
2073
2495
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2074
 
                name)
 
2496
                name, append_revisions_only=append_revisions_only)
2075
2497
        else:
2076
2498
            # We assume the bzrdir is parameterised; it may not be.
2077
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
2499
            result = self._custom_format.initialize(a_bzrdir, name,
 
2500
                append_revisions_only=append_revisions_only)
2078
2501
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2079
2502
            not isinstance(result, RemoteBranch)):
2080
2503
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2081
2504
                                  name=name)
2082
2505
        return result
2083
2506
 
2084
 
    def initialize(self, a_bzrdir, name=None):
 
2507
    def initialize(self, a_bzrdir, name=None, repository=None,
 
2508
                   append_revisions_only=None):
2085
2509
        # 1) get the network name to use.
2086
2510
        if self._custom_format:
2087
2511
            network_name = self._custom_format.network_name()
2088
2512
        else:
2089
2513
            # Select the current bzrlib default and ask for that.
2090
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
2514
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
2091
2515
            reference_format = reference_bzrdir_format.get_branch_format()
2092
2516
            self._custom_format = reference_format
2093
2517
            network_name = reference_format.network_name()
2094
2518
        # Being asked to create on a non RemoteBzrDir:
2095
2519
        if not isinstance(a_bzrdir, RemoteBzrDir):
2096
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2520
            return self._vfs_initialize(a_bzrdir, name=name,
 
2521
                append_revisions_only=append_revisions_only)
2097
2522
        medium = a_bzrdir._client._medium
2098
2523
        if medium._is_remote_before((1, 13)):
2099
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2524
            return self._vfs_initialize(a_bzrdir, name=name,
 
2525
                append_revisions_only=append_revisions_only)
2100
2526
        # Creating on a remote bzr dir.
2101
2527
        # 2) try direct creation via RPC
2102
2528
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2109
2535
        except errors.UnknownSmartMethod:
2110
2536
            # Fallback - use vfs methods
2111
2537
            medium._remember_remote_is_before((1, 13))
2112
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2538
            return self._vfs_initialize(a_bzrdir, name=name,
 
2539
                    append_revisions_only=append_revisions_only)
2113
2540
        if response[0] != 'ok':
2114
2541
            raise errors.UnexpectedSmartServerResponse(response)
2115
2542
        # Turn the response into a RemoteRepository object.
2116
2543
        format = RemoteBranchFormat(network_name=response[1])
2117
2544
        repo_format = response_tuple_to_repo_format(response[3:])
2118
 
        if response[2] == '':
2119
 
            repo_bzrdir = a_bzrdir
 
2545
        repo_path = response[2]
 
2546
        if repository is not None:
 
2547
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
 
2548
            url_diff = urlutils.relative_url(repository.user_url,
 
2549
                    remote_repo_url)
 
2550
            if url_diff != '.':
 
2551
                raise AssertionError(
 
2552
                    'repository.user_url %r does not match URL from server '
 
2553
                    'response (%r + %r)'
 
2554
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
 
2555
            remote_repo = repository
2120
2556
        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)
 
2557
            if repo_path == '':
 
2558
                repo_bzrdir = a_bzrdir
 
2559
            else:
 
2560
                repo_bzrdir = RemoteBzrDir(
 
2561
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
2562
                    a_bzrdir._client)
 
2563
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2125
2564
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2126
2565
            format=format, setup_stacking=False, name=name)
 
2566
        if append_revisions_only:
 
2567
            remote_branch.set_append_revisions_only(append_revisions_only)
2127
2568
        # XXX: We know this is a new branch, so it must have revno 0, revid
2128
2569
        # NULL_REVISION. Creating the branch locked would make this be unable
2129
2570
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2148
2589
        self._ensure_real()
2149
2590
        return self._custom_format.supports_set_append_revisions_only()
2150
2591
 
 
2592
    def _use_default_local_heads_to_fetch(self):
 
2593
        # If the branch format is a metadir format *and* its heads_to_fetch
 
2594
        # implementation is not overridden vs the base class, we can use the
 
2595
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
2596
        # usually cheaper in terms of net round trips, as the last-revision and
 
2597
        # tags info fetched is cached and would be fetched anyway.
 
2598
        self._ensure_real()
 
2599
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
2600
            branch_class = self._custom_format._branch_class()
 
2601
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
2602
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
2603
                return True
 
2604
        return False
2151
2605
 
2152
2606
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2153
2607
    """Branch stored on a server accessed by HPSS RPC.
2311
2765
                self.bzrdir, self._client)
2312
2766
        return self._control_files
2313
2767
 
2314
 
    def _get_checkout_format(self):
 
2768
    def _get_checkout_format(self, lightweight=False):
2315
2769
        self._ensure_real()
2316
 
        return self._real_branch._get_checkout_format()
 
2770
        if lightweight:
 
2771
            format = RemoteBzrDirFormat()
 
2772
            self.bzrdir._format._supply_sub_formats_to(format)
 
2773
            format.workingtree_format = self._real_branch._get_checkout_format(
 
2774
                lightweight=lightweight).workingtree_format
 
2775
            return format
 
2776
        else:
 
2777
            return self._real_branch._get_checkout_format(lightweight=False)
2317
2778
 
2318
2779
    def get_physical_lock_status(self):
2319
2780
        """See Branch.get_physical_lock_status()."""
2352
2813
            self._is_stacked = False
2353
2814
        else:
2354
2815
            self._is_stacked = True
2355
 
        
 
2816
 
2356
2817
    def _vfs_get_tags_bytes(self):
2357
2818
        self._ensure_real()
2358
2819
        return self._real_branch._get_tags_bytes()
2359
2820
 
 
2821
    @needs_read_lock
2360
2822
    def _get_tags_bytes(self):
 
2823
        if self._tags_bytes is None:
 
2824
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
2825
        return self._tags_bytes
 
2826
 
 
2827
    def _get_tags_bytes_via_hpss(self):
2361
2828
        medium = self._client._medium
2362
2829
        if medium._is_remote_before((1, 13)):
2363
2830
            return self._vfs_get_tags_bytes()
2373
2840
        return self._real_branch._set_tags_bytes(bytes)
2374
2841
 
2375
2842
    def _set_tags_bytes(self, bytes):
 
2843
        if self.is_locked():
 
2844
            self._tags_bytes = bytes
2376
2845
        medium = self._client._medium
2377
2846
        if medium._is_remote_before((1, 18)):
2378
2847
            self._vfs_set_tags_bytes(bytes)
2387
2856
            self._vfs_set_tags_bytes(bytes)
2388
2857
 
2389
2858
    def lock_read(self):
 
2859
        """Lock the branch for read operations.
 
2860
 
 
2861
        :return: A bzrlib.lock.LogicalLockResult.
 
2862
        """
2390
2863
        self.repository.lock_read()
2391
2864
        if not self._lock_mode:
2392
2865
            self._note_lock('r')
2396
2869
                self._real_branch.lock_read()
2397
2870
        else:
2398
2871
            self._lock_count += 1
 
2872
        return lock.LogicalLockResult(self.unlock)
2399
2873
 
2400
2874
    def _remote_lock_write(self, token):
2401
2875
        if token is None:
2402
2876
            branch_token = repo_token = ''
2403
2877
        else:
2404
2878
            branch_token = token
2405
 
            repo_token = self.repository.lock_write()
 
2879
            repo_token = self.repository.lock_write().repository_token
2406
2880
            self.repository.unlock()
2407
2881
        err_context = {'token': token}
2408
 
        response = self._call(
2409
 
            'Branch.lock_write', self._remote_path(), branch_token,
2410
 
            repo_token or '', **err_context)
 
2882
        try:
 
2883
            response = self._call(
 
2884
                'Branch.lock_write', self._remote_path(), branch_token,
 
2885
                repo_token or '', **err_context)
 
2886
        except errors.LockContention, e:
 
2887
            # The LockContention from the server doesn't have any
 
2888
            # information about the lock_url. We re-raise LockContention
 
2889
            # with valid lock_url.
 
2890
            raise errors.LockContention('(remote lock)',
 
2891
                self.repository.base.split('.bzr/')[0])
2411
2892
        if response[0] != 'ok':
2412
2893
            raise errors.UnexpectedSmartServerResponse(response)
2413
2894
        ok, branch_token, repo_token = response
2434
2915
            self._lock_mode = 'w'
2435
2916
            self._lock_count = 1
2436
2917
        elif self._lock_mode == 'r':
2437
 
            raise errors.ReadOnlyTransaction
 
2918
            raise errors.ReadOnlyError(self)
2438
2919
        else:
2439
2920
            if token is not None:
2440
2921
                # A token was given to lock_write, and we're relocking, so
2445
2926
            self._lock_count += 1
2446
2927
            # Re-lock the repository too.
2447
2928
            self.repository.lock_write(self._repo_lock_token)
2448
 
        return self._lock_token or None
 
2929
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
2449
2930
 
2450
2931
    def _unlock(self, branch_token, repo_token):
2451
2932
        err_context = {'token': str((branch_token, repo_token))}
2520
3001
            missing_parent = parent_map[missing_parent]
2521
3002
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2522
3003
 
2523
 
    def _last_revision_info(self):
 
3004
    def _read_last_revision_info(self):
2524
3005
        response = self._call('Branch.last_revision_info', self._remote_path())
2525
3006
        if response[0] != 'ok':
2526
3007
            raise SmartProtocolError('unexpected response code %s' % (response,))
2589
3070
            raise errors.UnexpectedSmartServerResponse(response)
2590
3071
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2591
3072
 
 
3073
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2592
3074
    @needs_write_lock
2593
3075
    def set_revision_history(self, rev_history):
 
3076
        """See Branch.set_revision_history."""
 
3077
        self._set_revision_history(rev_history)
 
3078
 
 
3079
    @needs_write_lock
 
3080
    def _set_revision_history(self, rev_history):
2594
3081
        # Send just the tip revision of the history; the server will generate
2595
3082
        # the full history from that.  If the revision doesn't exist in this
2596
3083
        # branch, NoSuchRevision will be raised.
2654
3141
            _override_hook_target=self, **kwargs)
2655
3142
 
2656
3143
    @needs_read_lock
2657
 
    def push(self, target, overwrite=False, stop_revision=None):
 
3144
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2658
3145
        self._ensure_real()
2659
3146
        return self._real_branch.push(
2660
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
3147
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2661
3148
            _override_hook_source_branch=self)
2662
3149
 
2663
3150
    def is_locked(self):
2673
3160
        # XXX: These should be returned by the set_last_revision_info verb
2674
3161
        old_revno, old_revid = self.last_revision_info()
2675
3162
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2676
 
        revision_id = ensure_null(revision_id)
 
3163
        if not revision_id or not isinstance(revision_id, basestring):
 
3164
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2677
3165
        try:
2678
3166
            response = self._call('Branch.set_last_revision_info',
2679
3167
                self._remote_path(), self._lock_token, self._repo_lock_token,
2708
3196
            except errors.UnknownSmartMethod:
2709
3197
                medium._remember_remote_is_before((1, 6))
2710
3198
        self._clear_cached_state_of_remote_branch_only()
2711
 
        self.set_revision_history(self._lefthand_history(revision_id,
 
3199
        self._set_revision_history(self._lefthand_history(revision_id,
2712
3200
            last_rev=last_rev,other_branch=other_branch))
2713
3201
 
2714
3202
    def set_push_location(self, location):
2715
3203
        self._ensure_real()
2716
3204
        return self._real_branch.set_push_location(location)
2717
3205
 
 
3206
    def heads_to_fetch(self):
 
3207
        if self._format._use_default_local_heads_to_fetch():
 
3208
            # We recognise this format, and its heads-to-fetch implementation
 
3209
            # is the default one (tip + tags).  In this case it's cheaper to
 
3210
            # just use the default implementation rather than a special RPC as
 
3211
            # the tip and tags data is cached.
 
3212
            return branch.Branch.heads_to_fetch(self)
 
3213
        medium = self._client._medium
 
3214
        if medium._is_remote_before((2, 4)):
 
3215
            return self._vfs_heads_to_fetch()
 
3216
        try:
 
3217
            return self._rpc_heads_to_fetch()
 
3218
        except errors.UnknownSmartMethod:
 
3219
            medium._remember_remote_is_before((2, 4))
 
3220
            return self._vfs_heads_to_fetch()
 
3221
 
 
3222
    def _rpc_heads_to_fetch(self):
 
3223
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3224
        if len(response) != 2:
 
3225
            raise errors.UnexpectedSmartServerResponse(response)
 
3226
        must_fetch, if_present_fetch = response
 
3227
        return set(must_fetch), set(if_present_fetch)
 
3228
 
 
3229
    def _vfs_heads_to_fetch(self):
 
3230
        self._ensure_real()
 
3231
        return self._real_branch.heads_to_fetch()
 
3232
 
2718
3233
 
2719
3234
class RemoteConfig(object):
2720
3235
    """A Config that reads and writes from smart verbs.
2734
3249
        """
2735
3250
        try:
2736
3251
            configobj = self._get_configobj()
 
3252
            section_obj = None
2737
3253
            if section is None:
2738
3254
                section_obj = configobj
2739
3255
            else:
2740
3256
                try:
2741
3257
                    section_obj = configobj[section]
2742
3258
                except KeyError:
2743
 
                    return default
2744
 
            return section_obj.get(name, default)
 
3259
                    pass
 
3260
            if section_obj is None:
 
3261
                value = default
 
3262
            else:
 
3263
                value = section_obj.get(name, default)
2745
3264
        except errors.UnknownSmartMethod:
2746
 
            return self._vfs_get_option(name, section, default)
 
3265
            value = self._vfs_get_option(name, section, default)
 
3266
        for hook in config.OldConfigHooks['get']:
 
3267
            hook(self, name, value)
 
3268
        return value
2747
3269
 
2748
3270
    def _response_to_configobj(self, response):
2749
3271
        if len(response[0]) and response[0][0] != 'ok':
2750
3272
            raise errors.UnexpectedSmartServerResponse(response)
2751
3273
        lines = response[1].read_body_bytes().splitlines()
2752
 
        return config.ConfigObj(lines, encoding='utf-8')
 
3274
        conf = config.ConfigObj(lines, encoding='utf-8')
 
3275
        for hook in config.OldConfigHooks['load']:
 
3276
            hook(self)
 
3277
        return conf
2753
3278
 
2754
3279
 
2755
3280
class RemoteBranchConfig(RemoteConfig):
2774
3299
        medium = self._branch._client._medium
2775
3300
        if medium._is_remote_before((1, 14)):
2776
3301
            return self._vfs_set_option(value, name, section)
 
3302
        if isinstance(value, dict):
 
3303
            if medium._is_remote_before((2, 2)):
 
3304
                return self._vfs_set_option(value, name, section)
 
3305
            return self._set_config_option_dict(value, name, section)
 
3306
        else:
 
3307
            return self._set_config_option(value, name, section)
 
3308
 
 
3309
    def _set_config_option(self, value, name, section):
2777
3310
        try:
2778
3311
            path = self._branch._remote_path()
2779
3312
            response = self._branch._client.call('Branch.set_config_option',
2780
3313
                path, self._branch._lock_token, self._branch._repo_lock_token,
2781
3314
                value.encode('utf8'), name, section or '')
2782
3315
        except errors.UnknownSmartMethod:
 
3316
            medium = self._branch._client._medium
2783
3317
            medium._remember_remote_is_before((1, 14))
2784
3318
            return self._vfs_set_option(value, name, section)
2785
3319
        if response != ():
2786
3320
            raise errors.UnexpectedSmartServerResponse(response)
2787
3321
 
 
3322
    def _serialize_option_dict(self, option_dict):
 
3323
        utf8_dict = {}
 
3324
        for key, value in option_dict.items():
 
3325
            if isinstance(key, unicode):
 
3326
                key = key.encode('utf8')
 
3327
            if isinstance(value, unicode):
 
3328
                value = value.encode('utf8')
 
3329
            utf8_dict[key] = value
 
3330
        return bencode.bencode(utf8_dict)
 
3331
 
 
3332
    def _set_config_option_dict(self, value, name, section):
 
3333
        try:
 
3334
            path = self._branch._remote_path()
 
3335
            serialised_dict = self._serialize_option_dict(value)
 
3336
            response = self._branch._client.call(
 
3337
                'Branch.set_config_option_dict',
 
3338
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
3339
                serialised_dict, name, section or '')
 
3340
        except errors.UnknownSmartMethod:
 
3341
            medium = self._branch._client._medium
 
3342
            medium._remember_remote_is_before((2, 2))
 
3343
            return self._vfs_set_option(value, name, section)
 
3344
        if response != ():
 
3345
            raise errors.UnexpectedSmartServerResponse(response)
 
3346
 
2788
3347
    def _real_object(self):
2789
3348
        self._branch._ensure_real()
2790
3349
        return self._branch._real_branch
2873
3432
                    'Missing key %r in context %r', key_err.args[0], context)
2874
3433
                raise err
2875
3434
 
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':
 
3435
    if err.error_verb == 'NoSuchRevision':
2880
3436
        raise NoSuchRevision(find('branch'), err.error_args[0])
2881
3437
    elif err.error_verb == 'nosuchrevision':
2882
3438
        raise NoSuchRevision(find('repository'), err.error_args[0])
2889
3445
            detail=extra)
2890
3446
    elif err.error_verb == 'norepository':
2891
3447
        raise errors.NoRepositoryPresent(find('bzrdir'))
2892
 
    elif err.error_verb == 'LockContention':
2893
 
        raise errors.LockContention('(remote lock)')
2894
3448
    elif err.error_verb == 'UnlockableTransport':
2895
3449
        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
3450
    elif err.error_verb == 'TokenMismatch':
2899
3451
        raise errors.TokenMismatch(find('token'), '(remote token)')
2900
3452
    elif err.error_verb == 'Diverged':
2901
3453
        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
3454
    elif err.error_verb == 'NotStacked':
2909
3455
        raise errors.NotStacked(branch=find('branch'))
2910
3456
    elif err.error_verb == 'PermissionDenied':
2920
3466
    elif err.error_verb == 'NoSuchFile':
2921
3467
        path = get_path()
2922
3468
        raise errors.NoSuchFile(path)
 
3469
    _translate_error_without_context(err)
 
3470
 
 
3471
 
 
3472
def _translate_error_without_context(err):
 
3473
    """Translate any ErrorFromSmartServer values that don't require context"""
 
3474
    if err.error_verb == 'IncompatibleRepositories':
 
3475
        raise errors.IncompatibleRepositories(err.error_args[0],
 
3476
            err.error_args[1], err.error_args[2])
 
3477
    elif err.error_verb == 'LockContention':
 
3478
        raise errors.LockContention('(remote lock)')
 
3479
    elif err.error_verb == 'LockFailed':
 
3480
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
 
3481
    elif err.error_verb == 'TipChangeRejected':
 
3482
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
 
3483
    elif err.error_verb == 'UnstackableBranchFormat':
 
3484
        raise errors.UnstackableBranchFormat(*err.error_args)
 
3485
    elif err.error_verb == 'UnstackableRepositoryFormat':
 
3486
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2923
3487
    elif err.error_verb == 'FileExists':
2924
3488
        raise errors.FileExists(err.error_args[0])
2925
3489
    elif err.error_verb == 'DirectoryNotEmpty':
2926
3490
        raise errors.DirectoryNotEmpty(err.error_args[0])
 
3491
    elif err.error_verb == 'RevisionNotPresent':
 
3492
        raise errors.RevisionNotPresent(err.error_args[0], err.error_args[1])
2927
3493
    elif err.error_verb == 'ShortReadvError':
2928
3494
        args = err.error_args
2929
3495
        raise errors.ShortReadvError(
2944
3510
            raise UnicodeEncodeError(encoding, val, start, end, reason)
2945
3511
    elif err.error_verb == 'ReadOnlyError':
2946
3512
        raise errors.TransportNotPossible('readonly transport')
 
3513
    elif err.error_verb == 'MemoryError':
 
3514
        raise errors.BzrError("remote server out of memory\n"
 
3515
            "Retry non-remotely, or contact the server admin for details.")
2947
3516
    raise errors.UnknownErrorFromSmartServer(err)