← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Vincent Ladeuil
  • Date: 2012-02-14 17:22:37 UTC
  • mfrom: (6466 +trunk)
  • mto: This revision was merged to the branch mainline in revision 6468.
  • Revision ID: v.ladeuil+lp@free.fr-20120214172237-7dv7er3n4uy8d5m4
Merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006-2012 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
from __future__ import absolute_import
 
18
 
17
19
import bz2
 
20
import zlib
18
21
 
19
22
from bzrlib import (
20
23
    bencode,
21
24
    branch,
22
 
    bzrdir,
23
 
    config,
 
25
    bzrdir as _mod_bzrdir,
 
26
    config as _mod_config,
24
27
    controldir,
25
28
    debug,
26
29
    errors,
 
30
    gpg,
27
31
    graph,
 
32
    inventory_delta,
28
33
    lock,
29
34
    lockdir,
30
 
    repository,
 
35
    osutils,
 
36
    registry,
31
37
    repository as _mod_repository,
32
 
    revision,
33
38
    revision as _mod_revision,
34
39
    static_tuple,
35
40
    symbol_versioning,
 
41
    testament as _mod_testament,
36
42
    urlutils,
37
 
)
 
43
    vf_repository,
 
44
    vf_search,
 
45
    )
38
46
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
39
 
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
40
47
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
41
48
from bzrlib.errors import (
42
49
    NoSuchRevision,
43
50
    SmartProtocolError,
44
51
    )
 
52
from bzrlib.i18n import gettext
 
53
from bzrlib.inventory import Inventory
45
54
from bzrlib.lockable_files import LockableFiles
46
55
from bzrlib.smart import client, vfs, repository as smart_repo
47
 
from bzrlib.revision import ensure_null, NULL_REVISION
48
 
from bzrlib.repository import RepositoryWriteLockResult
49
 
from bzrlib.trace import mutter, note, warning
 
56
from bzrlib.smart.client import _SmartClient
 
57
from bzrlib.revision import NULL_REVISION
 
58
from bzrlib.revisiontree import InventoryRevisionTree
 
59
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
 
60
from bzrlib.serializer import format_registry as serializer_format_registry
 
61
from bzrlib.trace import mutter, note, warning, log_exception_quietly
 
62
from bzrlib.versionedfile import FulltextContentFactory
 
63
 
 
64
 
 
65
_DEFAULT_SEARCH_DEPTH = 100
50
66
 
51
67
 
52
68
class _RpcHelper(object):
89
105
    return format
90
106
 
91
107
 
92
 
# Note: RemoteBzrDirFormat is in bzrdir.py
93
 
 
94
 
class RemoteBzrDir(BzrDir, _RpcHelper):
 
108
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
 
109
# does not have to be imported unless a remote format is involved.
 
110
 
 
111
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
 
112
    """Format representing bzrdirs accessed via a smart server"""
 
113
 
 
114
    supports_workingtrees = False
 
115
 
 
116
    colocated_branches = False
 
117
 
 
118
    def __init__(self):
 
119
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
 
120
        # XXX: It's a bit ugly that the network name is here, because we'd
 
121
        # like to believe that format objects are stateless or at least
 
122
        # immutable,  However, we do at least avoid mutating the name after
 
123
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
 
124
        self._network_name = None
 
125
 
 
126
    def __repr__(self):
 
127
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
128
            self._network_name)
 
129
 
 
130
    def get_format_description(self):
 
131
        if self._network_name:
 
132
            try:
 
133
                real_format = controldir.network_format_registry.get(
 
134
                        self._network_name)
 
135
            except KeyError:
 
136
                pass
 
137
            else:
 
138
                return 'Remote: ' + real_format.get_format_description()
 
139
        return 'bzr remote bzrdir'
 
140
 
 
141
    def get_format_string(self):
 
142
        raise NotImplementedError(self.get_format_string)
 
143
 
 
144
    def network_name(self):
 
145
        if self._network_name:
 
146
            return self._network_name
 
147
        else:
 
148
            raise AssertionError("No network name set.")
 
149
 
 
150
    def initialize_on_transport(self, transport):
 
151
        try:
 
152
            # hand off the request to the smart server
 
153
            client_medium = transport.get_smart_medium()
 
154
        except errors.NoSmartMedium:
 
155
            # TODO: lookup the local format from a server hint.
 
156
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
157
            return local_dir_format.initialize_on_transport(transport)
 
158
        client = _SmartClient(client_medium)
 
159
        path = client.remote_path_from_transport(transport)
 
160
        try:
 
161
            response = client.call('BzrDirFormat.initialize', path)
 
162
        except errors.ErrorFromSmartServer, err:
 
163
            _translate_error(err, path=path)
 
164
        if response[0] != 'ok':
 
165
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
 
166
        format = RemoteBzrDirFormat()
 
167
        self._supply_sub_formats_to(format)
 
168
        return RemoteBzrDir(transport, format)
 
169
 
 
170
    def parse_NoneTrueFalse(self, arg):
 
171
        if not arg:
 
172
            return None
 
173
        if arg == 'False':
 
174
            return False
 
175
        if arg == 'True':
 
176
            return True
 
177
        raise AssertionError("invalid arg %r" % arg)
 
178
 
 
179
    def _serialize_NoneTrueFalse(self, arg):
 
180
        if arg is False:
 
181
            return 'False'
 
182
        if arg:
 
183
            return 'True'
 
184
        return ''
 
185
 
 
186
    def _serialize_NoneString(self, arg):
 
187
        return arg or ''
 
188
 
 
189
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
190
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
191
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
192
        shared_repo=False):
 
193
        try:
 
194
            # hand off the request to the smart server
 
195
            client_medium = transport.get_smart_medium()
 
196
        except errors.NoSmartMedium:
 
197
            do_vfs = True
 
198
        else:
 
199
            # Decline to open it if the server doesn't support our required
 
200
            # version (3) so that the VFS-based transport will do it.
 
201
            if client_medium.should_probe():
 
202
                try:
 
203
                    server_version = client_medium.protocol_version()
 
204
                    if server_version != '2':
 
205
                        do_vfs = True
 
206
                    else:
 
207
                        do_vfs = False
 
208
                except errors.SmartProtocolError:
 
209
                    # Apparently there's no usable smart server there, even though
 
210
                    # the medium supports the smart protocol.
 
211
                    do_vfs = True
 
212
            else:
 
213
                do_vfs = False
 
214
        if not do_vfs:
 
215
            client = _SmartClient(client_medium)
 
216
            path = client.remote_path_from_transport(transport)
 
217
            if client_medium._is_remote_before((1, 16)):
 
218
                do_vfs = True
 
219
        if do_vfs:
 
220
            # TODO: lookup the local format from a server hint.
 
221
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
222
            self._supply_sub_formats_to(local_dir_format)
 
223
            return local_dir_format.initialize_on_transport_ex(transport,
 
224
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
225
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
226
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
227
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
228
                vfs_only=True)
 
229
        return self._initialize_on_transport_ex_rpc(client, path, transport,
 
230
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
231
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
 
232
 
 
233
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
 
234
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
235
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
 
236
        args = []
 
237
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
 
238
        args.append(self._serialize_NoneTrueFalse(create_prefix))
 
239
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
 
240
        args.append(self._serialize_NoneString(stacked_on))
 
241
        # stack_on_pwd is often/usually our transport
 
242
        if stack_on_pwd:
 
243
            try:
 
244
                stack_on_pwd = transport.relpath(stack_on_pwd)
 
245
                if not stack_on_pwd:
 
246
                    stack_on_pwd = '.'
 
247
            except errors.PathNotChild:
 
248
                pass
 
249
        args.append(self._serialize_NoneString(stack_on_pwd))
 
250
        args.append(self._serialize_NoneString(repo_format_name))
 
251
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
 
252
        args.append(self._serialize_NoneTrueFalse(shared_repo))
 
253
        request_network_name = self._network_name or \
 
254
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
 
255
        try:
 
256
            response = client.call('BzrDirFormat.initialize_ex_1.16',
 
257
                request_network_name, path, *args)
 
258
        except errors.UnknownSmartMethod:
 
259
            client._medium._remember_remote_is_before((1,16))
 
260
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
261
            self._supply_sub_formats_to(local_dir_format)
 
262
            return local_dir_format.initialize_on_transport_ex(transport,
 
263
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
264
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
265
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
266
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
267
                vfs_only=True)
 
268
        except errors.ErrorFromSmartServer, err:
 
269
            _translate_error(err, path=path)
 
270
        repo_path = response[0]
 
271
        bzrdir_name = response[6]
 
272
        require_stacking = response[7]
 
273
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
 
274
        format = RemoteBzrDirFormat()
 
275
        format._network_name = bzrdir_name
 
276
        self._supply_sub_formats_to(format)
 
277
        bzrdir = RemoteBzrDir(transport, format, _client=client)
 
278
        if repo_path:
 
279
            repo_format = response_tuple_to_repo_format(response[1:])
 
280
            if repo_path == '.':
 
281
                repo_path = ''
 
282
            if repo_path:
 
283
                repo_bzrdir_format = RemoteBzrDirFormat()
 
284
                repo_bzrdir_format._network_name = response[5]
 
285
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
 
286
                    repo_bzrdir_format)
 
287
            else:
 
288
                repo_bzr = bzrdir
 
289
            final_stack = response[8] or None
 
290
            final_stack_pwd = response[9] or None
 
291
            if final_stack_pwd:
 
292
                final_stack_pwd = urlutils.join(
 
293
                    transport.base, final_stack_pwd)
 
294
            remote_repo = RemoteRepository(repo_bzr, repo_format)
 
295
            if len(response) > 10:
 
296
                # Updated server verb that locks remotely.
 
297
                repo_lock_token = response[10] or None
 
298
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
 
299
                if repo_lock_token:
 
300
                    remote_repo.dont_leave_lock_in_place()
 
301
            else:
 
302
                remote_repo.lock_write()
 
303
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
 
304
                final_stack_pwd, require_stacking)
 
305
            policy.acquire_repository()
 
306
        else:
 
307
            remote_repo = None
 
308
            policy = None
 
309
        bzrdir._format.set_branch_format(self.get_branch_format())
 
310
        if require_stacking:
 
311
            # The repo has already been created, but we need to make sure that
 
312
            # we'll make a stackable branch.
 
313
            bzrdir._format.require_stacking(_skip_repo=True)
 
314
        return remote_repo, bzrdir, require_stacking, policy
 
315
 
 
316
    def _open(self, transport):
 
317
        return RemoteBzrDir(transport, self)
 
318
 
 
319
    def __eq__(self, other):
 
320
        if not isinstance(other, RemoteBzrDirFormat):
 
321
            return False
 
322
        return self.get_format_description() == other.get_format_description()
 
323
 
 
324
    def __return_repository_format(self):
 
325
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
 
326
        # repository format has been asked for, tell the RemoteRepositoryFormat
 
327
        # that it should use that for init() etc.
 
328
        result = RemoteRepositoryFormat()
 
329
        custom_format = getattr(self, '_repository_format', None)
 
330
        if custom_format:
 
331
            if isinstance(custom_format, RemoteRepositoryFormat):
 
332
                return custom_format
 
333
            else:
 
334
                # We will use the custom format to create repositories over the
 
335
                # wire; expose its details like rich_root_data for code to
 
336
                # query
 
337
                result._custom_format = custom_format
 
338
        return result
 
339
 
 
340
    def get_branch_format(self):
 
341
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
 
342
        if not isinstance(result, RemoteBranchFormat):
 
343
            new_result = RemoteBranchFormat()
 
344
            new_result._custom_format = result
 
345
            # cache the result
 
346
            self.set_branch_format(new_result)
 
347
            result = new_result
 
348
        return result
 
