← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Jelmer Vernooij
  • Date: 2011-12-05 14:12:23 UTC
  • mto: This revision was merged to the branch mainline in revision 6348.
  • Revision ID: jelmer@samba.org-20111205141223-8qxae4h37satlzgq
Move more functionality to vf_search.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
import bz2
 
18
import zlib
18
19
 
19
20
from bzrlib import (
20
21
    bencode,
21
22
    branch,
22
 
    bzrdir,
 
23
    bzrdir as _mod_bzrdir,
23
24
    config,
 
25
    controldir,
24
26
    debug,
25
27
    errors,
 
28
    gpg,
26
29
    graph,
27
30
    lock,
28
31
    lockdir,
29
 
    repository,
30
 
    revision,
 
32
    osutils,
 
33
    registry,
 
34
    repository as _mod_repository,
31
35
    revision as _mod_revision,
 
36
    static_tuple,
32
37
    symbol_versioning,
33
 
)
34
 
from bzrlib.branch import BranchReferenceFormat
35
 
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
 
38
    testament as _mod_testament,
 
39
    urlutils,
 
40
    vf_repository,
 
41
    vf_search,
 
42
    )
 
43
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
36
44
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
37
45
from bzrlib.errors import (
38
46
    NoSuchRevision,
39
47
    SmartProtocolError,
40
48
    )
 
49
from bzrlib.i18n import gettext
 
50
from bzrlib.inventory import Inventory
41
51
from bzrlib.lockable_files import LockableFiles
42
52
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
 
53
from bzrlib.smart.client import _SmartClient
 
54
from bzrlib.revision import NULL_REVISION
 
55
from bzrlib.revisiontree import InventoryRevisionTree
 
56
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
 
57
from bzrlib.serializer import format_registry as serializer_format_registry
 
58
from bzrlib.trace import mutter, note, warning, log_exception_quietly
 
59
 
 
60
 
 
61
_DEFAULT_SEARCH_DEPTH = 100
45
62
 
46
63
 
47
64
class _RpcHelper(object):
84
101
    return format
85
102
 
86
103
 
87
 
# Note: RemoteBzrDirFormat is in bzrdir.py
88
 
 
89
 
class RemoteBzrDir(BzrDir, _RpcHelper):
 
104
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
 
105
# does not have to be imported unless a remote format is involved.
 
106
 
 
107
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
 
108
    """Format representing bzrdirs accessed via a smart server"""
 
109
 
 
110
    supports_workingtrees = False
 
111
 
 
112
    def __init__(self):
 
113
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
 
114
        # XXX: It's a bit ugly that the network name is here, because we'd
 
115
        # like to believe that format objects are stateless or at least
 
116
        # immutable,  However, we do at least avoid mutating the name after
 
117
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
 
118
        self._network_name = None
 
119
 
 
120
    def __repr__(self):
 
121
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
122
            self._network_name)
 
123
 
 
124
    def get_format_description(self):
 
125
        if self._network_name:
 
126
            try:
 
127
                real_format = controldir.network_format_registry.get(
 
128
                        self._network_name)
 
129
            except KeyError:
 
130
                pass
 
131
            else:
 
132
                return 'Remote: ' + real_format.get_format_description()
 
133
        return 'bzr remote bzrdir'
 
134
 
 
135
    def get_format_string(self):
 
136
        raise NotImplementedError(self.get_format_string)
 
137
 
 
138
    def network_name(self):
 
139
        if self._network_name:
 
140
            return self._network_name
 
141
        else:
 
142
            raise AssertionError("No network name set.")
 
143
 
 
144
    def initialize_on_transport(self, transport):
 
145
        try:
 
146
            # hand off the request to the smart server
 
147
            client_medium = transport.get_smart_medium()
 
148
        except errors.NoSmartMedium:
 
149
            # TODO: lookup the local format from a server hint.
 
150
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
151
            return local_dir_format.initialize_on_transport(transport)
 
152
        client = _SmartClient(client_medium)
 
153
        path = client.remote_path_from_transport(transport)
 
154
        try:
 
155
            response = client.call('BzrDirFormat.initialize', path)
 
156
        except errors.ErrorFromSmartServer, err:
 
157
            _translate_error(err, path=path)
 
158
        if response[0] != 'ok':
 
159
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
 
160
        format = RemoteBzrDirFormat()
 
161
        self._supply_sub_formats_to(format)
 
162
        return RemoteBzrDir(transport, format)
 
163
 
 
164
    def parse_NoneTrueFalse(self, arg):
 
165
        if not arg:
 
166
            return None
 
167
        if arg == 'False':
 
168
            return False
 
169
        if arg == 'True':
 
170
            return True
 
171
        raise AssertionError("invalid arg %r" % arg)
 
172
 
 
173
    def _serialize_NoneTrueFalse(self, arg):
 
174
        if arg is False:
 
175
            return 'False'
 
176
        if arg:
 
177
            return 'True'
 
178
        return ''
 
179
 
 
180
    def _serialize_NoneString(self, arg):
 
181
        return arg or ''
 
182
 
 
183
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
184
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
185
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
186
        shared_repo=False):
 
187
        try:
 
188
            # hand off the request to the smart server
 
189
            client_medium = transport.get_smart_medium()
 
190
        except errors.NoSmartMedium:
 
191
            do_vfs = True
 
192
        else:
 
193
            # Decline to open it if the server doesn't support our required
 
194
            # version (3) so that the VFS-based transport will do it.
 
195
            if client_medium.should_probe():
 
196
                try:
 
197
                    server_version = client_medium.protocol_version()
 
198
                    if server_version != '2':
 
199
                        do_vfs = True
 
200
                    else:
 
201
                        do_vfs = False
 
202
                except errors.SmartProtocolError:
 
203
                    # Apparently there's no usable smart server there, even though
 
204
                    # the medium supports the smart protocol.
 
205
                    do_vfs = True
 
206
            else:
 
207
                do_vfs = False
 
208
        if not do_vfs:
 
209
            client = _SmartClient(client_medium)
 
210
            path = client.remote_path_from_transport(transport)
 
211
            if client_medium._is_remote_before((1, 16)):
 
212
                do_vfs = True
 
213
        if do_vfs:
 
214
            # TODO: lookup the local format from a server hint.
 
215
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
216
            self._supply_sub_formats_to(local_dir_format)
 
217
            return local_dir_format.initialize_on_transport_ex(transport,
 
218
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
219
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
220
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
221
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
222
                vfs_only=True)
 
223
        return self._initialize_on_transport_ex_rpc(client, path, transport,
 
224
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
225
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
 
226
 
 
227
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
 
228
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
229
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
 
230
        args = []
 
231
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
 
232
        args.append(self._serialize_NoneTrueFalse(create_prefix))
 
233
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
 
234
        args.append(self._serialize_NoneString(stacked_on))
 
235
        # stack_on_pwd is often/usually our transport
 
236
        if stack_on_pwd:
 
237
            try:
 
238
                stack_on_pwd = transport.relpath(stack_on_pwd)
 
239
                if not stack_on_pwd:
 
240
                    stack_on_pwd = '.'
 
241
            except errors.PathNotChild:
 
242
                pass
 
243
        args.append(self._serialize_NoneString(stack_on_pwd))
 
244
        args.append(self._serialize_NoneString(repo_format_name))
 
245
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
 
246
        args.append(self._serialize_NoneTrueFalse(shared_repo))
 
247
        request_network_name = self._network_name or \
 
248
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
 
249
        try:
 
250
            response = client.call('BzrDirFormat.initialize_ex_1.16',
 
251
                request_network_name, path, *args)
 
252
        except errors.UnknownSmartMethod:
 
253
            client._medium._remember_remote_is_before((1,16))
 
254
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
255
            self._supply_sub_formats_to(local_dir_format)
 
256
            return local_dir_format.initialize_on_transport_ex(transport,
 
257
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
258
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
259
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
260
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
261
                vfs_only=True)
 
262
        except errors.ErrorFromSmartServer, err:
 
263
            _translate_error(err, path=path)
 
264
        repo_path = response[0]
 
265
        bzrdir_name = response[6]
 
266
        require_stacking = response[7]
 
267
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
 
268
        format = RemoteBzrDirFormat()
 
269
        format._network_name = bzrdir_name
 
270
        self._supply_sub_formats_to(format)
 
271
        bzrdir = RemoteBzrDir(transport, format, _client=client)
 
272
        if repo_path:
 
273
            repo_format = response_tuple_to_repo_format(response[1:])
 
274
            if repo_path == '.':
 
275
                repo_path = ''
 
276
            if repo_path:
 
277
                repo_bzrdir_format = RemoteBzrDirFormat()
 
278
                repo_bzrdir_format._network_name = response[5]
 
279
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
 
280
                    repo_bzrdir_format)
 
281
            else:
 
282
                repo_bzr = bzrdir
 
283
            final_stack = response[8] or None
 
284
            final_stack_pwd = response[9] or None
 
285
            if final_stack_pwd:
 
286
                final_stack_pwd = urlutils.join(
 
287
                    transport.base, final_stack_pwd)
 
288
            remote_repo = RemoteRepository(repo_bzr, repo_format)
 
289
            if len(response) > 10:
 
290
                # Updated server verb that locks remotely.
 
291
                repo_lock_token = response[10] or None
 
292
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
 
293
                if repo_lock_token:
 
294
                    remote_repo.dont_leave_lock_in_place()
 
295
            else:
 
296
                remote_repo.lock_write()
 
297
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
 
298
                final_stack_pwd, require_stacking)
 
299
            policy.acquire_repository()
 
300
        else:
 
301
            remote_repo = None
 
302
            policy = None
 
303
        bzrdir._format.set_branch_format(self.get_branch_format())
 
304
        if require_stacking:
 
305
            # The repo has already been created, but we need to make sure that
 
306
            # we'll make a stackable branch.
 
307
            bzrdir._format.require_stacking(_skip_repo=True)
 
308
        return remote_repo, bzrdir, require_stacking, policy
 
309
 
 
310
    def _open(self, transport):
 
311
        return RemoteBzrDir(transport, self)
 
312
 
 
313
    def __eq__(self, other):
 
314
        if not isinstance(other, RemoteBzrDirFormat):
 
315
            return False
 
316
        return self.get_format_description() == other.get_format_description()
 
317
 
 
318
    def __return_repository_format(self):
 
319
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
 
320
        # repository format has been asked for, tell the RemoteRepositoryFormat
 
321
        # that it should use that for init() etc.
 
322
        result = RemoteRepositoryFormat()
 
323
        custom_format = getattr(self, '_repository_format', None)
 
324
        if custom_format:
 
325
            if isinstance(custom_format, RemoteRepositoryFormat):
 
326
                return custom_format
 
327
            else:
 
328
                # We will use the custom format to create repositories over the
 
329
                # wire; expose its details like rich_root_data for code to
 
330
                # query
 
331
                result._custom_format = custom_format
 
332
        return result
 
333
 
 
334
    def get_branch_format(self):
 
335
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
 
336
        if not isinstance(result, RemoteBranchFormat):
 
337
            new_result = RemoteBranchFormat()
 
338
            new_result._custom_format = result
 
339
            # cache the result
 
340
            self.set_branch_format(new_result)
 
341
            result = new_result
 
342
        return result
 
