← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-04-09 20:23:07 UTC
  • mfrom: (4265.1.4 bbc-merge)
  • Revision ID: pqm@pqm.ubuntu.com-20090409202307-n0depb16qepoe21o
(jam) Change _fetch_uses_deltas = False for CHK repos until we can
        write a better fix.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006, 2007, 2008 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
# TODO: At some point, handle upgrades by just passing the whole request
 
18
# across to run on the server.
 
19
 
17
20
import bz2
18
21
 
19
22
from bzrlib import (
20
 
    bencode,
21
23
    branch,
22
 
    bzrdir as _mod_bzrdir,
 
24
    bzrdir,
23
25
    config,
24
 
    controldir,
25
26
    debug,
26
27
    errors,
27
28
    graph,
28
 
    lock,
29
29
    lockdir,
30
 
    repository as _mod_repository,
31
 
    revision as _mod_revision,
32
 
    static_tuple,
 
30
    pack,
 
31
    repository,
 
32
    revision,
33
33
    symbol_versioning,
34
34
    urlutils,
35
 
    vf_repository,
36
 
    )
37
 
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
38
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
 
35
)
 
36
from bzrlib.branch import BranchReferenceFormat
 
37
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
 
38
from bzrlib.decorators import needs_read_lock, needs_write_lock
39
39
from bzrlib.errors import (
40
40
    NoSuchRevision,
41
41
    SmartProtocolError,
42
42
    )
43
43
from bzrlib.lockable_files import LockableFiles
44
44
from bzrlib.smart import client, vfs, repository as smart_repo
45
 
from bzrlib.smart.client import _SmartClient
46
 
from bzrlib.revision import NULL_REVISION
47
 
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
 
45
from bzrlib.revision import ensure_null, NULL_REVISION
48
46
from bzrlib.trace import mutter, note, warning
 
47
from bzrlib.util import bencode
49
48
 
50
49
 
51
50
class _RpcHelper(object):
63
62
        except errors.ErrorFromSmartServer, err:
64
63
            self._translate_error(err, **err_context)
65
64
 
66
 
    def _call_with_body_bytes(self, method, args, body_bytes, **err_context):
67
 
        try:
68
 
            return self._client.call_with_body_bytes(method, args, body_bytes)
69
 
        except errors.ErrorFromSmartServer, err:
70
 
            self._translate_error(err, **err_context)
71
 
 
72
65
    def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
73
66
                                             **err_context):
74
67
        try:
88
81
    return format
89
82
 
90
83
 
91
 
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
92
 
# does not have to be imported unless a remote format is involved.
93
 
 
94
 
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
95
 
    """Format representing bzrdirs accessed via a smart server"""
96
 
 
97
 
    supports_workingtrees = False
98
 
 
99
 
    def __init__(self):
100
 
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
101
 
        # XXX: It's a bit ugly that the network name is here, because we'd
102
 
        # like to believe that format objects are stateless or at least
103
 
        # immutable,  However, we do at least avoid mutating the name after
104
 
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
105
 
        self._network_name = None
106
 
 
107
 
    def __repr__(self):
108
 
        return "%s(_network_name=%r)" % (self.__class__.__name__,
109
 
            self._network_name)
110
 
 
111
 
    def get_format_description(self):
112
 
        if self._network_name:
113
 
            real_format = controldir.network_format_registry.get(self._network_name)
114
 
            return 'Remote: ' + real_format.get_format_description()
115
 
        return 'bzr remote bzrdir'
116
 
 
117
 
    def get_format_string(self):
118
 
        raise NotImplementedError(self.get_format_string)
119
 
 
120
 
    def network_name(self):
121
 
        if self._network_name:
122
 
            return self._network_name
123
 
        else:
124
 
            raise AssertionError("No network name set.")
125
 
 
126
 
    def initialize_on_transport(self, transport):
127
 
        try:
128
 
            # hand off the request to the smart server
129
 
            client_medium = transport.get_smart_medium()
130
 
        except errors.NoSmartMedium:
131
 
            # TODO: lookup the local format from a server hint.
132
 
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
133
 
            return local_dir_format.initialize_on_transport(transport)
134
 
        client = _SmartClient(client_medium)
135
 
        path = client.remote_path_from_transport(transport)
136
 
        try:
137
 
            response = client.call('BzrDirFormat.initialize', path)
138
 
        except errors.ErrorFromSmartServer, err:
139
 
            _translate_error(err, path=path)
140
 
        if response[0] != 'ok':
141
 
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
142
 
        format = RemoteBzrDirFormat()
143
 
        self._supply_sub_formats_to(format)
144
 
        return RemoteBzrDir(transport, format)
145
 
 
146
 
    def parse_NoneTrueFalse(self, arg):
147
 
        if not arg:
148
 
            return None
149
 
        if arg == 'False':
150
 
            return False
151
 
        if arg == 'True':
152
 
            return True
153
 
        raise AssertionError("invalid arg %r" % arg)
154
 
 
155
 
    def _serialize_NoneTrueFalse(self, arg):
156
 
        if arg is False:
157
 
            return 'False'
158
 
        if arg:
159
 
            return 'True'
160
 
        return ''
161
 
 
162
 
    def _serialize_NoneString(self, arg):
163
 
        return arg or ''
164
 
 
165
 
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
166
 
        create_prefix=False, force_new_repo=False, stacked_on=None,
167
 
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
168
 
        shared_repo=False):
169
 
        try:
170
 
            # hand off the request to the smart server
171
 
            client_medium = transport.get_smart_medium()
172
 
        except errors.NoSmartMedium:
173
 
            do_vfs = True
174
 
        else:
175
 
            # Decline to open it if the server doesn't support our required
176
 
            # version (3) so that the VFS-based transport will do it.
177
 
            if client_medium.should_probe():
178
 
                try:
179
 
                    server_version = client_medium.protocol_version()
180
 
                    if server_version != '2':
181
 
                        do_vfs = True
182
 
                    else:
183
 
                        do_vfs = False
184
 
                except errors.SmartProtocolError:
185
 
                    # Apparently there's no usable smart server there, even though
186
 
                    # the medium supports the smart protocol.
187
 
                    do_vfs = True
188
 
            else:
189
 
                do_vfs = False
190
 
        if not do_vfs:
191
 
            client = _SmartClient(client_medium)
192
 
            path = client.remote_path_from_transport(transport)
193
 
            if client_medium._is_remote_before((1, 16)):
194
 
                do_vfs = True
195
 
        if do_vfs:
196
 
            # TODO: lookup the local format from a server hint.
197
 
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
198
 
            self._supply_sub_formats_to(local_dir_format)
199
 
            return local_dir_format.initialize_on_transport_ex(transport,
200
 
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
201
 
                force_new_repo=force_new_repo, stacked_on=stacked_on,
202
 
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
203
 
                make_working_trees=make_working_trees, shared_repo=shared_repo,
204
 
                vfs_only=True)
205
 
        return self._initialize_on_transport_ex_rpc(client, path, transport,
206
 
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
207
 
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
208
 
 
209
 
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
210
 
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
211
 
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
212
 
        args = []
213
 
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
214
 
        args.append(self._serialize_NoneTrueFalse(create_prefix))
215
 
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
216
 
        args.append(self._serialize_NoneString(stacked_on))
217
 
        # stack_on_pwd is often/usually our transport
218
 
        if stack_on_pwd:
219
 
            try:
220
 
                stack_on_pwd = transport.relpath(stack_on_pwd)
221
 
                if not stack_on_pwd:
222
 
                    stack_on_pwd = '.'
223
 
            except errors.PathNotChild:
224
 
                pass
225
 
        args.append(self._serialize_NoneString(stack_on_pwd))
226
 
        args.append(self._serialize_NoneString(repo_format_name))
227
 
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
228
 
        args.append(self._serialize_NoneTrueFalse(shared_repo))
229
 
        request_network_name = self._network_name or \
230
 
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
231
 
        try:
232
 
            response = client.call('BzrDirFormat.initialize_ex_1.16',
233
 
                request_network_name, path, *args)
234
 
        except errors.UnknownSmartMethod:
235
 
            client._medium._remember_remote_is_before((1,16))
236
 
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
237
 
            self._supply_sub_formats_to(local_dir_format)
238
 
            return local_dir_format.initialize_on_transport_ex(transport,
239
 
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
240
 
                force_new_repo=force_new_repo, stacked_on=stacked_on,
241
 
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
242
 
                make_working_trees=make_working_trees, shared_repo=shared_repo,
243
 
                vfs_only=True)
244
 
        except errors.ErrorFromSmartServer, err:
245
 
            _translate_error(err, path=path)
246
 
        repo_path = response[0]
247
 
        bzrdir_name = response[6]
248
 
        require_stacking = response[7]
249
 
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
250
 
        format = RemoteBzrDirFormat()
251
 
        format._network_name = bzrdir_name
252
 
        self._supply_sub_formats_to(format)
253
 
        bzrdir = RemoteBzrDir(transport, format, _client=client)
254
 
        if repo_path:
255
 
            repo_format = response_tuple_to_repo_format(response[1:])
256
 
            if repo_path == '.':
257
 
                repo_path = ''
258
 
            if repo_path:
259
 
                repo_bzrdir_format = RemoteBzrDirFormat()
260
 
                repo_bzrdir_format._network_name = response[5]
261
 
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
262
 
                    repo_bzrdir_format)
263
 
            else:
264
 
                repo_bzr = bzrdir
265
 
            final_stack = response[8] or None
266
 
            final_stack_pwd = response[9] or None
267
 
            if final_stack_pwd:
268
 
                final_stack_pwd = urlutils.join(
269
 
                    transport.base, final_stack_pwd)
270
 
            remote_repo = RemoteRepository(repo_bzr, repo_format)
271
 
            if len(response) > 10:
272
 
                # Updated server verb that locks remotely.
273
 
                repo_lock_token = response[10] or None
274
 
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
275
 
                if repo_lock_token:
276
 
                    remote_repo.dont_leave_lock_in_place()
277
 
            else:
278
 
                remote_repo.lock_write()
279
 
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
280
 
                final_stack_pwd, require_stacking)
281
 
            policy.acquire_repository()
282
 
        else:
283
 
            remote_repo = None
284
 
            policy = None
285
 
        bzrdir._format.set_branch_format(self.get_branch_format())
286
 
        if require_stacking:
287
 
            # The repo has already been created, but we need to make sure that
288
 
            # we'll make a stackable branch.
289
 
            bzrdir._format.require_stacking(_skip_repo=True)
290
 
        return remote_repo, bzrdir, require_stacking, policy
291
 
 
292
 
    def _open(self, transport):
293
 
        return RemoteBzrDir(transport, self)
294
 
 
295
 
    def __eq__(self, other):
296
 
        if not isinstance(other, RemoteBzrDirFormat):
297
 
            return False
298
 
        return self.get_format_description() == other.get_format_description()
299
 
 
300
 
    def __return_repository_format(self):
301
 
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
302
 
        # repository format has been asked for, tell the RemoteRepositoryFormat
303
 
        # that it should use that for init() etc.
304
 
        result = RemoteRepositoryFormat()
305
 
        custom_format = getattr(self, '_repository_format', None)
306
 
        if custom_format:
307
 
            if isinstance(custom_format, RemoteRepositoryFormat):
308
 
                return custom_format
309
 
            else:
310
 
                # We will use the custom format to create repositories over the
311
 
                # wire; expose its details like rich_root_data for code to
312
 
                # query
313
 
                result._custom_format = custom_format
314
 
        return result
315
 
 
316
 
    def get_branch_format(self):
317
 
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
318
 
        if not isinstance(result, RemoteBranchFormat):
319
 
            new_result = RemoteBranchFormat()
320
 
            new_result._custom_format = result
321
 
            # cache the result
322
 
            self.set_branch_format(new_result)
323
 
            result = new_result
324
 
        return result
