← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
import bz2
 
18
import zlib
18
19
 
19
20
from bzrlib import (
20
21
    bencode,
21
22
    branch,
22
 
    bzrdir,
 
23
    bzrdir as _mod_bzrdir,
23
24
    config,
24
25
    controldir,
25
26
    debug,
26
27
    errors,
 
28
    gpg,
27
29
    graph,
28
30
    lock,
29
31
    lockdir,
30
 
    repository,
 
32
    osutils,
 
33
    registry,
31
34
    repository as _mod_repository,
32
 
    revision,
33
35
    revision as _mod_revision,
34
36
    static_tuple,
35
37
    symbol_versioning,
36
 
)
 
38
    testament as _mod_testament,
 
39
    urlutils,
 
40
    vf_repository,
 
41
    vf_search,
 
42
    )
37
43
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
38
 
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
39
44
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
40
45
from bzrlib.errors import (
41
46
    NoSuchRevision,
42
47
    SmartProtocolError,
43
48
    )
 
49
from bzrlib.i18n import gettext
 
50
from bzrlib.inventory import Inventory
44
51
from bzrlib.lockable_files import LockableFiles
45
52
from bzrlib.smart import client, vfs, repository as smart_repo
46
 
from bzrlib.revision import ensure_null, NULL_REVISION
47
 
from bzrlib.repository import RepositoryWriteLockResult
48
 
from bzrlib.trace import mutter, note, warning
 
53
from bzrlib.smart.client import _SmartClient
 
54
from bzrlib.revision import NULL_REVISION
 
55
from bzrlib.revisiontree import InventoryRevisionTree
 
56
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
 
57
from bzrlib.serializer import format_registry as serializer_format_registry
 
58
from bzrlib.trace import mutter, note, warning, log_exception_quietly
 
59
 
 
60
 
 
61
_DEFAULT_SEARCH_DEPTH = 100
49
62
 
50
63
 
51
64
class _RpcHelper(object):
88
101
    return format
89
102
 
90
103
 
91
 
# Note: RemoteBzrDirFormat is in bzrdir.py
92
 
 
93
 
class RemoteBzrDir(BzrDir, _RpcHelper):
 
104
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
 
105
# does not have to be imported unless a remote format is involved.
 
106
 
 
107
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
 
108
    """Format representing bzrdirs accessed via a smart server"""
 
109
 
 
110
    supports_workingtrees = False
 
111
 
 
112
    def __init__(self):
 
113
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
 
114
        # XXX: It's a bit ugly that the network name is here, because we'd
 
115
        # like to believe that format objects are stateless or at least
 
116
        # immutable,  However, we do at least avoid mutating the name after
 
117
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
 
118
        self._network_name = None
 
119
 
 
120
    def __repr__(self):
 
121
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
122
            self._network_name)
 
123
 
 
124
    def get_format_description(self):
 
125
        if self._network_name:
 
126
            try:
 
127
                real_format = controldir.network_format_registry.get(
 
128
                        self._network_name)
 
129
            except KeyError:
 
130
                pass
 
131
            else:
 
132
                return 'Remote: ' + real_format.get_format_description()
 
133
        return 'bzr remote bzrdir'
 
134
 
 
135
    def get_format_string(self):
 
136
        raise NotImplementedError(self.get_format_string)
 
137
 
 
138
    def network_name(self):
 
139
        if self._network_name:
 
140
            return self._network_name
 
141
        else:
 
142
            raise AssertionError("No network name set.")
 
143
 
 
144
    def initialize_on_transport(self, transport):
 
145
        try:
 
146
            # hand off the request to the smart server
 
147
            client_medium = transport.get_smart_medium()
 
148
        except errors.NoSmartMedium:
 
149
            # TODO: lookup the local format from a server hint.
 
150
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
151
            return local_dir_format.initialize_on_transport(transport)
 
152
        client = _SmartClient(client_medium)
 
153
        path = client.remote_path_from_transport(transport)
 
154
        try:
 
155
            response = client.call('BzrDirFormat.initialize', path)
 
156
        except errors.ErrorFromSmartServer, err:
 
157
            _translate_error(err, path=path)
 
158
        if response[0] != 'ok':
 
159
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
 
160
        format = RemoteBzrDirFormat()
 
161
        self._supply_sub_formats_to(format)
 
162
        return RemoteBzrDir(transport, format)
 
163
 
 
164
    def parse_NoneTrueFalse(self, arg):
 
165
        if not arg:
 
166
            return None
 
167
        if arg == 'False':
 
168
            return False
 
169
        if arg == 'True':
 
170
            return True
 
171
        raise AssertionError("invalid arg %r" % arg)
 
172
 
 
173
    def _serialize_NoneTrueFalse(self, arg):
 
174
        if arg is False:
 
175
            return 'False'
 
176
        if arg:
 
177
            return 'True'
 
178
        return ''
 
179
 
 
180
    def _serialize_NoneString(self, arg):
 
181
        return arg or ''
 
182
 
 
183
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
184
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
185
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
186
        shared_repo=False):
 
187
        try:
 
188
            # hand off the request to the smart server
 
189
            client_medium = transport.get_smart_medium()
 
190
        except errors.NoSmartMedium:
 
191
            do_vfs = True
 
192
        else:
 
193
            # Decline to open it if the server doesn't support our required
 
194
            # version (3) so that the VFS-based transport will do it.
 
195
            if client_medium.should_probe():
 
196
                try:
 
197
                    server_version = client_medium.protocol_version()
 
198
                    if server_version != '2':
 
199
                        do_vfs = True
 
200
                    else:
 
201
                        do_vfs = False
 
202
                except errors.SmartProtocolError:
 
203
                    # Apparently there's no usable smart server there, even though
 
204
                    # the medium supports the smart protocol.
 
205
                    do_vfs = True
 
206
            else:
 
207
                do_vfs = False
 
208
        if not do_vfs:
 
209
            client = _SmartClient(client_medium)
 
210
            path = client.remote_path_from_transport(transport)
 
211
            if client_medium._is_remote_before((1, 16)):
 
212
                do_vfs = True
 
213
        if do_vfs:
 
214
            # TODO: lookup the local format from a server hint.
 
215
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
216
            self._supply_sub_formats_to(local_dir_format)
 
217
            return local_dir_format.initialize_on_transport_ex(transport,
 
218
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
219
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
220
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
221
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
222
                vfs_only=True)
 
223
        return self._initialize_on_transport_ex_rpc(client, path, transport,
 
224
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
225
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
 
226
 
 
227
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
 
228
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
229
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
 
230
        args = []
 
231
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
 
232
        args.append(self._serialize_NoneTrueFalse(create_prefix))
 
233
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
 
234
        args.append(self._serialize_NoneString(stacked_on))
 
235
        # stack_on_pwd is often/usually our transport
 
236
        if stack_on_pwd:
 
237
            try:
 
238
                stack_on_pwd = transport.relpath(stack_on_pwd)
 
239
                if not stack_on_pwd:
 
240
                    stack_on_pwd = '.'
 
241
            except errors.PathNotChild:
 
242
                pass
 
243
        args.append(self._serialize_NoneString(stack_on_pwd))
 
244
        args.append(self._serialize_NoneString(repo_format_name))
 
245
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
 
246
        args.append(self._serialize_NoneTrueFalse(shared_repo))
 
247
        request_network_name = self._network_name or \
 
248
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
 
249
        try:
 
250
            response = client.call('BzrDirFormat.initialize_ex_1.16',
 
251
                request_network_name, path, *args)
 
252
        except errors.UnknownSmartMethod:
 
253
            client._medium._remember_remote_is_before((1,16))
 
254
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
255
            self._supply_sub_formats_to(local_dir_format)
 
256
            return local_dir_format.initialize_on_transport_ex(transport,
 
257
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
258
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
259
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
260
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
261
                vfs_only=True)
 
262
        except errors.ErrorFromSmartServer, err:
 
263
            _translate_error(err, path=path)
 
264
        repo_path = response[0]
 
265
        bzrdir_name = response[6]
 
266
        require_stacking = response[7]
 
267
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
 
268
        format = RemoteBzrDirFormat()
 
269
        format._network_name = bzrdir_name
 
270
        self._supply_sub_formats_to(format)
 
271
        bzrdir = RemoteBzrDir(transport, format, _client=client)
 
272
        if repo_path:
 
273
            repo_format = response_tuple_to_repo_format(response[1:])
 
274
            if repo_path == '.':
 
275
                repo_path = ''
 
276
            if repo_path:
 
277
                repo_bzrdir_format = RemoteBzrDirFormat()
 
278
                repo_bzrdir_format._network_name = response[5]
 
279
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
 
280
                    repo_bzrdir_format)
 
281
            else:
 
282
                repo_bzr = bzrdir
 
283
            final_stack = response[8] or None
 
284
            final_stack_pwd = response[9] or None
 
285
            if final_stack_pwd:
 
286
                final_stack_pwd = urlutils.join(
 
287
                    transport.base, final_stack_pwd)
 
288
            remote_repo = RemoteRepository(repo_bzr, repo_format)
 
289
            if len(response) > 10:
 
290
                # Updated server verb that locks remotely.
 
291
                repo_lock_token = response[10] or None
 
292
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
 
293
                if repo_lock_token:
 
294
                    remote_repo.dont_leave_lock_in_place()
 
295
            else:
 
296
                remote_repo.lock_write()
 
297
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
 
298
                final_stack_pwd, require_stacking)
 
299
            policy.acquire_repository()
 
300
        else:
 
301
            remote_repo = None
 
302
            policy = None
 
303
        bzrdir._format.set_branch_format(self.get_branch_format())
 
304
        if require_stacking:
 
305
            # The repo has already been created, but we need to make sure that
 
306
            # we'll make a stackable branch.
 
307
            bzrdir._format.require_stacking(_skip_repo=True)
 
308
        return remote_repo, bzrdir, require_stacking, policy
 
309
 
 
310
    def _open(self, transport):
 
311
        return RemoteBzrDir(transport, self)
 
312
 
 
313
    def __eq__(self, other):
 
314
        if not isinstance(other, RemoteBzrDirFormat):
 
315
            return False
 
316
        return self.get_format_description() == other.get_format_description()
 
317
 
 
318
    def __return_repository_format(self):
 
319
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
 
320
        # repository format has been asked for, tell the RemoteRepositoryFormat
 
321
        # that it should use that for init() etc.
 
322
        result = RemoteRepositoryFormat()
 
323
        custom_format = getattr(self, '_repository_format', None)
 
324
        if custom_format:
 
325
            if isinstance(custom_format, RemoteRepositoryFormat):
 
326
                return custom_format
 
327
            else:
 
328
                # We will use the custom format to create repositories over the
 
329
                # wire; expose its details like rich_root_data for code to
 
330
                # query
 
331
                result._custom_format = custom_format
 
332
        return result
 
333
 
 
334
    def get_branch_format(self):
 
335
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
 
336
        if not isinstance(result, RemoteBranchFormat):
 
337
            new_result = RemoteBranchFormat()
 
338
            new_result._custom_format = result
 
339
            # cache the result
 
340
            self.set_branch_format(new_result)
 
341
            result = new_result
 
342
        return result
 
