← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

(vila) Fix test failures blocking package builds. (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
1
 
# Copyright (C) 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2006-2012 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
from __future__ import absolute_import
 
18
 
17
19
import bz2
 
20
import zlib
18
21
 
19
22
from bzrlib import (
20
23
    bencode,
21
24
    branch,
22
 
    bzrdir,
23
 
    config,
 
25
    bzrdir as _mod_bzrdir,
 
26
    config as _mod_config,
 
27
    controldir,
24
28
    debug,
25
29
    errors,
 
30
    gpg,
26
31
    graph,
 
32
    inventory_delta,
27
33
    lock,
28
34
    lockdir,
29
 
    repository,
30
 
    revision,
 
35
    osutils,
 
36
    registry,
 
37
    repository as _mod_repository,
31
38
    revision as _mod_revision,
 
39
    static_tuple,
32
40
    symbol_versioning,
33
 
)
34
 
from bzrlib.branch import BranchReferenceFormat
35
 
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
36
 
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
37
48
from bzrlib.errors import (
38
49
    NoSuchRevision,
39
50
    SmartProtocolError,
40
51
    )
 
52
from bzrlib.i18n import gettext
 
53
from bzrlib.inventory import Inventory
41
54
from bzrlib.lockable_files import LockableFiles
42
55
from bzrlib.smart import client, vfs, repository as smart_repo
43
 
from bzrlib.revision import ensure_null, NULL_REVISION
44
 
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
45
66
 
46
67
 
47
68
class _RpcHelper(object):
84
105
    return format
85
106
 
86
107
 
87
 
# Note: RemoteBzrDirFormat is in bzrdir.py
88
 
 
89
 
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 urlutils.join(self.branch.user_url, 'control.conf')
 
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):
90
411
    """Control directory on a remote server, accessed via bzr:// or similar."""
91
412
 
92
 
    def __init__(self, transport, format, _client=None):
 
413
    def __init__(self, transport, format, _client=None, _force_probe=False):
93
414
        """Construct a RemoteBzrDir.
94
415
 
95
416
        :param _client: Private parameter for testing. Disables probing and the
96
417
            use of a real bzrdir.
97
418
        """
98
 
        BzrDir.__init__(self, transport, format)
 
419
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
99
420
        # this object holds a delegated bzrdir that uses file-level operations
100
421
        # to talk to the other side
101
422
        self._real_bzrdir = None
 
423
        self._has_working_tree = None
102
424
        # 1-shot cache for the call pattern 'create_branch; open_branch' - see
103
425
        # create_branch for details.
104
426
        self._next_open_branch_result = None
108
430
            self._client = client._SmartClient(medium)
109
431
        else:
110
432
            self._client = _client
111
 
            return
112
 
 
 
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
113
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):
114
469
        response = self._call('BzrDir.open', path)
115
470
        if response not in [('yes',), ('no',)]:
116
471
            raise errors.UnexpectedSmartServerResponse(response)
117
472
        if response == ('no',):
118
 
            raise errors.NotBranchError(path=transport.base)
 
473
            raise errors.NotBranchError(path=self.root_transport.base)
119
474
 
120
475
    def _ensure_real(self):
121
476
        """Ensure that there is a _real_bzrdir set.
123
478
        Used before calls to self._real_bzrdir.
124
479
        """
125
480
        if not self._real_bzrdir:
126
 
            self._real_bzrdir = BzrDir.open_from_transport(
127
 
                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])
128
487
            self._format._network_name = \
129
488
                self._real_bzrdir._format.network_name()
130
489
 
135
494
        # Prevent aliasing problems in the next_open_branch_result cache.
136
495
        # See create_branch for rationale.
137
496
        self._next_open_branch_result = None
138
 
        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
139
540
 
140
541
    def _vfs_cloning_metadir(self, require_stacking=False):
141
542
        self._ensure_real()
172
573
        if len(branch_info) != 2:
173
574
            raise errors.UnexpectedSmartServerResponse(response)
174
575
        branch_ref, branch_name = branch_info
175
 
        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
 
176
581
        if repo_name:
177
 
            format.repository_format = repository.network_format_registry.get(
178
 
                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)
179
588
        if branch_ref == 'ref':
180
589
            # XXX: we need possible_transports here to avoid reopening the
181
590
            # connection to the referenced location
182
 
            ref_bzrdir = BzrDir.open(branch_name)
 
591
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
183
592
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
184
593
            format.set_branch_format(branch_format)
185
594
        elif branch_ref == 'branch':
186
595
            if branch_name:
187
 
                format.set_branch_format(
188
 
                    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)
189
603
        else:
190
604
            raise errors.UnexpectedSmartServerResponse(response)
191
605
        return format
201
615
 
202
616
    def destroy_repository(self):
203
617
        """See BzrDir.destroy_repository"""
204
 
        self._ensure_real()
205
 
        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,))
206
627
 
207
 
    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)
208
634
        # as per meta1 formats - just delegate to the format object which may
209
635
        # be parameterised.
210
 
        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)
211
639
        if not isinstance(real_branch, RemoteBranch):
212
 
            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)
213
645
        else:
214
646
            result = real_branch
215
647
        # BzrDir.clone_on_transport() uses the result of create_branch but does
221
653
        self._next_open_branch_result = result
222
654
        return result
223
655
 
224
 
    def destroy_branch(self):
 
656
    def destroy_branch(self, name=None):
225
657
        """See BzrDir.destroy_branch"""
226
 
        self._ensure_real()
227
 
        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
228
674
        self._next_open_branch_result = None
 
675
        if response[0] != 'ok':
 
676
            raise SmartProtocolError('unexpected response code %s' % (response,))
229
677
 
230
 
    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):
231
680
        raise errors.NotLocalUrl(self.transport.base)
232
681
 
233
 
    def find_branch_format(self):
 
682
    def find_branch_format(self, name=None):
234
683
        """Find the branch 'format' for this bzrdir.
235
684
 
236
685
        This might be a synthetic object for e.g. RemoteBranch and SVN.
237
686
        """
238
 
        b = self.open_branch()
 
687
        b = self.open_branch(name=name)
239
688
        return b._format
240
689
 
241
 
    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):
242
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)
243
723
        response = self._get_branch_reference()
244
724
        if response[0] == 'ref':
245
725
            return response[1]
249
729
    def _get_branch_reference(self):
250
730
        path = self._path_for_remote_call(self._client)
251
731
        medium = self._client._medium
252
 
        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
253
740
            try:
254
 
                response = self._call('BzrDir.open_branchV2', path)
255
 
                if response[0] not in ('ref', 'branch'):
256
 
                    raise errors.UnexpectedSmartServerResponse(response)
257
 
                return response
 
741
                response = self._call(verb, path)
258
742
            except errors.UnknownSmartMethod:
259
 
                medium._remember_remote_is_before((1, 13))
260
 
        response = self._call('BzrDir.open_branch', path)
261
 
        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'):
262
756
            raise errors.UnexpectedSmartServerResponse(response)
263
 
        if response[1] != '':
264
 
            return ('ref', response[1])
265
 
        else:
266
 
            return ('branch', '')
 
757
        return response
267
758
 
268
 
    def _get_tree_branch(self):
 
759
    def _get_tree_branch(self, name=None):
269
760
        """See BzrDir._get_tree_branch()."""
270
 
        return None, self.open_branch()
 
761
        return None, self.open_branch(name=name)
271
762
 
272
 
    def open_branch(self, _unsupported=False, ignore_fallbacks=False):
273
 
        if _unsupported:
274
 
            raise NotImplementedError('unsupported flag support not implemented yet.')
275
 
        if self._next_open_branch_result is not None:
276
 
            # See create_branch for details.
277
 
            result = self._next_open_branch_result
278
 
            self._next_open_branch_result = None
279
 
            return result
280
 
        response = self._get_branch_reference()
281
 
        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':
282
766
            # a branch reference, use the existing BranchReference logic.
283
767
            format = BranchReferenceFormat()
284
 
            return format.open(self, _found=True, location=response[1],
285
 
                ignore_fallbacks=ignore_fallbacks)
286
 
        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
287
772
        if not branch_format_name:
288
773
            branch_format_name = None
289
774
        format = RemoteBranchFormat(network_name=branch_format_name)
290
775
        return RemoteBranch(self, self.find_repository(), format=format,
291
 
            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)
292
796
 
293
797
    def _open_repo_v1(self, path):
294
798
        verb = 'BzrDir.find_repository'
355
859
        else:
356
860
            raise errors.NoRepositoryPresent(self)
357
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
 
358
876
    def open_workingtree(self, recommend_upgrade=True):
359
 
        self._ensure_real()
360
 
        if self._real_bzrdir.has_workingtree():
 
877
        if self.has_workingtree():
361
878
            raise errors.NotLocalUrl(self.root_transport)
362
879
        else:
363
880
            raise errors.NoWorkingTree(self.root_transport.base)
364
881
 
365
882
    def _path_for_remote_call(self, client):
366
883
        """Return the path to be used for this bzrdir in a remote call."""
367
 
        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]
368
886
 
369
 
    def get_branch_transport(self, branch_format):
 
887
    def get_branch_transport(self, branch_format, name=None):
370
888
        self._ensure_real()
371
 
        return self._real_bzrdir.get_branch_transport(branch_format)
 
889
        return self._real_bzrdir.get_branch_transport(branch_format, name=name)
372
890
 
373
891
    def get_repository_transport(self, repository_format):
374
892
        self._ensure_real()
382
900
        """Upgrading of remote bzrdirs is not supported yet."""
383
901
        return False
384
902
 
385
 
    def needs_format_conversion(self, format=None):
 
903
    def needs_format_conversion(self, format):
386
904
        """Upgrading of remote bzrdirs is not supported yet."""
387
 
        if format is None:
388
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
389
 
                % 'needs_format_conversion(format=None)')
390
905
        return False
391
906
 
392
 
    def clone(self, url, revision_id=None, force_new_repo=False,
393
 
              preserve_stacking=False):
394
 
        self._ensure_real()