325
 
 
326
 
    repository_format = property(__return_repository_format,
327
 
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
328
 
 
329
 
 
330
 
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
 
84
# Note: RemoteBzrDirFormat is in bzrdir.py
 
85
 
 
86
class RemoteBzrDir(BzrDir, _RpcHelper):
331
87
    """Control directory on a remote server, accessed via bzr:// or similar."""
332
88
 
333
 
    def __init__(self, transport, format, _client=None, _force_probe=False):
 
89
    def __init__(self, transport, format, _client=None):
334
90
        """Construct a RemoteBzrDir.
335
91
 
336
92
        :param _client: Private parameter for testing. Disables probing and the
337
93
            use of a real bzrdir.
338
94
        """
339
 
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
 
95
        BzrDir.__init__(self, transport, format)
340
96
        # this object holds a delegated bzrdir that uses file-level operations
341
97
        # to talk to the other side
342
98
        self._real_bzrdir = None
343
 
        self._has_working_tree = None
344
99
        # 1-shot cache for the call pattern 'create_branch; open_branch' - see
345
100
        # create_branch for details.
346
101
        self._next_open_branch_result = None
350
105
            self._client = client._SmartClient(medium)
351
106
        else:
352
107
            self._client = _client
353
 
            if not _force_probe:
354
 
                return
355
 
 
356
 
        self._probe_bzrdir()
357
 
 
358
 
    def __repr__(self):
359
 
        return '%s(%r)' % (self.__class__.__name__, self._client)
360
 
 
361
 
    def _probe_bzrdir(self):
362
 
        medium = self._client._medium
 
108
            return
 
109
 
363
110
        path = self._path_for_remote_call(self._client)
364
 
        if medium._is_remote_before((2, 1)):
365
 
            self._rpc_open(path)
366
 
            return
367
 
        try:
368
 
            self._rpc_open_2_1(path)
369
 
            return
370
 
        except errors.UnknownSmartMethod:
371
 
            medium._remember_remote_is_before((2, 1))
372
 
            self._rpc_open(path)
373
 
 
374
 
    def _rpc_open_2_1(self, path):
375
 
        response = self._call('BzrDir.open_2.1', path)
376
 
        if response == ('no',):
377
 
            raise errors.NotBranchError(path=self.root_transport.base)
378
 
        elif response[0] == 'yes':
379
 
            if response[1] == 'yes':
380
 
                self._has_working_tree = True
381
 
            elif response[1] == 'no':
382
 
                self._has_working_tree = False
383
 
            else:
384
 
                raise errors.UnexpectedSmartServerResponse(response)
385
 
        else:
386
 
            raise errors.UnexpectedSmartServerResponse(response)
387
 
 
388
 
    def _rpc_open(self, path):
389
111
        response = self._call('BzrDir.open', path)
390
112
        if response not in [('yes',), ('no',)]:
391
113
            raise errors.UnexpectedSmartServerResponse(response)
392
114
        if response == ('no',):
393
 
            raise errors.NotBranchError(path=self.root_transport.base)
 
115
            raise errors.NotBranchError(path=transport.base)
394
116
 
395
117
    def _ensure_real(self):
396
118
        """Ensure that there is a _real_bzrdir set.
398
120
        Used before calls to self._real_bzrdir.
399
121
        """
400
122
        if not self._real_bzrdir:
401
 
            if 'hpssvfs' in debug.debug_flags:
402
 
                import traceback
403
 
                warning('VFS BzrDir access triggered\n%s',
404
 
                    ''.join(traceback.format_stack()))
405
 
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
 
123
            self._real_bzrdir = BzrDir.open_from_transport(
406
124
                self.root_transport, _server_formats=False)
407
125
            self._format._network_name = \
408
126
                self._real_bzrdir._format.network_name()
414
132
        # Prevent aliasing problems in the next_open_branch_result cache.
415
133
        # See create_branch for rationale.
416
134
        self._next_open_branch_result = None
417
 
        return _mod_bzrdir.BzrDir.break_lock(self)
 
135
        return BzrDir.break_lock(self)
418
136
 
419
137
    def _vfs_cloning_metadir(self, require_stacking=False):
420
138
        self._ensure_real()
451
169
        if len(branch_info) != 2:
452
170
            raise errors.UnexpectedSmartServerResponse(response)
453
171
        branch_ref, branch_name = branch_info
454
 
        format = controldir.network_format_registry.get(control_name)
 
172
        format = bzrdir.network_format_registry.get(control_name)
455
173
        if repo_name:
456
 
            format.repository_format = _mod_repository.network_format_registry.get(
 
174
            format.repository_format = repository.network_format_registry.get(
457
175
                repo_name)
458
176
        if branch_ref == 'ref':
459
177
            # XXX: we need possible_transports here to avoid reopening the
460
178
            # connection to the referenced location
461
 
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
 
179
            ref_bzrdir = BzrDir.open(branch_name)
462
180
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
463
181
            format.set_branch_format(branch_format)
464
182
        elif branch_ref == 'branch':
483
201
        self._ensure_real()
484
202
        self._real_bzrdir.destroy_repository()
485
203
 
486
 
    def create_branch(self, name=None, repository=None):
 
204
    def create_branch(self):
487
205
        # as per meta1 formats - just delegate to the format object which may
488
206
        # be parameterised.
489
 
        real_branch = self._format.get_branch_format().initialize(self,
490
 
            name=name, repository=repository)
 
207
        real_branch = self._format.get_branch_format().initialize(self)
491
208
        if not isinstance(real_branch, RemoteBranch):
492
 
            if not isinstance(repository, RemoteRepository):
493
 
                raise AssertionError(
494
 
                    'need a RemoteRepository to use with RemoteBranch, got %r'
495
 
                    % (repository,))
496
 
            result = RemoteBranch(self, repository, real_branch, name=name)
 
209
            result = RemoteBranch(self, self.find_repository(), real_branch)
497
210
        else:
498
211
            result = real_branch
499
212
        # BzrDir.clone_on_transport() uses the result of create_branch but does
505
218
        self._next_open_branch_result = result
506
219
        return result
507
220
 
508
 
    def destroy_branch(self, name=None):
 
221
    def destroy_branch(self):
509
222
        """See BzrDir.destroy_branch"""
510
223
        self._ensure_real()
511
 
        self._real_bzrdir.destroy_branch(name=name)
 
224
        self._real_bzrdir.destroy_branch()
512
225
        self._next_open_branch_result = None
513
226
 
514
 
    def create_workingtree(self, revision_id=None, from_branch=None,
515
 
        accelerator_tree=None, hardlink=False):
 
227
    def create_workingtree(self, revision_id=None, from_branch=None):
516
228
        raise errors.NotLocalUrl(self.transport.base)
517
229
 
518
 
    def find_branch_format(self, name=None):
 
230
    def find_branch_format(self):
519
231
        """Find the branch 'format' for this bzrdir.
520
232
 
521
233
        This might be a synthetic object for e.g. RemoteBranch and SVN.
522
234
        """
523
 
        b = self.open_branch(name=name)
 
235
        b = self.open_branch()
524
236
        return b._format
525
237
 
526
 
    def get_branch_reference(self, name=None):
 
238
    def get_branch_reference(self):
527
239
        """See BzrDir.get_branch_reference()."""
528
 
        if name is not None:
529
 
            # XXX JRV20100304: Support opening colocated branches
530
 
            raise errors.NoColocatedBranchSupport(self)
531
240
        response = self._get_branch_reference()
532
241
        if response[0] == 'ref':
533
242
            return response[1]
537
246
    def _get_branch_reference(self):
538
247
        path = self._path_for_remote_call(self._client)
539
248
        medium = self._client._medium
540
 
        candidate_calls = [
541
 
            ('BzrDir.open_branchV3', (2, 1)),
542
 
            ('BzrDir.open_branchV2', (1, 13)),
543
 
            ('BzrDir.open_branch', None),
544
 
            ]
545
 
        for verb, required_version in candidate_calls:
546
 
            if required_version and medium._is_remote_before(required_version):
547
 
                continue
 
249
        if not medium._is_remote_before((1, 13)):
548
250
            try:
549
 
                response = self._call(verb, path)
 
251
                response = self._call('BzrDir.open_branchV2', path)
 
252
                if response[0] not in ('ref', 'branch'):
 
253
                    raise errors.UnexpectedSmartServerResponse(response)
 
254
                return response
550
255
            except errors.UnknownSmartMethod:
551
 
                if required_version is None:
552
 
                    raise
553
 
                medium._remember_remote_is_before(required_version)
554
 
            else:
555
 
                break
556
 
        if verb == 'BzrDir.open_branch':
557
 
            if response[0] != 'ok':
558
 
                raise errors.UnexpectedSmartServerResponse(response)
559
 
            if response[1] != '':
560
 
                return ('ref', response[1])
561
 
            else:
562
 
                return ('branch', '')
563
 
        if response[0] not in ('ref', 'branch'):
 
256
                medium._remember_remote_is_before((1, 13))
 
257
        response = self._call('BzrDir.open_branch', path)
 
258
        if response[0] != 'ok':
564
259
            raise errors.UnexpectedSmartServerResponse(response)
565
 
        return response
 
260
        if response[1] != '':
 
261
            return ('ref', response[1])
 
262
        else:
 
263
            return ('branch', '')
566
264
 
567
 
    def _get_tree_branch(self, name=None):
 
265
    def _get_tree_branch(self):
568
266
        """See BzrDir._get_tree_branch()."""
569
 
        return None, self.open_branch(name=name)
 
267
        return None, self.open_branch()
570
268
 
571
 
    def open_branch(self, name=None, unsupported=False,
572
 
                    ignore_fallbacks=False):
573
 
        if unsupported:
 
269
    def open_branch(self, _unsupported=False, ignore_fallbacks=False):
 
270
        if _unsupported:
574
271
            raise NotImplementedError('unsupported flag support not implemented yet.')
575
272
        if self._next_open_branch_result is not None:
576
273
            # See create_branch for details.
581
278
        if response[0] == 'ref':
582
279
            # a branch reference, use the existing BranchReference logic.
583
280
            format = BranchReferenceFormat()
584
 
            return format.open(self, name=name, _found=True,
585
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
 
281
            return format.open(self, _found=True, location=response[1],
 
282
                ignore_fallbacks=ignore_fallbacks)
586
283
        branch_format_name = response[1]
587
284
        if not branch_format_name:
588
285
            branch_format_name = None
589
286
        format = RemoteBranchFormat(network_name=branch_format_name)
590
287
        return RemoteBranch(self, self.find_repository(), format=format,
591
 
            setup_stacking=not ignore_fallbacks, name=name)
 
288
            setup_stacking=not ignore_fallbacks)
592
289
 
593
290
    def _open_repo_v1(self, path):
594
291
        verb = 'BzrDir.find_repository'
655
352
        else:
656
353
            raise errors.NoRepositoryPresent(self)
657
354
 
658
 
    def has_workingtree(self):
659
 
        if self._has_working_tree is None:
660
 
            self._ensure_real()
661
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
662
 
        return self._has_working_tree
663
 
 
664
355
    def open_workingtree(self, recommend_upgrade=True):
665
 
        if self.has_workingtree():
 
356
        self._ensure_real()
 
357
        if self._real_bzrdir.has_workingtree():
666
358
            raise errors.NotLocalUrl(self.root_transport)
667
359
        else:
668
360
            raise errors.NoWorkingTree(self.root_transport.base)
669
361
 
670
362
    def _path_for_remote_call(self, client):
671
363
        """Return the path to be used for this bzrdir in a remote call."""
672
 
        return urlutils.split_segment_parameters_raw(
673
 
            client.remote_path_from_transport(self.root_transport))[0]
 
364
        return client.remote_path_from_transport(self.root_transport)
674
365
 
675
 
    def get_branch_transport(self, branch_format, name=None):
 
366
    def get_branch_transport(self, branch_format):
676
367
        self._ensure_real()
677
 
        return self._real_bzrdir.get_branch_transport(branch_format, name=name)
 
368
        return self._real_bzrdir.get_branch_transport(branch_format)
678
369
 
679
370
    def get_repository_transport(self, repository_format):
680
371
        self._ensure_real()
688
379
        """Upgrading of remote bzrdirs is not supported yet."""
689
380
        return False
690
381
 
691
 
    def needs_format_conversion(self, format):
 
382
    def needs_format_conversion(self, format=None):
692
383
        """Upgrading of remote bzrdirs is not supported yet."""
 
384
        if format is None:
 
385
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
 
386
                % 'needs_format_conversion(format=None)')
693
387
        return False
694
388
 
695
389
    def clone(self, url, revision_id=None, force_new_repo=False,
698
392
        return self._real_bzrdir.clone(url, revision_id=revision_id,
699
393
            force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
700
394
 
701
 
    def _get_config(self):
702
 
        return RemoteBzrDirConfig(self)
703
 
 
704
 
 
705
 
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
 
395
    def get_config(self):
 
396
        self._ensure_real()
 
397
        return self._real_bzrdir.get_config()
 
398
 
 
399
 
 
400
class RemoteRepositoryFormat(repository.RepositoryFormat):
706
401
    """Format for repositories accessed over a _SmartClient.
707
402
 
708
403
    Instances of this repository are represented by RemoteRepository
723
418
    """
724
419
 
725
420
    _matchingbzrdir = RemoteBzrDirFormat()
726
 
    supports_full_versioned_files = True
727
 
    supports_leaving_lock = True
728
421
 
729
422
    def __init__(self):
730
 
        _mod_repository.RepositoryFormat.__init__(self)
 
423
        repository.RepositoryFormat.__init__(self)
731
424
        self._custom_format = None
732
425
        self._network_name = None
733
426
        self._creating_bzrdir = None
734
 
        self._revision_graph_can_have_wrong_parents = None
735
 
        self._supports_chks = None
736
427
        self._supports_external_lookups = None
737
428
        self._supports_tree_reference = None
738
 
        self._supports_funky_characters = None
739
429
        self._rich_root_data = None
740
430
 
741
 
    def __repr__(self):
742
 
        return "%s(_network_name=%r)" % (self.__class__.__name__,
743
 
            self._network_name)
744
 
 
745
431
    @property
746
432
    def fast_deltas(self):
747
433
        self._ensure_real()
755
441
        return self._rich_root_data
756
442
 
757
443
    @property
758
 
    def supports_chks(self):
759
 
        if self._supports_chks is None:
760
 
            self._ensure_real()
761
 
            self._supports_chks = self._custom_format.supports_chks
762
 
        return self._supports_chks
763
 
 
764
 
    @property
765
444
    def supports_external_lookups(self):
766
445
        if self._supports_external_lookups is None:
767
446
            self._ensure_real()
770
449
        return self._supports_external_lookups
771
450
 
772
451
    @property
773
 
    def supports_funky_characters(self):
774
 
        if self._supports_funky_characters is None:
775
 
            self._ensure_real()
776
 
            self._supports_funky_characters = \
777
 
                self._custom_format.supports_funky_characters
778
 
        return self._supports_funky_characters
779
 
 
780
 
    @property
781
452
    def supports_tree_reference(self):
782
453
        if self._supports_tree_reference is None:
783
454
            self._ensure_real()
785
456
                self._custom_format.supports_tree_reference
786
457
        return self._supports_tree_reference
787
458
 
788
 
    @property
789
 
    def revision_graph_can_have_wrong_parents(self):
790
 
        if self._revision_graph_can_have_wrong_parents is None:
791
 
            self._ensure_real()
792
 
            self._revision_graph_can_have_wrong_parents = \
793
 
                self._custom_format.revision_graph_can_have_wrong_parents
794
 
        return self._revision_graph_can_have_wrong_parents
795
 
 
796
459
    def _vfs_initialize(self, a_bzrdir, shared):
797
460
        """Helper for common code in initialize."""
798
461
        if self._custom_format:
829
492
        # 1) get the network name to use.
830
493
        if self._custom_format:
831
494
            network_name = self._custom_format.network_name()
832
 
        elif self._network_name:
833
 
            network_name = self._network_name
834
495
        else:
835
496
            # Select the current bzrlib default and ask for that.
836
 
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
 
497
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
837
498
            reference_format = reference_bzrdir_format.repository_format
838
499
            network_name = reference_format.network_name()
839
500
        # 2) try direct creation via RPC
865
526
 
866
527
    def _ensure_real(self):
867
528
        if self._custom_format is None:
868
 
            self._custom_format = _mod_repository.network_format_registry.get(
 
529
            self._custom_format = repository.network_format_registry.get(
869
530
                self._network_name)
870
531
 
871
532
    @property
884
545
        return self._custom_format._fetch_reconcile
885
546
 
886
547
    def get_format_description(self):
887
 
        self._ensure_real()
888
 
        return 'Remote: ' + self._custom_format.get_format_description()
 
548
        return 'bzr remote repository'
889
549
 
890
550
    def __eq__(self, other):
891
551
        return self.__class__ is other.__class__
892
552
 
 
553
    def check_conversion_target(self, target_format):
 
554
        if self.rich_root_data and not target_format.rich_root_data:
 
555
            raise errors.BadConversionTarget(
 
556
                'Does not support rich root data.', target_format)
 
557
        if (self.supports_tree_reference and
 
558
            not getattr(target_format, 'supports_tree_reference', False)):
 
559
            raise errors.BadConversionTarget(
 
560
                'Does not support nested trees', target_format)
 
561
 
893
562
    def network_name(self):
894
563
        if self._network_name:
895
564
            return self._network_name
897
566
        return self._creating_repo._real_repository._format.network_name()
898
567
 
899
568
    @property
900
 
    def pack_compresses(self):
901
 
        self._ensure_real()
902
 
        return self._custom_format.pack_compresses
903
 
 
904
 
    @property
905
569
    def _serializer(self):
906
570
        self._ensure_real()
907
571
        return self._custom_format._serializer
908
572
 
909
573
 
910
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
911
 
    controldir.ControlComponent):
 
574
class RemoteRepository(_RpcHelper):
912
575
    """Repository accessed over rpc.
913
576
 
914
577
    For the moment most operations are performed using local transport-backed
940
603
        self._lock_token = None
941
604
        self._lock_count = 0
942
605
        self._leave_lock = False
943
 
        # Cache of revision parents; misses are cached during read locks, and
944
 
        # write locks when no _real_repository has been set.
945
606
        self._unstacked_provider = graph.CachingParentsProvider(
946
607
            get_parent_map=self._get_parent_map_rpc)
947
608
        self._unstacked_provider.disable_cache()
957
618
        # Additional places to query for data.
958
619
        self._fallback_repositories = []
959
620
 
960
 
    @property
961
 
    def user_transport(self):
962
 
        return self.bzrdir.user_transport
963
 
 
964
 
    @property
965
 
    def control_transport(self):
966
 
        # XXX: Normally you shouldn't directly get at the remote repository
967
 
        # transport, but I'm not sure it's worth making this method
968
 
        # optional -- mbp 2010-04-21
969
 
        return self.bzrdir.get_repository_transport(None)
970
 
 
971
621
    def __str__(self):
972
622
        return "%s(%s)" % (self.__class__.__name__, self.base)
973
623
 
1016
666
        self._ensure_real()
1017
667
        return self._real_repository.suspend_write_group()
1018
668
 
1019
 
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
1020
 
        self._ensure_real()
1021
 
        return self._real_repository.get_missing_parent_inventories(
1022
 
            check_for_missing_texts=check_for_missing_texts)
1023
 
 
1024
 
    def _get_rev_id_for_revno_vfs(self, revno, known_pair):
1025
 
        self._ensure_real()
1026
 
        return self._real_repository.get_rev_id_for_revno(
1027
 
            revno, known_pair)
1028
 
 
1029
 
    def get_rev_id_for_revno(self, revno, known_pair):
1030
 
        """See Repository.get_rev_id_for_revno."""
1031
 
        path = self.bzrdir._path_for_remote_call(self._client)
1032
 
        try:
1033
 
            if self._client._medium._is_remote_before((1, 17)):
1034
 
                return self._get_rev_id_for_revno_vfs(revno, known_pair)
1035
 
            response = self._call(
1036
 
                'Repository.get_rev_id_for_revno', path, revno, known_pair)
1037
 
        except errors.UnknownSmartMethod:
1038
 
            self._client._medium._remember_remote_is_before((1, 17))
1039
 
            return self._get_rev_id_for_revno_vfs(revno, known_pair)
1040
 
        if response[0] == 'ok':
1041
 
            return True, response[1]
1042
 
        elif response[0] == 'history-incomplete':
1043
 
            known_pair = response[1:3]
1044
 
            for fallback in self._fallback_repositories:
1045
 
                found, result = fallback.get_rev_id_for_revno(revno, known_pair)
1046
 
                if found:
1047
 
                    return True, result
1048
 
                else:
1049
 
                    known_pair = result
1050
 
            # Not found in any fallbacks
1051
 
            return False, known_pair
1052
 
        else:
1053
 
            raise errors.UnexpectedSmartServerResponse(response)
1054
 
 
1055
669
    def _ensure_real(self):
1056
670
        """Ensure that there is a _real_repository set.
1057
671
 
1066
680
        invocation. If in doubt chat to the bzr network team.
1067
681
        """
1068
682
        if self._real_repository is None:
1069
 
            if 'hpssvfs' in debug.debug_flags:
1070
 
                import traceback
1071
 
                warning('VFS Repository access triggered\n%s',
1072
 
                    ''.join(traceback.format_stack()))
1073
 
            self._unstacked_provider.missing_keys.clear()
1074
683
            self.bzrdir._ensure_real()
1075
684
            self._set_real_repository(
1076
685
                self.bzrdir._real_bzrdir.open_repository())
1081
690
    def find_text_key_references(self):
1082
691
        """Find the text key references within the repository.
1083
692
 
 
693
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
 
694
        revision_ids. Each altered file-ids has the exact revision_ids that
 
695
        altered it listed explicitly.
1084
696
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
1085
697
            to whether they were referred to by the inventory of the
1086
698
            revision_id that they contain. The inventory texts from all present
1104
716
        """Private method for using with old (< 1.2) servers to fallback."""
1105
717
        if revision_id is None:
1106
718
            revision_id = ''
1107
 
        elif _mod_revision.is_null(revision_id):
 
719
        elif revision.is_null(revision_id):
1108
720
            return {}
1109
721
 
1110
722
        path = self.bzrdir._path_for_remote_call(self._client)
1133
745
        """Return a source for streaming from this repository."""
1134
746
        return RemoteStreamSource(self, to_format)
1135
747
 
1136
 
    @needs_read_lock
1137
 
    def get_file_graph(self):
1138
 
        return graph.Graph(self.texts)
1139
 
 
1140
 
    @needs_read_lock
1141
748
    def has_revision(self, revision_id):
1142
 
        """True if this repository has a copy of the revision."""
1143
 
        # Copy of bzrlib.repository.Repository.has_revision
1144
 
        return revision_id in self.has_revisions((revision_id,))
 
749
        """See Repository.has_revision()."""
 
750
        if revision_id == NULL_REVISION:
 
751
            # The null revision is always present.
 
752
            return True
 
753
        path = self.bzrdir._path_for_remote_call(self._client)
 
754
        response = self._call('Repository.has_revision', path, revision_id)
 
755
        if response[0] not in ('yes', 'no'):
 
756
            raise errors.UnexpectedSmartServerResponse(response)
 
757
        if response[0] == 'yes':
 
758
            return True
 
759
        for fallback_repo in self._fallback_repositories:
 
760
            if fallback_repo.has_revision(revision_id):
 
761
                return True
 
762
        return False
1145
763
 
1146
 
    @needs_read_lock
1147
764
    def has_revisions(self, revision_ids):
1148
 
        """Probe to find out the presence of multiple revisions.
1149
 
 
1150
 
        :param revision_ids: An iterable of revision_ids.
1151
 
        :return: A set of the revision_ids that were present.
1152
 
        """
1153
 
        # Copy of bzrlib.repository.Repository.has_revisions
1154
 
        parent_map = self.get_parent_map(revision_ids)
1155
 
        result = set(parent_map)
1156
 
        if _mod_revision.NULL_REVISION in revision_ids:
1157
 
            result.add(_mod_revision.NULL_REVISION)
 
765
        """See Repository.has_revisions()."""
 
766
        # FIXME: This does many roundtrips, particularly when there are
 
767
        # fallback repositories.  -- mbp 20080905
 
768
        result = set()
 
769
        for revision_id in revision_ids:
 
770
            if self.has_revision(revision_id):
 
771
                result.add(revision_id)
1158
772
        return result
1159
773
 
1160
 
    def _has_same_fallbacks(self, other_repo):
1161
 
        """Returns true if the repositories have the same fallbacks."""
1162
 
        # XXX: copied from Repository; it should be unified into a base class
1163
 
        # <https://bugs.launchpad.net/bzr/+bug/401622>
1164
 
        my_fb = self._fallback_repositories
1165
 
        other_fb = other_repo._fallback_repositories
1166
 
        if len(my_fb) != len(other_fb):
1167
 
            return False
1168
 
        for f, g in zip(my_fb, other_fb):
1169
 
            if not f.has_same_location(g):
1170
 
                return False
1171
 
        return True
1172
 
 
1173
774
    def has_same_location(self, other):
1174
 
        # TODO: Move to RepositoryBase and unify with the regular Repository
1175
 
        # one; unfortunately the tests rely on slightly different behaviour at
1176
 
        # present -- mbp 20090710
1177
775
        return (self.__class__ is other.__class__ and
1178
776
                self.bzrdir.transport.base == other.bzrdir.transport.base)
1179
777
 
1182
780
        parents_provider = self._make_parents_provider(other_repository)
1183
781
        return graph.Graph(parents_provider)
1184
782
 
1185
 
    @needs_read_lock
1186
 
    def get_known_graph_ancestry(self, revision_ids):
1187
 
        """Return the known graph for a set of revision ids and their ancestors.
1188
 
        """
1189
 
        st = static_tuple.StaticTuple
1190
 
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
1191
 
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
1192
 
        return graph.GraphThunkIdsToKeys(known_graph)
1193
 
 
1194
783
    def gather_stats(self, revid=None, committers=None):
1195
784
        """See Repository.gather_stats()."""
1196
785
        path = self.bzrdir._path_for_remote_call(self._client)
1197
786
        # revid can be None to indicate no revisions, not just NULL_REVISION
1198
 
        if revid is None or _mod_revision.is_null(revid):
 
787
        if revid is None or revision.is_null(revid):
1199
788
            fmt_revid = ''
1200
789
        else:
1201
790
            fmt_revid = revid
1256
845
    def is_write_locked(self):
1257
846
        return self._lock_mode == 'w'
1258
847
 
1259
 
    def _warn_if_deprecated(self, branch=None):
1260
 
        # If we have a real repository, the check will be done there, if we
1261
 
        # don't the check will be done remotely.
1262
 
        pass
1263
 
 
1264
848
    def lock_read(self):
1265
 
        """Lock the repository for read operations.
1266
 
 
1267
 
        :return: A bzrlib.lock.LogicalLockResult.
1268
 
        """
1269
849
        # wrong eventually - want a local lock cache context
1270
850
        if not self._lock_mode:
1271
 
            self._note_lock('r')
1272
851
            self._lock_mode = 'r'
1273
852
            self._lock_count = 1
1274
853
            self._unstacked_provider.enable_cache(cache_misses=True)
1275
854
            if self._real_repository is not None:
1276
855
                self._real_repository.lock_read()
1277
 
            for repo in self._fallback_repositories:
1278
 
                repo.lock_read()
1279
856
        else:
1280
857
            self._lock_count += 1
1281
 
        return lock.LogicalLockResult(self.unlock)
 
858
        for repo in self._fallback_repositories:
 
859
            repo.lock_read()
1282
860
 
1283
861
    def _remote_lock_write(self, token):
1284
862
        path = self.bzrdir._path_for_remote_call(self._client)
1295
873
 
1296
874
    def lock_write(self, token=None, _skip_rpc=False):
1297
875
        if not self._lock_mode:
1298
 
            self._note_lock('w')
1299
876
            if _skip_rpc:
1300
877
                if self._lock_token is not None:
1301
878
                    if token != self._lock_token:
1315
892
                self._leave_lock = False
1316
893
            self._lock_mode = 'w'
1317
894
            self._lock_count = 1
1318
 
            cache_misses = self._real_repository is None
1319
 
            self._unstacked_provider.enable_cache(cache_misses=cache_misses)
1320
 
            for repo in self._fallback_repositories:
1321
 
                # Writes don't affect fallback repos
1322
 
                repo.lock_read()
 
895
            self._unstacked_provider.enable_cache(cache_misses=False)
1323
896
        elif self._lock_mode == 'r':
1324
897
            raise errors.ReadOnlyError(self)
1325
898
        else:
1326
899
            self._lock_count += 1
1327
 
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
 
900
        for repo in self._fallback_repositories:
 
901
            # Writes don't affect fallback repos
 
902
            repo.lock_read()
 
903
        return self._lock_token or None
1328
904
 
1329
905
    def leave_lock_in_place(self):
1330
906
        if not self._lock_token:
1404
980
        else:
1405
981
            raise errors.UnexpectedSmartServerResponse(response)
1406
982
 
1407
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
1408
983
    def unlock(self):
1409
984
        if not self._lock_count:
1410
 
            return lock.cant_unlock_not_held(self)
 
985
            raise errors.LockNotHeld(self)
1411
986
        self._lock_count -= 1
1412
987
        if self._lock_count > 0:
1413
988
            return
1432
1007
                self._lock_token = None
1433
1008
                if not self._leave_lock:
1434
1009
                    self._unlock(old_token)
1435
 
        # Fallbacks are always 'lock_read()' so we don't pay attention to
1436
 
        # self._leave_lock
1437
 
        for repo in self._fallback_repositories:
1438
 
            repo.unlock()
1439
1010
 
1440
1011
    def break_lock(self):
1441
1012
        # should hand off to the network
1484
1055
 
1485
1056
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1486
1057
                           timezone=None, committer=None, revprops=None,
1487
 
                           revision_id=None, lossy=False):
 
1058
                           revision_id=None):
1488
1059
        # FIXME: It ought to be possible to call this without immediately
1489
1060
        # triggering _ensure_real.  For now it's the easiest thing to do.
1490
1061
        self._ensure_real()
1491
1062
        real_repo = self._real_repository
1492
1063
        builder = real_repo.get_commit_builder(branch, parents,
1493
1064
                config, timestamp=timestamp, timezone=timezone,
1494
 
                committer=committer, revprops=revprops,
1495
 
                revision_id=revision_id, lossy=lossy)
 
1065
                committer=committer, revprops=revprops, revision_id=revision_id)
