← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

(jelmer) Add a post_connect hook for transports. (Bazaar Developers)

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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
from __future__ import absolute_import
 
18
 
17
19
import bz2
 
20
import zlib
18
21
 
19
22
from bzrlib import (
20
23
    bencode,
21
24
    branch,
22
 
    bzrdir,
 
25
    bzrdir as _mod_bzrdir,
23
26
    config,
 
27
    controldir,
24
28
    debug,
25
29
    errors,
 
30
    gpg,
26
31
    graph,
 
32
    inventory_delta,
27
33
    lock,
28
34
    lockdir,
29
 
    repository,
 
35
    osutils,
 
36
    registry,
30
37
    repository as _mod_repository,
31
 
    revision,
32
38
    revision as _mod_revision,
33
39
    static_tuple,
34
40
    symbol_versioning,
35
 
)
36
 
from bzrlib.branch import BranchReferenceFormat
37
 
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
 
41
    testament as _mod_testament,
 
42
    urlutils,
 
43
    vf_repository,
 
44
    vf_search,
 
45
    )
 
46
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
38
47
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
39
48
from bzrlib.errors import (
40
49
    NoSuchRevision,
41
50
    SmartProtocolError,
42
51
    )
 
52
from bzrlib.i18n import gettext
 
53
from bzrlib.inventory import Inventory
43
54
from bzrlib.lockable_files import LockableFiles
44
55
from bzrlib.smart import client, vfs, repository as smart_repo
45
 
from bzrlib.revision import ensure_null, NULL_REVISION
46
 
from bzrlib.trace import mutter, note, warning
 
56
from bzrlib.smart.client import _SmartClient
 
57
from bzrlib.revision import NULL_REVISION
 
58
from bzrlib.revisiontree import InventoryRevisionTree
 
59
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
 
60
from bzrlib.serializer import format_registry as serializer_format_registry
 
61
from bzrlib.trace import mutter, note, warning, log_exception_quietly
 
62
 
 
63
 
 
64
_DEFAULT_SEARCH_DEPTH = 100
47
65
 
48
66
 
49
67
class _RpcHelper(object):
86
104
    return format
87
105
 
88
106
 
89
 
# Note: RemoteBzrDirFormat is in bzrdir.py
90
 
 
91
 
class RemoteBzrDir(BzrDir, _RpcHelper):
 
107
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
 
108
# does not have to be imported unless a remote format is involved.
 
109
 
 
110
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
 
111
    """Format representing bzrdirs accessed via a smart server"""
 
112
 
 
113
    supports_workingtrees = False
 
114
 
 
115
    def __init__(self):
 
116
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
 
117
        # XXX: It's a bit ugly that the network name is here, because we'd
 
118
        # like to believe that format objects are stateless or at least
 
119
        # immutable,  However, we do at least avoid mutating the name after
 
120
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
 
121
        self._network_name = None
 
122
 
 
123
    def __repr__(self):
 
124
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
125
            self._network_name)
 
126
 
 
127
    def get_format_description(self):
 
128
        if self._network_name:
 
129
            try:
 
130
                real_format = controldir.network_format_registry.get(
 
131
                        self._network_name)
 
132
            except KeyError:
 
133
                pass
 
134
            else:
 
135
                return 'Remote: ' + real_format.get_format_description()
 
136
        return 'bzr remote bzrdir'
 
137
 
 
138
    def get_format_string(self):
 
139
        raise NotImplementedError(self.get_format_string)
 
140
 
 
141
    def network_name(self):
 
142
        if self._network_name:
 
143
            return self._network_name
 
144
        else:
 
145
            raise AssertionError("No network name set.")
 
146
 
 
147
    def initialize_on_transport(self, transport):
 
148
        try:
 
149
            # hand off the request to the smart server
 
150
            client_medium = transport.get_smart_medium()
 
151
        except errors.NoSmartMedium:
 
152
            # TODO: lookup the local format from a server hint.
 
153
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
154
            return local_dir_format.initialize_on_transport(transport)
 
155
        client = _SmartClient(client_medium)
 
156
        path = client.remote_path_from_transport(transport)
 
157
        try:
 
158
            response = client.call('BzrDirFormat.initialize', path)
 
159
        except errors.ErrorFromSmartServer, err:
 
160
            _translate_error(err, path=path)
 
161
        if response[0] != 'ok':
 
162
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
 
163
        format = RemoteBzrDirFormat()
 
164
        self._supply_sub_formats_to(format)
 
165
        return RemoteBzrDir(transport, format)
 
166
 
 
167
    def parse_NoneTrueFalse(self, arg):
 
168
        if not arg:
 
169
            return None
 
170
        if arg == 'False':
 
171
            return False
 
172
        if arg == 'True':
 
173
            return True
 
174
        raise AssertionError("invalid arg %r" % arg)
 
175
 
 
176
    def _serialize_NoneTrueFalse(self, arg):
 
177
        if arg is False:
 
178
            return 'False'
 
179
        if arg:
 
180
            return 'True'
 
181
        return ''
 
182
 
 
183
    def _serialize_NoneString(self, arg):
 
184
        return arg or ''
 
185
 
 
186
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
187
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
188
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
189
        shared_repo=False):
 
190
        try:
 
191
            # hand off the request to the smart server
 
192
            client_medium = transport.get_smart_medium()
 
193
        except errors.NoSmartMedium:
 
194
            do_vfs = True
 
195
        else:
 
196
            # Decline to open it if the server doesn't support our required
 
197
            # version (3) so that the VFS-based transport will do it.
 
198
            if client_medium.should_probe():
 
199
                try:
 
200
                    server_version = client_medium.protocol_version()
 
201
                    if server_version != '2':
 
202
                        do_vfs = True
 
203
                    else:
 
204
                        do_vfs = False
 
205
                except errors.SmartProtocolError:
 
206
                    # Apparently there's no usable smart server there, even though
 
207
                    # the medium supports the smart protocol.
 
208
                    do_vfs = True
 
209
            else:
 
210
                do_vfs = False
 
211
        if not do_vfs:
 
212
            client = _SmartClient(client_medium)
 
213
            path = client.remote_path_from_transport(transport)
 
214
            if client_medium._is_remote_before((1, 16)):
 
215
                do_vfs = True
 
216
        if do_vfs:
 
217
            # TODO: lookup the local format from a server hint.
 
218
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
219
            self._supply_sub_formats_to(local_dir_format)
 
220
            return local_dir_format.initialize_on_transport_ex(transport,
 
221
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
222
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
223
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
224
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
225
                vfs_only=True)
 
226
        return self._initialize_on_transport_ex_rpc(client, path, transport,
 
227
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
228
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
 
229
 
 
230
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
 
231
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
232
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
 
233
        args = []
 
234
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
 
235
        args.append(self._serialize_NoneTrueFalse(create_prefix))
 
236
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
 
237
        args.append(self._serialize_NoneString(stacked_on))
 
238
        # stack_on_pwd is often/usually our transport
 
239
        if stack_on_pwd:
 
240
            try:
 
241
                stack_on_pwd = transport.relpath(stack_on_pwd)
 
242
                if not stack_on_pwd:
 
243
                    stack_on_pwd = '.'
 
244
            except errors.PathNotChild:
 
245
                pass
 
246
        args.append(self._serialize_NoneString(stack_on_pwd))
 
247
        args.append(self._serialize_NoneString(repo_format_name))
 
248
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
 
249
        args.append(self._serialize_NoneTrueFalse(shared_repo))
 
250
        request_network_name = self._network_name or \
 
251
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
 
252
        try:
 
253
            response = client.call('BzrDirFormat.initialize_ex_1.16',
 
254
                request_network_name, path, *args)
 
255
        except errors.UnknownSmartMethod:
 
256
            client._medium._remember_remote_is_before((1,16))
 
257
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
258
            self._supply_sub_formats_to(local_dir_format)
 
259
            return local_dir_format.initialize_on_transport_ex(transport,
 
260
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
261
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
262
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
263
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
264
                vfs_only=True)
 
265
        except errors.ErrorFromSmartServer, err:
 
266
            _translate_error(err, path=path)
 
267
        repo_path = response[0]
 
268
        bzrdir_name = response[6]
 
269
        require_stacking = response[7]
 
270
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
 
271
        format = RemoteBzrDirFormat()
 
272
        format._network_name = bzrdir_name
 
273
        self._supply_sub_formats_to(format)
 
274
        bzrdir = RemoteBzrDir(transport, format, _client=client)
 
275
        if repo_path:
 
276
            repo_format = response_tuple_to_repo_format(response[1:])
 
277
            if repo_path == '.':
 
278
                repo_path = ''
 
279
            if repo_path:
 
280
                repo_bzrdir_format = RemoteBzrDirFormat()
 
281
                repo_bzrdir_format._network_name = response[5]
 
282
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
 
283
                    repo_bzrdir_format)
 
284
            else:
 
285
                repo_bzr = bzrdir
 
286
            final_stack = response[8] or None
 
287
            final_stack_pwd = response[9] or None
 
288
            if final_stack_pwd:
 
289
                final_stack_pwd = urlutils.join(
 
290
                    transport.base, final_stack_pwd)
 
291
            remote_repo = RemoteRepository(repo_bzr, repo_format)
 
292
            if len(response) > 10:
 
293
                # Updated server verb that locks remotely.
 
294
                repo_lock_token = response[10] or None
 
295
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
 
296
                if repo_lock_token:
 
297
                    remote_repo.dont_leave_lock_in_place()
 
298
            else:
 
299
                remote_repo.lock_write()
 
300
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
 
301
                final_stack_pwd, require_stacking)
 
302
            policy.acquire_repository()
 
303
        else:
 
304
            remote_repo = None
 
305
            policy = None
 
306
        bzrdir._format.set_branch_format(self.get_branch_format())
 
307
        if require_stacking:
 
308
            # The repo has already been created, but we need to make sure that
 
309
            # we'll make a stackable branch.
 
310
            bzrdir._format.require_stacking(_skip_repo=True)
 
311
        return remote_repo, bzrdir, require_stacking, policy
 
312
 
 
313
    def _open(self, transport):
 
314
        return RemoteBzrDir(transport, self)
 
315
 
 
316
    def __eq__(self, other):
 
317
        if not isinstance(other, RemoteBzrDirFormat):
 
318
            return False
 
319
        return self.get_format_description() == other.get_format_description()
 
320
 
 
321
    def __return_repository_format(self):
 
322
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
 
323
        # repository format has been asked for, tell the RemoteRepositoryFormat
 
324
        # that it should use that for init() etc.
 
325
        result = RemoteRepositoryFormat()
 
326
        custom_format = getattr(self, '_repository_format', None)
 
327
        if custom_format:
 
328
            if isinstance(custom_format, RemoteRepositoryFormat):
 
329
                return custom_format
 
330
            else:
 
331
                # We will use the custom format to create repositories over the
 
332
                # wire; expose its details like rich_root_data for code to
 
333
                # query
 
334
                result._custom_format = custom_format
 
335
        return result
 
336
 
 
337
    def get_branch_format(self):
 
338
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
 
339
        if not isinstance(result, RemoteBranchFormat):
 
340
            new_result = RemoteBranchFormat()
 
341
            new_result._custom_format = result
 
342
            # cache the result
 
343
            self.set_branch_format(new_result)
 
344
            result = new_result
 
345
        return result
 