395
 
        return self._real_bzrdir.clone(url, revision_id=revision_id,
396
 
            force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
397
 
 
398
907
    def _get_config(self):
399
908
        return RemoteBzrDirConfig(self)
400
909
 
401
 
 
402
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
910
    def _get_config_store(self):
 
911
        return RemoteControlStore(self)
 
912
 
 
913
 
 
914
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
403
915
    """Format for repositories accessed over a _SmartClient.
404
916
 
405
917
    Instances of this repository are represented by RemoteRepository
420
932
    """
421
933
 
422
934
    _matchingbzrdir = RemoteBzrDirFormat()
 
935
    supports_full_versioned_files = True
 
936
    supports_leaving_lock = True
423
937
 
424
938
    def __init__(self):
425
 
        repository.RepositoryFormat.__init__(self)
 
939
        _mod_repository.RepositoryFormat.__init__(self)
426
940
        self._custom_format = None
427
941
        self._network_name = None
428
942
        self._creating_bzrdir = None
 
943
        self._revision_graph_can_have_wrong_parents = None
429
944
        self._supports_chks = None
430
945
        self._supports_external_lookups = None
431
946
        self._supports_tree_reference = None
 
947
        self._supports_funky_characters = None
 
948
        self._supports_nesting_repositories = None
432
949
        self._rich_root_data = None
433
950
 
434
951
    def __repr__(self):
463
980
        return self._supports_external_lookups
464
981
 
465
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
466
999
    def supports_tree_reference(self):
467
1000
        if self._supports_tree_reference is None:
468
1001
            self._ensure_real()
470
1003
                self._custom_format.supports_tree_reference
471
1004
        return self._supports_tree_reference
472
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
 
473
1014
    def _vfs_initialize(self, a_bzrdir, shared):
474
1015
        """Helper for common code in initialize."""
475
1016
        if self._custom_format:
510
1051
            network_name = self._network_name
511
1052
        else:
512
1053
            # Select the current bzrlib default and ask for that.
513
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
1054
            reference_bzrdir_format = controldir.format_registry.get('default')()
514
1055
            reference_format = reference_bzrdir_format.repository_format
515
1056
            network_name = reference_format.network_name()
516
1057
        # 2) try direct creation via RPC
542
1083
 
543
1084
    def _ensure_real(self):
544
1085
        if self._custom_format is None:
545
 
            self._custom_format = repository.network_format_registry.get(
546
 
                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)
547
1092
 
548
1093
    @property
549
1094
    def _fetch_order(self):
561
1106
        return self._custom_format._fetch_reconcile
562
1107
 
563
1108
    def get_format_description(self):
564
 
        return 'bzr remote repository'
 
1109
        self._ensure_real()
 
1110
        return 'Remote: ' + self._custom_format.get_format_description()
565
1111
 
566
1112
    def __eq__(self, other):
567
1113
        return self.__class__ is other.__class__
583
1129
        return self._custom_format._serializer
584
1130
 
585
1131
 
586
 
class RemoteRepository(_RpcHelper):
 
1132
class RemoteRepository(_mod_repository.Repository, _RpcHelper,
 
1133
        lock._RelockDebugMixin):
587
1134
    """Repository accessed over rpc.
588
1135
 
589
1136
    For the moment most operations are performed using local transport-backed
613
1160
        self._format = format
614
1161
        self._lock_mode = None
615
1162
        self._lock_token = None
 
1163
        self._write_group_tokens = None
616
1164
        self._lock_count = 0
617
1165
        self._leave_lock = False
618
1166
        # Cache of revision parents; misses are cached during read locks, and
632
1180
        # Additional places to query for data.
633
1181
        self._fallback_repositories = []
634
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
 
635
1194
    def __str__(self):
636
1195
        return "%s(%s)" % (self.__class__.__name__, self.base)
637
1196
 
647
1206
 
648
1207
        :param suppress_errors: see Repository.abort_write_group.
649
1208
        """
650
 
        self._ensure_real()
651
 
        return self._real_repository.abort_write_group(
652
 
            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
653
1233
 
654
1234
    @property
655
1235
    def chk_bytes(self):
669
1249
        for older plugins that don't use e.g. the CommitBuilder
670
1250
        facility.
671
1251
        """
672
 
        self._ensure_real()
673
 
        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()
674
1265
 
675
1266
    def resume_write_group(self, tokens):
676
 
        self._ensure_real()
677
 
        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
678
1279
 
679
1280
    def suspend_write_group(self):
680
 
        self._ensure_real()
681
 
        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
682
1286
 
683
1287
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
684
1288
        self._ensure_real()
745
1349
    def find_text_key_references(self):
746
1350
        """Find the text key references within the repository.
747
1351
 
748
 
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
749
 
        revision_ids. Each altered file-ids has the exact revision_ids that
750
 
        altered it listed explicitly.
751
1352
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
752
1353
            to whether they were referred to by the inventory of the
753
1354
            revision_id that they contain. The inventory texts from all present
771
1372
        """Private method for using with old (< 1.2) servers to fallback."""
772
1373
        if revision_id is None:
773
1374
            revision_id = ''
774
 
        elif revision.is_null(revision_id):
 
1375
        elif _mod_revision.is_null(revision_id):
775
1376
            return {}
776
1377
 
777
1378
        path = self.bzrdir._path_for_remote_call(self._client)
801
1402
        return RemoteStreamSource(self, to_format)
802
1403
 
803
1404
    @needs_read_lock
 
1405
    def get_file_graph(self):
 
1406
        return graph.Graph(self.texts)
 
1407
 
 
1408
    @needs_read_lock
804
1409
    def has_revision(self, revision_id):
805
1410
        """True if this repository has a copy of the revision."""
806
1411
        # Copy of bzrlib.repository.Repository.has_revision
823
1428
    def _has_same_fallbacks(self, other_repo):
824
1429
        """Returns true if the repositories have the same fallbacks."""
825
1430
        # XXX: copied from Repository; it should be unified into a base class
826
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
1431
        # <https://bugs.launchpad.net/bzr/+bug/401622>
827
1432
        my_fb = self._fallback_repositories
828
1433
        other_fb = other_repo._fallback_repositories
829
1434
        if len(my_fb) != len(other_fb):
845
1450
        parents_provider = self._make_parents_provider(other_repository)
846
1451
        return graph.Graph(parents_provider)
847
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
 
848
1462
    def gather_stats(self, revid=None, committers=None):
849
1463
        """See Repository.gather_stats()."""
850
1464
        path = self.bzrdir._path_for_remote_call(self._client)
851
1465
        # revid can be None to indicate no revisions, not just NULL_REVISION
852
 
        if revid is None or revision.is_null(revid):
 
1466
        if revid is None or _mod_revision.is_null(revid):
853
1467
            fmt_revid = ''
854
1468
        else:
855
1469
            fmt_revid = revid
884
1498
 
885
1499
    def get_physical_lock_status(self):
886
1500
        """See Repository.get_physical_lock_status()."""
887
 
        # should be an API call to the server.
888
 
        self._ensure_real()
889
 
        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')
890
1510
 
891
1511
    def is_in_write_group(self):
892
1512
        """Return True if there is an open write group.
893
1513
 
894
1514
        write groups are only applicable locally for the smart server..
895
1515
        """
 
1516
        if self._write_group_tokens is not None:
 
1517
            return True
896
1518
        if self._real_repository:
897
1519
            return self._real_repository.is_in_write_group()
898
1520
 
910
1532
    def is_write_locked(self):
911
1533
        return self._lock_mode == 'w'
912
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
 
913
1540
    def lock_read(self):
 
1541
        """Lock the repository for read operations.
 
1542
 
 
1543
        :return: A bzrlib.lock.LogicalLockResult.
 
1544
        """
914
1545
        # wrong eventually - want a local lock cache context
915
1546
        if not self._lock_mode:
 
1547
            self._note_lock('r')
916
1548
            self._lock_mode = 'r'
917
1549
            self._lock_count = 1
918
1550
            self._unstacked_provider.enable_cache(cache_misses=True)
922
1554
                repo.lock_read()
923
1555
        else:
924
1556
            self._lock_count += 1
 
1557
        return lock.LogicalLockResult(self.unlock)
925
1558
 
926
1559
    def _remote_lock_write(self, token):
927
1560
        path = self.bzrdir._path_for_remote_call(self._client)
938
1571
 
939
1572
    def lock_write(self, token=None, _skip_rpc=False):
940
1573
        if not self._lock_mode:
 
1574
            self._note_lock('w')
941
1575
            if _skip_rpc:
942
1576
                if self._lock_token is not None:
943
1577
                    if token != self._lock_token:
966
1600
            raise errors.ReadOnlyError(self)
967
1601
        else:
968
1602
            self._lock_count += 1
969
 
        return self._lock_token or None
 
1603
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
970
1604
 
971
1605
    def leave_lock_in_place(self):
972
1606
        if not self._lock_token:
1021
1655
            self._real_repository.lock_write(self._lock_token)
1022
1656
        elif self._lock_mode == 'r':
1023
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
1024
1662
 
1025
1663
    def start_write_group(self):
1026
1664
        """Start a write group on the decorated repository.
1030
1668
        for older plugins that don't use e.g. the CommitBuilder
1031
1669
        facility.
1032
1670
        """
1033
 
        self._ensure_real()
1034
 
        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]
1035
1688
 
1036
1689
    def _unlock(self, token):
1037
1690
        path = self.bzrdir._path_for_remote_call(self._client)
1046
1699
        else:
1047
1700
            raise errors.UnexpectedSmartServerResponse(response)
1048
1701
 
 
1702
    @only_raises(errors.LockNotHeld, errors.LockBroken)
1049
1703
    def unlock(self):
1050
1704
        if not self._lock_count:
1051
1705
            return lock.cant_unlock_not_held(self)
1063
1717
            # This is just to let the _real_repository stay up to date.
1064
1718
            if self._real_repository is not None:
1065
1719
                self._real_repository.unlock()
 
1720
            elif self._write_group_tokens is not None:
 
1721
                self.abort_write_group()
1066
1722
        finally:
1067
1723
            # The rpc-level lock should be released even if there was a
1068
1724
            # problem releasing the vfs-based lock.
1080
1736
 
1081
1737
    def break_lock(self):
1082
1738
        # should hand off to the network
1083
 
        self._ensure_real()
1084
 
        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)
1085
1747
 
1086
1748
    def _get_tarball(self, compression):
1087
1749
        """Return a TemporaryFile containing a repository tarball.
1105
1767
            return t
1106
1768
        raise errors.UnexpectedSmartServerResponse(response)
1107
1769
 
 
1770
    @needs_read_lock
1108
1771
    def sprout(self, to_bzrdir, revision_id=None):
1109
 
        # TODO: Option to control what format is created?
1110
 
        self._ensure_real()
1111
 
        dest_repo = self._real_repository._format.initialize(to_bzrdir,
1112
 
                                                             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)
1113
1777
        dest_repo.fetch(self, revision_id=revision_id)
1114
1778
        return dest_repo
1115
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
 
1116
1793
    ### These methods are just thin shims to the VFS object for now.
1117
1794
 
 
1795
    @needs_read_lock
1118
1796
    def revision_tree(self, revision_id):
1119
 
        self._ensure_real()
1120
 
        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]
1121
1803
 
1122
1804
    def get_serializer_format(self):
1123
 
        self._ensure_real()
1124
 
        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]
1125
1815
 
1126
1816
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1127
1817
                           timezone=None, committer=None, revprops=None,
1128
 
                           revision_id=None):
1129
 
        # FIXME: It ought to be possible to call this without immediately
1130
 
        # triggering _ensure_real.  For now it's the easiest thing to do.
1131
 
        self._ensure_real()
1132
 
        real_repo = self._real_repository
1133
 
        builder = real_repo.get_commit_builder(branch, parents,
1134
 
                config, timestamp=timestamp, timezone=timezone,
1135
 
                committer=committer, revprops=revprops, revision_id=revision_id)
1136
 
        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
1137
1845
 
1138
1846
    def add_fallback_repository(self, repository):
1139
1847
        """Add a repository to use for looking up data not held locally.
1146
1854
        # We need to accumulate additional repositories here, to pass them in
1147
1855
        # on various RPC's.
1148
1856
        #
 
1857
        # Make the check before we lock: this raises an exception.
 
1858
        self._check_fallback_repository(repository)
1149
1859
        if self.is_locked():
1150
1860
            # We will call fallback.unlock() when we transition to the unlocked
1151
1861
            # state, so always add a lock here. If a caller passes us a locked
1156
1866
        # _real_branch had its get_stacked_on_url method called), then the
1157
1867
        # repository to be added may already be in the _real_repositories list.
1158
1868
        if self._real_repository is not None:
1159
 
            fallback_locations = [repo.bzrdir.root_transport.base for repo in
 
1869
            fallback_locations = [repo.user_url for repo in
1160
1870
                self._real_repository._fallback_repositories]
1161
 
            if repository.bzrdir.root_transport.base not in fallback_locations:
 
1871
            if repository.user_url not in fallback_locations:
1162
1872
                self._real_repository.add_fallback_repository(repository)
1163
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
 
1164
1884
    def add_inventory(self, revid, inv, parents):
1165
1885
        self._ensure_real()
1166
1886
        return self._real_repository.add_inventory(revid, inv, parents)
1167
1887
 
1168
1888
    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1169
 
                               parents):
 
1889
            parents, basis_inv=None, propagate_caches=False):
1170
1890
        self._ensure_real()
1171
1891
        return self._real_repository.add_inventory_by_delta(basis_revision_id,
1172
 
            delta, new_revision_id, parents)
1173
 
 
1174
 
    def add_revision(self, rev_id, rev, inv=None, config=None):
1175
 
        self._ensure_real()
1176
 
        return self._real_repository.add_revision(
1177
 
            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)
1178
1920
 
1179
1921
    @needs_read_lock
1180
1922
    def get_inventory(self, revision_id):
 
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):
1181
1966
        self._ensure_real()
1182
 
        return self._real_repository.get_inventory(revision_id)
 
1967
        return self._real_repository._iter_inventories(revision_ids, ordering)
1183
1968
 
1184
1969
    def iter_inventories(self, revision_ids, ordering=None):
1185
 
        self._ensure_real()
1186
 
        return self._real_repository.iter_inventories(revision_ids, ordering)
 
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()
1187
2044
 
1188
2045
    @needs_read_lock
1189
2046
    def get_revision(self, revision_id):
1190
 
        self._ensure_real()
1191
 
        return self._real_repository.get_revision(revision_id)
 
2047
        return self.get_revisions([revision_id])[0]
1192
2048
 
1193
2049
    def get_transaction(self):
1194
2050
        self._ensure_real()
1196
2052
 
1197
2053
    @needs_read_lock
1198
2054
    def clone(self, a_bzrdir, revision_id=None):
1199
 
        self._ensure_real()
1200
 
        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
1201
2059
 
1202
2060
    def make_working_trees(self):
1203
2061
        """See Repository.make_working_trees"""
1204
 
        self._ensure_real()
1205
 
        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'
1206
2071
 
