/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-22 11:20:10 UTC
  • mto: This revision was merged to the branch mainline in revision 6283.
  • Revision ID: jelmer@samba.org-20111122112010-rpk2hab1ju7lld5w
s/set_config_file/put_config_file.

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 RemoteControlStore(config.IniFileStore):
 
337
    """Control store which attempts to use HPSS calls to retrieve control store.
 
338
 
 
339
    Note that this is specific to bzr-based formats.
 
340
    """
 
341
 
 
342
    def __init__(self, bzrdir):
 
343
        super(RemoteControlStore, self).__init__()
 
344
        self.bzrdir = bzrdir
 
345
        self._real_store = None
 
346
 
 
347
    def lock_write(self, token=None):
 
348
        self._ensure_real()
 
349
        return self._real_store.lock_write(token)
 
350
 
 
351
    def unlock(self):
 
352
        self._ensure_real()
 
353
        return self._real_store.unlock()
 
354
 
 
355
    @needs_write_lock
 
356
    def save(self):
 
357
        # We need to be able to override the undecorated implementation
 
358
        self.save_without_locking()
 
359
 
 
360
    def save_without_locking(self):
 
361
        super(RemoteControlStore, self).save()
 
362
 
 
363
    def _ensure_real(self):
 
364
        self.bzrdir._ensure_real()
 
365
        if self._real_store is None:
 
366
            self._real_store = config.ControlStore(self.bzrdir)
 
367
 
 
368
    def external_url(self):
 
369
        return self.bzrdir.user_url
 
370
 
 
371
    def _load_content(self):
 
372
        medium = self.bzrdir._client._medium
 
373
        path = self.bzrdir._path_for_remote_call(self.bzrdir._client)
 
374
        try:
 
375
            response, handler = self.bzrdir._call_expecting_body(
 
376
                'BzrDir.get_config_file', path)
 
377
        except errors.UnknownSmartMethod:
 
378
            self._ensure_real()
 
379
            return self._real_store._load_content()
 
380
        if len(response) and response[0] != 'ok':
 
381
            raise errors.UnexpectedSmartServerResponse(response)
 
382
        return handler.read_body_bytes()
 
383
 
 
384
    def _save_content(self, content):
 
385
        # FIXME JRV 2011-11-22: Ideally this should use a
 
386
        # HPSS call too, but at the moment it is not possible
 
387
        # to write lock control directories.
 
388
        self._ensure_real()
 
389
        return self._real_store._save_content(content)
 
390
 
 
391
 
 
392
class RemoteControlStack(config._CompatibleStack):
 
393
    """Remote control-only options stack."""
 
394
 
 
395
    def __init__(self, bzrdir):
 
396
        cstore = RemoteControlStore(bzrdir)
 
397
        super(RemoteControlStack, self).__init__(
 
398
            [cstore.get_sections],
 
399
            cstore)
 
400
        self.bzrdir = bzrdir
 
401
 
 
402
 
 
403
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
92
404
    """Control directory on a remote server, accessed via bzr:// or similar."""
93
405
 
94
406
    def __init__(self, transport, format, _client=None, _force_probe=False):
97
409
        :param _client: Private parameter for testing. Disables probing and the
98
410
            use of a real bzrdir.
99
411
        """
100
 
        BzrDir.__init__(self, transport, format)
 
412
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
101
413
        # this object holds a delegated bzrdir that uses file-level operations
102
414
        # to talk to the other side
103
415
        self._real_bzrdir = None
163
475
                import traceback
164
476
                warning('VFS BzrDir access triggered\n%s',
165
477
                    ''.join(traceback.format_stack()))
166
 
            self._real_bzrdir = BzrDir.open_from_transport(
 
478
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
167
479
                self.root_transport, _server_formats=False)
168
480
            self._format._network_name = \
169
481
                self._real_bzrdir._format.network_name()
175
487
        # Prevent aliasing problems in the next_open_branch_result cache.
176
488
        # See create_branch for rationale.
177
489
        self._next_open_branch_result = None
178
 
        return BzrDir.break_lock(self)
 
490
        return _mod_bzrdir.BzrDir.break_lock(self)
179
491
 
180
492
    def _vfs_cloning_metadir(self, require_stacking=False):
181
493
        self._ensure_real()
212
524
        if len(branch_info) != 2:
213
525
            raise errors.UnexpectedSmartServerResponse(response)
214
526
        branch_ref, branch_name = branch_info
215
 
        format = bzrdir.network_format_registry.get(control_name)
 
527
        format = controldir.network_format_registry.get(control_name)
216
528
        if repo_name:
217
 
            format.repository_format = repository.network_format_registry.get(
 
529
            format.repository_format = _mod_repository.network_format_registry.get(
218
530
                repo_name)
219
531
        if branch_ref == 'ref':
220
532
            # XXX: we need possible_transports here to avoid reopening the
221
533
            # connection to the referenced location
222
 
            ref_bzrdir = BzrDir.open(branch_name)
 
534
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
223
535
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
224
536
            format.set_branch_format(branch_format)
225
537
        elif branch_ref == 'branch':
241
553
 
242
554
    def destroy_repository(self):
243
555
        """See BzrDir.destroy_repository"""
244
 
        self._ensure_real()
245
 
        self._real_bzrdir.destroy_repository()
 
556
        path = self._path_for_remote_call(self._client)
 
557
        try:
 
558
            response = self._call('BzrDir.destroy_repository', path)
 
559
        except errors.UnknownSmartMethod:
 
560
            self._ensure_real()
 
561
            self._real_bzrdir.destroy_repository()
 
562
            return
 
563
        if response[0] != 'ok':
 
564
            raise SmartProtocolError('unexpected response code %s' % (response,))
246
565
 
247
 
    def create_branch(self, name=None):
 
566
    def create_branch(self, name=None, repository=None,
 
567
                      append_revisions_only=None):
248
568
        # as per meta1 formats - just delegate to the format object which may
249
569
        # be parameterised.
250
570
        real_branch = self._format.get_branch_format().initialize(self,
251
 
            name=name)
 
571
            name=name, repository=repository,
 
572
            append_revisions_only=append_revisions_only)
252
573
        if not isinstance(real_branch, RemoteBranch):
253
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
254
 
                                  name=name)
 
574
            if not isinstance(repository, RemoteRepository):
 
575
                raise AssertionError(
 
576
                    'need a RemoteRepository to use with RemoteBranch, got %r'
 
577
                    % (repository,))
 
578
            result = RemoteBranch(self, repository, real_branch, name=name)
255
579
        else:
256
580
            result = real_branch
257
581
        # BzrDir.clone_on_transport() uses the result of create_branch but does
269
593
        self._real_bzrdir.destroy_branch(name=name)
270
594
        self._next_open_branch_result = None
271
595
 
272
 
    def create_workingtree(self, revision_id=None, from_branch=None):
 
596
    def create_workingtree(self, revision_id=None, from_branch=None,
 
597
        accelerator_tree=None, hardlink=False):
273
598
        raise errors.NotLocalUrl(self.transport.base)
274
599
 
275
 
    def find_branch_format(self):
 
600
    def find_branch_format(self, name=None):
276
601
        """Find the branch 'format' for this bzrdir.
277
602
 
278
603
        This might be a synthetic object for e.g. RemoteBranch and SVN.