1496
1066
        return builder
1497
1067
 
1498
1068
    def add_fallback_repository(self, repository):
1506
1076
        # We need to accumulate additional repositories here, to pass them in
1507
1077
        # on various RPC's.
1508
1078
        #
1509
 
        if self.is_locked():
1510
 
            # We will call fallback.unlock() when we transition to the unlocked
1511
 
            # state, so always add a lock here. If a caller passes us a locked
1512
 
            # repository, they are responsible for unlocking it later.
1513
 
            repository.lock_read()
1514
 
        self._check_fallback_repository(repository)
1515
1079
        self._fallback_repositories.append(repository)
1516
1080
        # If self._real_repository was parameterised already (e.g. because a
1517
1081
        # _real_branch had its get_stacked_on_url method called), then the
1518
1082
        # repository to be added may already be in the _real_repositories list.
1519
1083
        if self._real_repository is not None:
1520
 
            fallback_locations = [repo.user_url for repo in
 
1084
            fallback_locations = [repo.bzrdir.root_transport.base for repo in
1521
1085
                self._real_repository._fallback_repositories]
1522
 
            if repository.user_url not in fallback_locations:
 
1086
            if repository.bzrdir.root_transport.base not in fallback_locations:
1523
1087
                self._real_repository.add_fallback_repository(repository)
1524
1088
 
1525
 
    def _check_fallback_repository(self, repository):
1526
 
        """Check that this repository can fallback to repository safely.
1527
 
 
1528
 
        Raise an error if not.
1529
 
 
1530
 
        :param repository: A repository to fallback to.
1531
 
        """
1532
 
        return _mod_repository.InterRepository._assert_same_model(
1533
 
            self, repository)
1534
 
 
1535
1089
    def add_inventory(self, revid, inv, parents):
1536
1090
        self._ensure_real()
1537
1091
        return self._real_repository.add_inventory(revid, inv, parents)
1538
1092
 
1539
1093
    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1540
 
            parents, basis_inv=None, propagate_caches=False):
 
