← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Martin Packman
  • Date: 2012-03-27 17:32:19 UTC
  • mto: (6437.54.3 2.5)
  • mto: This revision was merged to the branch mainline in revision 6525.
  • Revision ID: martin.packman@canonical.com-20120327173219-401pil42gke8j0xh
https://launchpad.net/bugs/940704
Fall back to sys.prefix not /usr when looking for .mo files

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
1
 
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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.
 
17
from __future__ import absolute_import
19
18
 
20
19
import bz2
 
20
import zlib
21
21
 
22
22
from bzrlib import (
23
23
    bencode,
24
24
    branch,
25
 
    bzrdir,
26
 
    config,
 
25
    bzrdir as _mod_bzrdir,
 
26
    config as _mod_config,
 
27
    controldir,
27
28
    debug,
28
29
    errors,
 
30
    gpg,
29
31
    graph,
 
32
    inventory_delta,
 
33
    lock,
30
34
    lockdir,
31
 
    repository,
32
 
    revision,
 
35
    osutils,
 
36
    registry,
 
37
    repository as _mod_repository,
33
38
    revision as _mod_revision,
 
39
    static_tuple,
34
40
    symbol_versioning,
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
 
41
    testament as _mod_testament,
 
42
    urlutils,
 
43
    vf_repository,
 
44
    vf_search,
 
45
    )
 
46
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
 
47
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
39
48
from bzrlib.errors import (
40
49
    NoSuchRevision,
41
50
    SmartProtocolError,
42
51
    )
 
52
from bzrlib.i18n import gettext
 
53
from bzrlib.inventory import Inventory
43
54
from bzrlib.lockable_files import LockableFiles
44
55
from bzrlib.smart import client, vfs, repository as smart_repo
45
 
from bzrlib.revision import ensure_null, NULL_REVISION
46
 
from bzrlib.trace import mutter, note, warning
 
56
from bzrlib.smart.client import _SmartClient
 
57
from bzrlib.revision import NULL_REVISION
 
58
from bzrlib.revisiontree import InventoryRevisionTree
 
59
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
 
60
from bzrlib.serializer import format_registry as serializer_format_registry
 
61
from bzrlib.trace import mutter, note, warning, log_exception_quietly
 
62
from bzrlib.versionedfile import FulltextContentFactory
 
63
 
 
64
 
 
65
_DEFAULT_SEARCH_DEPTH = 100
47
66
 
48
67
 
49
68
class _RpcHelper(object):
61
80
        except errors.ErrorFromSmartServer, err:
62
81
            self._translate_error(err, **err_context)
63
82
 
 
83
    def _call_with_body_bytes(self, method, args, body_bytes, **err_context):
 
84
        try:
 
85
            return self._client.call_with_body_bytes(method, args, body_bytes)
 
86
        except errors.ErrorFromSmartServer, err:
 
87
            self._translate_error(err, **err_context)
 
88
 
64
89
    def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
65
90
                                             **err_context):
66
91
        try:
80
105
    return format
81
106
 
82
107
 
83
 
# Note: RemoteBzrDirFormat is in bzrdir.py
84
 
 
85
 
class RemoteBzrDir(BzrDir, _RpcHelper):
 
108
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
 
109
# does not have to be imported unless a remote format is involved.
 
110
 
 
111
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
 
112
    """Format representing bzrdirs accessed via a smart server"""
 
113
 
 
114
    supports_workingtrees = False
 
115
 
 
116
    colocated_branches = False
 
117
 
 
118
    def __init__(self):
 
119
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
 
120
        # XXX: It's a bit ugly that the network name is here, because we'd
 
121
        # like to believe that format objects are stateless or at least
 
122
        # immutable,  However, we do at least avoid mutating the name after
 
123
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
 
124
        self._network_name = None
 
125
 
 
126
    def __repr__(self):
 
127
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
128
            self._network_name)
 
129
 
 
130
    def get_format_description(self):
 
131
        if self._network_name:
 
132
            try:
 
133
                real_format = controldir.network_format_registry.get(
 
134
                        self._network_name)
 
135
            except KeyError:
 
136
                pass
 
137
            else:
 
138
                return 'Remote: ' + real_format.get_format_description()
 
139
        return 'bzr remote bzrdir'
 
140
 
 
141
    def get_format_string(self):
 
142
        raise NotImplementedError(self.get_format_string)
 
143
 
 
144
    def network_name(self):
 
145
        if self._network_name:
 
146
            return self._network_name
 
147
        else:
 
148
            raise AssertionError("No network name set.")
 
149
 
 
150
    def initialize_on_transport(self, transport):
 
151
        try:
 
152
            # hand off the request to the smart server
 
153
            client_medium = transport.get_smart_medium()
 
154
        except errors.NoSmartMedium:
 
155
            # TODO: lookup the local format from a server hint.
 
156
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
157
            return local_dir_format.initialize_on_transport(transport)
 
158
        client = _SmartClient(client_medium)
 
159
        path = client.remote_path_from_transport(transport)
 
160
        try:
 
161
            response = client.call('BzrDirFormat.initialize', path)
 
162
        except errors.ErrorFromSmartServer, err:
 
163
            _translate_error(err, path=path)
 
164
        if response[0] != 'ok':
 
165
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
 
166
        format = RemoteBzrDirFormat()
 
167
        self._supply_sub_formats_to(format)
 
168
        return RemoteBzrDir(transport, format)
 
169
 
 
170
    def parse_NoneTrueFalse(self, arg):
 
171
        if not arg:
 
172
            return None
 
173
        if arg == 'False':
 
174
            return False
 
175
        if arg == 'True':
 
176
            return True
 
177
        raise AssertionError("invalid arg %r" % arg)
 
178
 
 
179
    def _serialize_NoneTrueFalse(self, arg):
 
180
        if arg is False:
 
181
            return 'False'
 
182
        if arg:
 
183
            return 'True'
 
184
        return ''
 
185
 
 
186
    def _serialize_NoneString(self, arg):
 
187
        return arg or ''
 
188
 
 
189
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
190
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
191
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
192
        shared_repo=False):
 
193
        try:
 
194
            # hand off the request to the smart server
 
195
            client_medium = transport.get_smart_medium()
 
196
        except errors.NoSmartMedium:
 
197
            do_vfs = True
 
198
        else:
 
199
            # Decline to open it if the server doesn't support our required
 
200
            # version (3) so that the VFS-based transport will do it.
 
201
            if client_medium.should_probe():
 
202
                try:
 
203
                    server_version = client_medium.protocol_version()
 
204
                    if server_version != '2':
 
205
                        do_vfs = True
 
206
                    else:
 
207
                        do_vfs = False
 
208
                except errors.SmartProtocolError:
 
209
                    # Apparently there's no usable smart server there, even though
 
210
                    # the medium supports the smart protocol.
 
211
                    do_vfs = True
 
212
            else:
 
213
                do_vfs = False
 
214
        if not do_vfs:
 
215
            client = _SmartClient(client_medium)
 
216
            path = client.remote_path_from_transport(transport)
 
217
            if client_medium._is_remote_before((1, 16)):
 
218
                do_vfs = True
 
219
        if do_vfs:
 
220
            # TODO: lookup the local format from a server hint.
 
221
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
222
            self._supply_sub_formats_to(local_dir_format)
 
223
            return local_dir_format.initialize_on_transport_ex(transport,
 
224
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
225
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
226
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
227
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
228
                vfs_only=True)
 
229
        return self._initialize_on_transport_ex_rpc(client, path, transport,
 
230
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
231
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
 
232
 
 
233
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
 
234
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
235
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
 
236
        args = []
 
237
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
 
238
        args.append(self._serialize_NoneTrueFalse(create_prefix))
 
239
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
 
240
        args.append(self._serialize_NoneString(stacked_on))
 
241
        # stack_on_pwd is often/usually our transport
 
242
        if stack_on_pwd:
 
243
            try:
 
244
                stack_on_pwd = transport.relpath(stack_on_pwd)
 
245
                if not stack_on_pwd:
 
246
                    stack_on_pwd = '.'
 
247
            except errors.PathNotChild:
 
248
                pass
 
249
        args.append(self._serialize_NoneString(stack_on_pwd))
 
250
        args.append(self._serialize_NoneString(repo_format_name))
 
251
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
 
252
        args.append(self._serialize_NoneTrueFalse(shared_repo))
 
253
        request_network_name = self._network_name or \
 
254
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
 
255
        try:
 
256
            response = client.call('BzrDirFormat.initialize_ex_1.16',
 
257
                request_network_name, path, *args)
 
258
        except errors.UnknownSmartMethod:
 
259
            client._medium._remember_remote_is_before((1,16))
 
260
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
261
            self._supply_sub_formats_to(local_dir_format)
 
262
            return local_dir_format.initialize_on_transport_ex(transport,
 
263
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
264
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
265
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
266
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
267
                vfs_only=True)
 
268
        except errors.ErrorFromSmartServer, err:
 
269
            _translate_error(err, path=path)
 
270
        repo_path = response[0]
 
271
        bzrdir_name = response[6]
 
272
        require_stacking = response[7]
 
273
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
 
274
        format = RemoteBzrDirFormat()
 
275
        format._network_name = bzrdir_name
 
276
        self._supply_sub_formats_to(format)
 
277
        bzrdir = RemoteBzrDir(transport, format, _client=client)
 
278
        if repo_path:
 
279
            repo_format = response_tuple_to_repo_format(response[1:])
 
280
            if repo_path == '.':
 
281
                repo_path = ''
 
282
            if repo_path:
 
283
                repo_bzrdir_format = RemoteBzrDirFormat()
 
284
                repo_bzrdir_format._network_name = response[5]
 
285
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
 
286
                    repo_bzrdir_format)
 
287
            else:
 
288
                repo_bzr = bzrdir
 
289
            final_stack = response[8] or None
 
290
            final_stack_pwd = response[9] or None
 
291
            if final_stack_pwd:
 
292
                final_stack_pwd = urlutils.join(
 
293
                    transport.base, final_stack_pwd)
 
294
            remote_repo = RemoteRepository(repo_bzr, repo_format)
 
295
            if len(response) > 10:
 
296
                # Updated server verb that locks remotely.
 
297
                repo_lock_token = response[10] or None
 
298
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
 
299
                if repo_lock_token:
 
300
                    remote_repo.dont_leave_lock_in_place()
 
301
            else:
 
302
                remote_repo.lock_write()
 
303
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
 
304
                final_stack_pwd, require_stacking)
 
305
            policy.acquire_repository()
 
306
        else:
 
307
            remote_repo = None
 
308
            policy = None
 
309
        bzrdir._format.set_branch_format(self.get_branch_format())
 
310
        if require_stacking:
 
311
            # The repo has already been created, but we need to make sure that
 
312
            # we'll make a stackable branch.
 
313
            bzrdir._format.require_stacking(_skip_repo=True)
 
314
        return remote_repo, bzrdir, require_stacking, policy
 
315
 
 
316
    def _open(self, transport):
 
317
        return RemoteBzrDir(transport, self)
 
318
 
 
319
    def __eq__(self, other):
 
320
        if not isinstance(other, RemoteBzrDirFormat):
 
321
            return False
 
322
        return self.get_format_description() == other.get_format_description()
 
323
 
 
324
    def __return_repository_format(self):
 
325
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
 
326
        # repository format has been asked for, tell the RemoteRepositoryFormat
 
327
        # that it should use that for init() etc.
 
328
        result = RemoteRepositoryFormat()
 
329
        custom_format = getattr(self, '_repository_format', None)
 
330
        if custom_format:
 
331
            if isinstance(custom_format, RemoteRepositoryFormat):
 
332
                return custom_format
 
333
            else:
 
334
                # We will use the custom format to create repositories over the
 
335
                # wire; expose its details like rich_root_data for code to
 
336
                # query
 
337
                result._custom_format = custom_format
 
338
        return result
 
339
 
 
340
    def get_branch_format(self):
 
341
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
 
342
        if not isinstance(result, RemoteBranchFormat):
 
343
            new_result = RemoteBranchFormat()
 
344
            new_result._custom_format = result
 
345
            # cache the result
 
346
            self.set_branch_format(new_result)
 
347
            result = new_result
 
348
        return result
 
349
 
 
350
    repository_format = property(__return_repository_format,
 
351
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
 
352
 
 
353
 
 
354
class RemoteControlStore(_mod_config.IniFileStore):
 
355
    """Control store which attempts to use HPSS calls to retrieve control store.
 
356
 
 
357
    Note that this is specific to bzr-based formats.
 
358
    """
 
359
 
 
360
    def __init__(self, bzrdir):
 
361
        super(RemoteControlStore, self).__init__()
 
362
        self.bzrdir = bzrdir
 
363
        self._real_store = None
 
364
 
 
365
    def lock_write(self, token=None):
 
366
        self._ensure_real()
 
367
        return self._real_store.lock_write(token)
 
368
 
 
369
    def unlock(self):
 
370
        self._ensure_real()
 
371
        return self._real_store.unlock()
 
372
 
 
373
    @needs_write_lock
 
374
    def save(self):
 
375
        # We need to be able to override the undecorated implementation
 
376
        self.save_without_locking()
 
377
 
 
378
    def save_without_locking(self):
 
379
        super(RemoteControlStore, self).save()
 
380
 
 
381
    def _ensure_real(self):
 
382
        self.bzrdir._ensure_real()
 
383
        if self._real_store is None:
 
384
            self._real_store = _mod_config.ControlStore(self.bzrdir)
 
385
 
 
386
    def external_url(self):
 
387
        return self.bzrdir.user_url
 
388
 
 
389
    def _load_content(self):
 
390
        medium = self.bzrdir._client._medium
 
391
        path = self.bzrdir._path_for_remote_call(self.bzrdir._client)
 
392
        try:
 
393
            response, handler = self.bzrdir._call_expecting_body(
 
394
                'BzrDir.get_config_file', path)
 
395
        except errors.UnknownSmartMethod:
 
396
            self._ensure_real()
 
397
            return self._real_store._load_content()
 
398
        if len(response) and response[0] != 'ok':
 
399
            raise errors.UnexpectedSmartServerResponse(response)
 
400
        return handler.read_body_bytes()
 
401
 
 
402
    def _save_content(self, content):
 
403
        # FIXME JRV 2011-11-22: Ideally this should use a
 
404
        # HPSS call too, but at the moment it is not possible
 
405
        # to write lock control directories.
 
406
        self._ensure_real()
 
407
        return self._real_store._save_content(content)
 
408
 
 
409
 
 
410
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
86
411
    """Control directory on a remote server, accessed via bzr:// or similar."""
87
412
 
88
 
    def __init__(self, transport, format, _client=None):
 
413
    def __init__(self, transport, format, _client=None, _force_probe=False):
89
414
        """Construct a RemoteBzrDir.
90
415
 
91
416
        :param _client: Private parameter for testing. Disables probing and the
92
417
            use of a real bzrdir.
93
418
        """
94
 
        BzrDir.__init__(self, transport, format)
 
419
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
95
420
        # this object holds a delegated bzrdir that uses file-level operations
96
421
        # to talk to the other side
97
422
        self._real_bzrdir = None
 
423
        self._has_working_tree = None
98
424
        # 1-shot cache for the call pattern 'create_branch; open_branch' - see
99
425
        # create_branch for details.
100
426
        self._next_open_branch_result = None
104
430
            self._client = client._SmartClient(medium)
105
431
        else:
106
432
            self._client = _client
107
 
            return
108
 
 
 
433
            if not _force_probe:
 
434
                return
 
435
 
 
436
        self._probe_bzrdir()
 
437
 
 
438
    def __repr__(self):
 
439
        return '%s(%r)' % (self.__class__.__name__, self._client)
 
440
 
 
441
    def _probe_bzrdir(self):
 
442
        medium = self._client._medium
109
443
        path = self._path_for_remote_call(self._client)
 
444
        if medium._is_remote_before((2, 1)):
 
445
            self._rpc_open(path)
 
446
            return
 
447
        try:
 
448
            self._rpc_open_2_1(path)
 
449
            return
 
450
        except errors.UnknownSmartMethod:
 
451
            medium._remember_remote_is_before((2, 1))
 
452
            self._rpc_open(path)
 
453
 
 
454
    def _rpc_open_2_1(self, path):
 
455
        response = self._call('BzrDir.open_2.1', path)
 
456
        if response == ('no',):
 
457
            raise errors.NotBranchError(path=self.root_transport.base)
 
458
        elif response[0] == 'yes':
 
459
            if response[1] == 'yes':
 
460
                self._has_working_tree = True
 
461
            elif response[1] == 'no':
 
462
                self._has_working_tree = False
 
463
            else:
 
464
                raise errors.UnexpectedSmartServerResponse(response)
 
465
        else:
 
466
            raise errors.UnexpectedSmartServerResponse(response)
 
467
 
 
468
    def _rpc_open(self, path):
110
469
        response = self._call('BzrDir.open', path)
111
470
        if response not in [('yes',), ('no',)]:
112
471
            raise errors.UnexpectedSmartServerResponse(response)
113
472
        if response == ('no',):
114
 
            raise errors.NotBranchError(path=transport.base)
 
473
            raise errors.NotBranchError(path=self.root_transport.base)
115
474
 
116
475
    def _ensure_real(self):
117
476
        """Ensure that there is a _real_bzrdir set.
119
478
        Used before calls to self._real_bzrdir.
120
479
        """
121
480
        if not self._real_bzrdir:
122
 
            self._real_bzrdir = BzrDir.open_from_transport(
123
 
                self.root_transport, _server_formats=False)
 
481
            if 'hpssvfs' in debug.debug_flags:
 
482
                import traceback
 
483
                warning('VFS BzrDir access triggered\n%s',
 
484
                    ''.join(traceback.format_stack()))
 
485
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
 
486
                self.root_transport, probers=[_mod_bzrdir.BzrProber])
124
487
            self._format._network_name = \
125
488
                self._real_bzrdir._format.network_name()
126
489
 
131
494
        # Prevent aliasing problems in the next_open_branch_result cache.
132
495
        # See create_branch for rationale.
133
496
        self._next_open_branch_result = None
134
 
        return BzrDir.break_lock(self)
 
497
        return _mod_bzrdir.BzrDir.break_lock(self)
 
498
 
 
499
    def _vfs_checkout_metadir(self):
 
500
        self._ensure_real()
 
501
        return self._real_bzrdir.checkout_metadir()
 
502
 
 
503
    def checkout_metadir(self):
 
504
        """Retrieve the controldir format to use for checkouts of this one.
 
505
        """
 
506
        medium = self._client._medium
 
507
        if medium._is_remote_before((2, 5)):
 
508
            return self._vfs_checkout_metadir()
 
509
        path = self._path_for_remote_call(self._client)
 
510
        try:
 
511
            response = self._client.call('BzrDir.checkout_metadir',
 
512
                path)
 
513
        except errors.UnknownSmartMethod:
 
514
            medium._remember_remote_is_before((2, 5))
 
515
            return self._vfs_checkout_metadir()
 
516
        if len(response) != 3:
 
517
            raise errors.UnexpectedSmartServerResponse(response)
 
518
        control_name, repo_name, branch_name = response
 
519
        try:
 
520
            format = controldir.network_format_registry.get(control_name)
 