279
604
        """
280
 
        b = self.open_branch()
 
605
        b = self.open_branch(name=name)
281
606
        return b._format
282
607
 
283
 
    def get_branch_reference(self):
 
608
    def get_branch_reference(self, name=None):
284
609
        """See BzrDir.get_branch_reference()."""
 
610
        if name is not None:
 
611
            # XXX JRV20100304: Support opening colocated branches
 
612
            raise errors.NoColocatedBranchSupport(self)
285
613
        response = self._get_branch_reference()
286
614
        if response[0] == 'ref':
287
615
            return response[1]
318
646
            raise errors.UnexpectedSmartServerResponse(response)
319
647
        return response
320
648
 
321
 
    def _get_tree_branch(self):
 
649
    def _get_tree_branch(self, name=None):
322
650
        """See BzrDir._get_tree_branch()."""
323
 
        return None, self.open_branch()
 
651
        return None, self.open_branch(name=name)
324
652
 
325
653
    def open_branch(self, name=None, unsupported=False,
326
654
                    ignore_fallbacks=False):
411
739
 
412
740
    def has_workingtree(self):
413
741
        if self._has_working_tree is None:
414
 
            self._ensure_real()
415
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
 
742
            path = self._path_for_remote_call(self._client)
 
743
            try:
 
744
                response = self._call('BzrDir.has_workingtree', path)
 
745
            except errors.UnknownSmartMethod:
 
746
                self._ensure_real()
 
747
                self._has_working_tree = self._real_bzrdir.has_workingtree()
 
748
            else:
 
749
                if response[0] not in ('yes', 'no'):
 
750
                    raise SmartProtocolError('unexpected response code %s' % (response,))
 
751
                self._has_working_tree = (response[0] == 'yes')
416
752
        return self._has_working_tree
417
753
 
418
754
    def open_workingtree(self, recommend_upgrade=True):
423
759
 
424
760
    def _path_for_remote_call(self, client):
425
761
        """Return the path to be used for this bzrdir in a remote call."""
426
 
        return client.remote_path_from_transport(self.root_transport)
 
762
        return urlutils.split_segment_parameters_raw(
 
763
            client.remote_path_from_transport(self.root_transport))[0]
427
764
 
428
765
    def get_branch_transport(self, branch_format, name=None):
429
766
        self._ensure_real()
441
778
        """Upgrading of remote bzrdirs is not supported yet."""
442
779
        return False
443
780
 
444
 
    def needs_format_conversion(self, format=None):
 
781
    def needs_format_conversion(self, format):
445
782
        """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
783
        return False
450
784
 
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
785
    def _get_config(self):
458
786
        return RemoteBzrDirConfig(self)
459
787
 
460
 
 
461
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
788
    def get_config_stack(self):
 
789
        """Get a RemoteControlStack for this BzrDir.
 
790
 
 
791
        This can then be used to get and set configuration options for the
 
792
        bzrdir.
 
793
 
 
794
        :return: A RemoteControlStack
 
795
        """
 
796
        return RemoteControlStack(self)
 
797
 
 
798
 
 
799
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
462
800
    """Format for repositories accessed over a _SmartClient.
463
801
 
464
802
    Instances of this repository are represented by RemoteRepository
479
817
    """
480
818
 
481
819
    _matchingbzrdir = RemoteBzrDirFormat()
 
820
    supports_full_versioned_files = True
 
821
    supports_leaving_lock = True
482
822
 
483
823
    def __init__(self):
484
 
        repository.RepositoryFormat.__init__(self)
 
824
        _mod_repository.RepositoryFormat.__init__(self)
485
825
        self._custom_format = None
486
826
        self._network_name = None
487
827
        self._creating_bzrdir = None
 
828
        self._revision_graph_can_have_wrong_parents = None
488
829
        self._supports_chks = None
489
830
        self._supports_external_lookups = None
490
831
        self._supports_tree_reference = None
 
832
        self._supports_funky_characters = None
 
833
        self._supports_nesting_repositories = None
491
834
        self._rich_root_data = None
492
835
 
493
836
    def __repr__(self):
522
865
        return self._supports_external_lookups
523
866
 
524
867
    @property
 
868
    def supports_funky_characters(self):
 
869
        if self._supports_funky_characters is None:
 
870
            self._ensure_real()
 
871
            self._supports_funky_characters = \
 
872
                self._custom_format.supports_funky_characters
 
873
        return self._supports_funky_characters
 
874
 
 
875
    @property
 
876
    def supports_nesting_repositories(self):
 
877
        if self._supports_nesting_repositories is None:
 
878
            self._ensure_real()
 
879
            self._supports_nesting_repositories = \
 
880
                self._custom_format.supports_nesting_repositories
 
881
        return self._supports_nesting_repositories
 
882
 
 
883
    @property
525
884
    def supports_tree_reference(self):
526
885
        if self._supports_tree_reference is None:
527
886
            self._ensure_real()
529
888
                self._custom_format.supports_tree_reference
530
889
        return self._supports_tree_reference
531
890
 
 
891
    @property
 
892
    def revision_graph_can_have_wrong_parents(self):
 
893
        if self._revision_graph_can_have_wrong_parents is None:
 
894
            self._ensure_real()
 
895
            self._revision_graph_can_have_wrong_parents = \
 
896
                self._custom_format.revision_graph_can_have_wrong_parents
 
897
        return self._revision_graph_can_have_wrong_parents
 
898
 
532
899
    def _vfs_initialize(self, a_bzrdir, shared):
533
900
        """Helper for common code in initialize."""
534
901
        if self._custom_format:
569
936
            network_name = self._network_name
570
937
        else:
571
938
            # Select the current bzrlib default and ask for that.
572
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
939
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
573
940
            reference_format = reference_bzrdir_format.repository_format
574
941
            network_name = reference_format.network_name()
575
942
        # 2) try direct creation via RPC
601
968
 
602
969
    def _ensure_real(self):
603
970
        if self._custom_format is None:
604
 
            self._custom_format = repository.network_format_registry.get(
 
971
            self._custom_format = _mod_repository.network_format_registry.get(
605
972
                self._network_name)
606
973
 
607
974
    @property
644
1011
 
645
1012
 
646
1013
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
647
 
    bzrdir.ControlComponent):
 
1014
    controldir.ControlComponent):
648
1015
    """Repository accessed over rpc.
649
1016
 
650
1017
    For the moment most operations are performed using local transport-backed
703
1070
        # transport, but I'm not sure it's worth making this method
704
1071
        # optional -- mbp 2010-04-21
705
1072
        return self.bzrdir.get_repository_transport(None)
706
 
        
 
1073
 
707
1074
    def __str__(self):
708
1075
        return "%s(%s)" % (self.__class__.__name__, self.base)
709
1076
 
817
1184
    def find_text_key_references(self):
818
1185
        """Find the text key references within the repository.
819
1186
 
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
1187
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
824
1188
            to whether they were referred to by the inventory of the
825
1189
            revision_id that they contain. The inventory texts from all present
843
1207
        """Private method for using with old (< 1.2) servers to fallback."""
844
1208
        if revision_id is None:
845
1209
            revision_id = ''
846
 
        elif revision.is_null(revision_id):
 
1210
        elif _mod_revision.is_null(revision_id):
847
1211
            return {}
848
1212
 
849
1213
        path = self.bzrdir._path_for_remote_call(self._client)