1094
                               parents):
1541
1095
        self._ensure_real()
1542
1096
        return self._real_repository.add_inventory_by_delta(basis_revision_id,
1543
 
            delta, new_revision_id, parents, basis_inv=basis_inv,
1544
 
            propagate_caches=propagate_caches)
 
1097
            delta, new_revision_id, parents)
1545
1098
 
1546
1099
    def add_revision(self, rev_id, rev, inv=None, config=None):
1547
1100
        self._ensure_real()
1553
1106
        self._ensure_real()
1554
1107
        return self._real_repository.get_inventory(revision_id)
1555
1108
 
1556
 
    def iter_inventories(self, revision_ids, ordering=None):
 
1109
    def iter_inventories(self, revision_ids):
1557
1110
        self._ensure_real()
1558
 
        return self._real_repository.iter_inventories(revision_ids, ordering)
 
1111
        return self._real_repository.iter_inventories(revision_ids)
1559
1112
 
1560
1113
    @needs_read_lock
1561
1114
    def get_revision(self, revision_id):
1577
1130
        return self._real_repository.make_working_trees()
1578
1131
 
1579
1132
    def refresh_data(self):
1580
 
        """Re-read any data needed to synchronise with disk.
 
1133
        """Re-read any data needed to to synchronise with disk.
1581
1134
 
1582
1135
        This method is intended to be called after another repository instance
1583
1136
        (such as one used by a smart server) has inserted data into the
1584
 
        repository. On all repositories this will work outside of write groups.
1585
 
        Some repository formats (pack and newer for bzrlib native formats)
1586
 
        support refresh_data inside write groups. If called inside a write
1587
 
        group on a repository that does not support refreshing in a write group
1588
 
        IsInWriteGroupError will be raised.
 
1137
        repository. It may not be called during a write group, but may be
 
1138
        called at any other time.
1589
1139
        """
 
1140
        if self.is_in_write_group():
 
1141
            raise errors.InternalBzrError(
 
1142
                "May not refresh_data while in a write group.")
1590
1143
        if self._real_repository is not None:
1591
1144
            self._real_repository.refresh_data()
1592
1145
 
1604
1157
        return result
1605
1158
 
1606
1159
    @needs_read_lock
1607
 
    def search_missing_revision_ids(self, other,
1608
 
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
1609
 
            find_ghosts=True, revision_ids=None, if_present_ids=None,
1610
 
            limit=None):
 
1160
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1611
1161
        """Return the revision ids that other has that this does not.
1612
1162
 
1613
1163
        These are returned in topological order.
1614
1164
 
1615
1165
        revision_id: only return revision ids included by revision_id.
1616
1166
        """
1617
 
        if symbol_versioning.deprecated_passed(revision_id):
1618
 
            symbol_versioning.warn(
1619
 
                'search_missing_revision_ids(revision_id=...) was '
1620
 
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
1621
 
                DeprecationWarning, stacklevel=2)
1622
 
            if revision_ids is not None:
1623
 
                raise AssertionError(
1624
 
                    'revision_ids is mutually exclusive with revision_id')
1625
 
            if revision_id is not None:
1626
 
                revision_ids = [revision_id]
1627
 
        inter_repo = _mod_repository.InterRepository.get(other, self)
1628
 
        return inter_repo.search_missing_revision_ids(
1629
 
            find_ghosts=find_ghosts, revision_ids=revision_ids,
1630
 
            if_present_ids=if_present_ids, limit=limit)
 
1167
        return repository.InterRepository.get(
 
1168
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
1631
1169
 
1632
 
    def fetch(self, source, revision_id=None, find_ghosts=False,
 
1170
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
1633
1171
            fetch_spec=None):
1634
1172
        # No base implementation to use as RemoteRepository is not a subclass
1635
1173
        # of Repository; so this is a copy of Repository.fetch().
1640
1178
            raise errors.InternalBzrError(
1641
1179
                "May not fetch while in a write group.")
1642
1180
        # fast path same-url fetch operations
1643
 
        if (self.has_same_location(source)
1644
 
            and fetch_spec is None
1645
 
            and self._has_same_fallbacks(source)):
 
1181
        if self.has_same_location(source) and fetch_spec is None:
1646
1182
            # check that last_revision is in 'from' and then return a
1647
1183
            # no-operation.
1648
1184
            if (revision_id is not None and
1649
 
                not _mod_revision.is_null(revision_id)):
 
1185
                not revision.is_null(revision_id)):
1650
1186
                self.get_revision(revision_id)
1651
1187
            return 0, []
1652
1188
        # if there is no specific appropriate InterRepository, this will get
1653
1189
        # the InterRepository base class, which raises an
1654
1190
        # IncompatibleRepositories when asked to fetch.
1655
 
        inter = _mod_repository.InterRepository.get(source, self)
1656
 
        return inter.fetch(revision_id=revision_id,
 
1191
        inter = repository.InterRepository.get(source, self)
 
1192
        return inter.fetch(revision_id=revision_id, pb=pb,
1657
1193
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1658
1194
 
1659
1195
    def create_bundle(self, target, base, fileobj, format=None):
1661
1197
        self._real_repository.create_bundle(target, base, fileobj, format)
1662
1198
 
1663
1199
    @needs_read_lock
1664
 
    @symbol_versioning.deprecated_method(
1665
 
        symbol_versioning.deprecated_in((2, 4, 0)))
1666
1200
    def get_ancestry(self, revision_id, topo_sorted=True):
1667
1201
        self._ensure_real()
1668
1202
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1823
1357
        return self._real_repository.get_signature_text(revision_id)
1824
1358
 
1825
1359
    @needs_read_lock
1826
 
    def _get_inventory_xml(self, revision_id):
1827
 
        self._ensure_real()
1828
 
        return self._real_repository._get_inventory_xml(revision_id)
 
1360
    def get_inventory_xml(self, revision_id):
 
1361
        self._ensure_real()
 
1362
        return self._real_repository.get_inventory_xml(revision_id)
 
1363
 
 
1364
    def deserialise_inventory(self, revision_id, xml):
 
1365
        self._ensure_real()
 
1366
        return self._real_repository.deserialise_inventory(revision_id, xml)
1829
1367
 
1830
1368
    def reconcile(self, other=None, thorough=False):
1831
1369
        self._ensure_real()
1858
1396
        return self._real_repository.get_revision_reconcile(revision_id)
1859
1397
 
1860
1398
    @needs_read_lock
1861
 
    def check(self, revision_ids=None, callback_refs=None, check_repo=True):
 
1399
    def check(self, revision_ids=None):
1862
1400
        self._ensure_real()
1863
 
        return self._real_repository.check(revision_ids=revision_ids,
1864
 
            callback_refs=callback_refs, check_repo=check_repo)
 
1401
        return self._real_repository.check(revision_ids=revision_ids)
1865
1402
 
1866
1403
    def copy_content_into(self, destination, revision_id=None):
1867
1404
        self._ensure_real()
1885
1422
            tmpdir = osutils.mkdtemp()
1886
1423
            try:
1887
1424
                _extract_tar(tar, tmpdir)
1888
 
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
 
1425
                tmp_bzrdir = BzrDir.open(tmpdir)
1889
1426
                tmp_repo = tmp_bzrdir.open_repository()
1890
1427
                tmp_repo.copy_content_into(destination, revision_id)
1891
1428
            finally:
1907
1444
        return self._real_repository.inventories
1908
1445
 
1909
1446
    @needs_write_lock
1910
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
1447
    def pack(self):
1911
1448
        """Compress the data within the repository.