343
 
 
344
    repository_format = property(__return_repository_format,
 
345
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
 
346
 
 
347
 
 
348
class RemoteControlStore(config.IniFileStore):
 
349
    """Control store which attempts to use HPSS calls to retrieve control store.
 
350
 
 
351
    Note that this is specific to bzr-based formats.
 
352
    """
 
353
 
 
354
    def __init__(self, bzrdir):
 
355
        super(RemoteControlStore, self).__init__()
 
356
        self.bzrdir = bzrdir
 
357
        self._real_store = None
 
358
 
 
359
    def lock_write(self, token=None):
 
360
        self._ensure_real()
 
361
        return self._real_store.lock_write(token)
 
362
 
 
363
    def unlock(self):
 
364
        self._ensure_real()
 
365
        return self._real_store.unlock()
 
366
 
 
367
    @needs_write_lock
 
368
    def save(self):
 
369
        # We need to be able to override the undecorated implementation
 
370
        self.save_without_locking()
 
371
 
 
372
    def save_without_locking(self):
 
373
        super(RemoteControlStore, self).save()
 
374
 
 
375
    def _ensure_real(self):
 
376
        self.bzrdir._ensure_real()
 
377
        if self._real_store is None:
 
378
            self._real_store = config.ControlStore(self.bzrdir)
 
379
 
 
380
    def external_url(self):
 
381
        return self.bzrdir.user_url
 
382
 
 
383
    def _load_content(self):
 
384
        medium = self.bzrdir._client._medium
 
385
        path = self.bzrdir._path_for_remote_call(self.bzrdir._client)
 
386
        try:
 
387
            response, handler = self.bzrdir._call_expecting_body(
 
388
                'BzrDir.get_config_file', path)
 
389
        except errors.UnknownSmartMethod:
 
390
            self._ensure_real()
 
391
            return self._real_store._load_content()
 
392
        if len(response) and response[0] != 'ok':
 
393
            raise errors.UnexpectedSmartServerResponse(response)
 
394
        return handler.read_body_bytes()
 
395
 
 
396
    def _save_content(self, content):
 
397
        # FIXME JRV 2011-11-22: Ideally this should use a
 
398
        # HPSS call too, but at the moment it is not possible
 
399
        # to write lock control directories.
 
400
        self._ensure_real()
 
401
        return self._real_store._save_content(content)
 
402
 
 
403
 
 
404
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
94
405
    """Control directory on a remote server, accessed via bzr:// or similar."""
95
406
 
96
407
    def __init__(self, transport, format, _client=None, _force_probe=False):
99
410
        :param _client: Private parameter for testing. Disables probing and the
100
411
            use of a real bzrdir.
101
412
        """
102
 
        BzrDir.__init__(self, transport, format)
 
413
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
103
414
        # this object holds a delegated bzrdir that uses file-level operations
104
415
        # to talk to the other side
105
416
        self._real_bzrdir = None
165
476
                import traceback
166
477
                warning('VFS BzrDir access triggered\n%s',
167
478
                    ''.join(traceback.format_stack()))
168
 
            self._real_bzrdir = BzrDir.open_from_transport(
 
479
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
169
480
                self.root_transport, _server_formats=False)
170
481
            self._format._network_name = \
171
482
                self._real_bzrdir._format.network_name()
177
488
        # Prevent aliasing problems in the next_open_branch_result cache.
178
489
        # See create_branch for rationale.
179
490
        self._next_open_branch_result = None
180
 
        return BzrDir.break_lock(self)
 
491
        return _mod_bzrdir.BzrDir.break_lock(self)
181
492
 
182
493
    def _vfs_cloning_metadir(self, require_stacking=False):
183
494
        self._ensure_real()
214
525
        if len(branch_info) != 2:
215
526
            raise errors.UnexpectedSmartServerResponse(response)
216
527
        branch_ref, branch_name = branch_info
217
 
        format = controldir.network_format_registry.get(control_name)
 
528
        try:
 
529
            format = controldir.network_format_registry.get(control_name)
 
530
        except KeyError:
 
531
            raise errors.UnknownFormatError(kind='control', format=control_name)
 
532
 
218
533
        if repo_name:
219
 
            format.repository_format = repository.network_format_registry.get(
220
 
                repo_name)
 
534
            try:
 
535
                format.repository_format = _mod_repository.network_format_registry.get(
 
536
                    repo_name)
 
537
            except KeyError:
 
538
                raise errors.UnknownFormatError(kind='repository',
 
539
                    format=repo_name)
221
540
        if branch_ref == 'ref':
222
541
            # XXX: we need possible_transports here to avoid reopening the
223
542
            # connection to the referenced location
224
 
            ref_bzrdir = BzrDir.open(branch_name)
 
543
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
225
544
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
226
545
            format.set_branch_format(branch_format)
227
546
        elif branch_ref == 'branch':
228
547
            if branch_name:
229
 
                format.set_branch_format(
230
 
                    branch.network_format_registry.get(branch_name))
 
548
                try:
 
549
                    branch_format = branch.network_format_registry.get(
 
550
                        branch_name)
 
551
                except KeyError:
 
552
                    raise errors.UnknownFormatError(kind='branch',
 
553
                        format=branch_name)
 
554
                format.set_branch_format(branch_format)
231
555
        else:
232
556
            raise errors.UnexpectedSmartServerResponse(response)
233
557
        return format
243
567
 
244
568
    def destroy_repository(self):
245
569
        """See BzrDir.destroy_repository"""
246
 
        self._ensure_real()
247
 
        self._real_bzrdir.destroy_repository()
 
570
        path = self._path_for_remote_call(self._client)
 
571
        try:
 
572
            response = self._call('BzrDir.destroy_repository', path)
 
573
        except errors.UnknownSmartMethod:
 
574
            self._ensure_real()
 
575
            self._real_bzrdir.destroy_repository()
 
576
            return
 
577
        if response[0] != 'ok':
 
578
            raise SmartProtocolError('unexpected response code %s' % (response,))
248
579
 
249
 
    def create_branch(self, name=None):
 
580
    def create_branch(self, name=None, repository=None,
 
581
                      append_revisions_only=None):
250
582
        # as per meta1 formats - just delegate to the format object which may
251
583
        # be parameterised.
252
584
        real_branch = self._format.get_branch_format().initialize(self,
253
 
            name=name)
 
585
            name=name, repository=repository,
 
586
            append_revisions_only=append_revisions_only)
254
587
        if not isinstance(real_branch, RemoteBranch):
255
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
256
 
                                  name=name)
 
588
            if not isinstance(repository, RemoteRepository):
 
589
                raise AssertionError(
 
590
                    'need a RemoteRepository to use with RemoteBranch, got %r'
 
591
                    % (repository,))
 
592
            result = RemoteBranch(self, repository, real_branch, name=name)
257
593
        else:
258
594
            result = real_branch
259
595
        # BzrDir.clone_on_transport() uses the result of create_branch but does
267
603
 
268
604
    def destroy_branch(self, name=None):
269
605
        """See BzrDir.destroy_branch"""
270
 
        self._ensure_real()
271
 
        self._real_bzrdir.destroy_branch(name=name)
 
606
        path = self._path_for_remote_call(self._client)
 
607
        try:
 
608
            if name is not None:
 
609
                args = (name, )
 
610
            else:
 
611
                args = ()
 
612
            response = self._call('BzrDir.destroy_branch', path, *args)
 
613
        except errors.UnknownSmartMethod:
 
614
            self._ensure_real()
 
615
            self._real_bzrdir.destroy_branch(name=name)
 
616
            self._next_open_branch_result = None
 
617
            return
272
618
        self._next_open_branch_result = None
 
619
        if response[0] != 'ok':
 
620
            raise SmartProtocolError('unexpected response code %s' % (response,))
273
621
 
274
 
    def create_workingtree(self, revision_id=None, from_branch=None):
 
622
    def create_workingtree(self, revision_id=None, from_branch=None,
 
623
        accelerator_tree=None, hardlink=False):
275
624
        raise errors.NotLocalUrl(self.transport.base)
276
625
 
277
626
    def find_branch_format(self, name=None):
328
677
        return None, self.open_branch(name=name)
329
678
 
330
679
    def open_branch(self, name=None, unsupported=False,
331
 
                    ignore_fallbacks=False):
 
680
                    ignore_fallbacks=False, possible_transports=None):
332
681
        if unsupported:
333
682
            raise NotImplementedError('unsupported flag support not implemented yet.')
334
683
        if self._next_open_branch_result is not None:
341
690
            # a branch reference, use the existing BranchReference logic.
342
691
            format = BranchReferenceFormat()
343
692
            return format.open(self, name=name, _found=True,
344
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
 
693
                location=response[1], ignore_fallbacks=ignore_fallbacks,
 
694
                possible_transports=possible_transports)
345
695
        branch_format_name = response[1]
346
696
        if not branch_format_name:
347
697
            branch_format_name = None
348
698
        format = RemoteBranchFormat(network_name=branch_format_name)
349
699
        return RemoteBranch(self, self.find_repository(), format=format,
350
 
            setup_stacking=not ignore_fallbacks, name=name)
 
700
            setup_stacking=not ignore_fallbacks, name=name,
 
701
            possible_transports=possible_transports)
351
702
 
352
703
    def _open_repo_v1(self, path):
353
704
        verb = 'BzrDir.find_repository'
416
767
 
417
768
    def has_workingtree(self):
418
769
        if self._has_working_tree is None:
419
 
            self._ensure_real()
420
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
 
770
            path = self._path_for_remote_call(self._client)
 
771
            try:
 
772
                response = self._call('BzrDir.has_workingtree', path)
 
773
            except errors.UnknownSmartMethod:
 
774
                self._ensure_real()
 
775
                self._has_working_tree = self._real_bzrdir.has_workingtree()
 
776
            else:
 
777
                if response[0] not in ('yes', 'no'):
 
778
                    raise SmartProtocolError('unexpected response code %s' % (response,))
 
779
                self._has_working_tree = (response[0] == 'yes')
421
780
        return self._has_working_tree
422
781
 
423
782
    def open_workingtree(self, recommend_upgrade=True):
428
787
 
429
788
    def _path_for_remote_call(self, client):
430
789
        """Return the path to be used for this bzrdir in a remote call."""
431
 
        return client.remote_path_from_transport(self.root_transport)
 
790
        return urlutils.split_segment_parameters_raw(
 
791
            client.remote_path_from_transport(self.root_transport))[0]
432
792
 
433
793
    def get_branch_transport(self, branch_format, name=None):
434
794
        self._ensure_real()
446
806
        """Upgrading of remote bzrdirs is not supported yet."""
447
807
        return False
448
808
 
449
 
    def needs_format_conversion(self, format=None):
 
809
    def needs_format_conversion(self, format):
450
810
        """Upgrading of remote bzrdirs is not supported yet."""
451
 
        if format is None:
452
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
453
 
                % 'needs_format_conversion(format=None)')
454
811
        return False
455
812
 
456
 
    def clone(self, url, revision_id=None, force_new_repo=False,
457
 
              preserve_stacking=False):
458
 
        self._ensure_real()
459
 
        return self._real_bzrdir.clone(url, revision_id=revision_id,
460
 
            force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
461
 
 
462
813
    def _get_config(self):
463
814
        return RemoteBzrDirConfig(self)
464
815
 
465
 
 
466
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
816
    def _get_config_store(self):
 
817
        return RemoteControlStore(self)
 
818
 
 
819
 
 
820
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
467
821
    """Format for repositories accessed over a _SmartClient.
468
822
 
469
823
    Instances of this repository are represented by RemoteRepository
484
838
    """
485
839
 
486
840
    _matchingbzrdir = RemoteBzrDirFormat()
 
841
    supports_full_versioned_files = True
 
842
    supports_leaving_lock = True
487
843
 
488
844
    def __init__(self):
489
 
        repository.RepositoryFormat.__init__(self)
 
845
        _mod_repository.RepositoryFormat.__init__(self)
490
846
        self._custom_format = None
491
847
        self._network_name = None
492
848
        self._creating_bzrdir = None
 
849
        self._revision_graph_can_have_wrong_parents = None
493
850
        self._supports_chks = None
494
851
        self._supports_external_lookups = None
495
852
        self._supports_tree_reference = None
 
853
        self._supports_funky_characters = None
 
854
        self._supports_nesting_repositories = None
496
855
        self._rich_root_data = None
497
856
 
498
857
    def __repr__(self):
527
886
        return self._supports_external_lookups
528
887
 
529
888
    @property
 
889
    def supports_funky_characters(self):
 
890
        if self._supports_funky_characters is None:
 
891
            self._ensure_real()
 
892
            self._supports_funky_characters = \
 
893
                self._custom_format.supports_funky_characters
 
894
        return self._supports_funky_characters
 
895
 
 
896
    @property
 
897
    def supports_nesting_repositories(self):
 
898
        if self._supports_nesting_repositories is None:
 
899
            self._ensure_real()
 
900
            self._supports_nesting_repositories = \
 
901
                self._custom_format.supports_nesting_repositories
 
902
        return self._supports_nesting_repositories
 
903
 
 
904
    @property
530
905
    def supports_tree_reference(self):
531
906
        if self._supports_tree_reference is None:
532
907
            self._ensure_real()
534
909
                self._custom_format.supports_tree_reference
535
910
        return self._supports_tree_reference
536
911
 
 
912
    @property
 
913
    def revision_graph_can_have_wrong_parents(self):
 
914
        if self._revision_graph_can_have_wrong_parents is None:
 
915
            self._ensure_real()
 
916
            self._revision_graph_can_have_wrong_parents = \
 
917
                self._custom_format.revision_graph_can_have_wrong_parents
 
918
        return self._revision_graph_can_have_wrong_parents
 
919
 
537
920
    def _vfs_initialize(self, a_bzrdir, shared):
538
921
        """Helper for common code in initialize."""
539
922
        if self._custom_format:
574
957
            network_name = self._network_name
575
958
        else:
576
959
            # Select the current bzrlib default and ask for that.
577
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
960
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
578
961
            reference_format = reference_bzrdir_format.repository_format
579
962
            network_name = reference_format.network_name()
580
963
        # 2) try direct creation via RPC
606
989
 
607
990
    def _ensure_real(self):
608
991
        if self._custom_format is None:
609
 
            self._custom_format = repository.network_format_registry.get(
610
 
                self._network_name)
 
992
            try:
 
993
                self._custom_format = _mod_repository.network_format_registry.get(
 
994
                    self._network_name)
 
995
            except KeyError:
 
996
                raise errors.UnknownFormatError(kind='repository',
 
997
                    format=self._network_name)
611
998
 
612
999
    @property
613
1000
    def _fetch_order(self):
648
1035
        return self._custom_format._serializer
649
1036
 
650
1037
 
651
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
652
 
    controldir.ControlComponent):
 
1038
class RemoteRepository(_mod_repository.Repository, _RpcHelper,
 
1039
        lock._RelockDebugMixin):
653
1040
    """Repository accessed over rpc.
654
1041
 
655
1042
    For the moment most operations are performed using local transport-backed
679
1066
        self._format = format
680
1067
        self._lock_mode = None
681
1068
        self._lock_token = None
 
1069
        self._write_group_tokens = None
682
1070
        self._lock_count = 0
683
1071
        self._leave_lock = False
684
1072
        # Cache of revision parents; misses are cached during read locks, and
708
1096
        # transport, but I'm not sure it's worth making this method
709
1097
        # optional -- mbp 2010-04-21
710
1098
        return self.bzrdir.get_repository_transport(None)
711
 
        
 
1099
 
712
1100
    def __str__(self):
713
1101
        return "%s(%s)" % (self.__class__.__name__, self.base)
714
1102
 
724
1112
 
725
1113
        :param suppress_errors: see Repository.abort_write_group.
726
1114
        """
727
 
        self._ensure_real()
728
 
        return self._real_repository.abort_write_group(
729
 
            suppress_errors=suppress_errors)
 
1115
        if self._real_repository:
 
1116
            self._ensure_real()
 
1117
            return self._real_repository.abort_write_group(
 
1118
                suppress_errors=suppress_errors)
 
1119
        if not self.is_in_write_group():
 
1120
            if suppress_errors:
 
1121
                mutter('(suppressed) not in write group')
 
1122
                return
 
1123
            raise errors.BzrError("not in write group")
 
1124
        path = self.bzrdir._path_for_remote_call(self._client)
 
1125
        try:
 
1126
            response = self._call('Repository.abort_write_group', path,
 
1127
                self._lock_token, self._write_group_tokens)
 
1128
        except Exception, exc:
 
1129
            self._write_group = None
 
1130
            if not suppress_errors:
 
1131
                raise
 
1132
            mutter('abort_write_group failed')
 
1133
            log_exception_quietly()
 
1134
            note(gettext('bzr: ERROR (ignored): %s'), exc)
 
1135
        else:
 
1136
            if response != ('ok', ):
 
1137
                raise errors.UnexpectedSmartServerResponse(response)
 
1138
            self._write_group_tokens = None
730
1139
 
731
1140
    @property
732
1141
    def chk_bytes(self):
746
1155
        for older plugins that don't use e.g. the CommitBuilder
747
1156
        facility.
748
1157
        """
749
 
        self._ensure_real()
750
 
        return self._real_repository.commit_write_group()
 
1158
        if self._real_repository:
 
1159
            self._ensure_real()
 
1160
            return self._real_repository.commit_write_group()
 
1161
        if not self.is_in_write_group():
 
1162
            raise errors.BzrError("not in write group")
 
1163
        path = self.bzrdir._path_for_remote_call(self._client)
 
1164
        response = self._call('Repository.commit_write_group', path,
 
1165
            self._lock_token, self._write_group_tokens)
 
1166
        if response != ('ok', ):
 
1167
            raise errors.UnexpectedSmartServerResponse(response)
 
1168
        self._write_group_tokens = None
751
1169
 
752
1170
    def resume_write_group(self, tokens):
753
 
        self._ensure_real()
754
 
        return self._real_repository.resume_write_group(tokens)
 
1171
        if self._real_repository:
 
1172
            return self._real_repository.resume_write_group(tokens)
 
1173
        path = self.bzrdir._path_for_remote_call(self._client)
 
1174
        try:
 
1175
            response = self._call('Repository.check_write_group', path,
 
1176
               self._lock_token, tokens)
 
1177
        except errors.UnknownSmartMethod:
 
1178
            self._ensure_real()
 
1179
            return self._real_repository.resume_write_group(tokens)
 
1180
        if response != ('ok', ):
 
1181
            raise errors.UnexpectedSmartServerResponse(response)
 
1182
        self._write_group_tokens = tokens
755
1183
 
756
1184
    def suspend_write_group(self):
757
 
        self._ensure_real()
758
 
        return self._real_repository.suspend_write_group()
 
1185
        if self._real_repository:
 
1186
            return self._real_repository.suspend_write_group()
 
1187
        ret = self._write_group_tokens or []
 
1188
        self._write_group_tokens = None
 
1189
        return ret
759
1190
 
760
1191
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
761
1192
        self._ensure_real()
822
1253
    def find_text_key_references(self):
823
1254
        """Find the text key references within the repository.
824
1255
 
825
 
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
826
 
        revision_ids. Each altered file-ids has the exact revision_ids that
827
 
        altered it listed explicitly.
828
1256
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
829
1257
            to whether they were referred to by the inventory of the
830
1258
            revision_id that they contain. The inventory texts from all present
848
1276
        """Private method for using with old (< 1.2) servers to fallback."""
849
1277
        if revision_id is None:
850
1278
            revision_id = ''
851
 
        elif revision.is_null(revision_id):
 
1279
        elif _mod_revision.is_null(revision_id):
852
1280
            return {}
853
1281
 
854
1282
        path = self.bzrdir._path_for_remote_call(self._client)
878
1306
        return RemoteStreamSource(self, to_format)
879
1307
 
880
1308
    @needs_read_lock
 
1309
    def get_file_graph(self):
 
1310
        return graph.Graph(self.texts)
 
1311
 
 
1312
    @needs_read_lock
881
1313
    def has_revision(self, revision_id):
882
1314
        """True if this repository has a copy of the revision."""
883
1315
        # Copy of bzrlib.repository.Repository.has_revision
935
1367
        """See Repository.gather_stats()."""
936
1368
        path = self.bzrdir._path_for_remote_call(self._client)
937
1369
        # revid can be None to indicate no revisions, not just NULL_REVISION
938
 
        if revid is None or revision.is_null(revid):
 
1370
        if revid is None or _mod_revision.is_null(revid):
939
1371
            fmt_revid = ''
940
1372
        else:
941
1373
            fmt_revid = revid
970
1402
 
971
1403
    def get_physical_lock_status(self):
972
1404
        """See Repository.get_physical_lock_status()."""
973
 
        # should be an API call to the server.
974
 
        self._ensure_real()
975
 
        return self._real_repository.get_physical_lock_status()
 
1405
        path = self.bzrdir._path_for_remote_call(self._client)
 
1406
        try:
 
1407
            response = self._call('Repository.get_physical_lock_status', path)
 
1408
        except errors.UnknownSmartMethod:
 
1409
            self._ensure_real()
 
1410
            return self._real_repository.get_physical_lock_status()
 
1411
        if response[0] not in ('yes', 'no'):
 
1412
            raise errors.UnexpectedSmartServerResponse(response)
 
1413
        return (response[0] == 'yes')
976
1414
 
977
1415
    def is_in_write_group(self):
978
1416
        """Return True if there is an open write group.
979
1417
 
980
1418
        write groups are only applicable locally for the smart server..
981
1419
        """
 
1420
        if self._write_group_tokens is not None:
 
1421
            return True
982
1422
        if self._real_repository:
983
1423
            return self._real_repository.is_in_write_group()
984
1424
 
1119
1559
            self._real_repository.lock_write(self._lock_token)
1120
1560
        elif self._lock_mode == 'r':
1121
1561
            self._real_repository.lock_read()
 
1562
        if self._write_group_tokens is not None:
 
1563
            # if we are already in a write group, resume it
 
1564
            self._real_repository.resume_write_group(self._write_group_tokens)
 
1565
            self._write_group_tokens = None
1122
1566
 
1123
1567
    def start_write_group(self):
1124
1568
        """Start a write group on the decorated repository.
1128
1572
        for older plugins that don't use e.g. the CommitBuilder
1129
1573
        facility.
1130
1574
        """
1131
 
        self._ensure_real()
1132
 
        return self._real_repository.start_write_group()
 
1575
        if self._real_repository:
 
1576
            self._ensure_real()
 
1577
            return self._real_repository.start_write_group()
 
1578
        if not self.is_write_locked():
 
1579
            raise errors.NotWriteLocked(self)
 
1580
        if self._write_group_tokens is not None:
 
1581
            raise errors.BzrError('already in a write group')
 
1582
        path = self.bzrdir._path_for_remote_call(self._client)
 
1583
        try:
 
1584
            response = self._call('Repository.start_write_group', path,
 
1585
                self._lock_token)
 
1586
        except (errors.UnknownSmartMethod, errors.UnsuspendableWriteGroup):
 
1587
            self._ensure_real()
 
1588
            return self._real_repository.start_write_group()
 
1589
        if response[0] != 'ok':
 
1590
            raise errors.UnexpectedSmartServerResponse(response)
 
1591
        self._write_group_tokens = response[1]
1133
1592
 
1134
1593
    def _unlock(self, token):
1135
1594
        path = self.bzrdir._path_for_remote_call(self._client)
1162
1621
            # This is just to let the _real_repository stay up to date.
1163
1622
            if self._real_repository is not None:
1164
1623
                self._real_repository.unlock()
 
1624
            elif self._write_group_tokens is not None:
 
1625
                self.abort_write_group()
1165
1626
        finally:
1166
1627
            # The rpc-level lock should be released even if there was a
1167
1628
            # problem releasing the vfs-based lock.
1179
1640
 
1180
1641
    def break_lock(self):
1181
1642
        # should hand off to the network
1182
 
        self._ensure_real()
1183
 
        return self._real_repository.break_lock()
 
1643
        path = self.bzrdir._path_for_remote_call(self._client)
 
1644
        try:
 
1645
            response = self._call("Repository.break_lock", path)
 
1646
        except errors.UnknownSmartMethod:
 
1647
            self._ensure_real()
 
1648
            return self._real_repository.break_lock()
 
1649
        if response != ('ok',):
 
1650
            raise errors.UnexpectedSmartServerResponse(response)
1184
1651
 
1185
1652
    def _get_tarball(self, compression):
1186
1653
        """Return a TemporaryFile containing a repository tarball.
1204
1671
            return t
1205
1672
        raise errors.UnexpectedSmartServerResponse(response)
1206
1673
 
 
1674
    @needs_read_lock
1207
1675
    def sprout(self, to_bzrdir, revision_id=None):
1208
 
        # TODO: Option to control what format is created?
1209
 
        self._ensure_real()
1210
 
        dest_repo = self._real_repository._format.initialize(to_bzrdir,
1211
 
                                                             shared=False)
 
1676
        """Create a descendent repository for new development.
 
1677
 
 
1678
        Unlike clone, this does not copy the settings of the repository.
 
1679
        """
 
1680
        dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
1212
1681
        dest_repo.fetch(self, revision_id=revision_id)
1213
1682
        return dest_repo
1214
1683
 
 
1684
    def _create_sprouting_repo(self, a_bzrdir, shared):
 
1685
        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
 
1686
            # use target default format.
 
1687
            dest_repo = a_bzrdir.create_repository()
 
1688
        else:
 
1689
            # Most control formats need the repository to be specifically
 
1690
            # created, but on some old all-in-one formats it's not needed
 
1691
            try:
 
1692
                dest_repo = self._format.initialize(a_bzrdir, shared=shared)
 
1693
            except errors.UninitializableFormat:
 
1694
                dest_repo = a_bzrdir.open_repository()
 
1695
        return dest_repo
 
1696
 
1215
1697
    ### These methods are just thin shims to the VFS object for now.
1216
1698
 
 
1699
    @needs_read_lock
1217
1700
    def revision_tree(self, revision_id):
1218
 
        self._ensure_real()
1219
 
        return self._real_repository.revision_tree(revision_id)
 
1701
        revision_id = _mod_revision.ensure_null(revision_id)
 
1702
        if revision_id == _mod_revision.NULL_REVISION:
 
1703
            return InventoryRevisionTree(self,
 
1704
                Inventory(root_id=None), _mod_revision.NULL_REVISION)
 
1705
        else:
 
1706
            return list(self.revision_trees([revision_id]))[0]
1220
1707
 
1221
1708
    def get_serializer_format(self):
1222
 
        self._ensure_real()
1223
 
        return self._real_repository.get_serializer_format()
 
1709
        path = self.bzrdir._path_for_remote_call(self._client)
 
1710
        try:
 
1711
            response = self._call('VersionedFileRepository.get_serializer_format',
 
1712
                path)
 
1713
        except errors.UnknownSmartMethod:
 
1714
            self._ensure_real()
 
1715
            return self._real_repository.get_serializer_format()
 
1716
        if response[0] != 'ok':
 
1717
            raise errors.UnexpectedSmartServerResponse(response)
 
1718
        return response[1]
1224
1719
 
1225
1720
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1226
1721
                           timezone=None, committer=None, revprops=None,
1227
 
                           revision_id=None):
 
