/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

(jelmer) Reduce the number of connections made during "bzr branch
 --stacked". (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
19
19
from bzrlib import (
20
20
    bencode,
21
21
    branch,
22
 
    bzrdir,
 
22
    bzrdir as _mod_bzrdir,
23
23
    config,
 
24
    controldir,
24
25
    debug,
25
26
    errors,
 
27
    gpg,
26
28
    graph,
27
29
    lock,
28
30
    lockdir,
29
 
    repository,
 
31
    registry,
30
32
    repository as _mod_repository,
31
 
    revision,
32
33
    revision as _mod_revision,
33
34
    static_tuple,
34
35
    symbol_versioning,
35
 
)
36
 
from bzrlib.branch import BranchReferenceFormat
37
 
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
 
36
    testament as _mod_testament,
 
37
    urlutils,
 
38
    vf_repository,
 
39
    )
 
40
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
38
41
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
39
42
from bzrlib.errors import (
40
43
    NoSuchRevision,
41
44
    SmartProtocolError,
42
45
    )
 
46
from bzrlib.i18n import gettext
 
47
from bzrlib.inventory import Inventory
43
48
from bzrlib.lockable_files import LockableFiles
44
49
from bzrlib.smart import client, vfs, repository as smart_repo
45
 
from bzrlib.revision import ensure_null, NULL_REVISION
46
 
from bzrlib.trace import mutter, note, warning
 
50
from bzrlib.smart.client import _SmartClient
 
51
from bzrlib.revision import NULL_REVISION
 
52
from bzrlib.revisiontree import InventoryRevisionTree
 
53
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
 
54
from bzrlib.trace import mutter, note, warning, log_exception_quietly
 
55
 
 
56
 
 
57
_DEFAULT_SEARCH_DEPTH = 100
47
58
 
48
59
 
49
60
class _RpcHelper(object):
86
97
    return format
87
98
 
88
99
 
89
 
# Note: RemoteBzrDirFormat is in bzrdir.py
90
 
 
91
 
class RemoteBzrDir(BzrDir, _RpcHelper):
 
100
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
 
101
# does not have to be imported unless a remote format is involved.
 
102
 
 
103
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
 
104
    """Format representing bzrdirs accessed via a smart server"""
 
105
 
 
106
    supports_workingtrees = False
 
107
 
 
108
    def __init__(self):
 
109
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
 
110
        # XXX: It's a bit ugly that the network name is here, because we'd
 
111
        # like to believe that format objects are stateless or at least
 
112
        # immutable,  However, we do at least avoid mutating the name after
 
113
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
 
114
        self._network_name = None
 
115
 
 
116
    def __repr__(self):
 
117
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
118
            self._network_name)
 
119
 
 
120
    def get_format_description(self):
 
121
        if self._network_name:
 
122
            real_format = controldir.network_format_registry.get(self._network_name)
 
123
            return 'Remote: ' + real_format.get_format_description()
 
124
        return 'bzr remote bzrdir'
 
125
 
 
126
    def get_format_string(self):
 
127
        raise NotImplementedError(self.get_format_string)
 
128
 
 
129
    def network_name(self):
 
130
        if self._network_name:
 
131
            return self._network_name
 
132
        else:
 
133
            raise AssertionError("No network name set.")
 
134
 
 
135
    def initialize_on_transport(self, transport):
 
136
        try:
 
137
            # hand off the request to the smart server
 
138
            client_medium = transport.get_smart_medium()
 
139
        except errors.NoSmartMedium:
 
140
            # TODO: lookup the local format from a server hint.
 
141
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
142
            return local_dir_format.initialize_on_transport(transport)
 
143
        client = _SmartClient(client_medium)
 
144
        path = client.remote_path_from_transport(transport)
 
145
        try:
 
146
            response = client.call('BzrDirFormat.initialize', path)
 
147
        except errors.ErrorFromSmartServer, err:
 
148
            _translate_error(err, path=path)
 
149
        if response[0] != 'ok':
 
150
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
 
151
        format = RemoteBzrDirFormat()
 
152
        self._supply_sub_formats_to(format)
 
153
        return RemoteBzrDir(transport, format)
 
154
 
 
155
    def parse_NoneTrueFalse(self, arg):
 
156
        if not arg:
 
157
            return None
 
158
        if arg == 'False':
 
159
            return False
 
160
        if arg == 'True':
 
161
            return True
 
162
        raise AssertionError("invalid arg %r" % arg)
 
163
 
 
164
    def _serialize_NoneTrueFalse(self, arg):
 
165
        if arg is False:
 
166
            return 'False'
 
167
        if arg:
 
168
            return 'True'
 
169
        return ''
 
170
 
 
171
    def _serialize_NoneString(self, arg):
 
172
        return arg or ''
 
173
 
 
174
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
175
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
176
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
177
        shared_repo=False):
 
178
        try:
 
179
            # hand off the request to the smart server
 
180
            client_medium = transport.get_smart_medium()
 
181
        except errors.NoSmartMedium:
 
182
            do_vfs = True
 
183
        else:
 
184
            # Decline to open it if the server doesn't support our required
 
185
            # version (3) so that the VFS-based transport will do it.
 
186
            if client_medium.should_probe():
 
187
                try:
 
188
                    server_version = client_medium.protocol_version()
 
189
                    if server_version != '2':
 
190
                        do_vfs = True
 
191
                    else:
 
192
                        do_vfs = False
 
193
                except errors.SmartProtocolError:
 
194
                    # Apparently there's no usable smart server there, even though
 
195
                    # the medium supports the smart protocol.
 
196
                    do_vfs = True
 
197
            else:
 
198
                do_vfs = False
 
199
        if not do_vfs:
 
200
            client = _SmartClient(client_medium)
 
201
            path = client.remote_path_from_transport(transport)
 
202
            if client_medium._is_remote_before((1, 16)):
 
203
                do_vfs = True
 
204
        if do_vfs:
 
205
            # TODO: lookup the local format from a server hint.
 
206
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
207
            self._supply_sub_formats_to(local_dir_format)
 
208
            return local_dir_format.initialize_on_transport_ex(transport,
 
209
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
210
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
211
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
212
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
213
                vfs_only=True)
 
214
        return self._initialize_on_transport_ex_rpc(client, path, transport,
 
215
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
216
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
 
217
 
 
218
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
 
219
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
220
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
 
221
        args = []
 
222
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
 
223
        args.append(self._serialize_NoneTrueFalse(create_prefix))
 
224
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
 
225
        args.append(self._serialize_NoneString(stacked_on))
 
226
        # stack_on_pwd is often/usually our transport
 
227
        if stack_on_pwd:
 
228
            try:
 
229
                stack_on_pwd = transport.relpath(stack_on_pwd)
 
230
                if not stack_on_pwd:
 
231
                    stack_on_pwd = '.'
 
232
            except errors.PathNotChild:
 
233
                pass
 
234
        args.append(self._serialize_NoneString(stack_on_pwd))
 
235
        args.append(self._serialize_NoneString(repo_format_name))
 
236
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
 
237
        args.append(self._serialize_NoneTrueFalse(shared_repo))
 
238
        request_network_name = self._network_name or \
 
239
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
 
240
        try:
 
241
            response = client.call('BzrDirFormat.initialize_ex_1.16',
 
242
                request_network_name, path, *args)
 
243
        except errors.UnknownSmartMethod:
 
244
            client._medium._remember_remote_is_before((1,16))
 
245
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
246
            self._supply_sub_formats_to(local_dir_format)
 
247
            return local_dir_format.initialize_on_transport_ex(transport,
 
248
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
249
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
250
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
251
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
252
                vfs_only=True)
 
253
        except errors.ErrorFromSmartServer, err:
 
254
            _translate_error(err, path=path)
 
255
        repo_path = response[0]
 
256
        bzrdir_name = response[6]
 
257
        require_stacking = response[7]
 
258
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
 
259
        format = RemoteBzrDirFormat()
 
260
        format._network_name = bzrdir_name
 
261
        self._supply_sub_formats_to(format)
 
262
        bzrdir = RemoteBzrDir(transport, format, _client=client)
 
263
        if repo_path:
 
264
            repo_format = response_tuple_to_repo_format(response[1:])
 
265
            if repo_path == '.':
 
266
                repo_path = ''
 
267
            if repo_path:
 
268
                repo_bzrdir_format = RemoteBzrDirFormat()
 
269
                repo_bzrdir_format._network_name = response[5]
 
270
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
 
271
                    repo_bzrdir_format)
 
272
            else:
 
273
                repo_bzr = bzrdir
 
274
            final_stack = response[8] or None
 
275
            final_stack_pwd = response[9] or None
 
276
            if final_stack_pwd:
 
277
                final_stack_pwd = urlutils.join(
 
278
                    transport.base, final_stack_pwd)
 
279
            remote_repo = RemoteRepository(repo_bzr, repo_format)
 
280
            if len(response) > 10:
 
281
                # Updated server verb that locks remotely.
 
282
                repo_lock_token = response[10] or None
 
283
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
 
284
                if repo_lock_token:
 
285
                    remote_repo.dont_leave_lock_in_place()
 
286
            else:
 
287
                remote_repo.lock_write()
 
288
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
 
289
                final_stack_pwd, require_stacking)
 
290
            policy.acquire_repository()
 
291
        else:
 
292
            remote_repo = None
 
293
            policy = None
 
294
        bzrdir._format.set_branch_format(self.get_branch_format())
 
295
        if require_stacking:
 
296
            # The repo has already been created, but we need to make sure that
 
297
            # we'll make a stackable branch.
 
298
            bzrdir._format.require_stacking(_skip_repo=True)
 
299
        return remote_repo, bzrdir, require_stacking, policy
 
300
 
 
301
    def _open(self, transport):
 
302
        return RemoteBzrDir(transport, self)
 
303
 
 
304
    def __eq__(self, other):
 
305
        if not isinstance(other, RemoteBzrDirFormat):
 
306
            return False
 
307
        return self.get_format_description() == other.get_format_description()
 
308
 
 
309
    def __return_repository_format(self):
 
310
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
 
311
        # repository format has been asked for, tell the RemoteRepositoryFormat
 
312
        # that it should use that for init() etc.
 
313
        result = RemoteRepositoryFormat()
 
314
        custom_format = getattr(self, '_repository_format', None)
 
315
        if custom_format:
 
316
            if isinstance(custom_format, RemoteRepositoryFormat):
 
317
                return custom_format
 
318
            else:
 
319
                # We will use the custom format to create repositories over the
 
320
                # wire; expose its details like rich_root_data for code to
 
321
                # query
 
322
                result._custom_format = custom_format
 
323
        return result
 
324
 
 
325
    def get_branch_format(self):
 
326
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
 
327
        if not isinstance(result, RemoteBranchFormat):
 
328
            new_result = RemoteBranchFormat()
 
329
            new_result._custom_format = result
 
330
            # cache the result
 
331
            self.set_branch_format(new_result)
 
332
            result = new_result
 
333
        return result
 