346
 
 
347
    repository_format = property(__return_repository_format,
 
348
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
 
349
 
 
350
 
 
351
class RemoteControlStore(config.IniFileStore):
 
352
    """Control store which attempts to use HPSS calls to retrieve control store.
 
353
 
 
354
    Note that this is specific to bzr-based formats.
 
355
    """
 
356
 
 
357
    def __init__(self, bzrdir):
 
358
        super(RemoteControlStore, self).__init__()
 
359
        self.bzrdir = bzrdir
 
360
        self._real_store = None
 
361
 
 
362
    def lock_write(self, token=None):
 
363
        self._ensure_real()
 
364
        return self._real_store.lock_write(token)
 
365
 
 
366
    def unlock(self):
 
367
        self._ensure_real()
 
368
        return self._real_store.unlock()
 
369
 
 
370
    @needs_write_lock
 
371
    def save(self):
 
372
        # We need to be able to override the undecorated implementation
 
373
        self.save_without_locking()
 
374
 
 
375
    def save_without_locking(self):
 
376
        super(RemoteControlStore, self).save()
 
377
 
 
378
    def _ensure_real(self):
 
379
        self.bzrdir._ensure_real()
 
380
        if self._real_store is None:
 
381
            self._real_store = config.ControlStore(self.bzrdir)
 
382
 
 
383
    def external_url(self):
 
384
        return self.bzrdir.user_url
 
385
 
 
386
    def _load_content(self):
 
387
        medium = self.bzrdir._client._medium
 
388
        path = self.bzrdir._path_for_remote_call(self.bzrdir._client)
 
389
        try:
 
390
            response, handler = self.bzrdir._call_expecting_body(
 
391
                'BzrDir.get_config_file', path)
 
392
        except errors.UnknownSmartMethod:
 
393
            self._ensure_real()
 
394
            return self._real_store._load_content()
 
395
        if len(response) and response[0] != 'ok':
 
396
            raise errors.UnexpectedSmartServerResponse(response)
 
397
        return handler.read_body_bytes()
 
398
 
 
399
    def _save_content(self, content):
 
400
        # FIXME JRV 2011-11-22: Ideally this should use a
 
401
        # HPSS call too, but at the moment it is not possible
 
402
        # to write lock control directories.
 
403
        self._ensure_real()
 
404
        return self._real_store._save_content(content)
 
405
 
 
406
 
 
407
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
92
408
    """Control directory on a remote server, accessed via bzr:// or similar."""
93
409
 
94
410
    def __init__(self, transport, format, _client=None, _force_probe=False):
97
413
        :param _client: Private parameter for testing. Disables probing and the
98
414
            use of a real bzrdir.
99
415
        """
100
 
        BzrDir.__init__(self, transport, format)
 
416
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
101
417
        # this object holds a delegated bzrdir that uses file-level operations
102
418
        # to talk to the other side
103
419
        self._real_bzrdir = None
163
479
                import traceback
164
480
                warning('VFS BzrDir access triggered\n%s',
165
481
                    ''.join(traceback.format_stack()))
166
 
            self._real_bzrdir = BzrDir.open_from_transport(
 
482
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
167
483
                self.root_transport, _server_formats=False)
168
484
            self._format._network_name = \
169
485
                self._real_bzrdir._format.network_name()
175
491
        # Prevent aliasing problems in the next_open_branch_result cache.
176
492
        # See create_branch for rationale.
177
493
        self._next_open_branch_result = None
178
 
        return BzrDir.break_lock(self)
 
494
        return _mod_bzrdir.BzrDir.break_lock(self)
 
495
 
 
496
    def _vfs_checkout_metadir(self):
 
497
        self._ensure_real()
 
498
        return self._real_bzrdir.checkout_metadir()
 
499
 
 
500
    def checkout_metadir(self):
 
501
        """Retrieve the controldir format to use for checkouts of this one.
 
502
        """
 
503
        medium = self._client._medium
 
504
        if medium._is_remote_before((2, 5)):
 
505
            return self._vfs_checkout_metadir()
 
506
        path = self._path_for_remote_call(self._client)
 
507
        try:
 
508
            response = self._client.call('BzrDir.checkout_metadir',
 
509
                path)
 
510
        except errors.UnknownSmartMethod:
 
511
            medium._remember_remote_is_before((2, 5))
 
512
            return self._vfs_checkout_metadir()
 
513
        if len(response) != 3:
 
514
            raise errors.UnexpectedSmartServerResponse(response)
 
515
        control_name, repo_name, branch_name = response
 
516
        try:
 
517
            format = controldir.network_format_registry.get(control_name)
 
518
        except KeyError:
 
519
            raise errors.UnknownFormatError(kind='control',
 
520
                format=control_name)
 
521
        if repo_name:
 
522
            try:
 
523
                repo_format = _mod_repository.network_format_registry.get(
 
524
                    repo_name)
 
525
            except KeyError:
 
526
                raise errors.UnknownFormatError(kind='repository',
 
527
                    format=repo_name)
 
528
            format.repository_format = repo_format
 
529
        if branch_name:
 
530
            try:
 
531
                format.set_branch_format(
 
532
                    branch.network_format_registry.get(branch_name))
 
533
            except KeyError:
 
534
                raise errors.UnknownFormatError(kind='branch',
 
535
                    format=branch_name)
 
536
        return format
179
537
 
180
538
    def _vfs_cloning_metadir(self, require_stacking=False):
181
539
        self._ensure_real()
212
570
        if len(branch_info) != 2:
213
571
            raise errors.UnexpectedSmartServerResponse(response)
214
572
        branch_ref, branch_name = branch_info
215
 
        format = bzrdir.network_format_registry.get(control_name)
 
573
        try:
 
574
            format = controldir.network_format_registry.get(control_name)
 
575
        except KeyError:
 
576
            raise errors.UnknownFormatError(kind='control', format=control_name)
 
577
 
216
578
        if repo_name:
217
 
            format.repository_format = repository.network_format_registry.get(
218
 
                repo_name)
 
579
            try:
 
580
                format.repository_format = _mod_repository.network_format_registry.get(
 
581
                    repo_name)
 
582
            except KeyError:
 
583
                raise errors.UnknownFormatError(kind='repository',
 
584
                    format=repo_name)
219
585
        if branch_ref == 'ref':
220
586
            # XXX: we need possible_transports here to avoid reopening the
221
587
            # connection to the referenced location
222
 
            ref_bzrdir = BzrDir.open(branch_name)
 
588
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
223
589
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
224
590
            format.set_branch_format(branch_format)
225
591
        elif branch_ref == 'branch':
226
592
            if branch_name:
227
 
                format.set_branch_format(
228
 
                    branch.network_format_registry.get(branch_name))
 
593
                try:
 
594
                    branch_format = branch.network_format_registry.get(
 
595
                        branch_name)
 
596
                except KeyError:
 
597
                    raise errors.UnknownFormatError(kind='branch',
 
598
                        format=branch_name)
 
599
                format.set_branch_format(branch_format)
229
600
        else:
230
601
            raise errors.UnexpectedSmartServerResponse(response)
231
602
        return format
241
612
 
242
613
    def destroy_repository(self):
243
614
        """See BzrDir.destroy_repository"""
244
 
        self._ensure_real()
245
 
        self._real_bzrdir.destroy_repository()
 
615
        path = self._path_for_remote_call(self._client)
 
616
        try:
 
617
            response = self._call('BzrDir.destroy_repository', path)
 
618
        except errors.UnknownSmartMethod:
 
619
            self._ensure_real()
 
620
            self._real_bzrdir.destroy_repository()
 
621
            return
 
622
        if response[0] != 'ok':
 
623
            raise SmartProtocolError('unexpected response code %s' % (response,))
246
624
 
247
 
    def create_branch(self, name=None):
 
625
    def create_branch(self, name=None, repository=None,
 
626
                      append_revisions_only=None):
248
627
        # as per meta1 formats - just delegate to the format object which may
249
628
        # be parameterised.
250
629
        real_branch = self._format.get_branch_format().initialize(self,
251
 
            name=name)
 
630
            name=name, repository=repository,
 
631
            append_revisions_only=append_revisions_only)
252
632
        if not isinstance(real_branch, RemoteBranch):
253
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
254
 
                                  name=name)
 
633
            if not isinstance(repository, RemoteRepository):
 
634
                raise AssertionError(
 
635
                    'need a RemoteRepository to use with RemoteBranch, got %r'
 
636
                    % (repository,))
 
637
            result = RemoteBranch(self, repository, real_branch, name=name)
255
638
        else:
256
639
            result = real_branch
257
640
        # BzrDir.clone_on_transport() uses the result of create_branch but does
265
648
 
266
649
    def destroy_branch(self, name=None):
267
650
        """See BzrDir.destroy_branch"""
268
 
        self._ensure_real()
269
 
        self._real_bzrdir.destroy_branch(name=name)
 
651
        path = self._path_for_remote_call(self._client)
 
652
        try:
 
653
            if name is not None:
 
654
                args = (name, )
 
655
            else:
 
656
                args = ()
 
657
            response = self._call('BzrDir.destroy_branch', path, *args)
 
658
        except errors.UnknownSmartMethod:
 
659
            self._ensure_real()
 
660
            self._real_bzrdir.destroy_branch(name=name)
 
661
            self._next_open_branch_result = None
 
662
            return
270
663
        self._next_open_branch_result = None
 
664
        if response[0] != 'ok':
 
665
            raise SmartProtocolError('unexpected response code %s' % (response,))
271
666
 
272
 
    def create_workingtree(self, revision_id=None, from_branch=None):
 
667
    def create_workingtree(self, revision_id=None, from_branch=None,
 
668
        accelerator_tree=None, hardlink=False):
273
669
        raise errors.NotLocalUrl(self.transport.base)
274
670
 
275
 
    def find_branch_format(self):
 
671
    def find_branch_format(self, name=None):
276
672
        """Find the branch 'format' for this bzrdir.
277
673
 
278
674
        This might be a synthetic object for e.g. RemoteBranch and SVN.
279
675
        """
280
 
        b = self.open_branch()
 
676
        b = self.open_branch(name=name)
281
677
        return b._format
282
678
 
283
 
    def get_branch_reference(self):
 
679
    def get_branch_reference(self, name=None):
284
680
        """See BzrDir.get_branch_reference()."""
 
681
        if name is not None:
 
682
            # XXX JRV20100304: Support opening colocated branches
 
683
            raise errors.NoColocatedBranchSupport(self)
285
684
        response = self._get_branch_reference()
286
685
        if response[0] == 'ref':
287
686
            return response[1]
318
717
            raise errors.UnexpectedSmartServerResponse(response)
319
718
        return response
320
719
 
321
 
    def _get_tree_branch(self):
 
720
    def _get_tree_branch(self, name=None):
322
721
        """See BzrDir._get_tree_branch()."""
323
 
        return None, self.open_branch()
 
722
        return None, self.open_branch(name=name)
324
723
 
325
724
    def open_branch(self, name=None, unsupported=False,
326
 
                    ignore_fallbacks=False):
 
725
                    ignore_fallbacks=False, possible_transports=None):
327
726
        if unsupported:
328
727
            raise NotImplementedError('unsupported flag support not implemented yet.')
329
728
        if self._next_open_branch_result is not None:
336
735
            # a branch reference, use the existing BranchReference logic.
337
736
            format = BranchReferenceFormat()
338
737
            return format.open(self, name=name, _found=True,
339
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
 
738
                location=response[1], ignore_fallbacks=ignore_fallbacks,
 
739
                possible_transports=possible_transports)
340
740
        branch_format_name = response[1]
341
741
        if not branch_format_name:
342
742
            branch_format_name = None
343
743
        format = RemoteBranchFormat(network_name=branch_format_name)
344
744
        return RemoteBranch(self, self.find_repository(), format=format,
345
 
            setup_stacking=not ignore_fallbacks, name=name)
 
745
            setup_stacking=not ignore_fallbacks, name=name,
 
746
            possible_transports=possible_transports)
346
747
 
347
748
    def _open_repo_v1(self, path):
348
749
        verb = 'BzrDir.find_repository'
411
812
 
412
813
    def has_workingtree(self):
413
814
        if self._has_working_tree is None:
414
 
            self._ensure_real()
415
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
 
815
            path = self._path_for_remote_call(self._client)
 
816
            try:
 
817
                response = self._call('BzrDir.has_workingtree', path)
 
818
            except errors.UnknownSmartMethod:
 
819
                self._ensure_real()
 
820
                self._has_working_tree = self._real_bzrdir.has_workingtree()
 
821
            else:
 
822
                if response[0] not in ('yes', 'no'):
 
823
                    raise SmartProtocolError('unexpected response code %s' % (response,))
 
824
                self._has_working_tree = (response[0] == 'yes')
416
825
        return self._has_working_tree
417
826
 
418
827
    def open_workingtree(self, recommend_upgrade=True):
423
832
 
424
833
    def _path_for_remote_call(self, client):
425
834
        """Return the path to be used for this bzrdir in a remote call."""
426
 
        return client.remote_path_from_transport(self.root_transport)
 
835
        return urlutils.split_segment_parameters_raw(
 
836
            client.remote_path_from_transport(self.root_transport))[0]
427
837
 
428
838
    def get_branch_transport(self, branch_format, name=None):
429
839
        self._ensure_real()
441
851
        """Upgrading of remote bzrdirs is not supported yet."""
442
852
        return False
443
853
 
444
 
    def needs_format_conversion(self, format=None):
 
854
    def needs_format_conversion(self, format):
445
855
        """Upgrading of remote bzrdirs is not supported yet."""
446
 
        if format is None:
447
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
448
 
                % 'needs_format_conversion(format=None)')
449
856
        return False
450
857
 
451
 
    def clone(self, url, revision_id=None, force_new_repo=False,
452
 
              preserve_stacking=False):
453
 
        self._ensure_real()
454
 
        return self._real_bzrdir.clone(url, revision_id=revision_id,
455
 
            force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
456
 
 
457
858
    def _get_config(self):
458
859
        return RemoteBzrDirConfig(self)
459
860
 
460
 
 
461
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
861
    def _get_config_store(self):
 
862
        return RemoteControlStore(self)
 
863
 
 
864
 
 
865
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
462
866
    """Format for repositories accessed over a _SmartClient.
463
867
 
464
868
    Instances of this repository are represented by RemoteRepository
479
883
    """
480
884
 
481
885
    _matchingbzrdir = RemoteBzrDirFormat()
 
886
    supports_full_versioned_files = True
 
887
    supports_leaving_lock = True
482
888
 
483
889
    def __init__(self):
484
 
        repository.RepositoryFormat.__init__(self)
 
890
        _mod_repository.RepositoryFormat.__init__(self)
485
891
        self._custom_format = None
486
892
        self._network_name = None
487
893
        self._creating_bzrdir = None
 
894
        self._revision_graph_can_have_wrong_parents = None
488
895
        self._supports_chks = None
489
896
        self._supports_external_lookups = None
490
897
        self._supports_tree_reference = None
 
898
        self._supports_funky_characters = None
 
899
        self._supports_nesting_repositories = None
491
900
        self._rich_root_data = None
492
901
 
493
902
    def __repr__(self):
522
931
        return self._supports_external_lookups
523
932
 
524
933
    @property
 
934
    def supports_funky_characters(self):
 
935
        if self._supports_funky_characters is None:
 
936
            self._ensure_real()
 
937
            self._supports_funky_characters = \
 
938
                self._custom_format.supports_funky_characters
 
939
        return self._supports_funky_characters
 
940
 
 
941
    @property
 
942
    def supports_nesting_repositories(self):
 
943
        if self._supports_nesting_repositories is None:
 
944
            self._ensure_real()
 
945
            self._supports_nesting_repositories = \
 
946
                self._custom_format.supports_nesting_repositories
 
947
        return self._supports_nesting_repositories
 
948
 
 
949
    @property
525
950
    def supports_tree_reference(self):
526
951
        if self._supports_tree_reference is None:
527
952
            self._ensure_real()
529
954
                self._custom_format.supports_tree_reference
530
955
        return self._supports_tree_reference
531
956
 
 
957
    @property
 
958
    def revision_graph_can_have_wrong_parents(self):
 
959
        if self._revision_graph_can_have_wrong_parents is None:
 
960
            self._ensure_real()
 
961
            self._revision_graph_can_have_wrong_parents = \
 
962
                self._custom_format.revision_graph_can_have_wrong_parents
 
963
        return self._revision_graph_can_have_wrong_parents
 
964
 
532
965
    def _vfs_initialize(self, a_bzrdir, shared):
533
966
        """Helper for common code in initialize."""
534
967
        if self._custom_format:
569
1002
            network_name = self._network_name
570
1003
        else:
571
1004
            # Select the current bzrlib default and ask for that.
572
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
1005
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
573
1006
            reference_format = reference_bzrdir_format.repository_format
574
1007
            network_name = reference_format.network_name()
575
1008
        # 2) try direct creation via RPC
601
1034
 
602
1035
    def _ensure_real(self):
603
1036
        if self._custom_format is None:
604
 
            self._custom_format = repository.network_format_registry.get(
605
 
                self._network_name)
 
1037
            try:
 
1038
                self._custom_format = _mod_repository.network_format_registry.get(
 
1039
                    self._network_name)
 
1040
            except KeyError:
 
1041
                raise errors.UnknownFormatError(kind='repository',
 
1042
                    format=self._network_name)
606
1043
 
607
1044
    @property
608
1045
    def _fetch_order(self):
643
1080
        return self._custom_format._serializer
644
1081
 
645
1082
 
646
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
647
 
    bzrdir.ControlComponent):
 
1083
class RemoteRepository(_mod_repository.Repository, _RpcHelper,
 
1084
        lock._RelockDebugMixin):
648
1085
    """Repository accessed over rpc.
649
1086
 
650
1087
    For the moment most operations are performed using local transport-backed
674
1111
        self._format = format
675
1112
        self._lock_mode = None
676
1113
        self._lock_token = None
 
1114
        self._write_group_tokens = None
677
1115
        self._lock_count = 0
678
1116
        self._leave_lock = False
679
1117
        # Cache of revision parents; misses are cached during read locks, and
703
1141
        # transport, but I'm not sure it's worth making this method
704
1142
        # optional -- mbp 2010-04-21
705
1143
        return self.bzrdir.get_repository_transport(None)
706
 
        
 
1144
 
707
1145
    def __str__(self):
708
1146
        return "%s(%s)" % (self.__class__.__name__, self.base)
709
1147
 
719
1157
 
720
1158
        :param suppress_errors: see Repository.abort_write_group.
721
1159
        """
722
 
        self._ensure_real()
723
 
        return self._real_repository.abort_write_group(
724
 
            suppress_errors=suppress_errors)
 
1160
        if self._real_repository:
 
1161
            self._ensure_real()
 
1162
            return self._real_repository.abort_write_group(
 
1163
                suppress_errors=suppress_errors)
 
1164
        if not self.is_in_write_group():
 
1165
            if suppress_errors:
 
1166
                mutter('(suppressed) not in write group')
 
1167
                return
 
1168
            raise errors.BzrError("not in write group")
 
1169
        path = self.bzrdir._path_for_remote_call(self._client)
 
1170
        try:
 
1171
            response = self._call('Repository.abort_write_group', path,
 
1172
                self._lock_token, self._write_group_tokens)
 
1173
        except Exception, exc:
 
1174
            self._write_group = None
 
1175
            if not suppress_errors:
 
1176
                raise
 
1177
            mutter('abort_write_group failed')
 
1178
            log_exception_quietly()
 
1179
            note(gettext('bzr: ERROR (ignored): %s'), exc)
 
1180
        else:
 
1181
            if response != ('ok', ):
 
1182
                raise errors.UnexpectedSmartServerResponse(response)
 
1183
            self._write_group_tokens = None
725
1184
 
726
1185
    @property
727
1186
    def chk_bytes(self):
741
1200
        for older plugins that don't use e.g. the CommitBuilder
742
1201
        facility.
743
1202
        """
744
 
        self._ensure_real()
745
 
        return self._real_repository.commit_write_group()
 
1203
        if self._real_repository:
 
1204
            self._ensure_real()
 
1205
            return self._real_repository.commit_write_group()
 
1206
        if not self.is_in_write_group():
 
1207
            raise errors.BzrError("not in write group")
 
1208
        path = self.bzrdir._path_for_remote_call(self._client)
 
1209
        response = self._call('Repository.commit_write_group', path,
 
1210
            self._lock_token, self._write_group_tokens)
 
1211
        if response != ('ok', ):
 
1212
            raise errors.UnexpectedSmartServerResponse(response)
 
1213
        self._write_group_tokens = None
 
1214
        # Refresh data after writing to the repository.
 
1215
        self.refresh_data()
746
1216
 
747
1217
    def resume_write_group(self, tokens):
748
 
        self._ensure_real()
749
 
        return self._real_repository.resume_write_group(tokens)
 
1218
        if self._real_repository:
 
1219
            return self._real_repository.resume_write_group(tokens)
 
1220
        path = self.bzrdir._path_for_remote_call(self._client)
 
1221
        try:
 
1222
            response = self._call('Repository.check_write_group', path,
 
1223
               self._lock_token, tokens)
 
1224
        except errors.UnknownSmartMethod:
 
1225
            self._ensure_real()
 
1226
            return self._real_repository.resume_write_group(tokens)
 
1227
        if response != ('ok', ):
 
1228
            raise errors.UnexpectedSmartServerResponse(response)
 
1229
        self._write_group_tokens = tokens
750
1230
 
751
1231
    def suspend_write_group(self):
752
 
        self._ensure_real()
753
 
        return self._real_repository.suspend_write_group()
 
1232
        if self._real_repository:
 
1233
            return self._real_repository.suspend_write_group()
 
1234
        ret = self._write_group_tokens or []
 
1235
        self._write_group_tokens = None
 
1236
        return ret
754
1237
 
755
1238
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
756
1239
        self._ensure_real()
817
1300
    def find_text_key_references(self):
818
1301
        """Find the text key references within the repository.
819
1302
 
820
 
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
821
 
        revision_ids. Each altered file-ids has the exact revision_ids that
822
 
        altered it listed explicitly.
823
1303
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
824
1304
            to whether they were referred to by the inventory of the
825
1305
            revision_id that they contain. The inventory texts from all present
843
1323
        """Private method for using with old (< 1.2) servers to fallback."""
844
1324
        if revision_id is None:
845
1325
            revision_id = ''
846
 
        elif revision.is_null(revision_id):
 
1326
        elif _mod_revision.is_null(revision_id):
847
1327
            return {}
848
1328
 
849
1329
        path = self.bzrdir._path_for_remote_call(self._client)
873
1353
        return RemoteStreamSource(self, to_format)
874
1354
 
875
1355
    @needs_read_lock
 
1356
    def get_file_graph(self):
 
1357
        return graph.Graph(self.texts)
 
1358
 
 
1359
    @needs_read_lock
876
1360
    def has_revision(self, revision_id):
877
1361
        """True if this repository has a copy of the revision."""
878
1362
        # Copy of bzrlib.repository.Repository.has_revision
895
1379
    def _has_same_fallbacks(self, other_repo):
896
1380
        """Returns true if the repositories have the same fallbacks."""
897
1381
        # XXX: copied from Repository; it should be unified into a base class
898
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
1382
        # <https://bugs.launchpad.net/bzr/+bug/401622>
899
1383
        my_fb = self._fallback_repositories
900
1384
        other_fb = other_repo._fallback_repositories
901
1385
        if len(my_fb) != len(other_fb):
930
1414
        """See Repository.gather_stats()."""
931
1415
        path = self.bzrdir._path_for_remote_call(self._client)
932
1416
        # revid can be None to indicate no revisions, not just NULL_REVISION
933
 
        if revid is None or revision.is_null(revid):
 
1417
        if revid is None or _mod_revision.is_null(revid):
934
1418
            fmt_revid = ''
935
1419
        else:
936
1420
            fmt_revid = revid
965
1449
 
966
1450
    def get_physical_lock_status(self):
967
1451
        """See Repository.get_physical_lock_status()."""
968
 
        # should be an API call to the server.
969
 
        self._ensure_real()
970
 
        return self._real_repository.get_physical_lock_status()
 
1452
        path = self.bzrdir._path_for_remote_call(self._client)
 
1453
        try:
 
1454
            response = self._call('Repository.get_physical_lock_status', path)
 
1455
        except errors.UnknownSmartMethod:
 
1456
            self._ensure_real()
 
1457
            return self._real_repository.get_physical_lock_status()
 
1458
        if response[0] not in ('yes', 'no'):
 
1459
            raise errors.UnexpectedSmartServerResponse(response)
 
1460
        return (response[0] == 'yes')
971
1461
 
972
1462
    def is_in_write_group(self):
973
1463
        """Return True if there is an open write group.
974
1464
 
975
1465
        write groups are only applicable locally for the smart server..
976
1466
        """
 
1467
        if self._write_group_tokens is not None:
 
1468
            return True
977
1469
        if self._real_repository:
978
1470
            return self._real_repository.is_in_write_group()
979
1471
 
997
1489
        pass
998
1490
 
999
1491
    def lock_read(self):
 
1492
        """Lock the repository for read operations.
 
1493
 
 
1494
        :return: A bzrlib.lock.LogicalLockResult.
 
1495
        """
1000
1496
        # wrong eventually - want a local lock cache context
1001
1497
        if not self._lock_mode:
1002
1498
            self._note_lock('r')
1009
1505
                repo.lock_read()
1010
1506
        else:
1011
1507
            self._lock_count += 1
 
1508
        return lock.LogicalLockResult(self.unlock)
1012
1509
 
1013
1510
    def _remote_lock_write(self, token):
1014
1511
        path = self.bzrdir._path_for_remote_call(self._client)
1054
1551
            raise errors.ReadOnlyError(self)
1055
1552
        else:
1056
1553
            self._lock_count += 1
1057
 
        return self._lock_token or None
 
1554
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
1058
1555
 
1059
1556
    def leave_lock_in_place(self):
1060
1557
        if not self._lock_token:
1109
1606
            self._real_repository.lock_write(self._lock_token)
1110
1607
        elif self._lock_mode == 'r':
1111
1608
            self._real_repository.lock_read()
 
1609
        if self._write_group_tokens is not None:
 
1610
            # if we are already in a write group, resume it
 
1611
            self._real_repository.resume_write_group(self._write_group_tokens)
 
1612
            self._write_group_tokens = None
1112
1613
 
1113
1614
    def start_write_group(self):
1114
1615
        """Start a write group on the decorated repository.
1118
1619
        for older plugins that don't use e.g. the CommitBuilder
1119
1620
        facility.
1120
1621
        """
1121
 
        self._ensure_real()
1122
 
        return self._real_repository.start_write_group()
 
1622
        if self._real_repository:
 
1623
            self._ensure_real()
 
1624
            return self._real_repository.start_write_group()
 
1625
        if not self.is_write_locked():
 
1626
            raise errors.NotWriteLocked(self)
 
1627
        if self._write_group_tokens is not None:
 
1628
            raise errors.BzrError('already in a write group')
 
1629
        path = self.bzrdir._path_for_remote_call(self._client)
 
1630
        try:
 
1631
            response = self._call('Repository.start_write_group', path,
 
1632
                self._lock_token)
 
1633
        except (errors.UnknownSmartMethod, errors.UnsuspendableWriteGroup):
 
1634
            self._ensure_real()
 
1635
            return self._real_repository.start_write_group()
 
1636
        if response[0] != 'ok':
 
1637
            raise errors.UnexpectedSmartServerResponse(response)
 
1638
        self._write_group_tokens = response[1]
1123
1639
 
1124
1640
    def _unlock(self, token):
1125
1641
        path = self.bzrdir._path_for_remote_call(self._client)
1152
1668
            # This is just to let the _real_repository stay up to date.
1153
1669
            if self._real_repository is not None:
1154
1670
                self._real_repository.unlock()
 
1671
            elif self._write_group_tokens is not None:
 
1672
                self.abort_write_group()
1155
1673
        finally:
1156
1674
            # The rpc-level lock should be released even if there was a
1157
1675
            # problem releasing the vfs-based lock.
1169
1687
 
1170
1688
    def break_lock(self):
1171
1689
        # should hand off to the network
1172
 
        self._ensure_real()
1173
 
        return self._real_repository.break_lock()
 
1690
        path = self.bzrdir._path_for_remote_call(self._client)
 
1691
        try:
 
1692
            response = self._call("Repository.break_lock", path)
 
1693
        except errors.UnknownSmartMethod:
 
1694
            self._ensure_real()
 
1695
            return self._real_repository.break_lock()
 
1696
        if response != ('ok',):
 
1697
            raise errors.UnexpectedSmartServerResponse(response)
1174
1698
 
1175
1699
    def _get_tarball(self, compression):
1176
1700
        """Return a TemporaryFile containing a repository tarball.
1194
1718
            return t
1195
1719
        raise errors.UnexpectedSmartServerResponse(response)
1196
1720
 
 
1721
    @needs_read_lock
1197
1722
    def sprout(self, to_bzrdir, revision_id=None):
1198
 
        # TODO: Option to control what format is created?
1199
 
        self._ensure_real()
1200
 
        dest_repo = self._real_repository._format.initialize(to_bzrdir,
1201
 
                                                             shared=False)
 
1723
        """Create a descendent repository for new development.
 
1724
 
 
1725
        Unlike clone, this does not copy the settings of the repository.
 
1726
        """
 
1727
        dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
1202
1728
        dest_repo.fetch(self, revision_id=revision_id)
1203
1729
        return dest_repo
1204
1730
 
 
1731
    def _create_sprouting_repo(self, a_bzrdir, shared):
 
1732
        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
 
1733
            # use target default format.
 
1734
            dest_repo = a_bzrdir.create_repository()
 
1735
        else:
 
1736
            # Most control formats need the repository to be specifically
 
1737
            # created, but on some old all-in-one formats it's not needed
 
1738
            try:
 
1739
                dest_repo = self._format.initialize(a_bzrdir, shared=shared)
 
1740
            except errors.UninitializableFormat:
 
1741
                dest_repo = a_bzrdir.open_repository()
 
1742
        return dest_repo
 
1743
 
1205
1744
    ### These methods are just thin shims to the VFS object for now.
1206
1745
 
 
1746
    @needs_read_lock
1207
1747
    def revision_tree(self, revision_id):
1208
 
        self._ensure_real()
1209
 
        return self._real_repository.revision_tree(revision_id)
 
1748
        revision_id = _mod_revision.ensure_null(revision_id)
 
1749
        if revision_id == _mod_revision.NULL_REVISION:
 
1750
            return InventoryRevisionTree(self,
 
1751
                Inventory(root_id=None), _mod_revision.NULL_REVISION)
 
1752
        else:
 
1753
            return list(self.revision_trees([revision_id]))[0]
1210
1754
 
1211
1755
    def get_serializer_format(self):
1212
 
        self._ensure_real()
1213
 
        return self._real_repository.get_serializer_format()
 
1756
        path = self.bzrdir._path_for_remote_call(self._client)
 
1757
        try:
 
1758
            response = self._call('VersionedFileRepository.get_serializer_format',
 
1759
                path)
 
1760
        except errors.UnknownSmartMethod:
 
1761
            self._ensure_real()
 
1762
            return self._real_repository.get_serializer_format()
 
1763
        if response[0] != 'ok':
 
1764
            raise errors.UnexpectedSmartServerResponse(response)
 
1765
        return response[1]
1214
1766
 
1215
1767
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1216
1768
                           timezone=None, committer=None, revprops=None,
1217
 
                           revision_id=None):