1722
                           revision_id=None, lossy=False):
1228
1723
        # FIXME: It ought to be possible to call this without immediately
1229
1724
        # triggering _ensure_real.  For now it's the easiest thing to do.
1230
1725
        self._ensure_real()
1231
1726
        real_repo = self._real_repository
1232
1727
        builder = real_repo.get_commit_builder(branch, parents,
1233
1728
                config, timestamp=timestamp, timezone=timezone,
1234
 
                committer=committer, revprops=revprops, revision_id=revision_id)
 
1729
                committer=committer, revprops=revprops,
 
1730
                revision_id=revision_id, lossy=lossy)
1235
1731
        return builder
1236
1732
 
1237
1733
    def add_fallback_repository(self, repository):
1245
1741
        # We need to accumulate additional repositories here, to pass them in
1246
1742
        # on various RPC's.
1247
1743
        #
 
1744
        # Make the check before we lock: this raises an exception.
 
1745
        self._check_fallback_repository(repository)
1248
1746
        if self.is_locked():
1249
1747
            # We will call fallback.unlock() when we transition to the unlocked
1250
1748
            # state, so always add a lock here. If a caller passes us a locked
1251
1749
            # repository, they are responsible for unlocking it later.
1252
1750
            repository.lock_read()
1253
 
        self._check_fallback_repository(repository)