349
 
 
350
    repository_format = property(__return_repository_format,
 
351
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
 
352
 
 
353
 
 
354
class RemoteControlStore(_mod_config.IniFileStore):
 
355
    """Control store which attempts to use HPSS calls to retrieve control store.
 
356
 
 
357
    Note that this is specific to bzr-based formats.
 
358
    """
 
359
 
 
360
    def __init__(self, bzrdir):
 
361
        super(RemoteControlStore, self).__init__()
 
362
        self.bzrdir = bzrdir
 
363
        self._real_store = None
 
364
 
 
365
    def lock_write(self, token=None):
 
366
        self._ensure_real()
 
367
        return self._real_store.lock_write(token)
 
368
 
 
369
    def unlock(self):
 
370
        self._ensure_real()
 
371
        return self._real_store.unlock()
 
372
 
 
373
    @needs_write_lock
 
374
    def save(self):
 
375
        # We need to be able to override the undecorated implementation
 
376
        self.save_without_locking()
 
377
 
 
378
    def save_without_locking(self):
 
379
        super(RemoteControlStore, self).save()
 
380
 
 
381
    def _ensure_real(self):
 
382
        self.bzrdir._ensure_real()
 
383
        if self._real_store is None:
 
384
            self._real_store = _mod_config.ControlStore(self.bzrdir)
 
385
 
 
386
    def external_url(self):
 
387
        return self.bzrdir.user_url
 
388
 
 
389
    def _load_content(self):
 
390
        medium = self.bzrdir._client._medium
 
391
        path = self.bzrdir._path_for_remote_call(self.bzrdir._client)
 
392
        try:
 
393
            response, handler = self.bzrdir._call_expecting_body(
 
394
                'BzrDir.get_config_file', path)
 
395
        except errors.UnknownSmartMethod:
 
396
            self._ensure_real()
 
397
            return self._real_store._load_content()
 
398
        if len(response) and response[0] != 'ok':
 
399
            raise errors.UnexpectedSmartServerResponse(response)
 
400
        return handler.read_body_bytes()
 
401
 
 
402
    def _save_content(self, content):
 
403
        # FIXME JRV 2011-11-22: Ideally this should use a
 
404
        # HPSS call too, but at the moment it is not possible
 
405
        # to write lock control directories.
 
406
        self._ensure_real()
 
407
        return self._real_store._save_content(content)
 
408
 
 
409
 
 
410
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
95
411
    """Control directory on a remote server, accessed via bzr:// or similar."""
96
412
 
97
413
    def __init__(self, transport, format, _client=None, _force_probe=False):
100
416
        :param _client: Private parameter for testing. Disables probing and the
101
417
            use of a real bzrdir.
102
418
        """
103
 
        BzrDir.__init__(self, transport, format)
 
419
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
104
420
        # this object holds a delegated bzrdir that uses file-level operations
105
421
        # to talk to the other side
106
422
        self._real_bzrdir = None
166
482
                import traceback
167
483
                warning('VFS BzrDir access triggered\n%s',
168
484
                    ''.join(traceback.format_stack()))
169
 
            self._real_bzrdir = BzrDir.open_from_transport(
170
 
                self.root_transport, _server_formats=False)
 
485
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
 
486
                self.root_transport, probers=[_mod_bzrdir.BzrProber])
171
487
            self._format._network_name = \
172
488
                self._real_bzrdir._format.network_name()
173
489
 
178
494
        # Prevent aliasing problems in the next_open_branch_result cache.
179
495
        # See create_branch for rationale.
180
496
        self._next_open_branch_result = None
181
 
        return BzrDir.break_lock(self)
 
497
        return _mod_bzrdir.BzrDir.break_lock(self)
 
498
 
 
499
    def _vfs_checkout_metadir(self):
 
500
        self._ensure_real()
 
501
        return self._real_bzrdir.checkout_metadir()
 
502
 
 
503
    def checkout_metadir(self):
 
504
        """Retrieve the controldir format to use for checkouts of this one.
 
505
        """
 
506
        medium = self._client._medium
 
507
        if medium._is_remote_before((2, 5)):
 
508
            return self._vfs_checkout_metadir()
 
509
        path = self._path_for_remote_call(self._client)
 
510
        try:
 
511
            response = self._client.call('BzrDir.checkout_metadir',
 
512
                path)
 
513
        except errors.UnknownSmartMethod:
 
514
            medium._remember_remote_is_before((2, 5))
 
515
            return self._vfs_checkout_metadir()
 
516
        if len(response) != 3:
 
517
            raise errors.UnexpectedSmartServerResponse(response)
 
518
        control_name, repo_name, branch_name = response
 
519
        try:
 
520
            format = controldir.network_format_registry.get(control_name)
 
521
        except KeyError:
 
522
            raise errors.UnknownFormatError(kind='control',
 
523
                format=control_name)
 
524
        if repo_name:
 
525
            try:
 
526
                repo_format = _mod_repository.network_format_registry.get(
 
527
                    repo_name)
 
528
            except KeyError:
 
529
                raise errors.UnknownFormatError(kind='repository',
 
530
                    format=repo_name)
 
531
            format.repository_format = repo_format
 
532
        if branch_name:
 
533
            try:
 
534
                format.set_branch_format(
 
535
                    branch.network_format_registry.get(branch_name))
 
536
            except KeyError:
 
537
                raise errors.UnknownFormatError(kind='branch',
 
538
                    format=branch_name)
 
539
        return format
182
540
 
183
541
    def _vfs_cloning_metadir(self, require_stacking=False):
184
542
        self._ensure_real()
215
573
        if len(branch_info) != 2:
216
574
            raise errors.UnexpectedSmartServerResponse(response)
217
575
        branch_ref, branch_name = branch_info
218
 
        format = controldir.network_format_registry.get(control_name)
 
576
        try:
 
577
            format = controldir.network_format_registry.get(control_name)
 
578
        except KeyError:
 
579
            raise errors.UnknownFormatError(kind='control', format=control_name)
 
580
 
219
581
        if repo_name:
220
 
            format.repository_format = repository.network_format_registry.get(
221
 
                repo_name)
 
582
            try:
 
583
                format.repository_format = _mod_repository.network_format_registry.get(
 
584
                    repo_name)
 
585
            except KeyError:
 
586
                raise errors.UnknownFormatError(kind='repository',
 
587
                    format=repo_name)
222
588
        if branch_ref == 'ref':
223
589
            # XXX: we need possible_transports here to avoid reopening the
224
590
            # connection to the referenced location
225
 
            ref_bzrdir = BzrDir.open(branch_name)
 
591
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
226
592
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
227
593
            format.set_branch_format(branch_format)
228
594
        elif branch_ref == 'branch':
229
595
            if branch_name:
230
 
                format.set_branch_format(
231
 
                    branch.network_format_registry.get(branch_name))
 
596
                try:
 
597
                    branch_format = branch.network_format_registry.get(
 
598
                        branch_name)
 
599
                except KeyError:
 
600
                    raise errors.UnknownFormatError(kind='branch',
 
601
                        format=branch_name)
 
602
                format.set_branch_format(branch_format)
232
603
        else:
233
604
            raise errors.UnexpectedSmartServerResponse(response)
234
605
        return format
244
615
 
245
616
    def destroy_repository(self):
246
617
        """See BzrDir.destroy_repository"""
247
 
        self._ensure_real()
248
 
        self._real_bzrdir.destroy_repository()
 
618
        path = self._path_for_remote_call(self._client)
 
619
        try:
 
620
            response = self._call('BzrDir.destroy_repository', path)
 
621
        except errors.UnknownSmartMethod:
 
622
            self._ensure_real()
 
623
            self._real_bzrdir.destroy_repository()
 
624
            return
 
625
        if response[0] != 'ok':
 
626
            raise SmartProtocolError('unexpected response code %s' % (response,))
249
627
 
250
 
    def create_branch(self, name=None, repository=None):
 
628
    def create_branch(self, name=None, repository=None,
 
629
                      append_revisions_only=None):
 
630
        if name is None:
 
631
            name = self._get_selected_branch()
 
632
        if name != "":
 
633
            raise errors.NoColocatedBranchSupport(self)
251
634
        # as per meta1 formats - just delegate to the format object which may
252
635
        # be parameterised.
253
636
        real_branch = self._format.get_branch_format().initialize(self,
254
 
            name=name, repository=repository)
 
637
            name=name, repository=repository,
 
638
            append_revisions_only=append_revisions_only)
255
639
        if not isinstance(real_branch, RemoteBranch):
256
640
            if not isinstance(repository, RemoteRepository):
257
641
                raise AssertionError(
271
655
 
272
656
    def destroy_branch(self, name=None):
273
657
        """See BzrDir.destroy_branch"""
274
 
        self._ensure_real()
275
 
        self._real_bzrdir.destroy_branch(name=name)
 
658
        if name is None:
 
659
            name = self._get_selected_branch()
 
660
        if name != "":
 
661
            raise errors.NoColocatedBranchSupport(self)
 
662
        path = self._path_for_remote_call(self._client)
 
663
        try:
 
664
            if name != "":
 
665
                args = (name, )
 
666
            else:
 
667
                args = ()
 
668
            response = self._call('BzrDir.destroy_branch', path, *args)
 
669
        except errors.UnknownSmartMethod:
 
670
            self._ensure_real()
 
671
            self._real_bzrdir.destroy_branch(name=name)
 
672
            self._next_open_branch_result = None
 
673
            return
276
674
        self._next_open_branch_result = None
 
675
        if response[0] != 'ok':
 
676
            raise SmartProtocolError('unexpected response code %s' % (response,))
277
677
 
278
678
    def create_workingtree(self, revision_id=None, from_branch=None,
279
679
        accelerator_tree=None, hardlink=False):
287
687
        b = self.open_branch(name=name)
288
688
        return b._format
289
689
 
 
690
    def get_branches(self, possible_transports=None, ignore_fallbacks=False):
 
691
        path = self._path_for_remote_call(self._client)
 
692
        try:
 
693
            response, handler = self._call_expecting_body(
 
694
                'BzrDir.get_branches', path)
 
695
        except errors.UnknownSmartMethod:
 
696
            self._ensure_real()
 
697
            return self._real_bzrdir.get_branches()
 
698
        if response[0] != "success":
 
699
            raise errors.UnexpectedSmartServerResponse(response)
 
700
        body = bencode.bdecode(handler.read_body_bytes())
 
701
        ret = {}
 
702
        for (name, value) in body.iteritems():
 
703
            ret[name] = self._open_branch(name, value[0], value[1],
 
704
                possible_transports=possible_transports,
 
705
                ignore_fallbacks=ignore_fallbacks)
 
706
        return ret
 
707
 
 
708
    def set_branch_reference(self, target_branch, name=None):
 
709
        """See BzrDir.set_branch_reference()."""
 
710
        if name is None:
 
711
            name = self._get_selected_branch()
 
712
        if name != "":
 
713
            raise errors.NoColocatedBranchSupport(self)
 
714
        self._ensure_real()
 
715
        return self._real_bzrdir.set_branch_reference(target_branch, name=name)
 
716
 
290
717
    def get_branch_reference(self, name=None):
291
718
        """See BzrDir.get_branch_reference()."""
292
 
        if name is not None:
293
 
            # XXX JRV20100304: Support opening colocated branches
 
719
        if name is None:
 
720
            name = self._get_selected_branch()
 
721
        if name != "":
294
722
            raise errors.NoColocatedBranchSupport(self)
295
723
        response = self._get_branch_reference()
296
724
        if response[0] == 'ref':
332
760
        """See BzrDir._get_tree_branch()."""
333
761
        return None, self.open_branch(name=name)
334
762
 
335
 
    def open_branch(self, name=None, unsupported=False,
336
 
                    ignore_fallbacks=False):
337
 
        if unsupported:
338
 
            raise NotImplementedError('unsupported flag support not implemented yet.')
339
 
        if self._next_open_branch_result is not None:
340
 
            # See create_branch for details.
341
 
            result = self._next_open_branch_result
342
 
            self._next_open_branch_result = None
343
 
            return result
344
 
        response = self._get_branch_reference()
345
 
        if response[0] == 'ref':
 
763
    def _open_branch(self, name, kind, location_or_format,
 
764
                     ignore_fallbacks=False, possible_transports=None):
 
765
        if kind == 'ref':
346
766
            # a branch reference, use the existing BranchReference logic.
347
767
            format = BranchReferenceFormat()
348
768
            return format.open(self, name=name, _found=True,
349
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
350
 
        branch_format_name = response[1]
 
769
                location=location_or_format, ignore_fallbacks=ignore_fallbacks,
 
770
                possible_transports=possible_transports)
 
771
        branch_format_name = location_or_format
351
772
        if not branch_format_name:
352
773
            branch_format_name = None
353
774
        format = RemoteBranchFormat(network_name=branch_format_name)
354
775
        return RemoteBranch(self, self.find_repository(), format=format,
355
 
            setup_stacking=not ignore_fallbacks, name=name)
 
776
            setup_stacking=not ignore_fallbacks, name=name,
 
777
            possible_transports=possible_transports)
 
778
 
 
779
    def open_branch(self, name=None, unsupported=False,
 
780
                    ignore_fallbacks=False, possible_transports=None):
 
781
        if name is None:
 
782
            name = self._get_selected_branch()
 
783
        if name != "":
 
784
            raise errors.NoColocatedBranchSupport(self)
 
785
        if unsupported:
 
786
            raise NotImplementedError('unsupported flag support not implemented yet.')
 
787
        if self._next_open_branch_result is not None:
 
788
            # See create_branch for details.
 
789
            result = self._next_open_branch_result
 
790
            self._next_open_branch_result = None
 
791
            return result
 
792
        response = self._get_branch_reference()
 
793
        return self._open_branch(name, response[0], response[1],
 
794
            possible_transports=possible_transports,
 
795
            ignore_fallbacks=ignore_fallbacks)
356
796
 
357
797
    def _open_repo_v1(self, path):
358
798
        verb = 'BzrDir.find_repository'
421
861
 
422
862
    def has_workingtree(self):
423
863
        if self._has_working_tree is None:
424
 
            self._ensure_real()
425
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
 
864
            path = self._path_for_remote_call(self._client)
 
865
            try:
 
866
                response = self._call('BzrDir.has_workingtree', path)
 
867
            except errors.UnknownSmartMethod:
 
868
                self._ensure_real()
 
869
                self._has_working_tree = self._real_bzrdir.has_workingtree()
 
870
            else:
 
871
                if response[0] not in ('yes', 'no'):
 
872
                    raise SmartProtocolError('unexpected response code %s' % (response,))
 
873
                self._has_working_tree = (response[0] == 'yes')
426
874
        return self._has_working_tree
427
875
 
428
876
    def open_workingtree(self, recommend_upgrade=True):
433
881
 
434
882
    def _path_for_remote_call(self, client):
435
883
        """Return the path to be used for this bzrdir in a remote call."""
436
 
        return client.remote_path_from_transport(self.root_transport)
 
884
        return urlutils.split_segment_parameters_raw(
 
885
            client.remote_path_from_transport(self.root_transport))[0]
437
886
 
438
887
    def get_branch_transport(self, branch_format, name=None):
439
888
        self._ensure_real()
451
900
        """Upgrading of remote bzrdirs is not supported yet."""
452
901
        return False
453
902
 
454
 
    def needs_format_conversion(self, format=None):
 
903
    def needs_format_conversion(self, format):
455
904
        """Upgrading of remote bzrdirs is not supported yet."""
456
 
        if format is None:
457
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
458
 
                % 'needs_format_conversion(format=None)')
459
905
        return False
460
906
 
461
 
    def clone(self, url, revision_id=None, force_new_repo=False,
462
 
              preserve_stacking=False):
463
 
        self._ensure_real()
464
 
        return self._real_bzrdir.clone(url, revision_id=revision_id,
465
 
            force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
466
 
 
467
907
    def _get_config(self):
468
908
        return RemoteBzrDirConfig(self)
469
909
 
470
 
 
471
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
910
    def _get_config_store(self):
 
911
        return RemoteControlStore(self)
 
912
 
 
913
 
 
914
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
472
915
    """Format for repositories accessed over a _SmartClient.
473
916
 
474
917
    Instances of this repository are represented by RemoteRepository
489
932
    """
490
933
 
491
934
    _matchingbzrdir = RemoteBzrDirFormat()
 
935
    supports_full_versioned_files = True
 
936
    supports_leaving_lock = True
492
937
 
493
938
    def __init__(self):
494
 
        repository.RepositoryFormat.__init__(self)
 
939
        _mod_repository.RepositoryFormat.__init__(self)
495
940
        self._custom_format = None
496
941
        self._network_name = None
497
942
        self._creating_bzrdir = None
 
943
        self._revision_graph_can_have_wrong_parents = None
498
944
        self._supports_chks = None
499
945
        self._supports_external_lookups = None
500
946
        self._supports_tree_reference = None
 
947
        self._supports_funky_characters = None
 
948
        self._supports_nesting_repositories = None
501
949
        self._rich_root_data = None
502
950
 
503
951
    def __repr__(self):
532
980
        return self._supports_external_lookups
533
981
 
534
982
    @property
 
983
    def supports_funky_characters(self):
 
984
        if self._supports_funky_characters is None:
 
985
            self._ensure_real()
 
986
            self._supports_funky_characters = \
 
987
                self._custom_format.supports_funky_characters
 
988
        return self._supports_funky_characters
 
989
 
 
990
    @property
 
991
    def supports_nesting_repositories(self):
 
992
        if self._supports_nesting_repositories is None:
 
993
            self._ensure_real()
 
994
            self._supports_nesting_repositories = \
 
995
                self._custom_format.supports_nesting_repositories
 
996
        return self._supports_nesting_repositories
 
997
 
 
998
    @property
535
999
    def supports_tree_reference(self):
536
1000
        if self._supports_tree_reference is None:
537
1001
            self._ensure_real()
539
1003
                self._custom_format.supports_tree_reference
540
1004
        return self._supports_tree_reference
541
1005
 
 
1006
    @property
 
1007
    def revision_graph_can_have_wrong_parents(self):
 
1008
        if self._revision_graph_can_have_wrong_parents is None:
 
1009
            self._ensure_real()
 
1010
            self._revision_graph_can_have_wrong_parents = \
 
1011
                self._custom_format.revision_graph_can_have_wrong_parents
 
1012
        return self._revision_graph_can_have_wrong_parents
 
1013
 
542
1014
    def _vfs_initialize(self, a_bzrdir, shared):
543
1015
        """Helper for common code in initialize."""
544
1016
        if self._custom_format:
579
1051
            network_name = self._network_name
580
1052
        else:
581
1053
            # Select the current bzrlib default and ask for that.
582
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
1054
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
583
1055
            reference_format = reference_bzrdir_format.repository_format
584
1056
            network_name = reference_format.network_name()
585
1057
        # 2) try direct creation via RPC
611
1083
 
612
1084
    def _ensure_real(self):
613
1085
        if self._custom_format is None:
614
 
            self._custom_format = repository.network_format_registry.get(
615
 
                self._network_name)
 
1086
            try:
 
1087
                self._custom_format = _mod_repository.network_format_registry.get(
 
1088
                    self._network_name)
 
1089
            except KeyError:
 
1090
                raise errors.UnknownFormatError(kind='repository',
 
1091
                    format=self._network_name)
616
1092
 
617
1093
    @property
618
1094
    def _fetch_order(self):
653
1129
        return self._custom_format._serializer
654
1130
 
655
1131
 
656
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
657
 
    controldir.ControlComponent):
 
1132
class RemoteRepository(_mod_repository.Repository, _RpcHelper,
 
1133
        lock._RelockDebugMixin):
658
1134
    """Repository accessed over rpc.
659
1135
 
660
1136
    For the moment most operations are performed using local transport-backed
684
1160
        self._format = format
685
1161
        self._lock_mode = None
686
1162
        self._lock_token = None
 
1163
        self._write_group_tokens = None
687
1164
        self._lock_count = 0
688
1165
        self._leave_lock = False
689
1166
        # Cache of revision parents; misses are cached during read locks, and
713
1190
        # transport, but I'm not sure it's worth making this method
714
1191
        # optional -- mbp 2010-04-21
715
1192
        return self.bzrdir.get_repository_transport(None)
716
 
        
 
1193
 
717
1194
    def __str__(self):
718
1195
        return "%s(%s)" % (self.__class__.__name__, self.base)
719
1196
 
729
1206
 
730
1207
        :param suppress_errors: see Repository.abort_write_group.
731
1208
        """
732
 
        self._ensure_real()
733
 
        return self._real_repository.abort_write_group(
734
 
            suppress_errors=suppress_errors)
 
1209
        if self._real_repository:
 
1210
            self._ensure_real()
 
1211
            return self._real_repository.abort_write_group(
 
1212
                suppress_errors=suppress_errors)
 
1213
        if not self.is_in_write_group():
 
1214
            if suppress_errors:
 
1215
                mutter('(suppressed) not in write group')
 
1216
                return
 
1217
            raise errors.BzrError("not in write group")
 
1218
        path = self.bzrdir._path_for_remote_call(self._client)
 
1219
        try:
 
1220
            response = self._call('Repository.abort_write_group', path,
 
1221
                self._lock_token, self._write_group_tokens)
 
1222
        except Exception, exc:
 
1223
            self._write_group = None
 
1224
            if not suppress_errors:
 
1225
                raise
 
1226
            mutter('abort_write_group failed')
 
1227
            log_exception_quietly()
 
1228
            note(gettext('bzr: ERROR (ignored): %s'), exc)
 
1229
        else:
 
1230
            if response != ('ok', ):
 
1231
                raise errors.UnexpectedSmartServerResponse(response)
 
1232
            self._write_group_tokens = None
735
1233
 
736
1234
    @property
737
1235
    def chk_bytes(self):
751
1249
        for older plugins that don't use e.g. the CommitBuilder
752
1250
        facility.
753
1251
        """
754
 
        self._ensure_real()
755
 
        return self._real_repository.commit_write_group()
 
1252
        if self._real_repository:
 
1253
            self._ensure_real()
 
1254
            return self._real_repository.commit_write_group()
 
1255
        if not self.is_in_write_group():
 
1256
            raise errors.BzrError("not in write group")
 
1257
        path = self.bzrdir._path_for_remote_call(self._client)
 
1258
        response = self._call('Repository.commit_write_group', path,
 
1259
            self._lock_token, self._write_group_tokens)
 
1260
        if response != ('ok', ):
 
1261
            raise errors.UnexpectedSmartServerResponse(response)
 
1262
        self._write_group_tokens = None
 
1263
        # Refresh data after writing to the repository.
 
1264
        self.refresh_data()
756
1265
 
757
1266
    def resume_write_group(self, tokens):
758
 
        self._ensure_real()
759
 
        return self._real_repository.resume_write_group(tokens)
 
1267
        if self._real_repository:
 
1268
            return self._real_repository.resume_write_group(tokens)
 
1269
        path = self.bzrdir._path_for_remote_call(self._client)
 
1270
        try:
 
1271
            response = self._call('Repository.check_write_group', path,
 
1272
               self._lock_token, tokens)
 
1273
        except errors.UnknownSmartMethod:
 
1274
            self._ensure_real()
 
1275
            return self._real_repository.resume_write_group(tokens)
 
1276
        if response != ('ok', ):
 
1277
            raise errors.UnexpectedSmartServerResponse(response)
 
1278
        self._write_group_tokens = tokens
760
1279
 
761
1280
    def suspend_write_group(self):
762
 
        self._ensure_real()
763
 
        return self._real_repository.suspend_write_group()
 
1281
        if self._real_repository:
 
1282
            return self._real_repository.suspend_write_group()
 
1283
        ret = self._write_group_tokens or []
 
1284
        self._write_group_tokens = None
 
1285
        return ret
764
1286
 
765
1287
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
766
1288
        self._ensure_real()
827
1349
    def find_text_key_references(self):
828
1350
        """Find the text key references within the repository.
829
1351
 
830
 
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
831
 
        revision_ids. Each altered file-ids has the exact revision_ids that
832
 
        altered it listed explicitly.
833
1352
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
834
1353
            to whether they were referred to by the inventory of the
835
1354
            revision_id that they contain. The inventory texts from all present
853
1372
        """Private method for using with old (< 1.2) servers to fallback."""
854
1373
        if revision_id is None:
855
1374
            revision_id = ''
856
 
        elif revision.is_null(revision_id):
 
1375
        elif _mod_revision.is_null(revision_id):
857
1376
            return {}
858
1377
 
859
1378
        path = self.bzrdir._path_for_remote_call(self._client)
883
1402
        return RemoteStreamSource(self, to_format)
884
1403
 
885
1404
    @needs_read_lock
 
1405
    def get_file_graph(self):
 
1406
        return graph.Graph(self.texts)
 
1407
 
 
1408
    @needs_read_lock
886
1409
    def has_revision(self, revision_id):
887
1410
        """True if this repository has a copy of the revision."""
888
1411
        # Copy of bzrlib.repository.Repository.has_revision
940
1463
        """See Repository.gather_stats()."""
941
1464
        path = self.bzrdir._path_for_remote_call(self._client)
942
1465
        # revid can be None to indicate no revisions, not just NULL_REVISION
943
 
        if revid is None or revision.is_null(revid):
 
1466
        if revid is None or _mod_revision.is_null(revid):
944
1467
            fmt_revid = ''
945
1468
        else:
946
1469
            fmt_revid = revid
975
1498
 
976
1499
    def get_physical_lock_status(self):
977
1500
        """See Repository.get_physical_lock_status()."""
978
 
        # should be an API call to the server.
979
 
        self._ensure_real()
980
 
        return self._real_repository.get_physical_lock_status()
 
1501
        path = self.bzrdir._path_for_remote_call(self._client)
 
1502
        try:
 
1503
            response = self._call('Repository.get_physical_lock_status', path)
 
1504
        except errors.UnknownSmartMethod:
 
1505
            self._ensure_real()
 
1506
            return self._real_repository.get_physical_lock_status()
 
1507
        if response[0] not in ('yes', 'no'):
 
1508
            raise errors.UnexpectedSmartServerResponse(response)
 
1509
        return (response[0] == 'yes')
981
1510
 
982
1511
    def is_in_write_group(self):
983
1512
        """Return True if there is an open write group.
984
1513
 
985
1514
        write groups are only applicable locally for the smart server..
986
1515
        """
 
1516
        if self._write_group_tokens is not None:
 
1517
            return True
987
1518
        if self._real_repository:
988
1519
            return self._real_repository.is_in_write_group()
989
1520
 
1124
1655
            self._real_repository.lock_write(self._lock_token)
1125
1656
        elif self._lock_mode == 'r':
1126
1657
            self._real_repository.lock_read()
 
1658
        if self._write_group_tokens is not None:
 
1659
            # if we are already in a write group, resume it
 
1660
            self._real_repository.resume_write_group(self._write_group_tokens)
 
1661
            self._write_group_tokens = None
1127
1662
 
1128
1663
    def start_write_group(self):
1129
1664
        """Start a write group on the decorated repository.
1133
1668
        for older plugins that don't use e.g. the CommitBuilder
1134
1669
        facility.
1135
1670
        """
1136
 
        self._ensure_real()
1137
 
        return self._real_repository.start_write_group()
 
1671
        if self._real_repository:
 
1672
            self._ensure_real()
 
1673
            return self._real_repository.start_write_group()
 
1674
        if not self.is_write_locked():
 
1675
            raise errors.NotWriteLocked(self)
 
1676
        if self._write_group_tokens is not None:
 
1677
            raise errors.BzrError('already in a write group')
 
1678
        path = self.bzrdir._path_for_remote_call(self._client)
 
1679
        try:
 
1680
            response = self._call('Repository.start_write_group', path,
 
1681
                self._lock_token)
 
1682
        except (errors.UnknownSmartMethod, errors.UnsuspendableWriteGroup):
 
1683
            self._ensure_real()
 
1684
            return self._real_repository.start_write_group()
 
1685
        if response[0] != 'ok':
 
1686
            raise errors.UnexpectedSmartServerResponse(response)
 
1687
        self._write_group_tokens = response[1]
1138
1688
 
1139
1689
    def _unlock(self, token):
1140
1690
        path = self.bzrdir._path_for_remote_call(self._client)
1167
1717
            # This is just to let the _real_repository stay up to date.
1168
1718
            if self._real_repository is not None:
1169
1719
                self._real_repository.unlock()
 
1720
            elif self._write_group_tokens is not None:
 
1721
                self.abort_write_group()
1170
1722
        finally:
1171
1723
            # The rpc-level lock should be released even if there was a
1172
1724
            # problem releasing the vfs-based lock.
1184
1736
 
1185
1737
    def break_lock(self):
1186
1738
        # should hand off to the network
1187
 
        self._ensure_real()
1188
 
        return self._real_repository.break_lock()
 
1739
        path = self.bzrdir._path_for_remote_call(self._client)
 
1740
        try:
 
1741
            response = self._call("Repository.break_lock", path)
 
1742
        except errors.UnknownSmartMethod:
 
1743
            self._ensure_real()
 
1744
            return self._real_repository.break_lock()
 
1745
        if response != ('ok',):
 
1746
            raise errors.UnexpectedSmartServerResponse(response)
1189
1747
 
1190
1748
    def _get_tarball(self, compression):
1191
1749
        """Return a TemporaryFile containing a repository tarball.
1209
1767
            return t
1210
1768
        raise errors.UnexpectedSmartServerResponse(response)
1211
1769
 
 
1770
    @needs_read_lock
1212
1771
    def sprout(self, to_bzrdir, revision_id=None):
1213
 
        # TODO: Option to control what format is created?
1214
 
        self._ensure_real()
1215
 
        dest_repo = self._real_repository._format.initialize(to_bzrdir,
1216
 
                                                             shared=False)
 
1772
        """Create a descendent repository for new development.
 
1773
 
 
1774
        Unlike clone, this does not copy the settings of the repository.
 
1775
        """
 
1776
        dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
1217
1777
        dest_repo.fetch(self, revision_id=revision_id)
1218
1778
        return dest_repo
1219
1779
 
 
1780
    def _create_sprouting_repo(self, a_bzrdir, shared):
 
1781
        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
 
1782
            # use target default format.
 
1783
            dest_repo = a_bzrdir.create_repository()
 
1784
        else:
 
1785
            # Most control formats need the repository to be specifically
 
1786
            # created, but on some old all-in-one formats it's not needed
 
1787
            try:
 
1788
                dest_repo = self._format.initialize(a_bzrdir, shared=shared)
 
1789
            except errors.UninitializableFormat:
 
1790
                dest_repo = a_bzrdir.open_repository()
 
1791
        return dest_repo
 
1792
 
1220
1793
    ### These methods are just thin shims to the VFS object for now.
1221
1794
 
 
1795
    @needs_read_lock
1222
1796
    def revision_tree(self, revision_id):
1223
 
        self._ensure_real()
1224
 
        return self._real_repository.revision_tree(revision_id)
 
1797
        revision_id = _mod_revision.ensure_null(revision_id)
 
1798
        if revision_id == _mod_revision.NULL_REVISION:
 
1799
            return InventoryRevisionTree(self,
 
1800
                Inventory(root_id=None), _mod_revision.NULL_REVISION)
 
1801
        else:
 
1802
            return list(self.revision_trees([revision_id]))[0]
1225
1803
 
1226
1804
    def get_serializer_format(self):
1227
 
        self._ensure_real()
1228
 
        return self._real_repository.get_serializer_format()
 
1805
        path = self.bzrdir._path_for_remote_call(self._client)
 
1806
        try:
 
1807
            response = self._call('VersionedFileRepository.get_serializer_format',
 
1808
                path)
 
1809
        except errors.UnknownSmartMethod:
 
1810
            self._ensure_real()
 
1811
            return self._real_repository.get_serializer_format()
 
1812
        if response[0] != 'ok':
 
1813
            raise errors.UnexpectedSmartServerResponse(response)
 
1814
        return response[1]
1229
1815
 
1230
1816
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1231
1817
                           timezone=None, committer=None, revprops=None,
1232
 
                           revision_id=None):