873
1237
        return RemoteStreamSource(self, to_format)
874
1238
 
875
1239
    @needs_read_lock
 
1240
    def get_file_graph(self):
 
1241
        return graph.Graph(self.texts)
 
1242
 
 
1243
    @needs_read_lock
876
1244
    def has_revision(self, revision_id):
877
1245
        """True if this repository has a copy of the revision."""
878
1246
        # Copy of bzrlib.repository.Repository.has_revision
895
1263
    def _has_same_fallbacks(self, other_repo):
896
1264
        """Returns true if the repositories have the same fallbacks."""
897
1265
        # XXX: copied from Repository; it should be unified into a base class
898
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
1266
        # <https://bugs.launchpad.net/bzr/+bug/401622>
899
1267
        my_fb = self._fallback_repositories
900
1268
        other_fb = other_repo._fallback_repositories
901
1269
        if len(my_fb) != len(other_fb):
930
1298
        """See Repository.gather_stats()."""
931
1299
        path = self.bzrdir._path_for_remote_call(self._client)
932
1300
        # revid can be None to indicate no revisions, not just NULL_REVISION
933
 
        if revid is None or revision.is_null(revid):
 
1301
        if revid is None or _mod_revision.is_null(revid):
934
1302
            fmt_revid = ''
935
1303
        else:
936
1304
            fmt_revid = revid
997
1365
        pass
998
1366
 
999
1367
    def lock_read(self):
 
1368
        """Lock the repository for read operations.
 
1369
 
 
1370
        :return: A bzrlib.lock.LogicalLockResult.
 
1371
        """
1000
1372
        # wrong eventually - want a local lock cache context
1001
1373
        if not self._lock_mode:
1002
1374
            self._note_lock('r')
1009
1381
                repo.lock_read()
1010
1382
        else:
1011
1383
            self._lock_count += 1
 
1384
        return lock.LogicalLockResult(self.unlock)
1012
1385
 
1013
1386
    def _remote_lock_write(self, token):
1014
1387
        path = self.bzrdir._path_for_remote_call(self._client)
1054
1427
            raise errors.ReadOnlyError(self)
1055
1428
        else:
1056
1429
            self._lock_count += 1
1057
 
        return self._lock_token or None
 
1430
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
1058
1431
 
1059
1432
    def leave_lock_in_place(self):
1060
1433
        if not self._lock_token:
1194
1567
            return t
1195
1568
        raise errors.UnexpectedSmartServerResponse(response)
1196
1569
 
 
1570
    @needs_read_lock
1197
1571
    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)
 
1572
        """Create a descendent repository for new development.
 
1573
 
 
1574
        Unlike clone, this does not copy the settings of the repository.
 
1575
        """
 
1576
        dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
1202
1577
        dest_repo.fetch(self, revision_id=revision_id)
1203
1578
        return dest_repo
1204
1579
 
 
1580
    def _create_sprouting_repo(self, a_bzrdir, shared):
 
1581
        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
 
1582
            # use target default format.
 
1583
            dest_repo = a_bzrdir.create_repository()
 
1584
        else:
 
1585
            # Most control formats need the repository to be specifically
 
1586
            # created, but on some old all-in-one formats it's not needed
 
1587
            try:
 
1588
                dest_repo = self._format.initialize(a_bzrdir, shared=shared)
 
1589
            except errors.UninitializableFormat:
 
1590
                dest_repo = a_bzrdir.open_repository()
 
1591
        return dest_repo
 
1592
 
1205
1593
    ### These methods are just thin shims to the VFS object for now.
1206
1594
 
 
1595
    @needs_read_lock
1207
1596
    def revision_tree(self, revision_id):
1208
 
        self._ensure_real()
1209
 
        return self._real_repository.revision_tree(revision_id)
 
1597
        revision_id = _mod_revision.ensure_null(revision_id)
 
1598
        if revision_id == _mod_revision.NULL_REVISION:
 
1599
            return InventoryRevisionTree(self,
 
1600
                Inventory(root_id=None), _mod_revision.NULL_REVISION)
 
1601
        else:
 
1602
            return list(self.revision_trees([revision_id]))[0]
1210
1603
 
1211
1604
    def get_serializer_format(self):
1212
1605
        self._ensure_real()
1214
1607
 
1215
1608
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1216
1609
                           timezone=None, committer=None, revprops=None,
1217
 
                           revision_id=None):
 
1610
                           revision_id=None, lossy=False):
1218
1611
        # FIXME: It ought to be possible to call this without immediately
1219
1612
        # triggering _ensure_real.  For now it's the easiest thing to do.
1220
1613
        self._ensure_real()
1221
1614
        real_repo = self._real_repository
1222
1615
        builder = real_repo.get_commit_builder(branch, parents,
1223
1616
                config, timestamp=timestamp, timezone=timezone,
1224
 
                committer=committer, revprops=revprops, revision_id=revision_id)
 
1617
                committer=committer, revprops=revprops,
 
1618
                revision_id=revision_id, lossy=lossy)
1225
1619
        return builder
1226
1620
 
1227
1621
    def add_fallback_repository(self, repository):
1235
1629
        # We need to accumulate additional repositories here, to pass them in
1236
1630
        # on various RPC's.
1237
1631
        #
 
1632
        # Make the check before we lock: this raises an exception.
 
1633
        self._check_fallback_repository(repository)
1238
1634
        if self.is_locked():
1239
1635
            # We will call fallback.unlock() when we transition to the unlocked
1240
1636
            # state, so always add a lock here. If a caller passes us a locked
1241
1637
            # repository, they are responsible for unlocking it later.
1242
1638
            repository.lock_read()
1243
 
        self._check_fallback_repository(repository)
1244
1639
        self._fallback_repositories.append(repository)
1245
1640
        # If self._real_repository was parameterised already (e.g. because a
1246
1641
        # _real_branch had its get_stacked_on_url method called), then the
1288
1683
 
1289
1684
    @needs_read_lock
1290
1685
    def get_revision(self, revision_id):
1291
 
        self._ensure_real()
1292
 
        return self._real_repository.get_revision(revision_id)
 
1686
        return self.get_revisions([revision_id])[0]
1293
1687
 
1294
1688
    def get_transaction(self):
1295
1689
        self._ensure_real()
1297
1691
 
1298
1692
    @needs_read_lock
1299
1693
    def clone(self, a_bzrdir, revision_id=None):
1300
 
        self._ensure_real()
1301
 
        return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
 
1694
        dest_repo = self._create_sprouting_repo(
 
1695
            a_bzrdir, shared=self.is_shared())
 
1696
        self.copy_content_into(dest_repo, revision_id)
 
1697
        return dest_repo
1302
1698
 
1303
1699
    def make_working_trees(self):
1304
1700
        """See Repository.make_working_trees"""
1305
 
        self._ensure_real()
1306
 
        return self._real_repository.make_working_trees()
 
1701
        path = self.bzrdir._path_for_remote_call(self._client)
 
1702
        try:
 
1703
            response = self._call('Repository.make_working_trees', path)
 
1704
        except errors.UnknownSmartMethod:
 
1705
            self._ensure_real()
 
1706
            return self._real_repository.make_working_trees()
 
1707
        if response[0] not in ('yes', 'no'):
 
1708
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
1709
        return response[0] == 'yes'
1307
1710
 
1308
1711
    def refresh_data(self):