343
 
 
344
    repository_format = property(__return_repository_format,
 
345
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
 
346
 
 
347
 
 
348
class RemoteControlStore(config.IniFileStore):
 
349
    """Control store which attempts to use HPSS calls to retrieve control store.
 
350
 
 
351
    Note that this is specific to bzr-based formats.
 
352
    """
 
353
 
 
354
    def __init__(self, bzrdir):
 
355
        super(RemoteControlStore, self).__init__()
 
356
        self.bzrdir = bzrdir
 
357
        self._real_store = None
 
358
 
 
359
    def lock_write(self, token=None):
 
360
        self._ensure_real()
 
361
        return self._real_store.lock_write(token)
 
362
 
 
363
    def unlock(self):
 
364
        self._ensure_real()
 
365
        return self._real_store.unlock()
 
366
 
 
367
    @needs_write_lock
 
368
    def save(self):
 
369
        # We need to be able to override the undecorated implementation
 
370
        self.save_without_locking()
 
371
 
 
372
    def save_without_locking(self):
 
373
        super(RemoteControlStore, self).save()
 
374
 
 
375
    def _ensure_real(self):
 
376
        self.bzrdir._ensure_real()
 
377
        if self._real_store is None:
 
378
            self._real_store = config.ControlStore(self.bzrdir)
 
379
 
 
380
    def external_url(self):
 
381
        return self.bzrdir.user_url
 
382
 
 
383
    def _load_content(self):
 
384
        medium = self.bzrdir._client._medium
 
385
        path = self.bzrdir._path_for_remote_call(self.bzrdir._client)
 
386
        try:
 
387
            response, handler = self.bzrdir._call_expecting_body(
 
388
                'BzrDir.get_config_file', path)
 
389
        except errors.UnknownSmartMethod:
 
390
            self._ensure_real()
 
391
            return self._real_store._load_content()
 
392
        if len(response) and response[0] != 'ok':
 
393
            raise errors.UnexpectedSmartServerResponse(response)
 
394
        return handler.read_body_bytes()
 
395
 
 
396
    def _save_content(self, content):
 
397
        # FIXME JRV 2011-11-22: Ideally this should use a
 
398
        # HPSS call too, but at the moment it is not possible
 
399
        # to write lock control directories.
 
400
        self._ensure_real()
 
401
        return self._real_store._save_content(content)
 
402
 
 
403
 
 
404
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
90
405
    """Control directory on a remote server, accessed via bzr:// or similar."""
91
406
 
92
407
    def __init__(self, transport, format, _client=None, _force_probe=False):
95
410
        :param _client: Private parameter for testing. Disables probing and the
96
411
            use of a real bzrdir.
97
412
        """
98
 
        BzrDir.__init__(self, transport, format)
 
413
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
99
414
        # this object holds a delegated bzrdir that uses file-level operations
100
415
        # to talk to the other side
101
416
        self._real_bzrdir = None
161
476
                import traceback
162
477
                warning('VFS BzrDir access triggered\n%s',
163
478
                    ''.join(traceback.format_stack()))
164
 
            self._real_bzrdir = BzrDir.open_from_transport(
 
479
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
165
480
                self.root_transport, _server_formats=False)
166
481
            self._format._network_name = \
167
482
                self._real_bzrdir._format.network_name()
173
488
        # Prevent aliasing problems in the next_open_branch_result cache.
174
489
        # See create_branch for rationale.
175
490
        self._next_open_branch_result = None
176
 
        return BzrDir.break_lock(self)
 
491
        return _mod_bzrdir.BzrDir.break_lock(self)
177
492
 
178
493
    def _vfs_cloning_metadir(self, require_stacking=False):
179
494
        self._ensure_real()
210
525
        if len(branch_info) != 2:
211
526
            raise errors.UnexpectedSmartServerResponse(response)
212
527
        branch_ref, branch_name = branch_info
213
 
        format = bzrdir.network_format_registry.get(control_name)
 
528
        try:
 
529
            format = controldir.network_format_registry.get(control_name)
 
530
        except KeyError:
 
531
            raise errors.UnknownFormatError(kind='control', format=control_name)
 
532
 
214
533
        if repo_name:
215
 
            format.repository_format = repository.network_format_registry.get(
216
 
                repo_name)
 
534
            try:
 
535
                format.repository_format = _mod_repository.network_format_registry.get(
 
536
                    repo_name)
 
537
            except KeyError:
 
538
                raise errors.UnknownFormatError(kind='repository',
 
539
                    format=repo_name)
217
540
        if branch_ref == 'ref':
218
541
            # XXX: we need possible_transports here to avoid reopening the
219
542
            # connection to the referenced location
220
 
            ref_bzrdir = BzrDir.open(branch_name)
 
543
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
221
544
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
222
545
            format.set_branch_format(branch_format)
223
546
        elif branch_ref == 'branch':
224
547
            if branch_name:
225
 
                format.set_branch_format(
226
 
                    branch.network_format_registry.get(branch_name))
 
548
                try:
 
549
                    branch_format = branch.network_format_registry.get(
 
550
                        branch_name)
 
551
                except KeyError:
 
552
                    raise errors.UnknownFormatError(kind='branch',
 
553
                        format=branch_name)
 
554
                format.set_branch_format(branch_format)
227
555
        else:
228
556
            raise errors.UnexpectedSmartServerResponse(response)
229
557
        return format
239
567
 
240
568
    def destroy_repository(self):
241
569
        """See BzrDir.destroy_repository"""
242
 
        self._ensure_real()
243
 
        self._real_bzrdir.destroy_repository()
 
570
        path = self._path_for_remote_call(self._client)
 
571
        try:
 
572
            response = self._call('BzrDir.destroy_repository', path)
 
573
        except errors.UnknownSmartMethod:
 
574
            self._ensure_real()
 
575
            self._real_bzrdir.destroy_repository()
 
576
            return
 
577
        if response[0] != 'ok':
 
578
            raise SmartProtocolError('unexpected response code %s' % (response,))
244
579
 
245
 
    def create_branch(self):
 
580
    def create_branch(self, name=None, repository=None,
 
581
                      append_revisions_only=None):
246
582
        # as per meta1 formats - just delegate to the format object which may
247
583
        # be parameterised.
248
 
        real_branch = self._format.get_branch_format().initialize(self)
 
584
        real_branch = self._format.get_branch_format().initialize(self,
 
585
            name=name, repository=repository,
 
586
            append_revisions_only=append_revisions_only)
249
587
        if not isinstance(real_branch, RemoteBranch):
250
 
            result = RemoteBranch(self, self.find_repository(), real_branch)
 
588
            if not isinstance(repository, RemoteRepository):
 
589
                raise AssertionError(
 
590
                    'need a RemoteRepository to use with RemoteBranch, got %r'
 
591
                    % (repository,))
 
592
            result = RemoteBranch(self, repository, real_branch, name=name)
251
593
        else:
252
594
            result = real_branch
253
595
        # BzrDir.clone_on_transport() uses the result of create_branch but does
259
601
        self._next_open_branch_result = result
260
602
        return result
261
603
 
262
 
    def destroy_branch(self):
 
604
    def destroy_branch(self, name=None):
263
605
        """See BzrDir.destroy_branch"""
264
 
        self._ensure_real()
265
 
        self._real_bzrdir.destroy_branch()
 
606
        path = self._path_for_remote_call(self._client)
 
607
        try:
 
608
            if name is not None:
 
609
                args = (name, )
 
610
            else:
 
611
                args = ()
 
612
            response = self._call('BzrDir.destroy_branch', path, *args)
 
613
        except errors.UnknownSmartMethod:
 
614
            self._ensure_real()
 
615
            self._real_bzrdir.destroy_branch(name=name)
 
616
            self._next_open_branch_result = None
 
617
            return
266
618
        self._next_open_branch_result = None
 
619
        if response[0] != 'ok':
 
620
            raise SmartProtocolError('unexpected response code %s' % (response,))
267
621
 
268
 
    def create_workingtree(self, revision_id=None, from_branch=None):
 
622
    def create_workingtree(self, revision_id=None, from_branch=None,
 
623
        accelerator_tree=None, hardlink=False):
269
624
        raise errors.NotLocalUrl(self.transport.base)
270
625
 
271
 
    def find_branch_format(self):
 
626
    def find_branch_format(self, name=None):
272
627
        """Find the branch 'format' for this bzrdir.
273
628
 
274
629
        This might be a synthetic object for e.g. RemoteBranch and SVN.
275
630
        """
276
 
        b = self.open_branch()
 
631
        b = self.open_branch(name=name)
277
632
        return b._format
278
633
 
279
 
    def get_branch_reference(self):
 
634
    def get_branch_reference(self, name=None):
280
635
        """See BzrDir.get_branch_reference()."""
 
636
        if name is not None:
 
637
            # XXX JRV20100304: Support opening colocated branches
 
638
            raise errors.NoColocatedBranchSupport(self)
281
639
        response = self._get_branch_reference()
282
640
        if response[0] == 'ref':
283
641
            return response[1]
314
672
            raise errors.UnexpectedSmartServerResponse(response)
315
673
        return response
316
674
 
317
 
    def _get_tree_branch(self):
 
675
    def _get_tree_branch(self, name=None):
318
676
        """See BzrDir._get_tree_branch()."""
319
 
        return None, self.open_branch()
 
677
        return None, self.open_branch(name=name)
320
678
 
321
 
    def open_branch(self, _unsupported=False, ignore_fallbacks=False):
322
 
        if _unsupported:
 
679
    def open_branch(self, name=None, unsupported=False,
 
680
                    ignore_fallbacks=False, possible_transports=None):
 
681
        if unsupported:
323
682
            raise NotImplementedError('unsupported flag support not implemented yet.')
324
683
        if self._next_open_branch_result is not None:
325
684
            # See create_branch for details.
330
689
        if response[0] == 'ref':
331
690
            # a branch reference, use the existing BranchReference logic.
332
691
            format = BranchReferenceFormat()
333
 
            return format.open(self, _found=True, location=response[1],
334
 
                ignore_fallbacks=ignore_fallbacks)
 
692
            return format.open(self, name=name, _found=True,
 
693
                location=response[1], ignore_fallbacks=ignore_fallbacks,
 
694
                possible_transports=possible_transports)
335
695
        branch_format_name = response[1]
336
696
        if not branch_format_name:
337
697
            branch_format_name = None
338
698
        format = RemoteBranchFormat(network_name=branch_format_name)
339
699
        return RemoteBranch(self, self.find_repository(), format=format,
340
 
            setup_stacking=not ignore_fallbacks)
 
700
            setup_stacking=not ignore_fallbacks, name=name,
 
701
            possible_transports=possible_transports)
341
702
 
342
703
    def _open_repo_v1(self, path):
343
704
        verb = 'BzrDir.find_repository'
406
767
 
407
768
    def has_workingtree(self):
408
769
        if self._has_working_tree is None:
409
 
            self._ensure_real()
410
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
 
770
            path = self._path_for_remote_call(self._client)
 
771
            try:
 
772
                response = self._call('BzrDir.has_workingtree', path)
 
773
            except errors.UnknownSmartMethod:
 
774
                self._ensure_real()
 
775
                self._has_working_tree = self._real_bzrdir.has_workingtree()
 
776
            else:
 
777
                if response[0] not in ('yes', 'no'):
 
778
                    raise SmartProtocolError('unexpected response code %s' % (response,))
 
779
                self._has_working_tree = (response[0] == 'yes')
411
780
        return self._has_working_tree
412
781
 
413
782
    def open_workingtree(self, recommend_upgrade=True):
418
787
 
419
788
    def _path_for_remote_call(self, client):
420
789
        """Return the path to be used for this bzrdir in a remote call."""
421
 
        return client.remote_path_from_transport(self.root_transport)
 
790
        return urlutils.split_segment_parameters_raw(
 
791
            client.remote_path_from_transport(self.root_transport))[0]
422
792
 
423
 
    def get_branch_transport(self, branch_format):
 
793
    def get_branch_transport(self, branch_format, name=None):
424
794
        self._ensure_real()
425
 
        return self._real_bzrdir.get_branch_transport(branch_format)
 
795
        return self._real_bzrdir.get_branch_transport(branch_format, name=name)
426
796
 
427
797
    def get_repository_transport(self, repository_format):
428
798
        self._ensure_real()
436
806
        """Upgrading of remote bzrdirs is not supported yet."""
437
807
        return False
438
808
 
439
 
    def needs_format_conversion(self, format=None):
 
809
    def needs_format_conversion(self, format):
440
810
        """Upgrading of remote bzrdirs is not supported yet."""
441
 
        if format is None:
442
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
443
 
                % 'needs_format_conversion(format=None)')
444
811
        return False
445
812
 
446
 
    def clone(self, url, revision_id=None, force_new_repo=False,
447
 
              preserve_stacking=False):
448
 
        self._ensure_real()
449
 
        return self._real_bzrdir.clone(url, revision_id=revision_id,
450
 
            force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
451
 
 
452
813
    def _get_config(self):
453
814
        return RemoteBzrDirConfig(self)
454
815
 
455
 
 
456
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
816
    def _get_config_store(self):
 
817
        return RemoteControlStore(self)
 
818
 
 
819
 
 
820
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
457
821
    """Format for repositories accessed over a _SmartClient.
458
822
 
459
823
    Instances of this repository are represented by RemoteRepository
474
838
    """
475
839
 
476
840
    _matchingbzrdir = RemoteBzrDirFormat()
 
841
    supports_full_versioned_files = True
 
842
    supports_leaving_lock = True
477
843
 
478
844
    def __init__(self):
479
 
        repository.RepositoryFormat.__init__(self)
 
845
        _mod_repository.RepositoryFormat.__init__(self)
480
846
        self._custom_format = None
481
847
        self._network_name = None
482
848
        self._creating_bzrdir = None
 
849
        self._revision_graph_can_have_wrong_parents = None
483
850
        self._supports_chks = None
484
851
        self._supports_external_lookups = None
485
852
        self._supports_tree_reference = None
 
853
        self._supports_funky_characters = None
 
854
        self._supports_nesting_repositories = None
486
855
        self._rich_root_data = None
487
856
 
488
857
    def __repr__(self):
517
886
        return self._supports_external_lookups
518
887
 
519
888
    @property
 
889
    def supports_funky_characters(self):
 
890
        if self._supports_funky_characters is None:
 
891
            self._ensure_real()
 
892
            self._supports_funky_characters = \
 
893
                self._custom_format.supports_funky_characters
 
894
        return self._supports_funky_characters
 
895
 
 
896
    @property
 
897
    def supports_nesting_repositories(self):
 
898
        if self._supports_nesting_repositories is None:
 
899
            self._ensure_real()
 
900
            self._supports_nesting_repositories = \
 
901
                self._custom_format.supports_nesting_repositories
 
902
        return self._supports_nesting_repositories
 
903
 
 
904
    @property
520
905
    def supports_tree_reference(self):
521
906
        if self._supports_tree_reference is None:
522
907
            self._ensure_real()
524
909
                self._custom_format.supports_tree_reference
525
910
        return self._supports_tree_reference
526
911
 
 
912
    @property
 
913
    def revision_graph_can_have_wrong_parents(self):
 
914
        if self._revision_graph_can_have_wrong_parents is None:
 
915
            self._ensure_real()
 
916
            self._revision_graph_can_have_wrong_parents = \
 
917
                self._custom_format.revision_graph_can_have_wrong_parents
 
918
        return self._revision_graph_can_have_wrong_parents
 
919
 
527
920
    def _vfs_initialize(self, a_bzrdir, shared):
528
921
        """Helper for common code in initialize."""
529
922
        if self._custom_format:
564
957
            network_name = self._network_name
565
958
        else:
566
959
            # Select the current bzrlib default and ask for that.
567
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
960
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
568
961
            reference_format = reference_bzrdir_format.repository_format
569
962
            network_name = reference_format.network_name()
570
963
        # 2) try direct creation via RPC
596
989
 
597
990
    def _ensure_real(self):
598
991
        if self._custom_format is None:
599
 
            self._custom_format = repository.network_format_registry.get(
600
 
                self._network_name)
 
992
            try:
 
993
                self._custom_format = _mod_repository.network_format_registry.get(
 
994
                    self._network_name)
 
995
            except KeyError:
 
996
                raise errors.UnknownFormatError(kind='repository',
 
997
                    format=self._network_name)
601
998
 
602
999
    @property
603
1000
    def _fetch_order(self):
638
1035
        return self._custom_format._serializer
639
1036
 
640
1037
 
641
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin):
 
1038
class RemoteRepository(_mod_repository.Repository, _RpcHelper,
 
1039
        lock._RelockDebugMixin):
642
1040
    """Repository accessed over rpc.
643
1041
 
644
1042
    For the moment most operations are performed using local transport-backed
668
1066
        self._format = format
669
1067
        self._lock_mode = None
670
1068
        self._lock_token = None
 
1069
        self._write_group_tokens = None
671
1070
        self._lock_count = 0
672
1071
        self._leave_lock = False
673
1072
        # Cache of revision parents; misses are cached during read locks, and
687
1086
        # Additional places to query for data.
688
1087
        self._fallback_repositories = []
689
1088
 
 
1089
    @property
 
1090
    def user_transport(self):
 
1091
        return self.bzrdir.user_transport
 
1092
 
 
1093
    @property
 
1094
    def control_transport(self):
 
1095
        # XXX: Normally you shouldn't directly get at the remote repository
 
1096
        # transport, but I'm not sure it's worth making this method
 
1097
        # optional -- mbp 2010-04-21
 
1098
        return self.bzrdir.get_repository_transport(None)
 
1099
 
690
1100
    def __str__(self):
691
1101
        return "%s(%s)" % (self.__class__.__name__, self.base)
692
1102
 
702
1112
 
703
1113
        :param suppress_errors: see Repository.abort_write_group.
704
1114
        """
705
 
        self._ensure_real()
706
 
        return self._real_repository.abort_write_group(
707
 
            suppress_errors=suppress_errors)
 
1115
        if self._real_repository:
 
1116
            self._ensure_real()
 
1117
            return self._real_repository.abort_write_group(
 
1118
                suppress_errors=suppress_errors)
 
1119
        if not self.is_in_write_group():
 
1120
            if suppress_errors:
 
1121
                mutter('(suppressed) not in write group')
 
1122
                return
 
1123
            raise errors.BzrError("not in write group")
 
1124
        path = self.bzrdir._path_for_remote_call(self._client)
 
1125
        try:
 
1126
            response = self._call('Repository.abort_write_group', path,
 
1127
                self._lock_token, self._write_group_tokens)
 
1128
        except Exception, exc:
 
1129
            self._write_group = None
 
1130
            if not suppress_errors:
 
1131
                raise
 
1132
            mutter('abort_write_group failed')
 
1133
            log_exception_quietly()
 
1134
            note(gettext('bzr: ERROR (ignored): %s'), exc)
 
1135
        else:
 
1136
            if response != ('ok', ):
 
1137
                raise errors.UnexpectedSmartServerResponse(response)
 
1138
            self._write_group_tokens = None
708
1139
 
709
1140
    @property
710
1141
    def chk_bytes(self):
724
1155
        for older plugins that don't use e.g. the CommitBuilder
725
1156
        facility.
726
1157
        """
727
 
        self._ensure_real()
728
 
        return self._real_repository.commit_write_group()
 
1158
        if self._real_repository:
 
1159
            self._ensure_real()
 
1160
            return self._real_repository.commit_write_group()
 
1161
        if not self.is_in_write_group():
 
1162
            raise errors.BzrError("not in write group")
 
1163
        path = self.bzrdir._path_for_remote_call(self._client)
 
1164
        response = self._call('Repository.commit_write_group', path,
 
1165
            self._lock_token, self._write_group_tokens)
 
1166
        if response != ('ok', ):
 
1167
            raise errors.UnexpectedSmartServerResponse(response)
 
1168
        self._write_group_tokens = None
729
1169
 
730
1170
    def resume_write_group(self, tokens):
731
 
        self._ensure_real()
732
 
        return self._real_repository.resume_write_group(tokens)
 
1171
        if self._real_repository:
 
1172
            return self._real_repository.resume_write_group(tokens)
 
1173
        path = self.bzrdir._path_for_remote_call(self._client)
 
1174
        try:
 
1175
            response = self._call('Repository.check_write_group', path,
 
1176
               self._lock_token, tokens)
 
1177
        except errors.UnknownSmartMethod:
 
1178
            self._ensure_real()
 
1179
            return self._real_repository.resume_write_group(tokens)
 
1180
        if response != ('ok', ):
 
1181
            raise errors.UnexpectedSmartServerResponse(response)
 
1182
        self._write_group_tokens = tokens
733
1183
 
734
1184
    def suspend_write_group(self):
735
 
        self._ensure_real()
736
 
        return self._real_repository.suspend_write_group()
 
1185
        if self._real_repository:
 
1186
            return self._real_repository.suspend_write_group()
 
1187
        ret = self._write_group_tokens or []
 
1188
        self._write_group_tokens = None
 
1189
        return ret
737
1190
 
738
1191
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
739
1192
        self._ensure_real()
800
1253
    def find_text_key_references(self):
801
1254
        """Find the text key references within the repository.
802
1255
 
803
 
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
804
 
        revision_ids. Each altered file-ids has the exact revision_ids that
805
 
        altered it listed explicitly.
806
1256
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
807
1257
            to whether they were referred to by the inventory of the
808
1258
            revision_id that they contain. The inventory texts from all present
826
1276
        """Private method for using with old (< 1.2) servers to fallback."""
827
1277
        if revision_id is None:
828
1278
            revision_id = ''
829
 
        elif revision.is_null(revision_id):
 
1279
        elif _mod_revision.is_null(revision_id):
830
1280
            return {}
831
1281
 
832
1282
        path = self.bzrdir._path_for_remote_call(self._client)
856
1306
        return RemoteStreamSource(self, to_format)
857
1307
 
858
1308
    @needs_read_lock
 
1309
    def get_file_graph(self):
 
1310
        return graph.Graph(self.texts)
 
1311
 
 
1312
    @needs_read_lock
859
1313
    def has_revision(self, revision_id):
860
1314
        """True if this repository has a copy of the revision."""
861
1315
        # Copy of bzrlib.repository.Repository.has_revision
878
1332
    def _has_same_fallbacks(self, other_repo):
879
1333
        """Returns true if the repositories have the same fallbacks."""
880
1334
        # XXX: copied from Repository; it should be unified into a base class
881
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
1335
        # <https://bugs.launchpad.net/bzr/+bug/401622>
882
1336
        my_fb = self._fallback_repositories
883
1337
        other_fb = other_repo._fallback_repositories
884
1338
        if len(my_fb) != len(other_fb):
900
1354
        parents_provider = self._make_parents_provider(other_repository)
901
1355
        return graph.Graph(parents_provider)
902
1356
 
 
1357
    @needs_read_lock
 
1358
    def get_known_graph_ancestry(self, revision_ids):
 
1359
        """Return the known graph for a set of revision ids and their ancestors.
 
1360
        """
 
1361
        st = static_tuple.StaticTuple
 
1362
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
 
1363
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
 
1364
        return graph.GraphThunkIdsToKeys(known_graph)
 
1365
 
903
1366
    def gather_stats(self, revid=None, committers=None):
904
1367
        """See Repository.gather_stats()."""
905
1368
        path = self.bzrdir._path_for_remote_call(self._client)
906
1369
        # revid can be None to indicate no revisions, not just NULL_REVISION
907
 
        if revid is None or revision.is_null(revid):
 
1370
        if revid is None or _mod_revision.is_null(revid):
908
1371
            fmt_revid = ''
909
1372
        else:
910
1373
            fmt_revid = revid
939
1402
 
940
1403
    def get_physical_lock_status(self):
941
1404
        """See Repository.get_physical_lock_status()."""
942
 
        # should be an API call to the server.
943
 
        self._ensure_real()
944
 
        return self._real_repository.get_physical_lock_status()
 
1405
        path = self.bzrdir._path_for_remote_call(self._client)
 
1406
        try:
 
1407
            response = self._call('Repository.get_physical_lock_status', path)
 
1408
        except errors.UnknownSmartMethod:
 
1409
            self._ensure_real()
 
1410
            return self._real_repository.get_physical_lock_status()
 
1411
        if response[0] not in ('yes', 'no'):
 
1412
            raise errors.UnexpectedSmartServerResponse(response)
 
1413
        return (response[0] == 'yes')
945
1414
 
946
1415
    def is_in_write_group(self):
947
1416
        """Return True if there is an open write group.
948
1417
 
949
1418
        write groups are only applicable locally for the smart server..
950
1419
        """
 
1420
        if self._write_group_tokens is not None:
 
1421
            return True
951
1422
        if self._real_repository:
952
1423
            return self._real_repository.is_in_write_group()
953
1424
 
971
1442
        pass
972
1443
 
973
1444
    def lock_read(self):
 
1445
        """Lock the repository for read operations.
 
1446
 
 
1447
        :return: A bzrlib.lock.LogicalLockResult.
 
1448
        """
974
1449
        # wrong eventually - want a local lock cache context
975
1450
        if not self._lock_mode:
976
1451
            self._note_lock('r')
983
1458
                repo.lock_read()
984
1459
        else:
985
1460
            self._lock_count += 1
 
1461
        return lock.LogicalLockResult(self.unlock)
986
1462
 
987
1463
    def _remote_lock_write(self, token):
988
1464
        path = self.bzrdir._path_for_remote_call(self._client)
1028
1504
            raise errors.ReadOnlyError(self)
1029
1505
        else:
1030
1506
            self._lock_count += 1
1031
 
        return self._lock_token or None
 
1507
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
1032
1508
 
1033
1509
    def leave_lock_in_place(self):
1034
1510
        if not self._lock_token:
1083
1559
            self._real_repository.lock_write(self._lock_token)
1084
1560
        elif self._lock_mode == 'r':
1085
1561
            self._real_repository.lock_read()
 
1562
        if self._write_group_tokens is not None:
 
1563
            # if we are already in a write group, resume it
 
1564
            self._real_repository.resume_write_group(self._write_group_tokens)
 
1565
            self._write_group_tokens = None
1086
1566
 
1087
1567
    def start_write_group(self):
1088
1568
        """Start a write group on the decorated repository.
1092
1572
        for older plugins that don't use e.g. the CommitBuilder
1093
1573
        facility.
1094
1574
        """
1095
 
        self._ensure_real()
1096
 
        return self._real_repository.start_write_group()
 
1575
        if self._real_repository:
 
1576
            self._ensure_real()
 
1577
            return self._real_repository.start_write_group()
 
1578
        if not self.is_write_locked():
 
1579
            raise errors.NotWriteLocked(self)
 
1580
        if self._write_group_tokens is not None:
 
1581
            raise errors.BzrError('already in a write group')
 
1582
        path = self.bzrdir._path_for_remote_call(self._client)
 
1583
        try:
 
1584
            response = self._call('Repository.start_write_group', path,
 
1585
                self._lock_token)
 
1586
        except (errors.UnknownSmartMethod, errors.UnsuspendableWriteGroup):
 
1587
            self._ensure_real()
 
1588
            return self._real_repository.start_write_group()
 
1589
        if response[0] != 'ok':
 
1590
            raise errors.UnexpectedSmartServerResponse(response)
 
1591
        self._write_group_tokens = response[1]
1097
1592
 
1098
1593
    def _unlock(self, token):
1099
1594
        path = self.bzrdir._path_for_remote_call(self._client)
1126
1621
            # This is just to let the _real_repository stay up to date.
1127
1622
            if self._real_repository is not None:
1128
1623
                self._real_repository.unlock()
 
1624
            elif self._write_group_tokens is not None:
 
1625
                self.abort_write_group()
1129
1626
        finally:
1130
1627
            # The rpc-level lock should be released even if there was a
1131
1628
            # problem releasing the vfs-based lock.
1143
1640
 
1144
1641
    def break_lock(self):
1145
1642
        # should hand off to the network
1146
 
        self._ensure_real()
1147
 
        return self._real_repository.break_lock()
 
1643
        path = self.bzrdir._path_for_remote_call(self._client)
 
1644
        try:
 
1645
            response = self._call("Repository.break_lock", path)
 
1646
        except errors.UnknownSmartMethod:
 
1647
            self._ensure_real()
 
1648
            return self._real_repository.break_lock()
 
1649
        if response != ('ok',):
 
1650
            raise errors.UnexpectedSmartServerResponse(response)
1148
1651
 
1149
1652
    def _get_tarball(self, compression):
1150
1653
        """Return a TemporaryFile containing a repository tarball.
1168
1671
            return t
1169
1672
        raise errors.UnexpectedSmartServerResponse(response)
1170
1673
 
 
1674
    @needs_read_lock
1171
1675
    def sprout(self, to_bzrdir, revision_id=None):
1172
 
        # TODO: Option to control what format is created?
1173
 
        self._ensure_real()
1174
 
        dest_repo = self._real_repository._format.initialize(to_bzrdir,
1175
 
                                                             shared=False)
 
1676
        """Create a descendent repository for new development.
 
1677
 
 
1678
        Unlike clone, this does not copy the settings of the repository.
 
1679
        """
 
1680
        dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
1176
1681
        dest_repo.fetch(self, revision_id=revision_id)
1177
1682
        return dest_repo
1178
1683
 
 
1684
    def _create_sprouting_repo(self, a_bzrdir, shared):
 
1685
        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
 
1686
            # use target default format.
 
1687
            dest_repo = a_bzrdir.create_repository()
 
1688
        else:
 
1689
            # Most control formats need the repository to be specifically
 
1690
            # created, but on some old all-in-one formats it's not needed
 
1691
            try:
 
1692
                dest_repo = self._format.initialize(a_bzrdir, shared=shared)
 
1693
            except errors.UninitializableFormat:
 
1694
                dest_repo = a_bzrdir.open_repository()
 
1695
        return dest_repo
 
1696
 
1179
1697
    ### These methods are just thin shims to the VFS object for now.
1180
1698
 
 
1699
    @needs_read_lock
1181
1700
    def revision_tree(self, revision_id):
1182
 
        self._ensure_real()
1183
 
        return self._real_repository.revision_tree(revision_id)
 
1701
        revision_id = _mod_revision.ensure_null(revision_id)
 
1702
        if revision_id == _mod_revision.NULL_REVISION:
 
1703
            return InventoryRevisionTree(self,
 
1704
                Inventory(root_id=None), _mod_revision.NULL_REVISION)
 
1705
        else:
 
1706
            return list(self.revision_trees([revision_id]))[0]
1184
1707
 
1185
1708
    def get_serializer_format(self):
1186
 
        self._ensure_real()
1187
 
        return self._real_repository.get_serializer_format()
 
1709
        path = self.bzrdir._path_for_remote_call(self._client)
 
1710
        try:
 
1711
            response = self._call('VersionedFileRepository.get_serializer_format',
 
1712
                path)
 
1713
        except errors.UnknownSmartMethod:
 
1714
            self._ensure_real()
 
1715
            return self._real_repository.get_serializer_format()
 
1716
        if response[0] != 'ok':
 
1717
            raise errors.UnexpectedSmartServerResponse(response)
 
1718
        return response[1]
1188
1719
 
1189
1720
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1190
1721
                           timezone=None, committer=None, revprops=None,
1191
 
                           revision_id=None):
 