1254
1751
        self._fallback_repositories.append(repository)
1255
1752
        # If self._real_repository was parameterised already (e.g. because a
1256
1753
        # _real_branch had its get_stacked_on_url method called), then the
1289
1786
 
1290
1787
    @needs_read_lock
1291
1788
    def get_inventory(self, revision_id):
1292
 
        self._ensure_real()
1293
 
        return self._real_repository.get_inventory(revision_id)
 
1789
        return list(self.iter_inventories([revision_id]))[0]
1294
1790
 
1295
1791
    def iter_inventories(self, revision_ids, ordering=None):
1296
1792
        self._ensure_real()
1298
1794
 
1299
1795
    @needs_read_lock
1300
1796
    def get_revision(self, revision_id):
1301
 
        self._ensure_real()
1302
 
        return self._real_repository.get_revision(revision_id)
 
1797
        return self.get_revisions([revision_id])[0]
1303
1798
 
1304
1799
    def get_transaction(self):
1305
1800
        self._ensure_real()
1307
1802
 
1308
1803
    @needs_read_lock
1309
1804
    def clone(self, a_bzrdir, revision_id=None):
1310
 
        self._ensure_real()
1311
 
        return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
 
1805
        dest_repo = self._create_sprouting_repo(
 
1806
            a_bzrdir, shared=self.is_shared())
 
1807
        self.copy_content_into(dest_repo, revision_id)
 
1808
        return dest_repo
1312
1809
 
1313
1810
    def make_working_trees(self):
1314
1811
        """See Repository.make_working_trees"""
1315
 
        self._ensure_real()
1316
 
        return self._real_repository.make_working_trees()
 
1812
        path = self.bzrdir._path_for_remote_call(self._client)
 
1813
        try:
 
1814
            response = self._call('Repository.make_working_trees', path)
 
1815
        except errors.UnknownSmartMethod:
 
1816
            self._ensure_real()
 
1817
            return self._real_repository.make_working_trees()
 
1818
        if response[0] not in ('yes', 'no'):
 
1819
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
1820
        return response[0] == 'yes'
1317
1821
 
1318
1822
    def refresh_data(self):
1319
1823
        """Re-read any data needed to synchronise with disk.
1338
1842
        included_keys = result_set.intersection(result_parents)
1339
1843
        start_keys = result_set.difference(included_keys)
1340
1844
        exclude_keys = result_parents.difference(result_set)
1341
 
        result = graph.SearchResult(start_keys, exclude_keys,
 
1845
        result = vf_search.SearchResult(start_keys, exclude_keys,
1342
1846
            len(result_set), result_set)
1343
1847
        return result
1344
1848
 
1345
1849
    @needs_read_lock
1346
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
1850
    def search_missing_revision_ids(self, other,
 
1851
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
1852
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
1853
            limit=None):
1347
1854
        """Return the revision ids that other has that this does not.
1348
1855
 
1349
1856
        These are returned in topological order.
1350
1857
 
1351
1858
        revision_id: only return revision ids included by revision_id.
1352
1859
        """
1353
 
        return repository.InterRepository.get(
1354
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
1860
        if symbol_versioning.deprecated_passed(revision_id):
 
1861
            symbol_versioning.warn(
 
1862
                'search_missing_revision_ids(revision_id=...) was '
 
1863
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
1864
                DeprecationWarning, stacklevel=2)
 
1865
            if revision_ids is not None:
 
1866
                raise AssertionError(
 
1867
                    'revision_ids is mutually exclusive with revision_id')
 
1868
            if revision_id is not None:
 
1869
                revision_ids = [revision_id]
 
1870
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
1871
        return inter_repo.search_missing_revision_ids(
 
1872
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
1873
            if_present_ids=if_present_ids, limit=limit)
1355
1874
 
1356
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
1875
    def fetch(self, source, revision_id=None, find_ghosts=False,
1357
1876
            fetch_spec=None):
1358
1877
        # No base implementation to use as RemoteRepository is not a subclass
1359
1878
        # of Repository; so this is a copy of Repository.fetch().
1370
1889
            # check that last_revision is in 'from' and then return a
1371
1890
            # no-operation.
1372
1891
            if (revision_id is not None and
1373
 
                not revision.is_null(revision_id)):
 
1892
                not _mod_revision.is_null(revision_id)):
1374
1893
                self.get_revision(revision_id)
1375
1894
            return 0, []
1376
1895
        # if there is no specific appropriate InterRepository, this will get
1377
1896
        # the InterRepository base class, which raises an
1378
1897
        # IncompatibleRepositories when asked to fetch.
1379
 
        inter = repository.InterRepository.get(source, self)
1380
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
1898
        inter = _mod_repository.InterRepository.get(source, self)
 
1899
        if (fetch_spec is not None and
 
1900
            not getattr(inter, "supports_fetch_spec", False)):
 
1901
            raise errors.UnsupportedOperation(
 
1902
                "fetch_spec not supported for %r" % inter)
 
1903
        return inter.fetch(revision_id=revision_id,
1381
1904
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1382
1905
 
1383
1906
    def create_bundle(self, target, base, fileobj, format=None):
1385
1908
        self._real_repository.create_bundle(target, base, fileobj, format)
1386
1909
 
1387
1910
    @needs_read_lock
 
1911
    @symbol_versioning.deprecated_method(
 
1912
        symbol_versioning.deprecated_in((2, 4, 0)))
1388
1913
    def get_ancestry(self, revision_id, topo_sorted=True):
1389
1914
        self._ensure_real()
1390
1915
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1398
1923
        return self._real_repository._get_versioned_file_checker(
1399
1924
            revisions, revision_versions_cache)
1400
1925
 
 
1926
    def _iter_files_bytes_rpc(self, desired_files, absent):
 
1927
        path = self.bzrdir._path_for_remote_call(self._client)
 
1928
        lines = []
 
1929
        identifiers = []
 
1930
        for (file_id, revid, identifier) in desired_files:
 
1931
            lines.append("%s\0%s" % (
 
1932
                osutils.safe_file_id(file_id),
 
1933
                osutils.safe_revision_id(revid)))
 
1934
            identifiers.append(identifier)
 
1935
        (response_tuple, response_handler) = (
 
1936
            self._call_with_body_bytes_expecting_body(
 
1937
            "Repository.iter_files_bytes", (path, ), "\n".join(lines)))
 
1938
        if response_tuple != ('ok', ):
 
1939
            response_handler.cancel_read_body()
 
1940
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
1941
        byte_stream = response_handler.read_streamed_body()
 
1942
        def decompress_stream(start, byte_stream, unused):
 
1943
            decompressor = zlib.decompressobj()
 
1944
            yield decompressor.decompress(start)
 
1945
            while decompressor.unused_data == "":
 
1946
                try:
 
1947
                    data = byte_stream.next()
 
1948
                except StopIteration:
 
1949
                    break
 
1950
                yield decompressor.decompress(data)
 
1951
            yield decompressor.flush()
 
1952
            unused.append(decompressor.unused_data)
 
1953
        unused = ""
 
1954
        while True:
 
1955
            while not "\n" in unused:
 
1956
                unused += byte_stream.next()
 
1957
            header, rest = unused.split("\n", 1)
 
1958
            args = header.split("\0")
 
1959
            if args[0] == "absent":
 
1960
                absent[identifiers[int(args[3])]] = (args[1], args[2])
 
1961
                unused = rest
 
1962
                continue
 
1963
            elif args[0] == "ok":
 
1964
                idx = int(args[1])
 
1965
            else:
 
1966
                raise errors.UnexpectedSmartServerResponse(args)
 
1967
            unused_chunks = []
 
1968
            yield (identifiers[idx],
 
1969
                decompress_stream(rest, byte_stream, unused_chunks))
 
1970
            unused = "".join(unused_chunks)
 
1971
 
1401
1972
    def iter_files_bytes(self, desired_files):
1402
1973
        """See Repository.iter_file_bytes.