521
        except KeyError:
 
522
            raise errors.UnknownFormatError(kind='control',
 
523
                format=control_name)
 
524
        if repo_name:
 
525
            try:
 
526
                repo_format = _mod_repository.network_format_registry.get(
 
527
                    repo_name)
 
528
            except KeyError:
 
529
                raise errors.UnknownFormatError(kind='repository',
 
530
                    format=repo_name)
 
531
            format.repository_format = repo_format
 
532
        if branch_name:
 
533
            try:
 
534
                format.set_branch_format(
 
535
                    branch.network_format_registry.get(branch_name))
 
536
            except KeyError:
 
537
                raise errors.UnknownFormatError(kind='branch',
 
538
                    format=branch_name)
 
539
        return format
135
540
 
136
541
    def _vfs_cloning_metadir(self, require_stacking=False):
137
542
        self._ensure_real()
168
573
        if len(branch_info) != 2:
169
574
            raise errors.UnexpectedSmartServerResponse(response)
170
575
        branch_ref, branch_name = branch_info
171
 
        format = bzrdir.network_format_registry.get(control_name)
 
576
        try:
 
577
            format = controldir.network_format_registry.get(control_name)
 
578
        except KeyError:
 
579
            raise errors.UnknownFormatError(kind='control', format=control_name)
 
580
 
172
581
        if repo_name:
173
 
            format.repository_format = repository.network_format_registry.get(
174
 
                repo_name)
 
582
            try:
 
583
                format.repository_format = _mod_repository.network_format_registry.get(
 
584
                    repo_name)
 
585
            except KeyError:
 
586
                raise errors.UnknownFormatError(kind='repository',
 
587
                    format=repo_name)
175
588
        if branch_ref == 'ref':
176
589
            # XXX: we need possible_transports here to avoid reopening the
177
590
            # connection to the referenced location
178
 
            ref_bzrdir = BzrDir.open(branch_name)
 
591
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
179
592
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
180
593
            format.set_branch_format(branch_format)
181
594
        elif branch_ref == 'branch':
182
595
            if branch_name:
183
 
                format.set_branch_format(
184
 
                    branch.network_format_registry.get(branch_name))
 
596
                try:
 
597
                    branch_format = branch.network_format_registry.get(
 
598
                        branch_name)
 
599
                except KeyError:
 
600
                    raise errors.UnknownFormatError(kind='branch',
 
601
                        format=branch_name)
 
602
                format.set_branch_format(branch_format)
185
603
        else:
186
604
            raise errors.UnexpectedSmartServerResponse(response)
187
605
        return format
197
615
 
198
616
    def destroy_repository(self):
199
617
        """See BzrDir.destroy_repository"""
200
 
        self._ensure_real()
201
 
        self._real_bzrdir.destroy_repository()
 
618
        path = self._path_for_remote_call(self._client)
 
619
        try:
 
620
            response = self._call('BzrDir.destroy_repository', path)
 
621
        except errors.UnknownSmartMethod:
 
622
            self._ensure_real()
 
623
            self._real_bzrdir.destroy_repository()
 
624
            return
 
625
        if response[0] != 'ok':
 
626
            raise SmartProtocolError('unexpected response code %s' % (response,))
202
627
 
203
 
    def create_branch(self):
 
628
    def create_branch(self, name=None, repository=None,
 
629
                      append_revisions_only=None):
 
630
        if name is None:
 
631
            name = self._get_selected_branch()
 
632
        if name != "":
 
633
            raise errors.NoColocatedBranchSupport(self)
204
634
        # as per meta1 formats - just delegate to the format object which may
205
635
        # be parameterised.
206
 
        real_branch = self._format.get_branch_format().initialize(self)
 
636
        real_branch = self._format.get_branch_format().initialize(self,
 
637
            name=name, repository=repository,
 
638
            append_revisions_only=append_revisions_only)
207
639
        if not isinstance(real_branch, RemoteBranch):
208
 
            result = RemoteBranch(self, self.find_repository(), real_branch)
 
640
            if not isinstance(repository, RemoteRepository):
 
641
                raise AssertionError(
 
642
                    'need a RemoteRepository to use with RemoteBranch, got %r'
 
643
                    % (repository,))
 
644
            result = RemoteBranch(self, repository, real_branch, name=name)
209
645
        else:
210
646
            result = real_branch
211
647
        # BzrDir.clone_on_transport() uses the result of create_branch but does
217
653
        self._next_open_branch_result = result
218
654
        return result
219
655
 
220
 
    def destroy_branch(self):
 
656
    def destroy_branch(self, name=None):
221
657
        """See BzrDir.destroy_branch"""
222
 
        self._ensure_real()
223
 
        self._real_bzrdir.destroy_branch()
 
658
        if name is None:
 
659
            name = self._get_selected_branch()
 
660
        if name != "":
 
661
            raise errors.NoColocatedBranchSupport(self)
 
662
        path = self._path_for_remote_call(self._client)
 
663
        try:
 
664
            if name != "":
 
665
                args = (name, )
 
666
            else:
 
667
                args = ()
 
668
            response = self._call('BzrDir.destroy_branch', path, *args)
 
669
        except errors.UnknownSmartMethod:
 
670
            self._ensure_real()
 
671
            self._real_bzrdir.destroy_branch(name=name)
 
672
            self._next_open_branch_result = None
 
673
            return
224
674
        self._next_open_branch_result = None
 
675
        if response[0] != 'ok':
 
676
            raise SmartProtocolError('unexpected response code %s' % (response,))
225
677
 
226
 
    def create_workingtree(self, revision_id=None, from_branch=None):
 
678
    def create_workingtree(self, revision_id=None, from_branch=None,
 
679
        accelerator_tree=None, hardlink=False):
227
680
        raise errors.NotLocalUrl(self.transport.base)
228
681
 
229
 
    def find_branch_format(self):
 
682
    def find_branch_format(self, name=None):
230
683
        """Find the branch 'format' for this bzrdir.
231
684
 
232
685
        This might be a synthetic object for e.g. RemoteBranch and SVN.
233
686
        """
234
 
        b = self.open_branch()
 
687
        b = self.open_branch(name=name)
235
688
        return b._format
236
689
 
237
 
    def get_branch_reference(self):
 
690
    def get_branches(self, possible_transports=None, ignore_fallbacks=False):
 
691
        path = self._path_for_remote_call(self._client)
 
692
        try:
 
693
            response, handler = self._call_expecting_body(
 
694
                'BzrDir.get_branches', path)
 
695
        except errors.UnknownSmartMethod:
 
696
            self._ensure_real()
 
697
            return self._real_bzrdir.get_branches()
 
698
        if response[0] != "success":
 
699
            raise errors.UnexpectedSmartServerResponse(response)
 
700
        body = bencode.bdecode(handler.read_body_bytes())
 
701
        ret = {}
 
702
        for (name, value) in body.iteritems():
 
703
            ret[name] = self._open_branch(name, value[0], value[1],
 
704
                possible_transports=possible_transports,
 
705
                ignore_fallbacks=ignore_fallbacks)
 
706
        return ret
 
707
 
 
708
    def set_branch_reference(self, target_branch, name=None):
 
709
        """See BzrDir.set_branch_reference()."""
 
710
        if name is None:
 
711
            name = self._get_selected_branch()
 
712
        if name != "":
 
713
            raise errors.NoColocatedBranchSupport(self)
 
714
        self._ensure_real()
 
715
        return self._real_bzrdir.set_branch_reference(target_branch, name=name)
 
716
 
 
717
    def get_branch_reference(self, name=None):
238
718
        """See BzrDir.get_branch_reference()."""
 
719
        if name is None:
 
720
            name = self._get_selected_branch()
 
721
        if name != "":
 
722
            raise errors.NoColocatedBranchSupport(self)
239
723
        response = self._get_branch_reference()
240
724
        if response[0] == 'ref':
241
725
            return response[1]
245
729
    def _get_branch_reference(self):
246
730
        path = self._path_for_remote_call(self._client)
247
731
        medium = self._client._medium
248
 
        if not medium._is_remote_before((1, 13)):
 
732
        candidate_calls = [
 
733
            ('BzrDir.open_branchV3', (2, 1)),
 
734
            ('BzrDir.open_branchV2', (1, 13)),
 
735
            ('BzrDir.open_branch', None),
 
736
            ]
 
737
        for verb, required_version in candidate_calls:
 
738
            if required_version and medium._is_remote_before(required_version):
 
739
                continue
249
740
            try:
250
 
                response = self._call('BzrDir.open_branchV2', path)
251
 
                if response[0] not in ('ref', 'branch'):
252
 
                    raise errors.UnexpectedSmartServerResponse(response)
253
 
                return response
 
741
                response = self._call(verb, path)
254
742
            except errors.UnknownSmartMethod:
255
 
                medium._remember_remote_is_before((1, 13))
256
 
        response = self._call('BzrDir.open_branch', path)
257
 
        if response[0] != 'ok':
 
743
                if required_version is None:
 
744
                    raise
 
745
                medium._remember_remote_is_before(required_version)
 
746
            else:
 
747
                break
 
748
        if verb == 'BzrDir.open_branch':
 
749
            if response[0] != 'ok':
 
750
                raise errors.UnexpectedSmartServerResponse(response)
 
751
            if response[1] != '':
 
752
                return ('ref', response[1])
 
753
            else:
 
754
                return ('branch', '')
 
755
        if response[0] not in ('ref', 'branch'):
258
756
            raise errors.UnexpectedSmartServerResponse(response)
259
 
        if response[1] != '':
260
 
            return ('ref', response[1])
261
 
        else:
262
 
            return ('branch', '')
 
757
        return response
263
758
 
264
 
    def _get_tree_branch(self):
 
759
    def _get_tree_branch(self, name=None):
265
760
        """See BzrDir._get_tree_branch()."""
266
 
        return None, self.open_branch()
 
761
        return None, self.open_branch(name=name)
267
762
 
268
 
    def open_branch(self, _unsupported=False, ignore_fallbacks=False):
269
 
        if _unsupported:
270
 
            raise NotImplementedError('unsupported flag support not implemented yet.')
271
 
        if self._next_open_branch_result is not None:
272
 
            # See create_branch for details.
273
 
            result = self._next_open_branch_result
274
 
            self._next_open_branch_result = None
275
 
            return result
276
 
        response = self._get_branch_reference()
277
 
        if response[0] == 'ref':
 
763
    def _open_branch(self, name, kind, location_or_format,
 
764
                     ignore_fallbacks=False, possible_transports=None):
 
765
        if kind == 'ref':
278
766
            # a branch reference, use the existing BranchReference logic.
279
767
            format = BranchReferenceFormat()
280
 
            return format.open(self, _found=True, location=response[1],
281
 
                ignore_fallbacks=ignore_fallbacks)
282
 
        branch_format_name = response[1]
 
768
            return format.open(self, name=name, _found=True,
 
769
                location=location_or_format, ignore_fallbacks=ignore_fallbacks,
 
770
                possible_transports=possible_transports)
 
771
        branch_format_name = location_or_format
283
772
        if not branch_format_name:
284
773
            branch_format_name = None
285
774
        format = RemoteBranchFormat(network_name=branch_format_name)
286
775
        return RemoteBranch(self, self.find_repository(), format=format,
287
 
            setup_stacking=not ignore_fallbacks)
 
776
            setup_stacking=not ignore_fallbacks, name=name,
 
777
            possible_transports=possible_transports)
 
778
 
 
779
    def open_branch(self, name=None, unsupported=False,
 
780
                    ignore_fallbacks=False, possible_transports=None):
 
781
        if name is None:
 
782
            name = self._get_selected_branch()
 
783
        if name != "":
 
784
            raise errors.NoColocatedBranchSupport(self)
 
785
        if unsupported:
 
786
            raise NotImplementedError('unsupported flag support not implemented yet.')
 
787
        if self._next_open_branch_result is not None:
 
788
            # See create_branch for details.
 
789
            result = self._next_open_branch_result
 
790
            self._next_open_branch_result = None
 
791
            return result
 
792
        response = self._get_branch_reference()
 
793
        return self._open_branch(name, response[0], response[1],
 
794
            possible_transports=possible_transports,
 
795
            ignore_fallbacks=ignore_fallbacks)
288
796
 
289
797
    def _open_repo_v1(self, path):
290
798
        verb = 'BzrDir.find_repository'
351
859
        else:
352
860
            raise errors.NoRepositoryPresent(self)
353
861
 
 
862
    def has_workingtree(self):
 
863
        if self._has_working_tree is None:
 
864
            path = self._path_for_remote_call(self._client)
 
865
            try:
 
866
                response = self._call('BzrDir.has_workingtree', path)
 
867
            except errors.UnknownSmartMethod:
 
868
                self._ensure_real()
 
869
                self._has_working_tree = self._real_bzrdir.has_workingtree()
 
870
            else:
 
871
                if response[0] not in ('yes', 'no'):
 
872
                    raise SmartProtocolError('unexpected response code %s' % (response,))
 
873
                self._has_working_tree = (response[0] == 'yes')
 
874
        return self._has_working_tree
 
875
 
354
876
    def open_workingtree(self, recommend_upgrade=True):
355
 
        self._ensure_real()
356
 
        if self._real_bzrdir.has_workingtree():
 
877
        if self.has_workingtree():
357
878
            raise errors.NotLocalUrl(self.root_transport)
358
879
        else:
359
880
            raise errors.NoWorkingTree(self.root_transport.base)
360
881
 
361
882
    def _path_for_remote_call(self, client):
362
883
        """Return the path to be used for this bzrdir in a remote call."""
363
 
        return client.remote_path_from_transport(self.root_transport)
 
884
        return urlutils.split_segment_parameters_raw(
 
885
            client.remote_path_from_transport(self.root_transport))[0]
364
886
 
365
 
    def get_branch_transport(self, branch_format):
 
887
    def get_branch_transport(self, branch_format, name=None):
366
888
        self._ensure_real()
367
 
        return self._real_bzrdir.get_branch_transport(branch_format)
 
889
        return self._real_bzrdir.get_branch_transport(branch_format, name=name)
368
890
 
369
891
    def get_repository_transport(self, repository_format):
370
892
        self._ensure_real()
378
900
        """Upgrading of remote bzrdirs is not supported yet."""
379
901
        return False
380
902
 
381
 
    def needs_format_conversion(self, format=None):
 
903
    def needs_format_conversion(self, format):
382
904
        """Upgrading of remote bzrdirs is not supported yet."""
383
 
        if format is None:
384
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
385
 
                % 'needs_format_conversion(format=None)')
386
905
        return False
387
906
 
388
 
    def clone(self, url, revision_id=None, force_new_repo=False,
389
 
              preserve_stacking=False):
390
 
        self._ensure_real()
391
 
        return self._real_bzrdir.clone(url, revision_id=revision_id,
392
 
            force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
393
 
 
394
907
    def _get_config(self):
395
908
        return RemoteBzrDirConfig(self)
396
909
 
397
 
 
398
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
910
    def _get_config_store(self):
 
911
        return RemoteControlStore(self)
 
912
 
 
913
 
 
914
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
399
915
    """Format for repositories accessed over a _SmartClient.
400
916
 
401
917
    Instances of this repository are represented by RemoteRepository
416
932
    """
417
933
 
418
934
    _matchingbzrdir = RemoteBzrDirFormat()
 
935
    supports_full_versioned_files = True
 
936
    supports_leaving_lock = True
419
937
 
420
938
    def __init__(self):
421
 
        repository.RepositoryFormat.__init__(self)
 
939
        _mod_repository.RepositoryFormat.__init__(self)
422
940
        self._custom_format = None
423
941
        self._network_name = None
424
942
        self._creating_bzrdir = None
 
943
        self._revision_graph_can_have_wrong_parents = None
 
944
        self._supports_chks = None
425
945
        self._supports_external_lookups = None
426
946
        self._supports_tree_reference = None
 
947
        self._supports_funky_characters = None
 
948
        self._supports_nesting_repositories = None
427
949
        self._rich_root_data = None
428
950
 
 
951
    def __repr__(self):
 
952
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
953
            self._network_name)
 
954
 
429
955
    @property
430
956
    def fast_deltas(self):
431
957
        self._ensure_real()
439
965
        return self._rich_root_data
440
966
 
441
967
    @property
 
968
    def supports_chks(self):
 
969
        if self._supports_chks is None:
 
970
            self._ensure_real()
 
971
            self._supports_chks = self._custom_format.supports_chks
 
972
        return self._supports_chks
 
973
 
 
974
    @property
442
975
    def supports_external_lookups(self):
443
976
        if self._supports_external_lookups is None:
444
977
            self._ensure_real()
447
980
        return self._supports_external_lookups
448
981
 
449
982
    @property
 
983
    def supports_funky_characters(self):
 
984
        if self._supports_funky_characters is None:
 
985
            self._ensure_real()
 
986
            self._supports_funky_characters = \
 
987
                self._custom_format.supports_funky_characters
 
988
        return self._supports_funky_characters
 
989
 
 
990
    @property
 
991
    def supports_nesting_repositories(self):
 
992
        if self._supports_nesting_repositories is None:
 
993
            self._ensure_real()
 
994
            self._supports_nesting_repositories = \
 
995
                self._custom_format.supports_nesting_repositories
 
996
        return self._supports_nesting_repositories
 
997
 
 
998
    @property
450
999
    def supports_tree_reference(self):
451
1000
        if self._supports_tree_reference is None:
452
1001
            self._ensure_real()
454
1003
                self._custom_format.supports_tree_reference
455
1004
        return self._supports_tree_reference
456
1005
 
 
1006
    @property
 
1007
    def revision_graph_can_have_wrong_parents(self):
 
1008
        if self._revision_graph_can_have_wrong_parents is None:
 
1009
            self._ensure_real()
 
1010
            self._revision_graph_can_have_wrong_parents = \
 
1011
                self._custom_format.revision_graph_can_have_wrong_parents
 
1012
        return self._revision_graph_can_have_wrong_parents
 
1013
 
457
1014
    def _vfs_initialize(self, a_bzrdir, shared):
458
1015
        """Helper for common code in initialize."""
459
1016
        if self._custom_format:
494
1051
            network_name = self._network_name
495
1052
        else:
496
1053
            # Select the current bzrlib default and ask for that.
497
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
1054
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
498
1055
            reference_format = reference_bzrdir_format.repository_format
499
1056
            network_name = reference_format.network_name()
500
1057
        # 2) try direct creation via RPC
526
1083
 
527
1084
    def _ensure_real(self):
528
1085
        if self._custom_format is None:
529
 
            self._custom_format = repository.network_format_registry.get(
530
 
                self._network_name)
 
1086
            try:
 
1087
                self._custom_format = _mod_repository.network_format_registry.get(
 
1088
                    self._network_name)
 
1089
            except KeyError:
 
1090
                raise errors.UnknownFormatError(kind='repository',
 
1091
                    format=self._network_name)
531
1092
 
532
1093
    @property
533
1094
    def _fetch_order(self):
545
1106
        return self._custom_format._fetch_reconcile
546
1107
 
547
1108
    def get_format_description(self):
548
 
        return 'bzr remote repository'
 
1109
        self._ensure_real()
 
1110
        return 'Remote: ' + self._custom_format.get_format_description()