1722
                           revision_id=None, lossy=False):
1192
1723
        # FIXME: It ought to be possible to call this without immediately
1193
1724
        # triggering _ensure_real.  For now it's the easiest thing to do.
1194
1725
        self._ensure_real()
1195
1726
        real_repo = self._real_repository
1196
1727
        builder = real_repo.get_commit_builder(branch, parents,
1197
1728
                config, timestamp=timestamp, timezone=timezone,
1198
 
                committer=committer, revprops=revprops, revision_id=revision_id)
 
1729
                committer=committer, revprops=revprops,
 
1730
                revision_id=revision_id, lossy=lossy)
1199
1731
        return builder
1200
1732
 
1201
1733
    def add_fallback_repository(self, repository):
1209
1741
        # We need to accumulate additional repositories here, to pass them in
1210
1742
        # on various RPC's.
1211
1743
        #
 
1744
        # Make the check before we lock: this raises an exception.
 
1745
        self._check_fallback_repository(repository)
1212
1746
        if self.is_locked():
1213
1747
            # We will call fallback.unlock() when we transition to the unlocked
1214
1748
            # state, so always add a lock here. If a caller passes us a locked
1219
1753
        # _real_branch had its get_stacked_on_url method called), then the
1220
1754
        # repository to be added may already be in the _real_repositories list.