334
 
 
335
    repository_format = property(__return_repository_format,
 
336
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
 
337
 
 
338
 
 
339
class RemoteControlStore(config.IniFileStore):
 
340
    """Control store which attempts to use HPSS calls to retrieve control store.
 
341
 
 
342
    Note that this is specific to bzr-based formats.
 
343
    """
 
344
 
 
345
    def __init__(self, bzrdir):
 
346
        super(RemoteControlStore, self).__init__()
 
347
        self.bzrdir = bzrdir
 
348
        self._real_store = None
 
349
 
 
350
    def lock_write(self, token=None):
 
351
        self._ensure_real()
 
352
        return self._real_store.lock_write(token)
 
353
 
 
354
    def unlock(self):
 
355
        self._ensure_real()
 
356
        return self._real_store.unlock()
 
357
 
 
358
    @needs_write_lock
 
359
    def save(self):
 
360
        # We need to be able to override the undecorated implementation
 
361
        self.save_without_locking()
 
362
 
 
363
    def save_without_locking(self):
 
364
        super(RemoteControlStore, self).save()
 
365
 
 
366
    def _ensure_real(self):
 
367
        self.bzrdir._ensure_real()
 
368
        if self._real_store is None:
 
369
            self._real_store = config.ControlStore(self.bzrdir)
 
370
 
 
371
    def external_url(self):
 
372
        return self.bzrdir.user_url
 
373
 
 
374
    def _load_content(self):
 
375
        medium = self.bzrdir._client._medium
 
376
        path = self.bzrdir._path_for_remote_call(self.bzrdir._client)
 
377
        try:
 
378
            response, handler = self.bzrdir._call_expecting_body(
 
379
                'BzrDir.get_config_file', path)
 
380
        except errors.UnknownSmartMethod:
 
381
            self._ensure_real()
 
382
            return self._real_store._load_content()
 
383
        if len(response) and response[0] != 'ok':
 
384
            raise errors.UnexpectedSmartServerResponse(response)
 
385
        return handler.read_body_bytes()
 
386
 
 
387
    def _save_content(self, content):
 
388
        # FIXME JRV 2011-11-22: Ideally this should use a
 
389
        # HPSS call too, but at the moment it is not possible
 
390
        # to write lock control directories.
 
391
        self._ensure_real()
 
392
        return self._real_store._save_content(content)
 
393
 
 
394
 
 
395
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
92
396
    """Control directory on a remote server, accessed via bzr:// or similar."""
93
397
 
94
398
    def __init__(self, transport, format, _client=None, _force_probe=False):
97
401
        :param _client: Private parameter for testing. Disables probing and the
98
402
            use of a real bzrdir.
99
403
        """
100
 
        BzrDir.__init__(self, transport, format)
 
404
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
101
405
        # this object holds a delegated bzrdir that uses file-level operations
102
406
        # to talk to the other side
103
407
        self._real_bzrdir = None
163
467
                import traceback
164
468
                warning('VFS BzrDir access triggered\n%s',
165
469
                    ''.join(traceback.format_stack()))
166
 
            self._real_bzrdir = BzrDir.open_from_transport(
 
470
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
167
471
                self.root_transport, _server_formats=False)
168
472
            self._format._network_name = \
169
473
                self._real_bzrdir._format.network_name()
175
479
        # Prevent aliasing problems in the next_open_branch_result cache.
176
480
        # See create_branch for rationale.
177
481
        self._next_open_branch_result = None
178
 
        return BzrDir.break_lock(self)
 
482
        return _mod_bzrdir.BzrDir.break_lock(self)
179
483
 
180
484
    def _vfs_cloning_metadir(self, require_stacking=False):
181
485
        self._ensure_real()
212
516
        if len(branch_info) != 2:
213
517
            raise errors.UnexpectedSmartServerResponse(response)
214
518
        branch_ref, branch_name = branch_info
215
 
        format = bzrdir.network_format_registry.get(control_name)
 
519
        format = controldir.network_format_registry.get(control_name)
216
520
        if repo_name:
217
 
            format.repository_format = repository.network_format_registry.get(
 
521
            format.repository_format = _mod_repository.network_format_registry.get(
218
522
                repo_name)
219
523
        if branch_ref == 'ref':
220
524
            # XXX: we need possible_transports here to avoid reopening the
221
525
            # connection to the referenced location
222
 
            ref_bzrdir = BzrDir.open(branch_name)
 
526
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
223
527
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
224
528
            format.set_branch_format(branch_format)
225
529
        elif branch_ref == 'branch':
241
545
 
242
546
    def destroy_repository(self):
243
547
        """See BzrDir.destroy_repository"""
244
 
        self._ensure_real()
245
 
        self._real_bzrdir.destroy_repository()
 
548
        path = self._path_for_remote_call(self._client)
 
549
        try:
 
550
            response = self._call('BzrDir.destroy_repository', path)
 
551
        except errors.UnknownSmartMethod:
 
552
            self._ensure_real()
 
553
            self._real_bzrdir.destroy_repository()
 
554
            return
 
555
        if response[0] != 'ok':
 
556
            raise SmartProtocolError('unexpected response code %s' % (response,))
246
557
 
247
 
    def create_branch(self, name=None):
 
558
    def create_branch(self, name=None, repository=None,
 
559
                      append_revisions_only=None):
248
560
        # as per meta1 formats - just delegate to the format object which may
249
561
        # be parameterised.
250
562
        real_branch = self._format.get_branch_format().initialize(self,
251
 
            name=name)
 
563
            name=name, repository=repository,
 
564
            append_revisions_only=append_revisions_only)
252
565
        if not isinstance(real_branch, RemoteBranch):
253
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
254
 
                                  name=name)
 
566
            if not isinstance(repository, RemoteRepository):
 
567
                raise AssertionError(
 
568
                    'need a RemoteRepository to use with RemoteBranch, got %r'
 
569
                    % (repository,))
 
570
            result = RemoteBranch(self, repository, real_branch, name=name)
255
571
        else:
256
572
            result = real_branch
257
573
        # BzrDir.clone_on_transport() uses the result of create_branch but does
265
581
 
266
582
    def destroy_branch(self, name=None):
267
583
        """See BzrDir.destroy_branch"""
268
 
        self._ensure_real()
269
 
        self._real_bzrdir.destroy_branch(name=name)
 
584
        path = self._path_for_remote_call(self._client)
 
585
        try:
 
586
            if name is not None:
 
587
                args = (name, )
 
588
            else:
 
589
                args = ()
 
590
            response = self._call('BzrDir.destroy_branch', path, *args)
 
591
        except errors.UnknownSmartMethod:
 
592
            self._ensure_real()
 
593
            self._real_bzrdir.destroy_branch(name=name)
 
594
            self._next_open_branch_result = None
 
595
            return
270
596
        self._next_open_branch_result = None
 
597
        if response[0] != 'ok':
 
598
            raise SmartProtocolError('unexpected response code %s' % (response,))
271
599
 
272
 
    def create_workingtree(self, revision_id=None, from_branch=None):
 
600
    def create_workingtree(self, revision_id=None, from_branch=None,
 
601
        accelerator_tree=None, hardlink=False):
273
602
        raise errors.NotLocalUrl(self.transport.base)
274
603
 
275
 
    def find_branch_format(self):
 
604
    def find_branch_format(self, name=None):
276
605
        """Find the branch 'format' for this bzrdir.
277
606
 
278
607
        This might be a synthetic object for e.g. RemoteBranch and SVN.
279
608
        """
280
 
        b = self.open_branch()
 
609
        b = self.open_branch(name=name)
281
610
        return b._format
282
611
 
283
 
    def get_branch_reference(self):
 
612
    def get_branch_reference(self, name=None):
284
613
        """See BzrDir.get_branch_reference()."""
 
614
        if name is not None:
 
615
            # XXX JRV20100304: Support opening colocated branches
 
616
            raise errors.NoColocatedBranchSupport(self)
285
617
        response = self._get_branch_reference()
286
618
        if response[0] == 'ref':
287
619
            return response[1]
318
650
            raise errors.UnexpectedSmartServerResponse(response)
319
651
        return response
320
652
 
321
 
    def _get_tree_branch(self):
 
653
    def _get_tree_branch(self, name=None):
322
654
        """See BzrDir._get_tree_branch()."""
323
 
        return None, self.open_branch()
 
655
        return None, self.open_branch(name=name)
324
656
 
325
657
    def open_branch(self, name=None, unsupported=False,
326
 
                    ignore_fallbacks=False):
 
658
                    ignore_fallbacks=False, possible_transports=None):
327
659
        if unsupported:
328
660
            raise NotImplementedError('unsupported flag support not implemented yet.')
329
661
        if self._next_open_branch_result is not None:
336
668
            # a branch reference, use the existing BranchReference logic.
337
669
            format = BranchReferenceFormat()
338
670
            return format.open(self, name=name, _found=True,
339
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
 
671
                location=response[1], ignore_fallbacks=ignore_fallbacks,
 
672
                possible_transports=possible_transports)
340
673
        branch_format_name = response[1]
341
674
        if not branch_format_name:
342
675
            branch_format_name = None
343
676
        format = RemoteBranchFormat(network_name=branch_format_name)
344
677
        return RemoteBranch(self, self.find_repository(), format=format,
345
 
            setup_stacking=not ignore_fallbacks, name=name)
 
678
            setup_stacking=not ignore_fallbacks, name=name,
 
679
            possible_transports=possible_transports)
346
680
 
347
681
    def _open_repo_v1(self, path):
348
682
        verb = 'BzrDir.find_repository'
411
745
 
412
746
    def has_workingtree(self):
413
747
        if self._has_working_tree is None:
414
 
            self._ensure_real()
415
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
 
748
            path = self._path_for_remote_call(self._client)
 
749
            try:
 
750
                response = self._call('BzrDir.has_workingtree', path)
 
751
            except errors.UnknownSmartMethod:
 
752
                self._ensure_real()
 
753
                self._has_working_tree = self._real_bzrdir.has_workingtree()
 
754
            else:
 
755
                if response[0] not in ('yes', 'no'):
 
756
                    raise SmartProtocolError('unexpected response code %s' % (response,))
 
757
                self._has_working_tree = (response[0] == 'yes')
416
758
        return self._has_working_tree
417
759
 
418
760
    def open_workingtree(self, recommend_upgrade=True):
423
765
 
424
766
    def _path_for_remote_call(self, client):
425
767
        """Return the path to be used for this bzrdir in a remote call."""
426
 
        return client.remote_path_from_transport(self.root_transport)
 
768
        return urlutils.split_segment_parameters_raw(
 
769
            client.remote_path_from_transport(self.root_transport))[0]
427
770
 
428
771
    def get_branch_transport(self, branch_format, name=None):
429
772
        self._ensure_real()
441
784
        """Upgrading of remote bzrdirs is not supported yet."""
442
785
        return False
443
786
 
444
 
    def needs_format_conversion(self, format=None):
 
787
    def needs_format_conversion(self, format):
445
788
        """Upgrading of remote bzrdirs is not supported yet."""
446
 
        if format is None:
447
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
448
 
                % 'needs_format_conversion(format=None)')
449
789
        return False
450
790
 
451
 
    def clone(self, url, revision_id=None, force_new_repo=False,
452
 
              preserve_stacking=False):
453
 
        self._ensure_real()
454
 
        return self._real_bzrdir.clone(url, revision_id=revision_id,
455
 
            force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
456
 
 
457
791
    def _get_config(self):
458
792
        return RemoteBzrDirConfig(self)
459
793
 
460
 
 
461
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
794
    def _get_config_store(self):
 
795
        return RemoteControlStore(self)
 
796
 
 
797
 
 
798
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
462
799
    """Format for repositories accessed over a _SmartClient.
463
800
 
464
801
    Instances of this repository are represented by RemoteRepository
479
816
    """
480
817
 
481
818
    _matchingbzrdir = RemoteBzrDirFormat()
 
819
    supports_full_versioned_files = True
 
820
    supports_leaving_lock = True
482
821
 
483
822
    def __init__(self):
484
 
        repository.RepositoryFormat.__init__(self)
 
823
        _mod_repository.RepositoryFormat.__init__(self)
485
824
        self._custom_format = None
486
825
        self._network_name = None
487
826
        self._creating_bzrdir = None
 
827
        self._revision_graph_can_have_wrong_parents = None
488
828
        self._supports_chks = None
489
829
        self._supports_external_lookups = None
490
830
        self._supports_tree_reference = None
 
831
        self._supports_funky_characters = None
 
832
        self._supports_nesting_repositories = None
491
833
        self._rich_root_data = None
492
834
 
493
835
    def __repr__(self):
522
864
        return self._supports_external_lookups
523
865
 
524
866
    @property
 
867
    def supports_funky_characters(self):
 
868
        if self._supports_funky_characters is None:
 
869
            self._ensure_real()
 
870
            self._supports_funky_characters = \
 
871
                self._custom_format.supports_funky_characters
 
872
        return self._supports_funky_characters
 
873
 
 
874
    @property
 
875
    def supports_nesting_repositories(self):
 
876
        if self._supports_nesting_repositories is None:
 
877
            self._ensure_real()
 
878
            self._supports_nesting_repositories = \
 
879
                self._custom_format.supports_nesting_repositories
 
880
        return self._supports_nesting_repositories
 
881
 
 
882
    @property
525
883
    def supports_tree_reference(self):
526
884
        if self._supports_tree_reference is None:
527
885
            self._ensure_real()
529
887
                self._custom_format.supports_tree_reference
530
888
        return self._supports_tree_reference
531
889
 
 
890
    @property
 
891
    def revision_graph_can_have_wrong_parents(self):
 
892
        if self._revision_graph_can_have_wrong_parents is None:
 
893
            self._ensure_real()
 
894
            self._revision_graph_can_have_wrong_parents = \
 
895
                self._custom_format.revision_graph_can_have_wrong_parents
 
896
        return self._revision_graph_can_have_wrong_parents
 
897
 
532
898
    def _vfs_initialize(self, a_bzrdir, shared):
533
899
        """Helper for common code in initialize."""
534
900
        if self._custom_format:
569
935
            network_name = self._network_name
570
936
        else:
571
937
            # Select the current bzrlib default and ask for that.
572
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
938
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
573
939
            reference_format = reference_bzrdir_format.repository_format
574
940
            network_name = reference_format.network_name()
575
941
        # 2) try direct creation via RPC
601
967
 
602
968
    def _ensure_real(self):
603
969
        if self._custom_format is None:
604
 
            self._custom_format = repository.network_format_registry.get(
 
970
            self._custom_format = _mod_repository.network_format_registry.get(
605
971
                self._network_name)
606
972
 
607
973
    @property
643
1009
        return self._custom_format._serializer
644
1010
 
645
1011
 
646
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
647
 
    bzrdir.ControlComponent):
 
1012
class RemoteRepository(_mod_repository.Repository, _RpcHelper,
 
1013
        lock._RelockDebugMixin):
648
1014
    """Repository accessed over rpc.
649
1015
 
650
1016
    For the moment most operations are performed using local transport-backed
674
1040
        self._format = format
675
1041
        self._lock_mode = None
676
1042
        self._lock_token = None
 
1043
        self._write_group_tokens = None
677
1044
        self._lock_count = 0
678
1045
        self._leave_lock = False
679
1046
        # Cache of revision parents; misses are cached during read locks, and
703
1070
        # transport, but I'm not sure it's worth making this method
704
1071
        # optional -- mbp 2010-04-21
705
1072
        return self.bzrdir.get_repository_transport(None)
706
 
        
 
1073
 
707
1074
    def __str__(self):
708
1075
        return "%s(%s)" % (self.__class__.__name__, self.base)
709
1076
 
719
1086
 
720
1087
        :param suppress_errors: see Repository.abort_write_group.
721
1088
        """
722
 
        self._ensure_real()
723
 
        return self._real_repository.abort_write_group(
724
 
            suppress_errors=suppress_errors)
 
1089
        if self._real_repository:
 
1090
            self._ensure_real()
 
1091
            return self._real_repository.abort_write_group(
 
1092
                suppress_errors=suppress_errors)
 
1093
        if not self.is_in_write_group():
 
1094
            if suppress_errors:
 
1095
                mutter('(suppressed) not in write group')
 
1096
                return
 
1097
            raise errors.BzrError("not in write group")
 
1098
        path = self.bzrdir._path_for_remote_call(self._client)
 
1099
        try:
 
1100
            response = self._call('Repository.abort_write_group', path,
 
1101
                self._lock_token, self._write_group_tokens)
 
1102
        except Exception, exc:
 
1103
            self._write_group = None
 
1104
            if not suppress_errors:
 
1105
                raise
 
1106
            mutter('abort_write_group failed')
 
1107
            log_exception_quietly()
 
1108
            note(gettext('bzr: ERROR (ignored): %s'), exc)
 
1109
        else:
 
1110
            if response != ('ok', ):
 
1111
                raise errors.UnexpectedSmartServerResponse(response)
 
1112
            self._write_group_tokens = None
725
1113
 
726
1114
    @property
727
1115
    def chk_bytes(self):
741
1129
        for older plugins that don't use e.g. the CommitBuilder
742
1130
        facility.
743
1131
        """
744
 
        self._ensure_real()
745
 
        return self._real_repository.commit_write_group()
 
1132
        if self._real_repository:
 
1133
            self._ensure_real()
 
1134
            return self._real_repository.commit_write_group()
 
1135
        if not self.is_in_write_group():
 
1136
            raise errors.BzrError("not in write group")
 
1137
        path = self.bzrdir._path_for_remote_call(self._client)
 
1138
        response = self._call('Repository.commit_write_group', path,
 
1139
            self._lock_token, self._write_group_tokens)
 
1140
        if response != ('ok', ):
 
1141
            raise errors.UnexpectedSmartServerResponse(response)
 
1142
        self._write_group_tokens = None
746
1143
 
747
1144
    def resume_write_group(self, tokens):
748
 
        self._ensure_real()
749
 
        return self._real_repository.resume_write_group(tokens)
 
1145
        if self._real_repository:
 
1146
            return self._real_repository.resume_write_group(tokens)
 
1147
        path = self.bzrdir._path_for_remote_call(self._client)
 
1148
        try:
 
1149
            response = self._call('Repository.check_write_group', path,
 
1150
               self._lock_token, tokens)
 
1151
        except errors.UnknownSmartMethod:
 
1152
            self._ensure_real()
 
1153
            return self._real_repository.resume_write_group(tokens)
 
1154
        if response != ('ok', ):
 
1155
            raise errors.UnexpectedSmartServerResponse(response)
 
1156
        self._write_group_tokens = tokens
750
1157
 
751
1158
    def suspend_write_group(self):
752
 
        self._ensure_real()
753
 
        return self._real_repository.suspend_write_group()
 
1159
        if self._real_repository:
 
1160
            return self._real_repository.suspend_write_group()
 
1161
        ret = self._write_group_tokens or []
 
1162
        self._write_group_tokens = None
 
1163
        return ret
754
1164
 
755
1165
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
756
1166
        self._ensure_real()
817
1227
    def find_text_key_references(self):
818
1228
        """Find the text key references within the repository.
819
1229
 
820
 
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
821
 
        revision_ids. Each altered file-ids has the exact revision_ids that
822
 
        altered it listed explicitly.
823
1230
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
824
1231
            to whether they were referred to by the inventory of the
825
1232
            revision_id that they contain. The inventory texts from all present
843
1250
        """Private method for using with old (< 1.2) servers to fallback."""
844
1251
        if revision_id is None:
845
1252
            revision_id = ''
846
 
        elif revision.is_null(revision_id):
 
1253
        elif _mod_revision.is_null(revision_id):
847
1254
            return {}
848
1255
 
849
1256
        path = self.bzrdir._path_for_remote_call(self._client)
873
1280
        return RemoteStreamSource(self, to_format)
874
1281
 
875
1282
    @needs_read_lock
 
1283
    def get_file_graph(self):
 
1284
        return graph.Graph(self.texts)
 
1285
 
 
1286
    @needs_read_lock
876
1287
    def has_revision(self, revision_id):
877
1288
        """True if this repository has a copy of the revision."""
878
1289
        # Copy of bzrlib.repository.Repository.has_revision
895
1306
    def _has_same_fallbacks(self, other_repo):
896
1307
        """Returns true if the repositories have the same fallbacks."""
897
1308
        # XXX: copied from Repository; it should be unified into a base class
898
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
1309
        # <https://bugs.launchpad.net/bzr/+bug/401622>
899
1310
        my_fb = self._fallback_repositories
900
1311
        other_fb = other_repo._fallback_repositories
901
1312
        if len(my_fb) != len(other_fb):
930
1341
        """See Repository.gather_stats()."""
931
1342
        path = self.bzrdir._path_for_remote_call(self._client)
932
1343
        # revid can be None to indicate no revisions, not just NULL_REVISION
933
 
        if revid is None or revision.is_null(revid):
 
1344
        if revid is None or _mod_revision.is_null(revid):
934
1345
            fmt_revid = ''
935
1346
        else:
936
1347
            fmt_revid = revid
965
1376
 
966
1377
    def get_physical_lock_status(self):
967
1378
        """See Repository.get_physical_lock_status()."""
968
 
        # should be an API call to the server.
969
 
        self._ensure_real()
970
 
        return self._real_repository.get_physical_lock_status()
 
1379
        path = self.bzrdir._path_for_remote_call(self._client)
 
1380
        try:
 
1381
            response = self._call('Repository.get_physical_lock_status', path)
 
1382
        except errors.UnknownSmartMethod:
 
1383
            self._ensure_real()
 
1384
            return self._real_repository.get_physical_lock_status()
 
1385
        if response[0] not in ('yes', 'no'):
 
1386
            raise errors.UnexpectedSmartServerResponse(response)
 
1387
        return (response[0] == 'yes')
971
1388
 
972
1389
    def is_in_write_group(self):
973
1390
        """Return True if there is an open write group.
974
1391
 
975
1392
        write groups are only applicable locally for the smart server..
976
1393
        """
 
1394
        if self._write_group_tokens is not None:
 
1395
            return True
977
1396
        if self._real_repository:
978
1397
            return self._real_repository.is_in_write_group()
979
1398
 
997
1416
        pass
998
1417
 
999
1418
    def lock_read(self):
 
1419
        """Lock the repository for read operations.
 
1420
 
 
1421
        :return: A bzrlib.lock.LogicalLockResult.
 
1422
        """
1000
1423
        # wrong eventually - want a local lock cache context
1001
1424
        if not self._lock_mode:
1002
1425
            self._note_lock('r')
1009
1432
                repo.lock_read()
1010
1433
        else:
1011
1434
            self._lock_count += 1
 
1435
        return lock.LogicalLockResult(self.unlock)
1012
1436
 
1013
1437
    def _remote_lock_write(self, token):
1014
1438
        path = self.bzrdir._path_for_remote_call(self._client)
1054
1478
            raise errors.ReadOnlyError(self)
1055
1479
        else:
1056
1480
            self._lock_count += 1
1057
 
        return self._lock_token or None
 
1481
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
1058
1482
 
1059
1483
    def leave_lock_in_place(self):
1060
1484
        if not self._lock_token:
1109
1533
            self._real_repository.lock_write(self._lock_token)
1110
1534
        elif self._lock_mode == 'r':
1111
1535
            self._real_repository.lock_read()
 
1536
        if self._write_group_tokens is not None:
 
1537
            # if we are already in a write group, resume it
 
1538
            self._real_repository.resume_write_group(self._write_group_tokens)
 
1539
            self._write_group_tokens = None
1112
1540
 
1113
1541
    def start_write_group(self):
1114
1542
        """Start a write group on the decorated repository.
1118
1546
        for older plugins that don't use e.g. the CommitBuilder
1119
1547
        facility.
1120
1548
        """
1121
 
        self._ensure_real()
1122
 
        return self._real_repository.start_write_group()
 
1549
        if self._real_repository:
 
1550
            self._ensure_real()
 
1551
            return self._real_repository.start_write_group()
 
1552
        if not self.is_write_locked():
 
1553
            raise errors.NotWriteLocked(self)
 
1554
        if self._write_group_tokens is not None:
 
1555
            raise errors.BzrError('already in a write group')
 
1556
        path = self.bzrdir._path_for_remote_call(self._client)
 
1557
        try:
 
1558
            response = self._call('Repository.start_write_group', path,
 
1559
                self._lock_token)
 
1560
        except (errors.UnknownSmartMethod, errors.UnsuspendableWriteGroup):
 
1561
            self._ensure_real()
 
1562
            return self._real_repository.start_write_group()
 
1563
        if response[0] != 'ok':
 
1564
            raise errors.UnexpectedSmartServerResponse(response)
 
1565
        self._write_group_tokens = response[1]
1123
1566
 
1124
1567
    def _unlock(self, token):
1125
1568
        path = self.bzrdir._path_for_remote_call(self._client)
1152
1595
            # This is just to let the _real_repository stay up to date.
1153
1596
            if self._real_repository is not None:
1154
1597
                self._real_repository.unlock()
 
1598
            elif self._write_group_tokens is not None:
 
1599
                self.abort_write_group()
1155
1600
        finally:
1156
1601
            # The rpc-level lock should be released even if there was a
1157
1602
            # problem releasing the vfs-based lock.
1169
1614
 
1170
1615
    def break_lock(self):
1171
1616
        # should hand off to the network
1172
 
        self._ensure_real()
1173
 
        return self._real_repository.break_lock()
 
1617
        path = self.bzrdir._path_for_remote_call(self._client)
 
1618
        try:
 
1619
            response = self._call("Repository.break_lock", path)
 
1620
        except errors.UnknownSmartMethod:
 
1621
            self._ensure_real()
 
1622
            return self._real_repository.break_lock()
 
1623
        if response != ('ok',):
 
1624
            raise errors.UnexpectedSmartServerResponse(response)
1174
1625
 
1175
1626
    def _get_tarball(self, compression):
1176
1627
        """Return a TemporaryFile containing a repository tarball.
1194
1645
            return t
1195
1646
        raise errors.UnexpectedSmartServerResponse(response)
1196
1647
 
 
1648
    @needs_read_lock
1197
1649
    def sprout(self, to_bzrdir, revision_id=None):
1198
 
        # TODO: Option to control what format is created?
1199
 
        self._ensure_real()
1200
 
        dest_repo = self._real_repository._format.initialize(to_bzrdir,
1201
 
                                                             shared=False)
 
1650
        """Create a descendent repository for new development.
 
1651
 
 
1652
        Unlike clone, this does not copy the settings of the repository.
 
1653
        """
 
1654
        dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
1202
1655
        dest_repo.fetch(self, revision_id=revision_id)
1203
1656
        return dest_repo
1204
1657
 
 
1658
    def _create_sprouting_repo(self, a_bzrdir, shared):
 
1659
        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
 
1660
            # use target default format.
 
1661
            dest_repo = a_bzrdir.create_repository()
 
1662
        else:
 
1663
            # Most control formats need the repository to be specifically
 
1664
            # created, but on some old all-in-one formats it's not needed
 
1665
            try:
 
1666
                dest_repo = self._format.initialize(a_bzrdir, shared=shared)
 
1667
            except errors.UninitializableFormat:
 
1668
                dest_repo = a_bzrdir.open_repository()
 
1669
        return dest_repo
 
1670
 
1205
1671
    ### These methods are just thin shims to the VFS object for now.
1206
1672
 
 
1673
    @needs_read_lock
1207
1674
    def revision_tree(self, revision_id):
1208
 
        self._ensure_real()
1209
 
        return self._real_repository.revision_tree(revision_id)
 
1675
        revision_id = _mod_revision.ensure_null(revision_id)
 
1676
        if revision_id == _mod_revision.NULL_REVISION:
 
1677
            return InventoryRevisionTree(self,
 
1678
                Inventory(root_id=None), _mod_revision.NULL_REVISION)
 
1679
        else:
 
1680
            return list(self.revision_trees([revision_id]))[0]
1210
1681
 
1211
1682
    def get_serializer_format(self):
1212
 
        self._ensure_real()
1213
 
        return self._real_repository.get_serializer_format()
 
1683
        path = self.bzrdir._path_for_remote_call(self._client)
 
1684
        try:
 
1685
            response = self._call('VersionedFileRepository.get_serializer_format',
 
1686
                path)
 
1687
        except errors.UnknownSmartMethod:
 
1688
            self._ensure_real()
 
1689
            return self._real_repository.get_serializer_format()
 
1690
        if response[0] != 'ok':
 
1691
            raise errors.UnexpectedSmartServerResponse(response)
 
1692
        return response[1]
1214
1693
 
1215
1694
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1216
1695
                           timezone=None, committer=None, revprops=None,
1217
 
                           revision_id=None):
 