549
1111
 
550
1112
    def __eq__(self, other):
551
1113
        return self.__class__ is other.__class__
552
1114
 
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
 
 
562
1115
    def network_name(self):
563
1116
        if self._network_name:
564
1117
            return self._network_name
566
1119
        return self._creating_repo._real_repository._format.network_name()
567
1120
 
568
1121
    @property
 
1122
    def pack_compresses(self):
 
1123
        self._ensure_real()
 
1124
        return self._custom_format.pack_compresses
 
1125
 
 
1126
    @property
569
1127
    def _serializer(self):
570
1128
        self._ensure_real()
571
1129
        return self._custom_format._serializer
572
1130
 
573
1131
 
574
 
class RemoteRepository(_RpcHelper):
 
1132
class RemoteRepository(_mod_repository.Repository, _RpcHelper,
 
1133
        lock._RelockDebugMixin):
575
1134
    """Repository accessed over rpc.
576
1135
 
577
1136
    For the moment most operations are performed using local transport-backed
601
1160
        self._format = format
602
1161
        self._lock_mode = None
603
1162
        self._lock_token = None
 
1163
        self._write_group_tokens = None
604
1164
        self._lock_count = 0
605
1165
        self._leave_lock = False
606
1166
        # Cache of revision parents; misses are cached during read locks, and
620
1180
        # Additional places to query for data.
621
1181
        self._fallback_repositories = []
622
1182
 
 
1183
    @property
 
1184
    def user_transport(self):
 
1185
        return self.bzrdir.user_transport
 
1186
 
 
1187
    @property
 
1188
    def control_transport(self):
 
1189
        # XXX: Normally you shouldn't directly get at the remote repository
 
1190
        # transport, but I'm not sure it's worth making this method
 
1191
        # optional -- mbp 2010-04-21
 
1192
        return self.bzrdir.get_repository_transport(None)
 
1193
 
623
1194
    def __str__(self):
624
1195
        return "%s(%s)" % (self.__class__.__name__, self.base)
625
1196
 
635
1206
 
636
1207
        :param suppress_errors: see Repository.abort_write_group.
637
1208
        """
638
 
        self._ensure_real()
639
 
        return self._real_repository.abort_write_group(
640
 
            suppress_errors=suppress_errors)
 
1209
        if self._real_repository:
 
1210
            self._ensure_real()
 
1211
            return self._real_repository.abort_write_group(
 
1212
                suppress_errors=suppress_errors)
 
1213
        if not self.is_in_write_group():
 
1214
            if suppress_errors:
 
1215
                mutter('(suppressed) not in write group')
 
1216
                return
 
1217
            raise errors.BzrError("not in write group")
 
1218
        path = self.bzrdir._path_for_remote_call(self._client)
 
1219
        try:
 
1220
            response = self._call('Repository.abort_write_group', path,
 
1221
                self._lock_token, self._write_group_tokens)
 
1222
        except Exception, exc:
 
1223
            self._write_group = None
 
1224
            if not suppress_errors:
 
1225
                raise
 
1226
            mutter('abort_write_group failed')
 
1227
            log_exception_quietly()
 
1228
            note(gettext('bzr: ERROR (ignored): %s'), exc)
 
1229
        else:
 
1230
            if response != ('ok', ):
 
1231
                raise errors.UnexpectedSmartServerResponse(response)
 
1232
            self._write_group_tokens = None
641
1233
 
642
1234
    @property
643
1235
    def chk_bytes(self):
657
1249
        for older plugins that don't use e.g. the CommitBuilder
658
1250
        facility.
659
1251
        """
660
 
        self._ensure_real()
661
 
        return self._real_repository.commit_write_group()
 
1252
        if self._real_repository:
 
1253
            self._ensure_real()
 
1254
            return self._real_repository.commit_write_group()
 
1255
        if not self.is_in_write_group():
 
1256
            raise errors.BzrError("not in write group")
 
1257
        path = self.bzrdir._path_for_remote_call(self._client)
 
1258
        response = self._call('Repository.commit_write_group', path,
 
1259
            self._lock_token, self._write_group_tokens)
 
1260
        if response != ('ok', ):
 
1261
            raise errors.UnexpectedSmartServerResponse(response)
 
1262
        self._write_group_tokens = None
 
1263
        # Refresh data after writing to the repository.
 
1264
        self.refresh_data()
662
1265
 
663
1266
    def resume_write_group(self, tokens):
664
 
        self._ensure_real()
665
 
        return self._real_repository.resume_write_group(tokens)
 
1267
        if self._real_repository:
 
1268
            return self._real_repository.resume_write_group(tokens)
 
1269
        path = self.bzrdir._path_for_remote_call(self._client)
 
1270
        try:
 
1271
            response = self._call('Repository.check_write_group', path,
 
1272
               self._lock_token, tokens)
 
1273
        except errors.UnknownSmartMethod:
 
1274
            self._ensure_real()
 
1275
            return self._real_repository.resume_write_group(tokens)
 
1276
        if response != ('ok', ):
 
1277
            raise errors.UnexpectedSmartServerResponse(response)
 
1278
        self._write_group_tokens = tokens
666
1279
 
667
1280
    def suspend_write_group(self):
668
 
        self._ensure_real()
669
 
        return self._real_repository.suspend_write_group()
 
1281
        if self._real_repository:
 
1282
            return self._real_repository.suspend_write_group()
 
1283
        ret = self._write_group_tokens or []
 
1284
        self._write_group_tokens = None
 
1285
        return ret
670
1286
 
671
1287
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
672
1288
        self._ensure_real()
718
1334
        invocation. If in doubt chat to the bzr network team.
719
1335
        """
720
1336
        if self._real_repository is None:
721
 
            if 'hpss' in debug.debug_flags:
 
1337
            if 'hpssvfs' in debug.debug_flags:
722
1338
                import traceback
723
1339
                warning('VFS Repository access triggered\n%s',
724
1340
                    ''.join(traceback.format_stack()))
733
1349
    def find_text_key_references(self):
734
1350
        """Find the text key references within the repository.
735
1351
 
736
 
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
737
 
        revision_ids. Each altered file-ids has the exact revision_ids that
738
 
        altered it listed explicitly.
739
1352
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
740
1353
            to whether they were referred to by the inventory of the
741
1354
            revision_id that they contain. The inventory texts from all present
759
1372
        """Private method for using with old (< 1.2) servers to fallback."""
760
1373
        if revision_id is None:
761
1374
            revision_id = ''
762
 
        elif revision.is_null(revision_id):
 
1375
        elif _mod_revision.is_null(revision_id):
763
1376
            return {}
764
1377
 
765
1378
        path = self.bzrdir._path_for_remote_call(self._client)
789
1402
        return RemoteStreamSource(self, to_format)
790
1403
 
791
1404
    @needs_read_lock
 
1405
    def get_file_graph(self):
 
1406
        return graph.Graph(self.texts)
 
1407
 
 
1408
    @needs_read_lock
792
1409
    def has_revision(self, revision_id):
793
1410
        """True if this repository has a copy of the revision."""
794
1411
        # Copy of bzrlib.repository.Repository.has_revision
808
1425
            result.add(_mod_revision.NULL_REVISION)
809
1426
        return result
810
1427
 
 
1428
    def _has_same_fallbacks(self, other_repo):
 
1429
        """Returns true if the repositories have the same fallbacks."""
 
1430
        # XXX: copied from Repository; it should be unified into a base class
 
1431
        # <https://bugs.launchpad.net/bzr/+bug/401622>
 
1432
        my_fb = self._fallback_repositories
 
1433
        other_fb = other_repo._fallback_repositories
 
1434
        if len(my_fb) != len(other_fb):
 
1435
            return False
 
1436
        for f, g in zip(my_fb, other_fb):
 
1437
            if not f.has_same_location(g):
 
1438
                return False
 
1439
        return True
 
1440
 
811
1441
    def has_same_location(self, other):
 
1442
        # TODO: Move to RepositoryBase and unify with the regular Repository
 
1443
        # one; unfortunately the tests rely on slightly different behaviour at
 
1444
        # present -- mbp 20090710
812
1445
        return (self.__class__ is other.__class__ and
813
1446
                self.bzrdir.transport.base == other.bzrdir.transport.base)
814
1447
 
817
1450
        parents_provider = self._make_parents_provider(other_repository)
818
1451
        return graph.Graph(parents_provider)
819
1452
 
 
1453
    @needs_read_lock
 
1454
    def get_known_graph_ancestry(self, revision_ids):
 
1455
        """Return the known graph for a set of revision ids and their ancestors.
 
1456
        """
 
1457
        st = static_tuple.StaticTuple
 
1458
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
 
1459
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
 
1460
        return graph.GraphThunkIdsToKeys(known_graph)
 
1461
 
820
1462
    def gather_stats(self, revid=None, committers=None):
821
1463
        """See Repository.gather_stats()."""
822
1464
        path = self.bzrdir._path_for_remote_call(self._client)
823
1465
        # revid can be None to indicate no revisions, not just NULL_REVISION
824
 
        if revid is None or revision.is_null(revid):
 
1466
        if revid is None or _mod_revision.is_null(revid):
825
1467
            fmt_revid = ''
826
1468
        else:
827
1469
            fmt_revid = revid
856
1498
 
857
1499
    def get_physical_lock_status(self):
858
1500
        """See Repository.get_physical_lock_status()."""
859
 
        # should be an API call to the server.
860
 
        self._ensure_real()
861
 
        return self._real_repository.get_physical_lock_status()
 
1501
        path = self.bzrdir._path_for_remote_call(self._client)
 
1502
        try:
 
1503
            response = self._call('Repository.get_physical_lock_status', path)
 
1504
        except errors.UnknownSmartMethod:
 
1505
            self._ensure_real()
 
1506
            return self._real_repository.get_physical_lock_status()
 
1507
        if response[0] not in ('yes', 'no'):
 
1508
            raise errors.UnexpectedSmartServerResponse(response)
 
1509
        return (response[0] == 'yes')
862
1510
 
863
1511
    def is_in_write_group(self):
864
1512
        """Return True if there is an open write group.
865
1513
 
866
1514
        write groups are only applicable locally for the smart server..
867
1515
        """
 
1516
        if self._write_group_tokens is not None:
 
1517
            return True
868
1518
        if self._real_repository:
869
1519
            return self._real_repository.is_in_write_group()
870
1520
 
882
1532
    def is_write_locked(self):
883
1533
        return self._lock_mode == 'w'
884
1534
 
 
1535
    def _warn_if_deprecated(self, branch=None):
 
1536
        # If we have a real repository, the check will be done there, if we
 
1537
        # don't the check will be done remotely.
 
1538
        pass
 
1539
 
885
1540
    def lock_read(self):
 
1541
        """Lock the repository for read operations.
 
1542
 
 
1543
        :return: A bzrlib.lock.LogicalLockResult.
 
1544
        """
886
1545
        # wrong eventually - want a local lock cache context
887
1546
        if not self._lock_mode:
 
1547
            self._note_lock('r')
888
1548
            self._lock_mode = 'r'
889
1549
            self._lock_count = 1
890
1550
            self._unstacked_provider.enable_cache(cache_misses=True)
894
1554
                repo.lock_read()
895
1555
        else:
896
1556
            self._lock_count += 1
 
1557
        return lock.LogicalLockResult(self.unlock)
897
1558
 
898
1559
    def _remote_lock_write(self, token):
899
1560
        path = self.bzrdir._path_for_remote_call(self._client)
910
1571
 
911
1572
    def lock_write(self, token=None, _skip_rpc=False):
912
1573
        if not self._lock_mode:
 
1574
            self._note_lock('w')
913
1575
            if _skip_rpc:
914
1576
                if self._lock_token is not None:
915
1577
                    if token != self._lock_token:
938
1600
            raise errors.ReadOnlyError(self)
939
1601
        else:
940
1602
            self._lock_count += 1
941
 
        return self._lock_token or None
 
1603
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
942
1604
 
943
1605
    def leave_lock_in_place(self):
944
1606
        if not self._lock_token:
993
1655
            self._real_repository.lock_write(self._lock_token)
994
1656
        elif self._lock_mode == 'r':
995
1657
            self._real_repository.lock_read()
 
1658
        if self._write_group_tokens is not None:
 
1659
            # if we are already in a write group, resume it
 
1660
            self._real_repository.resume_write_group(self._write_group_tokens)
 
1661
            self._write_group_tokens = None
996
1662
 
997
1663
    def start_write_group(self):
998
1664
        """Start a write group on the decorated repository.
1002
1668
        for older plugins that don't use e.g. the CommitBuilder
1003
1669
        facility.
1004
1670
        """
1005
 
        self._ensure_real()
1006
 
        return self._real_repository.start_write_group()
 
1671
        if self._real_repository:
 
1672
            self._ensure_real()
 
1673
            return self._real_repository.start_write_group()
 
1674
        if not self.is_write_locked():
 
1675
            raise errors.NotWriteLocked(self)
 
1676
        if self._write_group_tokens is not None:
 
1677
            raise errors.BzrError('already in a write group')
 
1678
        path = self.bzrdir._path_for_remote_call(self._client)
 
1679
        try:
 
1680
            response = self._call('Repository.start_write_group', path,
 
1681
                self._lock_token)
 
1682
        except (errors.UnknownSmartMethod, errors.UnsuspendableWriteGroup):
 
1683
            self._ensure_real()
 
1684
            return self._real_repository.start_write_group()
 
1685
        if response[0] != 'ok':
 
1686
            raise errors.UnexpectedSmartServerResponse(response)
 
1687
        self._write_group_tokens = response[1]
1007
1688
 
1008
1689
    def _unlock(self, token):
1009
1690
        path = self.bzrdir._path_for_remote_call(self._client)
1018
1699
        else:
1019
1700
            raise errors.UnexpectedSmartServerResponse(response)
1020
1701
 
 
1702
    @only_raises(errors.LockNotHeld, errors.LockBroken)
1021
1703
    def unlock(self):
1022
1704
        if not self._lock_count:
1023
 
            raise errors.LockNotHeld(self)
 
1705
            return lock.cant_unlock_not_held(self)
1024
1706
        self._lock_count -= 1
1025
1707
        if self._lock_count > 0:
1026
1708
            return
1035
1717
            # This is just to let the _real_repository stay up to date.
1036
1718
            if self._real_repository is not None:
1037
1719
                self._real_repository.unlock()
 
1720
            elif self._write_group_tokens is not None:
 
1721
                self.abort_write_group()
1038
1722
        finally:
1039
1723
            # The rpc-level lock should be released even if there was a
1040
1724
            # problem releasing the vfs-based lock.
1052
1736
 
1053
1737
    def break_lock(self):
1054
1738
        # should hand off to the network
1055
 
        self._ensure_real()
1056
 
        return self._real_repository.break_lock()
 
1739
        path = self.bzrdir._path_for_remote_call(self._client)
 
1740
        try:
 
1741
            response = self._call("Repository.break_lock", path)
 
1742
        except errors.UnknownSmartMethod:
 
1743
            self._ensure_real()
 
1744
            return self._real_repository.break_lock()
 
1745
        if response != ('ok',):
 
1746
            raise errors.UnexpectedSmartServerResponse(response)
1057
1747
 
1058
1748
    def _get_tarball(self, compression):
1059
1749
        """Return a TemporaryFile containing a repository tarball.
1077
1767
            return t
1078
1768
        raise errors.UnexpectedSmartServerResponse(response)
1079
1769
 
 
1770
    @needs_read_lock
1080
1771
    def sprout(self, to_bzrdir, revision_id=None):
1081
 
        # TODO: Option to control what format is created?
1082
 
        self._ensure_real()
1083
 
        dest_repo = self._real_repository._format.initialize(to_bzrdir,
1084
 
                                                             shared=False)
 
1772
        """Create a descendent repository for new development.
 
1773
 
 
1774
        Unlike clone, this does not copy the settings of the repository.
 
1775
        """
 
1776
        dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
1085
1777
        dest_repo.fetch(self, revision_id=revision_id)
1086
1778
        return dest_repo
1087
1779
 
 
1780
    def _create_sprouting_repo(self, a_bzrdir, shared):
 
1781
        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
 
1782
            # use target default format.
 
1783
            dest_repo = a_bzrdir.create_repository()
 
1784
        else:
 
1785
            # Most control formats need the repository to be specifically
 
1786
            # created, but on some old all-in-one formats it's not needed
 
1787
            try:
 
1788
                dest_repo = self._format.initialize(a_bzrdir, shared=shared)
 
1789
            except errors.UninitializableFormat:
 
1790
                dest_repo = a_bzrdir.open_repository()
 
1791
        return dest_repo
 
1792
 
1088
1793
    ### These methods are just thin shims to the VFS object for now.
1089
1794
 
 
1795
    @needs_read_lock
1090
1796
    def revision_tree(self, revision_id):
1091
 
        self._ensure_real()
1092
 
        return self._real_repository.revision_tree(revision_id)
 
1797
        revision_id = _mod_revision.ensure_null(revision_id)
 
1798
        if revision_id == _mod_revision.NULL_REVISION:
 
1799
            return InventoryRevisionTree(self,
 
1800
                Inventory(root_id=None), _mod_revision.NULL_REVISION)
 
1801
        else:
 
1802
            return list(self.revision_trees([revision_id]))[0]
1093
1803
 
1094
1804
    def get_serializer_format(self):
1095
 
        self._ensure_real()
1096
 
        return self._real_repository.get_serializer_format()
 
1805
        path = self.bzrdir._path_for_remote_call(self._client)
 
1806
        try:
 
1807
            response = self._call('VersionedFileRepository.get_serializer_format',
 
1808
                path)
 
1809
        except errors.UnknownSmartMethod:
 
1810
            self._ensure_real()
 
1811
            return self._real_repository.get_serializer_format()
 
1812
        if response[0] != 'ok':
 
1813
            raise errors.UnexpectedSmartServerResponse(response)
 
1814
        return response[1]
1097
1815
 
1098
1816
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1099
1817
                           timezone=None, committer=None, revprops=None,
1100
 
                           revision_id=None):
1101
 
        # FIXME: It ought to be possible to call this without immediately
1102
 
        # triggering _ensure_real.  For now it's the easiest thing to do.
1103
 
        self._ensure_real()
1104
 
        real_repo = self._real_repository
1105
 
        builder = real_repo.get_commit_builder(branch, parents,
1106
 
                config, timestamp=timestamp, timezone=timezone,
1107
 
                committer=committer, revprops=revprops, revision_id=revision_id)
1108
 
        return builder
 
1818
                           revision_id=None, lossy=False):
 
1819
        """Obtain a CommitBuilder for this repository.
 
1820
 
 
1821
        :param branch: Branch to commit to.
 
1822
        :param parents: Revision ids of the parents of the new revision.
 
1823
        :param config: Configuration to use.
 
1824
        :param timestamp: Optional timestamp recorded for commit.
 
1825
        :param timezone: Optional timezone for timestamp.
 
1826
        :param committer: Optional committer to set for commit.
 
1827
        :param revprops: Optional dictionary of revision properties.
 
1828
        :param revision_id: Optional revision id.
 
1829
        :param lossy: Whether to discard data that can not be natively
 
1830
            represented, when pushing to a foreign VCS
 
1831
        """
 