1403
1974
        """
1404
 
        self._ensure_real()
1405
 
        return self._real_repository.iter_files_bytes(desired_files)
 
1975
        try:
 
1976
            absent = {}
 
1977
            for (identifier, bytes_iterator) in self._iter_files_bytes_rpc(
 
1978
                    desired_files, absent):
 
1979
                yield identifier, bytes_iterator
 
1980
            for fallback in self._fallback_repositories:
 
1981
                if not absent:
 
1982
                    break
 
1983
                desired_files = [(key[0], key[1], identifier) for
 
1984
                    (identifier, key) in absent.iteritems()]
 
1985
                for (identifier, bytes_iterator) in fallback.iter_files_bytes(desired_files):
 
1986
                    del absent[identifier]
 
1987
                    yield identifier, bytes_iterator
 
1988
            if absent:
 
1989
                # There may be more missing items, but raise an exception
 
1990
                # for just one.
 
1991
                missing_identifier = absent.keys()[0]
 
1992
                missing_key = absent[missing_identifier]
 
1993
                raise errors.RevisionNotPresent(revision_id=missing_key[1],
 
1994
                    file_id=missing_key[0])
 
1995
        except errors.UnknownSmartMethod:
 
1996
            self._ensure_real()
 
1997
            for (identifier, bytes_iterator) in (
 
1998
                self._real_repository.iter_files_bytes(desired_files)):
 
1999
                yield identifier, bytes_iterator
 
2000
 
 
2001
    def get_cached_parent_map(self, revision_ids):
 
2002
        """See bzrlib.CachingParentsProvider.get_cached_parent_map"""
 
2003
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
1406
2004
 
1407
2005
    def get_parent_map(self, revision_ids):
1408
2006
        """See bzrlib.Graph.get_parent_map()."""
1467
2065
        if parents_map is None:
1468
2066
            # Repository is not locked, so there's no cache.
1469
2067
            parents_map = {}
1470
 
        # start_set is all the keys in the cache
1471
 
        start_set = set(parents_map)
1472
 
        # result set is all the references to keys in the cache
1473
 
        result_parents = set()
1474
 
        for parents in parents_map.itervalues():
1475
 
            result_parents.update(parents)
1476
 
        stop_keys = result_parents.difference(start_set)
1477
 
        # We don't need to send ghosts back to the server as a position to
1478
 
        # stop either.
1479
 
        stop_keys.difference_update(self._unstacked_provider.missing_keys)
1480
 
        key_count = len(parents_map)
1481
 
        if (NULL_REVISION in result_parents
1482
 
            and NULL_REVISION in self._unstacked_provider.missing_keys):
1483
 
            # If we pruned NULL_REVISION from the stop_keys because it's also
1484
 
            # in our cache of "missing" keys we need to increment our key count
1485
 
            # by 1, because the reconsitituted SearchResult on the server will
1486
 
            # still consider NULL_REVISION to be an included key.
1487
 
            key_count += 1
1488
 
        included_keys = start_set.intersection(result_parents)
1489
 
        start_set.difference_update(included_keys)
 
2068
        if _DEFAULT_SEARCH_DEPTH <= 0:
 
2069
            (start_set, stop_keys,
 
2070
             key_count) = vf_search.search_result_from_parent_map(
 
2071
                parents_map, self._unstacked_provider.missing_keys)
 
2072
        else:
 
2073
            (start_set, stop_keys,
 
2074
             key_count) = vf_search.limited_search_result_from_parent_map(
 
2075
                parents_map, self._unstacked_provider.missing_keys,
 
2076
                keys, depth=_DEFAULT_SEARCH_DEPTH)
1490
2077
        recipe = ('manual', start_set, stop_keys, key_count)
1491
2078
        body = self._serialise_search_recipe(recipe)
1492
2079
        path = self.bzrdir._path_for_remote_call(self._client)
1541
2128
 
1542
2129
    @needs_read_lock
1543
2130
    def get_signature_text(self, revision_id):
1544
 
        self._ensure_real()
1545
 
        return self._real_repository.get_signature_text(revision_id)
 
2131
        path = self.bzrdir._path_for_remote_call(self._client)
 
2132
        try:
 
2133
            response_tuple, response_handler = self._call_expecting_body(
 
2134
                'Repository.get_revision_signature_text', path, revision_id)
 
2135
        except errors.UnknownSmartMethod:
 
2136
            self._ensure_real()
 
2137
            return self._real_repository.get_signature_text(revision_id)
 
2138
        except errors.NoSuchRevision, err:
 
2139
            for fallback in self._fallback_repositories:
 
2140
                try:
 
2141
                    return fallback.get_signature_text(revision_id)
 
2142
                except errors.NoSuchRevision:
 
2143
                    pass
 
2144
            raise err
 
2145
        else:
 
2146
            if response_tuple[0] != 'ok':
 
2147
                raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2148
            return response_handler.read_body_bytes()
1546
2149
 
1547
2150
    @needs_read_lock
1548
2151
    def _get_inventory_xml(self, revision_id):
1549
2152
        self._ensure_real()
1550
2153
        return self._real_repository._get_inventory_xml(revision_id)
1551
2154
 
 
2155
    @needs_write_lock
1552
2156
    def reconcile(self, other=None, thorough=False):
1553
 
        self._ensure_real()
1554
 
        return self._real_repository.reconcile(other=other, thorough=thorough)
 
2157
        from bzrlib.reconcile import RepoReconciler
 
2158
        path = self.bzrdir._path_for_remote_call(self._client)
 
2159
        try:
 
2160
            response, handler = self._call_expecting_body(
 
2161
                'Repository.reconcile', path, self._lock_token)
 
2162
        except (errors.UnknownSmartMethod, errors.TokenLockingNotSupported):
 
2163
            self._ensure_real()
 
2164
            return self._real_repository.reconcile(other=other, thorough=thorough)
 
2165
        if response != ('ok', ):
 
2166
            raise errors.UnexpectedSmartServerResponse(response)
 
2167
        body = handler.read_body_bytes()
 
2168
        result = RepoReconciler(self)
 
2169
        for line in body.split('\n'):
 
2170
            if not line:
 
2171
                continue
 
2172
            key, val_text = line.split(':')
 
2173
            if key == "garbage_inventories":
 
2174
                result.garbage_inventories = int(val_text)
 
2175
            elif key == "inconsistent_parents":
 
2176
                result.inconsistent_parents = int(val_text)
 
2177
            else:
 
2178
                mutter("unknown reconcile key %r" % key)
 
2179
        return result
1555
2180
 
1556
2181
    def all_revision_ids(self):
1557
 
        self._ensure_real()
1558
 
        return self._real_repository.all_revision_ids()
 
2182
        path = self.bzrdir._path_for_remote_call(self._client)
 
2183
        try:
 
2184
            response_tuple, response_handler = self._call_expecting_body(
 
2185
                "Repository.all_revision_ids", path)
 
2186
        except errors.UnknownSmartMethod:
 
2187
            self._ensure_real()
 
2188
            return self._real_repository.all_revision_ids()
 
2189
        if response_tuple != ("ok", ):
 
2190
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2191
        revids = set(response_handler.read_body_bytes().splitlines())
 
2192
        for fallback in self._fallback_repositories:
 
2193
            revids.update(set(fallback.all_revision_ids()))
 
2194
        return list(revids)
1559
2195
 
1560
2196
    @needs_read_lock
1561
2197
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1565
2201
 
1566
2202
    @needs_read_lock
1567
2203
    def get_revision_delta(self, revision_id, specific_fileids=None):
1568
 
        self._ensure_real()
1569
 
        return self._real_repository.get_revision_delta(revision_id,
1570
 
            specific_fileids=specific_fileids)
 
2204
        r = self.get_revision(revision_id)
 
2205
        return list(self.get_deltas_for_revisions([r],
 
2206
            specific_fileids=specific_fileids))[0]
1571
2207
 
1572
2208
    @needs_read_lock
1573
2209
    def revision_trees(self, revision_ids):
1574
 
        self._ensure_real()
1575
 
        return self._real_repository.revision_trees(revision_ids)
 
2210
        inventories = self.iter_inventories(revision_ids)
 
2211
        for inv in inventories:
 
2212
            yield InventoryRevisionTree(self, inv, inv.revision_id)
1576
2213
 
1577
2214
    @needs_read_lock
1578
2215
    def get_revision_reconcile(self, revision_id):
1586
2223
            callback_refs=callback_refs, check_repo=check_repo)
1587
2224
 
1588
2225
    def copy_content_into(self, destination, revision_id=None):
1589
 
        self._ensure_real()
1590
 
        return self._real_repository.copy_content_into(
1591
 
            destination, revision_id=revision_id)
 
2226
        """Make a complete copy of the content in self into destination.
 
2227
 
 
2228
        This is a destructive operation! Do not use it on existing
 
2229
        repositories.
 
2230
        """
 
2231
        interrepo = _mod_repository.InterRepository.get(self, destination)
 
2232
        return interrepo.copy_content(revision_id)
1592
2233
 
1593
2234
    def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1594
2235
        # get a tarball of the remote repository, and copy from that into the
1595
2236
        # destination
1596
 
        from bzrlib import osutils
1597
2237
        import tarfile
1598
2238
        # TODO: Maybe a progress bar while streaming the tarball?
1599
 
        note("Copying repository content as tarball...")
 
2239
        note(gettext("Copying repository content as tarball..."))
1600
2240
        tar_file = self._get_tarball('bz2')
1601
2241
        if tar_file is None:
1602
2242
            return None
1607
2247
            tmpdir = osutils.mkdtemp()
1608
2248
            try:
1609
2249
                _extract_tar(tar, tmpdir)
1610
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
2250
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1611
2251
                tmp_repo = tmp_bzrdir.open_repository()
1612
2252
                tmp_repo.copy_content_into(destination, revision_id)
1613
2253
            finally:
1631
2271
    @needs_write_lock
1632
2272
    def pack(self, hint=None, clean_obsolete_packs=False):
1633
2273
        """Compress the data within the repository.
1634
 
 
1635
 
        This is not currently implemented within the smart server.
1636
2274
        """
1637
 
        self._ensure_real()
1638
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
2275
        if hint is None:
 
2276
            body = ""
 
2277
        else:
 
2278
            body = "".join([l+"\n" for l in hint])
 
2279
        path = self.bzrdir._path_for_remote_call(self._client)
 
2280
        try:
 
2281
            response, handler = self._call_with_body_bytes_expecting_body(
 
2282
                'Repository.pack', (path, self._lock_token,
 
2283
                    str(clean_obsolete_packs)), body)
 
2284
        except errors.UnknownSmartMethod:
 
2285
            self._ensure_real()
 
2286
            return self._real_repository.pack(hint=hint,
 
2287
                clean_obsolete_packs=clean_obsolete_packs)
 
2288
        handler.cancel_read_body()
 
2289
        if response != ('ok', ):
 
2290
            raise errors.UnexpectedSmartServerResponse(response)
1639
2291
 
1640
2292
    @property
1641
2293
    def revisions(self):
1642
2294
        """Decorate the real repository for now.
1643
2295
 
1644
 
        In the short term this should become a real object to intercept graph
1645
 
        lookups.
1646
 
 
1647
2296
        In the long term a full blown network facility is needed.
1648
2297
        """
1649
2298
        self._ensure_real()
1677
2326
 
1678
2327
    @needs_write_lock
1679
2328
    def sign_revision(self, revision_id, gpg_strategy):
1680
 
        self._ensure_real()
1681
 
        return self._real_repository.sign_revision(revision_id, gpg_strategy)
 
2329
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2330
        plaintext = testament.as_short_text()
 
2331
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1682
2332
 
1683
2333
    @property
1684
2334
    def texts(self):
1690
2340
        self._ensure_real()
1691
2341
        return self._real_repository.texts
1692
2342
 
 
2343
    def _iter_revisions_rpc(self, revision_ids):
 
2344
        body = "\n".join(revision_ids)
 
2345
        path = self.bzrdir._path_for_remote_call(self._client)
 
2346
        response_tuple, response_handler = (
 
2347
            self._call_with_body_bytes_expecting_body(
 
2348
            "Repository.iter_revisions", (path, ), body))
 
2349
        if response_tuple[0] != "ok":
 
2350
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2351
        serializer_format = response_tuple[1]
 
2352
        serializer = serializer_format_registry.get(serializer_format)
 
2353
        byte_stream = response_handler.read_streamed_body()
 
2354
        decompressor = zlib.decompressobj()
 
2355
        chunks = []
 
2356
        for bytes in byte_stream:
 
2357
            chunks.append(decompressor.decompress(bytes))
 
2358
            if decompressor.unused_data != "":
 
2359
                chunks.append(decompressor.flush())
 
2360
                yield serializer.read_revision_from_string("".join(chunks))
 
2361
                unused = decompressor.unused_data
 
2362
                decompressor = zlib.decompressobj()
 
2363
                chunks = [decompressor.decompress(unused)]
 
2364
        chunks.append(decompressor.flush())
 
2365
        text = "".join(chunks)
 
2366
        if text != "":
 
2367
            yield serializer.read_revision_from_string("".join(chunks))
 
2368
 
1693
2369
    @needs_read_lock
1694
2370
    def get_revisions(self, revision_ids):
1695
 
        self._ensure_real()
1696
 
        return self._real_repository.get_revisions(revision_ids)
 
2371
        if revision_ids is None:
 
2372
            revision_ids = self.all_revision_ids()
 
2373
        else:
 
2374
            for rev_id in revision_ids:
 
2375
                if not rev_id or not isinstance(rev_id, basestring):
 
2376
                    raise errors.InvalidRevisionId(
 
2377
                        revision_id=rev_id, branch=self)
 
2378
        try:
 
2379
            missing = set(revision_ids)
 
2380
            revs = {}
 
2381
            for rev in self._iter_revisions_rpc(revision_ids):
 
2382
                missing.remove(rev.revision_id)
 
2383
                revs[rev.revision_id] = rev
 
2384
        except errors.UnknownSmartMethod:
 
2385
            self._ensure_real()
 
2386
            return self._real_repository.get_revisions(revision_ids)
 
2387
        for fallback in self._fallback_repositories:
 
2388
            if not missing:
 
2389
                break
 
2390
            for revid in list(missing):
 
2391
                # XXX JRV 2011-11-20: It would be nice if there was a
 
2392
                # public method on Repository that could be used to query
 
2393
                # for revision objects *without* failing completely if one
 
2394
                # was missing. There is VersionedFileRepository._iter_revisions,
 
2395
                # but unfortunately that's private and not provided by
 
2396
                # all repository implementations.
 
2397
                try:
 
2398
                    revs[revid] = fallback.get_revision(revid)
 
2399
                except errors.NoSuchRevision:
 
2400
                    pass
 
2401
                else:
 
2402
                    missing.remove(revid)
 
2403
        if missing:
 
2404
            raise errors.NoSuchRevision(self, list(missing)[0])
 
2405
        return [revs[revid] for revid in revision_ids]
1697
2406
 
1698
2407
    def supports_rich_root(self):
1699
2408
        return self._format.rich_root_data
1700
2409
 
 
2410
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1701
2411
    def iter_reverse_revision_history(self, revision_id):
1702
2412
        self._ensure_real()
1703
2413
        return self._real_repository.iter_reverse_revision_history(revision_id)
1706
2416
    def _serializer(self):
1707
2417
        return self._format._serializer
1708
2418
 
 
2419
    @needs_write_lock
1709
2420
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1710
 
        self._ensure_real()
1711
 
        return self._real_repository.store_revision_signature(
1712
 
            gpg_strategy, plaintext, revision_id)
 
2421
        signature = gpg_strategy.sign(plaintext)
 
2422
        self.add_signature_text(revision_id, signature)
1713
2423
 
1714
2424
    def add_signature_text(self, revision_id, signature):
1715
 
        self._ensure_real()
1716
 
        return self._real_repository.add_signature_text(revision_id, signature)
 
2425
        if self._real_repository:
 
2426
            # If there is a real repository the write group will
 
2427
            # be in the real repository as well, so use that:
 
2428
            self._ensure_real()
 
2429
            return self._real_repository.add_signature_text(
 
2430
                revision_id, signature)
 
2431
        path = self.bzrdir._path_for_remote_call(self._client)
 
2432
        response, handler = self._call_with_body_bytes_expecting_body(
 
2433
            'Repository.add_signature_text', (path, self._lock_token,
 
2434
                revision_id) + tuple(self._write_group_tokens), signature)
 
2435
        handler.cancel_read_body()
 
2436
        self.refresh_data()
 
2437
        if response[0] != 'ok':
 
2438
            raise errors.UnexpectedSmartServerResponse(response)
 
2439
        self._write_group_tokens = response[1:]
1717
2440
 
1718
2441
    def has_signature_for_revision_id(self, revision_id):
1719
 
        self._ensure_real()
1720
 
        return self._real_repository.has_signature_for_revision_id(revision_id)
 
2442
        path = self.bzrdir._path_for_remote_call(self._client)
 
2443
        try:
 
2444
            response = self._call('Repository.has_signature_for_revision_id',
 
2445
                path, revision_id)
 
2446
        except errors.UnknownSmartMethod:
 
2447
            self._ensure_real()
 
2448
            return self._real_repository.has_signature_for_revision_id(
 
2449
                revision_id)
 
2450
        if response[0] not in ('yes', 'no'):
 
2451
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2452
        if response[0] == 'yes':
 
2453
            return True
 
2454
        for fallback in self._fallback_repositories:
 
2455
            if fallback.has_signature_for_revision_id(revision_id):
 
2456
                return True
 
2457
        return False
 
2458
 
 
2459
    @needs_read_lock
 
2460
    def verify_revision_signature(self, revision_id, gpg_strategy):
 
2461
        if not self.has_signature_for_revision_id(revision_id):
 
2462
            return gpg.SIGNATURE_NOT_SIGNED, None
 
2463
        signature = self.get_signature_text(revision_id)
 
2464
 
 
2465
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2466
        plaintext = testament.as_short_text()
 
2467
 
 
2468
        return gpg_strategy.verify(signature, plaintext)
1721
2469
 
1722
2470
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1723
2471
        self._ensure_real()
1724
2472
        return self._real_repository.item_keys_introduced_by(revision_ids,
1725
2473
            _files_pb=_files_pb)
1726
2474
 
1727
 
    def revision_graph_can_have_wrong_parents(self):
1728
 
        # The answer depends on the remote repo format.
1729
 
        self._ensure_real()
1730
 
        return self._real_repository.revision_graph_can_have_wrong_parents()
1731
 
 
1732
2475
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1733
2476
        self._ensure_real()
1734
2477
        return self._real_repository._find_inconsistent_revision_parents(
1742
2485
        providers = [self._unstacked_provider]
1743
2486
        if other is not None:
1744
2487
            providers.insert(0, other)
1745
 
        providers.extend(r._make_parents_provider() for r in
1746
 
                         self._fallback_repositories)
1747
 
        return graph.StackedParentsProvider(providers)
 
2488
        return graph.StackedParentsProvider(_LazyListJoin(
 
2489
            providers, self._fallback_repositories))
1748
2490
 
1749
2491
    def _serialise_search_recipe(self, recipe):
1750
2492
        """Serialise a graph search recipe.