1696
                           revision_id=None, lossy=False):
1218
1697
        # FIXME: It ought to be possible to call this without immediately
1219
1698
        # triggering _ensure_real.  For now it's the easiest thing to do.
1220
1699
        self._ensure_real()
1221
1700
        real_repo = self._real_repository
1222
1701
        builder = real_repo.get_commit_builder(branch, parents,
1223
1702
                config, timestamp=timestamp, timezone=timezone,
1224
 
                committer=committer, revprops=revprops, revision_id=revision_id)
 
1703
                committer=committer, revprops=revprops,
 
1704
                revision_id=revision_id, lossy=lossy)
1225
1705
        return builder
1226
1706
 
1227
1707
    def add_fallback_repository(self, repository):
1235
1715
        # We need to accumulate additional repositories here, to pass them in
1236
1716
        # on various RPC's.
1237
1717
        #
 
1718
        # Make the check before we lock: this raises an exception.
 
1719
        self._check_fallback_repository(repository)
1238
1720
        if self.is_locked():
1239
1721
            # We will call fallback.unlock() when we transition to the unlocked
1240
1722
            # state, so always add a lock here. If a caller passes us a locked
1241
1723
            # repository, they are responsible for unlocking it later.
1242
1724
            repository.lock_read()
1243
 
        self._check_fallback_repository(repository)