1207
2072
    def refresh_data(self):
1208
 
        """Re-read any data needed to to synchronise with disk.
 
2073
        """Re-read any data needed to synchronise with disk.
1209
2074
 
1210
2075
        This method is intended to be called after another repository instance
1211
2076
        (such as one used by a smart server) has inserted data into the
1212
 
        repository. It may not be called during a write group, but may be
1213
 
        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.
1214
2082
        """
1215
 
        if self.is_in_write_group():
1216
 
            raise errors.InternalBzrError(
1217
 
                "May not refresh_data while in a write group.")
1218
2083
        if self._real_repository is not None:
1219
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()
1220
2088
 
1221
2089
    def revision_ids_to_search_result(self, result_set):
1222
2090
        """Convert a set of revision ids to a graph SearchResult."""
1227
2095
        included_keys = result_set.intersection(result_parents)
1228
2096
        start_keys = result_set.difference(included_keys)
1229
2097
        exclude_keys = result_parents.difference(result_set)
1230
 
        result = graph.SearchResult(start_keys, exclude_keys,
 
2098
        result = vf_search.SearchResult(start_keys, exclude_keys,
1231
2099
            len(result_set), result_set)
1232
2100
        return result
1233
2101
 
1234
2102
    @needs_read_lock
1235
 
    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):
1236
2107
        """Return the revision ids that other has that this does not.
1237
2108
 
1238
2109
        These are returned in topological order.
1239
2110
 
1240
2111
        revision_id: only return revision ids included by revision_id.
1241
2112
        """
1242
 
        return repository.InterRepository.get(
1243
 
            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)
1244
2127
 
1245
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
2128
    def fetch(self, source, revision_id=None, find_ghosts=False,
1246
2129
            fetch_spec=None):
1247
2130
        # No base implementation to use as RemoteRepository is not a subclass
1248
2131
        # of Repository; so this is a copy of Repository.fetch().
1259
2142
            # check that last_revision is in 'from' and then return a
1260
2143
            # no-operation.
1261
2144
            if (revision_id is not None and
1262
 
                not revision.is_null(revision_id)):
 
2145
                not _mod_revision.is_null(revision_id)):
1263
2146
                self.get_revision(revision_id)
1264
2147
            return 0, []
1265
2148
        # if there is no specific appropriate InterRepository, this will get
1266
2149
        # the InterRepository base class, which raises an
1267
2150
        # IncompatibleRepositories when asked to fetch.
1268
 
        inter = repository.InterRepository.get(source, self)
1269
 
        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,
1270
2157
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1271
2158
 
1272
2159
    def create_bundle(self, target, base, fileobj, format=None):
1273
2160
        self._ensure_real()
1274
2161
        self._real_repository.create_bundle(target, base, fileobj, format)
1275
2162
 
1276
 
    @needs_read_lock
1277
 
    def get_ancestry(self, revision_id, topo_sorted=True):
1278
 
        self._ensure_real()
1279
 
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1280
 
 
1281
2163
    def fileids_altered_by_revision_ids(self, revision_ids):
1282
2164
        self._ensure_real()
1283
2165
        return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
1287
2169
        return self._real_repository._get_versioned_file_checker(
1288
2170
            revisions, revision_versions_cache)
1289
2171
 
 
2172
    def _iter_files_bytes_rpc(self, desired_files, absent):
 
2173
        path = self.bzrdir._path_for_remote_call(self._client)
 
2174
        lines = []
 
2175
        identifiers = []
 
2176
        for (file_id, revid, identifier) in desired_files:
 
2177
            lines.append("%s\0%s" % (
 
2178
                osutils.safe_file_id(file_id),
 
2179
                osutils.safe_revision_id(revid)))
 
2180
            identifiers.append(identifier)
 
2181
        (response_tuple, response_handler) = (
 
2182
            self._call_with_body_bytes_expecting_body(
 
2183
            "Repository.iter_files_bytes", (path, ), "\n".join(lines)))
 
2184
        if response_tuple != ('ok', ):
 
2185
            response_handler.cancel_read_body()
 
2186
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2187
        byte_stream = response_handler.read_streamed_body()
 
2188
        def decompress_stream(start, byte_stream, unused):
 
2189
            decompressor = zlib.decompressobj()
 
2190
            yield decompressor.decompress(start)
 
2191
            while decompressor.unused_data == "":
 
2192
                try:
 
2193
                    data = byte_stream.next()
 
2194
                except StopIteration:
 
2195
                    break
 
2196
                yield decompressor.decompress(data)
 
2197
            yield decompressor.flush()
 
2198
            unused.append(decompressor.unused_data)
 
2199
        unused = ""
 
2200
        while True:
 
2201
            while not "\n" in unused:
 
2202
                unused += byte_stream.next()
 
2203
            header, rest = unused.split("\n", 1)
 
2204
            args = header.split("\0")
 
2205
            if args[0] == "absent":
 
2206
                absent[identifiers[int(args[3])]] = (args[1], args[2])
 
2207
                unused = rest
 
2208
                continue
 
2209
            elif args[0] == "ok":
 
2210
                idx = int(args[1])
 
2211
            else:
 
2212
                raise errors.UnexpectedSmartServerResponse(args)
 
2213
            unused_chunks = []
 
2214
            yield (identifiers[idx],
 
2215
                decompress_stream(rest, byte_stream, unused_chunks))
 
2216
            unused = "".join(unused_chunks)
 
2217
 
1290
2218
    def iter_files_bytes(self, desired_files):
1291
2219
        """See Repository.iter_file_bytes.
1292
2220
        """
1293
 
        self._ensure_real()
1294
 
        return self._real_repository.iter_files_bytes(desired_files)
 
2221
        try:
 
2222
            absent = {}
 
2223
            for (identifier, bytes_iterator) in self._iter_files_bytes_rpc(
 
2224
                    desired_files, absent):
 
2225
                yield identifier, bytes_iterator
 
2226
            for fallback in self._fallback_repositories:
 
2227
                if not absent:
 
2228
                    break
 
2229
                desired_files = [(key[0], key[1], identifier) for
 
2230
                    (identifier, key) in absent.iteritems()]
 
2231
                for (identifier, bytes_iterator) in fallback.iter_files_bytes(desired_files):
 
2232
                    del absent[identifier]
 
2233
                    yield identifier, bytes_iterator
 
2234
            if absent:
 
2235
                # There may be more missing items, but raise an exception
 
2236
                # for just one.
 
2237
                missing_identifier = absent.keys()[0]
 
2238
                missing_key = absent[missing_identifier]
 
2239
                raise errors.RevisionNotPresent(revision_id=missing_key[1],
 
2240
                    file_id=missing_key[0])
 
2241
        except errors.UnknownSmartMethod:
 
2242
            self._ensure_real()
 
2243
            for (identifier, bytes_iterator) in (
 
2244
                self._real_repository.iter_files_bytes(desired_files)):
 
2245
                yield identifier, bytes_iterator
 
2246
 
 
2247
    def get_cached_parent_map(self, revision_ids):
 
2248
        """See bzrlib.CachingParentsProvider.get_cached_parent_map"""
 
2249
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
1295
2250
 
1296
2251
    def get_parent_map(self, revision_ids):
1297
2252
        """See bzrlib.Graph.get_parent_map()."""
1356
2311
        if parents_map is None:
1357
2312
            # Repository is not locked, so there's no cache.
1358
2313
            parents_map = {}
1359
 
        # start_set is all the keys in the cache
1360
 
        start_set = set(parents_map)
1361
 
        # result set is all the references to keys in the cache
1362
 
        result_parents = set()
1363
 
        for parents in parents_map.itervalues():
1364
 
            result_parents.update(parents)
1365
 
        stop_keys = result_parents.difference(start_set)
1366
 
        # We don't need to send ghosts back to the server as a position to
1367
 
        # stop either.
1368
 
        stop_keys.difference_update(self._unstacked_provider.missing_keys)
1369
 
        key_count = len(parents_map)
1370
 
        if (NULL_REVISION in result_parents
1371
 
            and NULL_REVISION in self._unstacked_provider.missing_keys):
1372
 
            # If we pruned NULL_REVISION from the stop_keys because it's also
1373
 
            # in our cache of "missing" keys we need to increment our key count
1374
 
            # by 1, because the reconsitituted SearchResult on the server will
1375
 
            # still consider NULL_REVISION to be an included key.
1376
 
            key_count += 1
1377
 
        included_keys = start_set.intersection(result_parents)
1378
 
        start_set.difference_update(included_keys)
 
2314
        if _DEFAULT_SEARCH_DEPTH <= 0:
 
2315
            (start_set, stop_keys,
 
2316
             key_count) = vf_search.search_result_from_parent_map(
 
2317
                parents_map, self._unstacked_provider.missing_keys)
 
2318
        else:
 
2319
            (start_set, stop_keys,
 
2320
             key_count) = vf_search.limited_search_result_from_parent_map(
 
2321
                parents_map, self._unstacked_provider.missing_keys,
 
2322
                keys, depth=_DEFAULT_SEARCH_DEPTH)
1379
2323
        recipe = ('manual', start_set, stop_keys, key_count)
1380
2324
        body = self._serialise_search_recipe(recipe)
1381
2325
        path = self.bzrdir._path_for_remote_call(self._client)
1430
2374
 
1431
2375
    @needs_read_lock
1432
2376
    def get_signature_text(self, revision_id):
1433
 
        self._ensure_real()
1434
 
        return self._real_repository.get_signature_text(revision_id)
 
2377
        path = self.bzrdir._path_for_remote_call(self._client)
 
2378
        try:
 
2379
            response_tuple, response_handler = self._call_expecting_body(
 
2380
                'Repository.get_revision_signature_text', path, revision_id)
 
2381
        except errors.UnknownSmartMethod:
 
2382
            self._ensure_real()
 
2383
            return self._real_repository.get_signature_text(revision_id)
 
2384
        except errors.NoSuchRevision, err:
 
2385
            for fallback in self._fallback_repositories:
 
2386
                try:
 
2387
                    return fallback.get_signature_text(revision_id)
 
2388
                except errors.NoSuchRevision:
 
2389
                    pass
 
2390
            raise err
 
2391
        else:
 
2392
            if response_tuple[0] != 'ok':
 
2393
                raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2394
            return response_handler.read_body_bytes()
1435
2395
 
1436
2396
    @needs_read_lock
1437
 
    def get_inventory_xml(self, revision_id):
1438
 
        self._ensure_real()
1439
 
        return self._real_repository.get_inventory_xml(revision_id)
1440
 
 
1441
 
    def deserialise_inventory(self, revision_id, xml):
1442
 
        self._ensure_real()
1443
 
        return self._real_repository.deserialise_inventory(revision_id, xml)
1444
 
 
 
2397
    def _get_inventory_xml(self, revision_id):
 
2398
        # This call is used by older working tree formats,
 
2399
        # which stored a serialized basis inventory.
 
2400
        self._ensure_real()
 
2401
        return self._real_repository._get_inventory_xml(revision_id)
 
2402
 
 
2403
    @needs_write_lock
1445
2404
    def reconcile(self, other=None, thorough=False):
1446
 
        self._ensure_real()
1447
 
        return self._real_repository.reconcile(other=other, thorough=thorough)
 
2405
        from bzrlib.reconcile import RepoReconciler
 
2406
        path = self.bzrdir._path_for_remote_call(self._client)
 
2407
        try:
 
2408
            response, handler = self._call_expecting_body(
 
2409
                'Repository.reconcile', path, self._lock_token)
 
2410
        except (errors.UnknownSmartMethod, errors.TokenLockingNotSupported):
 
2411
            self._ensure_real()
 
2412
            return self._real_repository.reconcile(other=other, thorough=thorough)
 
2413
        if response != ('ok', ):
 
2414
            raise errors.UnexpectedSmartServerResponse(response)
 
2415
        body = handler.read_body_bytes()
 
2416
        result = RepoReconciler(self)
 
2417
        for line in body.split('\n'):
 
2418
            if not line:
 
2419
                continue
 
2420
            key, val_text = line.split(':')
 
2421
            if key == "garbage_inventories":
 
2422
                result.garbage_inventories = int(val_text)
 
2423
            elif key == "inconsistent_parents":
 
2424
                result.inconsistent_parents = int(val_text)
 
2425
            else:
 
2426
                mutter("unknown reconcile key %r" % key)
 
2427
        return result
1448
2428
 
1449
2429
    def all_revision_ids(self):
1450
 
        self._ensure_real()
1451
 
        return self._real_repository.all_revision_ids()
 
2430
        path = self.bzrdir._path_for_remote_call(self._client)
 
2431
        try:
 
2432
            response_tuple, response_handler = self._call_expecting_body(
 
2433
                "Repository.all_revision_ids", path)
 
2434
        except errors.UnknownSmartMethod:
 
2435
            self._ensure_real()
 
2436
            return self._real_repository.all_revision_ids()
 
2437
        if response_tuple != ("ok", ):
 
2438
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2439
        revids = set(response_handler.read_body_bytes().splitlines())
 
2440
        for fallback in self._fallback_repositories:
 
2441
            revids.update(set(fallback.all_revision_ids()))
 
2442
        return list(revids)
 
2443
 
 
2444
    def _filtered_revision_trees(self, revision_ids, file_ids):
 
2445
        """Return Tree for a revision on this branch with only some files.
 