1233
 
        # FIXME: It ought to be possible to call this without immediately
1234
 
        # triggering _ensure_real.  For now it's the easiest thing to do.
1235
 
        self._ensure_real()
1236
 
        real_repo = self._real_repository
1237
 
        builder = real_repo.get_commit_builder(branch, parents,
1238
 
                config, timestamp=timestamp, timezone=timezone,
1239
 
                committer=committer, revprops=revprops, revision_id=revision_id)
1240
 
        return builder
 
1818
                           revision_id=None, lossy=False):
 
1819
        """Obtain a CommitBuilder for this repository.
 
1820
 
 
1821
        :param branch: Branch to commit to.
 
1822
        :param parents: Revision ids of the parents of the new revision.
 
1823
        :param config: Configuration to use.
 
1824
        :param timestamp: Optional timestamp recorded for commit.
 
1825
        :param timezone: Optional timezone for timestamp.
 
1826
        :param committer: Optional committer to set for commit.
 
1827
        :param revprops: Optional dictionary of revision properties.
 
1828
        :param revision_id: Optional revision id.
 
1829
        :param lossy: Whether to discard data that can not be natively
 
1830
            represented, when pushing to a foreign VCS
 
1831
        """
 
1832
        if self._fallback_repositories and not self._format.supports_chks:
 