1912
1449
 
1913
1450
        This is not currently implemented within the smart server.
1914
1451
        """
1915
1452
        self._ensure_real()
1916
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
1453
        return self._real_repository.pack()
1917
1454
 
1918
1455
    @property
1919
1456
    def revisions(self):
1976
1513
    def supports_rich_root(self):
1977
1514
        return self._format.rich_root_data
1978
1515
 
1979
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1980
1516
    def iter_reverse_revision_history(self, revision_id):
1981
1517
        self._ensure_real()
1982
1518
        return self._real_repository.iter_reverse_revision_history(revision_id)
2003
1539
        return self._real_repository.item_keys_introduced_by(revision_ids,
2004
1540
            _files_pb=_files_pb)
2005
1541
 
2006
 
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
2007
 
        self._ensure_real()
2008
 
        return self._real_repository._find_inconsistent_revision_parents(
2009
 
            revisions_iterator)
 
1542
    def revision_graph_can_have_wrong_parents(self):
 
1543
        # The answer depends on the remote repo format.
 
1544
        self._ensure_real()
 
1545
        return self._real_repository.revision_graph_can_have_wrong_parents()
 
1546
 
 
1547
    def _find_inconsistent_revision_parents(self):
 
1548
        self._ensure_real()
 
1549
        return self._real_repository._find_inconsistent_revision_parents()
2010
1550
 
2011
1551
    def _check_for_inconsistent_revision_parents(self):
2012
1552
        self._ensure_real()
2016
1556
        providers = [self._unstacked_provider]
2017
1557
        if other is not None:
2018
1558
            providers.insert(0, other)
2019
 
        return graph.StackedParentsProvider(_LazyListJoin(
2020
 
            providers, self._fallback_repositories))
 
1559
        providers.extend(r._make_parents_provider() for r in
 
1560
                         self._fallback_repositories)
 
1561
        return graph._StackedParentsProvider(providers)
2021
1562
 
2022
1563
    def _serialise_search_recipe(self, recipe):
2023
1564
        """Serialise a graph search recipe.
2031
1572
        return '\n'.join((start_keys, stop_keys, count))
2032
1573
 
2033
1574
    def _serialise_search_result(self, search_result):
2034
 
        parts = search_result.get_network_struct()
 
1575
        if isinstance(search_result, graph.PendingAncestryResult):
 
1576
            parts = ['ancestry-of']
 
1577
            parts.extend(search_result.heads)
 
1578
        else:
 
1579
            recipe = search_result.get_recipe()
 
1580
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
2035
1581
        return '\n'.join(parts)
2036
1582
 
2037
1583
    def autopack(self):
2047
1593
            raise errors.UnexpectedSmartServerResponse(response)
2048
1594
 
2049
1595
 
2050
 
class RemoteStreamSink(vf_repository.StreamSink):
 
1596
class RemoteStreamSink(repository.StreamSink):
2051
1597
 
2052
1598
    def _insert_real(self, stream, src_format, resume_tokens):
2053
1599
        self.target_repo._ensure_real()
2059
1605
 
2060
1606
    def insert_stream(self, stream, src_format, resume_tokens):
2061
1607
        target = self.target_repo
2062
 
        target._unstacked_provider.missing_keys.clear()
2063
 
        candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
2064
1608
        if target._lock_token:
2065
 
            candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
2066
 
            lock_args = (target._lock_token or '',)
 
1609
            verb = 'Repository.insert_stream_locked'
 
1610
            extra_args = (target._lock_token or '',)
 
1611
            required_version = (1, 14)
2067
1612
        else:
2068
 
            candidate_calls.append(('Repository.insert_stream', (1, 13)))
2069
 
            lock_args = ()
 
1613
            verb = 'Repository.insert_stream'
 
1614
            extra_args = ()
 
1615
            required_version = (1, 13)
2070
1616
        client = target._client
2071
1617
        medium = client._medium
 
1618
        if medium._is_remote_before(required_version):
 
1619
            # No possible way this can work.
 
1620
            return self._insert_real(stream, src_format, resume_tokens)
2072
1621
        path = target.bzrdir._path_for_remote_call(client)
2073
 
        # Probe for the verb to use with an empty stream before sending the
2074
 
        # real stream to it.  We do this both to avoid the risk of sending a
2075
 
        # large request that is then rejected, and because we don't want to
2076
 
        # implement a way to buffer, rewind, or restart the stream.
2077
 
        found_verb = False
2078
 
        for verb, required_version in candidate_calls:
2079
 
            if medium._is_remote_before(required_version):
2080
 
                continue
2081
 
            if resume_tokens:
2082
 
                # We've already done the probing (and set _is_remote_before) on
2083
 
                # a previous insert.
2084
 
                found_verb = True
2085
 
                break
 
1622
        if not resume_tokens:
 
1623
            # XXX: Ugly but important for correctness, *will* be fixed during
 
1624
            # 1.13 cycle. Pushing a stream that is interrupted results in a
 
1625
            # fallback to the _real_repositories sink *with a partial stream*.
 
1626
            # Thats bad because we insert less data than bzr expected. To avoid
 
1627
            # this we do a trial push to make sure the verb is accessible, and
 
1628
            # do not fallback when actually pushing the stream. A cleanup patch
 
1629
            # is going to look at rewinding/restarting the stream/partial
 
1630
            # buffering etc.
2086
1631
            byte_stream = smart_repo._stream_to_byte_stream([], src_format)
2087
1632
            try:
2088
1633
                response = client.call_with_body_stream(
2089
 
                    (verb, path, '') + lock_args, byte_stream)
 
1634
                    (verb, path, '') + extra_args, byte_stream)
2090
1635
            except errors.UnknownSmartMethod:
2091
1636
                medium._remember_remote_is_before(required_version)
2092
 
            else:
2093
 
                found_verb = True
2094
 
                break
2095
 
        if not found_verb:
2096
 
            # Have to use VFS.
2097
 
            return self._insert_real(stream, src_format, resume_tokens)
2098
 
        self._last_inv_record = None
2099
 
        self._last_substream = None
2100
 
        if required_version < (1, 19):
2101
 
            # Remote side doesn't support inventory deltas.  Wrap the stream to
2102
 
            # make sure we don't send any.  If the stream contains inventory
2103
 
            # deltas we'll interrupt the smart insert_stream request and
2104
 
            # fallback to VFS.
2105
 
            stream = self._stop_stream_if_inventory_delta(stream)
 
1637
                return self._insert_real(stream, src_format, resume_tokens)
2106
1638
        byte_stream = smart_repo._stream_to_byte_stream(
2107
1639
            stream, src_format)
2108
1640
        resume_tokens = ' '.join(resume_tokens)
2109
1641
        response = client.call_with_body_stream(
2110
 
            (verb, path, resume_tokens) + lock_args, byte_stream)
 
1642
            (verb, path, resume_tokens) + extra_args, byte_stream)
2111
1643
        if response[0][0] not in ('ok', 'missing-basis'):
2112
1644
            raise errors.UnexpectedSmartServerResponse(response)
2113
 
        if self._last_substream is not None:
2114
 
            # The stream included an inventory-delta record, but the remote
2115
 
            # side isn't new enough to support them.  So we need to send the
2116
 
            # rest of the stream via VFS.
2117
 
            self.target_repo.refresh_data()
2118
 
            return self._resume_stream_with_vfs(response, src_format)
2119
1645
        if response[0][0] == 'missing-basis':
2120
1646
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
2121
1647
            resume_tokens = tokens
2122
 
            return resume_tokens, set(missing_keys)
 
1648
            return resume_tokens, missing_keys
2123
1649
        else:
2124
1650
            self.target_repo.refresh_data()
2125
1651
            return [], set()
2126
1652
 
2127
 
    def _resume_stream_with_vfs(self, response, src_format):
2128
 
        """Resume sending a stream via VFS, first resending the record and
2129
 
        substream that couldn't be sent via an insert_stream verb.
2130
 
        """
2131
 
        if response[0][0] == 'missing-basis':
2132
 
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
2133
 
            # Ignore missing_keys, we haven't finished inserting yet
2134
 
        else:
2135
 
            tokens = []
2136
 
        def resume_substream():
2137
 
            # Yield the substream that was interrupted.
2138
 
            for record in self._last_substream:
2139
 
                yield record
2140
 
            self._last_substream = None
2141
 
        def resume_stream():
2142
 
            # Finish sending the interrupted substream
2143
 
            yield ('inventory-deltas', resume_substream())
2144
 
            # Then simply continue sending the rest of the stream.
2145
 
            for substream_kind, substream in self._last_stream:
2146
 
                yield substream_kind, substream
2147
 
        return self._insert_real(resume_stream(), src_format, tokens)
2148
 
 
2149
 
    def _stop_stream_if_inventory_delta(self, stream):
2150
 
        """Normally this just lets the original stream pass-through unchanged.
2151
 
 
2152
 
        However if any 'inventory-deltas' substream occurs it will stop
2153
 
        streaming, and store the interrupted substream and stream in
2154
 
        self._last_substream and self._last_stream so that the stream can be
2155
 
        resumed by _resume_stream_with_vfs.
2156
 
        """
2157
 
 
2158
 
        stream_iter = iter(stream)
2159
 
        for substream_kind, substream in stream_iter:
2160
 
            if substream_kind == 'inventory-deltas':
2161
 
                self._last_substream = substream
2162
 
                self._last_stream = stream_iter
2163
 
                return
2164
 
            else:
2165
 
                yield substream_kind, substream
2166
 
 
2167
 
 
2168
 
class RemoteStreamSource(vf_repository.StreamSource):
 
1653
 
 
1654
class RemoteStreamSource(repository.StreamSource):
2169
1655
    """Stream data from a remote server."""
2170
1656
 
2171
1657
    def get_stream(self, search):
2172
1658
        if (self.from_repository._fallback_repositories and
2173
1659
            self.to_format._fetch_order == 'topological'):
2174
1660
            return self._real_stream(self.from_repository, search)
2175
 
        sources = []
2176
 
        seen = set()
2177
 
        repos = [self.from_repository]
2178
 
        while repos:
2179
 
            repo = repos.pop(0)
2180
 
            if repo in seen:
2181
 
                continue
2182
 
            seen.add(repo)
2183
 
            repos.extend(repo._fallback_repositories)
2184
 
            sources.append(repo)
2185
 
        return self.missing_parents_chain(search, sources)