1244
1725
        self._fallback_repositories.append(repository)
1245
1726
        # If self._real_repository was parameterised already (e.g. because a
1246
1727
        # _real_branch had its get_stacked_on_url method called), then the
1288
1769
 
1289
1770
    @needs_read_lock
1290
1771
    def get_revision(self, revision_id):
1291
 
        self._ensure_real()
1292
 
        return self._real_repository.get_revision(revision_id)
 
1772
        return self.get_revisions([revision_id])[0]
1293
1773
 
1294
1774
    def get_transaction(self):
1295
1775
        self._ensure_real()
1297
1777
 
1298
1778
    @needs_read_lock
1299
1779
    def clone(self, a_bzrdir, revision_id=None):
1300
 
        self._ensure_real()
1301
 
        return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
 
1780
        dest_repo = self._create_sprouting_repo(
 
1781
            a_bzrdir, shared=self.is_shared())
 
1782
        self.copy_content_into(dest_repo, revision_id)
 
1783
        return dest_repo
1302
1784
 
1303
1785
    def make_working_trees(self):
1304
1786
        """See Repository.make_working_trees"""
1305
 
        self._ensure_real()
1306
 
        return self._real_repository.make_working_trees()
 
1787
        path = self.bzrdir._path_for_remote_call(self._client)
 
1788
        try:
 
1789
            response = self._call('Repository.make_working_trees', path)
 
1790
        except errors.UnknownSmartMethod:
 
1791
            self._ensure_real()
 
1792
            return self._real_repository.make_working_trees()
 
1793
        if response[0] not in ('yes', 'no'):
 
1794
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
1795
        return response[0] == 'yes'
1307
1796
 
1308
1797
    def refresh_data(self):
1309
 
        """Re-read any data needed to to synchronise with disk.
 
1798
        """Re-read any data needed to synchronise with disk.
1310
1799
 
1311
1800
        This method is intended to be called after another repository instance
1312
1801
        (such as one used by a smart server) has inserted data into the
1313
 
        repository. It may not be called during a write group, but may be
1314
 
        called at any other time.
 
1802
        repository. On all repositories this will work outside of write groups.
 
1803
        Some repository formats (pack and newer for bzrlib native formats)
 
1804
        support refresh_data inside write groups. If called inside a write
 
1805
        group on a repository that does not support refreshing in a write group
 
1806
        IsInWriteGroupError will be raised.
1315
1807
        """
1316
 
        if self.is_in_write_group():
1317
 
            raise errors.InternalBzrError(
1318
 
                "May not refresh_data while in a write group.")
1319
1808
        if self._real_repository is not None:
1320
1809
            self._real_repository.refresh_data()
1321
1810
 
1333
1822
        return result
1334
1823
 
1335
1824
    @needs_read_lock
1336
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
1825
    def search_missing_revision_ids(self, other,
 
1826
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
1827
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
1828
            limit=None):
1337
1829
        """Return the revision ids that other has that this does not.
1338
1830
 
1339
1831
        These are returned in topological order.
1340
1832
 
1341
1833
        revision_id: only return revision ids included by revision_id.
1342
1834
        """
1343
 
        return repository.InterRepository.get(
1344
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
1835
        if symbol_versioning.deprecated_passed(revision_id):
 
1836
            symbol_versioning.warn(
 
1837
                'search_missing_revision_ids(revision_id=...) was '
 
1838
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
1839
                DeprecationWarning, stacklevel=2)
 
1840
            if revision_ids is not None:
 
1841
                raise AssertionError(
 
1842
                    'revision_ids is mutually exclusive with revision_id')
 
1843
            if revision_id is not None:
 
1844
                revision_ids = [revision_id]
 
1845
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
1846
        return inter_repo.search_missing_revision_ids(
 
1847
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
1848
            if_present_ids=if_present_ids, limit=limit)
1345
1849
 
1346
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
1850
    def fetch(self, source, revision_id=None, find_ghosts=False,
1347
1851
            fetch_spec=None):
1348
1852
        # No base implementation to use as RemoteRepository is not a subclass
1349
1853
        # of Repository; so this is a copy of Repository.fetch().
1360
1864
            # check that last_revision is in 'from' and then return a
1361
1865
            # no-operation.
1362
1866
            if (revision_id is not None and
1363
 
                not revision.is_null(revision_id)):
 
1867
                not _mod_revision.is_null(revision_id)):
1364
1868
                self.get_revision(revision_id)
1365
1869
            return 0, []
1366
1870
        # if there is no specific appropriate InterRepository, this will get
1367
1871
        # the InterRepository base class, which raises an
1368
1872
        # IncompatibleRepositories when asked to fetch.
1369
 
        inter = repository.InterRepository.get(source, self)
1370
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
1873
        inter = _mod_repository.InterRepository.get(source, self)
 
1874
        return inter.fetch(revision_id=revision_id,
1371
1875
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1372
1876
 
1373
1877
    def create_bundle(self, target, base, fileobj, format=None):
1375
1879
        self._real_repository.create_bundle(target, base, fileobj, format)
1376
1880
 
1377
1881
    @needs_read_lock
 
1882
    @symbol_versioning.deprecated_method(
 
1883
        symbol_versioning.deprecated_in((2, 4, 0)))
1378
1884
    def get_ancestry(self, revision_id, topo_sorted=True):
1379
1885
        self._ensure_real()
1380
1886
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1394
1900
        self._ensure_real()
1395
1901
        return self._real_repository.iter_files_bytes(desired_files)
1396
1902
 
 
1903
    def get_cached_parent_map(self, revision_ids):
 
1904
        """See bzrlib.CachingParentsProvider.get_cached_parent_map"""
 
1905
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
 
1906
 
1397
1907
    def get_parent_map(self, revision_ids):
1398
1908
        """See bzrlib.Graph.get_parent_map()."""
1399
1909
        return self._make_parents_provider().get_parent_map(revision_ids)
1457
1967
        if parents_map is None:
1458
1968
            # Repository is not locked, so there's no cache.
1459
1969
            parents_map = {}
1460
 
        # start_set is all the keys in the cache
1461
 
        start_set = set(parents_map)
1462
 
        # result set is all the references to keys in the cache
1463
 
        result_parents = set()
1464
 
        for parents in parents_map.itervalues():
1465
 
            result_parents.update(parents)
1466
 
        stop_keys = result_parents.difference(start_set)
1467
 
        # We don't need to send ghosts back to the server as a position to
1468
 
        # stop either.
1469
 
        stop_keys.difference_update(self._unstacked_provider.missing_keys)
1470
 
        key_count = len(parents_map)
1471
 
        if (NULL_REVISION in result_parents
1472
 
            and NULL_REVISION in self._unstacked_provider.missing_keys):
1473
 
            # If we pruned NULL_REVISION from the stop_keys because it's also
1474
 
            # in our cache of "missing" keys we need to increment our key count
1475
 
            # by 1, because the reconsitituted SearchResult on the server will
1476
 
            # still consider NULL_REVISION to be an included key.
1477
 
            key_count += 1
1478
 
        included_keys = start_set.intersection(result_parents)
1479
 
        start_set.difference_update(included_keys)
 
1970
        if _DEFAULT_SEARCH_DEPTH <= 0:
 
1971
            (start_set, stop_keys,
 
1972
             key_count) = graph.search_result_from_parent_map(
 
1973
                parents_map, self._unstacked_provider.missing_keys)
 
1974
        else:
 
1975
            (start_set, stop_keys,
 
1976
             key_count) = graph.limited_search_result_from_parent_map(
 
1977
                parents_map, self._unstacked_provider.missing_keys,
 
1978
                keys, depth=_DEFAULT_SEARCH_DEPTH)
1480
1979
        recipe = ('manual', start_set, stop_keys, key_count)
1481
1980
        body = self._serialise_search_recipe(recipe)
1482
1981
        path = self.bzrdir._path_for_remote_call(self._client)
1544
2043
        return self._real_repository.reconcile(other=other, thorough=thorough)
1545
2044
 
1546
2045
    def all_revision_ids(self):
1547
 
        self._ensure_real()
1548
 
        return self._real_repository.all_revision_ids()
 
2046
        path = self.bzrdir._path_for_remote_call(self._client)
 
2047
        try:
 
2048
            response_tuple, response_handler = self._call_expecting_body(
 
2049
                "Repository.all_revision_ids", path)
 
2050
        except errors.UnknownSmartMethod:
 
2051
            self._ensure_real()
 
2052
            return self._real_repository.all_revision_ids()
 
2053
        if response_tuple != ("ok", ):
 
2054
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2055
        revids = set(response_handler.read_body_bytes().splitlines())
 
2056
        for fallback in self._fallback_repositories:
 
2057
            revids.update(set(fallback.all_revision_ids()))
 
2058
        return list(revids)
1549
2059
 
1550
2060
    @needs_read_lock
1551
2061
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1555
2065
 
1556
2066
    @needs_read_lock
1557
2067
    def get_revision_delta(self, revision_id, specific_fileids=None):
1558
 
        self._ensure_real()
1559
 
        return self._real_repository.get_revision_delta(revision_id,
1560
 
            specific_fileids=specific_fileids)
 
2068
        r = self.get_revision(revision_id)
 
2069
        return list(self.get_deltas_for_revisions([r],
 
2070
            specific_fileids=specific_fileids))[0]
1561
2071
 
1562
2072
    @needs_read_lock
1563
2073
    def revision_trees(self, revision_ids):
1576
2086
            callback_refs=callback_refs, check_repo=check_repo)
1577
2087
 
1578
2088
    def copy_content_into(self, destination, revision_id=None):
1579
 
        self._ensure_real()
1580
 
        return self._real_repository.copy_content_into(
1581
 
            destination, revision_id=revision_id)
 
2089
        """Make a complete copy of the content in self into destination.
 