1833
            raise errors.BzrError("Cannot commit directly to a stacked branch"
 
1834
                " in pre-2a formats. See "
 
1835
                "https://bugs.launchpad.net/bzr/+bug/375013 for details.")
 
1836
        if self._format.rich_root_data:
 
1837
            commit_builder_kls = vf_repository.VersionedFileRootCommitBuilder
 
1838
        else:
 
1839
            commit_builder_kls = vf_repository.VersionedFileCommitBuilder
 
1840
        result = commit_builder_kls(self, parents, config,
 
1841
            timestamp, timezone, committer, revprops, revision_id,
 
1842
            lossy)
 
1843
        self.start_write_group()
 
1844
        return result
1241
1845
 
1242
1846
    def add_fallback_repository(self, repository):
1243
1847
        """Add a repository to use for looking up data not held locally.
1250
1854
        # We need to accumulate additional repositories here, to pass them in
1251
1855
        # on various RPC's.
1252
1856
        #
 
1857
        # Make the check before we lock: this raises an exception.
 
1858
        self._check_fallback_repository(repository)
1253
1859
        if self.is_locked():
1254
1860
            # We will call fallback.unlock() when we transition to the unlocked
1255
1861
            # state, so always add a lock here. If a caller passes us a locked
1256
1862
            # repository, they are responsible for unlocking it later.
1257
1863
            repository.lock_read()
1258
 
        self._check_fallback_repository(repository)
1259
1864
        self._fallback_repositories.append(repository)
1260
1865
        # If self._real_repository was parameterised already (e.g. because a
1261
1866
        # _real_branch had its get_stacked_on_url method called), then the
1287
1892
            delta, new_revision_id, parents, basis_inv=basis_inv,
1288
1893
            propagate_caches=propagate_caches)
1289
1894
 
1290
 
    def add_revision(self, rev_id, rev, inv=None, config=None):
1291
 
        self._ensure_real()
1292
 
        return self._real_repository.add_revision(
1293
 
            rev_id, rev, inv=inv, config=config)
 
1895
    def add_revision(self, revision_id, rev, inv=None):
 
1896
        _mod_revision.check_not_reserved_id(revision_id)
 
1897
        key = (revision_id,)
 
1898
        # check inventory present
 
1899
        if not self.inventories.get_parent_map([key]):
 
1900
            if inv is None:
 
1901
                raise errors.WeaveRevisionNotPresent(revision_id,
 
1902
                                                     self.inventories)
 
1903
            else:
 
1904
                # yes, this is not suitable for adding with ghosts.
 
1905
                rev.inventory_sha1 = self.add_inventory(revision_id, inv,
 
1906
                                                        rev.parent_ids)
 
1907
        else:
 
1908
            rev.inventory_sha1 = self.inventories.get_sha1s([key])[key]
 
1909
        self._add_revision(rev)
 
1910
 
 
1911
    def _add_revision(self, rev):
 
1912
        if self._real_repository is not None:
 
1913
            return self._real_repository._add_revision(rev)
 
1914
        text = self._serializer.write_revision_to_string(rev)
 
1915
        key = (rev.revision_id,)
 
1916
        parents = tuple((parent,) for parent in rev.parent_ids)
 
1917
        self._write_group_tokens, missing_keys = self._get_sink().insert_stream(
 
1918
            [('revisions', [FulltextContentFactory(key, parents, None, text)])],
 
1919
            self._format, self._write_group_tokens)
1294
1920
 
1295
1921
    @needs_read_lock
1296
1922
    def get_inventory(self, revision_id):
 
1923
        return list(self.iter_inventories([revision_id]))[0]
 
1924
 
 
1925
    def _iter_inventories_rpc(self, revision_ids, ordering):
 
1926
        if ordering is None:
 
1927
            ordering = 'unordered'
 
1928
        path = self.bzrdir._path_for_remote_call(self._client)
 
1929
        body = "\n".join(revision_ids)
 
1930
        response_tuple, response_handler = (
 
1931
            self._call_with_body_bytes_expecting_body(
 
1932
                "VersionedFileRepository.get_inventories",
 
1933
                (path, ordering), body))
 
1934
        if response_tuple[0] != "ok":
 
1935
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
1936
        deserializer = inventory_delta.InventoryDeltaDeserializer()
 
1937
        byte_stream = response_handler.read_streamed_body()
 
1938
        decoded = smart_repo._byte_stream_to_stream(byte_stream)
 
1939
        if decoded is None:
 
1940
            # no results whatsoever
 
1941
            return
 
1942
        src_format, stream = decoded
 
1943
        if src_format.network_name() != self._format.network_name():
 
1944
            raise AssertionError(
 
1945
                "Mismatched RemoteRepository and stream src %r, %r" % (
 
1946
                src_format.network_name(), self._format.network_name()))
 
1947
        # ignore the src format, it's not really relevant
 
1948
        prev_inv = Inventory(root_id=None,
 
1949
            revision_id=_mod_revision.NULL_REVISION)
 
1950
        # there should be just one substream, with inventory deltas
 
1951
        substream_kind, substream = stream.next()
 
1952
        if substream_kind != "inventory-deltas":
 
1953
            raise AssertionError(
 
1954
                 "Unexpected stream %r received" % substream_kind)
 
1955
        for record in substream:
 
1956
            (parent_id, new_id, versioned_root, tree_references, invdelta) = (
 
1957
                deserializer.parse_text_bytes(record.get_bytes_as("fulltext")))
 
1958
            if parent_id != prev_inv.revision_id:
 
1959
                raise AssertionError("invalid base %r != %r" % (parent_id,
 
1960
                    prev_inv.revision_id))
 
1961
            inv = prev_inv.create_by_apply_delta(invdelta, new_id)
 
1962
            yield inv, inv.revision_id
 
1963
            prev_inv = inv
 
1964
 
 
1965
    def _iter_inventories_vfs(self, revision_ids, ordering=None):
1297
1966
        self._ensure_real()
1298
 
        return self._real_repository.get_inventory(revision_id)
 
1967
        return self._real_repository._iter_inventories(revision_ids, ordering)
1299
1968
 
1300
1969
    def iter_inventories(self, revision_ids, ordering=None):
1301
 
        self._ensure_real()
1302
 
        return self._real_repository.iter_inventories(revision_ids, ordering)
 
1970
        """Get many inventories by revision_ids.
 
1971
 
 
1972
        This will buffer some or all of the texts used in constructing the
 
1973
        inventories in memory, but will only parse a single inventory at a
 
1974
        time.
 
1975
 
 
1976
        :param revision_ids: The expected revision ids of the inventories.
 
1977
        :param ordering: optional ordering, e.g. 'topological'.  If not
 
1978
            specified, the order of revision_ids will be preserved (by
 
1979
            buffering if necessary).
 
1980
        :return: An iterator of inventories.
 
1981
        """
 
1982
        if ((None in revision_ids)
 
1983
            or (_mod_revision.NULL_REVISION in revision_ids)):
 
1984
            raise ValueError('cannot get null revision inventory')
 
1985
        for inv, revid in self._iter_inventories(revision_ids, ordering):
 
1986
            if inv is None:
 
1987
                raise errors.NoSuchRevision(self, revid)
 
1988
            yield inv
 
1989
 
 
1990
    def _iter_inventories(self, revision_ids, ordering=None):
 
1991
        if len(revision_ids) == 0:
 
1992
            return
 
1993
        missing = set(revision_ids)
 
1994
        if ordering is None:
 
1995
            order_as_requested = True
 
1996
            invs = {}
 
1997
            order = list(revision_ids)
 
1998
            order.reverse()
 
1999
            next_revid = order.pop()
 
2000
        else:
 
2001
            order_as_requested = False
 
2002
            if ordering != 'unordered' and self._fallback_repositories:
 
2003
                raise ValueError('unsupported ordering %r' % ordering)
 
2004
        iter_inv_fns = [self._iter_inventories_rpc] + [
 
2005
            fallback._iter_inventories for fallback in
 
2006
            self._fallback_repositories]
 
2007
        try:
 
2008
            for iter_inv in iter_inv_fns:
 
2009
                request = [revid for revid in revision_ids if revid in missing]
 
2010
                for inv, revid in iter_inv(request, ordering):
 
2011
                    if inv is None:
 
2012
                        continue
 
2013
                    missing.remove(inv.revision_id)
 
2014
                    if ordering != 'unordered':
 
2015
                        invs[revid] = inv
 
2016
                    else:
 
2017
                        yield inv, revid
 
2018
                if order_as_requested:
 
2019
                    # Yield as many results as we can while preserving order.
 
2020
                    while next_revid in invs:
 
2021
                        inv = invs.pop(next_revid)
 
2022
                        yield inv, inv.revision_id
 
2023
                        try:
 
2024
                            next_revid = order.pop()
 
2025
                        except IndexError:
 
2026
                            # We still want to fully consume the stream, just
 
2027
                            # in case it is not actually finished at this point
 
2028
                            next_revid = None
 
2029
                            break
 
2030
        except errors.UnknownSmartMethod:
 
2031
            for inv, revid in self._iter_inventories_vfs(revision_ids, ordering):
 
2032
                yield inv, revid
 
2033
            return
 
2034
        # Report missing
 
2035
        if order_as_requested:
 
2036
            if next_revid is not None:
 
2037
                yield None, next_revid
 
2038
            while order:
 
2039
                revid = order.pop()
 
2040
                yield invs.get(revid), revid
 
2041
        else:
 
2042
            while missing:
 
2043
                yield None, missing.pop()
1303
2044
 
1304
2045
    @needs_read_lock
1305
2046
    def get_revision(self, revision_id):
1306
 
        self._ensure_real()
1307
 
        return self._real_repository.get_revision(revision_id)
 
2047
        return self.get_revisions([revision_id])[0]
1308
2048
 
1309
2049
    def get_transaction(self):
1310
2050
        self._ensure_real()
1312
2052
 
1313
2053
    @needs_read_lock
1314
2054
    def clone(self, a_bzrdir, revision_id=None):
1315
 
        self._ensure_real()
1316
 
        return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
 
2055
        dest_repo = self._create_sprouting_repo(
 
2056
            a_bzrdir, shared=self.is_shared())
 
2057
        self.copy_content_into(dest_repo, revision_id)
 
2058
        return dest_repo
1317
2059
 
1318
2060
    def make_working_trees(self):
1319
2061
        """See Repository.make_working_trees"""
1320
 
        self._ensure_real()
1321
 
        return self._real_repository.make_working_trees()
 
2062
        path = self.bzrdir._path_for_remote_call(self._client)
 
2063
        try:
 
2064
            response = self._call('Repository.make_working_trees', path)
 
2065
        except errors.UnknownSmartMethod:
 
2066
            self._ensure_real()
 
2067
            return self._real_repository.make_working_trees()
 
2068
        if response[0] not in ('yes', 'no'):
 
2069
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2070
        return response[0] == 'yes'
1322
2071
 
1323
2072
    def refresh_data(self):
1324
2073
        """Re-read any data needed to synchronise with disk.
1333
2082
        """
1334
2083
        if self._real_repository is not None:
1335
2084
            self._real_repository.refresh_data()
 
2085
        # Refresh the parents cache for this object
 
2086
        self._unstacked_provider.disable_cache()
 
2087
        self._unstacked_provider.enable_cache()
1336
2088
 
1337
2089
    def revision_ids_to_search_result(self, result_set):
1338
2090
        """Convert a set of revision ids to a graph SearchResult."""
1343
2095
        included_keys = result_set.intersection(result_parents)
1344
2096
        start_keys = result_set.difference(included_keys)
1345
2097
        exclude_keys = result_parents.difference(result_set)
1346
 
        result = graph.SearchResult(start_keys, exclude_keys,
 
2098
        result = vf_search.SearchResult(start_keys, exclude_keys,
1347
2099
            len(result_set), result_set)
1348
2100
        return result
1349
2101
 
1350
2102
    @needs_read_lock
1351
2103
    def search_missing_revision_ids(self, other,
1352
2104
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
1353
 
            find_ghosts=True, revision_ids=None, if_present_ids=None):
 
2105
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
2106
            limit=None):
1354
2107
        """Return the revision ids that other has that this does not.
1355
2108
 
1356
2109
        These are returned in topological order.
1367
2120
                    'revision_ids is mutually exclusive with revision_id')
1368
2121
            if revision_id is not None:
1369
2122
                revision_ids = [revision_id]
1370
 
        inter_repo = repository.InterRepository.get(other, self)
 
2123
        inter_repo = _mod_repository.InterRepository.get(other, self)
1371
2124
        return inter_repo.search_missing_revision_ids(
1372
2125
            find_ghosts=find_ghosts, revision_ids=revision_ids,
1373
 
            if_present_ids=if_present_ids)
 
2126
            if_present_ids=if_present_ids, limit=limit)
1374
2127
 
1375
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
2128
    def fetch(self, source, revision_id=None, find_ghosts=False,
1376
2129
            fetch_spec=None):
1377
2130
        # No base implementation to use as RemoteRepository is not a subclass
1378
2131
        # of Repository; so this is a copy of Repository.fetch().
1389
2142
            # check that last_revision is in 'from' and then return a
1390
2143
            # no-operation.
1391
2144
            if (revision_id is not None and
1392
 
                not revision.is_null(revision_id)):
 
2145
                not _mod_revision.is_null(revision_id)):
1393
2146
                self.get_revision(revision_id)
1394
2147
            return 0, []
1395
2148
        # if there is no specific appropriate InterRepository, this will get
1396
2149
        # the InterRepository base class, which raises an
1397
2150
        # IncompatibleRepositories when asked to fetch.
1398
 
        inter = repository.InterRepository.get(source, self)