1309
 
        """Re-read any data needed to to synchronise with disk.
 
1712
        """Re-read any data needed to synchronise with disk.
1310
1713
 
1311
1714
        This method is intended to be called after another repository instance
1312
1715
        (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.
 
1716
        repository. On all repositories this will work outside of write groups.
 
1717
        Some repository formats (pack and newer for bzrlib native formats)
 
1718
        support refresh_data inside write groups. If called inside a write
 
1719
        group on a repository that does not support refreshing in a write group
 
1720
        IsInWriteGroupError will be raised.
1315
1721
        """
1316
 
        if self.is_in_write_group():
1317
 
            raise errors.InternalBzrError(
1318
 
                "May not refresh_data while in a write group.")
1319
1722
        if self._real_repository is not None:
1320
1723
            self._real_repository.refresh_data()
1321
1724
 
1333
1736
        return result
1334
1737
 
1335
1738
    @needs_read_lock
1336
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
1739
    def search_missing_revision_ids(self, other,
 
1740
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
1741
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
1742
            limit=None):
1337
1743
        """Return the revision ids that other has that this does not.
1338
1744
 
1339
1745
        These are returned in topological order.
1340
1746
 
1341
1747
        revision_id: only return revision ids included by revision_id.
1342
1748
        """
1343
 
        return repository.InterRepository.get(
1344
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
1749
        if symbol_versioning.deprecated_passed(revision_id):
 
1750
            symbol_versioning.warn(
 
1751
                'search_missing_revision_ids(revision_id=...) was '
 
1752
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
1753
                DeprecationWarning, stacklevel=2)
 
1754
            if revision_ids is not None:
 
1755
                raise AssertionError(
 
1756
                    'revision_ids is mutually exclusive with revision_id')
 
1757
            if revision_id is not None:
 
1758
                revision_ids = [revision_id]
 
1759
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
1760
        return inter_repo.search_missing_revision_ids(
 
1761
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
1762
            if_present_ids=if_present_ids, limit=limit)
1345
1763
 
1346
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
1764
    def fetch(self, source, revision_id=None, find_ghosts=False,
1347
1765
            fetch_spec=None):
1348
1766
        # No base implementation to use as RemoteRepository is not a subclass
1349
1767
        # of Repository; so this is a copy of Repository.fetch().
1360
1778
            # check that last_revision is in 'from' and then return a
1361
1779
            # no-operation.
1362
1780
            if (revision_id is not None and
1363
 
                not revision.is_null(revision_id)):
 
1781
                not _mod_revision.is_null(revision_id)):
1364
1782
                self.get_revision(revision_id)
1365
1783
            return 0, []
1366
1784
        # if there is no specific appropriate InterRepository, this will get
1367
1785
        # the InterRepository base class, which raises an
1368
1786
        # IncompatibleRepositories when asked to fetch.
1369
 
        inter = repository.InterRepository.get(source, self)
1370
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
1787
        inter = _mod_repository.InterRepository.get(source, self)
 
1788
        return inter.fetch(revision_id=revision_id,
1371
1789
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1372
1790
 
1373
1791
    def create_bundle(self, target, base, fileobj, format=None):
1375
1793
        self._real_repository.create_bundle(target, base, fileobj, format)
1376
1794
 
1377
1795
    @needs_read_lock
 
1796
    @symbol_versioning.deprecated_method(
 
1797
        symbol_versioning.deprecated_in((2, 4, 0)))
1378
1798
    def get_ancestry(self, revision_id, topo_sorted=True):
1379
1799
        self._ensure_real()
1380
1800
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1394
1814
        self._ensure_real()
1395
1815
        return self._real_repository.iter_files_bytes(desired_files)
1396
1816
 
 
1817
    def get_cached_parent_map(self, revision_ids):
 
1818
        """See bzrlib.CachingParentsProvider.get_cached_parent_map"""
 
1819
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
 
1820
 
1397
1821
    def get_parent_map(self, revision_ids):
1398
1822
        """See bzrlib.Graph.get_parent_map()."""
1399
1823
        return self._make_parents_provider().get_parent_map(revision_ids)
1457
1881
        if parents_map is None:
1458
1882
            # Repository is not locked, so there's no cache.
1459
1883
            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)
 
1884
        if _DEFAULT_SEARCH_DEPTH <= 0:
 
1885
            (start_set, stop_keys,
 
1886
             key_count) = graph.search_result_from_parent_map(
 
1887
                parents_map, self._unstacked_provider.missing_keys)
 
1888
        else:
 
1889
            (start_set, stop_keys,
 
1890
             key_count) = graph.limited_search_result_from_parent_map(
 
1891
                parents_map, self._unstacked_provider.missing_keys,
 
1892
                keys, depth=_DEFAULT_SEARCH_DEPTH)
1480
1893
        recipe = ('manual', start_set, stop_keys, key_count)
1481
1894
        body = self._serialise_search_recipe(recipe)
1482
1895
        path = self.bzrdir._path_for_remote_call(self._client)
1555
1968
 
1556
1969
    @needs_read_lock
1557
1970
    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)
 
1971
        r = self.get_revision(revision_id)
 
1972
        return list(self.get_deltas_for_revisions([r],
 
1973
            specific_fileids=specific_fileids))[0]
1561
1974
 
1562
1975
    @needs_read_lock
1563
1976
    def revision_trees(self, revision_ids):
1576
1989
            callback_refs=callback_refs, check_repo=check_repo)
1577
1990
 
1578
1991
    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)
 
1992
        """Make a complete copy of the content in self into destination.
 
1993
 
 
1994
        This is a destructive operation! Do not use it on existing
 
1995
        repositories.
 
1996
        """
 
1997
        interrepo = _mod_repository.InterRepository.get(self, destination)
 
1998
        return interrepo.copy_content(revision_id)
1582
1999
 
1583
2000
    def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1584
2001
        # get a tarball of the remote repository, and copy from that into the
1586
2003
        from bzrlib import osutils
1587
2004
        import tarfile
1588
2005
        # TODO: Maybe a progress bar while streaming the tarball?
1589
 
        note("Copying repository content as tarball...")
 
2006
        note(gettext("Copying repository content as tarball..."))
1590
2007
        tar_file = self._get_tarball('bz2')
1591
2008
        if tar_file is None:
1592
2009
            return None
1597
2014
            tmpdir = osutils.mkdtemp()
1598
2015
            try:
1599
2016
                _extract_tar(tar, tmpdir)
1600
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
2017
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1601
2018
                tmp_repo = tmp_bzrdir.open_repository()
1602
2019
                tmp_repo.copy_content_into(destination, revision_id)
1603
2020
            finally:
1688
2105
    def supports_rich_root(self):
1689
2106
        return self._format.rich_root_data
1690
2107
 
 
2108
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1691
2109
    def iter_reverse_revision_history(self, revision_id):
1692
2110
        self._ensure_real()
1693
2111
        return self._real_repository.iter_reverse_revision_history(revision_id)
1696
2114
    def _serializer(self):
1697
2115
        return self._format._serializer
1698
2116
 
 
2117
    @needs_write_lock
1699
2118
    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)
 
2119
        signature = gpg_strategy.sign(plaintext)
 
2120
        self.add_signature_text(revision_id, signature)
1703
2121
 
1704
2122
    def add_signature_text(self, revision_id, signature):
1705
2123
        self._ensure_real()
1706
2124
        return self._real_repository.add_signature_text(revision_id, signature)
1707
2125
 
1708
2126
    def has_signature_for_revision_id(self, revision_id):
 
2127
        path = self.bzrdir._path_for_remote_call(self._client)
 
2128
        try:
 
2129
            response = self._call('Repository.has_signature_for_revision_id',
 
2130
                path, revision_id)
 
2131
        except errors.UnknownSmartMethod:
 
2132
            self._ensure_real()
 
2133
            return self._real_repository.has_signature_for_revision_id(
 
2134
                revision_id)
 
2135
        if response[0] not in ('yes', 'no'):
 
2136
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2137
        return (response[0] == 'yes')
 
2138
 
 
2139
    def verify_revision_signature(self, revision_id, gpg_strategy):
1709
2140
        self._ensure_real()
1710
 
        return self._real_repository.has_signature_for_revision_id(revision_id)
 
2141
        return self._real_repository.verify_revision_signature(
 
2142
            revision_id, gpg_strategy)
1711
2143
 
1712
2144
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1713
2145
        self._ensure_real()
1714
2146
        return self._real_repository.item_keys_introduced_by(revision_ids,
1715
2147
            _files_pb=_files_pb)
1716
2148
 
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
2149
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1723
2150
        self._ensure_real()
1724
2151
        return self._real_repository._find_inconsistent_revision_parents(
1732
2159
        providers = [self._unstacked_provider]
1733
2160
        if other is not None:
1734
2161
            providers.insert(0, other)
1735
 
        providers.extend(r._make_parents_provider() for r in
1736
 
                         self._fallback_repositories)
1737
 
        return graph.StackedParentsProvider(providers)
 
2162
        return graph.StackedParentsProvider(_LazyListJoin(
 
2163
            providers, self._fallback_repositories))
1738
2164
 
1739
2165
    def _serialise_search_recipe(self, recipe):
1740
2166
        """Serialise a graph search recipe.
1748
2174
        return '\n'.join((start_keys, stop_keys, count))
1749
2175
 
1750
2176
    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)]
 