2090
 
 
2091
        This is a destructive operation! Do not use it on existing
 
2092
        repositories.
 
2093
        """
 
2094
        interrepo = _mod_repository.InterRepository.get(self, destination)
 
2095
        return interrepo.copy_content(revision_id)
1582
2096
 
1583
2097
    def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1584
2098
        # get a tarball of the remote repository, and copy from that into the
1586
2100
        from bzrlib import osutils
1587
2101
        import tarfile
1588
2102
        # TODO: Maybe a progress bar while streaming the tarball?
1589
 
        note("Copying repository content as tarball...")
 
2103
        note(gettext("Copying repository content as tarball..."))
1590
2104
        tar_file = self._get_tarball('bz2')
1591
2105
        if tar_file is None:
1592
2106
            return None
1597
2111
            tmpdir = osutils.mkdtemp()
1598
2112
            try:
1599
2113
                _extract_tar(tar, tmpdir)
1600
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
2114
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1601
2115
                tmp_repo = tmp_bzrdir.open_repository()
1602
2116
                tmp_repo.copy_content_into(destination, revision_id)
1603
2117
            finally:
1621
2135
    @needs_write_lock
1622
2136
    def pack(self, hint=None, clean_obsolete_packs=False):
1623
2137
        """Compress the data within the repository.
1624
 
 
1625
 
        This is not currently implemented within the smart server.
1626
2138
        """
1627
 
        self._ensure_real()
1628
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
2139
        if hint is None:
 
2140
            body = ""
 
2141
        else:
 
2142
            body = "".join([l+"\n" for l in hint])
 
2143
        path = self.bzrdir._path_for_remote_call(self._client)
 
2144
        try:
 
2145
            response, handler = self._call_with_body_bytes_expecting_body(
 
2146
                'Repository.pack', (path, self._lock_token,
 
2147
                    str(clean_obsolete_packs)), body)
 
2148
        except errors.UnknownSmartMethod:
 
2149
            self._ensure_real()
 
2150
            return self._real_repository.pack(hint=hint,
 
2151
                clean_obsolete_packs=clean_obsolete_packs)
 
2152
        handler.cancel_read_body()
 
2153
        if response != ('ok', ):
 
2154
            raise errors.UnexpectedSmartServerResponse(response)
1629
2155
 
1630
2156
    @property
1631
2157
    def revisions(self):
1667
2193
 
1668
2194
    @needs_write_lock
1669
2195
    def sign_revision(self, revision_id, gpg_strategy):
1670
 
        self._ensure_real()
1671
 
        return self._real_repository.sign_revision(revision_id, gpg_strategy)
 
2196
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2197
        plaintext = testament.as_short_text()
 
2198
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1672
2199
 
1673
2200
    @property
1674
2201
    def texts(self):
1688
2215
    def supports_rich_root(self):
1689
2216
        return self._format.rich_root_data
1690
2217
 
 
2218
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1691
2219
    def iter_reverse_revision_history(self, revision_id):
1692
2220
        self._ensure_real()
1693
2221
        return self._real_repository.iter_reverse_revision_history(revision_id)
1696
2224
    def _serializer(self):
1697
2225
        return self._format._serializer
1698
2226
 
 
2227
    @needs_write_lock
1699
2228
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1700
 
        self._ensure_real()
1701
 
        return self._real_repository.store_revision_signature(
1702
 
            gpg_strategy, plaintext, revision_id)
 
2229
        signature = gpg_strategy.sign(plaintext)
 
2230
        self.add_signature_text(revision_id, signature)
1703
2231
 
1704
2232
    def add_signature_text(self, revision_id, signature):
1705
 
        self._ensure_real()
1706
 
        return self._real_repository.add_signature_text(revision_id, signature)
 
2233
        if self._real_repository:
 
2234
            # If there is a real repository the write group will
 
2235
            # be in the real repository as well, so use that:
 
2236
            self._ensure_real()
 
2237
            return self._real_repository.add_signature_text(
 
2238
                revision_id, signature)
 
2239
        path = self.bzrdir._path_for_remote_call(self._client)
 
2240
        response, response_handler = self._call_with_body_bytes(
 
2241
            'Repository.add_signature_text', (path, revision_id),
 
2242
            signature)
 
2243
        self.refresh_data()
 
2244
        if response[0] != 'ok':
 
2245
            raise errors.UnexpectedSmartServerResponse(response)
1707
2246
 
1708
2247
    def has_signature_for_revision_id(self, revision_id):
1709
 
        self._ensure_real()
1710
 
        return self._real_repository.has_signature_for_revision_id(revision_id)
 
2248
        path = self.bzrdir._path_for_remote_call(self._client)
 
2249
        try:
 
2250
            response = self._call('Repository.has_signature_for_revision_id',
 
2251
                path, revision_id)
 
2252
        except errors.UnknownSmartMethod:
 
2253
            self._ensure_real()
 
2254
            return self._real_repository.has_signature_for_revision_id(
 
2255
                revision_id)
 
2256
        if response[0] not in ('yes', 'no'):
 
2257
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2258
        return (response[0] == 'yes')
 
2259
 
 
2260
    @needs_read_lock
 
2261
    def verify_revision_signature(self, revision_id, gpg_strategy):
 
2262
        if not self.has_signature_for_revision_id(revision_id):
 
2263
            return gpg.SIGNATURE_NOT_SIGNED, None
 
2264
        signature = self.get_signature_text(revision_id)
 
2265
 
 
2266
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2267
        plaintext = testament.as_short_text()
 
2268
 
 
2269
        return gpg_strategy.verify(signature, plaintext)
1711
2270
 
1712
2271
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1713
2272
        self._ensure_real()
1714
2273
        return self._real_repository.item_keys_introduced_by(revision_ids,
1715
2274
            _files_pb=_files_pb)
1716
2275
 
1717
 
    def revision_graph_can_have_wrong_parents(self):
1718
 
        # The answer depends on the remote repo format.
1719
 
        self._ensure_real()
1720
 
        return self._real_repository.revision_graph_can_have_wrong_parents()
1721
 
 
1722
2276
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1723
2277
        self._ensure_real()
1724
2278
        return self._real_repository._find_inconsistent_revision_parents(
1732
2286
        providers = [self._unstacked_provider]
1733
2287
        if other is not None:
1734
2288
            providers.insert(0, other)
1735
 
        providers.extend(r._make_parents_provider() for r in
1736
 
                         self._fallback_repositories)
1737
 
        return graph.StackedParentsProvider(providers)
 
2289
        return graph.StackedParentsProvider(_LazyListJoin(
 
2290
            providers, self._fallback_repositories))
1738
2291
 
1739
2292
    def _serialise_search_recipe(self, recipe):
1740
2293
        """Serialise a graph search recipe.
1748
2301
        return '\n'.join((start_keys, stop_keys, count))
1749
2302
 
1750
2303
    def _serialise_search_result(self, search_result):
1751
 
        if isinstance(search_result, graph.PendingAncestryResult):
1752
 
            parts = ['ancestry-of']
1753
 
            parts.extend(search_result.heads)
1754
 
        else:
1755
 
            recipe = search_result.get_recipe()
1756
 
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
 
2304
        parts = search_result.get_network_struct()
1757
2305
        return '\n'.join(parts)
1758
2306
 
1759
2307
    def autopack(self):
1769
2317
            raise errors.UnexpectedSmartServerResponse(response)
1770
2318
 
1771
2319
 
1772
 
class RemoteStreamSink(repository.StreamSink):
 
2320
class RemoteStreamSink(vf_repository.StreamSink):
1773
2321
 
1774
2322
    def _insert_real(self, stream, src_format, resume_tokens):
1775
2323
        self.target_repo._ensure_real()
1876
2424
        self._last_substream and self._last_stream so that the stream can be
1877
2425
        resumed by _resume_stream_with_vfs.