1399
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
2151
        inter = _mod_repository.InterRepository.get(source, self)
 
2152
        if (fetch_spec is not None and
 
2153
            not getattr(inter, "supports_fetch_spec", False)):
 
2154
            raise errors.UnsupportedOperation(
 
2155
                "fetch_spec not supported for %r" % inter)
 
2156
        return inter.fetch(revision_id=revision_id,
1400
2157
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1401
2158
 
1402
2159
    def create_bundle(self, target, base, fileobj, format=None):
1404
2161
        self._real_repository.create_bundle(target, base, fileobj, format)
1405
2162
 
1406
2163
    @needs_read_lock
 
2164
    @symbol_versioning.deprecated_method(
 
2165
        symbol_versioning.deprecated_in((2, 4, 0)))
1407
2166
    def get_ancestry(self, revision_id, topo_sorted=True):
1408
2167
        self._ensure_real()
1409
2168
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1417
2176
        return self._real_repository._get_versioned_file_checker(
1418
2177
            revisions, revision_versions_cache)
1419
2178
 
 
2179
    def _iter_files_bytes_rpc(self, desired_files, absent):
 
2180
        path = self.bzrdir._path_for_remote_call(self._client)
 
2181
        lines = []
 
2182
        identifiers = []
 
2183
        for (file_id, revid, identifier) in desired_files:
 
2184
            lines.append("%s\0%s" % (
 
2185
                osutils.safe_file_id(file_id),
 
2186
                osutils.safe_revision_id(revid)))
 
2187
            identifiers.append(identifier)
 
2188
        (response_tuple, response_handler) = (
 
2189
            self._call_with_body_bytes_expecting_body(
 
2190
            "Repository.iter_files_bytes", (path, ), "\n".join(lines)))
 
2191
        if response_tuple != ('ok', ):
 
2192
            response_handler.cancel_read_body()
 
2193
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2194
        byte_stream = response_handler.read_streamed_body()
 
2195
        def decompress_stream(start, byte_stream, unused):
 
2196
            decompressor = zlib.decompressobj()
 
2197
            yield decompressor.decompress(start)
 
2198
            while decompressor.unused_data == "":
 
2199
                try:
 
2200
                    data = byte_stream.next()
 
2201
                except StopIteration:
 
2202
                    break
 
2203
                yield decompressor.decompress(data)
 
2204
            yield decompressor.flush()
 
2205
            unused.append(decompressor.unused_data)
 
2206
        unused = ""
 
2207
        while True:
 
2208
            while not "\n" in unused:
 
2209
                unused += byte_stream.next()
 
2210
            header, rest = unused.split("\n", 1)
 
2211
            args = header.split("\0")
 
2212
            if args[0] == "absent":
 
2213
                absent[identifiers[int(args[3])]] = (args[1], args[2])
 
2214
                unused = rest
 
2215
                continue
 
2216
            elif args[0] == "ok":
 
2217
                idx = int(args[1])
 
2218
            else:
 
2219
                raise errors.UnexpectedSmartServerResponse(args)
 
2220
            unused_chunks = []
 
2221
            yield (identifiers[idx],
 
2222
                decompress_stream(rest, byte_stream, unused_chunks))
 
2223
            unused = "".join(unused_chunks)
 
2224
 
1420
2225
    def iter_files_bytes(self, desired_files):
1421
2226
        """See Repository.iter_file_bytes.
1422
2227
        """
1423
 
        self._ensure_real()
1424
 
        return self._real_repository.iter_files_bytes(desired_files)
 
2228
        try:
 
2229
            absent = {}
 
2230
            for (identifier, bytes_iterator) in self._iter_files_bytes_rpc(
 
2231
                    desired_files, absent):
 
2232
                yield identifier, bytes_iterator
 
2233
            for fallback in self._fallback_repositories:
 
2234
                if not absent:
 
2235
                    break
 
2236
                desired_files = [(key[0], key[1], identifier) for
 
2237
                    (identifier, key) in absent.iteritems()]
 
2238
                for (identifier, bytes_iterator) in fallback.iter_files_bytes(desired_files):
 
2239
                    del absent[identifier]
 
2240
                    yield identifier, bytes_iterator
 
2241
            if absent:
 
2242
                # There may be more missing items, but raise an exception
 
2243
                # for just one.
 
2244
                missing_identifier = absent.keys()[0]
 
2245
                missing_key = absent[missing_identifier]
 
2246
                raise errors.RevisionNotPresent(revision_id=missing_key[1],
 
2247
                    file_id=missing_key[0])
 
2248
        except errors.UnknownSmartMethod:
 
2249
            self._ensure_real()
 
2250
            for (identifier, bytes_iterator) in (
 
2251
                self._real_repository.iter_files_bytes(desired_files)):
 
2252
                yield identifier, bytes_iterator
 
2253
 
 
2254
    def get_cached_parent_map(self, revision_ids):
 
2255
        """See bzrlib.CachingParentsProvider.get_cached_parent_map"""
 
2256
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
1425
2257
 
1426
2258
    def get_parent_map(self, revision_ids):
1427
2259
        """See bzrlib.Graph.get_parent_map()."""
1486
2318
        if parents_map is None:
1487
2319
            # Repository is not locked, so there's no cache.
1488
2320
            parents_map = {}
1489
 
        # start_set is all the keys in the cache
1490
 
        start_set = set(parents_map)
1491
 
        # result set is all the references to keys in the cache
1492
 
        result_parents = set()
1493
 
        for parents in parents_map.itervalues():
1494
 
            result_parents.update(parents)
1495
 
        stop_keys = result_parents.difference(start_set)
1496
 
        # We don't need to send ghosts back to the server as a position to
1497
 
        # stop either.
1498
 
        stop_keys.difference_update(self._unstacked_provider.missing_keys)
1499
 
        key_count = len(parents_map)
1500
 
        if (NULL_REVISION in result_parents
1501
 
            and NULL_REVISION in self._unstacked_provider.missing_keys):
1502
 
            # If we pruned NULL_REVISION from the stop_keys because it's also
1503
 
            # in our cache of "missing" keys we need to increment our key count
1504
 
            # by 1, because the reconsitituted SearchResult on the server will
1505
 
            # still consider NULL_REVISION to be an included key.
1506
 
            key_count += 1
1507
 
        included_keys = start_set.intersection(result_parents)
1508
 
        start_set.difference_update(included_keys)
 
2321
        if _DEFAULT_SEARCH_DEPTH <= 0:
 
2322
            (start_set, stop_keys,
 
2323
             key_count) = vf_search.search_result_from_parent_map(
 
2324
                parents_map, self._unstacked_provider.missing_keys)
 
2325
        else:
 
2326
            (start_set, stop_keys,
 
2327
             key_count) = vf_search.limited_search_result_from_parent_map(
 
2328
                parents_map, self._unstacked_provider.missing_keys,
 
2329
                keys, depth=_DEFAULT_SEARCH_DEPTH)
1509
2330
        recipe = ('manual', start_set, stop_keys, key_count)
1510
2331
        body = self._serialise_search_recipe(recipe)
1511
2332
        path = self.bzrdir._path_for_remote_call(self._client)
1560
2381
 
1561
2382
    @needs_read_lock
1562
2383
    def get_signature_text(self, revision_id):
1563
 
        self._ensure_real()
1564
 
        return self._real_repository.get_signature_text(revision_id)
 
2384
        path = self.bzrdir._path_for_remote_call(self._client)
 
2385
        try:
 
2386
            response_tuple, response_handler = self._call_expecting_body(
 
2387
                'Repository.get_revision_signature_text', path, revision_id)
 
2388
        except errors.UnknownSmartMethod:
 
2389
            self._ensure_real()
 
2390
            return self._real_repository.get_signature_text(revision_id)
 
2391
        except errors.NoSuchRevision, err:
 
2392
            for fallback in self._fallback_repositories:
 
2393
                try:
 
2394
                    return fallback.get_signature_text(revision_id)
 
2395
                except errors.NoSuchRevision:
 
2396
                    pass
 
2397
            raise err
 
2398
        else:
 
2399
            if response_tuple[0] != 'ok':
 
2400
                raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2401
            return response_handler.read_body_bytes()
1565
2402
 
1566
2403
    @needs_read_lock
1567
2404
    def _get_inventory_xml(self, revision_id):
 
2405
        # This call is used by older working tree formats,
 
2406
        # which stored a serialized basis inventory.
1568
2407
        self._ensure_real()
1569
2408
        return self._real_repository._get_inventory_xml(revision_id)
1570
2409
 
 
2410
    @needs_write_lock
1571
2411
    def reconcile(self, other=None, thorough=False):
1572
 
        self._ensure_real()
1573
 
        return self._real_repository.reconcile(other=other, thorough=thorough)
 
2412
        from bzrlib.reconcile import RepoReconciler
 
2413
        path = self.bzrdir._path_for_remote_call(self._client)
 
2414
        try:
 
2415
            response, handler = self._call_expecting_body(
 
2416
                'Repository.reconcile', path, self._lock_token)
 
2417
        except (errors.UnknownSmartMethod, errors.TokenLockingNotSupported):
 
2418
            self._ensure_real()
 
2419
            return self._real_repository.reconcile(other=other, thorough=thorough)
 
2420
        if response != ('ok', ):
 
2421
            raise errors.UnexpectedSmartServerResponse(response)
 
2422
        body = handler.read_body_bytes()
 
2423
        result = RepoReconciler(self)
 
2424
        for line in body.split('\n'):
 
2425
            if not line:
 
2426
                continue
 
2427
            key, val_text = line.split(':')
 
2428
            if key == "garbage_inventories":
 
2429
                result.garbage_inventories = int(val_text)
 
2430
            elif key == "inconsistent_parents":
 
2431
                result.inconsistent_parents = int(val_text)
 
2432
            else:
 
2433
                mutter("unknown reconcile key %r" % key)
 
2434
        return result
1574
2435
 
1575
2436
    def all_revision_ids(self):
1576
 
        self._ensure_real()
1577
 
        return self._real_repository.all_revision_ids()
 
2437
        path = self.bzrdir._path_for_remote_call(self._client)
 
2438
        try:
 
2439
            response_tuple, response_handler = self._call_expecting_body(
 
2440
                "Repository.all_revision_ids", path)
 
2441
        except errors.UnknownSmartMethod:
 
2442
            self._ensure_real()
 
2443
            return self._real_repository.all_revision_ids()
 
2444
        if response_tuple != ("ok", ):
 
2445
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2446
        revids = set(response_handler.read_body_bytes().splitlines())
 
2447
        for fallback in self._fallback_repositories:
 
2448
            revids.update(set(fallback.all_revision_ids()))
 
2449
        return list(revids)
 
2450
 
 
2451
    def _filtered_revision_trees(self, revision_ids, file_ids):
 
2452
        """Return Tree for a revision on this branch with only some files.
 
2453
 
 
2454
        :param revision_ids: a sequence of revision-ids;
 
2455
          a revision-id may not be None or 'null:'
 
2456
        :param file_ids: if not None, the result is filtered
 
2457
          so that only those file-ids, their parents and their
 
2458
          children are included.
 
2459
        """
 
2460
        inventories = self.iter_inventories(revision_ids)
 
2461
        for inv in inventories:
 
2462
            # Should we introduce a FilteredRevisionTree class rather
 
2463
            # than pre-filter the inventory here?
 
2464
            filtered_inv = inv.filter(file_ids)
 
2465
            yield InventoryRevisionTree(self, filtered_inv, filtered_inv.revision_id)
1578
2466
 
1579
2467
    @needs_read_lock
1580
2468
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1581
 
        self._ensure_real()
1582
 
        return self._real_repository.get_deltas_for_revisions(revisions,
1583
 
            specific_fileids=specific_fileids)
 
2469
        medium = self._client._medium
 
2470
        if medium._is_remote_before((1, 2)):
 
2471
            self._ensure_real()
 
2472
            for delta in self._real_repository.get_deltas_for_revisions(
 
2473
                    revisions, specific_fileids):
 
2474
                yield delta
 
2475
            return
 
2476
        # Get the revision-ids of interest
 
2477
        required_trees = set()
 
2478
        for revision in revisions:
 
2479
            required_trees.add(revision.revision_id)
 
2480
            required_trees.update(revision.parent_ids[:1])
 
2481
 
 
2482
        # Get the matching filtered trees. Note that it's more
 
2483
        # efficient to pass filtered trees to changes_from() rather
 
2484
        # than doing the filtering afterwards. changes_from() could
 
2485
        # arguably do the filtering itself but it's path-based, not
 
2486
        # file-id based, so filtering before or afterwards is
 
2487
        # currently easier.
 
2488
        if specific_fileids is None:
 
2489
            trees = dict((t.get_revision_id(), t) for
 
2490
                t in self.revision_trees(required_trees))
 
2491
        else:
 
2492
            trees = dict((t.get_revision_id(), t) for
 
2493
                t in self._filtered_revision_trees(required_trees,
 
2494
                specific_fileids))
 
2495
 
 
2496
        # Calculate the deltas
 
2497
        for revision in revisions:
 
2498
            if not revision.parent_ids:
 
2499
                old_tree = self.revision_tree(_mod_revision.NULL_REVISION)
 
2500
            else:
 
2501
                old_tree = trees[revision.parent_ids[0]]
 
2502
            yield trees[revision.revision_id].changes_from(old_tree)
1584
2503
 
1585
2504
    @needs_read_lock
1586
2505
    def get_revision_delta(self, revision_id, specific_fileids=None):
1587
 
        self._ensure_real()
1588
 
        return self._real_repository.get_revision_delta(revision_id,
1589
 
            specific_fileids=specific_fileids)
 
2506
        r = self.get_revision(revision_id)
 
2507
        return list(self.get_deltas_for_revisions([r],
 
2508
            specific_fileids=specific_fileids))[0]
1590
2509
 
1591
2510
    @needs_read_lock
1592
2511
    def revision_trees(self, revision_ids):
1593
 
        self._ensure_real()
1594
 
        return self._real_repository.revision_trees(revision_ids)
 
2512
        inventories = self.iter_inventories(revision_ids)
 
2513
        for inv in inventories:
 
2514
            yield InventoryRevisionTree(self, inv, inv.revision_id)
1595
2515
 
1596
2516
    @needs_read_lock
1597
2517
    def get_revision_reconcile(self, revision_id):
1605
2525
            callback_refs=callback_refs, check_repo=check_repo)
1606
2526
 
1607
2527
    def copy_content_into(self, destination, revision_id=None):
1608
 
        self._ensure_real()
1609
 
        return self._real_repository.copy_content_into(
1610
 
            destination, revision_id=revision_id)
 
2528
        """Make a complete copy of the content in self into destination.
 
2529
 
 
2530
        This is a destructive operation! Do not use it on existing
 
2531
        repositories.
 
2532
        """
 