1218
 
        # FIXME: It ought to be possible to call this without immediately
1219
 
        # triggering _ensure_real.  For now it's the easiest thing to do.
1220
 
        self._ensure_real()
1221
 
        real_repo = self._real_repository
1222
 
        builder = real_repo.get_commit_builder(branch, parents,
1223
 
                config, timestamp=timestamp, timezone=timezone,
1224
 
                committer=committer, revprops=revprops, revision_id=revision_id)
1225
 
        return builder
 
1769
                           revision_id=None, lossy=False):
 
1770
        """Obtain a CommitBuilder for this repository.
 
1771
 
 
1772
        :param branch: Branch to commit to.
 
1773
        :param parents: Revision ids of the parents of the new revision.
 
1774
        :param config: Configuration to use.
 
1775
        :param timestamp: Optional timestamp recorded for commit.
 
1776
        :param timezone: Optional timezone for timestamp.
 
1777
        :param committer: Optional committer to set for commit.
 
1778
        :param revprops: Optional dictionary of revision properties.
 
1779
        :param revision_id: Optional revision id.
 
1780
        :param lossy: Whether to discard data that can not be natively
 
1781
            represented, when pushing to a foreign VCS
 
1782
        """
 
1783
        if self._fallback_repositories and not self._format.supports_chks:
 
1784
            raise errors.BzrError("Cannot commit directly to a stacked branch"
 
1785
                " in pre-2a formats. See "
 
1786
                "https://bugs.launchpad.net/bzr/+bug/375013 for details.")
 
1787
        if self._format.rich_root_data:
 
1788
            commit_builder_kls = vf_repository.VersionedFileRootCommitBuilder
 
1789
        else:
 
1790
            commit_builder_kls = vf_repository.VersionedFileCommitBuilder
 
1791
        result = commit_builder_kls(self, parents, config,
 
1792
            timestamp, timezone, committer, revprops, revision_id,
 
1793
            lossy)
 
1794
        self.start_write_group()
 
1795
        return result
1226
1796
 
1227
1797
    def add_fallback_repository(self, repository):