1221
1755
        if self._real_repository is not None:
1222
 
            fallback_locations = [repo.bzrdir.root_transport.base for repo in
 
1756
            fallback_locations = [repo.user_url for repo in
1223
1757
                self._real_repository._fallback_repositories]
1224
 
            if repository.bzrdir.root_transport.base not in fallback_locations:
 
1758
            if repository.user_url not in fallback_locations:
1225
1759
                self._real_repository.add_fallback_repository(repository)
1226
1760
 
 
1761
    def _check_fallback_repository(self, repository):
 
1762
        """Check that this repository can fallback to repository safely.
 
1763
 
 
1764
        Raise an error if not.
 
1765
 
 
1766
        :param repository: A repository to fallback to.
 
1767
        """
 
1768
        return _mod_repository.InterRepository._assert_same_model(
 
1769
            self, repository)
 
1770
 
1227
1771
    def add_inventory(self, revid, inv, parents):
1228
1772
        self._ensure_real()
1229
1773
        return self._real_repository.add_inventory(revid, inv, parents)
1230
1774
 
1231
1775
    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1232
 
                               parents):
 
1776
            parents, basis_inv=None, propagate_caches=False):
1233
1777
        self._ensure_real()
1234
1778
        return self._real_repository.add_inventory_by_delta(basis_revision_id,
1235
 
            delta, new_revision_id, parents)
 
1779
            delta, new_revision_id, parents, basis_inv=basis_inv,
 
1780
            propagate_caches=propagate_caches)
1236
1781
 
1237
1782
    def add_revision(self, rev_id, rev, inv=None, config=None):
1238
1783
        self._ensure_real()
1241
1786
 
1242
1787
    @needs_read_lock
1243
1788
    def get_inventory(self, revision_id):
1244
 
        self._ensure_real()
1245
 
        return self._real_repository.get_inventory(revision_id)
 
1789
        return list(self.iter_inventories([revision_id]))[0]
1246
1790
 
1247
1791
    def iter_inventories(self, revision_ids, ordering=None):
1248
1792
        self._ensure_real()
1250
1794
 
1251
1795
    @needs_read_lock
1252
1796
    def get_revision(self, revision_id):
1253
 
        self._ensure_real()
1254
 
        return self._real_repository.get_revision(revision_id)
 
1797
        return self.get_revisions([revision_id])[0]
1255
1798
 
1256
1799
    def get_transaction(self):
1257
1800
        self._ensure_real()
1259
1802
 
1260
1803
    @needs_read_lock
1261
1804
    def clone(self, a_bzrdir, revision_id=None):
1262
 
        self._ensure_real()
1263
 
        return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
 
1805
        dest_repo = self._create_sprouting_repo(
 
1806
            a_bzrdir, shared=self.is_shared())
 
1807
        self.copy_content_into(dest_repo, revision_id)
 
1808
        return dest_repo
1264
1809
 
1265
1810
    def make_working_trees(self):
1266
1811
        """See Repository.make_working_trees"""
1267
 
        self._ensure_real()
1268
 
        return self._real_repository.make_working_trees()
 
1812
        path = self.bzrdir._path_for_remote_call(self._client)
 
1813
        try:
 
1814
            response = self._call('Repository.make_working_trees', path)
 
1815
        except errors.UnknownSmartMethod:
 
1816
            self._ensure_real()
 
1817
            return self._real_repository.make_working_trees()
 
1818
        if response[0] not in ('yes', 'no'):
 
1819
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
1820
        return response[0] == 'yes'
1269
1821
 
1270
1822
    def refresh_data(self):
1271
 
        """Re-read any data needed to to synchronise with disk.
 
1823
        """Re-read any data needed to synchronise with disk.
1272
1824
 
1273
1825
        This method is intended to be called after another repository instance
1274
1826
        (such as one used by a smart server) has inserted data into the
1275
 
        repository. It may not be called during a write group, but may be
1276
 
        called at any other time.
 
1827
        repository. On all repositories this will work outside of write groups.
 
1828
        Some repository formats (pack and newer for bzrlib native formats)
 
1829
        support refresh_data inside write groups. If called inside a write
 
1830
        group on a repository that does not support refreshing in a write group
 
1831
        IsInWriteGroupError will be raised.
1277
1832
        """
1278
 
        if self.is_in_write_group():
1279
 
            raise errors.InternalBzrError(
1280
 
                "May not refresh_data while in a write group.")
1281
1833
        if self._real_repository is not None:
1282
1834
            self._real_repository.refresh_data()
1283
1835
 
1290
1842
        included_keys = result_set.intersection(result_parents)
1291
1843
        start_keys = result_set.difference(included_keys)
1292
1844
        exclude_keys = result_parents.difference(result_set)
1293
 
        result = graph.SearchResult(start_keys, exclude_keys,
 
1845
        result = vf_search.SearchResult(start_keys, exclude_keys,
1294
1846
            len(result_set), result_set)
1295
1847
        return result
1296
1848
 
1297
1849
    @needs_read_lock
1298
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
1850
    def search_missing_revision_ids(self, other,
 
1851
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
1852
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
1853
            limit=None):
1299
1854
        """Return the revision ids that other has that this does not.
1300
1855
 
1301
1856
        These are returned in topological order.
1302
1857
 
1303
1858
        revision_id: only return revision ids included by revision_id.
1304
1859
        """
1305
 
        return repository.InterRepository.get(
1306
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
1860
        if symbol_versioning.deprecated_passed(revision_id):
 
1861
            symbol_versioning.warn(
 
1862
                'search_missing_revision_ids(revision_id=...) was '
 
1863
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
1864
                DeprecationWarning, stacklevel=2)
 
1865
            if revision_ids is not None:
 
1866
                raise AssertionError(
 
1867
                    'revision_ids is mutually exclusive with revision_id')
 
1868
            if revision_id is not None:
 
1869
                revision_ids = [revision_id]
 
1870
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
1871
        return inter_repo.search_missing_revision_ids(
 
1872
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
1873
            if_present_ids=if_present_ids, limit=limit)
1307
1874
 
1308
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
1875
    def fetch(self, source, revision_id=None, find_ghosts=False,
1309
1876
            fetch_spec=None):
1310
1877
        # No base implementation to use as RemoteRepository is not a subclass
1311
1878
        # of Repository; so this is a copy of Repository.fetch().
1322
1889
            # check that last_revision is in 'from' and then return a
1323
1890
            # no-operation.
1324
1891
            if (revision_id is not None and
1325
 
                not revision.is_null(revision_id)):
 
1892
                not _mod_revision.is_null(revision_id)):
1326
1893
                self.get_revision(revision_id)
1327
1894
            return 0, []
1328
1895
        # if there is no specific appropriate InterRepository, this will get
1329
1896
        # the InterRepository base class, which raises an
1330
1897
        # IncompatibleRepositories when asked to fetch.
1331
 
        inter = repository.InterRepository.get(source, self)
1332
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
1898
        inter = _mod_repository.InterRepository.get(source, self)
 
1899
        if (fetch_spec is not None and
 
1900
            not getattr(inter, "supports_fetch_spec", False)):
 
1901
            raise errors.UnsupportedOperation(
 
1902
                "fetch_spec not supported for %r" % inter)
 
1903
        return inter.fetch(revision_id=revision_id,
1333
1904
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1334
1905
 
1335
1906
    def create_bundle(self, target, base, fileobj, format=None):
1337
1908
        self._real_repository.create_bundle(target, base, fileobj, format)
1338
1909
 
1339
1910
    @needs_read_lock
 
1911
    @symbol_versioning.deprecated_method(
 
1912
        symbol_versioning.deprecated_in((2, 4, 0)))
1340
1913
    def get_ancestry(self, revision_id, topo_sorted=True):
1341
1914
        self._ensure_real()
1342
1915
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1350
1923
        return self._real_repository._get_versioned_file_checker(
1351
1924
            revisions, revision_versions_cache)
1352
1925
 
 
1926
    def _iter_files_bytes_rpc(self, desired_files, absent):
 
1927
        path = self.bzrdir._path_for_remote_call(self._client)
 
1928
        lines = []
 
1929
        identifiers = []
 
1930
        for (file_id, revid, identifier) in desired_files:
 
1931
            lines.append("%s\0%s" % (
 
1932
                osutils.safe_file_id(file_id),
 
1933
                osutils.safe_revision_id(revid)))
 
1934
            identifiers.append(identifier)
 
1935
        (response_tuple, response_handler) = (
 
1936
            self._call_with_body_bytes_expecting_body(
 
1937
            "Repository.iter_files_bytes", (path, ), "\n".join(lines)))
 
1938
        if response_tuple != ('ok', ):
 
1939
            response_handler.cancel_read_body()
 
1940
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
1941
        byte_stream = response_handler.read_streamed_body()
 
1942
        def decompress_stream(start, byte_stream, unused):
 
1943
            decompressor = zlib.decompressobj()
 
1944
            yield decompressor.decompress(start)
 
1945
            while decompressor.unused_data == "":
 
1946
                try:
 
1947
                    data = byte_stream.next()
 
1948
                except StopIteration:
 
1949
                    break
 
1950
                yield decompressor.decompress(data)
 
1951
            yield decompressor.flush()
 
1952
            unused.append(decompressor.unused_data)
 
1953
        unused = ""
 
1954
        while True:
 
1955
            while not "\n" in unused:
 
1956
                unused += byte_stream.next()
 
1957
            header, rest = unused.split("\n", 1)
 
1958
            args = header.split("\0")
 
1959
            if args[0] == "absent":
 
1960
                absent[identifiers[int(args[3])]] = (args[1], args[2])
 
1961
                unused = rest
 
1962
                continue
 
1963
            elif args[0] == "ok":
 
1964
                idx = int(args[1])
 
1965
            else:
 
1966
                raise errors.UnexpectedSmartServerResponse(args)
 
1967
            unused_chunks = []
 
1968
            yield (identifiers[idx],
 
1969
                decompress_stream(rest, byte_stream, unused_chunks))
 
1970
            unused = "".join(unused_chunks)
 
1971
 
1353
1972
    def iter_files_bytes(self, desired_files):
1354
1973
        """See Repository.iter_file_bytes.