2533
        interrepo = _mod_repository.InterRepository.get(self, destination)
 
2534
        return interrepo.copy_content(revision_id)
1611
2535
 
1612
2536
    def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1613
2537
        # get a tarball of the remote repository, and copy from that into the
1614
2538
        # destination
1615
 
        from bzrlib import osutils
1616
2539
        import tarfile
1617
2540
        # TODO: Maybe a progress bar while streaming the tarball?
1618
 
        note("Copying repository content as tarball...")
 
2541
        note(gettext("Copying repository content as tarball..."))
1619
2542
        tar_file = self._get_tarball('bz2')
1620
2543
        if tar_file is None:
1621
2544
            return None
1626
2549
            tmpdir = osutils.mkdtemp()
1627
2550
            try:
1628
2551
                _extract_tar(tar, tmpdir)
1629
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
2552
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1630
2553
                tmp_repo = tmp_bzrdir.open_repository()
1631
2554
                tmp_repo.copy_content_into(destination, revision_id)
1632
2555
            finally:
1650
2573
    @needs_write_lock
1651
2574
    def pack(self, hint=None, clean_obsolete_packs=False):
1652
2575
        """Compress the data within the repository.
1653
 
 
1654
 
        This is not currently implemented within the smart server.
1655
2576
        """
1656
 
        self._ensure_real()
1657
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
2577
        if hint is None:
 
2578
            body = ""
 
2579
        else:
 
2580
            body = "".join([l+"\n" for l in hint])
 
2581
        path = self.bzrdir._path_for_remote_call(self._client)
 
2582
        try:
 
2583
            response, handler = self._call_with_body_bytes_expecting_body(
 
2584
                'Repository.pack', (path, self._lock_token,
 
2585
                    str(clean_obsolete_packs)), body)
 
2586
        except errors.UnknownSmartMethod:
 
2587
            self._ensure_real()
 
2588
            return self._real_repository.pack(hint=hint,
 
2589
                clean_obsolete_packs=clean_obsolete_packs)
 
2590
        handler.cancel_read_body()
 
2591
        if response != ('ok', ):
 
2592
            raise errors.UnexpectedSmartServerResponse(response)
1658
2593
 
1659
2594
    @property
1660
2595
    def revisions(self):
1661
2596
        """Decorate the real repository for now.
1662
2597
 
1663
 
        In the short term this should become a real object to intercept graph
1664
 
        lookups.
1665
 
 
1666
2598
        In the long term a full blown network facility is needed.
1667
2599
        """
1668
2600
        self._ensure_real()
1696
2628
 
1697
2629
    @needs_write_lock
1698
2630
    def sign_revision(self, revision_id, gpg_strategy):
1699
 
        self._ensure_real()
1700
 
        return self._real_repository.sign_revision(revision_id, gpg_strategy)
 
2631
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2632
        plaintext = testament.as_short_text()
 
2633
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1701
2634
 
1702
2635
    @property
1703
2636
    def texts(self):
1709
2642
        self._ensure_real()
1710
2643
        return self._real_repository.texts
1711
2644
 
 
2645
    def _iter_revisions_rpc(self, revision_ids):
 
2646
        body = "\n".join(revision_ids)
 
2647
        path = self.bzrdir._path_for_remote_call(self._client)
 
2648
        response_tuple, response_handler = (
 
2649
            self._call_with_body_bytes_expecting_body(
 
2650
            "Repository.iter_revisions", (path, ), body))
 
2651
        if response_tuple[0] != "ok":
 
2652
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2653
        serializer_format = response_tuple[1]
 
2654
        serializer = serializer_format_registry.get(serializer_format)
 
2655
        byte_stream = response_handler.read_streamed_body()
 
2656
        decompressor = zlib.decompressobj()
 
2657
        chunks = []
 
2658
        for bytes in byte_stream:
 
2659
            chunks.append(decompressor.decompress(bytes))
 
2660
            if decompressor.unused_data != "":
 
2661
                chunks.append(decompressor.flush())
 
2662
                yield serializer.read_revision_from_string("".join(chunks))
 
2663
                unused = decompressor.unused_data
 
2664
                decompressor = zlib.decompressobj()
 
2665
                chunks = [decompressor.decompress(unused)]
 
2666
        chunks.append(decompressor.flush())
 
2667
        text = "".join(chunks)
 
2668
        if text != "":
 
2669
            yield serializer.read_revision_from_string("".join(chunks))
 
2670
 
1712
2671
    @needs_read_lock
1713
2672
    def get_revisions(self, revision_ids):
1714
 
        self._ensure_real()
1715
 
        return self._real_repository.get_revisions(revision_ids)
 
2673
        if revision_ids is None:
 
2674
            revision_ids = self.all_revision_ids()
 
2675
        else:
 
2676
            for rev_id in revision_ids:
 
2677
                if not rev_id or not isinstance(rev_id, basestring):
 
2678
                    raise errors.InvalidRevisionId(
 
2679
                        revision_id=rev_id, branch=self)
 
2680
        try:
 
2681
            missing = set(revision_ids)
 
2682
            revs = {}
 
2683
            for rev in self._iter_revisions_rpc(revision_ids):
 
2684
                missing.remove(rev.revision_id)
 
2685
                revs[rev.revision_id] = rev
 
2686
        except errors.UnknownSmartMethod:
 
2687
            self._ensure_real()
 
2688
            return self._real_repository.get_revisions(revision_ids)
 
2689
        for fallback in self._fallback_repositories:
 
2690
            if not missing:
 
2691
                break
 
2692
            for revid in list(missing):
 
2693
                # XXX JRV 2011-11-20: It would be nice if there was a
 
2694
                # public method on Repository that could be used to query
 
2695
                # for revision objects *without* failing completely if one
 
2696
                # was missing. There is VersionedFileRepository._iter_revisions,
 
2697
                # but unfortunately that's private and not provided by
 
2698
                # all repository implementations.
 
2699
                try:
 
2700
                    revs[revid] = fallback.get_revision(revid)
 
2701
                except errors.NoSuchRevision:
 
2702
                    pass
 
2703
                else:
 
2704
                    missing.remove(revid)
 
2705
        if missing:
 
2706
            raise errors.NoSuchRevision(self, list(missing)[0])
 
2707
        return [revs[revid] for revid in revision_ids]
1716
2708
 
1717
2709
    def supports_rich_root(self):
1718
2710
        return self._format.rich_root_data
1719
2711
 
 
2712
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1720
2713
    def iter_reverse_revision_history(self, revision_id):
1721
2714
        self._ensure_real()
1722
2715
        return self._real_repository.iter_reverse_revision_history(revision_id)
1725
2718
    def _serializer(self):
1726
2719
        return self._format._serializer
1727
2720
 
 
2721
    @needs_write_lock
1728
2722
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1729
 
        self._ensure_real()
1730
 
        return self._real_repository.store_revision_signature(
1731
 
            gpg_strategy, plaintext, revision_id)
 
2723
        signature = gpg_strategy.sign(plaintext)
 
2724
        self.add_signature_text(revision_id, signature)
1732
2725
 
1733
2726
    def add_signature_text(self, revision_id, signature):
1734
 
        self._ensure_real()
1735
 
        return self._real_repository.add_signature_text(revision_id, signature)
 
2727
        if self._real_repository:
 
2728
            # If there is a real repository the write group will
 
2729
            # be in the real repository as well, so use that:
 
2730
            self._ensure_real()
 
2731
            return self._real_repository.add_signature_text(
 
2732
                revision_id, signature)
 
2733
        path = self.bzrdir._path_for_remote_call(self._client)
 
2734
        response, handler = self._call_with_body_bytes_expecting_body(
 
2735
            'Repository.add_signature_text', (path, self._lock_token,
 
2736
                revision_id) + tuple(self._write_group_tokens), signature)
 
2737
        handler.cancel_read_body()
 
2738
        self.refresh_data()
 
2739
        if response[0] != 'ok':
 
2740
            raise errors.UnexpectedSmartServerResponse(response)
 
2741
        self._write_group_tokens = response[1:]
1736
2742
 
1737
2743
    def has_signature_for_revision_id(self, revision_id):
1738
 
        self._ensure_real()
1739
 
        return self._real_repository.has_signature_for_revision_id(revision_id)
 
2744
        path = self.bzrdir._path_for_remote_call(self._client)
 
2745
        try:
 
2746
            response = self._call('Repository.has_signature_for_revision_id',
 
2747
                path, revision_id)
 
2748
        except errors.UnknownSmartMethod:
 
2749
            self._ensure_real()
 
2750
            return self._real_repository.has_signature_for_revision_id(
 
2751
                revision_id)
 
2752
        if response[0] not in ('yes', 'no'):
 
2753
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2754
        if response[0] == 'yes':
 
2755
            return True
 
2756
        for fallback in self._fallback_repositories:
 
2757
            if fallback.has_signature_for_revision_id(revision_id):
 
2758
                return True
 
2759
        return False
 
2760
 
 
2761
    @needs_read_lock
 
2762
    def verify_revision_signature(self, revision_id, gpg_strategy):
 
2763
        if not self.has_signature_for_revision_id(revision_id):
 
2764
            return gpg.SIGNATURE_NOT_SIGNED, None
 
2765
        signature = self.get_signature_text(revision_id)
 
2766
 
 
2767
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2768
        plaintext = testament.as_short_text()
 
2769
 
 
2770
        return gpg_strategy.verify(signature, plaintext)
1740
2771
 
1741
2772
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1742
2773
        self._ensure_real()
1743
2774
        return self._real_repository.item_keys_introduced_by(revision_ids,
1744
2775
            _files_pb=_files_pb)
1745
2776
 
1746
 
    def revision_graph_can_have_wrong_parents(self):
1747
 
        # The answer depends on the remote repo format.
1748
 
        self._ensure_real()
1749
 
        return self._real_repository.revision_graph_can_have_wrong_parents()
1750
 
 
1751
2777
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1752
2778
        self._ensure_real()