1878
2426
        """
1879
 
                    
 
2427
 
1880
2428
        stream_iter = iter(stream)
1881
2429
        for substream_kind, substream in stream_iter:
1882
2430
            if substream_kind == 'inventory-deltas':
1885
2433
                return
1886
2434
            else:
1887
2435
                yield substream_kind, substream
1888
 
            
1889
 
 
1890
 
class RemoteStreamSource(repository.StreamSource):
 
2436
 
 
2437
 
 
2438
class RemoteStreamSource(vf_repository.StreamSource):
1891
2439
    """Stream data from a remote server."""
1892
2440
 
1893
2441
    def get_stream(self, search):
1953
2501
        candidate_verbs = [
1954
2502
            ('Repository.get_stream_1.19', (1, 19)),
1955
2503
            ('Repository.get_stream', (1, 13))]
 
2504
 
1956
2505
        found_verb = False
1957
2506
        for verb, version in candidate_verbs:
1958
2507
            if medium._is_remote_before(version):
1962
2511
                    verb, args, search_bytes)
1963
2512
            except errors.UnknownSmartMethod:
1964
2513
                medium._remember_remote_is_before(version)
 
2514
            except errors.UnknownErrorFromSmartServer, e:
 
2515
                if isinstance(search, graph.EverythingResult):
 
2516
                    error_verb = e.error_from_smart_server.error_verb
 
2517
                    if error_verb == 'BadSearch':
 
2518
                        # Pre-2.4 servers don't support this sort of search.
 
2519
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
2520
                        # good idea in general?  It might provide a little bit
 
2521
                        # of protection against client-side bugs.
 
2522
                        medium._remember_remote_is_before((2, 4))
 
2523
                        break
 
2524
                raise
1965
2525
            else:
1966
2526
                response_tuple, response_handler = response
1967
2527
                found_verb = True
1971
2531
        if response_tuple[0] != 'ok':
1972
2532
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1973
2533
        byte_stream = response_handler.read_streamed_body()
1974
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
2534
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
2535
            self._record_counter)
1975
2536
        if src_format.network_name() != repo._format.network_name():
1976
2537
            raise AssertionError(
1977
2538
                "Mismatched RemoteRepository and stream src %r, %r" % (
2063
2624
        return a_bzrdir.open_branch(name=name, 
2064
2625
            ignore_fallbacks=ignore_fallbacks)
2065
2626
 
2066
 
    def _vfs_initialize(self, a_bzrdir, name):
 
2627
    def _vfs_initialize(self, a_bzrdir, name, append_revisions_only):
2067
2628
        # Initialisation when using a local bzrdir object, or a non-vfs init
2068
2629
        # method is not available on the server.
2069
2630
        # self._custom_format is always set - the start of initialize ensures
2071
2632
        if isinstance(a_bzrdir, RemoteBzrDir):
2072
2633
            a_bzrdir._ensure_real()
2073
2634
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2074
 
                name)
 
2635
                name, append_revisions_only=append_revisions_only)
2075
2636
        else:
2076
2637
            # We assume the bzrdir is parameterised; it may not be.
2077
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
2638
            result = self._custom_format.initialize(a_bzrdir, name,
 
2639
                append_revisions_only=append_revisions_only)
2078
2640
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2079
2641
            not isinstance(result, RemoteBranch)):
2080
2642
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2081
2643
                                  name=name)
2082
2644
        return result
2083
2645
 
2084
 
    def initialize(self, a_bzrdir, name=None):
 
2646
    def initialize(self, a_bzrdir, name=None, repository=None,
 
2647
                   append_revisions_only=None):
2085
2648
        # 1) get the network name to use.
2086
2649
        if self._custom_format:
2087
2650
            network_name = self._custom_format.network_name()
2088
2651
        else:
2089
2652
            # Select the current bzrlib default and ask for that.
2090
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
2653
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
2091
2654
            reference_format = reference_bzrdir_format.get_branch_format()
2092
2655
            self._custom_format = reference_format
2093
2656
            network_name = reference_format.network_name()
2094
2657
        # Being asked to create on a non RemoteBzrDir:
2095
2658
        if not isinstance(a_bzrdir, RemoteBzrDir):
2096
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2659
            return self._vfs_initialize(a_bzrdir, name=name,
 
2660
                append_revisions_only=append_revisions_only)
2097
2661
        medium = a_bzrdir._client._medium
2098
2662
        if medium._is_remote_before((1, 13)):
2099
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2663
            return self._vfs_initialize(a_bzrdir, name=name,
 
2664
                append_revisions_only=append_revisions_only)
2100
2665
        # Creating on a remote bzr dir.
2101
2666
        # 2) try direct creation via RPC
2102
2667
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2109
2674
        except errors.UnknownSmartMethod:
2110
2675
            # Fallback - use vfs methods
2111
2676
            medium._remember_remote_is_before((1, 13))
2112
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2677
            return self._vfs_initialize(a_bzrdir, name=name,
 
2678
                    append_revisions_only=append_revisions_only)
2113
2679
        if response[0] != 'ok':
2114
2680
            raise errors.UnexpectedSmartServerResponse(response)
2115
2681
        # Turn the response into a RemoteRepository object.
2116
2682
        format = RemoteBranchFormat(network_name=response[1])
2117
2683
        repo_format = response_tuple_to_repo_format(response[3:])
2118
 
        if response[2] == '':
2119
 
            repo_bzrdir = a_bzrdir
 
2684
        repo_path = response[2]
 
2685
        if repository is not None:
 
2686
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
 
2687
            url_diff = urlutils.relative_url(repository.user_url,
 
2688
                    remote_repo_url)
 
2689
            if url_diff != '.':
 
2690
                raise AssertionError(
 
2691
                    'repository.user_url %r does not match URL from server '
 
2692
                    'response (%r + %r)'
 
2693
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
 
2694
            remote_repo = repository
2120
2695
        else:
2121
 
            repo_bzrdir = RemoteBzrDir(
2122
 
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2123
 
                a_bzrdir._client)
2124
 
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
2696
            if repo_path == '':
 
2697
                repo_bzrdir = a_bzrdir
 
2698
            else:
 
2699
                repo_bzrdir = RemoteBzrDir(
 
2700
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
2701
                    a_bzrdir._client)
 
2702
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2125
2703
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2126
2704
            format=format, setup_stacking=False, name=name)
 
2705
        if append_revisions_only:
 
2706
            remote_branch.set_append_revisions_only(append_revisions_only)
2127
2707
        # XXX: We know this is a new branch, so it must have revno 0, revid
2128
2708
        # NULL_REVISION. Creating the branch locked would make this be unable
2129
2709
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2148
2728
        self._ensure_real()
2149
2729
        return self._custom_format.supports_set_append_revisions_only()
2150
2730
 
 
2731
    def _use_default_local_heads_to_fetch(self):
 
2732
        # If the branch format is a metadir format *and* its heads_to_fetch
 
2733
        # implementation is not overridden vs the base class, we can use the
 
2734
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
2735
        # usually cheaper in terms of net round trips, as the last-revision and
 
2736
        # tags info fetched is cached and would be fetched anyway.
 
2737
        self._ensure_real()
 
2738
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
2739
            branch_class = self._custom_format._branch_class()
 
2740
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
2741
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
2742
                return True
 
2743
        return False
 
2744
 
 
2745
 
 
2746
class RemoteBranchStore(config.IniFileStore):
 
2747
    """Branch store which attempts to use HPSS calls to retrieve branch store.
 
2748
 
 
2749
    Note that this is specific to bzr-based formats.
 
2750
    """
 
2751
 
 
2752
    def __init__(self, branch):
 
2753
        super(RemoteBranchStore, self).__init__()
 
2754
        self.branch = branch
 
2755
        self.id = "branch"
 
2756
        self._real_store = None
 
2757
 
 
2758
    def lock_write(self, token=None):
 
2759
        return self.branch.lock_write(token)
 
2760
 
 
2761
    def unlock(self):
 
2762
        return self.branch.unlock()
 
2763
 
 
2764
    @needs_write_lock
 
2765
    def save(self):
 
2766
        # We need to be able to override the undecorated implementation
 
2767
        self.save_without_locking()
 
2768
 
 
2769
    def save_without_locking(self):
 
2770
        super(RemoteBranchStore, self).save()
 
2771
 
 
2772
    def external_url(self):
 
2773
        return self.branch.user_url
 
2774
 
 
2775
    def _load_content(self):
 
2776
        path = self.branch._remote_path()
 
2777
        try:
 
2778
            response, handler = self.branch._call_expecting_body(
 
2779
                'Branch.get_config_file', path)
 
2780
        except errors.UnknownSmartMethod:
 
2781
            self._ensure_real()
 
2782
            return self._real_store._load_content()
 
2783
        if len(response) and response[0] != 'ok':
 
2784
            raise errors.UnexpectedSmartServerResponse(response)
 
2785
        return handler.read_body_bytes()
 
2786
 
 
2787
    def _save_content(self, content):
 
2788
        path = self.branch._remote_path()
 
2789
        try:
 
2790
            response, handler = self.branch._call_with_body_bytes_expecting_body(
 
2791
                'Branch.put_config_file', (path,
 
2792
                    self.branch._lock_token, self.branch._repo_lock_token),
 
2793
                content)
 
2794
        except errors.UnknownSmartMethod:
 
2795
            self._ensure_real()
 
2796
            return self._real_store._save_content(content)
 
2797
        handler.cancel_read_body()
 
2798
        if response != ('ok', ):
 
2799
            raise errors.UnexpectedSmartServerResponse(response)
 
2800
 
 
2801
    def _ensure_real(self):
 
2802
        self.branch._ensure_real()
 
2803
        if self._real_store is None:
 
2804
            self._real_store = config.BranchStore(self.branch)
 
2805
 
2151
2806
 
2152
2807
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2153
2808
    """Branch stored on a server accessed by HPSS RPC.
2156
2811
    """
2157
2812
 
2158
2813
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2159
 
        _client=None, format=None, setup_stacking=True, name=None):
 
2814
        _client=None, format=None, setup_stacking=True, name=None,
 
2815
        possible_transports=None):
2160
2816
        """Create a RemoteBranch instance.
2161
2817
 
2162
2818
        :param real_branch: An optional local implementation of the branch
2227
2883
            hook(self)
2228
2884
        self._is_stacked = False
2229
2885
        if setup_stacking:
2230
 
            self._setup_stacking()
 
2886
            self._setup_stacking(possible_transports)
2231
2887
 
2232
 
    def _setup_stacking(self):
 
2888
    def _setup_stacking(self, possible_transports):
2233
2889
        # configure stacking into the remote repository, by reading it from
2234
2890
        # the vfs branch.
2235
2891
        try:
2238
2894
            errors.UnstackableRepositoryFormat), e:
2239
2895
            return
2240
2896
        self._is_stacked = True
2241
 
        self._activate_fallback_location(fallback_url)
 
2897
        if possible_transports is None:
 
2898
            possible_transports = []
 
2899
        else:
 
2900
            possible_transports = list(possible_transports)
 
2901
        possible_transports.append(self.bzrdir.root_transport)
 
2902
        self._activate_fallback_location(fallback_url,
 
2903
            possible_transports=possible_transports)
2242
2904
 
2243
2905
    def _get_config(self):
2244
2906
        return RemoteBranchConfig(self)
2245
2907
 
 
2908
    def _get_config_store(self):
 
2909
        return RemoteBranchStore(self)
 
2910
 
2246
2911
    def _get_real_transport(self):
2247
2912
        # if we try vfs access, return the real branch's vfs transport
2248
2913
        self._ensure_real()
2311
2976
                self.bzrdir, self._client)
2312
2977
        return self._control_files
2313
2978
 
2314
 
    def _get_checkout_format(self):
 
2979
    def _get_checkout_format(self, lightweight=False):
2315
2980
        self._ensure_real()
2316
 
        return self._real_branch._get_checkout_format()
 
2981
        if lightweight:
 
2982
            format = RemoteBzrDirFormat()
 
2983
            self.bzrdir._format._supply_sub_formats_to(format)
 
2984
            format.workingtree_format = self._real_branch._get_checkout_format(
 
2985
                lightweight=lightweight).workingtree_format
 
2986
            return format
 
2987
        else:
 
2988
            return self._real_branch._get_checkout_format(lightweight=False)
2317
2989
 
2318
2990
    def get_physical_lock_status(self):
2319
2991
        """See Branch.get_physical_lock_status()."""
2320
 
        # should be an API call to the server, as branches must be lockable.
2321
 
        self._ensure_real()
2322
 
        return self._real_branch.get_physical_lock_status()
 
2992
        try:
 
2993
            response = self._client.call('Branch.get_physical_lock_status',
 
2994
                self._remote_path())
 
2995
        except errors.UnknownSmartMethod:
 
2996
            self._ensure_real()
 
2997
            return self._real_branch.get_physical_lock_status()
 
2998
        if response[0] not in ('yes', 'no'):
 
2999
            raise errors.UnexpectedSmartServerResponse(response)
 
3000
        return (response[0] == 'yes')
2323
3001
 
2324
3002
    def get_stacked_on_url(self):