1228
1798
        """Add a repository to use for looking up data not held locally.
1235
1805
        # We need to accumulate additional repositories here, to pass them in
1236
1806
        # on various RPC's.
1237
1807
        #
 
1808
        # Make the check before we lock: this raises an exception.
 
1809
        self._check_fallback_repository(repository)
1238
1810
        if self.is_locked():
1239
1811
            # We will call fallback.unlock() when we transition to the unlocked
1240
1812
            # state, so always add a lock here. If a caller passes us a locked
1241
1813
            # repository, they are responsible for unlocking it later.
1242
1814
            repository.lock_read()
1243
 
        self._check_fallback_repository(repository)
1244
1815
        self._fallback_repositories.append(repository)
1245
1816
        # If self._real_repository was parameterised already (e.g. because a
1246
1817
        # _real_branch had its get_stacked_on_url method called), then the
1279
1850
 
1280
1851
    @needs_read_lock
1281
1852
    def get_inventory(self, revision_id):
 
1853
        return list(self.iter_inventories([revision_id]))[0]
 
1854
 
 
1855
    def _iter_inventories_rpc(self, revision_ids, ordering):
 
1856
        if ordering is None:
 
1857
            ordering = 'unordered'
 
1858
        path = self.bzrdir._path_for_remote_call(self._client)
 
1859
        body = "\n".join(revision_ids)
 
1860
        response_tuple, response_handler = (
 
1861
            self._call_with_body_bytes_expecting_body(
 
1862
                "VersionedFileRepository.get_inventories",
 
1863
                (path, ordering), body))
 
1864
        if response_tuple[0] != "ok":
 
1865
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
1866
        deserializer = inventory_delta.InventoryDeltaDeserializer()
 
1867
        byte_stream = response_handler.read_streamed_body()
 
1868
        decoded = smart_repo._byte_stream_to_stream(byte_stream)
 
1869
        if decoded is None:
 
1870
            # no results whatsoever
 
1871
            return
 
1872
        src_format, stream = decoded
 
1873
        if src_format.network_name() != self._format.network_name():
 
1874
            raise AssertionError(
 
1875
                "Mismatched RemoteRepository and stream src %r, %r" % (
 
1876
                src_format.network_name(), self._format.network_name()))
 
1877
        # ignore the src format, it's not really relevant
 
1878
        prev_inv = Inventory(root_id=None,
 
1879
            revision_id=_mod_revision.NULL_REVISION)
 
1880
        # there should be just one substream, with inventory deltas
 
1881
        substream_kind, substream = stream.next()
 
1882
        if substream_kind != "inventory-deltas":
 
1883
            raise AssertionError(
 
1884
                 "Unexpected stream %r received" % substream_kind)
 
1885
        for record in substream:
 
1886
            (parent_id, new_id, versioned_root, tree_references, invdelta) = (
 
1887
                deserializer.parse_text_bytes(record.get_bytes_as("fulltext")))
 
1888
            if parent_id != prev_inv.revision_id:
 
1889
                raise AssertionError("invalid base %r != %r" % (parent_id,
 
1890
                    prev_inv.revision_id))
 
1891
            inv = prev_inv.create_by_apply_delta(invdelta, new_id)
 
1892
            yield inv, inv.revision_id
 
1893
            prev_inv = inv
 
1894
 
 
1895
    def _iter_inventories_vfs(self, revision_ids, ordering=None):
1282
1896
        self._ensure_real()
1283
 
        return self._real_repository.get_inventory(revision_id)
 
1897
        return self._real_repository._iter_inventories(revision_ids, ordering)
1284
1898
 
1285
1899
    def iter_inventories(self, revision_ids, ordering=None):
1286
 
        self._ensure_real()
1287
 
        return self._real_repository.iter_inventories(revision_ids, ordering)
 
1900
        """Get many inventories by revision_ids.
 
1901
 
 
1902
        This will buffer some or all of the texts used in constructing the
 
1903
        inventories in memory, but will only parse a single inventory at a
 
1904
        time.
 
1905
 
 
1906
        :param revision_ids: The expected revision ids of the inventories.
 
1907
        :param ordering: optional ordering, e.g. 'topological'.  If not
 
1908
            specified, the order of revision_ids will be preserved (by
 
1909
            buffering if necessary).
 
1910
        :return: An iterator of inventories.
 
1911
        """
 
1912
        if ((None in revision_ids)
 
1913
            or (_mod_revision.NULL_REVISION in revision_ids)):
 
1914
            raise ValueError('cannot get null revision inventory')
 
1915
        for inv, revid in self._iter_inventories(revision_ids, ordering):
 
1916
            if inv is None:
 
1917
                raise errors.NoSuchRevision(self, revid)
 
1918
            yield inv
 
1919
 
 
1920
    def _iter_inventories(self, revision_ids, ordering=None):
 
1921
        if len(revision_ids) == 0:
 
1922
            return
 
1923
        missing = set(revision_ids)
 
1924
        if ordering is None:
 
1925
            order_as_requested = True
 
1926
            invs = {}
 
1927
            order = list(revision_ids)
 
1928
            order.reverse()
 
1929
            next_revid = order.pop()
 
1930
        else:
 
1931
            order_as_requested = False
 
1932
            if ordering != 'unordered' and self._fallback_repositories:
 
1933
                raise ValueError('unsupported ordering %r' % ordering)
 
1934
        iter_inv_fns = [self._iter_inventories_rpc] + [
 
1935
            fallback._iter_inventories for fallback in
 
1936
            self._fallback_repositories]
 
1937
        try:
 
1938
            for iter_inv in iter_inv_fns:
 
1939
                request = [revid for revid in revision_ids if revid in missing]
 
1940
                for inv, revid in iter_inv(request, ordering):
 
1941
                    if inv is None:
 
1942
                        continue
 
1943
                    missing.remove(inv.revision_id)
 
1944
                    if ordering != 'unordered':
 
1945
                        invs[revid] = inv
 
1946
                    else:
 
1947
                        yield inv, revid
 
1948
                if order_as_requested:
 
1949
                    # Yield as many results as we can while preserving order.
 
1950
                    while next_revid in invs:
 
1951
                        inv = invs.pop(next_revid)
 
1952
                        yield inv, inv.revision_id
 
1953
                        try:
 
1954
                            next_revid = order.pop()
 
1955
                        except IndexError:
 
1956
                            # We still want to fully consume the stream, just
 
1957
                            # in case it is not actually finished at this point
 
1958
                            next_revid = None
 
1959
                            break
 
1960
        except errors.UnknownSmartMethod:
 
1961
            for inv, revid in self._iter_inventories_vfs(revision_ids, ordering):
 
1962
                yield inv, revid
 
1963
            return
 
1964
        # Report missing
 
1965
        if order_as_requested:
 
1966
            if next_revid is not None:
 
1967
                yield None, next_revid
 
1968
            while order:
 
1969
                revid = order.pop()
 
1970
                yield invs.get(revid), revid
 
1971
        else:
 
1972
            while missing:
 
1973
                yield None, missing.pop()
1288
1974
 
1289
1975
    @needs_read_lock
1290
1976
    def get_revision(self, revision_id):
1291
 
        self._ensure_real()
1292
 
        return self._real_repository.get_revision(revision_id)
 
1977
        return self.get_revisions([revision_id])[0]
1293
1978
 
1294
1979
    def get_transaction(self):
1295
1980
        self._ensure_real()
1297
1982
 
1298
1983
    @needs_read_lock
1299
1984
    def clone(self, a_bzrdir, revision_id=None):
1300
 
        self._ensure_real()
1301
 
        return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
 
1985
        dest_repo = self._create_sprouting_repo(
 
1986
            a_bzrdir, shared=self.is_shared())
 
1987
        self.copy_content_into(dest_repo, revision_id)
 
1988
        return dest_repo
1302
1989
 
1303
1990
    def make_working_trees(self):
1304
1991
        """See Repository.make_working_trees"""
1305
 
        self._ensure_real()
1306
 
        return self._real_repository.make_working_trees()
 
1992
        path = self.bzrdir._path_for_remote_call(self._client)
 
1993
        try:
 
1994
            response = self._call('Repository.make_working_trees', path)
 
1995
        except errors.UnknownSmartMethod:
 
1996
            self._ensure_real()
 
1997
            return self._real_repository.make_working_trees()
 
1998
        if response[0] not in ('yes', 'no'):
 
1999
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2000
        return response[0] == 'yes'
1307
2001
 
1308
2002
    def refresh_data(self):
1309
 
        """Re-read any data needed to to synchronise with disk.
 
2003
        """Re-read any data needed to synchronise with disk.
1310
2004
 
1311
2005
        This method is intended to be called after another repository instance
1312
2006
        (such as one used by a smart server) has inserted data into the
1313
 
        repository. It may not be called during a write group, but may be
1314
 
        called at any other time.
 
2007
        repository. On all repositories this will work outside of write groups.
 
2008
        Some repository formats (pack and newer for bzrlib native formats)
 
2009
        support refresh_data inside write groups. If called inside a write
 
2010
        group on a repository that does not support refreshing in a write group
 
2011
        IsInWriteGroupError will be raised.
1315
2012
        """
1316
 
        if self.is_in_write_group():
1317
 
            raise errors.InternalBzrError(
1318
 
                "May not refresh_data while in a write group.")
1319
2013
        if self._real_repository is not None:
1320
2014
            self._real_repository.refresh_data()
 
2015
        # Refresh the parents cache for this object
 
2016
        self._unstacked_provider.disable_cache()
 
2017
        self._unstacked_provider.enable_cache()
1321
2018
 
1322
2019
    def revision_ids_to_search_result(self, result_set):
1323
2020
        """Convert a set of revision ids to a graph SearchResult."""
1328
2025
        included_keys = result_set.intersection(result_parents)
1329
2026
        start_keys = result_set.difference(included_keys)
1330
2027
        exclude_keys = result_parents.difference(result_set)