1753
2779
        return self._real_repository._find_inconsistent_revision_parents(
1761
2787
        providers = [self._unstacked_provider]
1762
2788
        if other is not None:
1763
2789
            providers.insert(0, other)
1764
 
        providers.extend(r._make_parents_provider() for r in
1765
 
                         self._fallback_repositories)
1766
 
        return graph.StackedParentsProvider(providers)
 
2790
        return graph.StackedParentsProvider(_LazyListJoin(
 
2791
            providers, self._fallback_repositories))
1767
2792
 
1768
2793
    def _serialise_search_recipe(self, recipe):
1769
2794
        """Serialise a graph search recipe.
1793
2818
            raise errors.UnexpectedSmartServerResponse(response)
1794
2819
 
1795
2820
 
1796
 
class RemoteStreamSink(repository.StreamSink):
 
2821
class RemoteStreamSink(vf_repository.StreamSink):
1797
2822
 
1798
2823
    def _insert_real(self, stream, src_format, resume_tokens):
1799
2824
        self.target_repo._ensure_real()
1900
2925
        self._last_substream and self._last_stream so that the stream can be
1901
2926
        resumed by _resume_stream_with_vfs.
1902
2927
        """
1903
 
                    
 
2928
 
1904
2929
        stream_iter = iter(stream)
1905
2930
        for substream_kind, substream in stream_iter:
1906
2931
            if substream_kind == 'inventory-deltas':
1909
2934
                return
1910
2935
            else:
1911
2936
                yield substream_kind, substream
1912
 
            
1913
 
 
1914
 
class RemoteStreamSource(repository.StreamSource):
 
2937
 
 
2938
 
 
2939
class RemoteStreamSource(vf_repository.StreamSource):
1915
2940
    """Stream data from a remote server."""
1916
2941
 
1917
2942
    def get_stream(self, search):
1938
2963
 
1939
2964
    def _real_stream(self, repo, search):
1940
2965
        """Get a stream for search from repo.
1941
 
        
1942
 
        This never called RemoteStreamSource.get_stream, and is a heler
1943
 
        for RemoteStreamSource._get_stream to allow getting a stream 
 
2966
 
 
2967
        This never called RemoteStreamSource.get_stream, and is a helper
 
2968
        for RemoteStreamSource._get_stream to allow getting a stream
1944
2969
        reliably whether fallback back because of old servers or trying
1945
2970
        to stream from a non-RemoteRepository (which the stacked support
1946
2971
        code will do).
1988
3013
            except errors.UnknownSmartMethod:
1989
3014
                medium._remember_remote_is_before(version)
1990
3015
            except errors.UnknownErrorFromSmartServer, e:
1991
 
                if isinstance(search, graph.EverythingResult):
 
3016
                if isinstance(search, vf_search.EverythingResult):
1992
3017
                    error_verb = e.error_from_smart_server.error_verb
1993
3018
                    if error_verb == 'BadSearch':
1994
3019
                        # Pre-2.4 servers don't support this sort of search.
2086
3111
 
2087
3112
    def _ensure_real(self):
2088
3113
        if self._custom_format is None:
2089
 
            self._custom_format = branch.network_format_registry.get(
2090
 
                self._network_name)
 
3114
            try:
 
3115
                self._custom_format = branch.network_format_registry.get(
 
3116
                    self._network_name)
 
3117
            except KeyError:
 
3118
                raise errors.UnknownFormatError(kind='branch',
 
3119
                    format=self._network_name)
2091
3120
 
2092
3121
    def get_format_description(self):
2093
3122
        self._ensure_real()
2100
3129
        return a_bzrdir.open_branch(name=name, 
2101
3130
            ignore_fallbacks=ignore_fallbacks)
2102
3131
 
2103
 
    def _vfs_initialize(self, a_bzrdir, name):
 
3132
    def _vfs_initialize(self, a_bzrdir, name, append_revisions_only):
2104
3133
        # Initialisation when using a local bzrdir object, or a non-vfs init
2105
3134
        # method is not available on the server.
2106
3135
        # self._custom_format is always set - the start of initialize ensures
2108
3137
        if isinstance(a_bzrdir, RemoteBzrDir):
2109
3138
            a_bzrdir._ensure_real()
2110
3139
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2111
 
                name)
 
3140
                name=name, append_revisions_only=append_revisions_only)
2112
3141
        else:
2113
3142
            # We assume the bzrdir is parameterised; it may not be.
2114
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
3143
            result = self._custom_format.initialize(a_bzrdir, name=name,
 
3144
                append_revisions_only=append_revisions_only)
2115
3145
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2116
3146
            not isinstance(result, RemoteBranch)):
2117
3147
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2118
3148
                                  name=name)
2119
3149
        return result
2120
3150
 
2121
 
    def initialize(self, a_bzrdir, name=None, repository=None):
 
3151
    def initialize(self, a_bzrdir, name=None, repository=None,
 
3152
                   append_revisions_only=None):
 
3153
        if name is None:
 
3154
            name = a_bzrdir._get_selected_branch()
2122
3155
        # 1) get the network name to use.
2123
3156
        if self._custom_format:
2124
3157
            network_name = self._custom_format.network_name()
2125
3158
        else:
2126
3159
            # Select the current bzrlib default and ask for that.
2127
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
3160
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
2128
3161
            reference_format = reference_bzrdir_format.get_branch_format()
2129
3162
            self._custom_format = reference_format
2130
3163
            network_name = reference_format.network_name()
2131
3164
        # Being asked to create on a non RemoteBzrDir:
2132
3165
        if not isinstance(a_bzrdir, RemoteBzrDir):
2133
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
3166
            return self._vfs_initialize(a_bzrdir, name=name,
 
3167
                append_revisions_only=append_revisions_only)
2134
3168
        medium = a_bzrdir._client._medium
2135
3169
        if medium._is_remote_before((1, 13)):
2136
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
3170
            return self._vfs_initialize(a_bzrdir, name=name,
 
3171
                append_revisions_only=append_revisions_only)
2137
3172
        # Creating on a remote bzr dir.
2138
3173
        # 2) try direct creation via RPC
2139
3174
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2140
 
        if name is not None:
 
3175
        if name != "":
2141
3176
            # XXX JRV20100304: Support creating colocated branches
2142
3177
            raise errors.NoColocatedBranchSupport(self)
2143
3178
        verb = 'BzrDir.create_branch'
2146
3181
        except errors.UnknownSmartMethod:
2147
3182
            # Fallback - use vfs methods
2148
3183
            medium._remember_remote_is_before((1, 13))
2149
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
3184
            return self._vfs_initialize(a_bzrdir, name=name,
 
3185
                    append_revisions_only=append_revisions_only)
2150
3186
        if response[0] != 'ok':
2151
3187
            raise errors.UnexpectedSmartServerResponse(response)
2152
3188
        # Turn the response into a RemoteRepository object.
2154
3190
        repo_format = response_tuple_to_repo_format(response[3:])
2155
3191
        repo_path = response[2]
2156
3192
        if repository is not None:
2157
 
            remote_repo_url = urlutils.join(medium.base, repo_path)
 
3193
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
2158
3194
            url_diff = urlutils.relative_url(repository.user_url,
2159
3195
                    remote_repo_url)
2160
3196
            if url_diff != '.':
2161
3197
                raise AssertionError(
2162
3198
                    'repository.user_url %r does not match URL from server '
2163
3199
                    'response (%r + %r)'
2164
 
                    % (repository.user_url, medium.base, repo_path))
 
3200
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
2165
3201
            remote_repo = repository
2166
3202
        else:
2167
3203
            if repo_path == '':
2173
3209
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2174
3210
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2175
3211
            format=format, setup_stacking=False, name=name)
 
3212
        if append_revisions_only:
 
3213
            remote_branch.set_append_revisions_only(append_revisions_only)
2176
3214
        # XXX: We know this is a new branch, so it must have revno 0, revid
2177
3215
        # NULL_REVISION. Creating the branch locked would make this be unable
2178
3216
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2197
3235
        self._ensure_real()
2198
3236
        return self._custom_format.supports_set_append_revisions_only()
2199
3237
 
 
3238
    def _use_default_local_heads_to_fetch(self):
 
3239
        # If the branch format is a metadir format *and* its heads_to_fetch
 
3240
        # implementation is not overridden vs the base class, we can use the
 
3241
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
3242
        # usually cheaper in terms of net round trips, as the last-revision and
 
3243
        # tags info fetched is cached and would be fetched anyway.
 
3244
        self._ensure_real()
 
3245
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
3246
            branch_class = self._custom_format._branch_class()
 
3247
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
3248
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
3249
                return True
 
3250
        return False
 
3251
 
 
3252
 
 
3253
class RemoteBranchStore(_mod_config.IniFileStore):
 
3254
    """Branch store which attempts to use HPSS calls to retrieve branch store.
 
3255
 
 
3256
    Note that this is specific to bzr-based formats.
 
3257
    """
 
3258
 
 
3259
    def __init__(self, branch):
 
3260
        super(RemoteBranchStore, self).__init__()
 
3261
        self.branch = branch
 
3262
        self.id = "branch"
 
3263
        self._real_store = None
 
3264
 
 
3265
    def external_url(self):
 
3266
        return self.branch.user_url
 
3267
 
 
3268
    def _load_content(self):
 
3269
        path = self.branch._remote_path()
 
3270
        try:
 
3271
            response, handler = self.branch._call_expecting_body(
 
3272
                'Branch.get_config_file', path)
 
3273
        except errors.UnknownSmartMethod:
 
3274
            self._ensure_real()
 
3275
            return self._real_store._load_content()
 
3276
        if len(response) and response[0] != 'ok':
 
3277
            raise errors.UnexpectedSmartServerResponse(response)
 
3278
        return handler.read_body_bytes()
 
3279
 
 
3280
    def _save_content(self, content):
 
3281
        path = self.branch._remote_path()
 
3282
        try:
 
3283
            response, handler = self.branch._call_with_body_bytes_expecting_body(
 
3284
                'Branch.put_config_file', (path,
 
3285
                    self.branch._lock_token, self.branch._repo_lock_token),
 
3286
                content)
 
3287
        except errors.UnknownSmartMethod:
 
3288
            self._ensure_real()
 
3289
            return self._real_store._save_content(content)
 
3290
        handler.cancel_read_body()
 
3291
        if response != ('ok', ):
 
3292
            raise errors.UnexpectedSmartServerResponse(response)
 
3293
 
 
3294
    def _ensure_real(self):
 
3295
        self.branch._ensure_real()
 
3296
        if self._real_store is None:
 
3297
            self._real_store = _mod_config.BranchStore(self.branch)
 
3298
 
2200
3299
 
2201
3300
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2202
3301
    """Branch stored on a server accessed by HPSS RPC.
2205
3304
    """
2206
3305
 
2207
3306
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2208
 
        _client=None, format=None, setup_stacking=True, name=None):
 
3307
        _client=None, format=None, setup_stacking=True, name=None,
 
3308
        possible_transports=None):
2209
3309
        """Create a RemoteBranch instance.
2210
3310
 
2211
3311
        :param real_branch: An optional local implementation of the branch
2223
3323
        # will try to assign to self.tags, which is a property in this subclass.
2224
3324
        # And the parent's __init__ doesn't do much anyway.
2225
3325
        self.bzrdir = remote_bzrdir
 
3326
        self.name = name
2226
3327
        if _client is not None:
2227
3328
            self._client = _client
2228
3329
        else:
2251
3352
        self._repo_lock_token = None
2252
3353
        self._lock_count = 0
2253
3354
        self._leave_lock = False
 
3355
        self.conf_store = None
2254
3356
        # Setup a format: note that we cannot call _ensure_real until all the
2255
3357
        # attributes above are set: This code cannot be moved higher up in this
2256
3358
        # function.
2276
3378
            hook(self)
2277
3379
        self._is_stacked = False
2278
3380
        if setup_stacking:
2279
 
            self._setup_stacking()
 
3381
            self._setup_stacking(possible_transports)
2280
3382
 
2281
 
    def _setup_stacking(self):
 
3383
    def _setup_stacking(self, possible_transports):
2282
3384
        # configure stacking into the remote repository, by reading it from
2283
3385
        # the vfs branch.
2284
3386
        try:
2287
3389
            errors.UnstackableRepositoryFormat), e:
2288
3390
            return
2289
3391
        self._is_stacked = True
2290
 
        self._activate_fallback_location(fallback_url)
 
3392
        if possible_transports is None:
 
3393
            possible_transports = []
 
3394
        else:
 
3395
            possible_transports = list(possible_transports)
 
3396
        possible_transports.append(self.bzrdir.root_transport)
 
3397
        self._activate_fallback_location(fallback_url,
 
3398
            possible_transports=possible_transports)
2291
3399
 
2292
3400
    def _get_config(self):
2293
3401
        return RemoteBranchConfig(self)
2294
3402
 
 
3403
    def _get_config_store(self):
 
3404
        if self.conf_store is None:
 
3405
            self.conf_store =  RemoteBranchStore(self)
 
3406
        return self.conf_store
 
3407
 
2295
3408
    def _get_real_transport(self):
2296
3409
        # if we try vfs access, return the real branch's vfs transport
2297
3410
        self._ensure_real()
2316
3429
            self.bzrdir._ensure_real()
2317
3430
            self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2318
3431
                ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
 
3432
            # The remote branch and the real branch shares the same store. If
 
3433
            # we don't, there will always be cases where one of the stores
 
3434
            # doesn't see an update made on the other.
 
3435
            self._real_branch.conf_store = self.conf_store
2319
3436
            if self.repository._real_repository is None:
2320
3437
                # Give the remote repository the matching real repo.
2321
3438
                real_repo = self._real_branch.repository
2360
3477
                self.bzrdir, self._client)
2361
3478
        return self._control_files
2362
3479
 
2363
 
    def _get_checkout_format(self):
2364
 
        self._ensure_real()
2365
 
        return self._real_branch._get_checkout_format()
2366
 
 
2367
3480
    def get_physical_lock_status(self):
2368
3481
        """See Branch.get_physical_lock_status()."""
2369
 
        # should be an API call to the server, as branches must be lockable.
2370
 
        self._ensure_real()
2371
 
        return self._real_branch.get_physical_lock_status()
 
3482
        try:
 
3483
            response = self._client.call('Branch.get_physical_lock_status',
 
3484
                self._remote_path())
 
3485
        except errors.UnknownSmartMethod:
 
3486
            self._ensure_real()
 
3487
            return self._real_branch.get_physical_lock_status()
 
3488
        if response[0] not in ('yes', 'no'):
 
3489
            raise errors.UnexpectedSmartServerResponse(response)
 
3490
        return (response[0] == 'yes')
2372
3491
 
2373
3492
    def get_stacked_on_url(self):
2374
3493
        """Get the URL this branch is stacked against.
2397
3516
 
2398
3517
    def set_stacked_on_url(self, url):
2399
3518
        branch.Branch.set_stacked_on_url(self, url)
 
3519
        # We need the stacked_on_url to be visible both locally (to not query
 
3520
        # it repeatedly) and remotely (so smart verbs can get it server side)
 
3521
        # Without the following line,
 
3522
        # bzrlib.tests.per_branch.test_create_clone.TestCreateClone
 
3523
        # .test_create_clone_on_transport_stacked_hooks_get_stacked_branch
 
3524
        # fails for remote branches -- vila 2012-01-04
 
3525
        self.conf_store.save_changes()
2400
3526
        if not url:
2401
3527
            self._is_stacked = False
2402
3528
        else:
2403
3529
            self._is_stacked = True
2404
 
        
 
3530
 
2405
3531
    def _vfs_get_tags_bytes(self):
2406
3532
        self._ensure_real()
2407
3533
        return self._real_branch._get_tags_bytes()
2530
3656
        try:
2531
3657
            self._lock_count -= 1
2532
3658
            if not self._lock_count:
 
3659
                if self.conf_store is not None:
 
3660
                    self.conf_store.save_changes()
2533
3661
                self._clear_cached_state()
2534
3662
                mode = self._lock_mode
2535
3663
                self._lock_mode = None
2558
3686
            self.repository.unlock()
2559
3687
 
2560
3688
    def break_lock(self):
2561
 
        self._ensure_real()
2562
 
        return self._real_branch.break_lock()
 
3689
        try:
 
3690
            response = self._call(
 
3691
                'Branch.break_lock', self._remote_path())
 
3692
        except errors.UnknownSmartMethod:
 
3693
            self._ensure_real()
 
3694
            return self._real_branch.break_lock()
 
3695
        if response != ('ok',):
 
3696
            raise errors.UnexpectedSmartServerResponse(response)
2563
3697
 
2564
3698
    def leave_lock_in_place(self):
2565
3699
        if not self._lock_token:
2589
3723
            missing_parent = parent_map[missing_parent]
2590
3724
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2591
3725
 
2592
 
    def _last_revision_info(self):
 
3726
    def _read_last_revision_info(self):
2593
3727
        response = self._call('Branch.last_revision_info', self._remote_path())
2594
3728
        if response[0] != 'ok':
2595
3729
            raise SmartProtocolError('unexpected response code %s' % (response,))
2658
3792
            raise errors.UnexpectedSmartServerResponse(response)
2659
3793
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2660
3794
 
 
3795
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2661
3796
    @needs_write_lock
2662
3797
    def set_revision_history(self, rev_history):
 
3798
        """See Branch.set_revision_history."""
 
3799
        self._set_revision_history(rev_history)
 
3800
 
 
3801
    @needs_write_lock
 
3802
    def _set_revision_history(self, rev_history):
2663
3803
        # Send just the tip revision of the history; the server will generate
2664
3804
        # the full history from that.  If the revision doesn't exist in this
2665
3805
        # branch, NoSuchRevision will be raised.
2723
3863
            _override_hook_target=self, **kwargs)
2724
3864
 
2725
3865
    @needs_read_lock
2726
 
    def push(self, target, overwrite=False, stop_revision=None):
 
3866
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2727
3867
        self._ensure_real()
2728
3868
        return self._real_branch.push(
2729
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
3869
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2730
3870
            _override_hook_source_branch=self)
2731
3871
 
2732
3872
    def is_locked(self):
2733
3873
        return self._lock_count >= 1
2734
3874
 
2735
3875
    @needs_read_lock
 
3876
    def revision_id_to_dotted_revno(self, revision_id):
 
3877
        """Given a revision id, return its dotted revno.
 
3878
 
 
3879
        :return: a tuple like (1,) or (400,1,3).
 
3880
        """
 
3881
        try:
 
3882
            response = self._call('Branch.revision_id_to_revno',
 
3883
                self._remote_path(), revision_id)
 
3884
        except errors.UnknownSmartMethod:
 
3885
            self._ensure_real()
 
3886
            return self._real_branch.revision_id_to_dotted_revno(revision_id)
 
3887
        if response[0] == 'ok':
 
3888
            return tuple([int(x) for x in response[1:]])
 
3889
        else:
 
3890
            raise errors.UnexpectedSmartServerResponse(response)
 
3891
 
 
3892
    @needs_read_lock
2736
3893
    def revision_id_to_revno(self, revision_id):
2737
 
        self._ensure_real()
2738
 
        return self._real_branch.revision_id_to_revno(revision_id)
 
3894
        """Given a revision id on the branch mainline, return its revno.
 
3895
 
 
3896
        :return: an integer
 