1832
        if self._fallback_repositories and not self._format.supports_chks:
 
1833
            raise errors.BzrError("Cannot commit directly to a stacked branch"
 
1834
                " in pre-2a formats. See "
 
1835
                "https://bugs.launchpad.net/bzr/+bug/375013 for details.")
 
1836
        if self._format.rich_root_data:
 
1837
            commit_builder_kls = vf_repository.VersionedFileRootCommitBuilder
 
1838
        else:
 
1839
            commit_builder_kls = vf_repository.VersionedFileCommitBuilder
 
1840
        result = commit_builder_kls(self, parents, config,
 
1841
            timestamp, timezone, committer, revprops, revision_id,
 
1842
            lossy)
 
1843
        self.start_write_group()
 
1844
        return result
1109
1845
 
1110
1846
    def add_fallback_repository(self, repository):
1111
1847
        """Add a repository to use for looking up data not held locally.
1118
1854
        # We need to accumulate additional repositories here, to pass them in
1119
1855
        # on various RPC's.
1120
1856
        #
 
1857
        # Make the check before we lock: this raises an exception.
 
1858
        self._check_fallback_repository(repository)
1121
1859
        if self.is_locked():
1122
1860
            # We will call fallback.unlock() when we transition to the unlocked
1123
1861
            # state, so always add a lock here. If a caller passes us a locked
1128
1866
        # _real_branch had its get_stacked_on_url method called), then the
1129
1867
        # repository to be added may already be in the _real_repositories list.
1130
1868
        if self._real_repository is not None:
1131
 
            fallback_locations = [repo.bzrdir.root_transport.base for repo in
 
1869
            fallback_locations = [repo.user_url for repo in
1132
1870
                self._real_repository._fallback_repositories]
1133
 
            if repository.bzrdir.root_transport.base not in fallback_locations:
 
1871
            if repository.user_url not in fallback_locations:
1134
1872
                self._real_repository.add_fallback_repository(repository)
1135
1873
 
 
1874
    def _check_fallback_repository(self, repository):
 
1875
        """Check that this repository can fallback to repository safely.
 
1876
 
 
1877
        Raise an error if not.
 
1878
 
 
1879
        :param repository: A repository to fallback to.
 
1880
        """
 
1881
        return _mod_repository.InterRepository._assert_same_model(
 
1882
            self, repository)
 
1883
 
1136
1884
    def add_inventory(self, revid, inv, parents):
1137
1885
        self._ensure_real()
1138
1886
        return self._real_repository.add_inventory(revid, inv, parents)
1139
1887
 
1140
1888
    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1141
 
                               parents):
 
1889
            parents, basis_inv=None, propagate_caches=False):
1142
1890
        self._ensure_real()
1143
1891
        return self._real_repository.add_inventory_by_delta(basis_revision_id,
1144
 
            delta, new_revision_id, parents)
1145
 
 
1146
 
    def add_revision(self, rev_id, rev, inv=None, config=None):
1147
 
        self._ensure_real()
1148
 
        return self._real_repository.add_revision(
1149
 
            rev_id, rev, inv=inv, config=config)
 
1892
            delta, new_revision_id, parents, basis_inv=basis_inv,
 
1893
            propagate_caches=propagate_caches)
 
1894
 
 
1895
    def add_revision(self, revision_id, rev, inv=None):
 
1896
        _mod_revision.check_not_reserved_id(revision_id)
 
1897
        key = (revision_id,)
 
1898
        # check inventory present
 
1899
        if not self.inventories.get_parent_map([key]):
 
1900
            if inv is None:
 
1901
                raise errors.WeaveRevisionNotPresent(revision_id,
 
1902
                                                     self.inventories)
 
1903
            else:
 
1904
                # yes, this is not suitable for adding with ghosts.
 
1905
                rev.inventory_sha1 = self.add_inventory(revision_id, inv,
 
1906
                                                        rev.parent_ids)
 
1907
        else:
 
1908
            rev.inventory_sha1 = self.inventories.get_sha1s([key])[key]
 
1909
        self._add_revision(rev)
 
1910
 
 
1911
    def _add_revision(self, rev):
 
1912
        if self._real_repository is not None:
 
1913
            return self._real_repository._add_revision(rev)
 
1914
        text = self._serializer.write_revision_to_string(rev)
 
1915
        key = (rev.revision_id,)
 
1916
        parents = tuple((parent,) for parent in rev.parent_ids)
 
1917
        self._write_group_tokens, missing_keys = self._get_sink().insert_stream(
 
1918
            [('revisions', [FulltextContentFactory(key, parents, None, text)])],
 
1919
            self._format, self._write_group_tokens)
1150
1920
 
1151
1921
    @needs_read_lock
1152
1922
    def get_inventory(self, revision_id):
1153
 
        self._ensure_real()
1154
 
        return self._real_repository.get_inventory(revision_id)
1155
 
 
1156
 
    def iter_inventories(self, revision_ids):
1157
 
        self._ensure_real()
1158
 
        return self._real_repository.iter_inventories(revision_ids)
 
1923
        return list(self.iter_inventories([revision_id]))[0]
 
1924
 
 
1925
    def _iter_inventories_rpc(self, revision_ids, ordering):
 
1926
        if ordering is None:
 
1927
            ordering = 'unordered'
 
1928
        path = self.bzrdir._path_for_remote_call(self._client)
 
1929
        body = "\n".join(revision_ids)
 
1930
        response_tuple, response_handler = (
 
1931
            self._call_with_body_bytes_expecting_body(
 
1932
                "VersionedFileRepository.get_inventories",
 
1933
                (path, ordering), body))
 
1934
        if response_tuple[0] != "ok":
 
1935
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
1936
        deserializer = inventory_delta.InventoryDeltaDeserializer()
 
1937
        byte_stream = response_handler.read_streamed_body()
 
1938
        decoded = smart_repo._byte_stream_to_stream(byte_stream)
 
1939
        if decoded is None:
 
1940
            # no results whatsoever
 
1941
            return
 
1942
        src_format, stream = decoded
 
1943
        if src_format.network_name() != self._format.network_name():
 
1944
            raise AssertionError(
 
1945
                "Mismatched RemoteRepository and stream src %r, %r" % (
 
1946
                src_format.network_name(), self._format.network_name()))
 
1947
        # ignore the src format, it's not really relevant
 
1948
        prev_inv = Inventory(root_id=None,
 
1949
            revision_id=_mod_revision.NULL_REVISION)
 
1950
        # there should be just one substream, with inventory deltas
 
1951
        substream_kind, substream = stream.next()
 
1952
        if substream_kind != "inventory-deltas":
 
1953
            raise AssertionError(
 
1954
                 "Unexpected stream %r received" % substream_kind)
 
1955
        for record in substream:
 
1956
            (parent_id, new_id, versioned_root, tree_references, invdelta) = (
 
1957
                deserializer.parse_text_bytes(record.get_bytes_as("fulltext")))
 
1958
            if parent_id != prev_inv.revision_id:
 
1959
                raise AssertionError("invalid base %r != %r" % (parent_id,
 
1960
                    prev_inv.revision_id))
 
1961
            inv = prev_inv.create_by_apply_delta(invdelta, new_id)
 
1962
            yield inv, inv.revision_id
 
1963
            prev_inv = inv
 
1964
 
 
1965
    def _iter_inventories_vfs(self, revision_ids, ordering=None):
 
1966
        self._ensure_real()
 
1967
        return self._real_repository._iter_inventories(revision_ids, ordering)
 
1968
 
 
1969
    def iter_inventories(self, revision_ids, ordering=None):
 
1970
        """Get many inventories by revision_ids.
 
1971
 
 
1972
        This will buffer some or all of the texts used in constructing the
 
1973
        inventories in memory, but will only parse a single inventory at a
 
1974
        time.
 
1975
 
 
1976
        :param revision_ids: The expected revision ids of the inventories.
 
1977
        :param ordering: optional ordering, e.g. 'topological'.  If not
 
1978
            specified, the order of revision_ids will be preserved (by
 
1979
            buffering if necessary).
 
1980
        :return: An iterator of inventories.
 
1981
        """
 
1982
        if ((None in revision_ids)
 
1983
            or (_mod_revision.NULL_REVISION in revision_ids)):
 
1984
            raise ValueError('cannot get null revision inventory')
 
1985
        for inv, revid in self._iter_inventories(revision_ids, ordering):
 
1986
            if inv is None:
 
1987
                raise errors.NoSuchRevision(self, revid)
 
1988
            yield inv
 
1989
 
 
1990
    def _iter_inventories(self, revision_ids, ordering=None):
 
1991
        if len(revision_ids) == 0:
 
1992
            return
 
1993
        missing = set(revision_ids)
 
1994
        if ordering is None:
 
1995
            order_as_requested = True
 
1996
            invs = {}
 
1997
            order = list(revision_ids)
 
1998
            order.reverse()
 
1999
            next_revid = order.pop()
 
2000
        else:
 
2001
            order_as_requested = False
 
2002
            if ordering != 'unordered' and self._fallback_repositories:
 
2003
                raise ValueError('unsupported ordering %r' % ordering)
 
2004
        iter_inv_fns = [self._iter_inventories_rpc] + [
 
2005
            fallback._iter_inventories for fallback in
 
2006
            self._fallback_repositories]
 
2007
        try:
 
2008
            for iter_inv in iter_inv_fns:
 
2009
                request = [revid for revid in revision_ids if revid in missing]
 
2010
                for inv, revid in iter_inv(request, ordering):
 
2011
                    if inv is None:
 
2012
                        continue
 
2013
                    missing.remove(inv.revision_id)
 
2014
                    if ordering != 'unordered':
 
2015
                        invs[revid] = inv
 
2016
                    else:
 
2017
                        yield inv, revid
 
2018
                if order_as_requested:
 
2019
                    # Yield as many results as we can while preserving order.
 
2020
                    while next_revid in invs:
 
2021
                        inv = invs.pop(next_revid)
 
2022
                        yield inv, inv.revision_id
 
2023
                        try:
 
2024
                            next_revid = order.pop()
 
2025
                        except IndexError:
 
2026
                            # We still want to fully consume the stream, just
 
2027
                            # in case it is not actually finished at this point
 
2028
                            next_revid = None
 
2029
                            break
 
2030
        except errors.UnknownSmartMethod:
 
2031
            for inv, revid in self._iter_inventories_vfs(revision_ids, ordering):
 
2032
                yield inv, revid
 
2033
            return
 
2034
        # Report missing
 
2035
        if order_as_requested:
 
2036
            if next_revid is not None:
 
2037
                yield None, next_revid
 
2038
            while order:
 
2039
                revid = order.pop()
 
2040
                yield invs.get(revid), revid
 
2041
        else:
 
2042
            while missing:
 
2043
                yield None, missing.pop()
1159
2044
 
1160
2045
    @needs_read_lock
1161
2046
    def get_revision(self, revision_id):
1162
 
        self._ensure_real()
1163
 
        return self._real_repository.get_revision(revision_id)
 
2047
        return self.get_revisions([revision_id])[0]
1164
2048
 
1165
2049
    def get_transaction(self):
1166
2050
        self._ensure_real()
1168
2052
 
1169
2053
    @needs_read_lock
1170
2054
    def clone(self, a_bzrdir, revision_id=None):
1171
 
        self._ensure_real()
1172
 
        return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
 
2055
        dest_repo = self._create_sprouting_repo(
 
2056
            a_bzrdir, shared=self.is_shared())
 
2057
        self.copy_content_into(dest_repo, revision_id)
 
2058
        return dest_repo
1173
2059
 
1174
2060
    def make_working_trees(self):
1175
2061
        """See Repository.make_working_trees"""
1176
 
        self._ensure_real()
1177
 
        return self._real_repository.make_working_trees()
 
2062
        path = self.bzrdir._path_for_remote_call(self._client)
 
2063
        try:
 
2064
            response = self._call('Repository.make_working_trees', path)
 
2065
        except errors.UnknownSmartMethod:
 
2066
            self._ensure_real()
 
2067
            return self._real_repository.make_working_trees()
 
2068
        if response[0] not in ('yes', 'no'):
 
2069
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2070
        return response[0] == 'yes'
1178
2071
 
1179
2072
    def refresh_data(self):
1180
 
        """Re-read any data needed to to synchronise with disk.
 
2073
        """Re-read any data needed to synchronise with disk.
1181
2074
 
1182
2075
        This method is intended to be called after another repository instance
1183
2076
        (such as one used by a smart server) has inserted data into the
1184
 
        repository. It may not be called during a write group, but may be
1185
 
        called at any other time.
 
2077
        repository. On all repositories this will work outside of write groups.
 
2078
        Some repository formats (pack and newer for bzrlib native formats)
 
2079
        support refresh_data inside write groups. If called inside a write
 
2080
        group on a repository that does not support refreshing in a write group
 
2081
        IsInWriteGroupError will be raised.
1186
2082
        """
1187
 
        if self.is_in_write_group():
1188
 
            raise errors.InternalBzrError(
1189
 
                "May not refresh_data while in a write group.")
1190
2083
        if self._real_repository is not None:
1191
2084
            self._real_repository.refresh_data()
 
2085
        # Refresh the parents cache for this object
 
2086
        self._unstacked_provider.disable_cache()
 
2087
        self._unstacked_provider.enable_cache()
1192
2088
 
1193
2089
    def revision_ids_to_search_result(self, result_set):
1194
2090
        """Convert a set of revision ids to a graph SearchResult."""
1199
2095
        included_keys = result_set.intersection(result_parents)
1200
2096
        start_keys = result_set.difference(included_keys)
1201
2097
        exclude_keys = result_parents.difference(result_set)