1355
1974
        """
1356
 
        self._ensure_real()
1357
 
        return self._real_repository.iter_files_bytes(desired_files)
 
1975
        try:
 
1976
            absent = {}
 
1977
            for (identifier, bytes_iterator) in self._iter_files_bytes_rpc(
 
1978
                    desired_files, absent):
 
1979
                yield identifier, bytes_iterator
 
1980
            for fallback in self._fallback_repositories:
 
1981
                if not absent:
 
1982
                    break
 
1983
                desired_files = [(key[0], key[1], identifier) for
 
1984
                    (identifier, key) in absent.iteritems()]
 
1985
                for (identifier, bytes_iterator) in fallback.iter_files_bytes(desired_files):
 
1986
                    del absent[identifier]
 
1987
                    yield identifier, bytes_iterator
 
1988
            if absent:
 
1989
                # There may be more missing items, but raise an exception
 
1990
                # for just one.
 
1991
                missing_identifier = absent.keys()[0]
 
1992
                missing_key = absent[missing_identifier]
 
1993
                raise errors.RevisionNotPresent(revision_id=missing_key[1],
 
1994
                    file_id=missing_key[0])
 
1995
        except errors.UnknownSmartMethod:
 
1996
            self._ensure_real()
 
1997
            for (identifier, bytes_iterator) in (
 
1998
                self._real_repository.iter_files_bytes(desired_files)):
 
1999
                yield identifier, bytes_iterator
 
2000
 
 
2001
    def get_cached_parent_map(self, revision_ids):
 
2002
        """See bzrlib.CachingParentsProvider.get_cached_parent_map"""
 
2003
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
1358
2004
 
1359
2005
    def get_parent_map(self, revision_ids):
1360
2006
        """See bzrlib.Graph.get_parent_map()."""
1419
2065
        if parents_map is None:
1420
2066
            # Repository is not locked, so there's no cache.
1421
2067
            parents_map = {}
1422
 
        # start_set is all the keys in the cache
1423
 
        start_set = set(parents_map)
1424
 
        # result set is all the references to keys in the cache
1425
 
        result_parents = set()
1426
 
        for parents in parents_map.itervalues():
1427
 
            result_parents.update(parents)
1428
 
        stop_keys = result_parents.difference(start_set)
1429
 
        # We don't need to send ghosts back to the server as a position to
1430
 
        # stop either.
1431
 
        stop_keys.difference_update(self._unstacked_provider.missing_keys)
1432
 
        key_count = len(parents_map)
1433
 
        if (NULL_REVISION in result_parents
1434
 
            and NULL_REVISION in self._unstacked_provider.missing_keys):
1435
 
            # If we pruned NULL_REVISION from the stop_keys because it's also
1436
 
            # in our cache of "missing" keys we need to increment our key count
1437
 
            # by 1, because the reconsitituted SearchResult on the server will
1438
 
            # still consider NULL_REVISION to be an included key.
1439
 
            key_count += 1
1440
 
        included_keys = start_set.intersection(result_parents)
1441
 
        start_set.difference_update(included_keys)
 
2068
        if _DEFAULT_SEARCH_DEPTH <= 0:
 
2069
            (start_set, stop_keys,
 
2070
             key_count) = vf_search.search_result_from_parent_map(
 
2071
                parents_map, self._unstacked_provider.missing_keys)
 
2072
        else:
 
2073
            (start_set, stop_keys,
 
2074
             key_count) = vf_search.limited_search_result_from_parent_map(
 
2075
                parents_map, self._unstacked_provider.missing_keys,
 
2076
                keys, depth=_DEFAULT_SEARCH_DEPTH)
1442
2077
        recipe = ('manual', start_set, stop_keys, key_count)
1443
2078
        body = self._serialise_search_recipe(recipe)
1444
2079
        path = self.bzrdir._path_for_remote_call(self._client)
1493
2128
 
1494
2129
    @needs_read_lock
1495
2130
    def get_signature_text(self, revision_id):
1496
 
        self._ensure_real()
1497
 
        return self._real_repository.get_signature_text(revision_id)
 
2131
        path = self.bzrdir._path_for_remote_call(self._client)
 
2132
        try:
 
2133
            response_tuple, response_handler = self._call_expecting_body(
 
2134
                'Repository.get_revision_signature_text', path, revision_id)
 
2135
        except errors.UnknownSmartMethod:
 
2136
            self._ensure_real()
 
2137
            return self._real_repository.get_signature_text(revision_id)
 
2138
        except errors.NoSuchRevision, err:
 
2139
            for fallback in self._fallback_repositories:
 
2140
                try:
 
2141
                    return fallback.get_signature_text(revision_id)
 
2142
                except errors.NoSuchRevision:
 
2143
                    pass
 
2144
            raise err
 
2145
        else:
 
2146
            if response_tuple[0] != 'ok':
 
2147
                raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2148
            return response_handler.read_body_bytes()
1498
2149
 
1499
2150
    @needs_read_lock
1500
2151
    def _get_inventory_xml(self, revision_id):
1501
2152
        self._ensure_real()
1502
2153
        return self._real_repository._get_inventory_xml(revision_id)
1503
2154
 
1504
 
    def _deserialise_inventory(self, revision_id, xml):
1505
 
        self._ensure_real()
1506
 
        return self._real_repository._deserialise_inventory(revision_id, xml)
1507
 
 
1508
2155
    def reconcile(self, other=None, thorough=False):
1509
2156
        self._ensure_real()
1510
2157
        return self._real_repository.reconcile(other=other, thorough=thorough)
1511
2158
 
1512
2159
    def all_revision_ids(self):
1513
 
        self._ensure_real()
1514
 
        return self._real_repository.all_revision_ids()
 
2160
        path = self.bzrdir._path_for_remote_call(self._client)
 
2161
        try:
 
2162
            response_tuple, response_handler = self._call_expecting_body(
 
2163
                "Repository.all_revision_ids", path)
 
2164
        except errors.UnknownSmartMethod:
 
2165
            self._ensure_real()
 
2166
            return self._real_repository.all_revision_ids()
 
2167
        if response_tuple != ("ok", ):
 
2168
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2169
        revids = set(response_handler.read_body_bytes().splitlines())
 
2170
        for fallback in self._fallback_repositories:
 
2171
            revids.update(set(fallback.all_revision_ids()))
 
2172
        return list(revids)
1515
2173
 
1516
2174
    @needs_read_lock
1517
2175
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1521
2179
 
1522
2180
    @needs_read_lock
1523
2181
    def get_revision_delta(self, revision_id, specific_fileids=None):
1524
 
        self._ensure_real()
1525
 
        return self._real_repository.get_revision_delta(revision_id,
1526
 
            specific_fileids=specific_fileids)
 
2182
        r = self.get_revision(revision_id)
 
2183
        return list(self.get_deltas_for_revisions([r],
 
2184
            specific_fileids=specific_fileids))[0]
1527
2185
 
1528
2186
    @needs_read_lock
1529
2187
    def revision_trees(self, revision_ids):
1530
 
        self._ensure_real()
1531
 
        return self._real_repository.revision_trees(revision_ids)
 
2188
        inventories = self.iter_inventories(revision_ids)
 
2189
        for inv in inventories:
 
2190
            yield InventoryRevisionTree(self, inv, inv.revision_id)
1532
2191
 
1533
2192
    @needs_read_lock
1534
2193
    def get_revision_reconcile(self, revision_id):
1542
2201
            callback_refs=callback_refs, check_repo=check_repo)
1543
2202
 
1544
2203
    def copy_content_into(self, destination, revision_id=None):
1545
 
        self._ensure_real()
1546
 
        return self._real_repository.copy_content_into(
1547
 
            destination, revision_id=revision_id)
 
2204
        """Make a complete copy of the content in self into destination.
 
2205
 
 
2206
        This is a destructive operation! Do not use it on existing
 
2207
        repositories.
 
2208
        """
 
2209
        interrepo = _mod_repository.InterRepository.get(self, destination)
 
2210
        return interrepo.copy_content(revision_id)
1548
2211
 
1549
2212
    def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1550
2213
        # get a tarball of the remote repository, and copy from that into the
1551
2214
        # destination
1552
 
        from bzrlib import osutils
1553
2215
        import tarfile
1554
2216
        # TODO: Maybe a progress bar while streaming the tarball?
1555
 
        note("Copying repository content as tarball...")
 
2217
        note(gettext("Copying repository content as tarball..."))
1556
2218
        tar_file = self._get_tarball('bz2')
1557
2219
        if tar_file is None:
1558
2220
            return None
1563
2225
            tmpdir = osutils.mkdtemp()
1564
2226
            try:
1565
2227
                _extract_tar(tar, tmpdir)
1566
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
2228
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1567
2229
                tmp_repo = tmp_bzrdir.open_repository()
1568
2230
                tmp_repo.copy_content_into(destination, revision_id)
1569
2231
            finally:
1585
2247
        return self._real_repository.inventories
1586
2248
 
1587
2249
    @needs_write_lock
1588
 
    def pack(self, hint=None):
 
2250
    def pack(self, hint=None, clean_obsolete_packs=False):
1589
2251
        """Compress the data within the repository.
1590
 
 
1591
 
        This is not currently implemented within the smart server.
1592
2252
        """
1593
 
        self._ensure_real()
1594
 
        return self._real_repository.pack(hint=hint)
 
2253
        if hint is None:
 
2254
            body = ""
 
2255
        else:
 
2256
            body = "".join([l+"\n" for l in hint])
 
2257
        path = self.bzrdir._path_for_remote_call(self._client)
 
2258
        try:
 
2259
            response, handler = self._call_with_body_bytes_expecting_body(
 
2260
                'Repository.pack', (path, self._lock_token,
 
2261
                    str(clean_obsolete_packs)), body)
 
2262
        except errors.UnknownSmartMethod:
 
2263
            self._ensure_real()
 
2264
            return self._real_repository.pack(hint=hint,
 
2265
                clean_obsolete_packs=clean_obsolete_packs)
 
2266
        handler.cancel_read_body()
 
2267
        if response != ('ok', ):
 
2268
            raise errors.UnexpectedSmartServerResponse(response)
1595
2269
 
1596
2270
    @property
1597
2271
    def revisions(self):
1598
2272
        """Decorate the real repository for now.
1599
2273
 
1600
 
        In the short term this should become a real object to intercept graph
1601
 
        lookups.
1602
 
 
1603
2274
        In the long term a full blown network facility is needed.
1604
2275
        """
1605
2276
        self._ensure_real()
1633
2304
 
1634
2305
    @needs_write_lock
1635
2306
    def sign_revision(self, revision_id, gpg_strategy):
1636
 
        self._ensure_real()
1637
 
        return self._real_repository.sign_revision(revision_id, gpg_strategy)
 
2307
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2308
        plaintext = testament.as_short_text()
 
2309
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1638
2310
 
1639
2311
    @property
1640
2312
    def texts(self):
1646
2318
        self._ensure_real()
1647
2319
        return self._real_repository.texts
1648
2320
 
 
2321
    def _iter_revisions_rpc(self, revision_ids):
 
2322
        body = "\n".join(revision_ids)
 
2323
        path = self.bzrdir._path_for_remote_call(self._client)
 
2324
        response_tuple, response_handler = (
 
2325
            self._call_with_body_bytes_expecting_body(
 
2326
            "Repository.iter_revisions", (path, ), body))
 
2327
        if response_tuple[0] != "ok":
 
2328
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2329
        serializer_format = response_tuple[1]
 
2330
        serializer = serializer_format_registry.get(serializer_format)
 
2331
        byte_stream = response_handler.read_streamed_body()
 
2332
        decompressor = zlib.decompressobj()
 
2333
        chunks = []
 
2334
        for bytes in byte_stream:
 
2335
            chunks.append(decompressor.decompress(bytes))
 
2336
            if decompressor.unused_data != "":
 
2337
                chunks.append(decompressor.flush())
 
2338
                yield serializer.read_revision_from_string("".join(chunks))
 
2339
                unused = decompressor.unused_data
 
2340
                decompressor = zlib.decompressobj()
 
2341
                chunks = [decompressor.decompress(unused)]
 
2342
        chunks.append(decompressor.flush())
 
2343
        text = "".join(chunks)
 
2344
        if text != "":
 
2345
            yield serializer.read_revision_from_string("".join(chunks))
 
2346
 
1649
2347
    @needs_read_lock
1650
2348
    def get_revisions(self, revision_ids):
1651
 
        self._ensure_real()
1652
 
        return self._real_repository.get_revisions(revision_ids)
 
2349
        if revision_ids is None:
 
2350
            revision_ids = self.all_revision_ids()
 
2351
        else:
 
2352
            for rev_id in revision_ids:
 
2353
                if not rev_id or not isinstance(rev_id, basestring):
 
2354
                    raise errors.InvalidRevisionId(
 
2355
                        revision_id=rev_id, branch=self)
 
2356
        try:
 
2357
            missing = set(revision_ids)
 
2358
            revs = {}
 
2359
            for rev in self._iter_revisions_rpc(revision_ids):
 
2360
                missing.remove(rev.revision_id)
 
2361
                revs[rev.revision_id] = rev
 
2362
        except errors.UnknownSmartMethod:
 
2363
            self._ensure_real()
 
2364
            return self._real_repository.get_revisions(revision_ids)
 
2365
        for fallback in self._fallback_repositories:
 
2366
            if not missing:
 
2367
                break
 
2368
            for revid in list(missing):
 
2369
                # XXX JRV 2011-11-20: It would be nice if there was a
 
2370
                # public method on Repository that could be used to query
 
2371
                # for revision objects *without* failing completely if one
 
2372
                # was missing. There is VersionedFileRepository._iter_revisions,
 
2373
                # but unfortunately that's private and not provided by
 
2374
                # all repository implementations.
 
2375
                try:
 
2376
                    revs[revid] = fallback.get_revision(revid)
 
2377
                except errors.NoSuchRevision:
 
2378
                    pass
 
2379
                else:
 
2380
                    missing.remove(revid)
 
2381
        if missing:
 
2382
            raise errors.NoSuchRevision(self, list(missing)[0])
 
2383
        return [revs[revid] for revid in revision_ids]
1653
2384
 
1654
2385
    def supports_rich_root(self):
1655
2386
        return self._format.rich_root_data
1656
2387
 
 
2388
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1657
2389
    def iter_reverse_revision_history(self, revision_id):
1658
2390
        self._ensure_real()
1659
2391
        return self._real_repository.iter_reverse_revision_history(revision_id)
1662
2394
    def _serializer(self):
1663
2395
        return self._format._serializer
1664
2396
 
 
2397
    @needs_write_lock
1665
2398
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1666
 
        self._ensure_real()
1667
 
        return self._real_repository.store_revision_signature(
1668
 
            gpg_strategy, plaintext, revision_id)
 
2399
        signature = gpg_strategy.sign(plaintext)
 
2400
        self.add_signature_text(revision_id, signature)
1669
2401
 
1670
2402
    def add_signature_text(self, revision_id, signature):
1671
 
        self._ensure_real()
1672
 
        return self._real_repository.add_signature_text(revision_id, signature)
 
2403
        if self._real_repository:
 
2404
            # If there is a real repository the write group will
 
2405
            # be in the real repository as well, so use that:
 
2406
            self._ensure_real()
 
2407
            return self._real_repository.add_signature_text(
 
2408
                revision_id, signature)
 
2409
        path = self.bzrdir._path_for_remote_call(self._client)
 
2410
        response, handler = self._call_with_body_bytes_expecting_body(
 
2411
            'Repository.add_signature_text', (path, self._lock_token,
 
2412
                revision_id) + tuple(self._write_group_tokens), signature)
 
2413
        handler.cancel_read_body()
 
2414
        self.refresh_data()
 
2415
        if response[0] != 'ok':
 
2416
            raise errors.UnexpectedSmartServerResponse(response)
 
2417
        self._write_group_tokens = response[1:]
1673
2418
 
1674
2419
    def has_signature_for_revision_id(self, revision_id):
1675
 
        self._ensure_real()
1676
 
        return self._real_repository.has_signature_for_revision_id(revision_id)
 
2420
        path = self.bzrdir._path_for_remote_call(self._client)
 
2421
        try:
 
2422
            response = self._call('Repository.has_signature_for_revision_id',
 
2423
                path, revision_id)
 
2424
        except errors.UnknownSmartMethod:
 
2425
            self._ensure_real()
 
2426
            return self._real_repository.has_signature_for_revision_id(
 
2427
                revision_id)
 
2428
        if response[0] not in ('yes', 'no'):
 
2429
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2430
        if response[0] == 'yes':
 
2431
            return True
 
2432
        for fallback in self._fallback_repositories:
 
2433
            if fallback.has_signature_for_revision_id(revision_id):
 
2434
                return True
 
2435
        return False
 
2436
 
 
2437
    @needs_read_lock
 
2438
    def verify_revision_signature(self, revision_id, gpg_strategy):
 
2439
        if not self.has_signature_for_revision_id(revision_id):
 
2440
            return gpg.SIGNATURE_NOT_SIGNED, None
 
2441
        signature = self.get_signature_text(revision_id)
 
2442
 
 
2443
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2444
        plaintext = testament.as_short_text()
 
2445
 
 
2446
        return gpg_strategy.verify(signature, plaintext)
1677
2447
 
1678
2448
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1679
2449
        self._ensure_real()
1680
2450
        return self._real_repository.item_keys_introduced_by(revision_ids,
1681
2451
            _files_pb=_files_pb)
1682
2452
 
1683
 
    def revision_graph_can_have_wrong_parents(self):
1684
 
        # The answer depends on the remote repo format.
1685
 
        self._ensure_real()
1686
 
        return self._real_repository.revision_graph_can_have_wrong_parents()
1687
 
 
1688
2453
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1689
2454
        self._ensure_real()
1690
2455
        return self._real_repository._find_inconsistent_revision_parents(
1698
2463
        providers = [self._unstacked_provider]
1699
2464
        if other is not None:
1700
2465
            providers.insert(0, other)
1701
 
        providers.extend(r._make_parents_provider() for r in
1702
 
                         self._fallback_repositories)
1703
 
        return graph.StackedParentsProvider(providers)
 
2466
        return graph.StackedParentsProvider(_LazyListJoin(
 
2467
            providers, self._fallback_repositories))
1704
2468
 
1705
2469
    def _serialise_search_recipe(self, recipe):
1706
2470
        """Serialise a graph search recipe.