2446
 
 
2447
        :param revision_ids: a sequence of revision-ids;
 
2448
          a revision-id may not be None or 'null:'
 
2449
        :param file_ids: if not None, the result is filtered
 
2450
          so that only those file-ids, their parents and their
 
2451
          children are included.
 
2452
        """
 
2453
        inventories = self.iter_inventories(revision_ids)
 
2454
        for inv in inventories:
 
2455
            # Should we introduce a FilteredRevisionTree class rather
 
2456
            # than pre-filter the inventory here?
 
2457
            filtered_inv = inv.filter(file_ids)
 
2458
            yield InventoryRevisionTree(self, filtered_inv, filtered_inv.revision_id)
1452
2459
 
1453
2460
    @needs_read_lock
1454
2461
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1455
 
        self._ensure_real()
1456
 
        return self._real_repository.get_deltas_for_revisions(revisions,
1457
 
            specific_fileids=specific_fileids)
 
2462
        medium = self._client._medium
 
2463
        if medium._is_remote_before((1, 2)):
 
2464
            self._ensure_real()
 
2465
            for delta in self._real_repository.get_deltas_for_revisions(
 
2466
                    revisions, specific_fileids):
 
2467
                yield delta
 
2468
            return
 
2469
        # Get the revision-ids of interest
 
2470
        required_trees = set()
 
2471
        for revision in revisions:
 
2472
            required_trees.add(revision.revision_id)
 
2473
            required_trees.update(revision.parent_ids[:1])
 
2474
 
 
2475
        # Get the matching filtered trees. Note that it's more
 
2476
        # efficient to pass filtered trees to changes_from() rather
 
2477
        # than doing the filtering afterwards. changes_from() could
 
2478
        # arguably do the filtering itself but it's path-based, not
 
2479
        # file-id based, so filtering before or afterwards is
 
2480
        # currently easier.
 
2481
        if specific_fileids is None:
 
2482
            trees = dict((t.get_revision_id(), t) for
 
2483
                t in self.revision_trees(required_trees))
 
2484
        else:
 
2485
            trees = dict((t.get_revision_id(), t) for
 
2486
                t in self._filtered_revision_trees(required_trees,
 
2487
                specific_fileids))
 
2488
 
 
2489
        # Calculate the deltas
 
2490
        for revision in revisions:
 
2491
            if not revision.parent_ids:
 
2492
                old_tree = self.revision_tree(_mod_revision.NULL_REVISION)
 
2493
            else:
 
2494
                old_tree = trees[revision.parent_ids[0]]
 
2495
            yield trees[revision.revision_id].changes_from(old_tree)
1458
2496
 
1459
2497
    @needs_read_lock
1460
2498
    def get_revision_delta(self, revision_id, specific_fileids=None):
1461
 
        self._ensure_real()
1462
 
        return self._real_repository.get_revision_delta(revision_id,
1463
 
            specific_fileids=specific_fileids)
 
2499
        r = self.get_revision(revision_id)
 
2500
        return list(self.get_deltas_for_revisions([r],
 
2501
            specific_fileids=specific_fileids))[0]
1464
2502
 
1465
2503
    @needs_read_lock
1466
2504
    def revision_trees(self, revision_ids):
1467
 
        self._ensure_real()
1468
 
        return self._real_repository.revision_trees(revision_ids)
 
2505
        inventories = self.iter_inventories(revision_ids)
 
2506
        for inv in inventories:
 
2507
            yield InventoryRevisionTree(self, inv, inv.revision_id)
1469
2508
 
1470
2509
    @needs_read_lock
1471
2510
    def get_revision_reconcile(self, revision_id):
1479
2518
            callback_refs=callback_refs, check_repo=check_repo)
1480
2519
 
1481
2520
    def copy_content_into(self, destination, revision_id=None):
1482
 
        self._ensure_real()
1483
 
        return self._real_repository.copy_content_into(
1484
 
            destination, revision_id=revision_id)
 
2521
        """Make a complete copy of the content in self into destination.
 
2522
 
 
2523
        This is a destructive operation! Do not use it on existing
 
2524
        repositories.
 
2525
        """
 
2526
        interrepo = _mod_repository.InterRepository.get(self, destination)
 
2527
        return interrepo.copy_content(revision_id)
1485
2528
 
1486
2529
    def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1487
2530
        # get a tarball of the remote repository, and copy from that into the
1488
2531
        # destination
1489
 
        from bzrlib import osutils
1490
2532
        import tarfile
1491
2533
        # TODO: Maybe a progress bar while streaming the tarball?
1492
 
        note("Copying repository content as tarball...")
 
2534
        note(gettext("Copying repository content as tarball..."))
1493
2535
        tar_file = self._get_tarball('bz2')
1494
2536
        if tar_file is None:
1495
2537
            return None
1500
2542
            tmpdir = osutils.mkdtemp()
1501
2543
            try:
1502
2544
                _extract_tar(tar, tmpdir)
1503
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
2545
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1504
2546
                tmp_repo = tmp_bzrdir.open_repository()
1505
2547
                tmp_repo.copy_content_into(destination, revision_id)
1506
2548
            finally:
1522
2564
        return self._real_repository.inventories
1523
2565
 
1524
2566
    @needs_write_lock
1525
 
    def pack(self, hint=None):
 
2567
    def pack(self, hint=None, clean_obsolete_packs=False):
1526
2568
        """Compress the data within the repository.
1527
 
 
1528
 
        This is not currently implemented within the smart server.
1529
2569
        """
1530
 
        self._ensure_real()
1531
 
        return self._real_repository.pack(hint=hint)
 
2570
        if hint is None:
 
2571
            body = ""
 
2572
        else:
 
2573
            body = "".join([l+"\n" for l in hint])
 
2574
        path = self.bzrdir._path_for_remote_call(self._client)
 
2575
        try:
 
2576
            response, handler = self._call_with_body_bytes_expecting_body(
 
2577
                'Repository.pack', (path, self._lock_token,
 
2578
                    str(clean_obsolete_packs)), body)
 
2579
        except errors.UnknownSmartMethod:
 
2580
            self._ensure_real()
 
2581
            return self._real_repository.pack(hint=hint,
 
2582
                clean_obsolete_packs=clean_obsolete_packs)
 
2583
        handler.cancel_read_body()
 
2584
        if response != ('ok', ):
 
2585
            raise errors.UnexpectedSmartServerResponse(response)
1532
2586
 
1533
2587
    @property
1534
2588
    def revisions(self):
1535
2589
        """Decorate the real repository for now.
1536
2590
 
1537
 
        In the short term this should become a real object to intercept graph
1538
 
        lookups.
1539
 
 
1540
2591
        In the long term a full blown network facility is needed.
1541
2592
        """
1542
2593
        self._ensure_real()
1570
2621
 
1571
2622
    @needs_write_lock
1572
2623
    def sign_revision(self, revision_id, gpg_strategy):
1573
 
        self._ensure_real()
1574
 
        return self._real_repository.sign_revision(revision_id, gpg_strategy)
 
2624
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2625
        plaintext = testament.as_short_text()
 
2626
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1575
2627
 
1576
2628
    @property
1577
2629
    def texts(self):
1583
2635
        self._ensure_real()
1584
2636
        return self._real_repository.texts
1585
2637
 
 
2638
    def _iter_revisions_rpc(self, revision_ids):
 
2639
        body = "\n".join(revision_ids)
 
2640
        path = self.bzrdir._path_for_remote_call(self._client)
 
2641
        response_tuple, response_handler = (
 
2642
            self._call_with_body_bytes_expecting_body(
 
2643
            "Repository.iter_revisions", (path, ), body))
 
2644
        if response_tuple[0] != "ok":
 
2645
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2646
        serializer_format = response_tuple[1]
 
2647
        serializer = serializer_format_registry.get(serializer_format)
 
2648
        byte_stream = response_handler.read_streamed_body()
 
2649
        decompressor = zlib.decompressobj()
 
2650
        chunks = []
 
2651
        for bytes in byte_stream:
 
2652
            chunks.append(decompressor.decompress(bytes))
 
2653
            if decompressor.unused_data != "":
 
2654
                chunks.append(decompressor.flush())
 
2655
                yield serializer.read_revision_from_string("".join(chunks))
 
2656
                unused = decompressor.unused_data
 
2657
                decompressor = zlib.decompressobj()
 
2658
                chunks = [decompressor.decompress(unused)]
 
2659
        chunks.append(decompressor.flush())
 
2660
        text = "".join(chunks)
 
2661
        if text != "":
 
2662
            yield serializer.read_revision_from_string("".join(chunks))
 
2663
 
1586
2664
    @needs_read_lock
1587
2665
    def get_revisions(self, revision_ids):
1588
 
        self._ensure_real()
1589
 
        return self._real_repository.get_revisions(revision_ids)
 
2666
        if revision_ids is None:
 
2667
            revision_ids = self.all_revision_ids()
 
2668
        else:
 
2669
            for rev_id in revision_ids:
 
2670
                if not rev_id or not isinstance(rev_id, basestring):
 
2671
                    raise errors.InvalidRevisionId(
 
2672
                        revision_id=rev_id, branch=self)
 
2673
        try:
 
2674
            missing = set(revision_ids)
 
2675
            revs = {}
 
2676
            for rev in self._iter_revisions_rpc(revision_ids):
 
2677
                missing.remove(rev.revision_id)
 
2678
                revs[rev.revision_id] = rev
 
2679
        except errors.UnknownSmartMethod:
 
2680
            self._ensure_real()
 
2681
            return self._real_repository.get_revisions(revision_ids)
 
2682
        for fallback in self._fallback_repositories:
 
2683
            if not missing:
 
2684
                break
 
2685
            for revid in list(missing):
 
2686
                # XXX JRV 2011-11-20: It would be nice if there was a
 
2687
                # public method on Repository that could be used to query
 
2688
                # for revision objects *without* failing completely if one
 
2689
                # was missing. There is VersionedFileRepository._iter_revisions,
 
2690
                # but unfortunately that's private and not provided by
 
2691
                # all repository implementations.
 
2692
                try:
 
2693
                    revs[revid] = fallback.get_revision(revid)
 
2694
                except errors.NoSuchRevision:
 
2695
                    pass
 
2696
                else:
 
2697
                    missing.remove(revid)
 
2698
        if missing:
 
2699
            raise errors.NoSuchRevision(self, list(missing)[0])
 
2700
        return [revs[revid] for revid in revision_ids]
1590
2701
 
1591
2702
    def supports_rich_root(self):
1592
2703
        return self._format.rich_root_data
1593
2704
 
1594
 
    def iter_reverse_revision_history(self, revision_id):
1595
 
        self._ensure_real()
1596
 
        return self._real_repository.iter_reverse_revision_history(revision_id)
1597
 
 
1598
2705
    @property
1599
2706
    def _serializer(self):
1600
2707
        return self._format._serializer
1601
2708
 
 
2709
    @needs_write_lock
1602
2710
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1603
 
        self._ensure_real()
1604
 
        return self._real_repository.store_revision_signature(
1605
 
            gpg_strategy, plaintext, revision_id)
 
2711
        signature = gpg_strategy.sign(plaintext)
 
2712
        self.add_signature_text(revision_id, signature)
1606
2713
 
1607
2714
    def add_signature_text(self, revision_id, signature):
1608
 
        self._ensure_real()
1609
 
        return self._real_repository.add_signature_text(revision_id, signature)
 
2715
        if self._real_repository:
 
2716
            # If there is a real repository the write group will
 
2717
            # be in the real repository as well, so use that:
 
2718
            self._ensure_real()
 
2719
            return self._real_repository.add_signature_text(
 
2720
                revision_id, signature)
 
2721
        path = self.bzrdir._path_for_remote_call(self._client)
 
2722
        response, handler = self._call_with_body_bytes_expecting_body(
 
2723
            'Repository.add_signature_text', (path, self._lock_token,
 
2724
                revision_id) + tuple(self._write_group_tokens), signature)
 
2725
        handler.cancel_read_body()
 
2726
        self.refresh_data()
 
2727
        if response[0] != 'ok':
 
2728
            raise errors.UnexpectedSmartServerResponse(response)
 
2729
        self._write_group_tokens = response[1:]
1610
2730
 
1611
2731
    def has_signature_for_revision_id(self, revision_id):
1612
 
        self._ensure_real()
1613
 
        return self._real_repository.has_signature_for_revision_id(revision_id)
 
2732
        path = self.bzrdir._path_for_remote_call(self._client)
 
2733
        try:
 
2734
            response = self._call('Repository.has_signature_for_revision_id',
 
2735
                path, revision_id)
 
2736
        except errors.UnknownSmartMethod:
 
2737
            self._ensure_real()
 
2738
            return self._real_repository.has_signature_for_revision_id(
 
2739
                revision_id)
 
2740
        if response[0] not in ('yes', 'no'):
 
2741
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2742
        if response[0] == 'yes':
 
2743
            return True
 
2744
        for fallback in self._fallback_repositories:
 
2745
            if fallback.has_signature_for_revision_id(revision_id):
 
2746
                return True
 
2747
        return False
 
2748
 
 
2749
    @needs_read_lock
 
2750
    def verify_revision_signature(self, revision_id, gpg_strategy):
 
2751
        if not self.has_signature_for_revision_id(revision_id):
 
2752
            return gpg.SIGNATURE_NOT_SIGNED, None
 
2753
        signature = self.get_signature_text(revision_id)
 
2754
 
 
2755
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2756
        plaintext = testament.as_short_text()
 
2757
 
 
2758
        return gpg_strategy.verify(signature, plaintext)
1614
2759
 
1615
2760
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1616
2761
        self._ensure_real()
1617
2762
        return self._real_repository.item_keys_introduced_by(revision_ids,
1618
2763
            _files_pb=_files_pb)
1619
2764
 
1620
 
    def revision_graph_can_have_wrong_parents(self):
1621
 
        # The answer depends on the remote repo format.
1622
 
        self._ensure_real()
1623
 
        return self._real_repository.revision_graph_can_have_wrong_parents()
1624
 
 
1625
2765
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1626
2766
        self._ensure_real()
1627
2767
        return self._real_repository._find_inconsistent_revision_parents(
1635
2775
        providers = [self._unstacked_provider]
1636
2776
        if other is not None:
1637
2777
            providers.insert(0, other)
1638
 
        providers.extend(r._make_parents_provider() for r in
1639
 
                         self._fallback_repositories)
1640
 
        return graph.StackedParentsProvider(providers)
 
2778
        return graph.StackedParentsProvider(_LazyListJoin(
 
2779
            providers, self._fallback_repositories))
1641
2780
 
1642
2781
    def _serialise_search_recipe(self, recipe):
1643
2782
        """Serialise a graph search recipe.