2177
        parts = search_result.get_network_struct()
1757
2178
        return '\n'.join(parts)
1758
2179
 
1759
2180
    def autopack(self):
1769
2190
            raise errors.UnexpectedSmartServerResponse(response)
1770
2191
 
1771
2192
 
1772
 
class RemoteStreamSink(repository.StreamSink):
 
2193
class RemoteStreamSink(vf_repository.StreamSink):
1773
2194
 
1774
2195
    def _insert_real(self, stream, src_format, resume_tokens):
1775
2196
        self.target_repo._ensure_real()
1876
2297
        self._last_substream and self._last_stream so that the stream can be
1877
2298
        resumed by _resume_stream_with_vfs.
1878
2299
        """
1879
 
                    
 
2300
 
1880
2301
        stream_iter = iter(stream)
1881
2302
        for substream_kind, substream in stream_iter:
1882
2303
            if substream_kind == 'inventory-deltas':
1885
2306
                return
1886
2307
            else:
1887
2308
                yield substream_kind, substream
1888
 
            
1889
 
 
1890
 
class RemoteStreamSource(repository.StreamSource):
 
2309
 
 
2310
 
 
2311
class RemoteStreamSource(vf_repository.StreamSource):
1891
2312
    """Stream data from a remote server."""
1892
2313
 
1893
2314
    def get_stream(self, search):
1953
2374
        candidate_verbs = [
1954
2375
            ('Repository.get_stream_1.19', (1, 19)),
1955
2376
            ('Repository.get_stream', (1, 13))]
 
2377
 
1956
2378
        found_verb = False
1957
2379
        for verb, version in candidate_verbs:
1958
2380
            if medium._is_remote_before(version):
1962
2384
                    verb, args, search_bytes)
1963
2385
            except errors.UnknownSmartMethod:
1964
2386
                medium._remember_remote_is_before(version)
 
2387
            except errors.UnknownErrorFromSmartServer, e:
 
2388
                if isinstance(search, graph.EverythingResult):
 
2389
                    error_verb = e.error_from_smart_server.error_verb
 
2390
                    if error_verb == 'BadSearch':
 
2391
                        # Pre-2.4 servers don't support this sort of search.
 
2392
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
2393
                        # good idea in general?  It might provide a little bit
 
2394
                        # of protection against client-side bugs.
 
2395
                        medium._remember_remote_is_before((2, 4))
 
2396
                        break
 
2397
                raise
1965
2398
            else:
1966
2399
                response_tuple, response_handler = response
1967
2400
                found_verb = True
1971
2404
        if response_tuple[0] != 'ok':
1972
2405
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1973
2406
        byte_stream = response_handler.read_streamed_body()
1974
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
2407
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
2408
            self._record_counter)
1975
2409
        if src_format.network_name() != repo._format.network_name():
1976
2410
            raise AssertionError(
1977
2411
                "Mismatched RemoteRepository and stream src %r, %r" % (
2063
2497
        return a_bzrdir.open_branch(name=name, 
2064
2498
            ignore_fallbacks=ignore_fallbacks)
2065
2499
 
2066
 
    def _vfs_initialize(self, a_bzrdir, name):
 
2500
    def _vfs_initialize(self, a_bzrdir, name, append_revisions_only):
2067
2501
        # Initialisation when using a local bzrdir object, or a non-vfs init
2068
2502
        # method is not available on the server.
2069
2503
        # self._custom_format is always set - the start of initialize ensures
2071
2505
        if isinstance(a_bzrdir, RemoteBzrDir):
2072
2506
            a_bzrdir._ensure_real()
2073
2507
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2074
 
                name)
 
2508
                name, append_revisions_only=append_revisions_only)
2075
2509
        else:
2076
2510
            # We assume the bzrdir is parameterised; it may not be.
2077
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
2511
            result = self._custom_format.initialize(a_bzrdir, name,
 
2512
                append_revisions_only=append_revisions_only)
2078
2513
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2079
2514
            not isinstance(result, RemoteBranch)):
2080
2515
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2081
2516
                                  name=name)
2082
2517
        return result
2083
2518
 
2084
 
    def initialize(self, a_bzrdir, name=None):
 
2519
    def initialize(self, a_bzrdir, name=None, repository=None,
 
2520
                   append_revisions_only=None):
2085
2521
        # 1) get the network name to use.
2086
2522
        if self._custom_format:
2087
2523
            network_name = self._custom_format.network_name()
2088
2524
        else:
2089
2525
            # Select the current bzrlib default and ask for that.
2090
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
2526
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
2091
2527
            reference_format = reference_bzrdir_format.get_branch_format()
2092
2528
            self._custom_format = reference_format
2093
2529
            network_name = reference_format.network_name()
2094
2530
        # Being asked to create on a non RemoteBzrDir:
2095
2531
        if not isinstance(a_bzrdir, RemoteBzrDir):
2096
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2532
            return self._vfs_initialize(a_bzrdir, name=name,
 
2533
                append_revisions_only=append_revisions_only)
2097
2534
        medium = a_bzrdir._client._medium
2098
2535
        if medium._is_remote_before((1, 13)):
2099
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2536
            return self._vfs_initialize(a_bzrdir, name=name,
 
2537
                append_revisions_only=append_revisions_only)
2100
2538
        # Creating on a remote bzr dir.
2101
2539
        # 2) try direct creation via RPC
2102
2540
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2109
2547
        except errors.UnknownSmartMethod:
2110
2548
            # Fallback - use vfs methods
2111
2549
            medium._remember_remote_is_before((1, 13))
2112
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2550
            return self._vfs_initialize(a_bzrdir, name=name,
 
2551
                    append_revisions_only=append_revisions_only)
2113
2552
        if response[0] != 'ok':
2114
2553
            raise errors.UnexpectedSmartServerResponse(response)
2115
2554
        # Turn the response into a RemoteRepository object.
2116
2555
        format = RemoteBranchFormat(network_name=response[1])
2117
2556
        repo_format = response_tuple_to_repo_format(response[3:])
2118
 
        if response[2] == '':
2119
 
            repo_bzrdir = a_bzrdir
 
2557
        repo_path = response[2]
 
2558
        if repository is not None:
 
2559
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
 
2560
            url_diff = urlutils.relative_url(repository.user_url,
 
2561
                    remote_repo_url)
 
2562
            if url_diff != '.':
 
2563
                raise AssertionError(
 
2564
                    'repository.user_url %r does not match URL from server '
 
2565
                    'response (%r + %r)'
 
2566
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
 
2567
            remote_repo = repository
2120
2568
        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)
 
2569
            if repo_path == '':
 
2570
                repo_bzrdir = a_bzrdir
 
2571
            else:
 
2572
                repo_bzrdir = RemoteBzrDir(
 
2573
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
2574
                    a_bzrdir._client)
 
2575
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2125
2576
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2126
2577
            format=format, setup_stacking=False, name=name)
 
2578
        if append_revisions_only:
 
2579
            remote_branch.set_append_revisions_only(append_revisions_only)
2127
2580
        # XXX: We know this is a new branch, so it must have revno 0, revid
2128
2581
        # NULL_REVISION. Creating the branch locked would make this be unable
2129
2582
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2148
2601
        self._ensure_real()
2149
2602
        return self._custom_format.supports_set_append_revisions_only()
2150
2603
 
 
2604
    def _use_default_local_heads_to_fetch(self):
 
2605
        # If the branch format is a metadir format *and* its heads_to_fetch
 
2606
        # implementation is not overridden vs the base class, we can use the
 
2607
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
2608
        # usually cheaper in terms of net round trips, as the last-revision and
 
2609
        # tags info fetched is cached and would be fetched anyway.
 
2610
        self._ensure_real()
 
2611
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
2612
            branch_class = self._custom_format._branch_class()
 
2613
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
2614
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
2615
                return True
 
2616
        return False
 
2617
 
 
2618
 
 
2619
class RemoteBranchStore(config.IniFileStore):
 
2620
    """Branch store which attempts to use HPSS calls to retrieve branch store.
 