2186
 
 
2187
 
    def get_stream_for_missing_keys(self, missing_keys):
2188
 
        self.from_repository._ensure_real()
2189
 
        real_repo = self.from_repository._real_repository
2190
 
        real_source = real_repo._get_source(self.to_format)
2191
 
        return real_source.get_stream_for_missing_keys(missing_keys)
 
1661
        return self.missing_parents_chain(search, [self.from_repository] +
 
1662
            self.from_repository._fallback_repositories)
2192
1663
 
2193
1664
    def _real_stream(self, repo, search):
2194
1665
        """Get a stream for search from repo.
2201
1672
        """
2202
1673
        source = repo._get_source(self.to_format)
2203
1674
        if isinstance(source, RemoteStreamSource):
2204
 
            repo._ensure_real()
2205
 
            source = repo._real_repository._get_source(self.to_format)
 
1675
            return repository.StreamSource.get_stream(source, search)
2206
1676
        return source.get_stream(search)
2207
1677
 
2208
1678
    def _get_stream(self, repo, search):
2225
1695
            return self._real_stream(repo, search)
2226
1696
        client = repo._client
2227
1697
        medium = client._medium
 
1698
        if medium._is_remote_before((1, 13)):
 
1699
            # streaming was added in 1.13
 
1700
            return self._real_stream(repo, search)
2228
1701
        path = repo.bzrdir._path_for_remote_call(client)
2229
 
        search_bytes = repo._serialise_search_result(search)
2230
 
        args = (path, self.to_format.network_name())
2231
 
        candidate_verbs = [
2232
 
            ('Repository.get_stream_1.19', (1, 19)),
2233
 
            ('Repository.get_stream', (1, 13))]
2234
 
 
2235
 
        found_verb = False
2236
 
        for verb, version in candidate_verbs:
2237
 
            if medium._is_remote_before(version):
2238
 
                continue
2239
 
            try:
2240
 
                response = repo._call_with_body_bytes_expecting_body(
2241
 
                    verb, args, search_bytes)
2242
 
            except errors.UnknownSmartMethod:
2243
 
                medium._remember_remote_is_before(version)
2244
 
            except errors.UnknownErrorFromSmartServer, e:
2245
 
                if isinstance(search, graph.EverythingResult):
2246
 
                    error_verb = e.error_from_smart_server.error_verb
2247
 
                    if error_verb == 'BadSearch':
2248
 
                        # Pre-2.4 servers don't support this sort of search.
2249
 
                        # XXX: perhaps falling back to VFS on BadSearch is a
2250
 
                        # good idea in general?  It might provide a little bit
2251
 
                        # of protection against client-side bugs.
2252
 
                        medium._remember_remote_is_before((2, 4))
2253
 
                        break
2254
 
                raise
2255
 
            else:
2256
 
                response_tuple, response_handler = response
2257
 
                found_verb = True
2258
 
                break
2259
 
        if not found_verb:
 
1702
        try:
 
1703
            search_bytes = repo._serialise_search_result(search)
 
1704
            response = repo._call_with_body_bytes_expecting_body(
 
1705
                'Repository.get_stream',
 
1706
                (path, self.to_format.network_name()), search_bytes)
 
1707
            response_tuple, response_handler = response
 
1708
        except errors.UnknownSmartMethod:
 
1709
            medium._remember_remote_is_before((1,13))
2260
1710
            return self._real_stream(repo, search)
2261
1711
        if response_tuple[0] != 'ok':
2262
1712
            raise errors.UnexpectedSmartServerResponse(response_tuple)
2263
1713
        byte_stream = response_handler.read_streamed_body()
2264
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
2265
 
            self._record_counter)
 
1714
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
2266
1715
        if src_format.network_name() != repo._format.network_name():