1758
2500
        return '\n'.join((start_keys, stop_keys, count))
1759
2501
 
1760
2502
    def _serialise_search_result(self, search_result):
1761
 
        if isinstance(search_result, graph.PendingAncestryResult):
1762
 
            parts = ['ancestry-of']
1763
 
            parts.extend(search_result.heads)
1764
 
        else:
1765
 
            recipe = search_result.get_recipe()
1766
 
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
 
2503
        parts = search_result.get_network_struct()
1767
2504
        return '\n'.join(parts)
1768
2505
 
1769
2506
    def autopack(self):
1779
2516
            raise errors.UnexpectedSmartServerResponse(response)
1780
2517
 
1781
2518
 
1782
 
class RemoteStreamSink(repository.StreamSink):
 
2519
class RemoteStreamSink(vf_repository.StreamSink):
1783
2520
 
1784
2521
    def _insert_real(self, stream, src_format, resume_tokens):
1785
2522
        self.target_repo._ensure_real()
1886
2623
        self._last_substream and self._last_stream so that the stream can be
1887
2624
        resumed by _resume_stream_with_vfs.
1888
2625
        """
1889
 
                    
 
2626
 
1890
2627
        stream_iter = iter(stream)
1891
2628
        for substream_kind, substream in stream_iter:
1892
2629
            if substream_kind == 'inventory-deltas':
1895
2632
                return
1896
2633
            else:
1897
2634
                yield substream_kind, substream
1898
 
            
1899
 
 
1900
 
class RemoteStreamSource(repository.StreamSource):
 
2635
 
 
2636
 
 
2637
class RemoteStreamSource(vf_repository.StreamSource):
1901
2638
    """Stream data from a remote server."""
1902
2639
 
1903
2640
    def get_stream(self, search):
1924
2661
 
1925
2662
    def _real_stream(self, repo, search):
1926
2663
        """Get a stream for search from repo.
1927
 
        
1928
 
        This never called RemoteStreamSource.get_stream, and is a heler
1929
 
        for RemoteStreamSource._get_stream to allow getting a stream 
 
2664
 
 
2665
        This never called RemoteStreamSource.get_stream, and is a helper
 
2666
        for RemoteStreamSource._get_stream to allow getting a stream
1930
2667
        reliably whether fallback back because of old servers or trying
1931
2668
        to stream from a non-RemoteRepository (which the stacked support
1932
2669
        code will do).
1963
2700
        candidate_verbs = [
1964
2701
            ('Repository.get_stream_1.19', (1, 19)),
1965
2702
            ('Repository.get_stream', (1, 13))]
 
2703
 
1966
2704
        found_verb = False
1967
2705
        for verb, version in candidate_verbs:
1968
2706
            if medium._is_remote_before(version):
1972
2710
                    verb, args, search_bytes)
1973
2711
            except errors.UnknownSmartMethod:
1974
2712
                medium._remember_remote_is_before(version)
 
2713
            except errors.UnknownErrorFromSmartServer, e:
 
2714
                if isinstance(search, vf_search.EverythingResult):
 
2715
                    error_verb = e.error_from_smart_server.error_verb
 
2716
                    if error_verb == 'BadSearch':
 
2717
                        # Pre-2.4 servers don't support this sort of search.
 
2718
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
2719
                        # good idea in general?  It might provide a little bit
 
2720
                        # of protection against client-side bugs.
 
2721
                        medium._remember_remote_is_before((2, 4))
 
2722
                        break
 
2723
                raise
1975
2724
            else:
1976
2725
                response_tuple, response_handler = response
1977
2726
                found_verb = True
2060
2809
 
2061
2810
    def _ensure_real(self):
2062
2811
        if self._custom_format is None:
2063
 
            self._custom_format = branch.network_format_registry.get(
2064
 
                self._network_name)
 
2812
            try:
 
2813
                self._custom_format = branch.network_format_registry.get(
 
2814
                    self._network_name)
 
2815
            except KeyError:
 
2816
                raise errors.UnknownFormatError(kind='branch',
 
2817
                    format=self._network_name)
2065
2818
 
2066
2819
    def get_format_description(self):
2067
2820
        self._ensure_real()
2074
2827
        return a_bzrdir.open_branch(name=name, 
2075
2828
            ignore_fallbacks=ignore_fallbacks)
2076
2829
 
2077
 
    def _vfs_initialize(self, a_bzrdir, name):
 
2830
    def _vfs_initialize(self, a_bzrdir, name, append_revisions_only):
2078
2831
        # Initialisation when using a local bzrdir object, or a non-vfs init
2079
2832
        # method is not available on the server.
2080
2833
        # self._custom_format is always set - the start of initialize ensures
2082
2835
        if isinstance(a_bzrdir, RemoteBzrDir):
2083
2836
            a_bzrdir._ensure_real()
2084
2837
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2085
 
                name)
 
2838
                name, append_revisions_only=append_revisions_only)
2086
2839
        else:
2087
2840
            # We assume the bzrdir is parameterised; it may not be.
2088
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
2841
            result = self._custom_format.initialize(a_bzrdir, name,
 
2842
                append_revisions_only=append_revisions_only)
2089
2843
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2090
2844
            not isinstance(result, RemoteBranch)):
2091
2845
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2092
2846
                                  name=name)
2093
2847
        return result
2094
2848
 
2095
 
    def initialize(self, a_bzrdir, name=None):
 
2849
    def initialize(self, a_bzrdir, name=None, repository=None,
 
2850
                   append_revisions_only=None):
2096
2851
        # 1) get the network name to use.
2097
2852
        if self._custom_format:
2098
2853
            network_name = self._custom_format.network_name()
2099
2854
        else:
2100
2855
            # Select the current bzrlib default and ask for that.
2101
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
2856
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
2102
2857
            reference_format = reference_bzrdir_format.get_branch_format()
2103
2858
            self._custom_format = reference_format
2104
2859
            network_name = reference_format.network_name()
2105
2860
        # Being asked to create on a non RemoteBzrDir:
2106
2861
        if not isinstance(a_bzrdir, RemoteBzrDir):
2107
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2862
            return self._vfs_initialize(a_bzrdir, name=name,
 
2863
                append_revisions_only=append_revisions_only)
2108
2864
        medium = a_bzrdir._client._medium
2109
2865
        if medium._is_remote_before((1, 13)):
2110
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2866
            return self._vfs_initialize(a_bzrdir, name=name,
 
2867
                append_revisions_only=append_revisions_only)
2111
2868
        # Creating on a remote bzr dir.
2112
2869
        # 2) try direct creation via RPC
2113
2870
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2120
2877
        except errors.UnknownSmartMethod:
2121
2878
            # Fallback - use vfs methods
2122
2879
            medium._remember_remote_is_before((1, 13))
2123
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2880
            return self._vfs_initialize(a_bzrdir, name=name,
 
2881
                    append_revisions_only=append_revisions_only)
2124
2882
        if response[0] != 'ok':
2125
2883
            raise errors.UnexpectedSmartServerResponse(response)
2126
2884
        # Turn the response into a RemoteRepository object.
2127
2885
        format = RemoteBranchFormat(network_name=response[1])
2128
2886
        repo_format = response_tuple_to_repo_format(response[3:])
2129
 
        if response[2] == '':
2130
 
            repo_bzrdir = a_bzrdir
 
2887
        repo_path = response[2]
 
2888
        if repository is not None:
 
2889
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
 
2890
            url_diff = urlutils.relative_url(repository.user_url,
 
2891
                    remote_repo_url)
 
2892
            if url_diff != '.':
 
2893
                raise AssertionError(
 
2894
                    'repository.user_url %r does not match URL from server '
 
2895
                    'response (%r + %r)'
 
2896
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
 
2897
            remote_repo = repository
2131
2898
        else:
2132
 
            repo_bzrdir = RemoteBzrDir(
2133
 
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2134
 
                a_bzrdir._client)
2135
 
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
2899
            if repo_path == '':
 
2900
                repo_bzrdir = a_bzrdir
 
2901
            else:
 
2902
                repo_bzrdir = RemoteBzrDir(
 
2903
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
2904
                    a_bzrdir._client)
 
2905
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2136
2906
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2137
2907
            format=format, setup_stacking=False, name=name)
 
2908
        if append_revisions_only:
 
2909
            remote_branch.set_append_revisions_only(append_revisions_only)
2138
2910
        # XXX: We know this is a new branch, so it must have revno 0, revid
2139
2911
        # NULL_REVISION. Creating the branch locked would make this be unable
2140
2912
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2159
2931
        self._ensure_real()
2160
2932
        return self._custom_format.supports_set_append_revisions_only()
2161
2933
 
 
2934
    def _use_default_local_heads_to_fetch(self):
 
2935
        # If the branch format is a metadir format *and* its heads_to_fetch
 
2936
        # implementation is not overridden vs the base class, we can use the
 
2937
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
2938
        # usually cheaper in terms of net round trips, as the last-revision and
 
2939
        # tags info fetched is cached and would be fetched anyway.
 
2940
        self._ensure_real()
 
2941
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
2942
            branch_class = self._custom_format._branch_class()
 
2943
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
2944
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
2945
                return True
 