2621
 
 
2622
    Note that this is specific to bzr-based formats.
 
2623
    """
 
2624
 
 
2625
    def __init__(self, branch):
 
2626
        super(RemoteBranchStore, self).__init__()
 
2627
        self.branch = branch
 
2628
        self.id = "branch"
 
2629
        self._real_store = None
 
2630
 
 
2631
    def lock_write(self, token=None):
 
2632
        return self.branch.lock_write(token)
 
2633
 
 
2634
    def unlock(self):
 
2635
        return self.branch.unlock()
 
2636
 
 
2637
    @needs_write_lock
 
2638
    def save(self):
 
2639
        # We need to be able to override the undecorated implementation
 
2640
        self.save_without_locking()
 
2641
 
 
2642
    def save_without_locking(self):
 
2643
        super(RemoteBranchStore, self).save()
 
2644
 
 
2645
    def external_url(self):
 
2646
        return self.branch.user_url
 
2647
 
 
2648
    def _load_content(self):
 
2649
        path = self.branch._remote_path()
 
2650
        try:
 
2651
            response, handler = self.branch._call_expecting_body(
 
2652
                'Branch.get_config_file', path)
 
2653
        except errors.UnknownSmartMethod:
 
2654
            self._ensure_real()
 
2655
            return self._real_store._load_content()
 
2656
        if len(response) and response[0] != 'ok':
 
2657
            raise errors.UnexpectedSmartServerResponse(response)
 
2658
        return handler.read_body_bytes()
 
2659
 
 
2660
    def _save_content(self, content):
 
2661
        path = self.branch._remote_path()
 
2662
        try:
 
2663
            response = self.branch._call_with_body_bytes(
 
2664
                'Branch.put_config_file', (path,
 
2665
                    self.branch._lock_token, self.branch._repo_lock_token),
 
2666
                content)
 
2667
        except errors.UnknownSmartMethod:
 
2668
            self._ensure_real()
 
2669
            return self._real_store._save_content(content)
 
2670
        if response != ('ok', ):
 
2671
            raise errors.UnexpectedSmartServerResponse(response)
 
2672
 
 
2673
    def _ensure_real(self):
 
2674
        self.branch._ensure_real()
 
2675
        if self._real_store is None:
 
2676
            self._real_store = config.BranchStore(self.branch)
 
2677
 
 
2678
 
 
2679
class RemoteBranchStack(config._CompatibleStack):
 
2680
    """Remote branch-only options stack."""
 
2681
 
 
2682
    def __init__(self, branch):
 
2683
        bstore = RemoteBranchStore(branch)
 
2684
        super(RemoteBranchStack, self).__init__(
 
2685
            [bstore.get_sections],
 
2686
            bstore)
 
2687
        self.branch = branch
 
2688
 
2151
2689
 
2152
2690
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2153
2691
    """Branch stored on a server accessed by HPSS RPC.
2243
2781
    def _get_config(self):
2244
2782
        return RemoteBranchConfig(self)
2245
2783
 
 
2784
    def get_config_stack(self):
 
2785
        """Get a RemoteBranchStack for this Branch.
 
2786
 
 
2787
        This can then be used to get and set configuration options for the
 
2788
        branch.
 
2789
 
 
2790
        :return: A RemoteBranchStack
 
2791
        """
 
2792
        return RemoteBranchStack(self)
 
2793
 
2246
2794
    def _get_real_transport(self):
2247
2795
        # if we try vfs access, return the real branch's vfs transport
2248
2796
        self._ensure_real()
2311
2859
                self.bzrdir, self._client)
2312
2860
        return self._control_files
2313
2861
 
2314
 
    def _get_checkout_format(self):
 
2862
    def _get_checkout_format(self, lightweight=False):
2315
2863
        self._ensure_real()
2316
 
        return self._real_branch._get_checkout_format()
 
2864
        if lightweight:
 
2865
            format = RemoteBzrDirFormat()
 
2866
            self.bzrdir._format._supply_sub_formats_to(format)
 
2867
            format.workingtree_format = self._real_branch._get_checkout_format(
 
2868
                lightweight=lightweight).workingtree_format
 
2869
            return format
 
2870
        else:
 
2871
            return self._real_branch._get_checkout_format(lightweight=False)
2317
2872
 
2318
2873
    def get_physical_lock_status(self):
2319
2874
        """See Branch.get_physical_lock_status()."""
2352
2907
            self._is_stacked = False
2353
2908
        else:
2354
2909
            self._is_stacked = True
2355
 
        
 
2910
 
2356
2911
    def _vfs_get_tags_bytes(self):