1651
2790
        return '\n'.join((start_keys, stop_keys, count))
1652
2791
 
1653
2792
    def _serialise_search_result(self, search_result):
1654
 
        if isinstance(search_result, graph.PendingAncestryResult):
1655
 
            parts = ['ancestry-of']
1656
 
            parts.extend(search_result.heads)
1657
 
        else:
1658
 
            recipe = search_result.get_recipe()
1659
 
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
 
2793
        parts = search_result.get_network_struct()
1660
2794
        return '\n'.join(parts)
1661
2795
 
1662
2796
    def autopack(self):
1672
2806
            raise errors.UnexpectedSmartServerResponse(response)
1673
2807
 
1674
2808
 
1675
 
class RemoteStreamSink(repository.StreamSink):
 
2809
class RemoteStreamSink(vf_repository.StreamSink):
1676
2810
 
1677
2811
    def _insert_real(self, stream, src_format, resume_tokens):
1678
2812
        self.target_repo._ensure_real()
1739
2873
            # The stream included an inventory-delta record, but the remote
1740
2874
            # side isn't new enough to support them.  So we need to send the
1741
2875
            # rest of the stream via VFS.
 
2876
            self.target_repo.refresh_data()
1742
2877
            return self._resume_stream_with_vfs(response, src_format)
1743
2878
        if response[0][0] == 'missing-basis':
1744
2879
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1778
2913
        self._last_substream and self._last_stream so that the stream can be
1779
2914
        resumed by _resume_stream_with_vfs.
1780
2915
        """
1781
 
                    
 
2916
 
1782
2917
        stream_iter = iter(stream)
1783
2918
        for substream_kind, substream in stream_iter:
1784
2919
            if substream_kind == 'inventory-deltas':
1787
2922
                return
1788
2923
            else:
1789
2924
                yield substream_kind, substream
1790
 
            
1791
 
 
1792
 
class RemoteStreamSource(repository.StreamSource):
 
2925
 
 
2926
 
 
2927
class RemoteStreamSource(vf_repository.StreamSource):
1793
2928
    """Stream data from a remote server."""
1794
2929
 
1795
2930
    def get_stream(self, search):
1816
2951
 
1817
2952
    def _real_stream(self, repo, search):
1818
2953
        """Get a stream for search from repo.
1819
 
        
1820
 
        This never called RemoteStreamSource.get_stream, and is a heler
1821
 
        for RemoteStreamSource._get_stream to allow getting a stream 
 
2954
 
 
2955
        This never called RemoteStreamSource.get_stream, and is a helper
 
2956
        for RemoteStreamSource._get_stream to allow getting a stream
1822
2957
        reliably whether fallback back because of old servers or trying
1823
2958
        to stream from a non-RemoteRepository (which the stacked support
1824
2959
        code will do).
1855
2990
        candidate_verbs = [
1856
2991
            ('Repository.get_stream_1.19', (1, 19)),
1857
2992
            ('Repository.get_stream', (1, 13))]
 
2993
 
1858
2994
        found_verb = False
1859
2995
        for verb, version in candidate_verbs:
1860
2996
            if medium._is_remote_before(version):
1864
3000
                    verb, args, search_bytes)
1865
3001
            except errors.UnknownSmartMethod:
1866
3002
                medium._remember_remote_is_before(version)
 
3003
            except errors.UnknownErrorFromSmartServer, e:
 
3004
                if isinstance(search, vf_search.EverythingResult):
 
3005
                    error_verb = e.error_from_smart_server.error_verb
 
3006
                    if error_verb == 'BadSearch':
 
3007
                        # Pre-2.4 servers don't support this sort of search.
 
3008
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
3009
                        # good idea in general?  It might provide a little bit
 
3010
                        # of protection against client-side bugs.
 
3011
                        medium._remember_remote_is_before((2, 4))
 
3012
                        break
 
3013
                raise
1867
3014
            else:
1868
3015
                response_tuple, response_handler = response
1869
3016
                found_verb = True
1873
3020
        if response_tuple[0] != 'ok':
1874
3021
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1875
3022
        byte_stream = response_handler.read_streamed_body()
1876
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
3023
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
3024
            self._record_counter)
1877
3025
        if src_format.network_name() != repo._format.network_name():