3897
        """
 
3898
        try:
 
3899
            response = self._call('Branch.revision_id_to_revno',
 
3900
                self._remote_path(), revision_id)
 
3901
        except errors.UnknownSmartMethod:
 
3902
            self._ensure_real()
 
3903
            return self._real_branch.revision_id_to_revno(revision_id)
 
3904
        if response[0] == 'ok':
 
3905
            if len(response) == 2:
 
3906
                return int(response[1])
 
3907
            raise NoSuchRevision(self, revision_id)
 
3908
        else:
 
3909
            raise errors.UnexpectedSmartServerResponse(response)
2739
3910
 
2740
3911
    @needs_write_lock
2741
3912
    def set_last_revision_info(self, revno, revision_id):
2742
3913
        # XXX: These should be returned by the set_last_revision_info verb
2743
3914
        old_revno, old_revid = self.last_revision_info()
2744
3915
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2745
 
        revision_id = ensure_null(revision_id)
 
3916
        if not revision_id or not isinstance(revision_id, basestring):
 
3917
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2746
3918
        try:
2747
3919
            response = self._call('Branch.set_last_revision_info',
2748
3920
                self._remote_path(), self._lock_token, self._repo_lock_token,
2777
3949
            except errors.UnknownSmartMethod:
2778
3950
                medium._remember_remote_is_before((1, 6))
2779
3951
        self._clear_cached_state_of_remote_branch_only()
2780
 
        self.set_revision_history(self._lefthand_history(revision_id,
 
3952
        self._set_revision_history(self._lefthand_history(revision_id,
2781
3953
            last_rev=last_rev,other_branch=other_branch))
2782
3954
 
2783
3955
    def set_push_location(self, location):
 
3956
        self._set_config_location('push_location', location)
 
3957
 
 
3958
    def heads_to_fetch(self):
 
3959
        if self._format._use_default_local_heads_to_fetch():
 
3960
            # We recognise this format, and its heads-to-fetch implementation
 
3961
            # is the default one (tip + tags).  In this case it's cheaper to
 
3962
            # just use the default implementation rather than a special RPC as
 
3963
            # the tip and tags data is cached.
 
3964
            return branch.Branch.heads_to_fetch(self)
 
3965
        medium = self._client._medium
 
3966
        if medium._is_remote_before((2, 4)):
 
3967
            return self._vfs_heads_to_fetch()
 
3968
        try:
 
3969
            return self._rpc_heads_to_fetch()
 
3970
        except errors.UnknownSmartMethod:
 
3971
            medium._remember_remote_is_before((2, 4))
 
3972
            return self._vfs_heads_to_fetch()
 
3973
 
 
3974
    def _rpc_heads_to_fetch(self):
 
3975
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3976
        if len(response) != 2:
 
3977
            raise errors.UnexpectedSmartServerResponse(response)
 
3978
        must_fetch, if_present_fetch = response
 
3979
        return set(must_fetch), set(if_present_fetch)
 
3980
 
 
3981
    def _vfs_heads_to_fetch(self):
2784
3982
        self._ensure_real()
2785
 
        return self._real_branch.set_push_location(location)
 
3983
        return self._real_branch.heads_to_fetch()
2786
3984
 
2787
3985
 
2788
3986
class RemoteConfig(object):
2803
4001
        """
2804
4002
        try:
2805
4003
            configobj = self._get_configobj()
 
4004
            section_obj = None
2806
4005
            if section is None:
2807
4006
                section_obj = configobj
2808
4007
            else:
2809
4008
                try:
2810
4009
                    section_obj = configobj[section]
2811
4010
                except KeyError:
2812
 
                    return default
2813
 
            return section_obj.get(name, default)
 
4011
                    pass
 
4012
            if section_obj is None:
 
4013
                value = default
 
4014
            else:
 
4015
                value = section_obj.get(name, default)
2814
4016
        except errors.UnknownSmartMethod:
2815
 
            return self._vfs_get_option(name, section, default)
 
4017
            value = self._vfs_get_option(name, section, default)
 
4018
        for hook in _mod_config.OldConfigHooks['get']:
 
4019
            hook(self, name, value)
 
4020
        return value
2816
4021
 
2817
4022
    def _response_to_configobj(self, response):
2818
4023
        if len(response[0]) and response[0][0] != 'ok':
2819
4024
            raise errors.UnexpectedSmartServerResponse(response)
2820
4025
        lines = response[1].read_body_bytes().splitlines()
2821
 
        return config.ConfigObj(lines, encoding='utf-8')
 
4026
        conf = _mod_config.ConfigObj(lines, encoding='utf-8')
 
4027
        for hook in _mod_config.OldConfigHooks['load']:
 
4028
            hook(self)
 
4029
        return conf
2822
4030
 
2823
4031
 
2824
4032
class RemoteBranchConfig(RemoteConfig):
2932
4140
        return self._bzrdir._real_bzrdir
2933
4141
 
2934
4142
 
2935
 
 
2936
4143
def _extract_tar(tar, to_dir):
2937
4144
    """Extract all the contents of a tarfile object.
2938
4145
 
2942
4149
        tar.extract(tarinfo, to_dir)
2943
4150
 
2944
4151
 
 
4152
error_translators = registry.Registry()
 
4153
no_context_error_translators = registry.Registry()
 
4154
 
 
4155
 
2945
4156
def _translate_error(err, **context):
2946
4157
    """Translate an ErrorFromSmartServer into a more useful error.
2947
4158
 
2976
4187
                    'Missing key %r in context %r', key_err.args[0], context)
2977
4188
                raise err
2978
4189
 
2979
 
    if err.error_verb == 'IncompatibleRepositories':
2980
 
        raise errors.IncompatibleRepositories(err.error_args[0],
2981
 
            err.error_args[1], err.error_args[2])
2982
 
    elif err.error_verb == 'NoSuchRevision':
2983
 
        raise NoSuchRevision(find('branch'), err.error_args[0])
2984
 
    elif err.error_verb == 'nosuchrevision':
2985
 
        raise NoSuchRevision(find('repository'), err.error_args[0])
2986
 
    elif err.error_verb == 'nobranch':
2987
 
        if len(err.error_args) >= 1:
2988
 
            extra = err.error_args[0]
2989
 
        else:
2990
 
            extra = None
2991
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
2992
 
            detail=extra)
2993
 
    elif err.error_verb == 'norepository':
2994
 
        raise errors.NoRepositoryPresent(find('bzrdir'))
2995
 
    elif err.error_verb == 'LockContention':
2996
 
        raise errors.LockContention('(remote lock)')
2997
 
    elif err.error_verb == 'UnlockableTransport':
2998
 
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
2999
 
    elif err.error_verb == 'LockFailed':
3000
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
3001
 
    elif err.error_verb == 'TokenMismatch':
3002
 
        raise errors.TokenMismatch(find('token'), '(remote token)')
3003
 
    elif err.error_verb == 'Diverged':
3004
 
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
3005
 
    elif err.error_verb == 'TipChangeRejected':
3006
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
3007
 
    elif err.error_verb == 'UnstackableBranchFormat':
3008
 
        raise errors.UnstackableBranchFormat(*err.error_args)
3009
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
3010
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
3011
 
    elif err.error_verb == 'NotStacked':
3012
 
        raise errors.NotStacked(branch=find('branch'))
3013
 
    elif err.error_verb == 'PermissionDenied':
3014
 
        path = get_path()
3015
 
        if len(err.error_args) >= 2:
3016
 
            extra = err.error_args[1]
3017
 
        else:
3018
 
            extra = None
3019
 
        raise errors.PermissionDenied(path, extra=extra)
3020
 
    elif err.error_verb == 'ReadError':
3021
 
        path = get_path()
3022
 
        raise errors.ReadError(path)
3023
 
    elif err.error_verb == 'NoSuchFile':
3024
 
        path = get_path()
3025
 
        raise errors.NoSuchFile(path)
3026
 
    elif err.error_verb == 'FileExists':
3027
 
        raise errors.FileExists(err.error_args[0])
3028
 
    elif err.error_verb == 'DirectoryNotEmpty':
3029
 
        raise errors.DirectoryNotEmpty(err.error_args[0])
3030
 
    elif err.error_verb == 'ShortReadvError':
3031
 
        args = err.error_args
3032
 
        raise errors.ShortReadvError(
3033
 
            args[0], int(args[1]), int(args[2]), int(args[3]))
3034
 
    elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
 
4190
    try:
 
4191
        translator = error_translators.get(err.error_verb)
 
4192
    except KeyError:
 
4193
        pass
 
4194
    else:
 
4195
        raise translator(err, find, get_path)
 
4196
    try:
 
4197
        translator = no_context_error_translators.get(err.error_verb)
 
4198
    except KeyError:
 
4199
        raise errors.UnknownErrorFromSmartServer(err)
 
4200
    else:
 
4201
        raise translator(err)
 
4202
 
 
4203
 
 
4204
error_translators.register('NoSuchRevision',
 
4205
    lambda err, find, get_path: NoSuchRevision(
 
4206
        find('branch'), err.error_args[0]))
 
4207
error_translators.register('nosuchrevision',
 
4208
    lambda err, find, get_path: NoSuchRevision(
 
4209
        find('repository'), err.error_args[0]))
 
4210
 
 
4211
def _translate_nobranch_error(err, find, get_path):
 
4212
    if len(err.error_args) >= 1:
 
4213
        extra = err.error_args[0]
 
4214
    else:
 
4215
        extra = None
 
4216
    return errors.NotBranchError(path=find('bzrdir').root_transport.base,
 
4217
        detail=extra)
 
4218
 
 
4219
error_translators.register('nobranch', _translate_nobranch_error)
 
4220
error_translators.register('norepository',
 
4221
    lambda err, find, get_path: errors.NoRepositoryPresent(
 
4222
        find('bzrdir')))
 
4223
error_translators.register('UnlockableTransport',
 
4224
    lambda err, find, get_path: errors.UnlockableTransport(
 
4225
        find('bzrdir').root_transport))
 
4226
error_translators.register('TokenMismatch',
 
4227
    lambda err, find, get_path: errors.TokenMismatch(
 
4228
        find('token'), '(remote token)'))
 
4229
error_translators.register('Diverged',
 
4230
    lambda err, find, get_path: errors.DivergedBranches(
 
4231
        find('branch'), find('other_branch')))
 
4232
error_translators.register('NotStacked',
 
4233
    lambda err, find, get_path: errors.NotStacked(branch=find('branch')))
 
4234
 
 
4235
def _translate_PermissionDenied(err, find, get_path):
 
4236
    path = get_path()
 
4237
    if len(err.error_args) >= 2:
 
4238
        extra = err.error_args[1]
 
4239
    else:
 
4240
        extra = None
 
4241
    return errors.PermissionDenied(path, extra=extra)
 
4242
 
 
4243
error_translators.register('PermissionDenied', _translate_PermissionDenied)
 
4244
error_translators.register('ReadError',
 
4245
    lambda err, find, get_path: errors.ReadError(get_path()))
 
4246
error_translators.register('NoSuchFile',
 
4247
    lambda err, find, get_path: errors.NoSuchFile(get_path()))
 
4248
error_translators.register('TokenLockingNotSupported',
 
4249
    lambda err, find, get_path: errors.TokenLockingNotSupported(
 
4250
        find('repository')))
 
4251
error_translators.register('UnsuspendableWriteGroup',
 
4252
    lambda err, find, get_path: errors.UnsuspendableWriteGroup(
 
4253
        repository=find('repository')))
 
4254
error_translators.register('UnresumableWriteGroup',
 
4255
    lambda err, find, get_path: errors.UnresumableWriteGroup(
 
4256
        repository=find('repository'), write_groups=err.error_args[0],
 
4257
        reason=err.error_args[1]))
 
4258
no_context_error_translators.register('IncompatibleRepositories',
 
4259
    lambda err: errors.IncompatibleRepositories(
 
4260
        err.error_args[0], err.error_args[1], err.error_args[2]))
 
4261
no_context_error_translators.register('LockContention',
 
4262
    lambda err: errors.LockContention('(remote lock)'))
 
4263
no_context_error_translators.register('LockFailed',
 
4264
    lambda err: errors.LockFailed(err.error_args[0], err.error_args[1]))
 
4265
no_context_error_translators.register('TipChangeRejected',
 
4266
    lambda err: errors.TipChangeRejected(err.error_args[0].decode('utf8')))
 
4267
no_context_error_translators.register('UnstackableBranchFormat',
 
4268
    lambda err: errors.UnstackableBranchFormat(*err.error_args))
 
4269
no_context_error_translators.register('UnstackableRepositoryFormat',
 
4270
    lambda err: errors.UnstackableRepositoryFormat(*err.error_args))
 
4271
no_context_error_translators.register('FileExists',
 
4272
    lambda err: errors.FileExists(err.error_args[0]))
 
4273
no_context_error_translators.register('DirectoryNotEmpty',
 
4274
    lambda err: errors.DirectoryNotEmpty(err.error_args[0]))
 
4275
 
 
4276
def _translate_short_readv_error(err):
 
4277
    args = err.error_args
 
4278
    return errors.ShortReadvError(args[0], int(args[1]), int(args[2]),
 
4279
        int(args[3]))
 
4280
 
 
4281
no_context_error_translators.register('ShortReadvError',
 
4282
    _translate_short_readv_error)
 
4283
 
 
4284
def _translate_unicode_error(err):
3035
4285
        encoding = str(err.error_args[0]) # encoding must always be a string
3036
4286
        val = err.error_args[1]
3037
4287
        start = int(err.error_args[2])
3045
4295
            raise UnicodeDecodeError(encoding, val, start, end, reason)
3046
4296
        elif err.error_verb == 'UnicodeEncodeError':
3047
4297
            raise UnicodeEncodeError(encoding, val, start, end, reason)
3048
 
    elif err.error_verb == 'ReadOnlyError':
3049
 
        raise errors.TransportNotPossible('readonly transport')
3050
 
    raise errors.UnknownErrorFromSmartServer(err)
 
4298
 
 
4299
no_context_error_translators.register('UnicodeEncodeError',
 
4300
    _translate_unicode_error)
 
4301
no_context_error_translators.register('UnicodeDecodeError',
 
4302
    _translate_unicode_error)
 
4303
no_context_error_translators.register('ReadOnlyError',
 
4304
    lambda err: errors.TransportNotPossible('readonly transport'))
 
4305
no_context_error_translators.register('MemoryError',
 
4306
    lambda err: errors.BzrError("remote server out of memory\n"
 
4307
        "Retry non-remotely, or contact the server admin for details."))
 
4308
no_context_error_translators.register('RevisionNotPresent',
 
4309
    lambda err: errors.RevisionNotPresent(err.error_args[0], err.error_args[1]))
 
4310
 
 
4311
no_context_error_translators.register('BzrCheckError',
 
4312
    lambda err: errors.BzrCheckError(msg=err.error_args[0]))
 
4313