1331
 
        result = graph.SearchResult(start_keys, exclude_keys,
 
2028
        result = vf_search.SearchResult(start_keys, exclude_keys,
1332
2029
            len(result_set), result_set)
1333
2030
        return result
1334
2031
 
1335
2032
    @needs_read_lock
1336
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
2033
    def search_missing_revision_ids(self, other,
 
2034
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
2035
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
2036
            limit=None):
1337
2037
        """Return the revision ids that other has that this does not.
1338
2038
 
1339
2039
        These are returned in topological order.
1340
2040
 
1341
2041
        revision_id: only return revision ids included by revision_id.
1342
2042
        """
1343
 
        return repository.InterRepository.get(
1344
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
2043
        if symbol_versioning.deprecated_passed(revision_id):
 
2044
            symbol_versioning.warn(
 
2045
                'search_missing_revision_ids(revision_id=...) was '
 
2046
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
2047
                DeprecationWarning, stacklevel=2)
 
2048
            if revision_ids is not None:
 
2049
                raise AssertionError(
 
2050
                    'revision_ids is mutually exclusive with revision_id')
 
2051
            if revision_id is not None:
 
2052
                revision_ids = [revision_id]
 
2053
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
2054
        return inter_repo.search_missing_revision_ids(
 
2055
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
2056
            if_present_ids=if_present_ids, limit=limit)
1345
2057
 
1346
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
2058
    def fetch(self, source, revision_id=None, find_ghosts=False,
1347
2059
            fetch_spec=None):
1348
2060
        # No base implementation to use as RemoteRepository is not a subclass
1349
2061
        # of Repository; so this is a copy of Repository.fetch().
1360
2072
            # check that last_revision is in 'from' and then return a
1361
2073
            # no-operation.
1362
2074
            if (revision_id is not None and
1363
 
                not revision.is_null(revision_id)):
 
2075
                not _mod_revision.is_null(revision_id)):
1364
2076
                self.get_revision(revision_id)
1365
2077
            return 0, []
1366
2078
        # if there is no specific appropriate InterRepository, this will get
1367
2079
        # the InterRepository base class, which raises an
1368
2080
        # IncompatibleRepositories when asked to fetch.
1369
 
        inter = repository.InterRepository.get(source, self)
1370
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
2081
        inter = _mod_repository.InterRepository.get(source, self)
 
2082
        if (fetch_spec is not None and
 
2083
            not getattr(inter, "supports_fetch_spec", False)):
 
2084
            raise errors.UnsupportedOperation(
 
2085
                "fetch_spec not supported for %r" % inter)
 
2086
        return inter.fetch(revision_id=revision_id,
1371
2087
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1372
2088
 
1373
2089
    def create_bundle(self, target, base, fileobj, format=None):
1375
2091
        self._real_repository.create_bundle(target, base, fileobj, format)
1376
2092
 
1377
2093
    @needs_read_lock
 
2094
    @symbol_versioning.deprecated_method(
 
2095
        symbol_versioning.deprecated_in((2, 4, 0)))
1378
2096
    def get_ancestry(self, revision_id, topo_sorted=True):
1379
2097
        self._ensure_real()
1380
2098
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1388
2106
        return self._real_repository._get_versioned_file_checker(
1389
2107
            revisions, revision_versions_cache)
1390
2108
 
 
2109
    def _iter_files_bytes_rpc(self, desired_files, absent):
 
2110
        path = self.bzrdir._path_for_remote_call(self._client)
 
2111
        lines = []
 
2112
        identifiers = []
 
2113
        for (file_id, revid, identifier) in desired_files:
 
2114
            lines.append("%s\0%s" % (
 
2115
                osutils.safe_file_id(file_id),
 
2116
                osutils.safe_revision_id(revid)))
 
2117
            identifiers.append(identifier)
 
2118
        (response_tuple, response_handler) = (
 
2119
            self._call_with_body_bytes_expecting_body(
 
2120
            "Repository.iter_files_bytes", (path, ), "\n".join(lines)))
 
2121
        if response_tuple != ('ok', ):
 
2122
            response_handler.cancel_read_body()
 
2123
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2124
        byte_stream = response_handler.read_streamed_body()
 
2125
        def decompress_stream(start, byte_stream, unused):
 
2126
            decompressor = zlib.decompressobj()
 
2127
            yield decompressor.decompress(start)
 
2128
            while decompressor.unused_data == "":
 
2129
                try:
 
2130
                    data = byte_stream.next()
 
2131
                except StopIteration:
 
2132
                    break
 
2133
                yield decompressor.decompress(data)
 
2134
            yield decompressor.flush()
 
2135
            unused.append(decompressor.unused_data)
 
2136
        unused = ""
 
2137
        while True:
 
2138
            while not "\n" in unused:
 
2139
                unused += byte_stream.next()
 
2140
            header, rest = unused.split("\n", 1)
 
2141
            args = header.split("\0")
 
2142
            if args[0] == "absent":
 
2143
                absent[identifiers[int(args[3])]] = (args[1], args[2])
 
2144
                unused = rest
 
2145
                continue
 
2146
            elif args[0] == "ok":
 
2147
                idx = int(args[1])
 
2148
            else:
 
2149
                raise errors.UnexpectedSmartServerResponse(args)
 
2150
            unused_chunks = []
 
2151
            yield (identifiers[idx],
 
2152
                decompress_stream(rest, byte_stream, unused_chunks))
 
2153
            unused = "".join(unused_chunks)
 
2154
 
1391
2155
    def iter_files_bytes(self, desired_files):
1392
2156
        """See Repository.iter_file_bytes.
1393
2157
        """
1394
 
        self._ensure_real()
1395
 
        return self._real_repository.iter_files_bytes(desired_files)
 
2158
        try:
 
2159
            absent = {}
 
2160
            for (identifier, bytes_iterator) in self._iter_files_bytes_rpc(
 
2161
                    desired_files, absent):
 
2162
                yield identifier, bytes_iterator
 
2163
            for fallback in self._fallback_repositories:
 
2164
                if not absent:
 
2165
                    break
 
2166
                desired_files = [(key[0], key[1], identifier) for
 
2167
                    (identifier, key) in absent.iteritems()]
 
2168
                for (identifier, bytes_iterator) in fallback.iter_files_bytes(desired_files):
 
2169
                    del absent[identifier]
 
2170
                    yield identifier, bytes_iterator
 
2171
            if absent:
 
2172
                # There may be more missing items, but raise an exception
 
2173
                # for just one.
 
2174
                missing_identifier = absent.keys()[0]
 
2175
                missing_key = absent[missing_identifier]
 
2176
                raise errors.RevisionNotPresent(revision_id=missing_key[1],
 
2177
                    file_id=missing_key[0])
 
2178
        except errors.UnknownSmartMethod:
 
2179
            self._ensure_real()
 
2180
            for (identifier, bytes_iterator) in (
 
2181
                self._real_repository.iter_files_bytes(desired_files)):
 
2182
                yield identifier, bytes_iterator
 
2183
 
 
2184
    def get_cached_parent_map(self, revision_ids):
 
2185
        """See bzrlib.CachingParentsProvider.get_cached_parent_map"""
 
2186
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
1396
2187
 
1397
2188
    def get_parent_map(self, revision_ids):
1398
2189
        """See bzrlib.Graph.get_parent_map()."""
1457
2248
        if parents_map is None:
1458
2249
            # Repository is not locked, so there's no cache.
1459
2250
            parents_map = {}
1460
 
        # start_set is all the keys in the cache
1461
 
        start_set = set(parents_map)
1462
 
        # result set is all the references to keys in the cache
1463
 
        result_parents = set()
1464
 
        for parents in parents_map.itervalues():
1465
 
            result_parents.update(parents)
1466
 
        stop_keys = result_parents.difference(start_set)
1467
 
        # We don't need to send ghosts back to the server as a position to
1468
 
        # stop either.
1469
 
        stop_keys.difference_update(self._unstacked_provider.missing_keys)
1470
 
        key_count = len(parents_map)
1471
 
        if (NULL_REVISION in result_parents
1472
 
            and NULL_REVISION in self._unstacked_provider.missing_keys):
1473
 
            # If we pruned NULL_REVISION from the stop_keys because it's also
1474
 
            # in our cache of "missing" keys we need to increment our key count
1475
 
            # by 1, because the reconsitituted SearchResult on the server will
1476
 
            # still consider NULL_REVISION to be an included key.
1477
 
            key_count += 1
1478
 
        included_keys = start_set.intersection(result_parents)
1479
 
        start_set.difference_update(included_keys)
 
2251
        if _DEFAULT_SEARCH_DEPTH <= 0:
 
2252
            (start_set, stop_keys,
 
2253
             key_count) = vf_search.search_result_from_parent_map(
 
2254
                parents_map, self._unstacked_provider.missing_keys)
 
2255
        else:
 
2256
            (start_set, stop_keys,
 
2257
             key_count) = vf_search.limited_search_result_from_parent_map(
 
2258
                parents_map, self._unstacked_provider.missing_keys,
 
2259
                keys, depth=_DEFAULT_SEARCH_DEPTH)
1480
2260
        recipe = ('manual', start_set, stop_keys, key_count)
1481
2261
        body = self._serialise_search_recipe(recipe)
1482
2262
        path = self.bzrdir._path_for_remote_call(self._client)
1531
2311
 
1532
2312
    @needs_read_lock
1533
2313
    def get_signature_text(self, revision_id):
1534
 
        self._ensure_real()
1535
 
        return self._real_repository.get_signature_text(revision_id)
 
2314
        path = self.bzrdir._path_for_remote_call(self._client)
 
2315
        try:
 
2316
            response_tuple, response_handler = self._call_expecting_body(
 
2317
                'Repository.get_revision_signature_text', path, revision_id)
 
2318
        except errors.UnknownSmartMethod:
 
2319
            self._ensure_real()
 
2320
            return self._real_repository.get_signature_text(revision_id)
 
2321
        except errors.NoSuchRevision, err:
 
2322
            for fallback in self._fallback_repositories:
 
2323
                try:
 
2324
                    return fallback.get_signature_text(revision_id)
 
2325
                except errors.NoSuchRevision:
 
2326
                    pass
 
2327
            raise err
 
2328
        else:
 
2329
            if response_tuple[0] != 'ok':
 
2330
                raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2331
            return response_handler.read_body_bytes()
1536
2332
 
1537
2333
    @needs_read_lock
1538
2334
    def _get_inventory_xml(self, revision_id):
 
2335
        # This call is used by older working tree formats,
 
2336
        # which stored a serialized basis inventory.
1539
2337
        self._ensure_real()
1540
2338
        return self._real_repository._get_inventory_xml(revision_id)
1541
2339
 
 
2340
    @needs_write_lock
1542
2341
    def reconcile(self, other=None, thorough=False):
1543
 
        self._ensure_real()
1544
 
        return self._real_repository.reconcile(other=other, thorough=thorough)
 
2342
        from bzrlib.reconcile import RepoReconciler
 
2343
        path = self.bzrdir._path_for_remote_call(self._client)
 
2344
        try:
 
2345
            response, handler = self._call_expecting_body(
 
2346
                'Repository.reconcile', path, self._lock_token)
 
2347
        except (errors.UnknownSmartMethod, errors.TokenLockingNotSupported):
 
2348
            self._ensure_real()
 
2349
            return self._real_repository.reconcile(other=other, thorough=thorough)
 
2350
        if response != ('ok', ):
 
2351
            raise errors.UnexpectedSmartServerResponse(response)
 
2352
        body = handler.read_body_bytes()
 
2353
        result = RepoReconciler(self)
 
2354
        for line in body.split('\n'):
 
2355
            if not line:
 
2356
                continue
 
2357
            key, val_text = line.split(':')
 
2358
            if key == "garbage_inventories":
 
2359
                result.garbage_inventories = int(val_text)
 
2360
            elif key == "inconsistent_parents":
 
2361
                result.inconsistent_parents = int(val_text)
 
2362
            else:
 
2363
                mutter("unknown reconcile key %r" % key)
 
2364
        return result
1545
2365
 
1546
2366
    def all_revision_ids(self):
1547
 
        self._ensure_real()
1548
 
        return self._real_repository.all_revision_ids()
 
2367
        path = self.bzrdir._path_for_remote_call(self._client)
 
2368
        try:
 
2369
            response_tuple, response_handler = self._call_expecting_body(
 
2370
                "Repository.all_revision_ids", path)
 
2371
        except errors.UnknownSmartMethod:
 
2372
            self._ensure_real()
 
2373
            return self._real_repository.all_revision_ids()
 
2374
        if response_tuple != ("ok", ):
 
2375
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2376
        revids = set(response_handler.read_body_bytes().splitlines())
 
2377
        for fallback in self._fallback_repositories:
 
2378
            revids.update(set(fallback.all_revision_ids()))
 
2379
        return list(revids)
 
2380
 
 
2381
    def _filtered_revision_trees(self, revision_ids, file_ids):
 
2382
        """Return Tree for a revision on this branch with only some files.
 
2383
 
 
2384
        :param revision_ids: a sequence of revision-ids;
 
2385
          a revision-id may not be None or 'null:'
 
2386
        :param file_ids: if not None, the result is filtered
 
2387
          so that only those file-ids, their parents and their
 
2388
          children are included.
 
2389
        """
 
2390
        inventories = self.iter_inventories(revision_ids)
 
2391
        for inv in inventories:
 
2392
            # Should we introduce a FilteredRevisionTree class rather
 
2393
            # than pre-filter the inventory here?
 
2394
            filtered_inv = inv.filter(file_ids)
 
2395
            yield InventoryRevisionTree(self, filtered_inv, filtered_inv.revision_id)
1549
2396
 
1550
2397
    @needs_read_lock
1551
2398
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1552
 
        self._ensure_real()
1553
 
        return self._real_repository.get_deltas_for_revisions(revisions,
1554
 
            specific_fileids=specific_fileids)
 
2399
        medium = self._client._medium
 
2400
        if medium._is_remote_before((1, 2)):
 
2401
            self._ensure_real()
 
2402
            for delta in self._real_repository.get_deltas_for_revisions(
 
2403
                    revisions, specific_fileids):
 
2404
                yield delta
 
2405
            return
 
2406
        # Get the revision-ids of interest
 
2407
        required_trees = set()
 
2408
        for revision in revisions:
 
2409
            required_trees.add(revision.revision_id)
 
2410
            required_trees.update(revision.parent_ids[:1])
 
2411
 
 
2412
        # Get the matching filtered trees. Note that it's more
 
2413
        # efficient to pass filtered trees to changes_from() rather
 
2414
        # than doing the filtering afterwards. changes_from() could
 
2415
        # arguably do the filtering itself but it's path-based, not
 
2416
        # file-id based, so filtering before or afterwards is
 
2417
        # currently easier.
 
2418
        if specific_fileids is None:
 
2419
            trees = dict((t.get_revision_id(), t) for
 
2420
                t in self.revision_trees(required_trees))
 
2421
        else:
 
2422
            trees = dict((t.get_revision_id(), t) for
 
2423
                t in self._filtered_revision_trees(required_trees,
 
2424
                specific_fileids))
 
2425
 
 
2426
        # Calculate the deltas
 
2427
        for revision in revisions:
 
2428
            if not revision.parent_ids:
 
2429
                old_tree = self.revision_tree(_mod_revision.NULL_REVISION)
 
2430
            else:
 
2431
                old_tree = trees[revision.parent_ids[0]]
 
2432
            yield trees[revision.revision_id].changes_from(old_tree)
1555
2433
 
1556
2434
    @needs_read_lock
1557
2435
    def get_revision_delta(self, revision_id, specific_fileids=None):
1558
 
        self._ensure_real()
1559
 
        return self._real_repository.get_revision_delta(revision_id,
1560
 
            specific_fileids=specific_fileids)
 
2436
        r = self.get_revision(revision_id)
 
2437
        return list(self.get_deltas_for_revisions([r],
 
2438
            specific_fileids=specific_fileids))[0]
1561
2439
 
1562
2440
    @needs_read_lock
1563
2441
    def revision_trees(self, revision_ids):
1564
 
        self._ensure_real()
1565
 
        return self._real_repository.revision_trees(revision_ids)
 
2442
        inventories = self.iter_inventories(revision_ids)
 
2443
        for inv in inventories:
 
2444
            yield InventoryRevisionTree(self, inv, inv.revision_id)
1566
2445
 
1567
2446
    @needs_read_lock
1568
2447
    def get_revision_reconcile(self, revision_id):
1576
2455
            callback_refs=callback_refs, check_repo=check_repo)
1577
2456
 
1578
2457
    def copy_content_into(self, destination, revision_id=None):
1579
 
        self._ensure_real()
1580
 
        return self._real_repository.copy_content_into(
1581
 
            destination, revision_id=revision_id)
 
2458
        """Make a complete copy of the content in self into destination.
 
2459
 
 
2460
        This is a destructive operation! Do not use it on existing
 
2461
        repositories.
 
2462
        """
 
2463
        interrepo = _mod_repository.InterRepository.get(self, destination)
 
2464
        return interrepo.copy_content(revision_id)
1582
2465
 
1583
2466
    def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1584
2467
        # get a tarball of the remote repository, and copy from that into the
1585
2468
        # destination
1586
 
        from bzrlib import osutils
1587
2469
        import tarfile
1588
2470
        # TODO: Maybe a progress bar while streaming the tarball?
1589
 
        note("Copying repository content as tarball...")
 
2471
        note(gettext("Copying repository content as tarball..."))
1590
2472
        tar_file = self._get_tarball('bz2')
1591
2473
        if tar_file is None:
1592
2474
            return None
1597
2479
            tmpdir = osutils.mkdtemp()
1598
2480
            try:
1599
2481
                _extract_tar(tar, tmpdir)
1600
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
2482
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1601
2483
                tmp_repo = tmp_bzrdir.open_repository()
1602
2484
                tmp_repo.copy_content_into(destination, revision_id)
1603
2485
            finally:
1621
2503
    @needs_write_lock
1622
2504
    def pack(self, hint=None, clean_obsolete_packs=False):
1623
2505
        """Compress the data within the repository.
1624
 
 
1625
 
        This is not currently implemented within the smart server.
1626
2506
        """
1627
 
        self._ensure_real()
1628
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
2507
        if hint is None:
 
2508
            body = ""
 
2509
        else:
 
2510
            body = "".join([l+"\n" for l in hint])
 
2511
        path = self.bzrdir._path_for_remote_call(self._client)
 
2512
        try:
 
2513
            response, handler = self._call_with_body_bytes_expecting_body(
 
2514
                'Repository.pack', (path, self._lock_token,
 
2515
                    str(clean_obsolete_packs)), body)
 
2516
        except errors.UnknownSmartMethod:
 
2517
            self._ensure_real()
 
2518
            return self._real_repository.pack(hint=hint,
 
2519
                clean_obsolete_packs=clean_obsolete_packs)
 
2520
        handler.cancel_read_body()
 
2521
        if response != ('ok', ):
 
2522
            raise errors.UnexpectedSmartServerResponse(response)
1629
2523
 
1630
2524
    @property
1631
2525
    def revisions(self):
1632
2526
        """Decorate the real repository for now.
1633
2527
 
1634
 
        In the short term this should become a real object to intercept graph
1635
 
        lookups.
1636
 
 
1637
2528
        In the long term a full blown network facility is needed.
1638
2529
        """
1639
2530
        self._ensure_real()
1667
2558
 
1668
2559
    @needs_write_lock
1669
2560
    def sign_revision(self, revision_id, gpg_strategy):
1670
 
        self._ensure_real()
1671
 
        return self._real_repository.sign_revision(revision_id, gpg_strategy)
 
2561
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2562
        plaintext = testament.as_short_text()
 
2563
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1672
2564
 
1673
2565
    @property
1674
2566
    def texts(self):
1680
2572
        self._ensure_real()
1681
2573
        return self._real_repository.texts
1682
2574
 
 
2575
    def _iter_revisions_rpc(self, revision_ids):
 
2576
        body = "\n".join(revision_ids)
 
2577
        path = self.bzrdir._path_for_remote_call(self._client)
 
2578
        response_tuple, response_handler = (
 
2579
            self._call_with_body_bytes_expecting_body(
 
2580
            "Repository.iter_revisions", (path, ), body))
 
2581
        if response_tuple[0] != "ok":
 
2582
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2583
        serializer_format = response_tuple[1]
 
2584
        serializer = serializer_format_registry.get(serializer_format)
 
2585
        byte_stream = response_handler.read_streamed_body()
 
2586
        decompressor = zlib.decompressobj()
 
2587
        chunks = []
 
2588
        for bytes in byte_stream:
 
2589
            chunks.append(decompressor.decompress(bytes))
 
2590
            if decompressor.unused_data != "":
 
2591
                chunks.append(decompressor.flush())
 
2592
                yield serializer.read_revision_from_string("".join(chunks))
 
2593
                unused = decompressor.unused_data
 
2594
                decompressor = zlib.decompressobj()
 
2595
                chunks = [decompressor.decompress(unused)]
 
2596
        chunks.append(decompressor.flush())
 
2597
        text = "".join(chunks)
 
2598
        if text != "":
 
2599
            yield serializer.read_revision_from_string("".join(chunks))
 
2600
 
1683
2601
    @needs_read_lock
1684
2602
    def get_revisions(self, revision_ids):
1685
 
        self._ensure_real()
1686
 
        return self._real_repository.get_revisions(revision_ids)
 
2603
        if revision_ids is None:
 
2604
            revision_ids = self.all_revision_ids()
 
2605
        else:
 
2606
            for rev_id in revision_ids:
 
2607
                if not rev_id or not isinstance(rev_id, basestring):
 
2608
                    raise errors.InvalidRevisionId(
 
2609
                        revision_id=rev_id, branch=self)
 
2610
        try:
 
2611
            missing = set(revision_ids)
 
2612
            revs = {}
 
2613
            for rev in self._iter_revisions_rpc(revision_ids):
 
2614
                missing.remove(rev.revision_id)
 
2615
                revs[rev.revision_id] = rev
 
2616
        except errors.UnknownSmartMethod:
 
2617
            self._ensure_real()
 
2618
            return self._real_repository.get_revisions(revision_ids)
 
2619
        for fallback in self._fallback_repositories:
 
2620
            if not missing:
 
2621
                break
 
2622
            for revid in list(missing):
 
2623
                # XXX JRV 2011-11-20: It would be nice if there was a
 
2624
                # public method on Repository that could be used to query
 
2625
                # for revision objects *without* failing completely if one
 
2626
                # was missing. There is VersionedFileRepository._iter_revisions,
 
2627
                # but unfortunately that's private and not provided by
 
2628
                # all repository implementations.
 
2629
                try:
 
2630
                    revs[revid] = fallback.get_revision(revid)
 
2631
                except errors.NoSuchRevision:
 
2632
                    pass
 
2633
                else:
 
2634
                    missing.remove(revid)
 
2635
        if missing:
 
2636
            raise errors.NoSuchRevision(self, list(missing)[0])
 
2637
        return [revs[revid] for revid in revision_ids]
1687
2638
 
1688
2639
    def supports_rich_root(self):
1689
2640
        return self._format.rich_root_data
1690
2641
 
 
2642
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1691
2643
    def iter_reverse_revision_history(self, revision_id):
1692
2644
        self._ensure_real()
1693
2645
        return self._real_repository.iter_reverse_revision_history(revision_id)
1696
2648
    def _serializer(self):
1697
2649
        return self._format._serializer
1698
2650
 
 
2651
    @needs_write_lock
1699
2652
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1700
 
        self._ensure_real()
1701
 
        return self._real_repository.store_revision_signature(
1702
 
            gpg_strategy, plaintext, revision_id)
 
2653
        signature = gpg_strategy.sign(plaintext)
 
2654
        self.add_signature_text(revision_id, signature)
1703
2655
 
1704
2656
    def add_signature_text(self, revision_id, signature):
1705
 
        self._ensure_real()
1706
 
        return self._real_repository.add_signature_text(revision_id, signature)
 
2657
        if self._real_repository:
 
2658
            # If there is a real repository the write group will
 
2659
            # be in the real repository as well, so use that:
 
2660
            self._ensure_real()
 
2661
            return self._real_repository.add_signature_text(
 
2662
                revision_id, signature)
 
2663
        path = self.bzrdir._path_for_remote_call(self._client)
 
2664
        response, handler = self._call_with_body_bytes_expecting_body(
 
2665
            'Repository.add_signature_text', (path, self._lock_token,
 
2666
                revision_id) + tuple(self._write_group_tokens), signature)
 
2667
        handler.cancel_read_body()
 
2668
        self.refresh_data()
 
2669
        if response[0] != 'ok':
 
2670
            raise errors.UnexpectedSmartServerResponse(response)
 
2671
        self._write_group_tokens = response[1:]
1707
2672
 
1708
2673
    def has_signature_for_revision_id(self, revision_id):
1709
 
        self._ensure_real()
1710
 
        return self._real_repository.has_signature_for_revision_id(revision_id)
 
2674
        path = self.bzrdir._path_for_remote_call(self._client)
 
2675
        try:
 
2676
            response = self._call('Repository.has_signature_for_revision_id',
 
2677
                path, revision_id)
 
2678
        except errors.UnknownSmartMethod:
 
2679
            self._ensure_real()
 
2680
            return self._real_repository.has_signature_for_revision_id(
 
2681
                revision_id)
 
2682
        if response[0] not in ('yes', 'no'):
 
2683
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2684
        if response[0] == 'yes':
 
2685
            return True
 
2686
        for fallback in self._fallback_repositories:
 
2687
            if fallback.has_signature_for_revision_id(revision_id):
 
2688
                return True
 
2689
        return False
 
2690
 
 
2691
    @needs_read_lock
 
2692
    def verify_revision_signature(self, revision_id, gpg_strategy):
 
2693
        if not self.has_signature_for_revision_id(revision_id):
 
2694
            return gpg.SIGNATURE_NOT_SIGNED, None
 
2695
        signature = self.get_signature_text(revision_id)
 
2696
 
 
2697
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2698
        plaintext = testament.as_short_text()
 
2699
 
 
2700
        return gpg_strategy.verify(signature, plaintext)
1711
2701
 
1712
2702
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1713
2703
        self._ensure_real()
1714
2704
        return self._real_repository.item_keys_introduced_by(revision_ids,
1715
2705
            _files_pb=_files_pb)
1716
2706
 
1717
 
    def revision_graph_can_have_wrong_parents(self):
1718
 
        # The answer depends on the remote repo format.
1719
 
        self._ensure_real()
1720
 
        return self._real_repository.revision_graph_can_have_wrong_parents()
1721
 
 
1722
2707
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1723
2708
        self._ensure_real()
1724
2709
        return self._real_repository._find_inconsistent_revision_parents(
1732
2717
        providers = [self._unstacked_provider]
1733
2718
        if other is not None:
1734
2719
            providers.insert(0, other)
1735
 
        providers.extend(r._make_parents_provider() for r in
1736
 
                         self._fallback_repositories)
1737
 
        return graph.StackedParentsProvider(providers)
 
2720
        return graph.StackedParentsProvider(_LazyListJoin(
 
2721
            providers, self._fallback_repositories))
1738
2722
 
1739
2723
    def _serialise_search_recipe(self, recipe):
1740
2724
        """Serialise a graph search recipe.
1748
2732
        return '\n'.join((start_keys, stop_keys, count))
1749
2733
 
1750
2734
    def _serialise_search_result(self, search_result):
1751
 
        if isinstance(search_result, graph.PendingAncestryResult):
1752
 
            parts = ['ancestry-of']
1753
 
            parts.extend(search_result.heads)
1754
 
        else:
1755
 
            recipe = search_result.get_recipe()
1756
 
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
 
2735
        parts = search_result.get_network_struct()
1757
2736
        return '\n'.join(parts)
1758
2737
 
1759
2738
    def autopack(self):
1769
2748
            raise errors.UnexpectedSmartServerResponse(response)
1770
2749
 
1771
2750
 
1772
 
class RemoteStreamSink(repository.StreamSink):
 
2751
class RemoteStreamSink(vf_repository.StreamSink):
1773
2752
 
1774
2753
    def _insert_real(self, stream, src_format, resume_tokens):
1775
2754
        self.target_repo._ensure_real()
1876
2855
        self._last_substream and self._last_stream so that the stream can be
1877
2856
        resumed by _resume_stream_with_vfs.
1878
2857
        """
1879
 
                    
 
2858
 
1880
2859
        stream_iter = iter(stream)
1881
2860
        for substream_kind, substream in stream_iter:
1882
2861
            if substream_kind == 'inventory-deltas':
1885
2864
                return
1886
2865
            else:
1887
2866
                yield substream_kind, substream
1888
 
            
1889
 
 
1890
 
class RemoteStreamSource(repository.StreamSource):
 
2867
 
 
2868
 
 
2869
class RemoteStreamSource(vf_repository.StreamSource):
1891
2870
    """Stream data from a remote server."""
1892
2871
 
1893
2872
    def get_stream(self, search):
1914
2893
 
1915
2894
    def _real_stream(self, repo, search):
1916
2895
        """Get a stream for search from repo.
1917
 
        
1918
 
        This never called RemoteStreamSource.get_stream, and is a heler
1919
 
        for RemoteStreamSource._get_stream to allow getting a stream 
 
2896
 
 
2897
        This never called RemoteStreamSource.get_stream, and is a helper
 
2898
        for RemoteStreamSource._get_stream to allow getting a stream
1920
2899
        reliably whether fallback back because of old servers or trying
1921
2900
        to stream from a non-RemoteRepository (which the stacked support
1922
2901
        code will do).
1953
2932
        candidate_verbs = [
1954
2933
            ('Repository.get_stream_1.19', (1, 19)),
1955
2934
            ('Repository.get_stream', (1, 13))]
 
2935
 
1956
2936
        found_verb = False
1957
2937
        for verb, version in candidate_verbs:
1958
2938
            if medium._is_remote_before(version):
1962
2942
                    verb, args, search_bytes)
1963
2943
            except errors.UnknownSmartMethod:
1964
2944
                medium._remember_remote_is_before(version)
 
2945
            except errors.UnknownErrorFromSmartServer, e:
 
2946
                if isinstance(search, vf_search.EverythingResult):
 
2947
                    error_verb = e.error_from_smart_server.error_verb
 
2948
                    if error_verb == 'BadSearch':
 
2949
                        # Pre-2.4 servers don't support this sort of search.
 
2950
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
2951
                        # good idea in general?  It might provide a little bit
 
2952
                        # of protection against client-side bugs.
 
2953
                        medium._remember_remote_is_before((2, 4))
 
2954
                        break
 
2955
                raise
1965
2956
            else:
1966
2957
                response_tuple, response_handler = response
1967
2958
                found_verb = True
1971
2962
        if response_tuple[0] != 'ok':
1972
2963
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1973
2964
        byte_stream = response_handler.read_streamed_body()
1974
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
2965
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
2966
            self._record_counter)
1975
2967
        if src_format.network_name() != repo._format.network_name():
1976
2968
            raise AssertionError(
1977
2969
                "Mismatched RemoteRepository and stream src %r, %r" % (
2049
3041
 
2050
3042
    def _ensure_real(self):
2051
3043
        if self._custom_format is None:
2052
 
            self._custom_format = branch.network_format_registry.get(
2053
 
                self._network_name)
 
3044
            try:
 
3045
                self._custom_format = branch.network_format_registry.get(
 
3046
                    self._network_name)
 
3047
            except KeyError:
 
3048
                raise errors.UnknownFormatError(kind='branch',
 
3049
                    format=self._network_name)
2054
3050
 
2055
3051
    def get_format_description(self):
2056
3052
        self._ensure_real()
2063
3059
        return a_bzrdir.open_branch(name=name, 
2064
3060
            ignore_fallbacks=ignore_fallbacks)
2065
3061
 
2066
 
    def _vfs_initialize(self, a_bzrdir, name):
 
3062
    def _vfs_initialize(self, a_bzrdir, name, append_revisions_only):
2067
3063
        # Initialisation when using a local bzrdir object, or a non-vfs init
2068
3064
        # method is not available on the server.
2069
3065
        # self._custom_format is always set - the start of initialize ensures
2071
3067
        if isinstance(a_bzrdir, RemoteBzrDir):
2072
3068
            a_bzrdir._ensure_real()
2073
3069
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2074
 
                name)
 
3070
                name, append_revisions_only=append_revisions_only)
2075
3071
        else:
2076
3072
            # We assume the bzrdir is parameterised; it may not be.
2077
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
3073
            result = self._custom_format.initialize(a_bzrdir, name,
 
3074
                append_revisions_only=append_revisions_only)
2078
3075
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2079
3076
            not isinstance(result, RemoteBranch)):
2080
3077
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2081
3078
                                  name=name)
2082
3079
        return result
2083
3080
 
2084
 
    def initialize(self, a_bzrdir, name=None):
 
3081
    def initialize(self, a_bzrdir, name=None, repository=None,
 
3082
                   append_revisions_only=None):
2085
3083
        # 1) get the network name to use.
2086
3084
        if self._custom_format:
2087
3085
            network_name = self._custom_format.network_name()
2088
3086
        else:
2089
3087
            # Select the current bzrlib default and ask for that.
2090
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
3088
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
2091
3089
            reference_format = reference_bzrdir_format.get_branch_format()
2092
3090
            self._custom_format = reference_format
2093
3091
            network_name = reference_format.network_name()
2094
3092
        # Being asked to create on a non RemoteBzrDir:
2095
3093
        if not isinstance(a_bzrdir, RemoteBzrDir):
2096
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
3094
            return self._vfs_initialize(a_bzrdir, name=name,
 
3095
                append_revisions_only=append_revisions_only)
2097
3096
        medium = a_bzrdir._client._medium
2098
3097
        if medium._is_remote_before((1, 13)):
2099
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
3098
            return self._vfs_initialize(a_bzrdir, name=name,
 
3099
                append_revisions_only=append_revisions_only)
2100
3100
        # Creating on a remote bzr dir.
2101
3101
        # 2) try direct creation via RPC
2102
3102
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2109
3109
        except errors.UnknownSmartMethod:
2110
3110
            # Fallback - use vfs methods
2111
3111
            medium._remember_remote_is_before((1, 13))
2112
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
3112
            return self._vfs_initialize(a_bzrdir, name=name,
 
3113
                    append_revisions_only=append_revisions_only)
2113
3114
        if response[0] != 'ok':
2114
3115
            raise errors.UnexpectedSmartServerResponse(response)
2115
3116
        # Turn the response into a RemoteRepository object.
2116
3117
        format = RemoteBranchFormat(network_name=response[1])
2117
3118
        repo_format = response_tuple_to_repo_format(response[3:])
2118
 
        if response[2] == '':
2119
 
            repo_bzrdir = a_bzrdir
 
3119
        repo_path = response[2]
 
3120
        if repository is not None:
 
3121
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
 
3122
            url_diff = urlutils.relative_url(repository.user_url,
 
3123
                    remote_repo_url)
 
3124
            if url_diff != '.':
 
3125
                raise AssertionError(
 
3126
                    'repository.user_url %r does not match URL from server '
 
3127
                    'response (%r + %r)'
 
3128
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
 
3129
            remote_repo = repository
2120
3130
        else:
2121
 
            repo_bzrdir = RemoteBzrDir(
2122
 
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2123
 
                a_bzrdir._client)
2124
 
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
3131
            if repo_path == '':
 
3132
                repo_bzrdir = a_bzrdir
 
3133
            else:
 
3134
                repo_bzrdir = RemoteBzrDir(
 
3135
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
3136
                    a_bzrdir._client)
 
3137
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2125
3138
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2126
3139
            format=format, setup_stacking=False, name=name)
 
3140
        if append_revisions_only:
 
3141
            remote_branch.set_append_revisions_only(append_revisions_only)
2127
3142
        # XXX: We know this is a new branch, so it must have revno 0, revid
2128
3143
        # NULL_REVISION. Creating the branch locked would make this be unable
2129
3144
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2148
3163
        self._ensure_real()
2149
3164
        return self._custom_format.supports_set_append_revisions_only()
2150
3165
 
 
3166
    def _use_default_local_heads_to_fetch(self):
 
3167
        # If the branch format is a metadir format *and* its heads_to_fetch
 
3168
        # implementation is not overridden vs the base class, we can use the
 
3169
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
3170
        # usually cheaper in terms of net round trips, as the last-revision and
 
3171
        # tags info fetched is cached and would be fetched anyway.
 
3172
        self._ensure_real()
 
3173
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
3174
            branch_class = self._custom_format._branch_class()
 
3175
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
3176
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
3177
                return True
 
3178
        return False
 
3179
 
 
3180
 
 
3181
class RemoteBranchStore(config.IniFileStore):
 
3182
    """Branch store which attempts to use HPSS calls to retrieve branch store.
 
3183
 
 
3184
    Note that this is specific to bzr-based formats.
 
3185
    """
 
3186
 
 
3187
    def __init__(self, branch):
 
3188
        super(RemoteBranchStore, self).__init__()
 
3189
        self.branch = branch
 
3190
        self.id = "branch"
 
3191
        self._real_store = None
 
3192
 
 
3193
    def lock_write(self, token=None):
 
3194
        return self.branch.lock_write(token)
 
3195
 
 
3196
    def unlock(self):
 
3197
        return self.branch.unlock()
 
3198
 
 
3199
    @needs_write_lock
 
3200
    def save(self):
 
3201
        # We need to be able to override the undecorated implementation
 
3202
        self.save_without_locking()
 
3203
 
 
3204
    def save_without_locking(self):
 
3205
        super(RemoteBranchStore, self).save()
 
3206
 
 
3207
    def external_url(self):
 
3208
        return self.branch.user_url
 
3209
 
 
3210
    def _load_content(self):
 
3211
        path = self.branch._remote_path()
 
3212
        try:
 
3213
            response, handler = self.branch._call_expecting_body(
 
3214
                'Branch.get_config_file', path)
 
3215
        except errors.UnknownSmartMethod:
 
3216
            self._ensure_real()
 
3217
            return self._real_store._load_content()
 
3218
        if len(response) and response[0] != 'ok':
 
3219
            raise errors.UnexpectedSmartServerResponse(response)
 
3220
        return handler.read_body_bytes()
 
3221
 
 
3222
    def _save_content(self, content):
 
3223
        path = self.branch._remote_path()
 
3224
        try:
 
3225
            response, handler = self.branch._call_with_body_bytes_expecting_body(
 
3226
                'Branch.put_config_file', (path,
 
3227
                    self.branch._lock_token, self.branch._repo_lock_token),
 
3228
                content)
 
3229
        except errors.UnknownSmartMethod:
 
3230
            self._ensure_real()
 
3231
            return self._real_store._save_content(content)
 
3232
        handler.cancel_read_body()
 
3233
        if response != ('ok', ):
 
3234
            raise errors.UnexpectedSmartServerResponse(response)
 
3235
 
 
3236
    def _ensure_real(self):
 
3237
        self.branch._ensure_real()
 
3238
        if self._real_store is None:
 
3239
            self._real_store = config.BranchStore(self.branch)
 
3240
 
2151
3241
 
2152
3242
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2153
3243
    """Branch stored on a server accessed by HPSS RPC.
2156
3246
    """
2157
3247
 
2158
3248
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2159
 
        _client=None, format=None, setup_stacking=True, name=None):
 
3249
        _client=None, format=None, setup_stacking=True, name=None,
 
3250
        possible_transports=None):
2160
3251
        """Create a RemoteBranch instance.
2161
3252
 
2162
3253
        :param real_branch: An optional local implementation of the branch
2227
3318
            hook(self)
2228
3319
        self._is_stacked = False
2229
3320
        if setup_stacking:
2230
 
            self._setup_stacking()
 
3321
            self._setup_stacking(possible_transports)
2231
3322
 
2232
 
    def _setup_stacking(self):
 
3323
    def _setup_stacking(self, possible_transports):
2233
3324
        # configure stacking into the remote repository, by reading it from
2234
3325
        # the vfs branch.
2235
3326
        try:
2238
3329
            errors.UnstackableRepositoryFormat), e:
2239
3330
            return
2240
3331
        self._is_stacked = True
2241
 
        self._activate_fallback_location(fallback_url)
 
3332
        if possible_transports is None:
 
3333
            possible_transports = []
 
3334
        else:
 
3335
            possible_transports = list(possible_transports)
 
3336
        possible_transports.append(self.bzrdir.root_transport)
 
3337
        self._activate_fallback_location(fallback_url,
 
3338
            possible_transports=possible_transports)
2242
3339
 
2243
3340
    def _get_config(self):
2244
3341
        return RemoteBranchConfig(self)
2245
3342
 
 
3343
    def _get_config_store(self):
 
3344
        return RemoteBranchStore(self)
 
3345
 
2246
3346
    def _get_real_transport(self):
2247
3347
        # if we try vfs access, return the real branch's vfs transport
2248
3348
        self._ensure_real()
2311
3411
                self.bzrdir, self._client)