1878
3026
            raise AssertionError(
1879
3027
                "Mismatched RemoteRepository and stream src %r, %r" % (
1886
3034
        :param search: The overall search to satisfy with streams.
1887
3035
        :param sources: A list of Repository objects to query.
1888
3036
        """
1889
 
        self.serialiser = self.to_format._serializer
 
3037
        self.from_serialiser = self.from_repository._format._serializer
1890
3038
        self.seen_revs = set()
1891
3039
        self.referenced_revs = set()
1892
3040
        # If there are heads in the search, or the key count is > 0, we are not
1909
3057
    def missing_parents_rev_handler(self, substream):
1910
3058
        for content in substream:
1911
3059
            revision_bytes = content.get_bytes_as('fulltext')
1912
 
            revision = self.serialiser.read_revision_from_string(revision_bytes)
 
3060
            revision = self.from_serialiser.read_revision_from_string(
 
3061
                revision_bytes)
1913
3062
            self.seen_revs.add(content.key[-1])
1914
3063
            self.referenced_revs.update(revision.parent_ids)
1915
3064
            yield content
1950
3099
 
1951
3100
    def _ensure_real(self):
1952
3101
        if self._custom_format is None:
1953
 
            self._custom_format = branch.network_format_registry.get(
1954
 
                self._network_name)
 
3102
            try:
 
3103
                self._custom_format = branch.network_format_registry.get(
 
3104
                    self._network_name)
 
3105
            except KeyError:
 
3106
                raise errors.UnknownFormatError(kind='branch',
 
3107
                    format=self._network_name)
1955
3108
 
1956
3109
    def get_format_description(self):
1957
 
        return 'Remote BZR Branch'
 
3110
        self._ensure_real()
 
3111
        return 'Remote: ' + self._custom_format.get_format_description()
1958
3112
 
1959
3113
    def network_name(self):
1960
3114
        return self._network_name
1961
3115
 
1962
 
    def open(self, a_bzrdir, ignore_fallbacks=False):
1963
 
        return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
 
3116
    def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
 
3117
        return a_bzrdir.open_branch(name=name, 
 
3118
            ignore_fallbacks=ignore_fallbacks)
1964
3119
 
1965
 
    def _vfs_initialize(self, a_bzrdir):
 
3120
    def _vfs_initialize(self, a_bzrdir, name, append_revisions_only,
 
3121
                        repository=None):
1966
3122
        # Initialisation when using a local bzrdir object, or a non-vfs init
1967
3123
        # method is not available on the server.
1968
3124
        # self._custom_format is always set - the start of initialize ensures
1969
3125
        # that.
1970
3126
        if isinstance(a_bzrdir, RemoteBzrDir):
1971
3127
            a_bzrdir._ensure_real()
1972
 
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
 
3128
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
 
3129
                name=name, append_revisions_only=append_revisions_only,
 
3130
                repository=repository)
1973
3131
        else:
1974
3132
            # We assume the bzrdir is parameterised; it may not be.
1975
 
            result = self._custom_format.initialize(a_bzrdir)
 
3133
            result = self._custom_format.initialize(a_bzrdir, name=name,
 
3134
                append_revisions_only=append_revisions_only,
 
3135
                repository=repository)
1976
3136
        if (isinstance(a_bzrdir, RemoteBzrDir) and
1977
3137
            not isinstance(result, RemoteBranch)):
1978
 
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
 
3138
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
 
3139
                                  name=name)
1979
3140
        return result
1980
3141
 
1981
 
    def initialize(self, a_bzrdir):
 
3142
    def initialize(self, a_bzrdir, name=None, repository=None,
 
3143
                   append_revisions_only=None):
 
3144
        if name is None:
 
3145
            name = a_bzrdir._get_selected_branch()
1982
3146
        # 1) get the network name to use.
1983
3147
        if self._custom_format:
1984
3148
            network_name = self._custom_format.network_name()
1985
3149
        else:
1986
3150
            # Select the current bzrlib default and ask for that.
1987
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
3151
            reference_bzrdir_format = controldir.format_registry.get('default')()
1988
3152
            reference_format = reference_bzrdir_format.get_branch_format()
1989
3153
            self._custom_format = reference_format
1990
3154
            network_name = reference_format.network_name()
1991
3155
        # Being asked to create on a non RemoteBzrDir:
1992
3156
        if not isinstance(a_bzrdir, RemoteBzrDir):
1993
 
            return self._vfs_initialize(a_bzrdir)
 
3157
            return self._vfs_initialize(a_bzrdir, name=name,
 
3158
                append_revisions_only=append_revisions_only,
 
3159
                repository=repository)
1994
3160
        medium = a_bzrdir._client._medium
1995
3161
        if medium._is_remote_before((1, 13)):
1996
 
            return self._vfs_initialize(a_bzrdir)
 
3162
            return self._vfs_initialize(a_bzrdir, name=name,
 
3163
                append_revisions_only=append_revisions_only,
 
3164
                repository=repository)
1997
3165
        # Creating on a remote bzr dir.
1998
3166
        # 2) try direct creation via RPC
1999
3167
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
 
3168
        if name != "":
 
3169
            # XXX JRV20100304: Support creating colocated branches
 
3170
            raise errors.NoColocatedBranchSupport(self)
2000
3171
        verb = 'BzrDir.create_branch'
2001
3172
        try:
2002
3173
            response = a_bzrdir._call(verb, path, network_name)
2003
3174
        except errors.UnknownSmartMethod:
2004
3175
            # Fallback - use vfs methods
2005
3176
            medium._remember_remote_is_before((1, 13))
2006
 
            return self._vfs_initialize(a_bzrdir)
 
3177
            return self._vfs_initialize(a_bzrdir, name=name,
 
3178
                    append_revisions_only=append_revisions_only,
 
3179
                    repository=repository)
2007
3180
        if response[0] != 'ok':
2008
3181
            raise errors.UnexpectedSmartServerResponse(response)
2009
3182
        # Turn the response into a RemoteRepository object.
2010
3183
        format = RemoteBranchFormat(network_name=response[1])
2011
3184
        repo_format = response_tuple_to_repo_format(response[3:])
2012
 
        if response[2] == '':
2013
 
            repo_bzrdir = a_bzrdir
 
3185
        repo_path = response[2]
 
3186
        if repository is not None:
 
3187
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
 
3188
            url_diff = urlutils.relative_url(repository.user_url,
 
3189
                    remote_repo_url)
 
3190
            if url_diff != '.':
 
3191
                raise AssertionError(
 
3192
                    'repository.user_url %r does not match URL from server '
 
3193
                    'response (%r + %r)'
 
3194
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
 
3195
            remote_repo = repository
2014
3196
        else:
2015
 
            repo_bzrdir = RemoteBzrDir(
2016
 
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2017
 
                a_bzrdir._client)
2018
 
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
3197
            if repo_path == '':
 
3198
                repo_bzrdir = a_bzrdir
 
3199
            else:
 
3200
                repo_bzrdir = RemoteBzrDir(
 
3201
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
3202
                    a_bzrdir._client)
 
3203
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2019
3204
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2020
 
            format=format, setup_stacking=False)
 
3205
            format=format, setup_stacking=False, name=name)
 
3206
        if append_revisions_only:
 
3207
            remote_branch.set_append_revisions_only(append_revisions_only)
2021
3208
        # XXX: We know this is a new branch, so it must have revno 0, revid
2022
3209
        # NULL_REVISION. Creating the branch locked would make this be unable
2023
3210
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2042
3229
        self._ensure_real()
2043
3230
        return self._custom_format.supports_set_append_revisions_only()
2044
3231
 
2045
 
 
2046
 
class RemoteBranch(branch.Branch, _RpcHelper):
 
3232
    def _use_default_local_heads_to_fetch(self):
 
3233
        # If the branch format is a metadir format *and* its heads_to_fetch
 
3234
        # implementation is not overridden vs the base class, we can use the
 
3235
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
3236
        # usually cheaper in terms of net round trips, as the last-revision and
 
3237
        # tags info fetched is cached and would be fetched anyway.
 
3238
        self._ensure_real()
 
3239
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
3240
            branch_class = self._custom_format._branch_class()
 
3241
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
3242
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
3243
                return True
 
3244
        return False
 
3245
 
 
3246
 
 
3247
class RemoteBranchStore(_mod_config.IniFileStore):
 
3248
    """Branch store which attempts to use HPSS calls to retrieve branch store.
 
3249
 
 
3250
    Note that this is specific to bzr-based formats.
 
3251
    """
 
3252
 
 
3253
    def __init__(self, branch):
 
3254
        super(RemoteBranchStore, self).__init__()
 
3255
        self.branch = branch
 
3256
        self.id = "branch"
 
3257
        self._real_store = None
 
3258
 
 
3259
    def external_url(self):
 
3260
        return urlutils.join(self.branch.user_url, 'branch.conf')
 
3261
 
 
3262
    def _load_content(self):
 
3263
        path = self.branch._remote_path()
 
3264
        try:
 
3265
            response, handler = self.branch._call_expecting_body(
 
3266
                'Branch.get_config_file', path)
 
3267
        except errors.UnknownSmartMethod:
 
3268
            self._ensure_real()
 
3269
            return self._real_store._load_content()
 
3270
        if len(response) and response[0] != 'ok':
 
3271
            raise errors.UnexpectedSmartServerResponse(response)
 
3272
        return handler.read_body_bytes()
 
3273
 
 
3274
    def _save_content(self, content):
 
3275
        path = self.branch._remote_path()
 
3276
        try:
 
3277
            response, handler = self.branch._call_with_body_bytes_expecting_body(
 
3278
                'Branch.put_config_file', (path,
 
3279
                    self.branch._lock_token, self.branch._repo_lock_token),
 
3280
                content)
 
3281
        except errors.UnknownSmartMethod:
 
3282
            self._ensure_real()
 
3283
            return self._real_store._save_content(content)
 
3284
        handler.cancel_read_body()
 
3285
        if response != ('ok', ):
 
3286
            raise errors.UnexpectedSmartServerResponse(response)
 
3287
 
 
3288
    def _ensure_real(self):
 
3289
        self.branch._ensure_real()
 
3290
        if self._real_store is None:
 
3291
            self._real_store = _mod_config.BranchStore(self.branch)
 
3292
 
 
3293
 
 
3294
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2047
3295
    """Branch stored on a server accessed by HPSS RPC.
2048
3296
 
2049
3297
    At the moment most operations are mapped down to simple file operations.
2050
3298
    """
2051
3299
 
2052
3300
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2053
 
        _client=None, format=None, setup_stacking=True):
 
3301
        _client=None, format=None, setup_stacking=True, name=None,
 
3302
        possible_transports=None):
2054
3303
        """Create a RemoteBranch instance.
2055
3304
 
2056
3305
        :param real_branch: An optional local implementation of the branch
2062
3311
        :param setup_stacking: If True make an RPC call to determine the
2063
3312
            stacked (or not) status of the branch. If False assume the branch
2064
3313
            is not stacked.
 
3314
        :param name: Colocated branch name
2065
3315
        """
2066
3316
        # We intentionally don't call the parent class's __init__, because it
2067
3317
        # will try to assign to self.tags, which is a property in this subclass.
2068
3318
        # And the parent's __init__ doesn't do much anyway.
2069
3319
        self.bzrdir = remote_bzrdir
 
3320
        self.name = name
2070
3321
        if _client is not None:
2071
3322
            self._client = _client
2072
3323
        else:
2086
3337
            self._real_branch = None
2087
3338
        # Fill out expected attributes of branch for bzrlib API users.
2088
3339
        self._clear_cached_state()
2089
 
        self.base = self.bzrdir.root_transport.base
 
3340
        # TODO: deprecate self.base in favor of user_url
 
3341
        self.base = self.bzrdir.user_url
 
3342
        self._name = name
2090
3343
        self._control_files = None
2091
3344
        self._lock_mode = None
2092
3345
        self._lock_token = None
2093
3346
        self._repo_lock_token = None
2094
3347
        self._lock_count = 0
2095
3348
        self._leave_lock = False
 
3349
        self.conf_store = None
2096
3350
        # Setup a format: note that we cannot call _ensure_real until all the
2097
3351
        # attributes above are set: This code cannot be moved higher up in this
2098
3352
        # function.
2118
3372
            hook(self)
2119
3373
        self._is_stacked = False
2120
3374
        if setup_stacking:
2121
 
            self._setup_stacking()
 
3375
            self._setup_stacking(possible_transports)
2122
3376
 
2123
 
    def _setup_stacking(self):
 
3377
    def _setup_stacking(self, possible_transports):
2124
3378
        # configure stacking into the remote repository, by reading it from
2125
3379
        # the vfs branch.
2126
3380
        try:
2129
3383
            errors.UnstackableRepositoryFormat), e:
2130
3384
            return
2131
3385
        self._is_stacked = True
2132
 
        self._activate_fallback_location(fallback_url)
 
3386
        if possible_transports is None:
 
3387
            possible_transports = []
 
3388
        else:
 
3389
            possible_transports = list(possible_transports)
 
3390
        possible_transports.append(self.bzrdir.root_transport)
 
3391
        self._activate_fallback_location(fallback_url,
 
3392
            possible_transports=possible_transports)
2133
3393
 
2134
3394
    def _get_config(self):
2135
3395
        return RemoteBranchConfig(self)
2136
3396
 
 
3397
    def _get_config_store(self):
 
3398
        if self.conf_store is None:
 
3399
            self.conf_store =  RemoteBranchStore(self)
 
3400
        return self.conf_store
 
3401
 
 
3402
    def store_uncommitted(self, creator):
 
3403
        self._ensure_real()
 
3404
        return self._real_branch.store_uncommitted(creator)
 
3405
 
 
3406
    def get_unshelver(self, tree):
 
3407
        self._ensure_real()
 
3408
        return self._real_branch.get_unshelver(tree)
 
3409
 
2137
3410
    def _get_real_transport(self):
2138
3411
        # if we try vfs access, return the real branch's vfs transport
2139
3412
        self._ensure_real()
2157
3430
                    'to use vfs implementation')
2158
3431
            self.bzrdir._ensure_real()
2159
3432
            self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2160
 
                ignore_fallbacks=self._real_ignore_fallbacks)
 
3433
                ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
 
3434
            # The remote branch and the real branch shares the same store. If
 
3435
            # we don't, there will always be cases where one of the stores
 
3436
            # doesn't see an update made on the other.
 
3437
            self._real_branch.conf_store = self.conf_store
2161
3438
            if self.repository._real_repository is None:
2162
3439
                # Give the remote repository the matching real repo.
2163
3440
                real_repo = self._real_branch.repository
2202
3479
                self.bzrdir, self._client)
2203
3480
        return self._control_files
2204
3481
 
2205
 
    def _get_checkout_format(self):
2206
 
        self._ensure_real()
2207
 
        return self._real_branch._get_checkout_format()
2208
 
 
2209
3482
    def get_physical_lock_status(self):
2210
3483
        """See Branch.get_physical_lock_status()."""
2211
 
        # should be an API call to the server, as branches must be lockable.
2212
 
        self._ensure_real()
2213
 
        return self._real_branch.get_physical_lock_status()
 
3484
        try:
 
3485
            response = self._client.call('Branch.get_physical_lock_status',
 
3486
                self._remote_path())
 
3487
        except errors.UnknownSmartMethod:
 
3488
            self._ensure_real()
 
3489
            return self._real_branch.get_physical_lock_status()
 
3490
        if response[0] not in ('yes', 'no'):
 
3491
            raise errors.UnexpectedSmartServerResponse(response)
 
3492
        return (response[0] == 'yes')
2214
3493
 
2215
3494
    def get_stacked_on_url(self):
2216
3495
        """Get the URL this branch is stacked against.
2239
3518
 
2240
3519
    def set_stacked_on_url(self, url):
2241
3520
        branch.Branch.set_stacked_on_url(self, url)
 
3521
        # We need the stacked_on_url to be visible both locally (to not query
 
3522
        # it repeatedly) and remotely (so smart verbs can get it server side)
 
3523
        # Without the following line,
 
3524
        # bzrlib.tests.per_branch.test_create_clone.TestCreateClone
 
3525
        # .test_create_clone_on_transport_stacked_hooks_get_stacked_branch
 
3526
        # fails for remote branches -- vila 2012-01-04
 
3527
        self.conf_store.save_changes()
2242
3528
        if not url:
2243
3529
            self._is_stacked = False
2244
3530
        else:
2245
3531
            self._is_stacked = True
2246
 
        
 
3532
 
2247
3533
    def _vfs_get_tags_bytes(self):
2248
3534
        self._ensure_real()
2249
3535
        return self._real_branch._get_tags_bytes()
2250
3536
 
 
3537
    @needs_read_lock
2251
3538
    def _get_tags_bytes(self):
 
3539
        if self._tags_bytes is None:
 
3540
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
3541
        return self._tags_bytes
 
3542
 
 
3543
    def _get_tags_bytes_via_hpss(self):
2252
3544
        medium = self._client._medium
2253
3545
        if medium._is_remote_before((1, 13)):
2254
3546
            return self._vfs_get_tags_bytes()
2264
3556
        return self._real_branch._set_tags_bytes(bytes)
2265
3557
 
2266
3558
    def _set_tags_bytes(self, bytes):
 
3559
        if self.is_locked():
 
3560
            self._tags_bytes = bytes
2267
3561
        medium = self._client._medium
2268
3562
        if medium._is_remote_before((1, 18)):
2269
3563
            self._vfs_set_tags_bytes(bytes)
 
3564
            return
2270
3565
        try:
2271
3566
            args = (
2272
3567
                self._remote_path(), self._lock_token, self._repo_lock_token)
2277
3572
            self._vfs_set_tags_bytes(bytes)
2278
3573
 
2279
3574
    def lock_read(self):
 
3575
        """Lock the branch for read operations.
 
3576
 
 
3577
        :return: A bzrlib.lock.LogicalLockResult.
 
3578
        """
2280
3579
        self.repository.lock_read()
2281
3580
        if not self._lock_mode:
 
3581
            self._note_lock('r')
2282
3582
            self._lock_mode = 'r'
2283
3583
            self._lock_count = 1
2284
3584
            if self._real_branch is not None:
2285
3585
                self._real_branch.lock_read()
2286
3586
        else:
2287
3587
            self._lock_count += 1
 
3588
        return lock.LogicalLockResult(self.unlock)
2288
3589
 
2289
3590
    def _remote_lock_write(self, token):
2290
3591
        if token is None:
2291
3592
            branch_token = repo_token = ''
2292
3593
        else:
2293
3594
            branch_token = token
2294
 
            repo_token = self.repository.lock_write()
 
3595
            repo_token = self.repository.lock_write().repository_token
2295
3596
            self.repository.unlock()
2296
3597
        err_context = {'token': token}
2297
 
        response = self._call(
2298
 
            'Branch.lock_write', self._remote_path(), branch_token,
2299
 
            repo_token or '', **err_context)
 
3598
        try:
 
3599
            response = self._call(
 
3600
                'Branch.lock_write', self._remote_path(), branch_token,
 
3601
                repo_token or '', **err_context)
 
3602
        except errors.LockContention, e:
 
3603
            # The LockContention from the server doesn't have any
 
3604
            # information about the lock_url. We re-raise LockContention
 
3605
            # with valid lock_url.
 
3606
            raise errors.LockContention('(remote lock)',
 
3607
                self.repository.base.split('.bzr/')[0])
2300
3608
        if response[0] != 'ok':
2301
3609
            raise errors.UnexpectedSmartServerResponse(response)
2302
3610
        ok, branch_token, repo_token = response
2304
3612
 
2305
3613
    def lock_write(self, token=None):
2306
3614
        if not self._lock_mode:
 
3615
            self._note_lock('w')
2307
3616
            # Lock the branch and repo in one remote call.
2308
3617
            remote_tokens = self._remote_lock_write(token)
2309
3618
            self._lock_token, self._repo_lock_token = remote_tokens
2322
3631
            self._lock_mode = 'w'
2323
3632
            self._lock_count = 1
2324
3633
        elif self._lock_mode == 'r':
2325
 
            raise errors.ReadOnlyTransaction
 
3634
            raise errors.ReadOnlyError(self)
2326
3635
        else:
2327
3636
            if token is not None:
2328
3637
                # A token was given to lock_write, and we're relocking, so
2333
3642
            self._lock_count += 1
2334
3643
            # Re-lock the repository too.
2335
3644
            self.repository.lock_write(self._repo_lock_token)
2336
 
        return self._lock_token or None
 
3645
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
2337
3646
 
2338
3647
    def _unlock(self, branch_token, repo_token):
2339
3648
        err_context = {'token': str((branch_token, repo_token))}
2344
3653
            return
2345
3654
        raise errors.UnexpectedSmartServerResponse(response)
2346
3655
 
 
3656
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2347
3657
    def unlock(self):
2348
3658
        try:
2349
3659
            self._lock_count -= 1
2350
3660
            if not self._lock_count:
 
3661
                if self.conf_store is not None:
 
3662
                    self.conf_store.save_changes()
2351
3663
                self._clear_cached_state()
2352
3664
                mode = self._lock_mode
2353
3665
                self._lock_mode = None
2376
3688
            self.repository.unlock()
2377
3689
 
2378
3690
    def break_lock(self):
2379
 
        self._ensure_real()
2380
 
        return self._real_branch.break_lock()
 
3691
        try:
 
3692
            response = self._call(
 
3693
                'Branch.break_lock', self._remote_path())
 
3694
        except errors.UnknownSmartMethod:
 
3695
            self._ensure_real()
 
3696
            return self._real_branch.break_lock()
 
3697
        if response != ('ok',):
 
3698
            raise errors.UnexpectedSmartServerResponse(response)
2381
3699
 
2382
3700
    def leave_lock_in_place(self):
2383
3701
        if not self._lock_token:
2389
3707
            raise NotImplementedError(self.dont_leave_lock_in_place)
2390
3708
        self._leave_lock = False
2391
3709
 
 
3710
    @needs_read_lock
2392
3711
    def get_rev_id(self, revno, history=None):
2393
3712
        if revno == 0:
2394
3713
            return _mod_revision.NULL_REVISION
2406
3725
            missing_parent = parent_map[missing_parent]
2407
3726
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2408
3727
 
2409
 
    def _last_revision_info(self):
 
3728
    def _read_last_revision_info(self):
2410
3729
        response = self._call('Branch.last_revision_info', self._remote_path())
2411
3730
        if response[0] != 'ok':
2412
3731
            raise SmartProtocolError('unexpected response code %s' % (response,))
2475
3794
            raise errors.UnexpectedSmartServerResponse(response)
2476
3795
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2477
3796
 
2478
 
    @needs_write_lock
2479
 
    def set_revision_history(self, rev_history):
2480
 
        # Send just the tip revision of the history; the server will generate
2481
 
        # the full history from that.  If the revision doesn't exist in this
2482
 
        # branch, NoSuchRevision will be raised.
2483
 
        if rev_history == []:
2484
 
            rev_id = 'null:'
2485
 
        else:
2486
 
            rev_id = rev_history[-1]
2487
 
        self._set_last_revision(rev_id)
2488
 
        for hook in branch.Branch.hooks['set_rh']:
2489
 
            hook(self, rev_history)
2490
 
        self._cache_revision_history(rev_history)
2491
 
 
2492
3797
    def _get_parent_location(self):
2493
3798
        medium = self._client._medium
2494
3799
        if medium._is_remote_before((1, 13)):
2540
3845
            _override_hook_target=self, **kwargs)
2541
3846
 
2542
3847
    @needs_read_lock
2543
 
    def push(self, target, overwrite=False, stop_revision=None):
 
3848
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2544
3849
        self._ensure_real()
2545
3850
        return self._real_branch.push(
2546
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
3851
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2547
3852
            _override_hook_source_branch=self)
2548
3853
 
 
3854
    def peek_lock_mode(self):
 
3855
        return self._lock_mode
 
3856
 
2549
3857
    def is_locked(self):
2550
3858
        return self._lock_count >= 1
2551
3859
 
2552
3860
    @needs_read_lock
 
3861
    def revision_id_to_dotted_revno(self, revision_id):
 
3862
        """Given a revision id, return its dotted revno.
 
3863
 
 
3864
        :return: a tuple like (1,) or (400,1,3).
 
3865
        """
 
3866
        try:
 
3867
            response = self._call('Branch.revision_id_to_revno',
 
3868
                self._remote_path(), revision_id)
 
3869
        except errors.UnknownSmartMethod:
 
3870
            self._ensure_real()
 
3871
            return self._real_branch.revision_id_to_dotted_revno(revision_id)
 
3872
        if response[0] == 'ok':
 
3873
            return tuple([int(x) for x in response[1:]])
 
3874
        else:
 
3875
            raise errors.UnexpectedSmartServerResponse(response)
 
3876
 
 
3877
    @needs_read_lock
2553
3878
    def revision_id_to_revno(self, revision_id):
2554
 
        self._ensure_real()
2555
 
        return self._real_branch.revision_id_to_revno(revision_id)
 
3879
        """Given a revision id on the branch mainline, return its revno.
 
3880
 
 
3881
        :return: an integer
 
3882
        """
 
3883
        try:
 
3884
            response = self._call('Branch.revision_id_to_revno',
 
3885
                self._remote_path(), revision_id)
 
3886
        except errors.UnknownSmartMethod:
 
3887
            self._ensure_real()
 
3888
            return self._real_branch.revision_id_to_revno(revision_id)
 
3889
        if response[0] == 'ok':
 
3890
            if len(response) == 2:
 
3891
                return int(response[1])
 
3892
            raise NoSuchRevision(self, revision_id)
 
3893
        else:
 
3894
            raise errors.UnexpectedSmartServerResponse(response)
2556
3895
 
2557
3896
    @needs_write_lock
2558
3897
    def set_last_revision_info(self, revno, revision_id):
2559
3898
        # XXX: These should be returned by the set_last_revision_info verb
2560
3899
        old_revno, old_revid = self.last_revision_info()
2561
3900
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2562
 
        revision_id = ensure_null(revision_id)
 
3901
        if not revision_id or not isinstance(revision_id, basestring):
 
3902
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2563
3903
        try:
2564
3904
            response = self._call('Branch.set_last_revision_info',
2565
3905
                self._remote_path(), self._lock_token, self._repo_lock_token,
2594
3934
            except errors.UnknownSmartMethod:
2595
3935
                medium._remember_remote_is_before((1, 6))
2596
3936
        self._clear_cached_state_of_remote_branch_only()
2597
 
        self.set_revision_history(self._lefthand_history(revision_id,
2598
 
            last_rev=last_rev,other_branch=other_branch))
 
3937
        graph = self.repository.get_graph()
 
3938
        (last_revno, last_revid) = self.last_revision_info()
 
3939
        known_revision_ids = [
 
3940
            (last_revid, last_revno),
 
3941
            (_mod_revision.NULL_REVISION, 0),
 
3942
            ]
 
3943
        if last_rev is not None:
 
3944
            if not graph.is_ancestor(last_rev, revision_id):
 
3945
                # our previous tip is not merged into stop_revision
 
3946
                raise errors.DivergedBranches(self, other_branch)
 
3947
        revno = graph.find_distance_to_null(revision_id, known_revision_ids)
 
3948
        self.set_last_revision_info(revno, revision_id)
2599
3949
 
2600
3950
    def set_push_location(self, location):
 
3951
        self._set_config_location('push_location', location)
 
3952
 
 
3953
    def heads_to_fetch(self):
 
3954
        if self._format._use_default_local_heads_to_fetch():
 
3955
            # We recognise this format, and its heads-to-fetch implementation
 
3956
            # is the default one (tip + tags).  In this case it's cheaper to
 
3957
            # just use the default implementation rather than a special RPC as
 
3958
            # the tip and tags data is cached.
 
3959
            return branch.Branch.heads_to_fetch(self)
 
3960
        medium = self._client._medium
 
3961
        if medium._is_remote_before((2, 4)):
 
3962
            return self._vfs_heads_to_fetch()
 
3963
        try:
 
3964
            return self._rpc_heads_to_fetch()
 
3965
        except errors.UnknownSmartMethod:
 
3966
            medium._remember_remote_is_before((2, 4))
 
3967
            return self._vfs_heads_to_fetch()
 
3968
 
 
3969
    def _rpc_heads_to_fetch(self):
 
3970
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3971
        if len(response) != 2:
 
3972
            raise errors.UnexpectedSmartServerResponse(response)
 
3973
        must_fetch, if_present_fetch = response
 
3974
        return set(must_fetch), set(if_present_fetch)
 
3975
 
 
3976
    def _vfs_heads_to_fetch(self):
2601
3977
        self._ensure_real()
2602
 
        return self._real_branch.set_push_location(location)
 
3978
        return self._real_branch.heads_to_fetch()
2603
3979
 
2604
3980
 
2605
3981
class RemoteConfig(object):
2620
3996
        """
2621
3997
        try:
2622
3998
            configobj = self._get_configobj()
 
3999
            section_obj = None
2623
4000
            if section is None:
2624
4001
                section_obj = configobj
2625
4002
            else:
2626
4003
                try:
2627
4004
                    section_obj = configobj[section]
2628
4005
                except KeyError:
2629
 
                    return default
2630
 
            return section_obj.get(name, default)
 
4006
                    pass
 
4007
            if section_obj is None:
 
4008
                value = default
 
4009
            else:
 
4010
                value = section_obj.get(name, default)
2631
4011
        except errors.UnknownSmartMethod:
2632
 
            return self._vfs_get_option(name, section, default)
 
4012
            value = self._vfs_get_option(name, section, default)
 
4013
        for hook in _mod_config.OldConfigHooks['get']:
 
4014
            hook(self, name, value)
 
4015
        return value
2633
4016
 
2634
4017
    def _response_to_configobj(self, response):
2635
4018
        if len(response[0]) and response[0][0] != 'ok':
2636
4019
            raise errors.UnexpectedSmartServerResponse(response)
2637
4020
        lines = response[1].read_body_bytes().splitlines()
2638
 
        return config.ConfigObj(lines, encoding='utf-8')
 
4021
        conf = _mod_config.ConfigObj(lines, encoding='utf-8')
 
4022
        for hook in _mod_config.OldConfigHooks['load']:
 
4023
            hook(self)
 
4024
        return conf
2639
4025
 
2640
4026
 
2641
4027
class RemoteBranchConfig(RemoteConfig):
2660
4046
        medium = self._branch._client._medium
2661
4047
        if medium._is_remote_before((1, 14)):
2662
4048
            return self._vfs_set_option(value, name, section)
 
4049
        if isinstance(value, dict):
 
4050
            if medium._is_remote_before((2, 2)):
 
4051
                return self._vfs_set_option(value, name, section)
 
4052
            return self._set_config_option_dict(value, name, section)
 
4053
        else:
 
4054
            return self._set_config_option(value, name, section)
 
4055
 
 
4056
    def _set_config_option(self, value, name, section):
2663
4057
        try:
2664
4058
            path = self._branch._remote_path()
2665
4059
            response = self._branch._client.call('Branch.set_config_option',
2666
4060
                path, self._branch._lock_token, self._branch._repo_lock_token,
2667
4061
                value.encode('utf8'), name, section or '')
2668
4062
        except errors.UnknownSmartMethod:
 
4063
            medium = self._branch._client._medium
2669
4064
            medium._remember_remote_is_before((1, 14))
2670
4065
            return self._vfs_set_option(value, name, section)
2671
4066
        if response != ():
2672
4067
            raise errors.UnexpectedSmartServerResponse(response)
2673
4068
 
 
4069
    def _serialize_option_dict(self, option_dict):
 
4070
        utf8_dict = {}
 
4071
        for key, value in option_dict.items():
 
4072
            if isinstance(key, unicode):
 
4073
                key = key.encode('utf8')
 
4074
            if isinstance(value, unicode):
 
4075
                value = value.encode('utf8')
 
4076
            utf8_dict[key] = value
 
4077
        return bencode.bencode(utf8_dict)
 
4078
 
 
4079
    def _set_config_option_dict(self, value, name, section):
 
4080
        try:
 
4081
            path = self._branch._remote_path()
 
4082
            serialised_dict = self._serialize_option_dict(value)
 
4083
            response = self._branch._client.call(
 
4084
                'Branch.set_config_option_dict',
 
4085
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
4086
                serialised_dict, name, section or '')
 
4087
        except errors.UnknownSmartMethod:
 
4088
            medium = self._branch._client._medium
 
4089
            medium._remember_remote_is_before((2, 2))
 
4090
            return self._vfs_set_option(value, name, section)
 
4091
        if response != ():
 
4092
            raise errors.UnexpectedSmartServerResponse(response)
 
4093
 
2674
4094
    def _real_object(self):
2675
4095
        self._branch._ensure_real()
2676
4096
        return self._branch._real_branch
2715
4135
        return self._bzrdir._real_bzrdir
2716
4136
 
2717
4137
 
2718
 
 
2719
4138
def _extract_tar(tar, to_dir):
2720
4139
    """Extract all the contents of a tarfile object.
2721
4140
 
2725
4144
        tar.extract(tarinfo, to_dir)
2726
4145
 
2727
4146
 
 
4147
error_translators = registry.Registry()
 
4148
no_context_error_translators = registry.Registry()
 
4149
 
 
4150
 
2728
4151
def _translate_error(err, **context):
2729
4152
    """Translate an ErrorFromSmartServer into a more useful error.
2730
4153
 
2759
4182
                    'Missing key %r in context %r', key_err.args[0], context)
2760
4183
                raise err
2761
4184
 
2762
 
    if err.error_verb == 'NoSuchRevision':
2763
 
        raise NoSuchRevision(find('branch'), err.error_args[0])
2764
 
    elif err.error_verb == 'nosuchrevision':
2765
 
        raise NoSuchRevision(find('repository'), err.error_args[0])
2766
 
    elif err.error_tuple == ('nobranch',):
2767
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
2768
 
    elif err.error_verb == 'norepository':
2769
 
        raise errors.NoRepositoryPresent(find('bzrdir'))
2770
 
    elif err.error_verb == 'LockContention':
2771
 
        raise errors.LockContention('(remote lock)')
2772
 
    elif err.error_verb == 'UnlockableTransport':
2773
 
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
2774
 
    elif err.error_verb == 'LockFailed':
2775
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
2776
 
    elif err.error_verb == 'TokenMismatch':
2777
 
        raise errors.TokenMismatch(find('token'), '(remote token)')
2778
 
    elif err.error_verb == 'Diverged':
2779
 
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
2780
 
    elif err.error_verb == 'TipChangeRejected':
2781
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2782
 
    elif err.error_verb == 'UnstackableBranchFormat':
2783
 
        raise errors.UnstackableBranchFormat(*err.error_args)
2784
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
2785
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2786
 
    elif err.error_verb == 'NotStacked':
2787
 
        raise errors.NotStacked(branch=find('branch'))
2788
 
    elif err.error_verb == 'PermissionDenied':
2789
 
        path = get_path()
2790
 
        if len(err.error_args) >= 2:
2791
 
            extra = err.error_args[1]
2792
 
        else:
2793
 
            extra = None
2794
 
        raise errors.PermissionDenied(path, extra=extra)
2795
 
    elif err.error_verb == 'ReadError':
2796
 
        path = get_path()
2797
 
        raise errors.ReadError(path)
2798
 
    elif err.error_verb == 'NoSuchFile':
2799
 
        path = get_path()
2800
 
        raise errors.NoSuchFile(path)
2801
 
    elif err.error_verb == 'FileExists':
2802
 
        raise errors.FileExists(err.error_args[0])
2803
 
    elif err.error_verb == 'DirectoryNotEmpty':
2804
 
        raise errors.DirectoryNotEmpty(err.error_args[0])
2805
 
    elif err.error_verb == 'ShortReadvError':
2806
 
        args = err.error_args
2807
 
        raise errors.ShortReadvError(
2808
 
            args[0], int(args[1]), int(args[2]), int(args[3]))
2809
 
    elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
 
4185
    try:
 
4186
        translator = error_translators.get(err.error_verb)
 
4187
    except KeyError:
 
4188
        pass
 
4189
    else:
 
4190
        raise translator(err, find, get_path)
 
4191
    try:
 
4192
        translator = no_context_error_translators.get(err.error_verb)
 
4193
    except KeyError:
 
4194
        raise errors.UnknownErrorFromSmartServer(err)
 
4195
    else:
 
4196
        raise translator(err)
 
4197
 
 
4198
 
 
4199
error_translators.register('NoSuchRevision',
 
4200
    lambda err, find, get_path: NoSuchRevision(
 
4201
        find('branch'), err.error_args[0]))
 
4202
error_translators.register('nosuchrevision',
 
4203
    lambda err, find, get_path: NoSuchRevision(
 
4204
        find('repository'), err.error_args[0]))
 
4205
 
 
4206
def _translate_nobranch_error(err, find, get_path):
 
4207
    if len(err.error_args) >= 1:
 
4208
        extra = err.error_args[0]
 
4209
    else:
 
4210
        extra = None
 
4211
    return errors.NotBranchError(path=find('bzrdir').root_transport.base,
 
4212
        detail=extra)
 
4213
 
 
4214
error_translators.register('nobranch', _translate_nobranch_error)
 
4215
error_translators.register('norepository',
 
4216
    lambda err, find, get_path: errors.NoRepositoryPresent(
 
4217
        find('bzrdir')))
 
4218
error_translators.register('UnlockableTransport',
 
4219
    lambda err, find, get_path: errors.UnlockableTransport(
 
4220
        find('bzrdir').root_transport))
 
4221
error_translators.register('TokenMismatch',
 
4222
    lambda err, find, get_path: errors.TokenMismatch(
 
4223
        find('token'), '(remote token)'))
 
4224
error_translators.register('Diverged',
 
4225
    lambda err, find, get_path: errors.DivergedBranches(
 
4226
        find('branch'), find('other_branch')))
 
4227
error_translators.register('NotStacked',
 
4228
    lambda err, find, get_path: errors.NotStacked(branch=find('branch')))
 
4229
 
 
4230
def _translate_PermissionDenied(err, find, get_path):
 
4231
    path = get_path()
 
4232
    if len(err.error_args) >= 2:
 
4233
        extra = err.error_args[1]
 
4234
    else:
 
4235
        extra = None
 
4236
    return errors.PermissionDenied(path, extra=extra)
 
4237
 
 
4238
error_translators.register('PermissionDenied', _translate_PermissionDenied)
 
4239
error_translators.register('ReadError',
 
4240
    lambda err, find, get_path: errors.ReadError(get_path()))
 
4241
error_translators.register('NoSuchFile',
 
4242
    lambda err, find, get_path: errors.NoSuchFile(get_path()))
 
4243
error_translators.register('TokenLockingNotSupported',
 
4244
    lambda err, find, get_path: errors.TokenLockingNotSupported(
 
4245
        find('repository')))
 
4246
error_translators.register('UnsuspendableWriteGroup',
 
4247
    lambda err, find, get_path: errors.UnsuspendableWriteGroup(
 
4248
        repository=find('repository')))
 
4249
error_translators.register('UnresumableWriteGroup',
 
4250
    lambda err, find, get_path: errors.UnresumableWriteGroup(
 
4251
        repository=find('repository'), write_groups=err.error_args[0],
 
4252
        reason=err.error_args[1]))
 
4253
no_context_error_translators.register('IncompatibleRepositories',
 
4254
    lambda err: errors.IncompatibleRepositories(
 
4255
        err.error_args[0], err.error_args[1], err.error_args[2]))
 
4256
no_context_error_translators.register('LockContention',
 
4257
    lambda err: errors.LockContention('(remote lock)'))
 
4258
no_context_error_translators.register('LockFailed',
 
4259
    lambda err: errors.LockFailed(err.error_args[0], err.error_args[1]))
 
4260
no_context_error_translators.register('TipChangeRejected',
 
4261
    lambda err: errors.TipChangeRejected(err.error_args[0].decode('utf8')))
 
4262
no_context_error_translators.register('UnstackableBranchFormat',
 
4263
    lambda err: errors.UnstackableBranchFormat(*err.error_args))
 
4264
no_context_error_translators.register('UnstackableRepositoryFormat',
 
4265
    lambda err: errors.UnstackableRepositoryFormat(*err.error_args))
 
4266
no_context_error_translators.register('FileExists',
 
4267
    lambda err: errors.FileExists(err.error_args[0]))
 
4268
no_context_error_translators.register('DirectoryNotEmpty',
 
4269
    lambda err: errors.DirectoryNotEmpty(err.error_args[0]))
 
4270
 
 
4271
def _translate_short_readv_error(err):
 
4272
    args = err.error_args
 
4273
    return errors.ShortReadvError(args[0], int(args[1]), int(args[2]),
 
4274
        int(args[3]))
 
4275
 
 
4276
no_context_error_translators.register('ShortReadvError',
 
4277
    _translate_short_readv_error)
 
4278
 
 
4279
def _translate_unicode_error(err):
2810
4280
        encoding = str(err.error_args[0]) # encoding must always be a string
2811
4281
        val = err.error_args[1]
2812
4282
        start = int(err.error_args[2])
2820
4290
            raise UnicodeDecodeError(encoding, val, start, end, reason)
2821
4291
        elif err.error_verb == 'UnicodeEncodeError':
2822
4292
            raise UnicodeEncodeError(encoding, val, start, end, reason)
2823
 
    elif err.error_verb == 'ReadOnlyError':
2824
 
        raise errors.TransportNotPossible('readonly transport')
2825
 
    raise errors.UnknownErrorFromSmartServer(err)
 
4293
 
 
4294
no_context_error_translators.register('UnicodeEncodeError',
 
4295
    _translate_unicode_error)
 
4296
no_context_error_translators.register('UnicodeDecodeError',
 
4297
    _translate_unicode_error)
 
4298
no_context_error_translators.register('ReadOnlyError',
 
4299
    lambda err: errors.TransportNotPossible('readonly transport'))
 
4300
no_context_error_translators.register('MemoryError',
 
4301
    lambda err: errors.BzrError("remote server out of memory\n"
 
4302
        "Retry non-remotely, or contact the server admin for details."))
 
4303
no_context_error_translators.register('RevisionNotPresent',
 
4304
    lambda err: errors.RevisionNotPresent(err.error_args[0], err.error_args[1]))
 
4305
 
 
4306
no_context_error_translators.register('BzrCheckError',
 
4307
    lambda err: errors.BzrCheckError(msg=err.error_args[0]))
 
4308