1202
 
        result = graph.SearchResult(start_keys, exclude_keys,
 
2098
        result = vf_search.SearchResult(start_keys, exclude_keys,
1203
2099
            len(result_set), result_set)
1204
2100
        return result
1205
2101
 
1206
2102
    @needs_read_lock
1207
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
2103
    def search_missing_revision_ids(self, other,
 
2104
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
2105
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
2106
            limit=None):
1208
2107
        """Return the revision ids that other has that this does not.
1209
2108
 
1210
2109
        These are returned in topological order.
1211
2110
 
1212
2111
        revision_id: only return revision ids included by revision_id.
1213
2112
        """
1214
 
        return repository.InterRepository.get(
1215
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
2113
        if symbol_versioning.deprecated_passed(revision_id):
 
2114
            symbol_versioning.warn(
 
2115
                'search_missing_revision_ids(revision_id=...) was '
 
2116
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
2117
                DeprecationWarning, stacklevel=2)
 
2118
            if revision_ids is not None:
 
2119
                raise AssertionError(
 
2120
                    'revision_ids is mutually exclusive with revision_id')
 
2121
            if revision_id is not None:
 
2122
                revision_ids = [revision_id]
 
2123
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
2124
        return inter_repo.search_missing_revision_ids(
 
2125
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
2126
            if_present_ids=if_present_ids, limit=limit)
1216
2127
 
1217
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
2128
    def fetch(self, source, revision_id=None, find_ghosts=False,
1218
2129
            fetch_spec=None):
1219
2130
        # No base implementation to use as RemoteRepository is not a subclass
1220
2131
        # of Repository; so this is a copy of Repository.fetch().
1225
2136
            raise errors.InternalBzrError(
1226
2137
                "May not fetch while in a write group.")
1227
2138
        # fast path same-url fetch operations
1228
 
        if self.has_same_location(source) and fetch_spec is None:
 
2139
        if (self.has_same_location(source)
 
2140
            and fetch_spec is None
 
2141
            and self._has_same_fallbacks(source)):
1229
2142
            # check that last_revision is in 'from' and then return a
1230
2143
            # no-operation.
1231
2144
            if (revision_id is not None and
1232
 
                not revision.is_null(revision_id)):
 
2145
                not _mod_revision.is_null(revision_id)):
1233
2146
                self.get_revision(revision_id)
1234
2147
            return 0, []
1235
2148
        # if there is no specific appropriate InterRepository, this will get
1236
2149
        # the InterRepository base class, which raises an
1237
2150
        # IncompatibleRepositories when asked to fetch.
1238
 
        inter = repository.InterRepository.get(source, self)
1239
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
2151
        inter = _mod_repository.InterRepository.get(source, self)
 
2152
        if (fetch_spec is not None and
 
2153
            not getattr(inter, "supports_fetch_spec", False)):
 
2154
            raise errors.UnsupportedOperation(
 
2155
                "fetch_spec not supported for %r" % inter)
 
2156
        return inter.fetch(revision_id=revision_id,
1240
2157
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1241
2158
 
1242
2159
    def create_bundle(self, target, base, fileobj, format=None):
1244
2161
        self._real_repository.create_bundle(target, base, fileobj, format)
1245
2162
 
1246
2163
    @needs_read_lock
 
2164
    @symbol_versioning.deprecated_method(
 
2165
        symbol_versioning.deprecated_in((2, 4, 0)))
1247
2166
    def get_ancestry(self, revision_id, topo_sorted=True):
1248
2167
        self._ensure_real()
1249
2168
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1257
2176
        return self._real_repository._get_versioned_file_checker(
1258
2177
            revisions, revision_versions_cache)
1259
2178
 
 
2179
    def _iter_files_bytes_rpc(self, desired_files, absent):
 
2180
        path = self.bzrdir._path_for_remote_call(self._client)
 
2181
        lines = []
 
2182
        identifiers = []
 
2183
        for (file_id, revid, identifier) in desired_files:
 
2184
            lines.append("%s\0%s" % (
 
2185
                osutils.safe_file_id(file_id),
 
2186
                osutils.safe_revision_id(revid)))
 
2187
            identifiers.append(identifier)
 
2188
        (response_tuple, response_handler) = (
 
2189
            self._call_with_body_bytes_expecting_body(
 
2190
            "Repository.iter_files_bytes", (path, ), "\n".join(lines)))
 
2191
        if response_tuple != ('ok', ):
 
2192
            response_handler.cancel_read_body()
 
2193
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2194
        byte_stream = response_handler.read_streamed_body()
 
2195
        def decompress_stream(start, byte_stream, unused):
 
2196
            decompressor = zlib.decompressobj()
 
2197
            yield decompressor.decompress(start)
 
2198
            while decompressor.unused_data == "":
 
2199
                try:
 
2200
                    data = byte_stream.next()
 
2201
                except StopIteration:
 
2202
                    break
 
2203
                yield decompressor.decompress(data)
 
2204
            yield decompressor.flush()
 
2205
            unused.append(decompressor.unused_data)
 
2206
        unused = ""
 
2207
        while True:
 
2208
            while not "\n" in unused:
 
2209
                unused += byte_stream.next()
 
2210
            header, rest = unused.split("\n", 1)
 
2211
            args = header.split("\0")
 
2212
            if args[0] == "absent":
 
2213
                absent[identifiers[int(args[3])]] = (args[1], args[2])
 
2214
                unused = rest
 
2215
                continue
 
2216
            elif args[0] == "ok":
 
2217
                idx = int(args[1])
 
2218
            else:
 
2219
                raise errors.UnexpectedSmartServerResponse(args)
 
2220
            unused_chunks = []
 
2221
            yield (identifiers[idx],
 
2222
                decompress_stream(rest, byte_stream, unused_chunks))
 
2223
            unused = "".join(unused_chunks)
 
2224
 
1260
2225
    def iter_files_bytes(self, desired_files):
1261
2226
        """See Repository.iter_file_bytes.
1262
2227
        """
1263
 
        self._ensure_real()
1264
 
        return self._real_repository.iter_files_bytes(desired_files)
 
2228
        try:
 
2229
            absent = {}
 
2230
            for (identifier, bytes_iterator) in self._iter_files_bytes_rpc(
 
2231
                    desired_files, absent):
 
2232
                yield identifier, bytes_iterator
 
2233
            for fallback in self._fallback_repositories:
 
2234
                if not absent:
 
2235
                    break
 
2236
                desired_files = [(key[0], key[1], identifier) for
 
2237
                    (identifier, key) in absent.iteritems()]
 
2238
                for (identifier, bytes_iterator) in fallback.iter_files_bytes(desired_files):
 
2239
                    del absent[identifier]
 
2240
                    yield identifier, bytes_iterator
 
2241
            if absent:
 
2242
                # There may be more missing items, but raise an exception
 
2243
                # for just one.
 
2244
                missing_identifier = absent.keys()[0]
 
2245
                missing_key = absent[missing_identifier]
 
2246
                raise errors.RevisionNotPresent(revision_id=missing_key[1],
 
2247
                    file_id=missing_key[0])
 
2248
        except errors.UnknownSmartMethod:
 
2249
            self._ensure_real()
 
2250
            for (identifier, bytes_iterator) in (
 
2251
                self._real_repository.iter_files_bytes(desired_files)):
 
2252
                yield identifier, bytes_iterator
 
2253
 
 
2254
    def get_cached_parent_map(self, revision_ids):
 
2255
        """See bzrlib.CachingParentsProvider.get_cached_parent_map"""
 
2256
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
1265
2257
 
1266
2258
    def get_parent_map(self, revision_ids):
1267
2259
        """See bzrlib.Graph.get_parent_map()."""
1326
2318
        if parents_map is None:
1327
2319
            # Repository is not locked, so there's no cache.
1328
2320
            parents_map = {}
1329
 
        # start_set is all the keys in the cache
1330
 
        start_set = set(parents_map)
1331
 
        # result set is all the references to keys in the cache
1332
 
        result_parents = set()
1333
 
        for parents in parents_map.itervalues():
1334
 
            result_parents.update(parents)
1335
 
        stop_keys = result_parents.difference(start_set)
1336
 
        # We don't need to send ghosts back to the server as a position to
1337
 
        # stop either.
1338
 
        stop_keys.difference_update(self._unstacked_provider.missing_keys)
1339
 
        key_count = len(parents_map)
1340
 
        if (NULL_REVISION in result_parents
1341
 
            and NULL_REVISION in self._unstacked_provider.missing_keys):
1342
 
            # If we pruned NULL_REVISION from the stop_keys because it's also
1343
 
            # in our cache of "missing" keys we need to increment our key count
1344
 
            # by 1, because the reconsitituted SearchResult on the server will
1345
 
            # still consider NULL_REVISION to be an included key.
1346
 
            key_count += 1
1347
 
        included_keys = start_set.intersection(result_parents)
1348
 
        start_set.difference_update(included_keys)
 
2321
        if _DEFAULT_SEARCH_DEPTH <= 0:
 
2322
            (start_set, stop_keys,
 
2323
             key_count) = vf_search.search_result_from_parent_map(
 
2324
                parents_map, self._unstacked_provider.missing_keys)
 
2325
        else:
 
2326
            (start_set, stop_keys,
 
2327
             key_count) = vf_search.limited_search_result_from_parent_map(
 
2328
                parents_map, self._unstacked_provider.missing_keys,
 
2329
                keys, depth=_DEFAULT_SEARCH_DEPTH)
1349
2330
        recipe = ('manual', start_set, stop_keys, key_count)
1350
2331
        body = self._serialise_search_recipe(recipe)
1351
2332
        path = self.bzrdir._path_for_remote_call(self._client)
1400
2381
 
1401
2382
    @needs_read_lock
1402
2383
    def get_signature_text(self, revision_id):
1403
 
        self._ensure_real()
1404
 
        return self._real_repository.get_signature_text(revision_id)
 
2384
        path = self.bzrdir._path_for_remote_call(self._client)
 
2385
        try:
 
2386
            response_tuple, response_handler = self._call_expecting_body(
 
2387
                'Repository.get_revision_signature_text', path, revision_id)
 
2388
        except errors.UnknownSmartMethod:
 
2389
            self._ensure_real()
 
2390
            return self._real_repository.get_signature_text(revision_id)
 
2391
        except errors.NoSuchRevision, err:
 
2392
            for fallback in self._fallback_repositories:
 
2393
                try:
 
2394
                    return fallback.get_signature_text(revision_id)
 
2395
                except errors.NoSuchRevision:
 
2396
                    pass
 
2397
            raise err
 
2398
        else:
 
2399
            if response_tuple[0] != 'ok':
 
2400
                raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2401
            return response_handler.read_body_bytes()
1405
2402
 
1406
2403
    @needs_read_lock
1407
 
    def get_inventory_xml(self, revision_id):
1408
 
        self._ensure_real()
1409
 
        return self._real_repository.get_inventory_xml(revision_id)
1410
 
 
1411
 
    def deserialise_inventory(self, revision_id, xml):
1412
 
        self._ensure_real()
1413
 
        return self._real_repository.deserialise_inventory(revision_id, xml)
1414
 
 
 
2404
    def _get_inventory_xml(self, revision_id):
 
2405
        # This call is used by older working tree formats,
 
2406
        # which stored a serialized basis inventory.
 
2407
        self._ensure_real()
 
2408
        return self._real_repository._get_inventory_xml(revision_id)
 
2409
 
 
2410
    @needs_write_lock
1415
2411
    def reconcile(self, other=None, thorough=False):
1416
 
        self._ensure_real()
1417
 
        return self._real_repository.reconcile(other=other, thorough=thorough)
 
2412
        from bzrlib.reconcile import RepoReconciler
 
2413
        path = self.bzrdir._path_for_remote_call(self._client)
 
2414
        try:
 
2415
            response, handler = self._call_expecting_body(
 
2416
                'Repository.reconcile', path, self._lock_token)
 
2417
        except (errors.UnknownSmartMethod, errors.TokenLockingNotSupported):
 
2418
            self._ensure_real()
 
2419
            return self._real_repository.reconcile(other=other, thorough=thorough)
 
2420
        if response != ('ok', ):
 
2421
            raise errors.UnexpectedSmartServerResponse(response)
 
2422
        body = handler.read_body_bytes()
 
2423
        result = RepoReconciler(self)
 
2424
        for line in body.split('\n'):
 
2425
            if not line:
 
2426
                continue
 
2427
            key, val_text = line.split(':')
 
2428
            if key == "garbage_inventories":
 
2429
                result.garbage_inventories = int(val_text)
 
2430
            elif key == "inconsistent_parents":
 
2431
                result.inconsistent_parents = int(val_text)
 
2432
            else:
 
2433
                mutter("unknown reconcile key %r" % key)
 
2434
        return result
1418
2435
 
1419
2436
    def all_revision_ids(self):
1420
 
        self._ensure_real()
1421
 
        return self._real_repository.all_revision_ids()
 
2437
        path = self.bzrdir._path_for_remote_call(self._client)
 
2438
        try:
 
2439
            response_tuple, response_handler = self._call_expecting_body(
 
2440
                "Repository.all_revision_ids", path)
 
2441
        except errors.UnknownSmartMethod:
 
2442
            self._ensure_real()
 
2443
            return self._real_repository.all_revision_ids()
 
2444
        if response_tuple != ("ok", ):
 
2445
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2446
        revids = set(response_handler.read_body_bytes().splitlines())
 
2447
        for fallback in self._fallback_repositories:
 
2448
            revids.update(set(fallback.all_revision_ids()))
 
2449
        return list(revids)
 
2450
 
 
2451
    def _filtered_revision_trees(self, revision_ids, file_ids):
 
2452
        """Return Tree for a revision on this branch with only some files.
 
2453
 
 
2454
        :param revision_ids: a sequence of revision-ids;
 
2455
          a revision-id may not be None or 'null:'
 
2456
        :param file_ids: if not None, the result is filtered
 
2457
          so that only those file-ids, their parents and their
 
2458
          children are included.
 
2459
        """
 
2460
        inventories = self.iter_inventories(revision_ids)
 
2461
        for inv in inventories:
 
2462
            # Should we introduce a FilteredRevisionTree class rather
 
2463
            # than pre-filter the inventory here?
 
2464
            filtered_inv = inv.filter(file_ids)
 
2465
            yield InventoryRevisionTree(self, filtered_inv, filtered_inv.revision_id)
1422
2466
 
1423
2467
    @needs_read_lock
1424
2468
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1425
 
        self._ensure_real()
1426
 
        return self._real_repository.get_deltas_for_revisions(revisions,
1427
 
            specific_fileids=specific_fileids)
 
2469
        medium = self._client._medium
 
2470
        if medium._is_remote_before((1, 2)):
 
2471
            self._ensure_real()
 
2472
            for delta in self._real_repository.get_deltas_for_revisions(
 
2473
                    revisions, specific_fileids):
 
2474
                yield delta
 
2475
            return
 
2476
        # Get the revision-ids of interest
 
2477
        required_trees = set()
 
2478
        for revision in revisions:
 
2479
            required_trees.add(revision.revision_id)
 
2480
            required_trees.update(revision.parent_ids[:1])
 
2481
 
 
2482
        # Get the matching filtered trees. Note that it's more
 
2483
        # efficient to pass filtered trees to changes_from() rather
 
2484
        # than doing the filtering afterwards. changes_from() could
 
2485
        # arguably do the filtering itself but it's path-based, not
 
2486
        # file-id based, so filtering before or afterwards is
 
2487
        # currently easier.
 
2488
        if specific_fileids is None:
 
2489
            trees = dict((t.get_revision_id(), t) for
 
2490
                t in self.revision_trees(required_trees))
 
2491
        else:
 
2492
            trees = dict((t.get_revision_id(), t) for
 
2493
                t in self._filtered_revision_trees(required_trees,
 
2494
                specific_fileids))
 
2495
 
 
2496
        # Calculate the deltas
 
2497
        for revision in revisions:
 
2498
            if not revision.parent_ids:
 
2499
                old_tree = self.revision_tree(_mod_revision.NULL_REVISION)
 
2500
            else:
 
2501
                old_tree = trees[revision.parent_ids[0]]
 
2502
            yield trees[revision.revision_id].changes_from(old_tree)
1428
2503
 
1429
2504
    @needs_read_lock
1430
2505
    def get_revision_delta(self, revision_id, specific_fileids=None):
1431
 
        self._ensure_real()
1432
 
        return self._real_repository.get_revision_delta(revision_id,
1433
 
            specific_fileids=specific_fileids)
 
2506
        r = self.get_revision(revision_id)
 
2507
        return list(self.get_deltas_for_revisions([r],
 
2508
            specific_fileids=specific_fileids))[0]
1434
2509
 
1435
2510
    @needs_read_lock
1436
2511
    def revision_trees(self, revision_ids):
1437
 
        self._ensure_real()
1438
 
        return self._real_repository.revision_trees(revision_ids)
 
2512
        inventories = self.iter_inventories(revision_ids)
 
2513
        for inv in inventories:
 
2514
            yield InventoryRevisionTree(self, inv, inv.revision_id)
1439
2515
 
1440
2516
    @needs_read_lock
1441
2517
    def get_revision_reconcile(self, revision_id):
1443
2519
        return self._real_repository.get_revision_reconcile(revision_id)
1444
2520
 
1445
2521
    @needs_read_lock
1446
 
    def check(self, revision_ids=None):
 
2522
    def check(self, revision_ids=None, callback_refs=None, check_repo=True):
1447
2523
        self._ensure_real()
1448
 
        return self._real_repository.check(revision_ids=revision_ids)
 
2524
        return self._real_repository.check(revision_ids=revision_ids,
 
2525
            callback_refs=callback_refs, check_repo=check_repo)
1449
2526
 
1450
2527
    def copy_content_into(self, destination, revision_id=None):
1451
 
        self._ensure_real()
1452
 
        return self._real_repository.copy_content_into(
1453
 
            destination, revision_id=revision_id)
 
2528
        """Make a complete copy of the content in self into destination.
 
2529
 
 
2530
        This is a destructive operation! Do not use it on existing
 
2531
        repositories.
 
2532
        """
 
2533
        interrepo = _mod_repository.InterRepository.get(self, destination)
 
2534
        return interrepo.copy_content(revision_id)
1454
2535
 
1455
2536
    def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1456
2537
        # get a tarball of the remote repository, and copy from that into the
1457
2538
        # destination
1458
 
        from bzrlib import osutils
1459
2539
        import tarfile
1460
2540
        # TODO: Maybe a progress bar while streaming the tarball?
1461
 
        note("Copying repository content as tarball...")
 
2541
        note(gettext("Copying repository content as tarball..."))
1462
2542
        tar_file = self._get_tarball('bz2')
1463
2543
        if tar_file is None:
1464
2544
            return None
1469
2549
            tmpdir = osutils.mkdtemp()
1470
2550
            try:
1471
2551
                _extract_tar(tar, tmpdir)
1472
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
2552
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1473
2553
                tmp_repo = tmp_bzrdir.open_repository()
1474
2554
                tmp_repo.copy_content_into(destination, revision_id)
1475
2555
            finally:
1491
2571
        return self._real_repository.inventories
1492
2572
 
1493
2573
    @needs_write_lock
1494
 
    def pack(self):
 
2574
    def pack(self, hint=None, clean_obsolete_packs=False):
1495
2575
        """Compress the data within the repository.
1496
 
 
1497
 
        This is not currently implemented within the smart server.
1498
2576
        """
1499
 
        self._ensure_real()
1500
 
        return self._real_repository.pack()
 
2577
        if hint is None:
 
2578
            body = ""
 
2579
        else:
 
2580
            body = "".join([l+"\n" for l in hint])
 
2581
        path = self.bzrdir._path_for_remote_call(self._client)
 
2582
        try:
 
2583
            response, handler = self._call_with_body_bytes_expecting_body(
 
2584
                'Repository.pack', (path, self._lock_token,
 
2585
                    str(clean_obsolete_packs)), body)
 
2586
        except errors.UnknownSmartMethod:
 
2587
            self._ensure_real()
 
2588
            return self._real_repository.pack(hint=hint,
 
2589
                clean_obsolete_packs=clean_obsolete_packs)
 
2590
        handler.cancel_read_body()
 
2591
        if response != ('ok', ):
 
2592
            raise errors.UnexpectedSmartServerResponse(response)
1501
2593
 
1502
2594
    @property
1503
2595
    def revisions(self):
1504
2596
        """Decorate the real repository for now.
1505
2597
 
1506
 
        In the short term this should become a real object to intercept graph
1507
 
        lookups.
1508
 
 
1509
2598
        In the long term a full blown network facility is needed.
1510
2599
        """
1511
2600
        self._ensure_real()
1539
2628
 
1540
2629
    @needs_write_lock
1541
2630
    def sign_revision(self, revision_id, gpg_strategy):
1542
 
        self._ensure_real()
1543
 
        return self._real_repository.sign_revision(revision_id, gpg_strategy)
 
2631
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2632
        plaintext = testament.as_short_text()
 
2633
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1544
2634
 
1545
2635
    @property
1546
2636
    def texts(self):
1552
2642
        self._ensure_real()
1553
2643
        return self._real_repository.texts
1554
2644
 
 
2645
    def _iter_revisions_rpc(self, revision_ids):
 
2646
        body = "\n".join(revision_ids)
 
2647
        path = self.bzrdir._path_for_remote_call(self._client)
 
2648
        response_tuple, response_handler = (
 
2649
            self._call_with_body_bytes_expecting_body(
 
2650
            "Repository.iter_revisions", (path, ), body))
 
2651
        if response_tuple[0] != "ok":
 
2652
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2653
        serializer_format = response_tuple[1]
 
2654
        serializer = serializer_format_registry.get(serializer_format)
 
2655
        byte_stream = response_handler.read_streamed_body()
 
2656
        decompressor = zlib.decompressobj()
 
2657
        chunks = []
 
2658
        for bytes in byte_stream:
 
2659
            chunks.append(decompressor.decompress(bytes))
 
2660
            if decompressor.unused_data != "":
 
2661
                chunks.append(decompressor.flush())
 
2662
                yield serializer.read_revision_from_string("".join(chunks))
 
2663
                unused = decompressor.unused_data
 
2664
                decompressor = zlib.decompressobj()
 
2665
                chunks = [decompressor.decompress(unused)]
 
2666
        chunks.append(decompressor.flush())
 
2667
        text = "".join(chunks)
 
2668
        if text != "":
 
2669
            yield serializer.read_revision_from_string("".join(chunks))
 
2670
 
1555
2671
    @needs_read_lock
1556
2672
    def get_revisions(self, revision_ids):
1557
 
        self._ensure_real()
1558
 
        return self._real_repository.get_revisions(revision_ids)
 
2673
        if revision_ids is None:
 
2674
            revision_ids = self.all_revision_ids()
 
2675
        else:
 
2676
            for rev_id in revision_ids:
 
2677
                if not rev_id or not isinstance(rev_id, basestring):
 
2678
                    raise errors.InvalidRevisionId(
 
2679
                        revision_id=rev_id, branch=self)
 
2680
        try:
 
2681
            missing = set(revision_ids)
 
2682
            revs = {}
 
2683
            for rev in self._iter_revisions_rpc(revision_ids):
 
2684
                missing.remove(rev.revision_id)
 
2685
                revs[rev.revision_id] = rev
 
2686
        except errors.UnknownSmartMethod:
 
2687
            self._ensure_real()
 
2688
            return self._real_repository.get_revisions(revision_ids)
 
2689
        for fallback in self._fallback_repositories:
 
2690
            if not missing:
 
2691
                break
 
2692
            for revid in list(missing):
 
2693
                # XXX JRV 2011-11-20: It would be nice if there was a
 
2694
                # public method on Repository that could be used to query
 
2695
                # for revision objects *without* failing completely if one
 
2696
                # was missing. There is VersionedFileRepository._iter_revisions,
 
2697
                # but unfortunately that's private and not provided by
 
2698
                # all repository implementations.
 
2699
                try:
 
2700
                    revs[revid] = fallback.get_revision(revid)
 
2701
                except errors.NoSuchRevision:
 
2702
                    pass
 
2703
                else:
 
2704
                    missing.remove(revid)
 
2705
        if missing:
 
2706
            raise errors.NoSuchRevision(self, list(missing)[0])
 
2707
        return [revs[revid] for revid in revision_ids]
1559
2708
 
1560
2709
    def supports_rich_root(self):
1561
2710
        return self._format.rich_root_data
1562
2711
 
 
2712
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1563
2713
    def iter_reverse_revision_history(self, revision_id):
1564
2714
        self._ensure_real()
1565
2715
        return self._real_repository.iter_reverse_revision_history(revision_id)
1568
2718
    def _serializer(self):
1569
2719
        return self._format._serializer
1570
2720
 
 
2721
    @needs_write_lock
1571
2722
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1572
 
        self._ensure_real()
1573
 
        return self._real_repository.store_revision_signature(
1574
 
            gpg_strategy, plaintext, revision_id)
 
2723
        signature = gpg_strategy.sign(plaintext)
 
2724
        self.add_signature_text(revision_id, signature)
1575
2725
 
1576
2726
    def add_signature_text(self, revision_id, signature):
1577
 
        self._ensure_real()
1578
 
        return self._real_repository.add_signature_text(revision_id, signature)
 
2727
        if self._real_repository:
 
2728
            # If there is a real repository the write group will
 
2729
            # be in the real repository as well, so use that:
 
2730
            self._ensure_real()
 
2731
            return self._real_repository.add_signature_text(
 
2732
                revision_id, signature)
 
2733
        path = self.bzrdir._path_for_remote_call(self._client)
 
2734
        response, handler = self._call_with_body_bytes_expecting_body(
 
2735
            'Repository.add_signature_text', (path, self._lock_token,
 
2736
                revision_id) + tuple(self._write_group_tokens), signature)
 
2737
        handler.cancel_read_body()
 
2738
        self.refresh_data()
 
2739
        if response[0] != 'ok':
 
2740
            raise errors.UnexpectedSmartServerResponse(response)
 
2741
        self._write_group_tokens = response[1:]
1579
2742
 
1580
2743
    def has_signature_for_revision_id(self, revision_id):
1581
 
        self._ensure_real()
1582
 
        return self._real_repository.has_signature_for_revision_id(revision_id)
 
2744
        path = self.bzrdir._path_for_remote_call(self._client)
 
2745
        try:
 
2746
            response = self._call('Repository.has_signature_for_revision_id',
 
2747
                path, revision_id)
 
2748
        except errors.UnknownSmartMethod:
 
2749
            self._ensure_real()
 
2750
            return self._real_repository.has_signature_for_revision_id(
 
2751
                revision_id)
 
2752
        if response[0] not in ('yes', 'no'):
 
2753
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2754
        if response[0] == 'yes':
 
2755
            return True
 
2756
        for fallback in self._fallback_repositories:
 
2757
            if fallback.has_signature_for_revision_id(revision_id):
 
2758
                return True
 
2759
        return False
 
2760
 
 
2761
    @needs_read_lock
 
2762
    def verify_revision_signature(self, revision_id, gpg_strategy):
 
2763
        if not self.has_signature_for_revision_id(revision_id):
 
2764
            return gpg.SIGNATURE_NOT_SIGNED, None
 
2765
        signature = self.get_signature_text(revision_id)
 
2766
 
 
2767
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2768
        plaintext = testament.as_short_text()
 
2769
 
 
2770
        return gpg_strategy.verify(signature, plaintext)
1583
2771
 
1584
2772
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1585
2773
        self._ensure_real()
1586
2774
        return self._real_repository.item_keys_introduced_by(revision_ids,
1587
2775
            _files_pb=_files_pb)
1588
2776
 
1589
 
    def revision_graph_can_have_wrong_parents(self):
1590
 
        # The answer depends on the remote repo format.
1591
 
        self._ensure_real()
1592
 
        return self._real_repository.revision_graph_can_have_wrong_parents()
1593
 
 
1594
 
    def _find_inconsistent_revision_parents(self):
1595
 
        self._ensure_real()
1596
 
        return self._real_repository._find_inconsistent_revision_parents()
 
2777
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
 
2778
        self._ensure_real()
 
2779
        return self._real_repository._find_inconsistent_revision_parents(
 
2780
            revisions_iterator)
1597
2781
 
1598
2782
    def _check_for_inconsistent_revision_parents(self):
1599
2783
        self._ensure_real()
1603
2787
        providers = [self._unstacked_provider]
1604
2788
        if other is not None:
1605
2789
            providers.insert(0, other)
1606
 
        providers.extend(r._make_parents_provider() for r in
1607
 
                         self._fallback_repositories)
1608
 
        return graph.StackedParentsProvider(providers)
 
2790
        return graph.StackedParentsProvider(_LazyListJoin(
 
2791
            providers, self._fallback_repositories))
1609
2792
 
1610
2793
    def _serialise_search_recipe(self, recipe):
1611
2794
        """Serialise a graph search recipe.
1619
2802
        return '\n'.join((start_keys, stop_keys, count))
1620
2803
 
1621
2804
    def _serialise_search_result(self, search_result):
1622
 
        if isinstance(search_result, graph.PendingAncestryResult):
1623
 
            parts = ['ancestry-of']
1624
 
            parts.extend(search_result.heads)
1625
 
        else:
1626
 
            recipe = search_result.get_recipe()
1627
 
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
 
2805
        parts = search_result.get_network_struct()
1628
2806
        return '\n'.join(parts)
1629
2807
 
1630
2808
    def autopack(self):
1640
2818
            raise errors.UnexpectedSmartServerResponse(response)
1641
2819
 
1642
2820
 
1643
 
class RemoteStreamSink(repository.StreamSink):
 
2821
class RemoteStreamSink(vf_repository.StreamSink):
1644
2822
 
1645
2823
    def _insert_real(self, stream, src_format, resume_tokens):
1646
2824
        self.target_repo._ensure_real()
1653
2831
    def insert_stream(self, stream, src_format, resume_tokens):
1654
2832
        target = self.target_repo
1655
2833
        target._unstacked_provider.missing_keys.clear()
 
2834
        candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
1656
2835
        if target._lock_token:
1657
 
            verb = 'Repository.insert_stream_locked'
1658
 
            extra_args = (target._lock_token or '',)
1659
 
            required_version = (1, 14)
 
2836
            candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
 
2837
            lock_args = (target._lock_token or '',)
1660
2838
        else:
1661
 
            verb = 'Repository.insert_stream'
1662
 
            extra_args = ()
1663
 
            required_version = (1, 13)
 
2839
            candidate_calls.append(('Repository.insert_stream', (1, 13)))
 
2840
            lock_args = ()
1664
2841
        client = target._client
1665
2842
        medium = client._medium
1666
 
        if medium._is_remote_before(required_version):
1667
 
            # No possible way this can work.
1668
 
            return self._insert_real(stream, src_format, resume_tokens)
1669
2843
        path = target.bzrdir._path_for_remote_call(client)
1670
 
        if not resume_tokens:
1671
 
            # XXX: Ugly but important for correctness, *will* be fixed during
1672
 
            # 1.13 cycle. Pushing a stream that is interrupted results in a
1673
 
            # fallback to the _real_repositories sink *with a partial stream*.
1674
 
            # Thats bad because we insert less data than bzr expected. To avoid
1675
 
            # this we do a trial push to make sure the verb is accessible, and
1676
 
            # do not fallback when actually pushing the stream. A cleanup patch
1677
 
            # is going to look at rewinding/restarting the stream/partial
1678
 
            # buffering etc.
 
2844
        # Probe for the verb to use with an empty stream before sending the
 
2845
        # real stream to it.  We do this both to avoid the risk of sending a
 
2846
        # large request that is then rejected, and because we don't want to
 
2847
        # implement a way to buffer, rewind, or restart the stream.
 
2848
        found_verb = False
 
2849
        for verb, required_version in candidate_calls:
 
2850
            if medium._is_remote_before(required_version):
 
2851
                continue
 
2852
            if resume_tokens:
 
2853
                # We've already done the probing (and set _is_remote_before) on
 
2854
                # a previous insert.
 
2855
                found_verb = True
 
2856
                break
1679
2857
            byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1680
2858
            try:
1681
2859
                response = client.call_with_body_stream(
1682
 
                    (verb, path, '') + extra_args, byte_stream)
 
2860
                    (verb, path, '') + lock_args, byte_stream)
1683
2861
            except errors.UnknownSmartMethod:
1684
2862
                medium._remember_remote_is_before(required_version)
1685
 
                return self._insert_real(stream, src_format, resume_tokens)
 
2863
            else:
 
2864
                found_verb = True
 
2865
                break
 
2866
        if not found_verb:
 
2867
            # Have to use VFS.
 
2868
            return self._insert_real(stream, src_format, resume_tokens)
 
2869
        self._last_inv_record = None
 
2870
        self._last_substream = None
 
2871
        if required_version < (1, 19):
 
2872
            # Remote side doesn't support inventory deltas.  Wrap the stream to
 
2873
            # make sure we don't send any.  If the stream contains inventory
 
2874
            # deltas we'll interrupt the smart insert_stream request and
 
2875
            # fallback to VFS.
 
2876
            stream = self._stop_stream_if_inventory_delta(stream)
1686
2877
        byte_stream = smart_repo._stream_to_byte_stream(
1687
2878
            stream, src_format)
1688
2879
        resume_tokens = ' '.join(resume_tokens)
1689
2880
        response = client.call_with_body_stream(
1690
 
            (verb, path, resume_tokens) + extra_args, byte_stream)
 
2881
            (verb, path, resume_tokens) + lock_args, byte_stream)
1691
2882
        if response[0][0] not in ('ok', 'missing-basis'):
1692
2883
            raise errors.UnexpectedSmartServerResponse(response)
 
2884
        if self._last_substream is not None:
 
2885
            # The stream included an inventory-delta record, but the remote
 
2886
            # side isn't new enough to support them.  So we need to send the
 
2887
            # rest of the stream via VFS.
 
2888
            self.target_repo.refresh_data()
 
2889
            return self._resume_stream_with_vfs(response, src_format)
1693
2890
        if response[0][0] == 'missing-basis':
1694
2891
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1695
2892
            resume_tokens = tokens
1698
2895
            self.target_repo.refresh_data()
1699
2896
            return [], set()
1700
2897
 
1701
 
 
1702
 
class RemoteStreamSource(repository.StreamSource):
 
2898
    def _resume_stream_with_vfs(self, response, src_format):
 
2899
        """Resume sending a stream via VFS, first resending the record and
 
2900
        substream that couldn't be sent via an insert_stream verb.
 
2901
        """
 
2902
        if response[0][0] == 'missing-basis':
 
2903
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
 
2904
            # Ignore missing_keys, we haven't finished inserting yet
 
2905
        else:
 
2906
            tokens = []
 
2907
        def resume_substream():
 
2908
            # Yield the substream that was interrupted.
 
2909
            for record in self._last_substream:
 
2910
                yield record
 
2911
            self._last_substream = None
 
2912
        def resume_stream():
 
2913
            # Finish sending the interrupted substream
 
2914
            yield ('inventory-deltas', resume_substream())
 
2915
            # Then simply continue sending the rest of the stream.
 
2916
            for substream_kind, substream in self._last_stream:
 
2917
                yield substream_kind, substream
 
2918
        return self._insert_real(resume_stream(), src_format, tokens)
 
2919
 
 
2920
    def _stop_stream_if_inventory_delta(self, stream):
 
2921
        """Normally this just lets the original stream pass-through unchanged.
 
2922
 
 
2923
        However if any 'inventory-deltas' substream occurs it will stop
 
2924
        streaming, and store the interrupted substream and stream in
 
2925
        self._last_substream and self._last_stream so that the stream can be
 
2926
        resumed by _resume_stream_with_vfs.
 
2927
        """
 
2928
 
 
2929
        stream_iter = iter(stream)
 
2930
        for substream_kind, substream in stream_iter:
 
2931
            if substream_kind == 'inventory-deltas':
 
2932
                self._last_substream = substream
 
2933
                self._last_stream = stream_iter
 
2934
                return
 
2935
            else:
 
2936
                yield substream_kind, substream
 
2937
 
 
2938
 
 
2939
class RemoteStreamSource(vf_repository.StreamSource):
1703
2940
    """Stream data from a remote server."""
1704
2941
 
1705
2942
    def get_stream(self, search):
1706
2943
        if (self.from_repository._fallback_repositories and
1707
2944
            self.to_format._fetch_order == 'topological'):
1708
2945
            return self._real_stream(self.from_repository, search)
1709
 
        return self.missing_parents_chain(search, [self.from_repository] +
1710
 
            self.from_repository._fallback_repositories)
 
2946
        sources = []
 
2947
        seen = set()
 
2948
        repos = [self.from_repository]
 
2949
        while repos:
 
2950
            repo = repos.pop(0)
 
2951
            if repo in seen:
 
2952
                continue
 
2953
            seen.add(repo)
 
2954
            repos.extend(repo._fallback_repositories)
 
2955
            sources.append(repo)
 
2956
        return self.missing_parents_chain(search, sources)
 
2957
 
 
2958
    def get_stream_for_missing_keys(self, missing_keys):
 
2959
        self.from_repository._ensure_real()
 
2960
        real_repo = self.from_repository._real_repository
 
2961
        real_source = real_repo._get_source(self.to_format)
 
2962
        return real_source.get_stream_for_missing_keys(missing_keys)
1711
2963
 
1712
2964
    def _real_stream(self, repo, search):
1713
2965
        """Get a stream for search from repo.
1714
 
        
1715
 
        This never called RemoteStreamSource.get_stream, and is a heler
1716
 
        for RemoteStreamSource._get_stream to allow getting a stream 
 
2966
 
 
2967
        This never called RemoteStreamSource.get_stream, and is a helper
 
2968
        for RemoteStreamSource._get_stream to allow getting a stream
1717
2969
        reliably whether fallback back because of old servers or trying
1718
2970
        to stream from a non-RemoteRepository (which the stacked support
1719
2971
        code will do).
1720
2972
        """
1721
2973
        source = repo._get_source(self.to_format)
1722
2974
        if isinstance(source, RemoteStreamSource):
1723
 
            return repository.StreamSource.get_stream(source, search)
 
2975
            repo._ensure_real()
 
2976
            source = repo._real_repository._get_source(self.to_format)
1724
2977
        return source.get_stream(search)
1725
2978
 
1726
2979
    def _get_stream(self, repo, search):
1743
2996
            return self._real_stream(repo, search)
1744
2997
        client = repo._client
1745
2998
        medium = client._medium
1746
 
        if medium._is_remote_before((1, 13)):
1747
 
            # streaming was added in 1.13
1748
 
            return self._real_stream(repo, search)
1749
2999
        path = repo.bzrdir._path_for_remote_call(client)
1750
 
        try:
1751
 
            search_bytes = repo._serialise_search_result(search)
1752
 
            response = repo._call_with_body_bytes_expecting_body(
1753
 
                'Repository.get_stream',
1754
 
                (path, self.to_format.network_name()), search_bytes)
1755
 
            response_tuple, response_handler = response
1756
 
        except errors.UnknownSmartMethod:
1757
 
            medium._remember_remote_is_before((1,13))
 
3000
        search_bytes = repo._serialise_search_result(search)
 
3001
        args = (path, self.to_format.network_name())
 
3002
        candidate_verbs = [
 
3003
            ('Repository.get_stream_1.19', (1, 19)),
 
3004
            ('Repository.get_stream', (1, 13))]
 
3005
 
 
3006
        found_verb = False
 
3007
        for verb, version in candidate_verbs:
 
3008
            if medium._is_remote_before(version):
 
3009
                continue
 
3010
            try:
 
3011
                response = repo._call_with_body_bytes_expecting_body(
 
3012
                    verb, args, search_bytes)
 
3013
            except errors.UnknownSmartMethod:
 
3014
                medium._remember_remote_is_before(version)
 
3015
            except errors.UnknownErrorFromSmartServer, e:
 
3016
                if isinstance(search, vf_search.EverythingResult):
 
3017
                    error_verb = e.error_from_smart_server.error_verb
 
3018
                    if error_verb == 'BadSearch':
 
3019
                        # Pre-2.4 servers don't support this sort of search.
 
3020
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
3021
                        # good idea in general?  It might provide a little bit
 
3022
                        # of protection against client-side bugs.
 
3023
                        medium._remember_remote_is_before((2, 4))
 
3024
                        break
 
3025
                raise
 
3026
            else:
 
3027
                response_tuple, response_handler = response
 
3028
                found_verb = True
 
3029
                break
 
3030
        if not found_verb:
1758
3031
            return self._real_stream(repo, search)
1759
3032
        if response_tuple[0] != 'ok':
1760
3033
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1761
3034
        byte_stream = response_handler.read_streamed_body()
1762
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
3035
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
3036
            self._record_counter)
1763
3037
        if src_format.network_name() != repo._format.network_name():
1764
3038
            raise AssertionError(
1765
3039
                "Mismatched RemoteRepository and stream src %r, %r" % (
1772
3046
        :param search: The overall search to satisfy with streams.
1773
3047
        :param sources: A list of Repository objects to query.
1774
3048
        """
1775
 
        self.serialiser = self.to_format._serializer
 
3049
        self.from_serialiser = self.from_repository._format._serializer
1776
3050
        self.seen_revs = set()
1777
3051
        self.referenced_revs = set()
1778
3052
        # If there are heads in the search, or the key count is > 0, we are not
1795
3069
    def missing_parents_rev_handler(self, substream):
1796
3070
        for content in substream:
1797
3071
            revision_bytes = content.get_bytes_as('fulltext')
1798
 
            revision = self.serialiser.read_revision_from_string(revision_bytes)
 
3072
            revision = self.from_serialiser.read_revision_from_string(
 
3073
                revision_bytes)
1799
3074
            self.seen_revs.add(content.key[-1])
1800
3075
            self.referenced_revs.update(revision.parent_ids)
1801
3076
            yield content
1836
3111
 
1837
3112
    def _ensure_real(self):
1838
3113
        if self._custom_format is None:
1839
 
            self._custom_format = branch.network_format_registry.get(
1840
 
                self._network_name)
 
3114
            try:
 
3115
                self._custom_format = branch.network_format_registry.get(
 
3116
                    self._network_name)
 
3117
            except KeyError:
 
3118
                raise errors.UnknownFormatError(kind='branch',
 
3119
                    format=self._network_name)
1841
3120
 
1842
3121
    def get_format_description(self):
1843
 
        return 'Remote BZR Branch'
 
3122
        self._ensure_real()
 
3123
        return 'Remote: ' + self._custom_format.get_format_description()
1844
3124
 
1845
3125
    def network_name(self):
1846
3126
        return self._network_name
1847
3127
 
1848
 
    def open(self, a_bzrdir, ignore_fallbacks=False):
1849
 
        return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
 
3128
    def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
 
3129
        return a_bzrdir.open_branch(name=name, 
 
3130
            ignore_fallbacks=ignore_fallbacks)
1850
3131
 
1851
 
    def _vfs_initialize(self, a_bzrdir):
 
3132
    def _vfs_initialize(self, a_bzrdir, name, append_revisions_only):
1852
3133
        # Initialisation when using a local bzrdir object, or a non-vfs init
1853
3134
        # method is not available on the server.
1854
3135
        # self._custom_format is always set - the start of initialize ensures
1855
3136
        # that.
1856
3137
        if isinstance(a_bzrdir, RemoteBzrDir):
1857
3138
            a_bzrdir._ensure_real()
1858
 
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
 
3139
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
 
3140
                name=name, append_revisions_only=append_revisions_only)
1859
3141
        else:
1860
3142
            # We assume the bzrdir is parameterised; it may not be.
1861
 
            result = self._custom_format.initialize(a_bzrdir)
 
3143
            result = self._custom_format.initialize(a_bzrdir, name=name,
 
3144
                append_revisions_only=append_revisions_only)
1862
3145
        if (isinstance(a_bzrdir, RemoteBzrDir) and
1863
3146
            not isinstance(result, RemoteBranch)):
1864
 
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
 
3147
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
 
3148
                                  name=name)