2312
3412
        return self._control_files
2313
3413
 
2314
 
    def _get_checkout_format(self):
2315
 
        self._ensure_real()
2316
 
        return self._real_branch._get_checkout_format()
2317
 
 
2318
3414
    def get_physical_lock_status(self):
2319
3415
        """See Branch.get_physical_lock_status()."""
2320
 
        # should be an API call to the server, as branches must be lockable.
2321
 
        self._ensure_real()
2322
 
        return self._real_branch.get_physical_lock_status()
 
3416
        try:
 
3417
            response = self._client.call('Branch.get_physical_lock_status',
 
3418
                self._remote_path())
 
3419
        except errors.UnknownSmartMethod:
 
3420
            self._ensure_real()
 
3421
            return self._real_branch.get_physical_lock_status()
 
3422
        if response[0] not in ('yes', 'no'):
 
3423
            raise errors.UnexpectedSmartServerResponse(response)
 
3424
        return (response[0] == 'yes')
2323
3425
 
2324
3426
    def get_stacked_on_url(self):
2325
3427
        """Get the URL this branch is stacked against.
2352
3454
            self._is_stacked = False
2353
3455
        else:
2354
3456
            self._is_stacked = True
2355
 
        
 
3457
 
2356
3458
    def _vfs_get_tags_bytes(self):
2357
3459
        self._ensure_real()
2358
3460
        return self._real_branch._get_tags_bytes()
2359
3461
 
 
3462
    @needs_read_lock
2360
3463
    def _get_tags_bytes(self):
 
3464
        if self._tags_bytes is None:
 
3465
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
3466
        return self._tags_bytes
 
3467
 
 
3468
    def _get_tags_bytes_via_hpss(self):
2361
3469
        medium = self._client._medium
2362
3470
        if medium._is_remote_before((1, 13)):
2363
3471
            return self._vfs_get_tags_bytes()
2373
3481
        return self._real_branch._set_tags_bytes(bytes)
2374
3482
 
2375
3483
    def _set_tags_bytes(self, bytes):
 
3484
        if self.is_locked():
 
3485
            self._tags_bytes = bytes
2376
3486
        medium = self._client._medium
2377
3487
        if medium._is_remote_before((1, 18)):
2378
3488
            self._vfs_set_tags_bytes(bytes)
2387
3497
            self._vfs_set_tags_bytes(bytes)
2388
3498
 
2389
3499
    def lock_read(self):
 
3500
        """Lock the branch for read operations.
 