1714
2478
        return '\n'.join((start_keys, stop_keys, count))
1715
2479
 
1716
2480
    def _serialise_search_result(self, search_result):
1717
 
        if isinstance(search_result, graph.PendingAncestryResult):
1718
 
            parts = ['ancestry-of']
1719
 
            parts.extend(search_result.heads)
1720
 
        else:
1721
 
            recipe = search_result.get_recipe()
1722
 
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
 
2481
        parts = search_result.get_network_struct()
1723
2482
        return '\n'.join(parts)
1724
2483
 
1725
2484
    def autopack(self):
1735
2494
            raise errors.UnexpectedSmartServerResponse(response)
1736
2495
 
1737
2496
 
1738
 
class RemoteStreamSink(repository.StreamSink):
 
2497
class RemoteStreamSink(vf_repository.StreamSink):
1739
2498
 
1740
2499
    def _insert_real(self, stream, src_format, resume_tokens):
1741
2500
        self.target_repo._ensure_real()
1842
2601
        self._last_substream and self._last_stream so that the stream can be
1843
2602
        resumed by _resume_stream_with_vfs.
1844
2603
        """
1845
 
                    
 
2604
 
1846
2605
        stream_iter = iter(stream)
1847
2606
        for substream_kind, substream in stream_iter:
1848
2607
            if substream_kind == 'inventory-deltas':
1851
2610
                return
1852
2611
            else:
1853
2612
                yield substream_kind, substream
1854
 
            
1855
 
 
1856
 
class RemoteStreamSource(repository.StreamSource):
 
2613
 
 
2614
 
 
2615
class RemoteStreamSource(vf_repository.StreamSource):
1857
2616
    """Stream data from a remote server."""
1858
2617
 
1859
2618
    def get_stream(self, search):
1880
2639
 
1881
2640
    def _real_stream(self, repo, search):
1882
2641
        """Get a stream for search from repo.
1883
 
        
1884
 
        This never called RemoteStreamSource.get_stream, and is a heler
1885
 
        for RemoteStreamSource._get_stream to allow getting a stream 
 
2642
 
 
2643
        This never called RemoteStreamSource.get_stream, and is a helper
 
2644
        for RemoteStreamSource._get_stream to allow getting a stream
1886
2645
        reliably whether fallback back because of old servers or trying
1887
2646
        to stream from a non-RemoteRepository (which the stacked support
1888
2647
        code will do).
1919
2678
        candidate_verbs = [
1920
2679
            ('Repository.get_stream_1.19', (1, 19)),
1921
2680
            ('Repository.get_stream', (1, 13))]
 
2681
 
1922
2682
        found_verb = False
1923
2683
        for verb, version in candidate_verbs:
1924
2684
            if medium._is_remote_before(version):
1928
2688
                    verb, args, search_bytes)
1929
2689
            except errors.UnknownSmartMethod:
1930
2690
                medium._remember_remote_is_before(version)
 
2691
            except errors.UnknownErrorFromSmartServer, e:
 
2692
                if isinstance(search, vf_search.EverythingResult):
 
2693
                    error_verb = e.error_from_smart_server.error_verb
 
2694
                    if error_verb == 'BadSearch':
 
2695
                        # Pre-2.4 servers don't support this sort of search.
 
2696
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
2697
                        # good idea in general?  It might provide a little bit
 
2698
                        # of protection against client-side bugs.
 
2699
                        medium._remember_remote_is_before((2, 4))
 
2700
                        break
 
2701
                raise
1931
2702
            else:
1932
2703
                response_tuple, response_handler = response
1933
2704
                found_verb = True
1937
2708
        if response_tuple[0] != 'ok':
1938
2709
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1939
2710
        byte_stream = response_handler.read_streamed_body()
1940
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
2711
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
2712
            self._record_counter)
1941
2713
        if src_format.network_name() != repo._format.network_name():
1942
2714
            raise AssertionError(
1943
2715
                "Mismatched RemoteRepository and stream src %r, %r" % (
2015
2787
 
2016
2788
    def _ensure_real(self):
2017
2789
        if self._custom_format is None:
2018
 
            self._custom_format = branch.network_format_registry.get(
2019
 
                self._network_name)
 
2790
            try:
 
2791
                self._custom_format = branch.network_format_registry.get(
 
2792
                    self._network_name)
 
2793
            except KeyError:
 
2794
                raise errors.UnknownFormatError(kind='branch',
 
2795
                    format=self._network_name)
2020
2796
 
2021
2797
    def get_format_description(self):
2022
2798
        self._ensure_real()
2025
2801
    def network_name(self):
2026
2802
        return self._network_name
2027
2803
 
2028
 
    def open(self, a_bzrdir, ignore_fallbacks=False):
2029
 
        return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
 
2804
    def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
 
2805
        return a_bzrdir.open_branch(name=name, 
 
2806
            ignore_fallbacks=ignore_fallbacks)
2030
2807
 
2031
 
    def _vfs_initialize(self, a_bzrdir):
 
2808
    def _vfs_initialize(self, a_bzrdir, name, append_revisions_only):
2032
2809
        # Initialisation when using a local bzrdir object, or a non-vfs init
2033
2810
        # method is not available on the server.
2034
2811
        # self._custom_format is always set - the start of initialize ensures
2035
2812
        # that.
2036
2813
        if isinstance(a_bzrdir, RemoteBzrDir):
2037
2814
            a_bzrdir._ensure_real()
2038
 
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
 
2815
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
 
2816
                name, append_revisions_only=append_revisions_only)
2039
2817
        else:
2040
2818
            # We assume the bzrdir is parameterised; it may not be.
2041
 
            result = self._custom_format.initialize(a_bzrdir)
 
2819
            result = self._custom_format.initialize(a_bzrdir, name,
 
2820
                append_revisions_only=append_revisions_only)
2042
2821
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2043
2822
            not isinstance(result, RemoteBranch)):
2044
 
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
 
2823
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
 
2824
                                  name=name)
2045
2825
        return result
2046
2826
 
2047
 
    def initialize(self, a_bzrdir):
 
2827
    def initialize(self, a_bzrdir, name=None, repository=None,
 
2828
                   append_revisions_only=None):
2048
2829
        # 1) get the network name to use.
2049
2830
        if self._custom_format:
2050
2831
            network_name = self._custom_format.network_name()
2051
2832
        else:
2052
2833
            # Select the current bzrlib default and ask for that.
2053
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
2834
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
2054
2835
            reference_format = reference_bzrdir_format.get_branch_format()
2055
2836
            self._custom_format = reference_format
2056
2837
            network_name = reference_format.network_name()
2057
2838
        # Being asked to create on a non RemoteBzrDir:
2058
2839
        if not isinstance(a_bzrdir, RemoteBzrDir):
2059
 
            return self._vfs_initialize(a_bzrdir)
 
2840
            return self._vfs_initialize(a_bzrdir, name=name,
 
2841
                append_revisions_only=append_revisions_only)
2060
2842
        medium = a_bzrdir._client._medium
2061
2843
        if medium._is_remote_before((1, 13)):
2062
 
            return self._vfs_initialize(a_bzrdir)
 
2844
            return self._vfs_initialize(a_bzrdir, name=name,
 
2845
                append_revisions_only=append_revisions_only)
2063
2846
        # Creating on a remote bzr dir.
2064
2847
        # 2) try direct creation via RPC
2065
2848
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
 
2849
        if name is not None:
 
2850
            # XXX JRV20100304: Support creating colocated branches
 
2851
            raise errors.NoColocatedBranchSupport(self)
2066
2852
        verb = 'BzrDir.create_branch'
2067
2853
        try:
2068
2854
            response = a_bzrdir._call(verb, path, network_name)
2069
2855
        except errors.UnknownSmartMethod:
2070
2856
            # Fallback - use vfs methods
2071
2857
            medium._remember_remote_is_before((1, 13))
2072
 
            return self._vfs_initialize(a_bzrdir)
 
2858
            return self._vfs_initialize(a_bzrdir, name=name,
 
2859
                    append_revisions_only=append_revisions_only)
2073
2860
        if response[0] != 'ok':
2074
2861
            raise errors.UnexpectedSmartServerResponse(response)
2075
2862
        # Turn the response into a RemoteRepository object.
2076
2863
        format = RemoteBranchFormat(network_name=response[1])
2077
2864
        repo_format = response_tuple_to_repo_format(response[3:])
2078
 
        if response[2] == '':
2079
 
            repo_bzrdir = a_bzrdir
 
2865
        repo_path = response[2]
 
2866
        if repository is not None:
 
2867
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
 
2868
            url_diff = urlutils.relative_url(repository.user_url,
 
2869
                    remote_repo_url)
 
2870
            if url_diff != '.':
 
2871
                raise AssertionError(
 
2872
                    'repository.user_url %r does not match URL from server '
 
2873
                    'response (%r + %r)'
 
2874
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
 
2875
            remote_repo = repository
2080
2876
        else:
2081
 
            repo_bzrdir = RemoteBzrDir(
2082
 
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2083
 
                a_bzrdir._client)
2084
 
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
2877
            if repo_path == '':
 
2878
                repo_bzrdir = a_bzrdir
 
2879
            else:
 
2880
                repo_bzrdir = RemoteBzrDir(
 
2881
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
2882
                    a_bzrdir._client)
 
2883
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2085
2884
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2086
 
            format=format, setup_stacking=False)
 
2885
            format=format, setup_stacking=False, name=name)
 
2886
        if append_revisions_only:
 
2887
            remote_branch.set_append_revisions_only(append_revisions_only)
2087
2888
        # XXX: We know this is a new branch, so it must have revno 0, revid
2088
2889
        # NULL_REVISION. Creating the branch locked would make this be unable
2089
2890
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2108
2909
        self._ensure_real()
2109
2910
        return self._custom_format.supports_set_append_revisions_only()
2110
2911
 
 
2912
    def _use_default_local_heads_to_fetch(self):
 
2913
        # If the branch format is a metadir format *and* its heads_to_fetch
 
2914
        # implementation is not overridden vs the base class, we can use the
 
2915
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
2916
        # usually cheaper in terms of net round trips, as the last-revision and
 
2917
        # tags info fetched is cached and would be fetched anyway.
 
2918
        self._ensure_real()
 
2919
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
2920
            branch_class = self._custom_format._branch_class()
 
2921
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
2922
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
2923
                return True
 
2924
        return False
 
2925
 
 
2926
 
 
2927
class RemoteBranchStore(config.IniFileStore):
 
2928
    """Branch store which attempts to use HPSS calls to retrieve branch store.
 
2929
 
 
2930
    Note that this is specific to bzr-based formats.
 
2931
    """
 
2932
 
 
2933
    def __init__(self, branch):
 
2934
        super(RemoteBranchStore, self).__init__()
 
2935
        self.branch = branch
 
2936
        self.id = "branch"
 
2937
        self._real_store = None
 
2938
 
 
2939
    def lock_write(self, token=None):
 
2940
        return self.branch.lock_write(token)
 
2941
 
 
2942
    def unlock(self):
 
2943
        return self.branch.unlock()
 
2944
 
 
2945
    @needs_write_lock
 
2946
    def save(self):
 
2947
        # We need to be able to override the undecorated implementation
 
2948
        self.save_without_locking()
 
2949
 
 
2950
    def save_without_locking(self):
 
2951
        super(RemoteBranchStore, self).save()
 
2952
 
 
2953
    def external_url(self):
 
2954
        return self.branch.user_url
 
2955
 
 
2956
    def _load_content(self):
 
2957
        path = self.branch._remote_path()
 
2958
        try:
 
2959
            response, handler = self.branch._call_expecting_body(
 
2960
                'Branch.get_config_file', path)
 
2961
        except errors.UnknownSmartMethod:
 
2962
            self._ensure_real()
 
2963
            return self._real_store._load_content()
 
2964
        if len(response) and response[0] != 'ok':
 
2965
            raise errors.UnexpectedSmartServerResponse(response)
 
2966
        return handler.read_body_bytes()
 
2967
 
 
2968
    def _save_content(self, content):
 
2969
        path = self.branch._remote_path()
 
2970
        try:
 
2971
            response, handler = self.branch._call_with_body_bytes_expecting_body(
 
2972
                'Branch.put_config_file', (path,
 
2973
                    self.branch._lock_token, self.branch._repo_lock_token),
 
2974
                content)
 
2975
        except errors.UnknownSmartMethod:
 
2976
            self._ensure_real()
 
2977
            return self._real_store._save_content(content)
 
2978
        handler.cancel_read_body()
 
2979
        if response != ('ok', ):
 
2980
            raise errors.UnexpectedSmartServerResponse(response)
 
2981
 
 
2982
    def _ensure_real(self):
 
2983
        self.branch._ensure_real()
 
2984
        if self._real_store is None:
 
2985
            self._real_store = config.BranchStore(self.branch)
 
2986
 
2111
2987
 
2112
2988
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2113
2989
    """Branch stored on a server accessed by HPSS RPC.
2116
2992
    """
2117
2993
 
2118
2994
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2119
 
        _client=None, format=None, setup_stacking=True):
 
2995
        _client=None, format=None, setup_stacking=True, name=None,
 
2996
        possible_transports=None):