2325
3003
        """Get the URL this branch is stacked against.
2352
3030
            self._is_stacked = False
2353
3031
        else:
2354
3032
            self._is_stacked = True
2355
 
        
 
3033
 
2356
3034
    def _vfs_get_tags_bytes(self):
2357
3035
        self._ensure_real()
2358
3036
        return self._real_branch._get_tags_bytes()
2359
3037
 
 
3038
    @needs_read_lock
2360
3039
    def _get_tags_bytes(self):
 
3040
        if self._tags_bytes is None:
 
3041
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
3042
        return self._tags_bytes
 
3043
 
 
3044
    def _get_tags_bytes_via_hpss(self):
2361
3045
        medium = self._client._medium
2362
3046
        if medium._is_remote_before((1, 13)):
2363
3047
            return self._vfs_get_tags_bytes()
2373
3057
        return self._real_branch._set_tags_bytes(bytes)
2374
3058
 
2375
3059
    def _set_tags_bytes(self, bytes):
 
3060
        if self.is_locked():
 
3061
            self._tags_bytes = bytes
2376
3062
        medium = self._client._medium
2377
3063
        if medium._is_remote_before((1, 18)):
2378
3064
            self._vfs_set_tags_bytes(bytes)
2387
3073
            self._vfs_set_tags_bytes(bytes)
2388
3074
 
2389
3075
    def lock_read(self):
 
3076
        """Lock the branch for read operations.
 
3077
 
 
3078
        :return: A bzrlib.lock.LogicalLockResult.
 
3079
        """
2390
3080
        self.repository.lock_read()
2391
3081
        if not self._lock_mode:
2392
3082
            self._note_lock('r')
2396
3086
                self._real_branch.lock_read()
2397
3087
        else:
2398
3088
            self._lock_count += 1
 
3089
        return lock.LogicalLockResult(self.unlock)
2399
3090
 
2400
3091
    def _remote_lock_write(self, token):
2401
3092
        if token is None:
2402
3093
            branch_token = repo_token = ''
2403
3094
        else:
2404
3095
            branch_token = token
2405
 
            repo_token = self.repository.lock_write()
 
3096
            repo_token = self.repository.lock_write().repository_token
2406
3097
            self.repository.unlock()
2407
3098
        err_context = {'token': token}
2408
 
        response = self._call(
2409
 
            'Branch.lock_write', self._remote_path(), branch_token,
2410
 
            repo_token or '', **err_context)
 
3099
        try:
 
3100
            response = self._call(
 
3101
                'Branch.lock_write', self._remote_path(), branch_token,
 
3102
                repo_token or '', **err_context)
 
3103
        except errors.LockContention, e:
 
3104
            # The LockContention from the server doesn't have any
 
3105
            # information about the lock_url. We re-raise LockContention
 
3106
            # with valid lock_url.
 
3107
            raise errors.LockContention('(remote lock)',
 
3108
                self.repository.base.split('.bzr/')[0])
2411
3109
        if response[0] != 'ok':
2412
3110
            raise errors.UnexpectedSmartServerResponse(response)
2413
3111
        ok, branch_token, repo_token = response
2434
3132
            self._lock_mode = 'w'
2435
3133
            self._lock_count = 1
2436
3134
        elif self._lock_mode == 'r':
2437
 
            raise errors.ReadOnlyTransaction
 
3135
            raise errors.ReadOnlyError(self)
2438
3136
        else:
2439
3137
            if token is not None:
2440
3138
                # A token was given to lock_write, and we're relocking, so
2445
3143
            self._lock_count += 1
2446
3144
            # Re-lock the repository too.
2447
3145
            self.repository.lock_write(self._repo_lock_token)
2448
 
        return self._lock_token or None
 
3146
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
2449
3147
 
2450
3148
    def _unlock(self, branch_token, repo_token):
2451
3149
        err_context = {'token': str((branch_token, repo_token))}
2489
3187
            self.repository.unlock()
2490
3188
 
2491
3189
    def break_lock(self):
2492
 
        self._ensure_real()
2493
 
        return self._real_branch.break_lock()
 
3190
        try:
 
3191
            response = self._call(
 
3192
                'Branch.break_lock', self._remote_path())
 
3193
        except errors.UnknownSmartMethod:
 
3194
            self._ensure_real()
 
3195
            return self._real_branch.break_lock()
 
3196
        if response != ('ok',):
 
3197
            raise errors.UnexpectedSmartServerResponse(response)
2494
3198
 
2495
3199
    def leave_lock_in_place(self):
2496
3200
        if not self._lock_token:
2520
3224
            missing_parent = parent_map[missing_parent]
2521
3225
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2522
3226
 
2523
 
    def _last_revision_info(self):
 
3227
    def _read_last_revision_info(self):
2524
3228
        response = self._call('Branch.last_revision_info', self._remote_path())
2525
3229
        if response[0] != 'ok':
2526
3230
            raise SmartProtocolError('unexpected response code %s' % (response,))
2589
3293
            raise errors.UnexpectedSmartServerResponse(response)
2590
3294
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2591
3295
 
 
3296
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2592
3297
    @needs_write_lock
2593
3298
    def set_revision_history(self, rev_history):
 
3299
        """See Branch.set_revision_history."""
 
3300
        self._set_revision_history(rev_history)
 
3301
 
 
3302
    @needs_write_lock
 
3303
    def _set_revision_history(self, rev_history):
2594
3304
        # Send just the tip revision of the history; the server will generate
2595
3305
        # the full history from that.  If the revision doesn't exist in this
2596
3306
        # branch, NoSuchRevision will be raised.
2654
3364
            _override_hook_target=self, **kwargs)
2655
3365
 
2656
3366
    @needs_read_lock
2657
 
    def push(self, target, overwrite=False, stop_revision=None):
 
3367
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2658
3368
        self._ensure_real()
2659
3369
        return self._real_branch.push(
2660
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
3370
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2661
3371
            _override_hook_source_branch=self)
2662
3372
 
2663
3373
    def is_locked(self):
2664
3374
        return self._lock_count >= 1
2665
3375
 
2666
3376
    @needs_read_lock
 
3377
    def revision_id_to_dotted_revno(self, revision_id):
 
3378
        """Given a revision id, return its dotted revno.
 
3379
 
 
3380
        :return: a tuple like (1,) or (400,1,3).
 
3381
        """
 
3382
        try:
 
3383
            response = self._call('Branch.revision_id_to_revno',
 
3384
                self._remote_path(), revision_id)
 
3385
        except errors.UnknownSmartMethod:
 
3386
            self._ensure_real()
 
3387
            return self._real_branch.revision_id_to_dotted_revno(revision_id)
 
3388
        if response[0] == 'ok':
 
3389
            return tuple([int(x) for x in response[1:]])
 
3390
        else:
 
3391
            raise errors.UnexpectedSmartServerResponse(response)
 
3392
 
 
3393
    @needs_read_lock
2667
3394
    def revision_id_to_revno(self, revision_id):
2668
 
        self._ensure_real()
2669
 
        return self._real_branch.revision_id_to_revno(revision_id)
 
3395
        """Given a revision id on the branch mainline, return its revno.
 
3396
 
 
3397
        :return: an integer
 
3398
        """
 
3399
        try:
 
3400
            response = self._call('Branch.revision_id_to_revno',
 
3401
                self._remote_path(), revision_id)
 
3402
        except errors.UnknownSmartMethod:
 
3403
            self._ensure_real()
 
3404
            return self._real_branch.revision_id_to_revno(revision_id)
 
3405
        if response[0] == 'ok':
 
3406
            if len(response) == 2:
 
3407
                return int(response[1])
 
3408
            raise NoSuchRevision(self, revision_id)
 
3409
        else:
 
3410
            raise errors.UnexpectedSmartServerResponse(response)
2670
3411
 
2671
3412
    @needs_write_lock
2672
3413
    def set_last_revision_info(self, revno, revision_id):
2673
3414
        # XXX: These should be returned by the set_last_revision_info verb
2674
3415
        old_revno, old_revid = self.last_revision_info()
2675
3416
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2676
 
        revision_id = ensure_null(revision_id)
 
3417
        if not revision_id or not isinstance(revision_id, basestring):
 
3418
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2677
3419
        try:
2678
3420
            response = self._call('Branch.set_last_revision_info',
2679
3421
                self._remote_path(), self._lock_token, self._repo_lock_token,
2708
3450
            except errors.UnknownSmartMethod:
2709
3451
                medium._remember_remote_is_before((1, 6))
2710
3452
        self._clear_cached_state_of_remote_branch_only()
2711
 
        self.set_revision_history(self._lefthand_history(revision_id,
 
3453
        self._set_revision_history(self._lefthand_history(revision_id,
2712
3454
            last_rev=last_rev,other_branch=other_branch))
2713
3455
 
2714
3456
    def set_push_location(self, location):
2715
3457
        self._ensure_real()
2716
3458
        return self._real_branch.set_push_location(location)
2717
3459
 
 
3460
    def heads_to_fetch(self):
 
3461
        if self._format._use_default_local_heads_to_fetch():
 
3462
            # We recognise this format, and its heads-to-fetch implementation
 
3463
            # is the default one (tip + tags).  In this case it's cheaper to
 
3464
            # just use the default implementation rather than a special RPC as
 
3465
            # the tip and tags data is cached.
 
3466
            return branch.Branch.heads_to_fetch(self)
 
3467
        medium = self._client._medium
 
3468
        if medium._is_remote_before((2, 4)):
 
3469
            return self._vfs_heads_to_fetch()
 
3470
        try:
 
3471
            return self._rpc_heads_to_fetch()
 
3472
        except errors.UnknownSmartMethod:
 
3473
            medium._remember_remote_is_before((2, 4))
 
3474
            return self._vfs_heads_to_fetch()
 
3475
 
 
3476
    def _rpc_heads_to_fetch(self):
 
3477
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3478
        if len(response) != 2:
 
3479
            raise errors.UnexpectedSmartServerResponse(response)
 
3480
        must_fetch, if_present_fetch = response
 
3481
        return set(must_fetch), set(if_present_fetch)
 
3482
 
 
3483
    def _vfs_heads_to_fetch(self):
 
3484
        self._ensure_real()
 
3485
        return self._real_branch.heads_to_fetch()
 
3486
 
2718
3487
 
2719
3488
class RemoteConfig(object):
2720
3489
    """A Config that reads and writes from smart verbs.