3501
 
 
3502
        :return: A bzrlib.lock.LogicalLockResult.
 
3503
        """
2390
3504
        self.repository.lock_read()
2391
3505
        if not self._lock_mode:
2392
3506
            self._note_lock('r')
2396
3510
                self._real_branch.lock_read()
2397
3511
        else:
2398
3512
            self._lock_count += 1
 
3513
        return lock.LogicalLockResult(self.unlock)
2399
3514
 
2400
3515
    def _remote_lock_write(self, token):
2401
3516
        if token is None:
2402
3517
            branch_token = repo_token = ''
2403
3518
        else:
2404
3519
            branch_token = token
2405
 
            repo_token = self.repository.lock_write()
 
3520
            repo_token = self.repository.lock_write().repository_token
2406
3521
            self.repository.unlock()
2407
3522
        err_context = {'token': token}
2408
 
        response = self._call(
2409
 
            'Branch.lock_write', self._remote_path(), branch_token,
2410
 
            repo_token or '', **err_context)
 
3523
        try:
 
3524
            response = self._call(
 
3525
                'Branch.lock_write', self._remote_path(), branch_token,
 
3526
                repo_token or '', **err_context)
 
3527
        except errors.LockContention, e:
 
3528
            # The LockContention from the server doesn't have any
 
3529
            # information about the lock_url. We re-raise LockContention
 
3530
            # with valid lock_url.
 
3531
            raise errors.LockContention('(remote lock)',
 
3532
                self.repository.base.split('.bzr/')[0])
2411
3533
        if response[0] != 'ok':
2412
3534
            raise errors.UnexpectedSmartServerResponse(response)
2413
3535
        ok, branch_token, repo_token = response
2434
3556
            self._lock_mode = 'w'
2435
3557
            self._lock_count = 1
2436
3558
        elif self._lock_mode == 'r':
2437
 
            raise errors.ReadOnlyTransaction
 
3559
            raise errors.ReadOnlyError(self)
2438
3560
        else:
2439
3561
            if token is not None:
2440
3562
                # A token was given to lock_write, and we're relocking, so
2445
3567
            self._lock_count += 1
2446
3568
            # Re-lock the repository too.
2447
3569
            self.repository.lock_write(self._repo_lock_token)
2448
 
        return self._lock_token or None
 
3570
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
2449
3571
 
2450
3572
    def _unlock(self, branch_token, repo_token):
2451
3573
        err_context = {'token': str((branch_token, repo_token))}
2489
3611
            self.repository.unlock()
2490
3612
 
2491
3613
    def break_lock(self):
2492
 
        self._ensure_real()
2493
 
        return self._real_branch.break_lock()
 
3614
        try:
 
3615
            response = self._call(
 
3616
                'Branch.break_lock', self._remote_path())
 
3617
        except errors.UnknownSmartMethod:
 
3618
            self._ensure_real()
 
3619
            return self._real_branch.break_lock()
 
3620
        if response != ('ok',):
 
3621
            raise errors.UnexpectedSmartServerResponse(response)
2494
3622
 
2495
3623
    def leave_lock_in_place(self):
2496
3624
        if not self._lock_token:
2520
3648
            missing_parent = parent_map[missing_parent]
2521
3649
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2522
3650
 
2523
 
    def _last_revision_info(self):
 
3651
    def _read_last_revision_info(self):
2524
3652
        response = self._call('Branch.last_revision_info', self._remote_path())
2525
3653
        if response[0] != 'ok':
2526
3654
            raise SmartProtocolError('unexpected response code %s' % (response,))
2589
3717
            raise errors.UnexpectedSmartServerResponse(response)
2590
3718
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2591
3719
 
 
3720
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2592
3721
    @needs_write_lock
2593
3722
    def set_revision_history(self, rev_history):
 
3723
        """See Branch.set_revision_history."""
 
3724
        self._set_revision_history(rev_history)
 
3725
 
 
3726
    @needs_write_lock
 
3727
    def _set_revision_history(self, rev_history):
2594
3728
        # Send just the tip revision of the history; the server will generate
2595
3729
        # the full history from that.  If the revision doesn't exist in this
2596
3730
        # branch, NoSuchRevision will be raised.
2654
3788
            _override_hook_target=self, **kwargs)
2655
3789
 
2656
3790
    @needs_read_lock
2657
 
    def push(self, target, overwrite=False, stop_revision=None):
 
3791
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2658
3792
        self._ensure_real()
2659
3793
        return self._real_branch.push(
2660
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
3794
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2661
3795
            _override_hook_source_branch=self)
2662
3796
 
2663
3797
    def is_locked(self):
2664
3798
        return self._lock_count >= 1
2665
3799
 
2666
3800
    @needs_read_lock
 
3801
    def revision_id_to_dotted_revno(self, revision_id):
 
3802
        """Given a revision id, return its dotted revno.
 
3803
 
 
3804
        :return: a tuple like (1,) or (400,1,3).
 
3805
        """
 
3806
        try:
 
3807
            response = self._call('Branch.revision_id_to_revno',
 
3808
                self._remote_path(), revision_id)
 
3809
        except errors.UnknownSmartMethod:
 
3810
            self._ensure_real()
 
3811
            return self._real_branch.revision_id_to_dotted_revno(revision_id)
 
3812
        if response[0] == 'ok':
 
3813
            return tuple([int(x) for x in response[1:]])
 
3814
        else:
 
3815
            raise errors.UnexpectedSmartServerResponse(response)
 
3816
 
 
3817
    @needs_read_lock
2667
3818
    def revision_id_to_revno(self, revision_id):
2668
 
        self._ensure_real()
2669
 
        return self._real_branch.revision_id_to_revno(revision_id)
 
3819
        """Given a revision id on the branch mainline, return its revno.
 
3820
 
 
3821
        :return: an integer
 
3822
        """
 
3823
        try:
 
3824
            response = self._call('Branch.revision_id_to_revno',
 
3825
                self._remote_path(), revision_id)
 
3826
        except errors.UnknownSmartMethod:
 
3827
            self._ensure_real()
 
3828
            return self._real_branch.revision_id_to_revno(revision_id)
 
3829
        if response[0] == 'ok':
 
3830
            if len(response) == 2:
 
3831
                return int(response[1])
 
3832
            raise NoSuchRevision(self, revision_id)
 
3833
        else:
 
3834
            raise errors.UnexpectedSmartServerResponse(response)
2670
3835
 
2671
3836
    @needs_write_lock
2672
3837
    def set_last_revision_info(self, revno, revision_id):
2673
3838
        # XXX: These should be returned by the set_last_revision_info verb
2674
3839
        old_revno, old_revid = self.last_revision_info()
2675
3840
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2676
 
        revision_id = ensure_null(revision_id)
 
3841
        if not revision_id or not isinstance(revision_id, basestring):
 
3842
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2677
3843
        try:
2678
3844
            response = self._call('Branch.set_last_revision_info',
2679
3845
                self._remote_path(), self._lock_token, self._repo_lock_token,
2708
3874
            except errors.UnknownSmartMethod:
2709
3875
                medium._remember_remote_is_before((1, 6))
2710
3876
        self._clear_cached_state_of_remote_branch_only()
2711
 
        self.set_revision_history(self._lefthand_history(revision_id,
 
3877
        self._set_revision_history(self._lefthand_history(revision_id,
2712
3878
            last_rev=last_rev,other_branch=other_branch))
2713
3879
 
2714
3880
    def set_push_location(self, location):
2715
3881
        self._ensure_real()
2716
3882
        return self._real_branch.set_push_location(location)
2717
3883
 
 
3884
    def heads_to_fetch(self):
 
3885
        if self._format._use_default_local_heads_to_fetch():
 
3886
            # We recognise this format, and its heads-to-fetch implementation
 
3887
            # is the default one (tip + tags).  In this case it's cheaper to
 
3888
            # just use the default implementation rather than a special RPC as
 
3889
            # the tip and tags data is cached.
 
3890
            return branch.Branch.heads_to_fetch(self)
 
3891
        medium = self._client._medium
 
3892
        if medium._is_remote_before((2, 4)):
 
3893
            return self._vfs_heads_to_fetch()
 
3894
        try:
 
3895
            return self._rpc_heads_to_fetch()
 
3896
        except errors.UnknownSmartMethod:
 
3897
            medium._remember_remote_is_before((2, 4))
 
3898
            return self._vfs_heads_to_fetch()
 
3899
 
 
3900
    def _rpc_heads_to_fetch(self):
 
3901
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3902
        if len(response) != 2:
 
3903
            raise errors.UnexpectedSmartServerResponse(response)
 
3904
        must_fetch, if_present_fetch = response
 
3905
        return set(must_fetch), set(if_present_fetch)
 
3906
 
 
3907
    def _vfs_heads_to_fetch(self):
 
3908
        self._ensure_real()
 
3909
        return self._real_branch.heads_to_fetch()
 
3910
 
2718
3911
 
2719
3912
class RemoteConfig(object):
2720
3913
    """A Config that reads and writes from smart verbs.