2120
2997
        """Create a RemoteBranch instance.
2121
2998
 
2122
2999
        :param real_branch: An optional local implementation of the branch
2128
3005
        :param setup_stacking: If True make an RPC call to determine the
2129
3006
            stacked (or not) status of the branch. If False assume the branch
2130
3007
            is not stacked.
 
3008
        :param name: Colocated branch name
2131
3009
        """
2132
3010
        # We intentionally don't call the parent class's __init__, because it
2133
3011
        # will try to assign to self.tags, which is a property in this subclass.
2152
3030
            self._real_branch = None
2153
3031
        # Fill out expected attributes of branch for bzrlib API users.
2154
3032
        self._clear_cached_state()
2155
 
        self.base = self.bzrdir.root_transport.base
 
3033
        # TODO: deprecate self.base in favor of user_url
 
3034
        self.base = self.bzrdir.user_url
 
3035
        self._name = name
2156
3036
        self._control_files = None
2157
3037
        self._lock_mode = None
2158
3038
        self._lock_token = None
2184
3064
            hook(self)
2185
3065
        self._is_stacked = False
2186
3066
        if setup_stacking:
2187
 
            self._setup_stacking()
 
3067
            self._setup_stacking(possible_transports)
2188
3068
 
2189
 
    def _setup_stacking(self):
 
3069
    def _setup_stacking(self, possible_transports):
2190
3070
        # configure stacking into the remote repository, by reading it from
2191
3071
        # the vfs branch.
2192
3072
        try:
2195
3075
            errors.UnstackableRepositoryFormat), e:
2196
3076
            return
2197
3077
        self._is_stacked = True
2198
 
        self._activate_fallback_location(fallback_url)
 
3078
        if possible_transports is None:
 
3079
            possible_transports = []
 
3080
        else:
 
3081
            possible_transports = list(possible_transports)
 
3082
        possible_transports.append(self.bzrdir.root_transport)
 
3083
        self._activate_fallback_location(fallback_url,
 
3084
            possible_transports=possible_transports)
2199
3085
 
2200
3086
    def _get_config(self):
2201
3087
        return RemoteBranchConfig(self)
2202
3088
 
 
3089
    def _get_config_store(self):
 
3090
        return RemoteBranchStore(self)
 
3091
 
2203
3092
    def _get_real_transport(self):
2204
3093
        # if we try vfs access, return the real branch's vfs transport
2205
3094
        self._ensure_real()
2223
3112
                    'to use vfs implementation')
2224
3113
            self.bzrdir._ensure_real()
2225
3114
            self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2226
 
                ignore_fallbacks=self._real_ignore_fallbacks)
 
3115
                ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
2227
3116
            if self.repository._real_repository is None:
2228
3117
                # Give the remote repository the matching real repo.
2229
3118
                real_repo = self._real_branch.repository
2268
3157
                self.bzrdir, self._client)
2269
3158
        return self._control_files
2270
3159
 
2271
 
    def _get_checkout_format(self):
 
3160
    def _get_checkout_format(self, lightweight=False):
2272
3161
        self._ensure_real()
2273
 
        return self._real_branch._get_checkout_format()
 
3162
        if lightweight:
 
3163
            format = RemoteBzrDirFormat()
 
3164
            self.bzrdir._format._supply_sub_formats_to(format)
 
3165
            format.workingtree_format = self._real_branch._get_checkout_format(
 
3166
                lightweight=lightweight).workingtree_format
 
3167
            return format
 
3168
        else:
 
3169
            return self._real_branch._get_checkout_format(lightweight=False)
2274
3170
 
2275
3171
    def get_physical_lock_status(self):
2276
3172
        """See Branch.get_physical_lock_status()."""
2277
 
        # should be an API call to the server, as branches must be lockable.
2278
 
        self._ensure_real()
2279
 
        return self._real_branch.get_physical_lock_status()
 
3173
        try:
 
3174
            response = self._client.call('Branch.get_physical_lock_status',
 
3175
                self._remote_path())
 
3176
        except errors.UnknownSmartMethod:
 
3177
            self._ensure_real()
 
3178
            return self._real_branch.get_physical_lock_status()
 
3179
        if response[0] not in ('yes', 'no'):
 
3180
            raise errors.UnexpectedSmartServerResponse(response)
 
3181
        return (response[0] == 'yes')
2280
3182
 
2281
3183
    def get_stacked_on_url(self):
2282
3184
        """Get the URL this branch is stacked against.
2309
3211
            self._is_stacked = False
2310
3212
        else:
2311
3213
            self._is_stacked = True
2312
 
        
 
3214
 
2313
3215
    def _vfs_get_tags_bytes(self):
2314
3216
        self._ensure_real()
2315
3217
        return self._real_branch._get_tags_bytes()
2316
3218
 
 
3219
    @needs_read_lock
2317
3220
    def _get_tags_bytes(self):
 
3221
        if self._tags_bytes is None:
 
3222
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
3223
        return self._tags_bytes
 
3224
 
 
3225
    def _get_tags_bytes_via_hpss(self):
2318
3226
        medium = self._client._medium
2319
3227
        if medium._is_remote_before((1, 13)):
2320
3228
            return self._vfs_get_tags_bytes()
2330
3238
        return self._real_branch._set_tags_bytes(bytes)
2331
3239
 
2332
3240
    def _set_tags_bytes(self, bytes):
 
3241
        if self.is_locked():
 
3242
            self._tags_bytes = bytes
2333
3243
        medium = self._client._medium
2334
3244
        if medium._is_remote_before((1, 18)):
2335
3245
            self._vfs_set_tags_bytes(bytes)
2344
3254
            self._vfs_set_tags_bytes(bytes)
2345
3255
 
2346
3256
    def lock_read(self):
 
3257
        """Lock the branch for read operations.
 
3258
 
 
3259
        :return: A bzrlib.lock.LogicalLockResult.
 
3260
        """
2347
3261
        self.repository.lock_read()
2348
3262
        if not self._lock_mode:
2349
3263
            self._note_lock('r')
2353
3267
                self._real_branch.lock_read()
2354
3268
        else:
2355
3269
            self._lock_count += 1
 
3270
        return lock.LogicalLockResult(self.unlock)
2356
3271
 
2357
3272
    def _remote_lock_write(self, token):
2358
3273
        if token is None:
2359
3274
            branch_token = repo_token = ''
2360
3275
        else:
2361
3276
            branch_token = token
2362
 
            repo_token = self.repository.lock_write()
 
3277
            repo_token = self.repository.lock_write().repository_token
2363
3278
            self.repository.unlock()
2364
3279
        err_context = {'token': token}
2365
 
        response = self._call(
2366
 
            'Branch.lock_write', self._remote_path(), branch_token,
2367
 
            repo_token or '', **err_context)
 
3280
        try:
 
3281
            response = self._call(
 
3282
                'Branch.lock_write', self._remote_path(), branch_token,
 
3283
                repo_token or '', **err_context)
 
3284
        except errors.LockContention, e:
 
3285
            # The LockContention from the server doesn't have any
 
3286
            # information about the lock_url. We re-raise LockContention
 
3287
            # with valid lock_url.
 
3288
            raise errors.LockContention('(remote lock)',
 
3289
                self.repository.base.split('.bzr/')[0])
2368
3290
        if response[0] != 'ok':
2369
3291
            raise errors.UnexpectedSmartServerResponse(response)
2370
3292
        ok, branch_token, repo_token = response
2391
3313
            self._lock_mode = 'w'
2392
3314
            self._lock_count = 1
2393
3315
        elif self._lock_mode == 'r':
2394
 
            raise errors.ReadOnlyTransaction
 
3316
            raise errors.ReadOnlyError(self)
2395
3317
        else:
2396
3318
            if token is not None:
2397
3319
                # A token was given to lock_write, and we're relocking, so
2402
3324
            self._lock_count += 1
2403
3325
            # Re-lock the repository too.
2404
3326
            self.repository.lock_write(self._repo_lock_token)
2405
 
        return self._lock_token or None
 
3327
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
2406
3328
 
2407
3329
    def _unlock(self, branch_token, repo_token):
2408
3330
        err_context = {'token': str((branch_token, repo_token))}
2446
3368
            self.repository.unlock()
2447
3369
 
2448
3370
    def break_lock(self):
2449
 
        self._ensure_real()
2450
 
        return self._real_branch.break_lock()
 
3371
        try:
 
3372
            response = self._call(
 
3373
                'Branch.break_lock', self._remote_path())
 
3374
        except errors.UnknownSmartMethod:
 
3375
            self._ensure_real()
 
3376
            return self._real_branch.break_lock()
 
3377
        if response != ('ok',):
 
3378
            raise errors.UnexpectedSmartServerResponse(response)
2451
3379
 
2452
3380
    def leave_lock_in_place(self):
2453
3381
        if not self._lock_token:
2477
3405
            missing_parent = parent_map[missing_parent]
2478
3406
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2479
3407
 
2480
 
    def _last_revision_info(self):
 
3408
    def _read_last_revision_info(self):
2481
3409
        response = self._call('Branch.last_revision_info', self._remote_path())
2482
3410
        if response[0] != 'ok':
2483
3411
            raise SmartProtocolError('unexpected response code %s' % (response,))
2546
3474
            raise errors.UnexpectedSmartServerResponse(response)
2547
3475
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2548
3476
 
 
3477
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2549
3478
    @needs_write_lock
2550
3479
    def set_revision_history(self, rev_history):
 
3480
        """See Branch.set_revision_history."""
 
3481
        self._set_revision_history(rev_history)
 
3482
 
 
3483
    @needs_write_lock
 
3484
    def _set_revision_history(self, rev_history):
2551
3485
        # Send just the tip revision of the history; the server will generate
2552
3486
        # the full history from that.  If the revision doesn't exist in this
2553
3487
        # branch, NoSuchRevision will be raised.
2611
3545
            _override_hook_target=self, **kwargs)
2612
3546
 
2613
3547
    @needs_read_lock
2614
 
    def push(self, target, overwrite=False, stop_revision=None):
 
3548
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2615
3549
        self._ensure_real()
2616
3550
        return self._real_branch.push(
2617
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
3551
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2618
3552
            _override_hook_source_branch=self)
2619
3553
 
2620
3554
    def is_locked(self):
2621
3555
        return self._lock_count >= 1
2622
3556
 
2623
3557
    @needs_read_lock
 
3558
    def revision_id_to_dotted_revno(self, revision_id):
 
3559
        """Given a revision id, return its dotted revno.
 
3560
 
 
3561
        :return: a tuple like (1,) or (400,1,3).
 
3562
        """
 
3563
        try:
 
3564
            response = self._call('Branch.revision_id_to_revno',
 
3565
                self._remote_path(), revision_id)
 
3566
        except errors.UnknownSmartMethod:
 
3567
            self._ensure_real()
 
3568
            return self._real_branch.revision_id_to_dotted_revno(revision_id)
 
3569
        if response[0] == 'ok':
 
3570
            return tuple([int(x) for x in response[1:]])
 
3571
        else:
 
3572
            raise errors.UnexpectedSmartServerResponse(response)
 
3573
 
 
3574
    @needs_read_lock
2624
3575
    def revision_id_to_revno(self, revision_id):
2625
 
        self._ensure_real()
2626
 
        return self._real_branch.revision_id_to_revno(revision_id)
 
3576
        """Given a revision id on the branch mainline, return its revno.
 
3577
 
 
3578
        :return: an integer
 
3579
        """
 
3580
        try:
 
3581
            response = self._call('Branch.revision_id_to_revno',
 
3582
                self._remote_path(), revision_id)
 
3583
        except errors.UnknownSmartMethod:
 
3584
            self._ensure_real()
 
3585
            return self._real_branch.revision_id_to_revno(revision_id)
 
3586
        if response[0] == 'ok':
 
3587
            if len(response) == 2:
 
3588
                return int(response[1])
 
3589
            raise NoSuchRevision(self, revision_id)
 
3590
        else:
 
3591
            raise errors.UnexpectedSmartServerResponse(response)
2627
3592
 
2628
3593
    @needs_write_lock
2629
3594
    def set_last_revision_info(self, revno, revision_id):
2630
3595
        # XXX: These should be returned by the set_last_revision_info verb
2631
3596
        old_revno, old_revid = self.last_revision_info()
2632
3597
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2633
 
        revision_id = ensure_null(revision_id)
 
3598
        if not revision_id or not isinstance(revision_id, basestring):
 
3599
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2634
3600
        try:
2635
3601
            response = self._call('Branch.set_last_revision_info',
2636
3602
                self._remote_path(), self._lock_token, self._repo_lock_token,
2665
3631
            except errors.UnknownSmartMethod:
2666
3632
                medium._remember_remote_is_before((1, 6))
2667
3633
        self._clear_cached_state_of_remote_branch_only()
2668
 
        self.set_revision_history(self._lefthand_history(revision_id,
 
3634
        self._set_revision_history(self._lefthand_history(revision_id,
2669
3635
            last_rev=last_rev,other_branch=other_branch))
2670
3636
 
2671
3637
    def set_push_location(self, location):
2672
3638
        self._ensure_real()
2673
3639
        return self._real_branch.set_push_location(location)
2674
3640
 
 
3641
    def heads_to_fetch(self):
 
3642
        if self._format._use_default_local_heads_to_fetch():
 
3643
            # We recognise this format, and its heads-to-fetch implementation
 
3644
            # is the default one (tip + tags).  In this case it's cheaper to
 
3645
            # just use the default implementation rather than a special RPC as
 
3646
            # the tip and tags data is cached.
 
3647
            return branch.Branch.heads_to_fetch(self)
 
3648
        medium = self._client._medium
 
3649
        if medium._is_remote_before((2, 4)):
 
3650
            return self._vfs_heads_to_fetch()
 
3651
        try:
 
3652
            return self._rpc_heads_to_fetch()
 
3653
        except errors.UnknownSmartMethod:
 
3654
            medium._remember_remote_is_before((2, 4))
 
3655
            return self._vfs_heads_to_fetch()
 
3656
 
 
3657
    def _rpc_heads_to_fetch(self):
 
3658
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3659
        if len(response) != 2:
 
3660
            raise errors.UnexpectedSmartServerResponse(response)
 
3661
        must_fetch, if_present_fetch = response
 
3662
        return set(must_fetch), set(if_present_fetch)
 
3663
 
 
3664
    def _vfs_heads_to_fetch(self):
 
3665
        self._ensure_real()
 
3666
        return self._real_branch.heads_to_fetch()
 
3667
 
2675
3668
 
2676
3669
class RemoteConfig(object):
2677
3670
    """A Config that reads and writes from smart verbs.