1865
3149
        return result
1866
3150
 
1867
 
    def initialize(self, a_bzrdir):
 
3151
    def initialize(self, a_bzrdir, name=None, repository=None,
 
3152
                   append_revisions_only=None):
 
3153
        if name is None:
 
3154
            name = a_bzrdir._get_selected_branch()
1868
3155
        # 1) get the network name to use.
1869
3156
        if self._custom_format:
1870
3157
            network_name = self._custom_format.network_name()
1871
3158
        else:
1872
3159
            # Select the current bzrlib default and ask for that.
1873
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
3160
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
1874
3161
            reference_format = reference_bzrdir_format.get_branch_format()
1875
3162
            self._custom_format = reference_format
1876
3163
            network_name = reference_format.network_name()
1877
3164
        # Being asked to create on a non RemoteBzrDir:
1878
3165
        if not isinstance(a_bzrdir, RemoteBzrDir):
1879
 
            return self._vfs_initialize(a_bzrdir)
 
3166
            return self._vfs_initialize(a_bzrdir, name=name,
 
3167
                append_revisions_only=append_revisions_only)
1880
3168
        medium = a_bzrdir._client._medium
1881
3169
        if medium._is_remote_before((1, 13)):
1882
 
            return self._vfs_initialize(a_bzrdir)
 