2946
        return False
 
2947
 
 
2948
 
 
2949
class RemoteBranchStore(config.IniFileStore):
 
2950
    """Branch store which attempts to use HPSS calls to retrieve branch store.
 
2951
 
 
2952
    Note that this is specific to bzr-based formats.
 
2953
    """
 
2954
 
 
2955
    def __init__(self, branch):
 
2956
        super(RemoteBranchStore, self).__init__()
 
2957
        self.branch = branch
 
2958
        self.id = "branch"
 
2959
        self._real_store = None
 
2960
 
 
2961
    def lock_write(self, token=None):
 
2962
        return self.branch.lock_write(token)
 
2963
 
 
2964
    def unlock(self):
 
2965
        return self.branch.unlock()
 
2966
 
 
2967
    @needs_write_lock
 
2968
    def save(self):
 
2969
        # We need to be able to override the undecorated implementation
 
2970
        self.save_without_locking()
 
2971
 
 
2972
    def save_without_locking(self):
 
2973
        super(RemoteBranchStore, self).save()
 
2974
 
 
2975
    def external_url(self):
 
2976
        return self.branch.user_url
 
2977
 
 
2978
    def _load_content(self):
 
2979
        path = self.branch._remote_path()
 
2980
        try:
 
2981
            response, handler = self.branch._call_expecting_body(
 
2982
                'Branch.get_config_file', path)
 
2983
        except errors.UnknownSmartMethod:
 
2984
            self._ensure_real()
 
2985
            return self._real_store._load_content()
 
2986
        if len(response) and response[0] != 'ok':
 
2987
            raise errors.UnexpectedSmartServerResponse(response)
 
2988
        return handler.read_body_bytes()
 
2989
 
 
2990
    def _save_content(self, content):
 
2991
        path = self.branch._remote_path()
 
2992
        try:
 
2993
            response, handler = self.branch._call_with_body_bytes_expecting_body(
 
2994
                'Branch.put_config_file', (path,
 
2995
                    self.branch._lock_token, self.branch._repo_lock_token),
 
2996
                content)
 
2997
        except errors.UnknownSmartMethod:
 
2998
            self._ensure_real()
 
2999
            return self._real_store._save_content(content)
 
3000
        handler.cancel_read_body()
 
3001
        if response != ('ok', ):
 
3002
            raise errors.UnexpectedSmartServerResponse(response)
 
3003
 
 
3004
    def _ensure_real(self):
 
3005
        self.branch._ensure_real()
 
3006
        if self._real_store is None:
 
3007
            self._real_store = config.BranchStore(self.branch)
 
3008
 
2162
3009
 
2163
3010
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2164
3011
    """Branch stored on a server accessed by HPSS RPC.
2167
3014
    """
2168
3015
 
2169
3016
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2170
 
        _client=None, format=None, setup_stacking=True, name=None):
 
3017
        _client=None, format=None, setup_stacking=True, name=None,
 
3018
        possible_transports=None):
2171
3019
        """Create a RemoteBranch instance.
2172
3020
 
2173
3021
        :param real_branch: An optional local implementation of the branch
2238
3086
            hook(self)
2239
3087
        self._is_stacked = False
2240
3088
        if setup_stacking:
2241
 
            self._setup_stacking()
 
3089
            self._setup_stacking(possible_transports)
2242
3090
 
2243
 
    def _setup_stacking(self):
 
3091
    def _setup_stacking(self, possible_transports):
2244
3092
        # configure stacking into the remote repository, by reading it from
2245
3093
        # the vfs branch.
2246
3094
        try:
2249
3097
            errors.UnstackableRepositoryFormat), e:
2250
3098
            return
2251
3099
        self._is_stacked = True
2252
 
        self._activate_fallback_location(fallback_url)
 
3100
        if possible_transports is None:
 
3101
            possible_transports = []
 
3102
        else:
 
3103
            possible_transports = list(possible_transports)
 
3104
        possible_transports.append(self.bzrdir.root_transport)
 
3105
        self._activate_fallback_location(fallback_url,
 
3106
            possible_transports=possible_transports)
2253
3107
 
2254
3108
    def _get_config(self):
2255
3109
        return RemoteBranchConfig(self)
2256
3110
 
 
3111
    def _get_config_store(self):
 
3112
        return RemoteBranchStore(self)
 
3113
 
2257
3114
    def _get_real_transport(self):
2258
3115
        # if we try vfs access, return the real branch's vfs transport
2259
3116
        self._ensure_real()
2322
3179
                self.bzrdir, self._client)
2323
3180
        return self._control_files
2324
3181
 
2325
 
    def _get_checkout_format(self):
 
3182
    def _get_checkout_format(self, lightweight=False):
2326
3183
        self._ensure_real()
2327
 
        return self._real_branch._get_checkout_format()
 
3184
        if lightweight:
 
3185
            format = RemoteBzrDirFormat()
 
3186
            self.bzrdir._format._supply_sub_formats_to(format)
 
3187
            format.workingtree_format = self._real_branch._get_checkout_format(
 
3188
                lightweight=lightweight).workingtree_format
 
3189
            return format
 
3190
        else:
 
3191
            return self._real_branch._get_checkout_format(lightweight=False)
2328
3192
 
2329
3193
    def get_physical_lock_status(self):
2330
3194
        """See Branch.get_physical_lock_status()."""
2331
 
        # should be an API call to the server, as branches must be lockable.
2332
 
        self._ensure_real()
2333
 
        return self._real_branch.get_physical_lock_status()
 
3195
        try:
 
3196
            response = self._client.call('Branch.get_physical_lock_status',
 
3197
                self._remote_path())
 
3198
        except errors.UnknownSmartMethod:
 
3199
            self._ensure_real()
 
3200
            return self._real_branch.get_physical_lock_status()
 
3201
        if response[0] not in ('yes', 'no'):
 
3202
            raise errors.UnexpectedSmartServerResponse(response)
 
3203
        return (response[0] == 'yes')
2334
3204
 
2335
3205
    def get_stacked_on_url(self):
2336
3206
        """Get the URL this branch is stacked against.
2363
3233
            self._is_stacked = False
2364
3234
        else:
2365
3235
            self._is_stacked = True
2366
 
        
 
3236
 
2367
3237
    def _vfs_get_tags_bytes(self):
2368
3238
        self._ensure_real()
2369
3239
        return self._real_branch._get_tags_bytes()
2370
3240
 
 
3241
    @needs_read_lock
2371
3242
    def _get_tags_bytes(self):
 
3243
        if self._tags_bytes is None:
 
3244
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
3245
        return self._tags_bytes
 
3246
 
 
3247
    def _get_tags_bytes_via_hpss(self):
2372
3248
        medium = self._client._medium
2373
3249
        if medium._is_remote_before((1, 13)):
2374
3250
            return self._vfs_get_tags_bytes()
2384
3260
        return self._real_branch._set_tags_bytes(bytes)
2385
3261
 
2386
3262
    def _set_tags_bytes(self, bytes):
 
3263
        if self.is_locked():
 
3264
            self._tags_bytes = bytes
2387
3265
        medium = self._client._medium
2388
3266
        if medium._is_remote_before((1, 18)):
2389
3267
            self._vfs_set_tags_bytes(bytes)
2512
3390
            self.repository.unlock()
2513
3391
 
2514
3392
    def break_lock(self):
2515
 
        self._ensure_real()
2516
 
        return self._real_branch.break_lock()
 
3393
        try:
 
3394
            response = self._call(
 
3395
                'Branch.break_lock', self._remote_path())
 
3396
        except errors.UnknownSmartMethod:
 
3397
            self._ensure_real()
 
3398
            return self._real_branch.break_lock()
 
3399
        if response != ('ok',):
 
3400
            raise errors.UnexpectedSmartServerResponse(response)
2517
3401
 
2518
3402
    def leave_lock_in_place(self):
2519
3403
        if not self._lock_token:
2543
3427
            missing_parent = parent_map[missing_parent]
2544
3428
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2545
3429
 
2546
 
    def _last_revision_info(self):
 
3430
    def _read_last_revision_info(self):
2547
3431
        response = self._call('Branch.last_revision_info', self._remote_path())
2548
3432
        if response[0] != 'ok':
2549
3433
            raise SmartProtocolError('unexpected response code %s' % (response,))
2612
3496
            raise errors.UnexpectedSmartServerResponse(response)
2613
3497
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2614
3498
 
 
3499
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2615
3500
    @needs_write_lock
2616
3501
    def set_revision_history(self, rev_history):
 
3502
        """See Branch.set_revision_history."""
 
3503
        self._set_revision_history(rev_history)
 
3504
 
 
3505
    @needs_write_lock
 
3506
    def _set_revision_history(self, rev_history):
2617
3507
        # Send just the tip revision of the history; the server will generate
2618
3508
        # the full history from that.  If the revision doesn't exist in this
2619
3509
        # branch, NoSuchRevision will be raised.
2677
3567
            _override_hook_target=self, **kwargs)
2678
3568
 
2679
3569
    @needs_read_lock
2680
 
    def push(self, target, overwrite=False, stop_revision=None):
 
3570
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2681
3571
        self._ensure_real()
2682
3572
        return self._real_branch.push(
2683
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
3573
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2684
3574
            _override_hook_source_branch=self)
2685
3575
 
2686
3576
    def is_locked(self):
2687
3577
        return self._lock_count >= 1
2688
3578
 
2689
3579
    @needs_read_lock
 
3580
    def revision_id_to_dotted_revno(self, revision_id):
 
3581
        """Given a revision id, return its dotted revno.
 
3582
 
 
3583
        :return: a tuple like (1,) or (400,1,3).
 
3584
        """
 
3585
        try:
 
3586
            response = self._call('Branch.revision_id_to_revno',
 
3587
                self._remote_path(), revision_id)
 
3588
        except errors.UnknownSmartMethod:
 
3589
            self._ensure_real()
 
3590
            return self._real_branch.revision_id_to_dotted_revno(revision_id)
 
3591
        if response[0] == 'ok':
 
3592
            return tuple([int(x) for x in response[1:]])
 
3593
        else:
 
3594
            raise errors.UnexpectedSmartServerResponse(response)
 
3595
 
 
3596
    @needs_read_lock
2690
3597
    def revision_id_to_revno(self, revision_id):
2691
 
        self._ensure_real()
2692
 
        return self._real_branch.revision_id_to_revno(revision_id)
 
3598
        """Given a revision id on the branch mainline, return its revno.
 
3599
 
 
3600
        :return: an integer
 
3601
        """
 
3602
        try:
 
3603
            response = self._call('Branch.revision_id_to_revno',
 
3604
                self._remote_path(), revision_id)
 
3605
        except errors.UnknownSmartMethod:
 
3606
            self._ensure_real()
 
3607
            return self._real_branch.revision_id_to_revno(revision_id)
 
3608
        if response[0] == 'ok':
 
3609
            if len(response) == 2:
 
3610
                return int(response[1])
 
3611
            raise NoSuchRevision(self, revision_id)
 
3612
        else:
 
3613
            raise errors.UnexpectedSmartServerResponse(response)
2693
3614
 
2694
3615
    @needs_write_lock
2695
3616
    def set_last_revision_info(self, revno, revision_id):
2696
3617
        # XXX: These should be returned by the set_last_revision_info verb
2697
3618
        old_revno, old_revid = self.last_revision_info()
2698
3619
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2699
 
        revision_id = ensure_null(revision_id)
 
3620
        if not revision_id or not isinstance(revision_id, basestring):
 
3621
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2700
3622
        try:
2701
3623
            response = self._call('Branch.set_last_revision_info',
2702
3624
                self._remote_path(), self._lock_token, self._repo_lock_token,
2731
3653
            except errors.UnknownSmartMethod:
2732
3654
                medium._remember_remote_is_before((1, 6))
2733
3655
        self._clear_cached_state_of_remote_branch_only()
2734
 
        self.set_revision_history(self._lefthand_history(revision_id,
 
3656
        self._set_revision_history(self._lefthand_history(revision_id,
2735
3657
            last_rev=last_rev,other_branch=other_branch))
2736
3658
 
2737
3659
    def set_push_location(self, location):
2738
3660
        self._ensure_real()
2739
3661
        return self._real_branch.set_push_location(location)
2740
3662
 
 
3663
    def heads_to_fetch(self):
 
3664
        if self._format._use_default_local_heads_to_fetch():
 
3665
            # We recognise this format, and its heads-to-fetch implementation
 
3666
            # is the default one (tip + tags).  In this case it's cheaper to
 
3667
            # just use the default implementation rather than a special RPC as
 
3668
            # the tip and tags data is cached.
 
3669
            return branch.Branch.heads_to_fetch(self)
 
3670
        medium = self._client._medium
 
3671
        if medium._is_remote_before((2, 4)):
 
3672
            return self._vfs_heads_to_fetch()
 
3673
        try:
 
3674
            return self._rpc_heads_to_fetch()
 
3675
        except errors.UnknownSmartMethod:
 
3676
            medium._remember_remote_is_before((2, 4))
 
3677
            return self._vfs_heads_to_fetch()
 
3678
 
 
3679
    def _rpc_heads_to_fetch(self):
 
3680
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3681
        if len(response) != 2:
 
3682
            raise errors.UnexpectedSmartServerResponse(response)
 
3683
        must_fetch, if_present_fetch = response
 
3684
        return set(must_fetch), set(if_present_fetch)
 
3685
 
 
3686
    def _vfs_heads_to_fetch(self):
 
3687
        self._ensure_real()
 
3688
        return self._real_branch.heads_to_fetch()
 
3689
 
2741
3690
 
2742
3691
class RemoteConfig(object):
2743
3692
    """A Config that reads and writes from smart verbs.
2757
3706
        """
2758
3707
        try:
2759
3708
            configobj = self._get_configobj()
 
3709
            section_obj = None
2760
3710
            if section is None:
2761
3711
                section_obj = configobj
2762
3712
            else:
2763
3713
                try:
2764
3714
                    section_obj = configobj[section]
2765
3715
                except KeyError:
2766
 
                    return default
2767
 
            return section_obj.get(name, default)
 
3716
                    pass
 
3717
            if section_obj is None:
 
3718
                value = default
 
3719
            else:
 
3720
                value = section_obj.get(name, default)
2768
3721
        except errors.UnknownSmartMethod:
2769
 
            return self._vfs_get_option(name, section, default)
 
3722
            value = self._vfs_get_option(name, section, default)
 
3723
        for hook in config.OldConfigHooks['get']:
 
3724
            hook(self, name, value)
 
3725
        return value
2770
3726
 
2771
3727
    def _response_to_configobj(self, response):
2772
3728
        if len(response[0]) and response[0][0] != 'ok':
2773
3729
            raise errors.UnexpectedSmartServerResponse(response)
2774
3730
        lines = response[1].read_body_bytes().splitlines()
2775
 
        return config.ConfigObj(lines, encoding='utf-8')
 
3731
        conf = config.ConfigObj(lines, encoding='utf-8')
 
3732
        for hook in config.OldConfigHooks['load']:
 
3733
            hook(self)
 
3734
        return conf
2776
3735
 
2777
3736
 
2778
3737
class RemoteBranchConfig(RemoteConfig):
2886
3845
        return self._bzrdir._real_bzrdir
2887
3846
 
2888
3847
 
2889
 
 
2890
3848
def _extract_tar(tar, to_dir):
2891
3849
    """Extract all the contents of a tarfile object.
2892
3850
 
2896
3854
        tar.extract(tarinfo, to_dir)
2897
3855
 
2898
3856
 
 
3857
error_translators = registry.Registry()
 
3858
no_context_error_translators = registry.Registry()
 
3859
 
 
3860
 
2899
3861
def _translate_error(err, **context):
2900
3862
    """Translate an ErrorFromSmartServer into a more useful error.
2901
3863
 
2930
3892
                    'Missing key %r in context %r', key_err.args[0], context)
2931
3893
                raise err
2932
3894
 
2933
 
    if err.error_verb == 'IncompatibleRepositories':
2934
 
        raise errors.IncompatibleRepositories(err.error_args[0],
2935
 
            err.error_args[1], err.error_args[2])
2936
 
    elif err.error_verb == 'NoSuchRevision':
2937
 
        raise NoSuchRevision(find('branch'), err.error_args[0])
2938
 
    elif err.error_verb == 'nosuchrevision':
2939
 
        raise NoSuchRevision(find('repository'), err.error_args[0])
2940
 
    elif err.error_verb == 'nobranch':
2941
 
        if len(err.error_args) >= 1:
2942
 
            extra = err.error_args[0]
2943
 
        else:
2944
 
            extra = None
2945
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
2946
 
            detail=extra)
2947
 
    elif err.error_verb == 'norepository':
2948
 
        raise errors.NoRepositoryPresent(find('bzrdir'))
2949
 
    elif err.error_verb == 'LockContention':
2950
 
        raise errors.LockContention('(remote lock)')
2951
 
    elif err.error_verb == 'UnlockableTransport':
2952
 
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
2953
 
    elif err.error_verb == 'LockFailed':
2954
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
2955
 
    elif err.error_verb == 'TokenMismatch':
2956
 
        raise errors.TokenMismatch(find('token'), '(remote token)')
2957
 
    elif err.error_verb == 'Diverged':
2958
 
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
2959
 
    elif err.error_verb == 'TipChangeRejected':
2960
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2961
 
    elif err.error_verb == 'UnstackableBranchFormat':
2962
 
        raise errors.UnstackableBranchFormat(*err.error_args)
2963
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
2964
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2965
 
    elif err.error_verb == 'NotStacked':
2966
 
        raise errors.NotStacked(branch=find('branch'))
2967
 
    elif err.error_verb == 'PermissionDenied':
2968
 
        path = get_path()
2969
 
        if len(err.error_args) >= 2:
2970
 
            extra = err.error_args[1]
2971
 
        else:
2972
 
            extra = None
2973
 
        raise errors.PermissionDenied(path, extra=extra)
2974
 
    elif err.error_verb == 'ReadError':
2975
 
        path = get_path()
2976
 
        raise errors.ReadError(path)
2977
 
    elif err.error_verb == 'NoSuchFile':
2978
 
        path = get_path()
2979
 
        raise errors.NoSuchFile(path)
2980
 
    elif err.error_verb == 'FileExists':
2981
 
        raise errors.FileExists(err.error_args[0])
2982
 
    elif err.error_verb == 'DirectoryNotEmpty':
2983
 
        raise errors.DirectoryNotEmpty(err.error_args[0])
2984
 
    elif err.error_verb == 'ShortReadvError':
2985
 
        args = err.error_args
2986
 
        raise errors.ShortReadvError(
2987
 
            args[0], int(args[1]), int(args[2]), int(args[3]))
2988
 
    elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
 
3895
    try:
 
3896
        translator = error_translators.get(err.error_verb)
 
3897
    except KeyError:
 
3898
        pass
 
3899
    else:
 
3900
        raise translator(err, find, get_path)
 
3901
    try:
 
3902
        translator = no_context_error_translators.get(err.error_verb)
 
3903
    except KeyError:
 
3904
        raise errors.UnknownErrorFromSmartServer(err)
 
3905
    else:
 
3906
        raise translator(err)
 
3907
 
 
3908
 
 
3909
error_translators.register('NoSuchRevision',
 
3910
    lambda err, find, get_path: NoSuchRevision(
 
3911
        find('branch'), err.error_args[0]))
 
3912
error_translators.register('nosuchrevision',
 
3913
    lambda err, find, get_path: NoSuchRevision(
 
3914
        find('repository'), err.error_args[0]))
 
3915
 
 
3916
def _translate_nobranch_error(err, find, get_path):
 
3917
    if len(err.error_args) >= 1:
 
3918
        extra = err.error_args[0]
 
3919
    else:
 
3920
        extra = None
 
3921
    return errors.NotBranchError(path=find('bzrdir').root_transport.base,
 
3922
        detail=extra)
 
3923
 
 
3924
error_translators.register('nobranch', _translate_nobranch_error)
 
3925
error_translators.register('norepository',
 
3926
    lambda err, find, get_path: errors.NoRepositoryPresent(
 
3927
        find('bzrdir')))
 
3928
error_translators.register('UnlockableTransport',
 
3929
    lambda err, find, get_path: errors.UnlockableTransport(
 
3930
        find('bzrdir').root_transport))
 
3931
error_translators.register('TokenMismatch',
 
3932
    lambda err, find, get_path: errors.TokenMismatch(
 
3933
        find('token'), '(remote token)'))
 
3934
error_translators.register('Diverged',
 
3935
    lambda err, find, get_path: errors.DivergedBranches(
 
3936
        find('branch'), find('other_branch')))
 
3937
error_translators.register('NotStacked',
 
3938
    lambda err, find, get_path: errors.NotStacked(branch=find('branch')))
 
3939
 
 
3940
def _translate_PermissionDenied(err, find, get_path):
 
3941
    path = get_path()
 
3942
    if len(err.error_args) >= 2:
 
3943
        extra = err.error_args[1]
 
3944
    else:
 
3945
        extra = None
 
3946
    return errors.PermissionDenied(path, extra=extra)
 
3947
 
 
3948
error_translators.register('PermissionDenied', _translate_PermissionDenied)
 
3949
error_translators.register('ReadError',
 
3950
    lambda err, find, get_path: errors.ReadError(get_path()))
 
3951
error_translators.register('NoSuchFile',
 
3952
    lambda err, find, get_path: errors.NoSuchFile(get_path()))
 
3953
error_translators.register('TokenLockingNotSupported',
 
3954
    lambda err, find, get_path: errors.TokenLockingNotSupported(
 
3955
        find('repository')))
 
3956
error_translators.register('UnsuspendableWriteGroup',
 
3957
    lambda err, find, get_path: errors.UnsuspendableWriteGroup(
 
3958
        repository=find('repository')))
 
3959
error_translators.register('UnresumableWriteGroup',
 
3960
    lambda err, find, get_path: errors.UnresumableWriteGroup(
 
3961
        repository=find('repository'), write_groups=err.error_args[0],
 
3962
        reason=err.error_args[1]))
 
3963
no_context_error_translators.register('IncompatibleRepositories',
 
3964
    lambda err: errors.IncompatibleRepositories(
 
3965
        err.error_args[0], err.error_args[1], err.error_args[2]))
 
3966
no_context_error_translators.register('LockContention',
 
3967
    lambda err: errors.LockContention('(remote lock)'))
 
3968
no_context_error_translators.register('LockFailed',
 
3969
    lambda err: errors.LockFailed(err.error_args[0], err.error_args[1]))
 
3970
no_context_error_translators.register('TipChangeRejected',
 
3971
    lambda err: errors.TipChangeRejected(err.error_args[0].decode('utf8')))
 
3972
no_context_error_translators.register('UnstackableBranchFormat',
 
3973
    lambda err: errors.UnstackableBranchFormat(*err.error_args))
 
3974
no_context_error_translators.register('UnstackableRepositoryFormat',
 
3975
    lambda err: errors.UnstackableRepositoryFormat(*err.error_args))
 
3976
no_context_error_translators.register('FileExists',
 
3977
    lambda err: errors.FileExists(err.error_args[0]))
 
3978
no_context_error_translators.register('DirectoryNotEmpty',
 
3979
    lambda err: errors.DirectoryNotEmpty(err.error_args[0]))
 
3980
 
 
3981
def _translate_short_readv_error(err):
 
3982
    args = err.error_args
 
3983
    return errors.ShortReadvError(args[0], int(args[1]), int(args[2]),
 
3984
        int(args[3]))
 
3985
 
 
3986
no_context_error_translators.register('ShortReadvError',
 
3987
    _translate_short_readv_error)
 
3988
 
 
3989
def _translate_unicode_error(err):
2989
3990
        encoding = str(err.error_args[0]) # encoding must always be a string
2990
3991
        val = err.error_args[1]
2991
3992
        start = int(err.error_args[2])
2999
4000
            raise UnicodeDecodeError(encoding, val, start, end, reason)
3000
4001
        elif err.error_verb == 'UnicodeEncodeError':
3001
4002
            raise UnicodeEncodeError(encoding, val, start, end, reason)
3002
 
    elif err.error_verb == 'ReadOnlyError':
3003
 
        raise errors.TransportNotPossible('readonly transport')
3004
 
    raise errors.UnknownErrorFromSmartServer(err)
 
4003
 
 
4004
no_context_error_translators.register('UnicodeEncodeError',
 
4005
    _translate_unicode_error)
 
4006
no_context_error_translators.register('UnicodeDecodeError',
 
4007
    _translate_unicode_error)
 
4008
no_context_error_translators.register('ReadOnlyError',
 
4009
    lambda err: errors.TransportNotPossible('readonly transport'))
 
4010
no_context_error_translators.register('MemoryError',
 
4011
    lambda err: errors.BzrError("remote server out of memory\n"
 
4012
        "Retry non-remotely, or contact the server admin for details."))
 
4013
no_context_error_translators.register('RevisionNotPresent',
 
4014
    lambda err: errors.RevisionNotPresent(err.error_args[0], err.error_args[1]))
 
4015
 
 
4016
no_context_error_translators.register('BzrCheckError',
 
4017
    lambda err: errors.BzrCheckError(msg=err.error_args[0]))
 
4018