2691
3684
        """
2692
3685
        try:
2693
3686
            configobj = self._get_configobj()
 
3687
            section_obj = None
2694
3688
            if section is None:
2695
3689
                section_obj = configobj
2696
3690
            else:
2697
3691
                try:
2698
3692
                    section_obj = configobj[section]
2699
3693
                except KeyError:
2700
 
                    return default
2701
 
            return section_obj.get(name, default)
 
3694
                    pass
 
3695
            if section_obj is None:
 
3696
                value = default
 
3697
            else:
 
3698
                value = section_obj.get(name, default)
2702
3699
        except errors.UnknownSmartMethod:
2703
 
            return self._vfs_get_option(name, section, default)
 
3700
            value = self._vfs_get_option(name, section, default)
 
3701
        for hook in config.OldConfigHooks['get']:
 
3702
            hook(self, name, value)
 
3703
        return value
2704
3704
 
2705
3705
    def _response_to_configobj(self, response):
2706
3706
        if len(response[0]) and response[0][0] != 'ok':
2707
3707
            raise errors.UnexpectedSmartServerResponse(response)
2708
3708
        lines = response[1].read_body_bytes().splitlines()
2709
 
        return config.ConfigObj(lines, encoding='utf-8')
 
3709
        conf = config.ConfigObj(lines, encoding='utf-8')
 
3710
        for hook in config.OldConfigHooks['load']:
 
3711
            hook(self)
 
3712
        return conf
2710
3713
 
2711
3714
 
2712
3715
class RemoteBranchConfig(RemoteConfig):
2731
3734
        medium = self._branch._client._medium
2732
3735
        if medium._is_remote_before((1, 14)):
2733
3736
            return self._vfs_set_option(value, name, section)
 
3737
        if isinstance(value, dict):
 
3738
            if medium._is_remote_before((2, 2)):
 
3739
                return self._vfs_set_option(value, name, section)
 
3740
            return self._set_config_option_dict(value, name, section)
 
3741
        else:
 
3742
            return self._set_config_option(value, name, section)
 
3743
 
 
3744
    def _set_config_option(self, value, name, section):
2734
3745
        try:
2735
3746
            path = self._branch._remote_path()
2736
3747
            response = self._branch._client.call('Branch.set_config_option',
2737
3748
                path, self._branch._lock_token, self._branch._repo_lock_token,
2738
3749
                value.encode('utf8'), name, section or '')
2739
3750
        except errors.UnknownSmartMethod:
 
3751
            medium = self._branch._client._medium
2740
3752
            medium._remember_remote_is_before((1, 14))
2741
3753
            return self._vfs_set_option(value, name, section)
2742
3754
        if response != ():
2743
3755
            raise errors.UnexpectedSmartServerResponse(response)
2744
3756
 
 
3757
    def _serialize_option_dict(self, option_dict):
 
3758
        utf8_dict = {}
 
3759
        for key, value in option_dict.items():
 
3760
            if isinstance(key, unicode):
 
3761
                key = key.encode('utf8')
 
3762
            if isinstance(value, unicode):
 
3763
                value = value.encode('utf8')
 
3764
            utf8_dict[key] = value
 
3765
        return bencode.bencode(utf8_dict)
 
3766
 
 
3767
    def _set_config_option_dict(self, value, name, section):
 
3768
        try:
 
3769
            path = self._branch._remote_path()
 
3770
            serialised_dict = self._serialize_option_dict(value)
 
3771
            response = self._branch._client.call(
 
3772
                'Branch.set_config_option_dict',
 
3773
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
3774
                serialised_dict, name, section or '')
 
3775
        except errors.UnknownSmartMethod:
 
3776
            medium = self._branch._client._medium
 
3777
            medium._remember_remote_is_before((2, 2))
 
3778
            return self._vfs_set_option(value, name, section)
 
3779
        if response != ():
 
3780
            raise errors.UnexpectedSmartServerResponse(response)
 
3781
 
2745
3782
    def _real_object(self):
2746
3783
        self._branch._ensure_real()
2747
3784
        return self._branch._real_branch
2786
3823
        return self._bzrdir._real_bzrdir
2787
3824
 
2788
3825
 
2789
 
 
2790
3826
def _extract_tar(tar, to_dir):
2791
3827
    """Extract all the contents of a tarfile object.
2792
3828
 
2796
3832
        tar.extract(tarinfo, to_dir)
2797
3833
 
2798
3834
 
 
3835
error_translators = registry.Registry()
 
3836
no_context_error_translators = registry.Registry()
 
3837
 
 
3838
 
2799
3839
def _translate_error(err, **context):
2800
3840
    """Translate an ErrorFromSmartServer into a more useful error.
2801
3841
 
2830
3870
                    'Missing key %r in context %r', key_err.args[0], context)
2831
3871
                raise err
2832
3872
 
2833
 
    if err.error_verb == 'IncompatibleRepositories':
2834
 
        raise errors.IncompatibleRepositories(err.error_args[0],
2835
 
            err.error_args[1], err.error_args[2])
2836
 
    elif err.error_verb == 'NoSuchRevision':
2837
 
        raise NoSuchRevision(find('branch'), err.error_args[0])
2838
 
    elif err.error_verb == 'nosuchrevision':
2839
 
        raise NoSuchRevision(find('repository'), err.error_args[0])
2840
 
    elif err.error_verb == 'nobranch':
2841
 
        if len(err.error_args) >= 1:
2842
 
            extra = err.error_args[0]
2843
 
        else:
2844
 
            extra = None
2845
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
2846
 
            detail=extra)
2847
 
    elif err.error_verb == 'norepository':
2848
 
        raise errors.NoRepositoryPresent(find('bzrdir'))
2849
 
    elif err.error_verb == 'LockContention':
2850
 
        raise errors.LockContention('(remote lock)')
2851
 
    elif err.error_verb == 'UnlockableTransport':
2852
 
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
2853
 
    elif err.error_verb == 'LockFailed':
2854
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
2855
 
    elif err.error_verb == 'TokenMismatch':
2856
 
        raise errors.TokenMismatch(find('token'), '(remote token)')
2857
 
    elif err.error_verb == 'Diverged':
2858
 
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
2859
 
    elif err.error_verb == 'TipChangeRejected':
2860
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2861
 
    elif err.error_verb == 'UnstackableBranchFormat':
2862
 
        raise errors.UnstackableBranchFormat(*err.error_args)
2863
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
2864
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2865
 
    elif err.error_verb == 'NotStacked':
2866
 
        raise errors.NotStacked(branch=find('branch'))
2867
 
    elif err.error_verb == 'PermissionDenied':
2868
 
        path = get_path()
2869
 
        if len(err.error_args) >= 2:
2870
 
            extra = err.error_args[1]
2871
 
        else:
2872
 
            extra = None
2873
 
        raise errors.PermissionDenied(path, extra=extra)
2874
 
    elif err.error_verb == 'ReadError':
2875
 
        path = get_path()
2876
 
        raise errors.ReadError(path)
2877
 
    elif err.error_verb == 'NoSuchFile':
2878
 
        path = get_path()
2879
 
        raise errors.NoSuchFile(path)
2880
 
    elif err.error_verb == 'FileExists':
2881
 
        raise errors.FileExists(err.error_args[0])
2882
 
    elif err.error_verb == 'DirectoryNotEmpty':
2883
 
        raise errors.DirectoryNotEmpty(err.error_args[0])
2884
 
    elif err.error_verb == 'ShortReadvError':
2885
 
        args = err.error_args
2886
 
        raise errors.ShortReadvError(
2887
 
            args[0], int(args[1]), int(args[2]), int(args[3]))
2888
 
    elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
 
3873
    try:
 
3874
        translator = error_translators.get(err.error_verb)
 
3875
    except KeyError:
 
3876
        pass
 
3877
    else:
 
3878
        raise translator(err, find, get_path)
 
3879
    try:
 
3880
        translator = no_context_error_translators.get(err.error_verb)
 
3881
    except KeyError:
 
3882
        raise errors.UnknownErrorFromSmartServer(err)
 
3883
    else:
 
3884
        raise translator(err)
 
3885
 
 
3886
 
 
3887
error_translators.register('NoSuchRevision',
 
3888
    lambda err, find, get_path: NoSuchRevision(
 
3889
        find('branch'), err.error_args[0]))
 
3890
error_translators.register('nosuchrevision',
 
3891
    lambda err, find, get_path: NoSuchRevision(
 
3892
        find('repository'), err.error_args[0]))
 
3893
 
 
3894
def _translate_nobranch_error(err, find, get_path):
 
3895
    if len(err.error_args) >= 1:
 
3896
        extra = err.error_args[0]
 
3897
    else:
 
3898
        extra = None
 
3899
    return errors.NotBranchError(path=find('bzrdir').root_transport.base,
 
3900
        detail=extra)
 
3901
 
 
3902
error_translators.register('nobranch', _translate_nobranch_error)
 
3903
error_translators.register('norepository',
 
3904
    lambda err, find, get_path: errors.NoRepositoryPresent(
 
3905
        find('bzrdir')))
 
3906
error_translators.register('UnlockableTransport',
 
3907
    lambda err, find, get_path: errors.UnlockableTransport(
 
3908
        find('bzrdir').root_transport))
 
3909
error_translators.register('TokenMismatch',
 
3910
    lambda err, find, get_path: errors.TokenMismatch(
 
3911
        find('token'), '(remote token)'))
 
3912
error_translators.register('Diverged',
 
3913
    lambda err, find, get_path: errors.DivergedBranches(
 
3914
        find('branch'), find('other_branch')))
 
3915
error_translators.register('NotStacked',
 
3916
    lambda err, find, get_path: errors.NotStacked(branch=find('branch')))
 
3917
 
 
3918
def _translate_PermissionDenied(err, find, get_path):
 
3919
    path = get_path()
 
3920
    if len(err.error_args) >= 2:
 
3921
        extra = err.error_args[1]
 
3922
    else:
 
3923
        extra = None
 
3924
    return errors.PermissionDenied(path, extra=extra)
 
3925
 
 
3926
error_translators.register('PermissionDenied', _translate_PermissionDenied)
 
3927
error_translators.register('ReadError',
 
3928
    lambda err, find, get_path: errors.ReadError(get_path()))
 
3929
error_translators.register('NoSuchFile',
 
3930
    lambda err, find, get_path: errors.NoSuchFile(get_path()))
 
3931
error_translators.register('UnsuspendableWriteGroup',
 
3932
    lambda err, find, get_path: errors.UnsuspendableWriteGroup(
 
3933
        repository=find('repository')))
 
3934
error_translators.register('UnresumableWriteGroup',
 
3935
    lambda err, find, get_path: errors.UnresumableWriteGroup(
 
3936
        repository=find('repository'), write_groups=err.error_args[0],
 
3937
        reason=err.error_args[1]))
 
3938
no_context_error_translators.register('IncompatibleRepositories',
 
3939
    lambda err: errors.IncompatibleRepositories(
 
3940
        err.error_args[0], err.error_args[1], err.error_args[2]))
 
3941
no_context_error_translators.register('LockContention',
 
3942
    lambda err: errors.LockContention('(remote lock)'))
 
3943
no_context_error_translators.register('LockFailed',
 
3944
    lambda err: errors.LockFailed(err.error_args[0], err.error_args[1]))
 
3945
no_context_error_translators.register('TipChangeRejected',
 
3946
    lambda err: errors.TipChangeRejected(err.error_args[0].decode('utf8')))
 
3947
no_context_error_translators.register('UnstackableBranchFormat',
 
3948
    lambda err: errors.UnstackableBranchFormat(*err.error_args))
 
3949
no_context_error_translators.register('UnstackableRepositoryFormat',
 
3950
    lambda err: errors.UnstackableRepositoryFormat(*err.error_args))
 
3951
no_context_error_translators.register('FileExists',
 
3952
    lambda err: errors.FileExists(err.error_args[0]))
 
3953
no_context_error_translators.register('DirectoryNotEmpty',
 
3954
    lambda err: errors.DirectoryNotEmpty(err.error_args[0]))
 
3955
 
 
3956
def _translate_short_readv_error(err):
 
3957
    args = err.error_args
 
3958
    return errors.ShortReadvError(args[0], int(args[1]), int(args[2]),
 
3959
        int(args[3]))
 
3960
 
 
3961
no_context_error_translators.register('ShortReadvError',
 
3962
    _translate_short_readv_error)
 
3963
 
 
3964
def _translate_unicode_error(err):
2889
3965
        encoding = str(err.error_args[0]) # encoding must always be a string
2890
3966
        val = err.error_args[1]
2891
3967
        start = int(err.error_args[2])
2899
3975
            raise UnicodeDecodeError(encoding, val, start, end, reason)
2900
3976
        elif err.error_verb == 'UnicodeEncodeError':
2901
3977
            raise UnicodeEncodeError(encoding, val, start, end, reason)
2902
 
    elif err.error_verb == 'ReadOnlyError':
2903
 
        raise errors.TransportNotPossible('readonly transport')
2904
 
    raise errors.UnknownErrorFromSmartServer(err)
 
3978
 
 
3979
no_context_error_translators.register('UnicodeEncodeError',
 
3980
    _translate_unicode_error)
 
3981
no_context_error_translators.register('UnicodeDecodeError',
 
3982
    _translate_unicode_error)
 
3983
no_context_error_translators.register('ReadOnlyError',
 
3984
    lambda err: errors.TransportNotPossible('readonly transport'))
 
3985
no_context_error_translators.register('MemoryError',
 
3986
    lambda err: errors.BzrError("remote server out of memory\n"
 
3987
        "Retry non-remotely, or contact the server admin for details."))
 
3988
no_context_error_translators.register('RevisionNotPresent',
 
3989
    lambda err: errors.RevisionNotPresent(err.error_args[0], err.error_args[1]))
 
3990
 
 
3991
no_context_error_translators.register('BzrCheckError',
 
3992
    lambda err: errors.BzrCheckError(msg=err.error_args[0]))
 
3993