3170
            return self._vfs_initialize(a_bzrdir, name=name,
 
3171
                append_revisions_only=append_revisions_only)
1883
3172
        # Creating on a remote bzr dir.
1884
3173
        # 2) try direct creation via RPC
1885
3174
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
 
3175
        if name != "":
 
3176
            # XXX JRV20100304: Support creating colocated branches
 
3177
            raise errors.NoColocatedBranchSupport(self)
1886
3178
        verb = 'BzrDir.create_branch'
1887
3179
        try:
1888
3180
            response = a_bzrdir._call(verb, path, network_name)
1889
3181
        except errors.UnknownSmartMethod:
1890
3182
            # Fallback - use vfs methods
1891
3183
            medium._remember_remote_is_before((1, 13))
1892
 
            return self._vfs_initialize(a_bzrdir)
 
3184
            return self._vfs_initialize(a_bzrdir, name=name,
 
3185
                    append_revisions_only=append_revisions_only)
1893
3186
        if response[0] != 'ok':
1894
3187
            raise errors.UnexpectedSmartServerResponse(response)
1895
3188
        # Turn the response into a RemoteRepository object.
1896
3189
        format = RemoteBranchFormat(network_name=response[1])
1897
3190
        repo_format = response_tuple_to_repo_format(response[3:])
1898
 
        if response[2] == '':
1899
 
            repo_bzrdir = a_bzrdir
 
3191
        repo_path = response[2]
 
3192
        if repository is not None:
 
3193
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
 
3194
            url_diff = urlutils.relative_url(repository.user_url,
 
3195
                    remote_repo_url)
 
3196
            if url_diff != '.':
 
3197
                raise AssertionError(
 
3198
                    'repository.user_url %r does not match URL from server '
 
3199
                    'response (%r + %r)'
 
3200
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
 
3201
            remote_repo = repository
1900
3202
        else:
1901
 
            repo_bzrdir = RemoteBzrDir(
1902
 
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
1903
 
                a_bzrdir._client)
1904
 
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
3203
            if repo_path == '':
 
3204
                repo_bzrdir = a_bzrdir
 
3205
            else:
 
3206
                repo_bzrdir = RemoteBzrDir(
 
3207
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
3208
                    a_bzrdir._client)
 
3209
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
1905
3210
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
1906
 
            format=format, setup_stacking=False)
 
3211
            format=format, setup_stacking=False, name=name)
 
3212
        if append_revisions_only:
 
3213
            remote_branch.set_append_revisions_only(append_revisions_only)
1907
3214
        # XXX: We know this is a new branch, so it must have revno 0, revid
1908
3215
        # NULL_REVISION. Creating the branch locked would make this be unable
1909
3216
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
1928
3235
        self._ensure_real()
1929
3236
        return self._custom_format.supports_set_append_revisions_only()
1930
3237
 
1931
 
 
1932
 
class RemoteBranch(branch.Branch, _RpcHelper):
 
3238
    def _use_default_local_heads_to_fetch(self):
 
3239
        # If the branch format is a metadir format *and* its heads_to_fetch
 
3240
        # implementation is not overridden vs the base class, we can use the
 
3241
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
3242
        # usually cheaper in terms of net round trips, as the last-revision and
 
3243
        # tags info fetched is cached and would be fetched anyway.
 
3244
        self._ensure_real()
 
3245
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
3246
            branch_class = self._custom_format._branch_class()
 
3247
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
3248
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
3249
                return True
 
3250
        return False
 
3251
 
 
3252
 
 
3253
class RemoteBranchStore(_mod_config.IniFileStore):
 
3254
    """Branch store which attempts to use HPSS calls to retrieve branch store.
 
3255
 
 
3256
    Note that this is specific to bzr-based formats.
 
3257
    """
 
3258
 
 
3259
    def __init__(self, branch):
 
3260
        super(RemoteBranchStore, self).__init__()
 
3261
        self.branch = branch
 
3262
        self.id = "branch"
 
3263
        self._real_store = None
 
3264
 
 
3265
    def lock_write(self, token=None):
 
3266
        return self.branch.lock_write(token)
 
3267
 
 
3268
    def unlock(self):
 
3269
        return self.branch.unlock()
 
3270
 
 
3271
    @needs_write_lock
 
3272
    def save(self):
 
3273
        # We need to be able to override the undecorated implementation
 
3274
        self.save_without_locking()
 
3275
 
 
3276
    def save_without_locking(self):
 
3277
        super(RemoteBranchStore, self).save()
 
3278
 
 
3279
    def external_url(self):
 
3280
        return self.branch.user_url
 
3281
 
 
3282
    def _load_content(self):
 
3283
        path = self.branch._remote_path()
 
3284
        try:
 
3285
            response, handler = self.branch._call_expecting_body(
 
3286
                'Branch.get_config_file', path)
 
3287
        except errors.UnknownSmartMethod:
 
3288
            self._ensure_real()
 
3289
            return self._real_store._load_content()
 
3290
        if len(response) and response[0] != 'ok':
 
3291
            raise errors.UnexpectedSmartServerResponse(response)
 
3292
        return handler.read_body_bytes()
 
3293
 
 
3294
    def _save_content(self, content):
 
3295
        path = self.branch._remote_path()
 
3296
        try:
 
3297
            response, handler = self.branch._call_with_body_bytes_expecting_body(
 
3298
                'Branch.put_config_file', (path,
 
3299
                    self.branch._lock_token, self.branch._repo_lock_token),
 
3300
                content)
 
3301
        except errors.UnknownSmartMethod:
 
3302
            self._ensure_real()
 
3303
            return self._real_store._save_content(content)
 
3304
        handler.cancel_read_body()
 
3305
        if response != ('ok', ):
 
3306
            raise errors.UnexpectedSmartServerResponse(response)
 
3307
 
 
3308
    def _ensure_real(self):
 
3309
        self.branch._ensure_real()
 
3310
        if self._real_store is None:
 
3311
            self._real_store = _mod_config.BranchStore(self.branch)
 
3312
 
 
3313
 
 
3314
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
1933
3315
    """Branch stored on a server accessed by HPSS RPC.
1934
3316
 
1935
3317
    At the moment most operations are mapped down to simple file operations.
1936
3318
    """
1937
3319
 
1938
3320
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
1939
 
        _client=None, format=None, setup_stacking=True):
 
3321
        _client=None, format=None, setup_stacking=True, name=None,
 
3322
        possible_transports=None):
1940
3323
        """Create a RemoteBranch instance.
1941
3324
 
1942
3325
        :param real_branch: An optional local implementation of the branch
1948
3331
        :param setup_stacking: If True make an RPC call to determine the
1949
3332
            stacked (or not) status of the branch. If False assume the branch
1950
3333
            is not stacked.
 
3334
        :param name: Colocated branch name
1951
3335
        """
1952
3336
        # We intentionally don't call the parent class's __init__, because it
1953
3337
        # will try to assign to self.tags, which is a property in this subclass.
1954
3338
        # And the parent's __init__ doesn't do much anyway.
1955
3339
        self.bzrdir = remote_bzrdir
 
3340
        self.name = name
1956
3341
        if _client is not None:
1957
3342
            self._client = _client
1958
3343
        else:
1972
3357
            self._real_branch = None
1973
3358
        # Fill out expected attributes of branch for bzrlib API users.
1974
3359
        self._clear_cached_state()
1975
 
        self.base = self.bzrdir.root_transport.base
 
3360
        # TODO: deprecate self.base in favor of user_url
 
3361
        self.base = self.bzrdir.user_url
 
3362
        self._name = name
1976
3363
        self._control_files = None
1977
3364
        self._lock_mode = None
1978
3365
        self._lock_token = None
1989
3376
                    self._real_branch._format.network_name()
1990
3377
        else:
1991
3378
            self._format = format
 
3379
        # when we do _ensure_real we may need to pass ignore_fallbacks to the
 
3380
        # branch.open_branch method.
 
3381
        self._real_ignore_fallbacks = not setup_stacking
1992
3382
        if not self._format._network_name:
1993
3383
            # Did not get from open_branchV2 - old server.
1994
3384
            self._ensure_real()
2001
3391
            hook(self)
2002
3392
        self._is_stacked = False
2003
3393
        if setup_stacking:
2004
 
            self._setup_stacking()
 
3394
            self._setup_stacking(possible_transports)
2005
3395
 
2006
 
    def _setup_stacking(self):
 
3396
    def _setup_stacking(self, possible_transports):
2007
3397
        # configure stacking into the remote repository, by reading it from
2008
3398
        # the vfs branch.
2009
3399
        try:
2012
3402
            errors.UnstackableRepositoryFormat), e:
2013
3403
            return
2014
3404
        self._is_stacked = True
2015
 
        self._activate_fallback_location(fallback_url)
 
3405
        if possible_transports is None:
 
3406
            possible_transports = []
 
3407
        else:
 
3408
            possible_transports = list(possible_transports)
 
3409
        possible_transports.append(self.bzrdir.root_transport)
 
3410
        self._activate_fallback_location(fallback_url,
 
3411
            possible_transports=possible_transports)
2016
3412
 
2017
3413
    def _get_config(self):
2018
3414
        return RemoteBranchConfig(self)
2019
3415
 
 
3416
    def _get_config_store(self):
 
3417
        return RemoteBranchStore(self)
 
3418
 
2020
3419
    def _get_real_transport(self):
2021
3420
        # if we try vfs access, return the real branch's vfs transport
2022
3421
        self._ensure_real()
2039
3438
                raise AssertionError('smart server vfs must be enabled '
2040
3439
                    'to use vfs implementation')
2041
3440
            self.bzrdir._ensure_real()
2042
 
            self._real_branch = self.bzrdir._real_bzrdir.open_branch()
 
3441
            self._real_branch = self.bzrdir._real_bzrdir.open_branch(
 
3442
                ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
2043
3443
            if self.repository._real_repository is None:
2044
3444
                # Give the remote repository the matching real repo.
2045
3445
                real_repo = self._real_branch.repository
2084
3484
                self.bzrdir, self._client)
2085
3485
        return self._control_files
2086
3486
 
2087
 
    def _get_checkout_format(self):
2088
 
        self._ensure_real()
2089
 
        return self._real_branch._get_checkout_format()
2090
 
 
2091
3487
    def get_physical_lock_status(self):
2092
3488
        """See Branch.get_physical_lock_status()."""
2093
 
        # should be an API call to the server, as branches must be lockable.
2094
 
        self._ensure_real()
2095
 
        return self._real_branch.get_physical_lock_status()
 
3489
        try:
 
3490
            response = self._client.call('Branch.get_physical_lock_status',
 
3491
                self._remote_path())
 
3492
        except errors.UnknownSmartMethod:
 
3493
            self._ensure_real()
 
3494
            return self._real_branch.get_physical_lock_status()
 
3495
        if response[0] not in ('yes', 'no'):
 
3496
            raise errors.UnexpectedSmartServerResponse(response)
 
3497
        return (response[0] == 'yes')
2096
3498
 
2097
3499
    def get_stacked_on_url(self):
2098
3500
        """Get the URL this branch is stacked against.
2125
3527
            self._is_stacked = False
2126
3528
        else:
2127
3529
            self._is_stacked = True
2128
 
        
 
3530
 
2129
3531
    def _vfs_get_tags_bytes(self):
2130
3532
        self._ensure_real()
2131
3533
        return self._real_branch._get_tags_bytes()
2132
3534
 
 
3535
    @needs_read_lock
2133
3536
    def _get_tags_bytes(self):
 
3537
        if self._tags_bytes is None:
 
3538
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
3539
        return self._tags_bytes
 
3540
 
 
3541
    def _get_tags_bytes_via_hpss(self):
2134
3542
        medium = self._client._medium
2135
3543
        if medium._is_remote_before((1, 13)):
2136
3544
            return self._vfs_get_tags_bytes()
2141
3549
            return self._vfs_get_tags_bytes()
2142
3550
        return response[0]
2143
3551
 
 
3552
    def _vfs_set_tags_bytes(self, bytes):
 
3553
        self._ensure_real()
 
3554
        return self._real_branch._set_tags_bytes(bytes)
 
3555
 
 
3556
    def _set_tags_bytes(self, bytes):
 
3557
        if self.is_locked():
 
3558
            self._tags_bytes = bytes
 
3559
        medium = self._client._medium
 
3560
        if medium._is_remote_before((1, 18)):
 
3561
            self._vfs_set_tags_bytes(bytes)
 
3562
            return
 
3563
        try:
 
3564
            args = (
 
3565
                self._remote_path(), self._lock_token, self._repo_lock_token)
 
3566
            response = self._call_with_body_bytes(
 
3567
                'Branch.set_tags_bytes', args, bytes)
 
3568
        except errors.UnknownSmartMethod:
 
3569
            medium._remember_remote_is_before((1, 18))
 
3570
            self._vfs_set_tags_bytes(bytes)
 
3571
 
2144
3572
    def lock_read(self):
 
3573
        """Lock the branch for read operations.
 
3574
 
 
3575
        :return: A bzrlib.lock.LogicalLockResult.
 
3576
        """
2145
3577
        self.repository.lock_read()
2146
3578
        if not self._lock_mode:
 
3579
            self._note_lock('r')
2147
3580
            self._lock_mode = 'r'
2148
3581
            self._lock_count = 1
2149
3582
            if self._real_branch is not None:
2150
3583
                self._real_branch.lock_read()
2151
3584
        else:
2152
3585
            self._lock_count += 1
 
3586
        return lock.LogicalLockResult(self.unlock)
2153
3587
 
2154
3588
    def _remote_lock_write(self, token):
2155
3589
        if token is None:
2156
3590
            branch_token = repo_token = ''
2157
3591
        else:
2158
3592
            branch_token = token
2159
 
            repo_token = self.repository.lock_write()
 
3593
            repo_token = self.repository.lock_write().repository_token
2160
3594
            self.repository.unlock()
2161
3595
        err_context = {'token': token}
2162
 
        response = self._call(
2163
 
            'Branch.lock_write', self._remote_path(), branch_token,
2164
 
            repo_token or '', **err_context)
 
3596
        try:
 
3597
            response = self._call(
 
3598
                'Branch.lock_write', self._remote_path(), branch_token,
 
3599
                repo_token or '', **err_context)
 
3600
        except errors.LockContention, e:
 
3601
            # The LockContention from the server doesn't have any
 
3602
            # information about the lock_url. We re-raise LockContention
 
3603
            # with valid lock_url.
 
3604
            raise errors.LockContention('(remote lock)',
 
3605
                self.repository.base.split('.bzr/')[0])
2165
3606
        if response[0] != 'ok':
2166
3607
            raise errors.UnexpectedSmartServerResponse(response)
2167
3608
        ok, branch_token, repo_token = response
2169
3610
 
2170
3611
    def lock_write(self, token=None):
2171
3612
        if not self._lock_mode:
 
3613
            self._note_lock('w')
2172
3614
            # Lock the branch and repo in one remote call.
2173
3615
            remote_tokens = self._remote_lock_write(token)
2174
3616
            self._lock_token, self._repo_lock_token = remote_tokens
2187
3629
            self._lock_mode = 'w'
2188
3630
            self._lock_count = 1
2189
3631
        elif self._lock_mode == 'r':
2190
 
            raise errors.ReadOnlyTransaction
 
3632
            raise errors.ReadOnlyError(self)
2191
3633
        else:
2192
3634
            if token is not None:
2193
3635
                # A token was given to lock_write, and we're relocking, so
2198
3640
            self._lock_count += 1
2199
3641
            # Re-lock the repository too.
2200
3642
            self.repository.lock_write(self._repo_lock_token)
2201
 
        return self._lock_token or None
2202
 
 
2203
 
    def _set_tags_bytes(self, bytes):
2204
 
        self._ensure_real()
2205
 
        return self._real_branch._set_tags_bytes(bytes)
 
3643
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
2206
3644
 
2207
3645
    def _unlock(self, branch_token, repo_token):
2208
3646
        err_context = {'token': str((branch_token, repo_token))}
2213
3651
            return
2214
3652
        raise errors.UnexpectedSmartServerResponse(response)
2215
3653
 
 
3654
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2216
3655
    def unlock(self):
2217
3656
        try:
2218
3657
            self._lock_count -= 1
2245
3684
            self.repository.unlock()
2246
3685
 
2247
3686
    def break_lock(self):
2248
 
        self._ensure_real()
2249
 
        return self._real_branch.break_lock()
 
3687
        try:
 
3688
            response = self._call(
 
3689
                'Branch.break_lock', self._remote_path())
 
3690
        except errors.UnknownSmartMethod:
 
3691
            self._ensure_real()
 
3692
            return self._real_branch.break_lock()
 
3693
        if response != ('ok',):
 
3694
            raise errors.UnexpectedSmartServerResponse(response)
2250
3695
 
2251
3696
    def leave_lock_in_place(self):
2252
3697
        if not self._lock_token:
2258
3703
            raise NotImplementedError(self.dont_leave_lock_in_place)
2259
3704
        self._leave_lock = False
2260
3705
 
 
3706
    @needs_read_lock
2261
3707
    def get_rev_id(self, revno, history=None):
2262
3708
        if revno == 0:
2263
3709
            return _mod_revision.NULL_REVISION
2275
3721
            missing_parent = parent_map[missing_parent]
2276
3722
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2277
3723
 
2278
 
    def _last_revision_info(self):
 
3724
    def _read_last_revision_info(self):
2279
3725
        response = self._call('Branch.last_revision_info', self._remote_path())
2280
3726
        if response[0] != 'ok':
2281
3727
            raise SmartProtocolError('unexpected response code %s' % (response,))
2344
3790
            raise errors.UnexpectedSmartServerResponse(response)
2345
3791
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2346
3792
 
 
3793
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2347
3794
    @needs_write_lock
2348
3795
    def set_revision_history(self, rev_history):
 
3796
        """See Branch.set_revision_history."""
 
3797
        self._set_revision_history(rev_history)
 
3798
 
 
3799
    @needs_write_lock
 
3800
    def _set_revision_history(self, rev_history):
2349
3801
        # Send just the tip revision of the history; the server will generate
2350
3802
        # the full history from that.  If the revision doesn't exist in this
2351
3803
        # branch, NoSuchRevision will be raised.
2409
3861
            _override_hook_target=self, **kwargs)
2410
3862
 
2411
3863
    @needs_read_lock
2412
 
    def push(self, target, overwrite=False, stop_revision=None):
 
3864
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2413
3865
        self._ensure_real()
2414
3866
        return self._real_branch.push(
2415
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
3867
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2416
3868
            _override_hook_source_branch=self)
2417
3869
 
2418
3870
    def is_locked(self):
2419
3871
        return self._lock_count >= 1
2420
3872
 
2421
3873
    @needs_read_lock
 
3874
    def revision_id_to_dotted_revno(self, revision_id):
 
3875
        """Given a revision id, return its dotted revno.
 