2357
2912
        self._ensure_real()
2358
2913
        return self._real_branch._get_tags_bytes()
2359
2914
 
 
2915
    @needs_read_lock
2360
2916
    def _get_tags_bytes(self):
 
2917
        if self._tags_bytes is None:
 
2918
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
2919
        return self._tags_bytes
 
2920
 
 
2921
    def _get_tags_bytes_via_hpss(self):
2361
2922
        medium = self._client._medium
2362
2923
        if medium._is_remote_before((1, 13)):
2363
2924
            return self._vfs_get_tags_bytes()
2373
2934
        return self._real_branch._set_tags_bytes(bytes)
2374
2935
 
2375
2936
    def _set_tags_bytes(self, bytes):
 
2937
        if self.is_locked():
 
2938
            self._tags_bytes = bytes
2376
2939
        medium = self._client._medium
2377
2940
        if medium._is_remote_before((1, 18)):
2378
2941
            self._vfs_set_tags_bytes(bytes)
2387
2950
            self._vfs_set_tags_bytes(bytes)
2388
2951
 
2389
2952
    def lock_read(self):
 
2953
        """Lock the branch for read operations.
 
2954
 
 
2955
        :return: A bzrlib.lock.LogicalLockResult.
 
2956
        """
2390
2957
        self.repository.lock_read()
2391
2958
        if not self._lock_mode:
2392
2959
            self._note_lock('r')
2396
2963
                self._real_branch.lock_read()
2397
2964
        else:
2398
2965
            self._lock_count += 1
 
2966
        return lock.LogicalLockResult(self.unlock)
2399
2967
 
2400
2968
    def _remote_lock_write(self, token):
2401
2969
        if token is None:
2402
2970
            branch_token = repo_token = ''
2403
2971
        else:
2404
2972
            branch_token = token
2405
 
            repo_token = self.repository.lock_write()
 
2973
            repo_token = self.repository.lock_write().repository_token
2406
2974
            self.repository.unlock()
2407
2975
        err_context = {'token': token}
2408
 
        response = self._call(
2409
 
            'Branch.lock_write', self._remote_path(), branch_token,
2410
 
            repo_token or '', **err_context)
 
2976
        try:
 
2977
            response = self._call(
 
2978
                'Branch.lock_write', self._remote_path(), branch_token,
 
2979
                repo_token or '', **err_context)
 
2980
        except errors.LockContention, e:
 
2981
            # The LockContention from the server doesn't have any
 
2982
            # information about the lock_url. We re-raise LockContention
 
2983
            # with valid lock_url.
 
2984
            raise errors.LockContention('(remote lock)',
 
2985
                self.repository.base.split('.bzr/')[0])
2411
2986
        if response[0] != 'ok':
2412
2987
            raise errors.UnexpectedSmartServerResponse(response)
2413
2988
        ok, branch_token, repo_token = response
2434
3009
            self._lock_mode = 'w'
2435
3010
            self._lock_count = 1
2436
3011
        elif self._lock_mode == 'r':
2437
 
            raise errors.ReadOnlyTransaction
 
3012
            raise errors.ReadOnlyError(self)
2438
3013
        else:
2439
3014
            if token is not None:
2440
3015
                # A token was given to lock_write, and we're relocking, so
2445
3020
            self._lock_count += 1
2446
3021
            # Re-lock the repository too.
2447
3022
            self.repository.lock_write(self._repo_lock_token)
2448
 
        return self._lock_token or None
 
3023
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
2449
3024
 
2450
3025
    def _unlock(self, branch_token, repo_token):
2451
3026
        err_context = {'token': str((branch_token, repo_token))}
2520
3095
            missing_parent = parent_map[missing_parent]
2521
3096
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2522
3097
 
2523
 
    def _last_revision_info(self):
 
3098
    def _read_last_revision_info(self):
2524
3099
        response = self._call('Branch.last_revision_info', self._remote_path())
2525
3100
        if response[0] != 'ok':
2526
3101
            raise SmartProtocolError('unexpected response code %s' % (response,))
2589
3164
            raise errors.UnexpectedSmartServerResponse(response)
2590
3165
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2591
3166
 
 
3167
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2592
3168
    @needs_write_lock
2593
3169
    def set_revision_history(self, rev_history):
 
3170
        """See Branch.set_revision_history."""
 
3171
        self._set_revision_history(rev_history)
 
3172
 
 
3173
    @needs_write_lock
 
3174
    def _set_revision_history(self, rev_history):
2594
3175
        # Send just the tip revision of the history; the server will generate
2595
3176
        # the full history from that.  If the revision doesn't exist in this
2596
3177
        # branch, NoSuchRevision will be raised.
2654
3235
            _override_hook_target=self, **kwargs)
2655
3236
 
2656
3237
    @needs_read_lock
2657
 
    def push(self, target, overwrite=False, stop_revision=None):
 
3238
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2658
3239
        self._ensure_real()
2659
3240
        return self._real_branch.push(
2660
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
3241
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2661
3242
            _override_hook_source_branch=self)
2662
3243
 
2663
3244
    def is_locked(self):
2673
3254
        # XXX: These should be returned by the set_last_revision_info verb
2674
3255
        old_revno, old_revid = self.last_revision_info()
2675
3256
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2676
 
        revision_id = ensure_null(revision_id)
 
3257
        if not revision_id or not isinstance(revision_id, basestring):
 
3258
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2677
3259
        try:
2678
3260
            response = self._call('Branch.set_last_revision_info',
2679
3261
                self._remote_path(), self._lock_token, self._repo_lock_token,
2708
3290
            except errors.UnknownSmartMethod:
2709
3291
                medium._remember_remote_is_before((1, 6))
2710
3292
        self._clear_cached_state_of_remote_branch_only()
2711
 
        self.set_revision_history(self._lefthand_history(revision_id,
 
3293
        self._set_revision_history(self._lefthand_history(revision_id,
2712
3294
            last_rev=last_rev,other_branch=other_branch))
2713
3295
 
2714
3296
    def set_push_location(self, location):
2715
3297
        self._ensure_real()
2716
3298
        return self._real_branch.set_push_location(location)
2717
3299
 
 
3300
    def heads_to_fetch(self):
 
3301
        if self._format._use_default_local_heads_to_fetch():
 
3302
            # We recognise this format, and its heads-to-fetch implementation
 
3303
            # is the default one (tip + tags).  In this case it's cheaper to
 
3304
            # just use the default implementation rather than a special RPC as
 
3305
            # the tip and tags data is cached.
 
3306
            return branch.Branch.heads_to_fetch(self)
 
3307
        medium = self._client._medium
 
3308
        if medium._is_remote_before((2, 4)):
 
3309
            return self._vfs_heads_to_fetch()
 
3310
        try:
 
3311
            return self._rpc_heads_to_fetch()
 
3312
        except errors.UnknownSmartMethod:
 
3313
            medium._remember_remote_is_before((2, 4))
 
3314
            return self._vfs_heads_to_fetch()
 
3315
 
 
3316
    def _rpc_heads_to_fetch(self):
 
3317
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3318
        if len(response) != 2:
 
3319
            raise errors.UnexpectedSmartServerResponse(response)
 
3320
        must_fetch, if_present_fetch = response
 
3321
        return set(must_fetch), set(if_present_fetch)
 
3322
 
 
3323
    def _vfs_heads_to_fetch(self):
 
3324
        self._ensure_real()
 
3325
        return self._real_branch.heads_to_fetch()
 
3326
 
2718
3327
 
2719
3328
class RemoteConfig(object):
2720
3329
    """A Config that reads and writes from smart verbs.
2734
3343
        """
2735
3344
        try:
2736
3345
            configobj = self._get_configobj()
 
3346
            section_obj = None
2737
3347
            if section is None:
2738
3348
                section_obj = configobj
2739
3349
            else:
2740
3350
                try:
2741
3351
                    section_obj = configobj[section]
2742
3352
                except KeyError:
2743
 
                    return default
2744
 
            return section_obj.get(name, default)
 
3353
                    pass
 
3354
            if section_obj is None:
 
3355
                value = default
 
3356
            else:
 
3357
                value = section_obj.get(name, default)
2745
3358
        except errors.UnknownSmartMethod:
2746
 
            return self._vfs_get_option(name, section, default)
 
3359
            value = self._vfs_get_option(name, section, default)
 
3360
        for hook in config.OldConfigHooks['get']:
 
3361
            hook(self, name, value)
 
3362
        return value
2747
3363
 
2748
3364
    def _response_to_configobj(self, response):
2749
3365
        if len(response[0]) and response[0][0] != 'ok':
2750
3366
            raise errors.UnexpectedSmartServerResponse(response)
2751
3367
        lines = response[1].read_body_bytes().splitlines()
2752
 
        return config.ConfigObj(lines, encoding='utf-8')
 
3368
        conf = config.ConfigObj(lines, encoding='utf-8')
 
3369
        for hook in config.OldConfigHooks['load']:
 
3370
            hook(self)
 
3371
        return conf
2753
3372
 
2754
3373
 
2755
3374
class RemoteBranchConfig(RemoteConfig):
2774
3393
        medium = self._branch._client._medium
2775
3394
        if medium._is_remote_before((1, 14)):
2776
3395
            return self._vfs_set_option(value, name, section)
 
3396
        if isinstance(value, dict):
 
3397
            if medium._is_remote_before((2, 2)):
 
3398
                return self._vfs_set_option(value, name, section)
 
3399
            return self._set_config_option_dict(value, name, section)
 
3400
        else:
 
3401
            return self._set_config_option(value, name, section)
 
3402
 
 
3403
    def _set_config_option(self, value, name, section):
2777
3404
        try:
2778
3405
            path = self._branch._remote_path()
2779
3406
            response = self._branch._client.call('Branch.set_config_option',
2780
3407
                path, self._branch._lock_token, self._branch._repo_lock_token,
2781
3408
                value.encode('utf8'), name, section or '')
2782
3409
        except errors.UnknownSmartMethod:
 
3410
            medium = self._branch._client._medium
2783
3411
            medium._remember_remote_is_before((1, 14))
2784
3412
            return self._vfs_set_option(value, name, section)
2785
3413
        if response != ():
2786
3414
            raise errors.UnexpectedSmartServerResponse(response)
2787
3415
 
 
3416
    def _serialize_option_dict(self, option_dict):
 
3417
        utf8_dict = {}
 
3418
        for key, value in option_dict.items():
 
3419
            if isinstance(key, unicode):
 
3420
                key = key.encode('utf8')
 
3421
            if isinstance(value, unicode):
 
3422
                value = value.encode('utf8')
 
3423
            utf8_dict[key] = value
 
3424
        return bencode.bencode(utf8_dict)
 
3425
 
 
3426
    def _set_config_option_dict(self, value, name, section):
 
3427
        try:
 
3428
            path = self._branch._remote_path()
 
3429
            serialised_dict = self._serialize_option_dict(value)
 
3430
            response = self._branch._client.call(
 
3431
                'Branch.set_config_option_dict',
 
3432
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
3433
                serialised_dict, name, section or '')
 
3434
        except errors.UnknownSmartMethod:
 
3435
            medium = self._branch._client._medium
 
3436
            medium._remember_remote_is_before((2, 2))
 
3437
            return self._vfs_set_option(value, name, section)
 
3438
        if response != ():
 
3439
            raise errors.UnexpectedSmartServerResponse(response)
 
3440
 
2788
3441
    def _real_object(self):
2789
3442
        self._branch._ensure_real()
2790
3443
        return self._branch._real_branch
2873
3526
                    'Missing key %r in context %r', key_err.args[0], context)
2874
3527
                raise err
2875
3528
 
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':
 
3529
    if err.error_verb == 'NoSuchRevision':
2880
3530
        raise NoSuchRevision(find('branch'), err.error_args[0])
2881
3531
    elif err.error_verb == 'nosuchrevision':
2882
3532
        raise NoSuchRevision(find('repository'), err.error_args[0])
2889
3539
            detail=extra)
2890
3540
    elif err.error_verb == 'norepository':
2891
3541
        raise errors.NoRepositoryPresent(find('bzrdir'))
2892
 
    elif err.error_verb == 'LockContention':
2893
 
        raise errors.LockContention('(remote lock)')
2894
3542
    elif err.error_verb == 'UnlockableTransport':
2895
3543
        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
3544
    elif err.error_verb == 'TokenMismatch':
2899
3545
        raise errors.TokenMismatch(find('token'), '(remote token)')
2900
3546
    elif err.error_verb == 'Diverged':
2901
3547
        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
3548
    elif err.error_verb == 'NotStacked':
2909
3549
        raise errors.NotStacked(branch=find('branch'))
2910
3550
    elif err.error_verb == 'PermissionDenied':
2920
3560
    elif err.error_verb == 'NoSuchFile':
2921
3561
        path = get_path()
2922
3562
        raise errors.NoSuchFile(path)
 
3563
    _translate_error_without_context(err)
 
3564
 
 
3565
 
 
3566
def _translate_error_without_context(err):
 
3567
    """Translate any ErrorFromSmartServer values that don't require context"""
 
3568
    if err.error_verb == 'IncompatibleRepositories':
 
3569
        raise errors.IncompatibleRepositories(err.error_args[0],
 
3570
            err.error_args[1], err.error_args[2])
 
3571
    elif err.error_verb == 'LockContention':
 
3572
        raise errors.LockContention('(remote lock)')
 
3573
    elif err.error_verb == 'LockFailed':
 
3574
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
 
3575
    elif err.error_verb == 'TipChangeRejected':
 
3576
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
 
3577
    elif err.error_verb == 'UnstackableBranchFormat':
 
3578
        raise errors.UnstackableBranchFormat(*err.error_args)
 
3579
    elif err.error_verb == 'UnstackableRepositoryFormat':
 
3580
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2923
3581
    elif err.error_verb == 'FileExists':
2924
3582
        raise errors.FileExists(err.error_args[0])
2925
3583
    elif err.error_verb == 'DirectoryNotEmpty':
2944
3602
            raise UnicodeEncodeError(encoding, val, start, end, reason)
2945
3603
    elif err.error_verb == 'ReadOnlyError':
2946
3604
        raise errors.TransportNotPossible('readonly transport')
 
3605
    elif err.error_verb == 'MemoryError':
 
3606
        raise errors.BzrError("remote server out of memory\n"
 
3607
            "Retry non-remotely, or contact the server admin for details.")
2947
3608
    raise errors.UnknownErrorFromSmartServer(err)