2734
3927
        """
2735
3928
        try:
2736
3929
            configobj = self._get_configobj()
 
3930
            section_obj = None
2737
3931
            if section is None:
2738
3932
                section_obj = configobj
2739
3933
            else:
2740
3934
                try:
2741
3935
                    section_obj = configobj[section]
2742
3936
                except KeyError:
2743
 
                    return default
2744
 
            return section_obj.get(name, default)
 
3937
                    pass
 
3938
            if section_obj is None:
 
3939
                value = default
 
3940
            else:
 
3941
                value = section_obj.get(name, default)
2745
3942
        except errors.UnknownSmartMethod:
2746
 
            return self._vfs_get_option(name, section, default)
 
3943
            value = self._vfs_get_option(name, section, default)
 
3944
        for hook in config.OldConfigHooks['get']:
 
3945
            hook(self, name, value)
 
3946
        return value
2747
3947
 
2748
3948
    def _response_to_configobj(self, response):
2749
3949
        if len(response[0]) and response[0][0] != 'ok':
2750
3950
            raise errors.UnexpectedSmartServerResponse(response)
2751
3951
        lines = response[1].read_body_bytes().splitlines()
2752
 
        return config.ConfigObj(lines, encoding='utf-8')
 
3952
        conf = config.ConfigObj(lines, encoding='utf-8')
 
3953
        for hook in config.OldConfigHooks['load']:
 
3954
            hook(self)
 
3955
        return conf
2753
3956
 
2754
3957
 
2755
3958
class RemoteBranchConfig(RemoteConfig):
2774
3977
        medium = self._branch._client._medium
2775
3978
        if medium._is_remote_before((1, 14)):
2776
3979
            return self._vfs_set_option(value, name, section)
 
3980
        if isinstance(value, dict):
 
3981
            if medium._is_remote_before((2, 2)):
 
3982
                return self._vfs_set_option(value, name, section)
 
3983
            return self._set_config_option_dict(value, name, section)
 
3984
        else:
 
3985
            return self._set_config_option(value, name, section)
 
3986
 
 
3987
    def _set_config_option(self, value, name, section):
2777
3988
        try:
2778
3989
            path = self._branch._remote_path()
2779
3990
            response = self._branch._client.call('Branch.set_config_option',
2780
3991
                path, self._branch._lock_token, self._branch._repo_lock_token,
2781
3992
                value.encode('utf8'), name, section or '')
2782
3993
        except errors.UnknownSmartMethod:
 
3994
            medium = self._branch._client._medium
2783
3995
            medium._remember_remote_is_before((1, 14))
2784
3996
            return self._vfs_set_option(value, name, section)
2785
3997
        if response != ():
2786
3998
            raise errors.UnexpectedSmartServerResponse(response)
2787
3999
 
 
4000
    def _serialize_option_dict(self, option_dict):
 
4001
        utf8_dict = {}
 
4002
        for key, value in option_dict.items():
 
4003
            if isinstance(key, unicode):
 
4004
                key = key.encode('utf8')
 
4005
            if isinstance(value, unicode):
 
4006
                value = value.encode('utf8')
 
4007
            utf8_dict[key] = value
 
4008
        return bencode.bencode(utf8_dict)
 
4009
 
 
4010
    def _set_config_option_dict(self, value, name, section):
 
4011
        try:
 
4012
            path = self._branch._remote_path()
 
4013
            serialised_dict = self._serialize_option_dict(value)
 
4014
            response = self._branch._client.call(
 
4015
                'Branch.set_config_option_dict',
 
4016
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
4017
                serialised_dict, name, section or '')
 
4018
        except errors.UnknownSmartMethod:
 
4019
            medium = self._branch._client._medium
 
4020
            medium._remember_remote_is_before((2, 2))
 
4021
            return self._vfs_set_option(value, name, section)
 
4022
        if response != ():
 
4023
            raise errors.UnexpectedSmartServerResponse(response)
 
4024
 
2788
4025
    def _real_object(self):
2789
4026
        self._branch._ensure_real()
2790
4027
        return self._branch._real_branch
2829
4066
        return self._bzrdir._real_bzrdir
2830
4067
 
2831
4068
 
2832
 
 
2833
4069
def _extract_tar(tar, to_dir):
2834
4070
    """Extract all the contents of a tarfile object.
2835
4071
 
2839
4075
        tar.extract(tarinfo, to_dir)
2840
4076
 
2841
4077
 
 
4078
error_translators = registry.Registry()
 
4079
no_context_error_translators = registry.Registry()
 
4080
 
 
4081
 
2842
4082
def _translate_error(err, **context):
2843
4083
    """Translate an ErrorFromSmartServer into a more useful error.
2844
4084
 
2873
4113
                    'Missing key %r in context %r', key_err.args[0], context)
2874
4114
                raise err
2875
4115
 
2876
 
    if err.error_verb == 'IncompatibleRepositories':
2877
 
        raise errors.IncompatibleRepositories(err.error_args[0],
2878
 
            err.error_args[1], err.error_args[2])
2879
 
    elif err.error_verb == 'NoSuchRevision':
2880
 
        raise NoSuchRevision(find('branch'), err.error_args[0])
2881
 
    elif err.error_verb == 'nosuchrevision':
2882
 
        raise NoSuchRevision(find('repository'), err.error_args[0])
2883
 
    elif err.error_verb == 'nobranch':
2884
 
        if len(err.error_args) >= 1:
2885
 
            extra = err.error_args[0]
2886
 
        else:
2887
 
            extra = None
2888
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
2889
 
            detail=extra)
2890
 
    elif err.error_verb == 'norepository':
2891
 
        raise errors.NoRepositoryPresent(find('bzrdir'))
2892
 
    elif err.error_verb == 'LockContention':
2893
 
        raise errors.LockContention('(remote lock)')
2894
 
    elif err.error_verb == 'UnlockableTransport':
2895
 
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
2896
 
    elif err.error_verb == 'LockFailed':
2897
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
2898
 
    elif err.error_verb == 'TokenMismatch':
2899
 
        raise errors.TokenMismatch(find('token'), '(remote token)')
2900
 
    elif err.error_verb == 'Diverged':
2901
 
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
2902
 
    elif err.error_verb == 'TipChangeRejected':
2903
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2904
 
    elif err.error_verb == 'UnstackableBranchFormat':
2905
 
        raise errors.UnstackableBranchFormat(*err.error_args)
2906
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
2907
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2908
 
    elif err.error_verb == 'NotStacked':
2909
 
        raise errors.NotStacked(branch=find('branch'))
2910
 
    elif err.error_verb == 'PermissionDenied':
2911
 
        path = get_path()
2912
 
        if len(err.error_args) >= 2:
2913
 
            extra = err.error_args[1]
2914
 
        else:
2915
 
            extra = None
2916
 
        raise errors.PermissionDenied(path, extra=extra)
2917
 
    elif err.error_verb == 'ReadError':
2918
 
        path = get_path()
2919
 
        raise errors.ReadError(path)
2920
 
    elif err.error_verb == 'NoSuchFile':
2921
 
        path = get_path()
2922
 
        raise errors.NoSuchFile(path)
2923
 
    elif err.error_verb == 'FileExists':
2924
 
        raise errors.FileExists(err.error_args[0])
2925
 
    elif err.error_verb == 'DirectoryNotEmpty':
2926
 
        raise errors.DirectoryNotEmpty(err.error_args[0])
2927
 
    elif err.error_verb == 'ShortReadvError':
2928
 
        args = err.error_args
2929
 
        raise errors.ShortReadvError(
2930
 
            args[0], int(args[1]), int(args[2]), int(args[3]))
2931
 
    elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
 
4116
    try:
 
4117
        translator = error_translators.get(err.error_verb)
 
4118
    except KeyError:
 
4119
        pass
 
4120
    else:
 
4121
        raise translator(err, find, get_path)
 
4122
    try:
 
4123
        translator = no_context_error_translators.get(err.error_verb)
 
4124
    except KeyError:
 
4125
        raise errors.UnknownErrorFromSmartServer(err)
 
4126
    else:
 
4127
        raise translator(err)
 
4128
 
 
4129
 
 
4130
error_translators.register('NoSuchRevision',
 
4131
    lambda err, find, get_path: NoSuchRevision(
 
4132
        find('branch'), err.error_args[0]))
 
4133
error_translators.register('nosuchrevision',
 
4134
    lambda err, find, get_path: NoSuchRevision(
 
4135
        find('repository'), err.error_args[0]))
 
4136
 
 
4137
def _translate_nobranch_error(err, find, get_path):
 
4138
    if len(err.error_args) >= 1:
 
4139
        extra = err.error_args[0]
 
4140
    else:
 
4141
        extra = None
 
4142
    return errors.NotBranchError(path=find('bzrdir').root_transport.base,
 
4143
        detail=extra)
 
4144
 
 
4145
error_translators.register('nobranch', _translate_nobranch_error)
 
4146
error_translators.register('norepository',
 
4147
    lambda err, find, get_path: errors.NoRepositoryPresent(
 
4148
        find('bzrdir')))
 
4149
error_translators.register('UnlockableTransport',
 
4150
    lambda err, find, get_path: errors.UnlockableTransport(
 
4151
        find('bzrdir').root_transport))
 
4152
error_translators.register('TokenMismatch',
 
4153
    lambda err, find, get_path: errors.TokenMismatch(
 
4154
        find('token'), '(remote token)'))
 
4155
error_translators.register('Diverged',
 
4156
    lambda err, find, get_path: errors.DivergedBranches(
 
4157
        find('branch'), find('other_branch')))
 
4158
error_translators.register('NotStacked',
 
4159
    lambda err, find, get_path: errors.NotStacked(branch=find('branch')))
 
4160
 
 
4161
def _translate_PermissionDenied(err, find, get_path):
 
4162
    path = get_path()
 
4163
    if len(err.error_args) >= 2:
 
4164
        extra = err.error_args[1]
 
4165
    else:
 
4166
        extra = None
 
4167
    return errors.PermissionDenied(path, extra=extra)
 
4168
 
 
4169
error_translators.register('PermissionDenied', _translate_PermissionDenied)
 
4170
error_translators.register('ReadError',
 
4171
    lambda err, find, get_path: errors.ReadError(get_path()))
 
4172
error_translators.register('NoSuchFile',
 
4173
    lambda err, find, get_path: errors.NoSuchFile(get_path()))
 
4174
error_translators.register('TokenLockingNotSupported',
 
4175
    lambda err, find, get_path: errors.TokenLockingNotSupported(
 
4176
        find('repository')))
 
4177
error_translators.register('UnsuspendableWriteGroup',
 
4178
    lambda err, find, get_path: errors.UnsuspendableWriteGroup(
 
4179
        repository=find('repository')))
 
4180
error_translators.register('UnresumableWriteGroup',
 
4181
    lambda err, find, get_path: errors.UnresumableWriteGroup(
 
4182
        repository=find('repository'), write_groups=err.error_args[0],
 
4183
        reason=err.error_args[1]))
 
4184
no_context_error_translators.register('IncompatibleRepositories',
 
4185
    lambda err: errors.IncompatibleRepositories(
 
4186
        err.error_args[0], err.error_args[1], err.error_args[2]))
 
4187
no_context_error_translators.register('LockContention',
 
4188
    lambda err: errors.LockContention('(remote lock)'))
 
4189
no_context_error_translators.register('LockFailed',
 
4190
    lambda err: errors.LockFailed(err.error_args[0], err.error_args[1]))
 
4191
no_context_error_translators.register('TipChangeRejected',
 
4192
    lambda err: errors.TipChangeRejected(err.error_args[0].decode('utf8')))
 
4193
no_context_error_translators.register('UnstackableBranchFormat',
 
4194
    lambda err: errors.UnstackableBranchFormat(*err.error_args))
 
4195
no_context_error_translators.register('UnstackableRepositoryFormat',
 
4196
    lambda err: errors.UnstackableRepositoryFormat(*err.error_args))
 
4197
no_context_error_translators.register('FileExists',
 
4198
    lambda err: errors.FileExists(err.error_args[0]))
 
4199
no_context_error_translators.register('DirectoryNotEmpty',
 
4200
    lambda err: errors.DirectoryNotEmpty(err.error_args[0]))
 
4201
 
 
4202
def _translate_short_readv_error(err):
 
4203
    args = err.error_args
 
4204
    return errors.ShortReadvError(args[0], int(args[1]), int(args[2]),
 
4205
        int(args[3]))
 
4206
 
 
4207
no_context_error_translators.register('ShortReadvError',
 
4208
    _translate_short_readv_error)
 
4209
 
 
4210
def _translate_unicode_error(err):
2932
4211
        encoding = str(err.error_args[0]) # encoding must always be a string
2933
4212
        val = err.error_args[1]
2934
4213
        start = int(err.error_args[2])
2942
4221
            raise UnicodeDecodeError(encoding, val, start, end, reason)
2943
4222
        elif err.error_verb == 'UnicodeEncodeError':
2944
4223
            raise UnicodeEncodeError(encoding, val, start, end, reason)
2945
 
    elif err.error_verb == 'ReadOnlyError':
2946
 
        raise errors.TransportNotPossible('readonly transport')
2947
 
    raise errors.UnknownErrorFromSmartServer(err)
 
4224
 
 
4225
no_context_error_translators.register('UnicodeEncodeError',
 
4226
    _translate_unicode_error)
 
4227
no_context_error_translators.register('UnicodeDecodeError',
 
4228
    _translate_unicode_error)
 
4229
no_context_error_translators.register('ReadOnlyError',
 
4230
    lambda err: errors.TransportNotPossible('readonly transport'))
 
4231
no_context_error_translators.register('MemoryError',
 
4232
    lambda err: errors.BzrError("remote server out of memory\n"
 
4233
        "Retry non-remotely, or contact the server admin for details."))
 
4234
no_context_error_translators.register('RevisionNotPresent',
 
4235
    lambda err: errors.RevisionNotPresent(err.error_args[0], err.error_args[1]))
 
4236
 
 
4237
no_context_error_translators.register('BzrCheckError',
 
4238
    lambda err: errors.BzrCheckError(msg=err.error_args[0]))
 
4239