3876
 
 
3877
        :return: a tuple like (1,) or (400,1,3).
 
3878
        """
 
3879
        try:
 
3880
            response = self._call('Branch.revision_id_to_revno',
 
3881
                self._remote_path(), revision_id)
 
3882
        except errors.UnknownSmartMethod:
 
3883
            self._ensure_real()
 
3884
            return self._real_branch.revision_id_to_dotted_revno(revision_id)
 
3885
        if response[0] == 'ok':
 
3886
            return tuple([int(x) for x in response[1:]])
 
3887
        else:
 
3888
            raise errors.UnexpectedSmartServerResponse(response)
 
3889
 
 
3890
    @needs_read_lock
2422
3891
    def revision_id_to_revno(self, revision_id):
2423
 
        self._ensure_real()
2424
 
        return self._real_branch.revision_id_to_revno(revision_id)
 
3892
        """Given a revision id on the branch mainline, return its revno.
 
3893
 
 
3894
        :return: an integer
 
3895
        """
 
3896
        try:
 
3897
            response = self._call('Branch.revision_id_to_revno',
 
3898
                self._remote_path(), revision_id)
 
3899
        except errors.UnknownSmartMethod:
 
3900
            self._ensure_real()
 
3901
            return self._real_branch.revision_id_to_revno(revision_id)
 
3902
        if response[0] == 'ok':
 
3903
            if len(response) == 2:
 
3904
                return int(response[1])
 
3905
            raise NoSuchRevision(self, revision_id)
 
3906
        else:
 
3907
            raise errors.UnexpectedSmartServerResponse(response)
2425
3908
 
2426
3909
    @needs_write_lock
2427
3910
    def set_last_revision_info(self, revno, revision_id):
2428
3911
        # XXX: These should be returned by the set_last_revision_info verb
2429
3912
        old_revno, old_revid = self.last_revision_info()
2430
3913
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2431
 
        revision_id = ensure_null(revision_id)
 
3914
        if not revision_id or not isinstance(revision_id, basestring):
 
3915
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2432
3916
        try:
2433
3917
            response = self._call('Branch.set_last_revision_info',
2434
3918
                self._remote_path(), self._lock_token, self._repo_lock_token,
2463
3947
            except errors.UnknownSmartMethod:
2464
3948
                medium._remember_remote_is_before((1, 6))
2465
3949
        self._clear_cached_state_of_remote_branch_only()
2466
 
        self.set_revision_history(self._lefthand_history(revision_id,
 
3950
        self._set_revision_history(self._lefthand_history(revision_id,
2467
3951
            last_rev=last_rev,other_branch=other_branch))
2468
3952
 
2469
3953
    def set_push_location(self, location):
2470
3954
        self._ensure_real()
2471
3955
        return self._real_branch.set_push_location(location)
2472
3956
 
 
3957
    def heads_to_fetch(self):
 
3958
        if self._format._use_default_local_heads_to_fetch():
 
3959
            # We recognise this format, and its heads-to-fetch implementation
 
3960
            # is the default one (tip + tags).  In this case it's cheaper to
 
3961
            # just use the default implementation rather than a special RPC as
 
3962
            # the tip and tags data is cached.
 
3963
            return branch.Branch.heads_to_fetch(self)
 
3964
        medium = self._client._medium
 
3965
        if medium._is_remote_before((2, 4)):
 
3966
            return self._vfs_heads_to_fetch()
 
3967
        try:
 
3968
            return self._rpc_heads_to_fetch()
 
3969
        except errors.UnknownSmartMethod:
 
3970
            medium._remember_remote_is_before((2, 4))
 
3971
            return self._vfs_heads_to_fetch()
 
3972
 
 
3973
    def _rpc_heads_to_fetch(self):
 
3974
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3975
        if len(response) != 2:
 
3976
            raise errors.UnexpectedSmartServerResponse(response)
 
3977
        must_fetch, if_present_fetch = response
 
3978
        return set(must_fetch), set(if_present_fetch)
 
3979
 
 
3980
    def _vfs_heads_to_fetch(self):
 
3981
        self._ensure_real()
 
3982
        return self._real_branch.heads_to_fetch()
 
3983
 
2473
3984
 
2474
3985
class RemoteConfig(object):
2475
3986
    """A Config that reads and writes from smart verbs.
2489
4000
        """
2490
4001
        try:
2491
4002
            configobj = self._get_configobj()
 
4003
            section_obj = None
2492
4004
            if section is None:
2493
4005
                section_obj = configobj
2494
4006
            else:
2495
4007
                try:
2496
4008
                    section_obj = configobj[section]
2497
4009
                except KeyError:
2498
 
                    return default
2499
 
            return section_obj.get(name, default)
 
4010
                    pass
 
4011
            if section_obj is None:
 
4012
                value = default
 
4013
            else:
 
4014
                value = section_obj.get(name, default)
2500
4015
        except errors.UnknownSmartMethod:
2501
 
            return self._vfs_get_option(name, section, default)
 
4016
            value = self._vfs_get_option(name, section, default)
 
4017
        for hook in _mod_config.OldConfigHooks['get']:
 
4018
            hook(self, name, value)
 
4019
        return value
2502
4020
 
2503
4021
    def _response_to_configobj(self, response):
2504
4022
        if len(response[0]) and response[0][0] != 'ok':
2505
4023
            raise errors.UnexpectedSmartServerResponse(response)
2506
4024
        lines = response[1].read_body_bytes().splitlines()
2507
 
        return config.ConfigObj(lines, encoding='utf-8')
 
4025
        conf = _mod_config.ConfigObj(lines, encoding='utf-8')
 
4026
        for hook in _mod_config.OldConfigHooks['load']:
 
4027
            hook(self)
 
4028
        return conf
2508
4029
 
2509
4030
 
2510
4031
class RemoteBranchConfig(RemoteConfig):
2529
4050
        medium = self._branch._client._medium
2530
4051
        if medium._is_remote_before((1, 14)):
2531
4052
            return self._vfs_set_option(value, name, section)
 
4053
        if isinstance(value, dict):
 
4054
            if medium._is_remote_before((2, 2)):
 
4055
                return self._vfs_set_option(value, name, section)
 
4056
            return self._set_config_option_dict(value, name, section)
 
4057
        else:
 
4058
            return self._set_config_option(value, name, section)
 
4059
 
 
4060
    def _set_config_option(self, value, name, section):
2532
4061
        try:
2533
4062
            path = self._branch._remote_path()
2534
4063
            response = self._branch._client.call('Branch.set_config_option',
2535
4064
                path, self._branch._lock_token, self._branch._repo_lock_token,
2536
4065
                value.encode('utf8'), name, section or '')
2537
4066
        except errors.UnknownSmartMethod:
 
4067
            medium = self._branch._client._medium
2538
4068
            medium._remember_remote_is_before((1, 14))
2539
4069
            return self._vfs_set_option(value, name, section)
2540
4070
        if response != ():
2541
4071
            raise errors.UnexpectedSmartServerResponse(response)
2542
4072
 
 
4073
    def _serialize_option_dict(self, option_dict):
 
4074
        utf8_dict = {}
 
4075
        for key, value in option_dict.items():
 
4076
            if isinstance(key, unicode):
 
4077
                key = key.encode('utf8')
 
4078
            if isinstance(value, unicode):
 
4079
                value = value.encode('utf8')
 
4080
            utf8_dict[key] = value
 
4081
        return bencode.bencode(utf8_dict)
 
4082
 
 
4083
    def _set_config_option_dict(self, value, name, section):
 
4084
        try:
 
4085
            path = self._branch._remote_path()
 
4086
            serialised_dict = self._serialize_option_dict(value)
 
4087
            response = self._branch._client.call(
 
4088
                'Branch.set_config_option_dict',
 
4089
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
4090
                serialised_dict, name, section or '')
 
4091
        except errors.UnknownSmartMethod:
 
4092
            medium = self._branch._client._medium
 
4093
            medium._remember_remote_is_before((2, 2))
 
4094
            return self._vfs_set_option(value, name, section)
 
4095
        if response != ():
 
4096
            raise errors.UnexpectedSmartServerResponse(response)
 
4097
 
2543
4098
    def _real_object(self):
2544
4099
        self._branch._ensure_real()
2545
4100
        return self._branch._real_branch
2584
4139
        return self._bzrdir._real_bzrdir
2585
4140
 
2586
4141
 
2587
 
 
2588
4142
def _extract_tar(tar, to_dir):
2589
4143
    """Extract all the contents of a tarfile object.
2590
4144
 
2594
4148
        tar.extract(tarinfo, to_dir)
2595
4149
 
2596
4150
 
 
4151
error_translators = registry.Registry()
 
4152
no_context_error_translators = registry.Registry()
 
4153
 
 
4154
 
2597
4155
def _translate_error(err, **context):
2598
4156
    """Translate an ErrorFromSmartServer into a more useful error.
2599
4157
 
2628
4186
                    'Missing key %r in context %r', key_err.args[0], context)
2629
4187
                raise err
2630
4188
 
2631
 
    if err.error_verb == 'NoSuchRevision':
2632
 
        raise NoSuchRevision(find('branch'), err.error_args[0])
2633
 
    elif err.error_verb == 'nosuchrevision':
2634
 
        raise NoSuchRevision(find('repository'), err.error_args[0])
2635
 
    elif err.error_tuple == ('nobranch',):
2636
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
2637
 
    elif err.error_verb == 'norepository':
2638
 
        raise errors.NoRepositoryPresent(find('bzrdir'))
2639
 
    elif err.error_verb == 'LockContention':
2640
 
        raise errors.LockContention('(remote lock)')
2641
 
    elif err.error_verb == 'UnlockableTransport':
2642
 
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
2643
 
    elif err.error_verb == 'LockFailed':
2644
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
2645
 
    elif err.error_verb == 'TokenMismatch':
2646
 
        raise errors.TokenMismatch(find('token'), '(remote token)')
2647
 
    elif err.error_verb == 'Diverged':
2648
 
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
2649
 
    elif err.error_verb == 'TipChangeRejected':
2650
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2651
 
    elif err.error_verb == 'UnstackableBranchFormat':
2652
 
        raise errors.UnstackableBranchFormat(*err.error_args)
2653
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
2654
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2655
 
    elif err.error_verb == 'NotStacked':
2656
 
        raise errors.NotStacked(branch=find('branch'))
2657
 
    elif err.error_verb == 'PermissionDenied':
2658
 
        path = get_path()
2659
 
        if len(err.error_args) >= 2:
2660
 
            extra = err.error_args[1]
2661
 
        else:
2662
 
            extra = None
2663
 
        raise errors.PermissionDenied(path, extra=extra)
2664
 
    elif err.error_verb == 'ReadError':
2665
 
        path = get_path()
2666
 
        raise errors.ReadError(path)
2667
 
    elif err.error_verb == 'NoSuchFile':
2668
 
        path = get_path()
2669
 
        raise errors.NoSuchFile(path)
2670
 
    elif err.error_verb == 'FileExists':
2671
 
        raise errors.FileExists(err.error_args[0])
2672
 
    elif err.error_verb == 'DirectoryNotEmpty':
2673
 
        raise errors.DirectoryNotEmpty(err.error_args[0])
2674
 
    elif err.error_verb == 'ShortReadvError':
2675
 
        args = err.error_args
2676
 
        raise errors.ShortReadvError(
2677
 
            args[0], int(args[1]), int(args[2]), int(args[3]))
2678
 
    elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
 
4189
    try:
 
4190
        translator = error_translators.get(err.error_verb)
 
4191
    except KeyError:
 
4192
        pass
 
4193
    else:
 
4194
        raise translator(err, find, get_path)
 
4195
    try:
 
4196
        translator = no_context_error_translators.get(err.error_verb)
 
4197
    except KeyError:
 
4198
        raise errors.UnknownErrorFromSmartServer(err)
 
4199
    else:
 
4200
        raise translator(err)
 
4201
 
 
4202
 
 
4203
error_translators.register('NoSuchRevision',
 
4204
    lambda err, find, get_path: NoSuchRevision(
 
4205
        find('branch'), err.error_args[0]))
 
4206
error_translators.register('nosuchrevision',
 
4207
    lambda err, find, get_path: NoSuchRevision(
 
4208
        find('repository'), err.error_args[0]))
 
4209
 
 
4210
def _translate_nobranch_error(err, find, get_path):
 
4211
    if len(err.error_args) >= 1:
 
4212
        extra = err.error_args[0]
 
4213
    else:
 
4214
        extra = None
 
4215
    return errors.NotBranchError(path=find('bzrdir').root_transport.base,
 
4216
        detail=extra)
 
4217
 
 
4218
error_translators.register('nobranch', _translate_nobranch_error)
 
4219
error_translators.register('norepository',
 
4220
    lambda err, find, get_path: errors.NoRepositoryPresent(
 
4221
        find('bzrdir')))
 
4222
error_translators.register('UnlockableTransport',
 
4223
    lambda err, find, get_path: errors.UnlockableTransport(
 
4224
        find('bzrdir').root_transport))
 
4225
error_translators.register('TokenMismatch',
 
4226
    lambda err, find, get_path: errors.TokenMismatch(
 
4227
        find('token'), '(remote token)'))
 
4228
error_translators.register('Diverged',
 
4229
    lambda err, find, get_path: errors.DivergedBranches(
 
4230
        find('branch'), find('other_branch')))
 
4231
error_translators.register('NotStacked',
 
4232
    lambda err, find, get_path: errors.NotStacked(branch=find('branch')))
 
4233
 
 
4234
def _translate_PermissionDenied(err, find, get_path):
 
4235
    path = get_path()
 
4236
    if len(err.error_args) >= 2:
 
4237
        extra = err.error_args[1]
 
4238
    else:
 
4239
        extra = None
 
4240
    return errors.PermissionDenied(path, extra=extra)
 
4241
 
 
4242
error_translators.register('PermissionDenied', _translate_PermissionDenied)
 
4243
error_translators.register('ReadError',
 
4244
    lambda err, find, get_path: errors.ReadError(get_path()))
 
4245
error_translators.register('NoSuchFile',
 
4246
    lambda err, find, get_path: errors.NoSuchFile(get_path()))
 
4247
error_translators.register('TokenLockingNotSupported',
 
4248
    lambda err, find, get_path: errors.TokenLockingNotSupported(
 
4249
        find('repository')))
 
4250
error_translators.register('UnsuspendableWriteGroup',
 
4251
    lambda err, find, get_path: errors.UnsuspendableWriteGroup(
 
4252
        repository=find('repository')))
 
4253
error_translators.register('UnresumableWriteGroup',
 
4254
    lambda err, find, get_path: errors.UnresumableWriteGroup(
 
4255
        repository=find('repository'), write_groups=err.error_args[0],
 
4256
        reason=err.error_args[1]))
 
4257
no_context_error_translators.register('IncompatibleRepositories',
 
4258
    lambda err: errors.IncompatibleRepositories(
 
4259
        err.error_args[0], err.error_args[1], err.error_args[2]))
 
4260
no_context_error_translators.register('LockContention',
 
4261
    lambda err: errors.LockContention('(remote lock)'))
 
4262
no_context_error_translators.register('LockFailed',
 
4263
    lambda err: errors.LockFailed(err.error_args[0], err.error_args[1]))
 
4264
no_context_error_translators.register('TipChangeRejected',
 
4265
    lambda err: errors.TipChangeRejected(err.error_args[0].decode('utf8')))
 
4266
no_context_error_translators.register('UnstackableBranchFormat',
 
4267
    lambda err: errors.UnstackableBranchFormat(*err.error_args))
 
4268
no_context_error_translators.register('UnstackableRepositoryFormat',
 
4269
    lambda err: errors.UnstackableRepositoryFormat(*err.error_args))
 
4270
no_context_error_translators.register('FileExists',
 
4271
    lambda err: errors.FileExists(err.error_args[0]))
 
4272
no_context_error_translators.register('DirectoryNotEmpty',
 
4273
    lambda err: errors.DirectoryNotEmpty(err.error_args[0]))
 
4274
 
 
4275
def _translate_short_readv_error(err):
 
4276
    args = err.error_args
 
4277
    return errors.ShortReadvError(args[0], int(args[1]), int(args[2]),
 
4278
        int(args[3]))
 
4279
 
 
4280
no_context_error_translators.register('ShortReadvError',
 
4281
    _translate_short_readv_error)
 
4282
 
 
4283
def _translate_unicode_error(err):
2679
4284
        encoding = str(err.error_args[0]) # encoding must always be a string
2680
4285
        val = err.error_args[1]
2681
4286
        start = int(err.error_args[2])
2689
4294
            raise UnicodeDecodeError(encoding, val, start, end, reason)
2690
4295
        elif err.error_verb == 'UnicodeEncodeError':
2691
4296
            raise UnicodeEncodeError(encoding, val, start, end, reason)
2692
 
    elif err.error_verb == 'ReadOnlyError':
2693
 
        raise errors.TransportNotPossible('readonly transport')
2694
 
    raise errors.UnknownErrorFromSmartServer(err)
 
4297
 
 
4298
no_context_error_translators.register('UnicodeEncodeError',
 
4299
    _translate_unicode_error)
 
4300
no_context_error_translators.register('UnicodeDecodeError',
 
4301
    _translate_unicode_error)
 
4302
no_context_error_translators.register('ReadOnlyError',
 
4303
    lambda err: errors.TransportNotPossible('readonly transport'))
 
4304
no_context_error_translators.register('MemoryError',
 
4305
    lambda err: errors.BzrError("remote server out of memory\n"
 
4306
        "Retry non-remotely, or contact the server admin for details."))
 
4307
no_context_error_translators.register('RevisionNotPresent',
 
4308
    lambda err: errors.RevisionNotPresent(err.error_args[0], err.error_args[1]))
 
4309
 
 
4310
no_context_error_translators.register('BzrCheckError',
 
4311
    lambda err: errors.BzrCheckError(msg=err.error_args[0]))
 
4312