2267
1716
            raise AssertionError(
2268
1717
                "Mismatched RemoteRepository and stream src %r, %r" % (
2275
1724
        :param search: The overall search to satisfy with streams.
2276
1725
        :param sources: A list of Repository objects to query.
2277
1726
        """
2278
 
        self.from_serialiser = self.from_repository._format._serializer
 
1727
        self.serialiser = self.to_format._serializer
2279
1728
        self.seen_revs = set()
2280
1729
        self.referenced_revs = set()
2281
1730
        # If there are heads in the search, or the key count is > 0, we are not
2298
1747
    def missing_parents_rev_handler(self, substream):
2299
1748
        for content in substream:
2300
1749
            revision_bytes = content.get_bytes_as('fulltext')
2301
 
            revision = self.from_serialiser.read_revision_from_string(
2302
 
                revision_bytes)
 
1750
            revision = self.serialiser.read_revision_from_string(revision_bytes)
2303
1751
            self.seen_revs.add(content.key[-1])
2304
1752
            self.referenced_revs.update(revision.parent_ids)
2305
1753
            yield content
2344
1792
                self._network_name)
2345
1793
 
2346
1794
    def get_format_description(self):
2347
 
        self._ensure_real()
2348
 
        return 'Remote: ' + self._custom_format.get_format_description()
 
1795
        return 'Remote BZR Branch'
2349
1796
 
2350
1797
    def network_name(self):
2351
1798
        return self._network_name
2352
1799
 
2353
 
    def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2354
 
        return a_bzrdir.open_branch(name=name, 
2355
 
            ignore_fallbacks=ignore_fallbacks)
 
1800
    def open(self, a_bzrdir, ignore_fallbacks=False):
 
1801
        return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
2356
1802
 
2357
 
    def _vfs_initialize(self, a_bzrdir, name):
 
1803
    def _vfs_initialize(self, a_bzrdir):
2358
1804
        # Initialisation when using a local bzrdir object, or a non-vfs init
2359
1805
        # method is not available on the server.
2360
1806
        # self._custom_format is always set - the start of initialize ensures
2361
1807
        # that.
2362
1808
        if isinstance(a_bzrdir, RemoteBzrDir):
2363
1809
            a_bzrdir._ensure_real()
2364
 
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2365
 
                name)
 
1810
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
2366
1811
        else:
2367
1812
            # We assume the bzrdir is parameterised; it may not be.
2368
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
1813
            result = self._custom_format.initialize(a_bzrdir)
2369
1814
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2370
1815
            not isinstance(result, RemoteBranch)):
2371
 
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2372
 
                                  name=name)
 
1816
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
2373
1817
        return result
2374
1818
 
2375
 
    def initialize(self, a_bzrdir, name=None, repository=None):
 
1819
    def initialize(self, a_bzrdir):
2376
1820
        # 1) get the network name to use.
2377
1821
        if self._custom_format:
2378
1822
            network_name = self._custom_format.network_name()
2379
1823
        else:
2380
1824
            # Select the current bzrlib default and ask for that.
2381
 
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
 
1825
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
2382
1826
            reference_format = reference_bzrdir_format.get_branch_format()
2383
1827
            self._custom_format = reference_format
2384
1828
            network_name = reference_format.network_name()
2385
1829
        # Being asked to create on a non RemoteBzrDir:
2386
1830
        if not isinstance(a_bzrdir, RemoteBzrDir):
2387
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
1831
            return self._vfs_initialize(a_bzrdir)
2388
1832
        medium = a_bzrdir._client._medium
2389
1833
        if medium._is_remote_before((1, 13)):
2390
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
1834
            return self._vfs_initialize(a_bzrdir)
2391
1835
        # Creating on a remote bzr dir.
2392
1836
        # 2) try direct creation via RPC
2393
1837
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2394
 
        if name is not None:
2395
 
            # XXX JRV20100304: Support creating colocated branches
2396
 
            raise errors.NoColocatedBranchSupport(self)
2397
1838
        verb = 'BzrDir.create_branch'
2398
1839
        try:
2399
1840
            response = a_bzrdir._call(verb, path, network_name)
2400
1841
        except errors.UnknownSmartMethod:
2401
1842
            # Fallback - use vfs methods
2402
1843
            medium._remember_remote_is_before((1, 13))
2403
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
1844
            return self._vfs_initialize(a_bzrdir)
2404
1845
        if response[0] != 'ok':
2405
1846
            raise errors.UnexpectedSmartServerResponse(response)
2406
1847
        # Turn the response into a RemoteRepository object.
2407
1848
        format = RemoteBranchFormat(network_name=response[1])
2408
1849
        repo_format = response_tuple_to_repo_format(response[3:])
2409
 
        repo_path = response[2]
2410
 
        if repository is not None:
2411
 
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
2412
 
            url_diff = urlutils.relative_url(repository.user_url,
2413
 
                    remote_repo_url)
2414
 
            if url_diff != '.':
2415
 
                raise AssertionError(
2416
 
                    'repository.user_url %r does not match URL from server '
2417
 
                    'response (%r + %r)'
2418
 
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
2419
 
            remote_repo = repository
 
1850
        if response[2] == '':
 
1851
            repo_bzrdir = a_bzrdir
2420
1852
        else:
2421
 
            if repo_path == '':
2422
 
                repo_bzrdir = a_bzrdir
2423
 
            else:
2424
 
                repo_bzrdir = RemoteBzrDir(
2425
 
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
2426
 
                    a_bzrdir._client)
2427
 
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
1853
            repo_bzrdir = RemoteBzrDir(
 
1854
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
 
1855
                a_bzrdir._client)
 
1856
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2428
1857
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2429
 
            format=format, setup_stacking=False, name=name)
 
1858
            format=format, setup_stacking=False)
2430
1859
        # XXX: We know this is a new branch, so it must have revno 0, revid
2431
1860
        # NULL_REVISION. Creating the branch locked would make this be unable
2432
1861
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2447
1876
        self._ensure_real()
2448
1877
        return self._custom_format.supports_stacking()
2449
1878
 
2450
 
    def supports_set_append_revisions_only(self):
2451
 
        self._ensure_real()
2452
 
        return self._custom_format.supports_set_append_revisions_only()
2453
 
 
2454
 
    def _use_default_local_heads_to_fetch(self):
2455
 
        # If the branch format is a metadir format *and* its heads_to_fetch
2456
 
        # implementation is not overridden vs the base class, we can use the
2457
 
        # base class logic rather than use the heads_to_fetch RPC.  This is
2458
 
        # usually cheaper in terms of net round trips, as the last-revision and
2459
 
        # tags info fetched is cached and would be fetched anyway.
2460
 
        self._ensure_real()
2461
 
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
2462
 
            branch_class = self._custom_format._branch_class()
2463
 
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
2464
 
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
2465
 
                return True
2466
 
        return False
2467
 
 
2468
 
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
 
1879
 
 
1880
class RemoteBranch(branch.Branch, _RpcHelper):
2469
1881
    """Branch stored on a server accessed by HPSS RPC.
2470
1882
 
2471
1883
    At the moment most operations are mapped down to simple file operations.
2472
1884
    """
2473
1885
 
2474
1886
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2475
 
        _client=None, format=None, setup_stacking=True, name=None):
 
1887
        _client=None, format=None, setup_stacking=True):
2476
1888
        """Create a RemoteBranch instance.
2477
1889
 
2478
1890
        :param real_branch: An optional local implementation of the branch
2484
1896
        :param setup_stacking: If True make an RPC call to determine the
2485
1897
            stacked (or not) status of the branch. If False assume the branch
2486
1898
            is not stacked.
2487
 
        :param name: Colocated branch name
2488
1899
        """
2489
1900
        # We intentionally don't call the parent class's __init__, because it
2490
1901
        # will try to assign to self.tags, which is a property in this subclass.
2491
1902
        # And the parent's __init__ doesn't do much anyway.
 
1903
        self._revision_id_to_revno_cache = None
 
1904
        self._partial_revision_id_to_revno_cache = {}
 
1905
        self._revision_history_cache = None
 
1906
        self._last_revision_info_cache = None
 
1907
        self._merge_sorted_revisions_cache = None
2492
1908
        self.bzrdir = remote_bzrdir
2493
1909
        if _client is not None:
2494
1910
            self._client = _client
2508
1924
        else:
2509
1925
            self._real_branch = None
2510
1926
        # Fill out expected attributes of branch for bzrlib API users.
2511
 
        self._clear_cached_state()
2512
 
        # TODO: deprecate self.base in favor of user_url
2513
 
        self.base = self.bzrdir.user_url
2514
 
        self._name = name
 
1927
        self.base = self.bzrdir.root_transport.base
2515
1928
        self._control_files = None
2516
1929
        self._lock_mode = None
2517
1930
        self._lock_token = None
2528
1941
                    self._real_branch._format.network_name()
2529
1942
        else:
2530
1943
            self._format = format
2531
 
        # when we do _ensure_real we may need to pass ignore_fallbacks to the
2532
 
        # branch.open_branch method.
2533
 
        self._real_ignore_fallbacks = not setup_stacking
2534
1944
        if not self._format._network_name:
2535
1945
            # Did not get from open_branchV2 - old server.
2536
1946
            self._ensure_real()
2541
1951
        hooks = branch.Branch.hooks['open']
2542
1952
        for hook in hooks:
2543
1953
            hook(self)
2544
 
        self._is_stacked = False
2545
1954
        if setup_stacking:
2546
1955
            self._setup_stacking()
2547
1956
 
2553
1962
        except (errors.NotStacked, errors.UnstackableBranchFormat,
2554
1963
            errors.UnstackableRepositoryFormat), e:
2555
1964
            return
2556
 
        self._is_stacked = True
2557
1965
        self._activate_fallback_location(fallback_url)
2558
1966
 
2559
1967
    def _get_config(self):
2581
1989
                raise AssertionError('smart server vfs must be enabled '
2582
1990
                    'to use vfs implementation')
2583
1991
            self.bzrdir._ensure_real()
2584
 
            self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2585
 
                ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
 
1992
            self._real_branch = self.bzrdir._real_bzrdir.open_branch()
2586
1993
            if self.repository._real_repository is None:
2587
1994
                # Give the remote repository the matching real repo.
2588
1995
                real_repo = self._real_branch.repository
2662
2069
            raise errors.UnexpectedSmartServerResponse(response)
2663
2070
        return response[1]
2664
2071
 
2665
 
    def set_stacked_on_url(self, url):
2666
 
        branch.Branch.set_stacked_on_url(self, url)
2667
 
        if not url:
2668
 
            self._is_stacked = False
2669
 
        else:
2670
 
            self._is_stacked = True
2671
 
 
2672
2072
    def _vfs_get_tags_bytes(self):
2673
2073
        self._ensure_real()
2674
2074
        return self._real_branch._get_tags_bytes()
2675
2075
 
2676
 
    @needs_read_lock
2677
2076
    def _get_tags_bytes(self):
2678
 
        if self._tags_bytes is None:
2679
 
            self._tags_bytes = self._get_tags_bytes_via_hpss()
2680
 
        return self._tags_bytes
2681
 
 
2682
 
    def _get_tags_bytes_via_hpss(self):
2683
2077
        medium = self._client._medium
2684
2078
        if medium._is_remote_before((1, 13)):
2685
2079
            return self._vfs_get_tags_bytes()
2690
2084
            return self._vfs_get_tags_bytes()
2691
2085
        return response[0]
2692
2086
 
2693
 
    def _vfs_set_tags_bytes(self, bytes):
2694
 
        self._ensure_real()
2695
 
        return self._real_branch._set_tags_bytes(bytes)
2696
 
 
2697
 
    def _set_tags_bytes(self, bytes):
2698
 
        if self.is_locked():
2699
 
            self._tags_bytes = bytes
2700
 
        medium = self._client._medium
2701
 
        if medium._is_remote_before((1, 18)):
2702
 
            self._vfs_set_tags_bytes(bytes)
2703
 
            return
2704
 
        try:
2705
 
            args = (
2706
 
                self._remote_path(), self._lock_token, self._repo_lock_token)
2707
 
            response = self._call_with_body_bytes(
2708
 
                'Branch.set_tags_bytes', args, bytes)
2709
 
        except errors.UnknownSmartMethod:
2710
 
            medium._remember_remote_is_before((1, 18))
2711
 
            self._vfs_set_tags_bytes(bytes)
2712
 
 
2713
2087
    def lock_read(self):
2714
 
        """Lock the branch for read operations.
2715
 
 
2716
 
        :return: A bzrlib.lock.LogicalLockResult.
2717
 
        """
2718
2088
        self.repository.lock_read()
2719
2089
        if not self._lock_mode:
2720
 
            self._note_lock('r')
2721
2090
            self._lock_mode = 'r'
2722
2091
            self._lock_count = 1
2723
2092
            if self._real_branch is not None:
2724
2093
                self._real_branch.lock_read()
2725
2094
        else:
2726
2095
            self._lock_count += 1
2727
 
        return lock.LogicalLockResult(self.unlock)
2728
2096
 
2729
2097
    def _remote_lock_write(self, token):
2730
2098
        if token is None:
2731
2099
            branch_token = repo_token = ''
2732
2100
        else:
2733
2101
            branch_token = token
2734
 
            repo_token = self.repository.lock_write().repository_token
 
2102
            repo_token = self.repository.lock_write()
2735
2103
            self.repository.unlock()
2736
2104
        err_context = {'token': token}
2737
 
        try:
2738
 
            response = self._call(
2739
 
                'Branch.lock_write', self._remote_path(), branch_token,
2740
 
                repo_token or '', **err_context)
2741
 
        except errors.LockContention, e:
2742
 
            # The LockContention from the server doesn't have any
2743
 
            # information about the lock_url. We re-raise LockContention
2744
 
            # with valid lock_url.
2745
 
            raise errors.LockContention('(remote lock)',
2746
 
                self.repository.base.split('.bzr/')[0])
 
2105
        response = self._call(
 
2106
            'Branch.lock_write', self._remote_path(), branch_token,
 
2107
            repo_token or '', **err_context)
2747
2108
        if response[0] != 'ok':
2748
2109
            raise errors.UnexpectedSmartServerResponse(response)
2749
2110
        ok, branch_token, repo_token = response
2751
2112
 
2752
2113
    def lock_write(self, token=None):
2753
2114
        if not self._lock_mode:
2754
 
            self._note_lock('w')
2755
2115
            # Lock the branch and repo in one remote call.
2756
2116
            remote_tokens = self._remote_lock_write(token)
2757
2117
            self._lock_token, self._repo_lock_token = remote_tokens
2770
2130
            self._lock_mode = 'w'
2771
2131
            self._lock_count = 1
2772
2132
        elif self._lock_mode == 'r':
2773
 
            raise errors.ReadOnlyError(self)
 
2133
            raise errors.ReadOnlyTransaction
2774
2134
        else:
2775
2135
            if token is not None:
2776
2136
                # A token was given to lock_write, and we're relocking, so
2781
2141
            self._lock_count += 1
2782
2142
            # Re-lock the repository too.
2783
2143
            self.repository.lock_write(self._repo_lock_token)
2784
 
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
 
2144
        return self._lock_token or None
 
2145
 
 
2146
    def _set_tags_bytes(self, bytes):
 
2147
        self._ensure_real()
 
2148
        return self._real_branch._set_tags_bytes(bytes)
2785
2149
 
2786
2150
    def _unlock(self, branch_token, repo_token):
2787
2151
        err_context = {'token': str((branch_token, repo_token))}
2792
2156
            return
2793
2157
        raise errors.UnexpectedSmartServerResponse(response)
2794
2158
 
2795
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2796
2159
    def unlock(self):
2797
2160
        try:
2798
2161
            self._lock_count -= 1
2838
2201
            raise NotImplementedError(self.dont_leave_lock_in_place)
2839
2202
        self._leave_lock = False
2840
2203
 
2841
 
    @needs_read_lock
2842
 
    def get_rev_id(self, revno, history=None):
2843
 
        if revno == 0:
2844
 
            return _mod_revision.NULL_REVISION
2845
 
        last_revision_info = self.last_revision_info()
2846
 
        ok, result = self.repository.get_rev_id_for_revno(
2847
 
            revno, last_revision_info)
2848
 
        if ok:
2849
 
            return result
2850
 
        missing_parent = result[1]
2851
 
        # Either the revision named by the server is missing, or its parent
2852
 
        # is.  Call get_parent_map to determine which, so that we report a
2853
 
        # useful error.
2854
 
        parent_map = self.repository.get_parent_map([missing_parent])
2855
 
        if missing_parent in parent_map:
2856
 
            missing_parent = parent_map[missing_parent]
2857
 
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2858
 
 
2859
 
    def _read_last_revision_info(self):
 
2204
    def _last_revision_info(self):
2860
2205
        response = self._call('Branch.last_revision_info', self._remote_path())
2861
2206
        if response[0] != 'ok':
2862
2207
            raise SmartProtocolError('unexpected response code %s' % (response,))
2866
2211
 
2867
2212
    def _gen_revision_history(self):
2868
2213
        """See Branch._gen_revision_history()."""
2869
 
        if self._is_stacked:
2870
 
            self._ensure_real()
2871
 
            return self._real_branch._gen_revision_history()
2872
2214
        response_tuple, response_handler = self._call_expecting_body(
2873
2215
            'Branch.revision_history', self._remote_path())
2874
2216
        if response_tuple[0] != 'ok':
2925
2267
            raise errors.UnexpectedSmartServerResponse(response)
2926
2268
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2927
2269
 
2928
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2929
2270
    @needs_write_lock
2930
2271
    def set_revision_history(self, rev_history):
2931
 
        """See Branch.set_revision_history."""
2932
 
        self._set_revision_history(rev_history)
2933
 
 
2934
 
    @needs_write_lock
2935
 
    def _set_revision_history(self, rev_history):
2936
2272
        # Send just the tip revision of the history; the server will generate
2937
2273
        # the full history from that.  If the revision doesn't exist in this
2938
2274
        # branch, NoSuchRevision will be raised.
2965
2301
        self._ensure_real()
2966
2302
        return self._real_branch._get_parent_location()
2967
2303
 
 
2304
    def set_parent(self, url):
 
2305
        self._ensure_real()
 
2306
        return self._real_branch.set_parent(url)
 
2307
 
2968
2308
    def _set_parent_location(self, url):
2969
 
        medium = self._client._medium
2970
 
        if medium._is_remote_before((1, 15)):
2971
 
            return self._vfs_set_parent_location(url)
2972
 
        try:
2973
 
            call_url = url or ''
2974
 
            if type(call_url) is not str:
2975
 
                raise AssertionError('url must be a str or None (%s)' % url)
2976
 
            response = self._call('Branch.set_parent_location',
2977
 
                self._remote_path(), self._lock_token, self._repo_lock_token,
2978
 
                call_url)
2979
 
        except errors.UnknownSmartMethod:
2980
 
            medium._remember_remote_is_before((1, 15))
2981
 
            return self._vfs_set_parent_location(url)
2982
 
        if response != ():
2983
 
            raise errors.UnexpectedSmartServerResponse(response)
2984
 
 
2985
 
    def _vfs_set_parent_location(self, url):
2986
 
        self._ensure_real()
2987
 
        return self._real_branch._set_parent_location(url)
 
2309
        # Used by tests, to poke bad urls into branch configurations
 
2310
        if url is None:
 
2311
            self.set_parent(url)
 
2312
        else:
 
2313
            self._ensure_real()
 
2314
            return self._real_branch._set_parent_location(url)
2988
2315
 
2989
2316
    @needs_write_lock
2990
2317
    def pull(self, source, overwrite=False, stop_revision=None,
2996
2323
            _override_hook_target=self, **kwargs)
2997
2324
 
2998
2325
    @needs_read_lock
2999
 
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
 
2326
    def push(self, target, overwrite=False, stop_revision=None):
3000
2327
        self._ensure_real()
3001
2328
        return self._real_branch.push(
3002
 
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
 
2329
            target, overwrite=overwrite, stop_revision=stop_revision,
3003
2330
            _override_hook_source_branch=self)
3004
2331
 
3005
2332
    def is_locked(self):
3015
2342
        # XXX: These should be returned by the set_last_revision_info verb
3016
2343
        old_revno, old_revid = self.last_revision_info()
3017
2344
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
3018
 
        if not revision_id or not isinstance(revision_id, basestring):
3019
 
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
 
2345
        revision_id = ensure_null(revision_id)
3020
2346
        try:
3021
2347
            response = self._call('Branch.set_last_revision_info',
3022
2348
                self._remote_path(), self._lock_token, self._repo_lock_token,
3051
2377
            except errors.UnknownSmartMethod:
3052
2378
                medium._remember_remote_is_before((1, 6))
3053
2379
        self._clear_cached_state_of_remote_branch_only()
3054
 
        self._set_revision_history(self._lefthand_history(revision_id,
 
2380
        self.set_revision_history(self._lefthand_history(revision_id,
3055
2381
            last_rev=last_rev,other_branch=other_branch))
3056
2382
 
3057
2383
    def set_push_location(self, location):
3058
2384
        self._ensure_real()
3059
2385
        return self._real_branch.set_push_location(location)
3060
2386
 
3061
 
    def heads_to_fetch(self):
3062
 
        if self._format._use_default_local_heads_to_fetch():
3063
 
            # We recognise this format, and its heads-to-fetch implementation
3064
 
            # is the default one (tip + tags).  In this case it's cheaper to
3065
 
            # just use the default implementation rather than a special RPC as
3066
 
            # the tip and tags data is cached.
3067
 
            return branch.Branch.heads_to_fetch(self)
3068
 
        medium = self._client._medium
3069
 
        if medium._is_remote_before((2, 4)):
3070
 
            return self._vfs_heads_to_fetch()
3071
 
        try:
3072
 
            return self._rpc_heads_to_fetch()
3073
 
        except errors.UnknownSmartMethod:
3074
 
            medium._remember_remote_is_before((2, 4))
3075
 
            return self._vfs_heads_to_fetch()
3076
 
 
3077
 
    def _rpc_heads_to_fetch(self):
3078
 
        response = self._call('Branch.heads_to_fetch', self._remote_path())
3079
 
        if len(response) != 2:
3080
 
            raise errors.UnexpectedSmartServerResponse(response)
3081
 
        must_fetch, if_present_fetch = response
3082
 
        return set(must_fetch), set(if_present_fetch)
3083
 
 
3084
 
    def _vfs_heads_to_fetch(self):
3085
 
        self._ensure_real()
3086
 
        return self._real_branch.heads_to_fetch()
3087
 
 
3088
 
 
3089
 
class RemoteConfig(object):
3090
 
    """A Config that reads and writes from smart verbs.
 
2387
 
 
2388
class RemoteBranchConfig(object):
 
2389
    """A Config that reads from a smart branch and writes via smart methods.
3091
2390
 
3092
2391
    It is a low-level object that considers config data to be name/value pairs
3093
2392
    that may be associated with a section. Assigning meaning to the these
3094
2393
    values is done at higher levels like bzrlib.config.TreeConfig.
3095
2394
    """
3096
2395
 
 
2396
    def __init__(self, branch):
 
2397
        self._branch = branch
 
2398
 
3097
2399
    def get_option(self, name, section=None, default=None):
3098
2400
        """Return the value associated with a named option.
3099
2401
 
3102
2404
        :param default: The value to return if the value is not set
3103
2405
        :return: The value or default value
3104
2406
        """
3105
 
        try:
3106
 
            configobj = self._get_configobj()
3107
 
            section_obj = None
3108
 
            if section is None:
3109
 
                section_obj = configobj
3110
 
            else:
3111
 
                try:
3112
 
                    section_obj = configobj[section]
3113
 
                except KeyError:
3114
 
                    pass
3115
 
            if section_obj is None:
3116
 
                value = default
3117
 
            else:
3118
 
                value = section_obj.get(name, default)
3119
 
        except errors.UnknownSmartMethod:
3120
 
            value = self._vfs_get_option(name, section, default)
3121
 
        for hook in config.OldConfigHooks['get']:
3122
 
            hook(self, name, value)
3123
 
        return value
3124
 
 
3125
 
    def _response_to_configobj(self, response):
3126
 
        if len(response[0]) and response[0][0] != 'ok':
3127
 
            raise errors.UnexpectedSmartServerResponse(response)
3128
 
        lines = response[1].read_body_bytes().splitlines()
3129
 
        conf = config.ConfigObj(lines, encoding='utf-8')
3130
 
        for hook in config.OldConfigHooks['load']:
3131
 
            hook(self)
3132
 
        return conf
3133
 
 
3134
 
 
3135
 
class RemoteBranchConfig(RemoteConfig):
3136
 
    """A RemoteConfig for Branches."""
3137
 
 
3138
 
    def __init__(self, branch):
3139
 
        self._branch = branch
 
2407
        configobj = self._get_configobj()
 
2408
        if section is None:
 
2409
            section_obj = configobj
 
2410
        else:
 
2411
            try:
 
2412
                section_obj = configobj[section]
 
2413
            except KeyError:
 
2414
                return default
 
2415
        return section_obj.get(name, default)
3140
2416
 
3141
2417
    def _get_configobj(self):
3142
2418
        path = self._branch._remote_path()
3143
2419
        response = self._branch._client.call_expecting_body(
3144
2420
            'Branch.get_config_file', path)
3145
 
        return self._response_to_configobj(response)
 
2421
        if response[0][0] != 'ok':
 
2422
            raise UnexpectedSmartServerResponse(response)
 
2423
        lines = response[1].read_body_bytes().splitlines()
 
2424
        return config.ConfigObj(lines, encoding='utf-8')
3146
2425
 
3147
2426
    def set_option(self, value, name, section=None):
3148
2427
        """Set the value associated with a named option.
3154
2433
        medium = self._branch._client._medium
3155
2434
        if medium._is_remote_before((1, 14)):
3156
2435
            return self._vfs_set_option(value, name, section)
3157
 
        if isinstance(value, dict):
3158
 
            if medium._is_remote_before((2, 2)):
3159
 
                return self._vfs_set_option(value, name, section)
3160
 
            return self._set_config_option_dict(value, name, section)
3161
 
        else:
3162
 
            return self._set_config_option(value, name, section)
3163
 
 
3164
 
    def _set_config_option(self, value, name, section):
3165
2436
        try:
3166
2437
            path = self._branch._remote_path()
3167
2438
            response = self._branch._client.call('Branch.set_config_option',
3168
2439
                path, self._branch._lock_token, self._branch._repo_lock_token,
3169
2440
                value.encode('utf8'), name, section or '')
3170
2441
        except errors.UnknownSmartMethod:
3171
 
            medium = self._branch._client._medium
3172
2442
            medium._remember_remote_is_before((1, 14))
3173
2443
            return self._vfs_set_option(value, name, section)
3174
2444
        if response != ():
3175
2445
            raise errors.UnexpectedSmartServerResponse(response)
3176
2446
 
3177
 
    def _serialize_option_dict(self, option_dict):
3178
 
        utf8_dict = {}
3179
 
        for key, value in option_dict.items():
3180
 
            if isinstance(key, unicode):
3181
 
                key = key.encode('utf8')
3182
 
            if isinstance(value, unicode):
3183
 
                value = value.encode('utf8')
3184
 
            utf8_dict[key] = value
3185
 
        return bencode.bencode(utf8_dict)
3186
 
 
3187
 
    def _set_config_option_dict(self, value, name, section):
3188
 
        try:
3189
 
            path = self._branch._remote_path()
3190
 
            serialised_dict = self._serialize_option_dict(value)
3191
 
            response = self._branch._client.call(
3192
 
                'Branch.set_config_option_dict',
3193
 
                path, self._branch._lock_token, self._branch._repo_lock_token,
3194
 
                serialised_dict, name, section or '')
3195
 
        except errors.UnknownSmartMethod:
3196
 
            medium = self._branch._client._medium
3197
 
            medium._remember_remote_is_before((2, 2))
3198
 
            return self._vfs_set_option(value, name, section)
3199
 
        if response != ():
3200
 
            raise errors.UnexpectedSmartServerResponse(response)
3201
 
 
3202
 
    def _real_object(self):
 
2447
    def _vfs_set_option(self, value, name, section=None):
3203
2448
        self._branch._ensure_real()
3204
 
        return self._branch._real_branch
3205
 
 
3206
 
    def _vfs_set_option(self, value, name, section=None):
3207
 
        return self._real_object()._get_config().set_option(
3208
 
            value, name, section)
3209
 
 
3210
 
 
3211
 
class RemoteBzrDirConfig(RemoteConfig):
3212
 
    """A RemoteConfig for BzrDirs."""
3213
 
 
3214
 
    def __init__(self, bzrdir):
3215
 
        self._bzrdir = bzrdir
3216
 
 
3217
 
    def _get_configobj(self):
3218
 
        medium = self._bzrdir._client._medium
3219
 
        verb = 'BzrDir.get_config_file'
3220
 
        if medium._is_remote_before((1, 15)):
3221
 
            raise errors.UnknownSmartMethod(verb)
3222
 
        path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
3223
 
        response = self._bzrdir._call_expecting_body(
3224
 
            verb, path)
3225
 
        return self._response_to_configobj(response)
3226
 
 
3227
 
    def _vfs_get_option(self, name, section, default):
3228
 
        return self._real_object()._get_config().get_option(
3229
 
            name, section, default)
3230
 
 
3231
 
    def set_option(self, value, name, section=None):
3232
 
        """Set the value associated with a named option.
3233
 
 
3234
 
        :param value: The value to set
3235
 
        :param name: The name of the value to set
3236
 
        :param section: The section the option is in (if any)
3237
 
        """
3238
 
        return self._real_object()._get_config().set_option(
3239
 
            value, name, section)
3240
 
 
3241
 
    def _real_object(self):
3242
 
        self._bzrdir._ensure_real()
3243
 
        return self._bzrdir._real_bzrdir
3244
 
 
 
2449
        return self._branch._real_branch._get_config().set_option(
 
2450
            value, name, section)
3245
2451
 
3246
2452
 
3247
2453
def _extract_tar(tar, to_dir):
3291
2497
        raise NoSuchRevision(find('branch'), err.error_args[0])
3292
2498
    elif err.error_verb == 'nosuchrevision':
3293
2499
        raise NoSuchRevision(find('repository'), err.error_args[0])
3294
 
    elif err.error_verb == 'nobranch':
3295
 
        if len(err.error_args) >= 1:
3296
 
            extra = err.error_args[0]
3297
 
        else:
3298
 
            extra = None
3299
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
3300
 
            detail=extra)
 
2500
    elif err.error_tuple == ('nobranch',):
 
2501
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
3301
2502
    elif err.error_verb == 'norepository':
3302
2503
        raise errors.NoRepositoryPresent(find('bzrdir'))
 
2504
    elif err.error_verb == 'LockContention':
 
2505
        raise errors.LockContention('(remote lock)')
3303
2506
    elif err.error_verb == 'UnlockableTransport':
3304
2507
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
 
2508
    elif err.error_verb == 'LockFailed':
 
2509
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
3305
2510
    elif err.error_verb == 'TokenMismatch':
3306
2511
        raise errors.TokenMismatch(find('token'), '(remote token)')
3307
2512
    elif err.error_verb == 'Diverged':
3308
2513
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
 
2514
    elif err.error_verb == 'TipChangeRejected':
 
2515
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
 
2516
    elif err.error_verb == 'UnstackableBranchFormat':
 
2517
        raise errors.UnstackableBranchFormat(*err.error_args)
 
2518
    elif err.error_verb == 'UnstackableRepositoryFormat':
 
2519
        raise errors.UnstackableRepositoryFormat(*err.error_args)
3309
2520
    elif err.error_verb == 'NotStacked':
3310
2521
        raise errors.NotStacked(branch=find('branch'))
3311
2522
    elif err.error_verb == 'PermissionDenied':
3321
2532
    elif err.error_verb == 'NoSuchFile':
3322
2533
        path = get_path()
3323
2534
        raise errors.NoSuchFile(path)
3324
 
    _translate_error_without_context(err)
3325
 
 
3326
 
 
3327
 
def _translate_error_without_context(err):
3328
 
    """Translate any ErrorFromSmartServer values that don't require context"""
3329
 
    if err.error_verb == 'IncompatibleRepositories':
3330
 
        raise errors.IncompatibleRepositories(err.error_args[0],
3331
 
            err.error_args[1], err.error_args[2])
3332
 
    elif err.error_verb == 'LockContention':
3333
 
        raise errors.LockContention('(remote lock)')
3334
 
    elif err.error_verb == 'LockFailed':
3335
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
3336
 
    elif err.error_verb == 'TipChangeRejected':
3337
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
3338
 
    elif err.error_verb == 'UnstackableBranchFormat':
3339
 
        raise errors.UnstackableBranchFormat(*err.error_args)
3340
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
3341
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
3342
2535
    elif err.error_verb == 'FileExists':
3343
2536
        raise errors.FileExists(err.error_args[0])
3344
2537
    elif err.error_verb == 'DirectoryNotEmpty':
3363
2556
            raise UnicodeEncodeError(encoding, val, start, end, reason)
3364
2557
    elif err.error_verb == 'ReadOnlyError':
3365
2558
        raise errors.TransportNotPossible('readonly transport')
3366
 
    elif err.error_verb == 'MemoryError':
3367
 
        raise errors.BzrError("remote server out of memory\n"
3368
 
            "Retry non-remotely, or contact the server admin for details.")
3369
2559
    raise errors.UnknownErrorFromSmartServer(err)