2734
3503
        """
2735
3504
        try:
2736
3505
            configobj = self._get_configobj()
 
3506
            section_obj = None
2737
3507
            if section is None:
2738
3508
                section_obj = configobj
2739
3509
            else:
2740
3510
                try:
2741
3511
                    section_obj = configobj[section]
2742
3512
                except KeyError:
2743
 
                    return default
2744
 
            return section_obj.get(name, default)
 
3513
                    pass
 
3514
            if section_obj is None:
 
3515
                value = default
 
3516
            else:
 
3517
                value = section_obj.get(name, default)
2745
3518
        except errors.UnknownSmartMethod:
2746
 
            return self._vfs_get_option(name, section, default)
 
3519
            value = self._vfs_get_option(name, section, default)
 
3520
        for hook in config.OldConfigHooks['get']:
 
3521
            hook(self, name, value)
 
3522
        return value
2747
3523
 
2748
3524
    def _response_to_configobj(self, response):
2749
3525
        if len(response[0]) and response[0][0] != 'ok':
2750
3526
            raise errors.UnexpectedSmartServerResponse(response)
2751
3527
        lines = response[1].read_body_bytes().splitlines()
2752
 
        return config.ConfigObj(lines, encoding='utf-8')
 
3528
        conf = config.ConfigObj(lines, encoding='utf-8')
 
3529
        for hook in config.OldConfigHooks['load']:
 
3530
            hook(self)
 
3531
        return conf
2753
3532
 
2754
3533
 
2755
3534
class RemoteBranchConfig(RemoteConfig):
2774
3553
        medium = self._branch._client._medium
2775
3554
        if medium._is_remote_before((1, 14)):
2776
3555
            return self._vfs_set_option(value, name, section)
 
3556
        if isinstance(value, dict):
 
3557
            if medium._is_remote_before((2, 2)):
 
3558
                return self._vfs_set_option(value, name, section)
 
3559
            return self._set_config_option_dict(value, name, section)
 
3560
        else:
 
3561
            return self._set_config_option(value, name, section)
 
3562
 
 
3563
    def _set_config_option(self, value, name, section):
2777
3564
        try:
2778
3565
            path = self._branch._remote_path()
2779
3566
            response = self._branch._client.call('Branch.set_config_option',
2780
3567
                path, self._branch._lock_token, self._branch._repo_lock_token,
2781
3568
                value.encode('utf8'), name, section or '')
2782
3569
        except errors.UnknownSmartMethod:
 
3570
            medium = self._branch._client._medium
2783
3571
            medium._remember_remote_is_before((1, 14))
2784
3572
            return self._vfs_set_option(value, name, section)
2785
3573
        if response != ():
2786
3574
            raise errors.UnexpectedSmartServerResponse(response)
2787
3575
 
 
3576
    def _serialize_option_dict(self, option_dict):
 
3577
        utf8_dict = {}
 
3578
        for key, value in option_dict.items():
 
3579
            if isinstance(key, unicode):
 
3580
                key = key.encode('utf8')
 
3581
            if isinstance(value, unicode):
 
3582
                value = value.encode('utf8')
 
3583
            utf8_dict[key] = value
 
3584
        return bencode.bencode(utf8_dict)
 
3585
 
 
3586
    def _set_config_option_dict(self, value, name, section):
 
3587
        try:
 
3588
            path = self._branch._remote_path()
 
3589
            serialised_dict = self._serialize_option_dict(value)
 
3590
            response = self._branch._client.call(
 
3591
                'Branch.set_config_option_dict',
 
3592
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
3593
                serialised_dict, name, section or '')
 
3594
        except errors.UnknownSmartMethod:
 
3595
            medium = self._branch._client._medium
 
3596
            medium._remember_remote_is_before((2, 2))
 
3597
            return self._vfs_set_option(value, name, section)
 
3598
        if response != ():
 
3599
            raise errors.UnexpectedSmartServerResponse(response)
 
3600
 
2788
3601
    def _real_object(self):
2789
3602
        self._branch._ensure_real()
2790
3603
        return self._branch._real_branch
2839
3652
        tar.extract(tarinfo, to_dir)
2840
3653
 
2841
3654
 
 
3655
error_translators = registry.Registry()
 
3656
no_context_error_translators = registry.Registry()
 
3657
 
 
3658
 
2842
3659
def _translate_error(err, **context):
2843
3660
    """Translate an ErrorFromSmartServer into a more useful error.
2844
3661
 
2873
3690
                    'Missing key %r in context %r', key_err.args[0], context)
2874
3691
                raise err
2875
3692
 
2876
 
    if err.error_verb == 'IncompatibleRepositories':
2877
 
        raise errors.IncompatibleRepositories(err.error_args[0],
2878
 
            err.error_args[1], err.error_args[2])
2879
 
    elif err.error_verb == 'NoSuchRevision':
2880
 
        raise NoSuchRevision(find('branch'), err.error_args[0])
2881
 
    elif err.error_verb == 'nosuchrevision':
2882
 
        raise NoSuchRevision(find('repository'), err.error_args[0])
2883
 
    elif err.error_verb == 'nobranch':
2884
 
        if len(err.error_args) >= 1:
2885
 
            extra = err.error_args[0]
2886
 
        else:
2887
 
            extra = None
2888
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
2889
 
            detail=extra)
2890
 
    elif err.error_verb == 'norepository':
2891
 
        raise errors.NoRepositoryPresent(find('bzrdir'))
2892
 
    elif err.error_verb == 'LockContention':
2893
 
        raise errors.LockContention('(remote lock)')
2894
 
    elif err.error_verb == 'UnlockableTransport':
2895
 
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
2896
 
    elif err.error_verb == 'LockFailed':
2897
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
2898
 
    elif err.error_verb == 'TokenMismatch':
2899
 
        raise errors.TokenMismatch(find('token'), '(remote token)')
2900
 
    elif err.error_verb == 'Diverged':
2901
 
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
2902
 
    elif err.error_verb == 'TipChangeRejected':
2903
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2904
 
    elif err.error_verb == 'UnstackableBranchFormat':
2905
 
        raise errors.UnstackableBranchFormat(*err.error_args)
2906
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
2907
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2908
 
    elif err.error_verb == 'NotStacked':
2909
 
        raise errors.NotStacked(branch=find('branch'))
2910
 
    elif err.error_verb == 'PermissionDenied':
2911
 
        path = get_path()
2912
 
        if len(err.error_args) >= 2:
2913
 
            extra = err.error_args[1]
2914
 
        else:
2915
 
            extra = None
2916
 
        raise errors.PermissionDenied(path, extra=extra)
2917
 
    elif err.error_verb == 'ReadError':
2918
 
        path = get_path()
2919
 
        raise errors.ReadError(path)
2920
 
    elif err.error_verb == 'NoSuchFile':
2921
 
        path = get_path()
2922
 
        raise errors.NoSuchFile(path)
2923
 
    elif err.error_verb == 'FileExists':
2924
 
        raise errors.FileExists(err.error_args[0])
2925
 
    elif err.error_verb == 'DirectoryNotEmpty':
2926
 
        raise errors.DirectoryNotEmpty(err.error_args[0])
2927
 
    elif err.error_verb == 'ShortReadvError':
2928
 
        args = err.error_args
2929
 
        raise errors.ShortReadvError(
2930
 
            args[0], int(args[1]), int(args[2]), int(args[3]))
2931
 
    elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
 
3693
    try:
 
3694
        translator = error_translators.get(err.error_verb)
 
3695
    except KeyError:
 
3696
        pass
 
3697
    else:
 
3698
        raise translator(err, find, get_path)
 
3699
    try:
 
3700
        translator = no_context_error_translators.get(err.error_verb)
 
3701
    except KeyError:
 
3702
        raise errors.UnknownErrorFromSmartServer(err)
 
3703
    else:
 
3704
        raise translator(err)
 
3705
 
 
3706
 
 
3707
error_translators.register('NoSuchRevision',
 
3708
    lambda err, find, get_path: NoSuchRevision(
 
3709
        find('branch'), err.error_args[0]))
 
3710
error_translators.register('nosuchrevision',
 
3711
    lambda err, find, get_path: NoSuchRevision(
 
3712
        find('repository'), err.error_args[0]))
 
3713
 
 
3714
def _translate_nobranch_error(err, find, get_path):
 
3715
    if len(err.error_args) >= 1:
 
3716
        extra = err.error_args[0]
 
3717
    else:
 
3718
        extra = None
 
3719
    return errors.NotBranchError(path=find('bzrdir').root_transport.base,
 
3720
        detail=extra)
 
3721
 
 
3722
error_translators.register('nobranch', _translate_nobranch_error)
 
3723
error_translators.register('norepository',
 
3724
    lambda err, find, get_path: errors.NoRepositoryPresent(
 
3725
        find('bzrdir')))
 
3726
error_translators.register('UnlockableTransport',
 
3727
    lambda err, find, get_path: errors.UnlockableTransport(
 
3728
        find('bzrdir').root_transport))
 
3729
error_translators.register('TokenMismatch',
 
3730
    lambda err, find, get_path: errors.TokenMismatch(
 
3731
        find('token'), '(remote token)'))
 
3732
error_translators.register('Diverged',
 
3733
    lambda err, find, get_path: errors.DivergedBranches(
 
3734
        find('branch'), find('other_branch')))
 
3735
error_translators.register('NotStacked',
 
3736
    lambda err, find, get_path: errors.NotStacked(branch=find('branch')))
 
3737
 
 
3738
def _translate_PermissionDenied(err, find, get_path):
 
3739
    path = get_path()
 
3740
    if len(err.error_args) >= 2:
 
3741
        extra = err.error_args[1]
 
3742
    else:
 
3743
        extra = None
 
3744
    return errors.PermissionDenied(path, extra=extra)
 
3745
 
 
3746
error_translators.register('PermissionDenied', _translate_PermissionDenied)
 
3747
error_translators.register('ReadError',
 
3748
    lambda err, find, get_path: errors.ReadError(get_path()))
 
3749
error_translators.register('NoSuchFile',
 
3750
    lambda err, find, get_path: errors.NoSuchFile(get_path()))
 
3751
no_context_error_translators.register('IncompatibleRepositories',
 
3752
    lambda err: errors.IncompatibleRepositories(
 
3753
        err.error_args[0], err.error_args[1], err.error_args[2]))
 
3754
no_context_error_translators.register('LockContention',
 
3755
    lambda err: errors.LockContention('(remote lock)'))
 
3756
no_context_error_translators.register('LockFailed',
 
3757
    lambda err: errors.LockFailed(err.error_args[0], err.error_args[1]))
 
3758
no_context_error_translators.register('TipChangeRejected',
 
3759
    lambda err: errors.TipChangeRejected(err.error_args[0].decode('utf8')))
 
3760
no_context_error_translators.register('UnstackableBranchFormat',
 
3761
    lambda err: errors.UnstackableBranchFormat(*err.error_args))
 
3762
no_context_error_translators.register('UnstackableRepositoryFormat',
 
3763
    lambda err: errors.UnstackableRepositoryFormat(*err.error_args))
 
3764
no_context_error_translators.register('FileExists',
 
3765
    lambda err: errors.FileExists(err.error_args[0]))
 
3766
no_context_error_translators.register('DirectoryNotEmpty',
 
3767
    lambda err: errors.DirectoryNotEmpty(err.error_args[0]))
 
3768
 
 
3769
def _translate_short_readv_error(err):
 
3770
    args = err.error_args
 
3771
    return errors.ShortReadvError(args[0], int(args[1]), int(args[2]),
 
3772
        int(args[3]))
 
3773
 
 
3774
no_context_error_translators.register('ShortReadvError',
 
3775
    _translate_short_readv_error)
 
3776
 
 
3777
def _translate_unicode_error(err):
2932
3778
        encoding = str(err.error_args[0]) # encoding must always be a string
2933
3779
        val = err.error_args[1]
2934
3780
        start = int(err.error_args[2])
2942
3788
            raise UnicodeDecodeError(encoding, val, start, end, reason)
2943
3789
        elif err.error_verb == 'UnicodeEncodeError':
2944
3790
            raise UnicodeEncodeError(encoding, val, start, end, reason)
2945
 
    elif err.error_verb == 'ReadOnlyError':
2946
 
        raise errors.TransportNotPossible('readonly transport')
2947
 
    raise errors.UnknownErrorFromSmartServer(err)
 
3791
 
 
3792
no_context_error_translators.register('UnicodeEncodeError',
 
3793
    _translate_unicode_error)
 
3794
no_context_error_translators.register('UnicodeDecodeError',
 
3795
    _translate_unicode_error)
 
3796
no_context_error_translators.register('ReadOnlyError',
 
3797
    lambda err: errors.TransportNotPossible('readonly transport'))
 
3798
no_context_error_translators.register('MemoryError',
 
3799
    lambda err: errors.BzrError("remote server out of memory\n"
 
3800
        "Retry non-remotely, or contact the server admin for details."))
 
3801
 
 
3802
no_context_error_translators.register('BzrCheckError',
 
3803
    lambda err: errors.BzrCheckError(msg=err.error_args[0]))
 
3804
 
 
3805
error_translators.register('UnsuspendableWriteGroup',
 
3806
    lambda err, find, get_path: errors.UnsuspendableWriteGroup(
 
3807
        repository=find('repository')))
 
3808
error_translators.register('UnresumableWriteGroup',
 
3809
    lambda err, find, get_path: errors.UnresumableWriteGroup(
 
3810
        repository=find('repository'), write_groups=err.error_args[0],
 
3811
        reason=err.error_args[1]))