~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Jelmer Vernooij
  • Date: 2016-04-03 16:32:31 UTC
  • mto: This revision was merged to the branch mainline in revision 6617.
  • Revision ID: jelmer@jelmer.uk-20160403163231-h72bo0uyek2gikw0
Don't put French text in doc/en/user-reference when LANGUAGE=fr_CH.UTF_8.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
25
    bzrdir as _mod_bzrdir,
23
 
    config,
 
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,
 
35
    osutils,
 
36
    registry,
30
37
    repository as _mod_repository,
31
38
    revision as _mod_revision,
32
39
    static_tuple,
33
40
    symbol_versioning,
 
41
    testament as _mod_testament,
34
42
    urlutils,
35
43
    vf_repository,
 
44
    vf_search,
36
45
    )
37
46
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
38
47
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
40
49
    NoSuchRevision,
41
50
    SmartProtocolError,
42
51
    )
 
52
from bzrlib.i18n import gettext
 
53
from bzrlib.inventory import Inventory
43
54
from bzrlib.lockable_files import LockableFiles
44
55
from bzrlib.smart import client, vfs, repository as smart_repo
45
56
from bzrlib.smart.client import _SmartClient
46
57
from bzrlib.revision import NULL_REVISION
 
58
from bzrlib.revisiontree import InventoryRevisionTree
47
59
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
48
 
from bzrlib.trace import mutter, note, warning
 
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
49
66
 
50
67
 
51
68
class _RpcHelper(object):
96
113
 
97
114
    supports_workingtrees = False
98
115
 
 
116
    colocated_branches = False
 
117
 
99
118
    def __init__(self):
100
119
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
101
120
        # XXX: It's a bit ugly that the network name is here, because we'd
110
129
 
111
130
    def get_format_description(self):
112
131
        if self._network_name:
113
 
            real_format = controldir.network_format_registry.get(self._network_name)
114
 
            return 'Remote: ' + real_format.get_format_description()
 
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()
115
139
        return 'bzr remote bzrdir'
116
140
 
117
141
    def get_format_string(self):
327
351
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
328
352
 
329
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 urlutils.join(self.branch.user_url, 'control.conf')
 
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
 
330
410
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
331
411
    """Control directory on a remote server, accessed via bzr:// or similar."""
332
412
 
403
483
                warning('VFS BzrDir access triggered\n%s',
404
484
                    ''.join(traceback.format_stack()))
405
485
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
406
 
                self.root_transport, _server_formats=False)
 
486
                self.root_transport, probers=[_mod_bzrdir.BzrProber])
407
487
            self._format._network_name = \
408
488
                self._real_bzrdir._format.network_name()
409
489
 
416
496
        self._next_open_branch_result = None
417
497
        return _mod_bzrdir.BzrDir.break_lock(self)
418
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
 
540
 
419
541
    def _vfs_cloning_metadir(self, require_stacking=False):
420
542
        self._ensure_real()
421
543
        return self._real_bzrdir.cloning_metadir(
451
573
        if len(branch_info) != 2:
452
574
            raise errors.UnexpectedSmartServerResponse(response)
453
575
        branch_ref, branch_name = branch_info
454
 
        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
 
455
581
        if repo_name:
456
 
            format.repository_format = _mod_repository.network_format_registry.get(
457
 
                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)
458
588
        if branch_ref == 'ref':
459
589
            # XXX: we need possible_transports here to avoid reopening the
460
590
            # connection to the referenced location
463
593
            format.set_branch_format(branch_format)
464
594
        elif branch_ref == 'branch':
465
595
            if branch_name:
466
 
                format.set_branch_format(
467
 
                    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)
468
603
        else:
469
604
            raise errors.UnexpectedSmartServerResponse(response)
470
605
        return format
480
615
 
481
616
    def destroy_repository(self):
482
617
        """See BzrDir.destroy_repository"""
483
 
        self._ensure_real()
484
 
        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,))
485
627
 
486
 
    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)
487
634
        # as per meta1 formats - just delegate to the format object which may
488
635
        # be parameterised.
489
636
        real_branch = self._format.get_branch_format().initialize(self,
490
 
            name=name, repository=repository)
 
637
            name=name, repository=repository,
 
638
            append_revisions_only=append_revisions_only)
491
639
        if not isinstance(real_branch, RemoteBranch):
492
640
            if not isinstance(repository, RemoteRepository):
493
641
                raise AssertionError(
507
655
 
508
656
    def destroy_branch(self, name=None):
509
657
        """See BzrDir.destroy_branch"""
510
 
        self._ensure_real()
511
 
        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
512
674
        self._next_open_branch_result = None
 
675
        if response[0] != 'ok':
 
676
            raise SmartProtocolError('unexpected response code %s' % (response,))
513
677
 
514
678
    def create_workingtree(self, revision_id=None, from_branch=None,
515
679
        accelerator_tree=None, hardlink=False):
523
687
        b = self.open_branch(name=name)
524
688
        return b._format
525
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
 
526
717
    def get_branch_reference(self, name=None):
527
718
        """See BzrDir.get_branch_reference()."""
528
 
        if name is not None:
529
 
            # XXX JRV20100304: Support opening colocated branches
 
719
        if name is None:
 
720
            name = self._get_selected_branch()
 
721
        if name != "":
530
722
            raise errors.NoColocatedBranchSupport(self)
531
723
        response = self._get_branch_reference()
532
724
        if response[0] == 'ref':
568
760
        """See BzrDir._get_tree_branch()."""
569
761
        return None, self.open_branch(name=name)
570
762
 
571
 
    def open_branch(self, name=None, unsupported=False,
572
 
                    ignore_fallbacks=False):
573
 
        if unsupported:
574
 
            raise NotImplementedError('unsupported flag support not implemented yet.')
575
 
        if self._next_open_branch_result is not None:
576
 
            # See create_branch for details.
577
 
            result = self._next_open_branch_result
578
 
            self._next_open_branch_result = None
579
 
            return result
580
 
        response = self._get_branch_reference()
581
 
        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':
582
766
            # a branch reference, use the existing BranchReference logic.
583
767
            format = BranchReferenceFormat()
584
768
            return format.open(self, name=name, _found=True,
585
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
586
 
        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
587
772
        if not branch_format_name:
588
773
            branch_format_name = None
589
774
        format = RemoteBranchFormat(network_name=branch_format_name)
590
775
        return RemoteBranch(self, self.find_repository(), format=format,
591
 
            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)
592
796
 
593
797
    def _open_repo_v1(self, path):
594
798
        verb = 'BzrDir.find_repository'
657
861
 
658
862
    def has_workingtree(self):
659
863
        if self._has_working_tree is None:
660
 
            self._ensure_real()
661
 
            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')
662
874
        return self._has_working_tree
663
875
 
664
876
    def open_workingtree(self, recommend_upgrade=True):
669
881
 
670
882
    def _path_for_remote_call(self, client):
671
883
        """Return the path to be used for this bzrdir in a remote call."""
672
 
        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]
673
886
 
674
887
    def get_branch_transport(self, branch_format, name=None):
675
888
        self._ensure_real()
691
904
        """Upgrading of remote bzrdirs is not supported yet."""
692
905
        return False
693
906
 
694
 
    def clone(self, url, revision_id=None, force_new_repo=False,
695
 
              preserve_stacking=False):
696
 
        self._ensure_real()
697
 
        return self._real_bzrdir.clone(url, revision_id=revision_id,
698
 
            force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
699
 
 
700
907
    def _get_config(self):
701
908
        return RemoteBzrDirConfig(self)
702
909
 
 
910
    def _get_config_store(self):
 
911
        return RemoteControlStore(self)
 
912
 
703
913
 
704
914
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
705
915
    """Format for repositories accessed over a _SmartClient.
735
945
        self._supports_external_lookups = None
736
946
        self._supports_tree_reference = None
737
947
        self._supports_funky_characters = None
 
948
        self._supports_nesting_repositories = None
738
949
        self._rich_root_data = None
739
950
 
740
951
    def __repr__(self):
777
988
        return self._supports_funky_characters
778
989
 
779
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
780
999
    def supports_tree_reference(self):
781
1000
        if self._supports_tree_reference is None:
782
1001
            self._ensure_real()
832
1051
            network_name = self._network_name
833
1052
        else:
834
1053
            # Select the current bzrlib default and ask for that.
835
 
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
 
1054
            reference_bzrdir_format = controldir.format_registry.get('default')()
836
1055
            reference_format = reference_bzrdir_format.repository_format
837
1056
            network_name = reference_format.network_name()
838
1057
        # 2) try direct creation via RPC
864
1083
 
865
1084
    def _ensure_real(self):
866
1085
        if self._custom_format is None:
867
 
            self._custom_format = _mod_repository.network_format_registry.get(
868
 
                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)
869
1092
 
870
1093
    @property
871
1094
    def _fetch_order(self):
906
1129
        return self._custom_format._serializer
907
1130
 
908
1131
 
909
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
910
 
    controldir.ControlComponent):
 
1132
class RemoteRepository(_mod_repository.Repository, _RpcHelper,
 
1133
        lock._RelockDebugMixin):
911
1134
    """Repository accessed over rpc.
912
1135
 
913
1136
    For the moment most operations are performed using local transport-backed
937
1160
        self._format = format
938
1161
        self._lock_mode = None
939
1162
        self._lock_token = None
 
1163
        self._write_group_tokens = None
940
1164
        self._lock_count = 0
941
1165
        self._leave_lock = False
942
1166
        # Cache of revision parents; misses are cached during read locks, and
982
1206
 
983
1207
        :param suppress_errors: see Repository.abort_write_group.
984
1208
        """
985
 
        self._ensure_real()
986
 
        return self._real_repository.abort_write_group(
987
 
            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
988
1233
 
989
1234
    @property
990
1235
    def chk_bytes(self):
1004
1249
        for older plugins that don't use e.g. the CommitBuilder
1005
1250
        facility.
1006
1251
        """
1007
 
        self._ensure_real()
1008
 
        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()
1009
1265
 
1010
1266
    def resume_write_group(self, tokens):
1011
 
        self._ensure_real()
1012
 
        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
1013
1279
 
1014
1280
    def suspend_write_group(self):
1015
 
        self._ensure_real()
1016
 
        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
1017
1286
 
1018
1287
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
1019
1288
        self._ensure_real()
1229
1498
 
1230
1499
    def get_physical_lock_status(self):
1231
1500
        """See Repository.get_physical_lock_status()."""
1232
 
        # should be an API call to the server.
1233
 
        self._ensure_real()
1234
 
        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')
1235
1510
 
1236
1511
    def is_in_write_group(self):
1237
1512
        """Return True if there is an open write group.
1238
1513
 
1239
1514
        write groups are only applicable locally for the smart server..
1240
1515
        """
 
1516
        if self._write_group_tokens is not None:
 
1517
            return True
1241
1518
        if self._real_repository:
1242
1519
            return self._real_repository.is_in_write_group()
1243
1520
 
1378
1655
            self._real_repository.lock_write(self._lock_token)
1379
1656
        elif self._lock_mode == 'r':
1380
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
1381
1662
 
1382
1663
    def start_write_group(self):
1383
1664
        """Start a write group on the decorated repository.
1387
1668
        for older plugins that don't use e.g. the CommitBuilder
1388
1669
        facility.
1389
1670
        """
1390
 
        self._ensure_real()
1391
 
        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]
1392
1688
 
1393
1689
    def _unlock(self, token):
1394
1690
        path = self.bzrdir._path_for_remote_call(self._client)
1421
1717
            # This is just to let the _real_repository stay up to date.
1422
1718
            if self._real_repository is not None:
1423
1719
                self._real_repository.unlock()
 
1720
            elif self._write_group_tokens is not None:
 
1721
                self.abort_write_group()
1424
1722
        finally:
1425
1723
            # The rpc-level lock should be released even if there was a
1426
1724
            # problem releasing the vfs-based lock.
1438
1736
 
1439
1737
    def break_lock(self):
1440
1738
        # should hand off to the network
1441
 
        self._ensure_real()
1442
 
        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)
1443
1747
 
1444
1748
    def _get_tarball(self, compression):
1445
1749
        """Return a TemporaryFile containing a repository tarball.
1463
1767
            return t
1464
1768
        raise errors.UnexpectedSmartServerResponse(response)
1465
1769
 
 
1770
    @needs_read_lock
1466
1771
    def sprout(self, to_bzrdir, revision_id=None):
1467
 
        # TODO: Option to control what format is created?
1468
 
        self._ensure_real()
1469
 
        dest_repo = self._real_repository._format.initialize(to_bzrdir,
1470
 
                                                             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)
1471
1777
        dest_repo.fetch(self, revision_id=revision_id)
1472
1778
        return dest_repo
1473
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
 
1474
1793
    ### These methods are just thin shims to the VFS object for now.
1475
1794
 
 
1795
    @needs_read_lock
1476
1796
    def revision_tree(self, revision_id):
1477
 
        self._ensure_real()
1478
 
        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]
1479
1803
 
1480
1804
    def get_serializer_format(self):
1481
 
        self._ensure_real()
1482
 
        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]
1483
1815
 
1484
1816
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1485
1817
                           timezone=None, committer=None, revprops=None,
1486
1818
                           revision_id=None, lossy=False):
1487
 
        # FIXME: It ought to be possible to call this without immediately
1488
 
        # triggering _ensure_real.  For now it's the easiest thing to do.
1489
 
        self._ensure_real()
1490
 
        real_repo = self._real_repository
1491
 
        builder = real_repo.get_commit_builder(branch, parents,
1492
 
                config, timestamp=timestamp, timezone=timezone,
1493
 
                committer=committer, revprops=revprops,
1494
 
                revision_id=revision_id, lossy=lossy)
1495
 
        return builder
 
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
1496
1845
 
1497
1846
    def add_fallback_repository(self, repository):
1498
1847
        """Add a repository to use for looking up data not held locally.
1543
1892
            delta, new_revision_id, parents, basis_inv=basis_inv,
1544
1893
            propagate_caches=propagate_caches)
1545
1894
 
1546
 
    def add_revision(self, rev_id, rev, inv=None, config=None):
1547
 
        self._ensure_real()
1548
 
        return self._real_repository.add_revision(
1549
 
            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)
1550
1920
 
1551
1921
    @needs_read_lock
1552
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):
1553
1966
        self._ensure_real()
1554
 
        return self._real_repository.get_inventory(revision_id)
 
1967
        return self._real_repository._iter_inventories(revision_ids, ordering)
1555
1968
 
1556
1969
    def iter_inventories(self, revision_ids, ordering=None):
1557
 
        self._ensure_real()
1558
 
        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()
1559
2044
 
1560
2045
    @needs_read_lock
1561
2046
    def get_revision(self, revision_id):
1562
 
        self._ensure_real()
1563
 
        return self._real_repository.get_revision(revision_id)
 
2047
        return self.get_revisions([revision_id])[0]
1564
2048
 
1565
2049
    def get_transaction(self):
1566
2050
        self._ensure_real()
1568
2052
 
1569
2053
    @needs_read_lock
1570
2054
    def clone(self, a_bzrdir, revision_id=None):
1571
 
        self._ensure_real()
1572
 
        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
1573
2059
 
1574
2060
    def make_working_trees(self):
1575
2061
        """See Repository.make_working_trees"""
1576
 
        self._ensure_real()
1577
 
        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'
1578
2071
 
1579
2072
    def refresh_data(self):
1580
2073
        """Re-read any data needed to synchronise with disk.
1589
2082
        """
1590
2083
        if self._real_repository is not None:
1591
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()
1592
2088
 
1593
2089
    def revision_ids_to_search_result(self, result_set):
1594
2090
        """Convert a set of revision ids to a graph SearchResult."""
1599
2095
        included_keys = result_set.intersection(result_parents)
1600
2096
        start_keys = result_set.difference(included_keys)
1601
2097
        exclude_keys = result_parents.difference(result_set)
1602
 
        result = graph.SearchResult(start_keys, exclude_keys,
 
2098
        result = vf_search.SearchResult(start_keys, exclude_keys,
1603
2099
            len(result_set), result_set)
1604
2100
        return result
1605
2101
 
1653
2149
        # the InterRepository base class, which raises an
1654
2150
        # IncompatibleRepositories when asked to fetch.
1655
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)
1656
2156
        return inter.fetch(revision_id=revision_id,
1657
2157
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1658
2158
 
1660
2160
        self._ensure_real()
1661
2161
        self._real_repository.create_bundle(target, base, fileobj, format)
1662
2162
 
1663
 
    @needs_read_lock
1664
 
    @symbol_versioning.deprecated_method(
1665
 
        symbol_versioning.deprecated_in((2, 4, 0)))
1666
 
    def get_ancestry(self, revision_id, topo_sorted=True):
1667
 
        self._ensure_real()
1668
 
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1669
 
 
1670
2163
    def fileids_altered_by_revision_ids(self, revision_ids):
1671
2164
        self._ensure_real()
1672
2165
        return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
1676
2169
        return self._real_repository._get_versioned_file_checker(
1677
2170
            revisions, revision_versions_cache)
1678
2171
 
 
2172
    def _iter_files_bytes_rpc(self, desired_files, absent):
 
2173
        path = self.bzrdir._path_for_remote_call(self._client)
 
2174
        lines = []
 
2175
        identifiers = []
 
2176
        for (file_id, revid, identifier) in desired_files:
 
2177
            lines.append("%s\0%s" % (
 
2178
                osutils.safe_file_id(file_id),
 
2179
                osutils.safe_revision_id(revid)))
 
2180
            identifiers.append(identifier)
 
2181
        (response_tuple, response_handler) = (
 
2182
            self._call_with_body_bytes_expecting_body(
 
2183
            "Repository.iter_files_bytes", (path, ), "\n".join(lines)))
 
2184
        if response_tuple != ('ok', ):
 
2185
            response_handler.cancel_read_body()
 
2186
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2187
        byte_stream = response_handler.read_streamed_body()
 
2188
        def decompress_stream(start, byte_stream, unused):
 
2189
            decompressor = zlib.decompressobj()
 
2190
            yield decompressor.decompress(start)
 
2191
            while decompressor.unused_data == "":
 
2192
                try:
 
2193
                    data = byte_stream.next()
 
2194
                except StopIteration:
 
2195
                    break
 
2196
                yield decompressor.decompress(data)
 
2197
            yield decompressor.flush()
 
2198
            unused.append(decompressor.unused_data)
 
2199
        unused = ""
 
2200
        while True:
 
2201
            while not "\n" in unused:
 
2202
                unused += byte_stream.next()
 
2203
            header, rest = unused.split("\n", 1)
 
2204
            args = header.split("\0")
 
2205
            if args[0] == "absent":
 
2206
                absent[identifiers[int(args[3])]] = (args[1], args[2])
 
2207
                unused = rest
 
2208
                continue
 
2209
            elif args[0] == "ok":
 
2210
                idx = int(args[1])
 
2211
            else:
 
2212
                raise errors.UnexpectedSmartServerResponse(args)
 
2213
            unused_chunks = []
 
2214
            yield (identifiers[idx],
 
2215
                decompress_stream(rest, byte_stream, unused_chunks))
 
2216
            unused = "".join(unused_chunks)
 
2217
 
1679
2218
    def iter_files_bytes(self, desired_files):
1680
2219
        """See Repository.iter_file_bytes.
1681
2220
        """
1682
 
        self._ensure_real()
1683
 
        return self._real_repository.iter_files_bytes(desired_files)
 
2221
        try:
 
2222
            absent = {}
 
2223
            for (identifier, bytes_iterator) in self._iter_files_bytes_rpc(
 
2224
                    desired_files, absent):
 
2225
                yield identifier, bytes_iterator
 
2226
            for fallback in self._fallback_repositories:
 
2227
                if not absent:
 
2228
                    break
 
2229
                desired_files = [(key[0], key[1], identifier) for
 
2230
                    (identifier, key) in absent.iteritems()]
 
2231
                for (identifier, bytes_iterator) in fallback.iter_files_bytes(desired_files):
 
2232
                    del absent[identifier]
 
2233
                    yield identifier, bytes_iterator
 
2234
            if absent:
 
2235
                # There may be more missing items, but raise an exception
 
2236
                # for just one.
 
2237
                missing_identifier = absent.keys()[0]
 
2238
                missing_key = absent[missing_identifier]
 
2239
                raise errors.RevisionNotPresent(revision_id=missing_key[1],
 
2240
                    file_id=missing_key[0])
 
2241
        except errors.UnknownSmartMethod:
 
2242
            self._ensure_real()
 
2243
            for (identifier, bytes_iterator) in (
 
2244
                self._real_repository.iter_files_bytes(desired_files)):
 
2245
                yield identifier, bytes_iterator
 
2246
 
 
2247
    def get_cached_parent_map(self, revision_ids):
 
2248
        """See bzrlib.CachingParentsProvider.get_cached_parent_map"""
 
2249
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
1684
2250
 
1685
2251
    def get_parent_map(self, revision_ids):
1686
2252
        """See bzrlib.Graph.get_parent_map()."""
1745
2311
        if parents_map is None:
1746
2312
            # Repository is not locked, so there's no cache.
1747
2313
            parents_map = {}
1748
 
        # start_set is all the keys in the cache
1749
 
        start_set = set(parents_map)
1750
 
        # result set is all the references to keys in the cache
1751
 
        result_parents = set()
1752
 
        for parents in parents_map.itervalues():
1753
 
            result_parents.update(parents)
1754
 
        stop_keys = result_parents.difference(start_set)
1755
 
        # We don't need to send ghosts back to the server as a position to
1756
 
        # stop either.
1757
 
        stop_keys.difference_update(self._unstacked_provider.missing_keys)
1758
 
        key_count = len(parents_map)
1759
 
        if (NULL_REVISION in result_parents
1760
 
            and NULL_REVISION in self._unstacked_provider.missing_keys):
1761
 
            # If we pruned NULL_REVISION from the stop_keys because it's also
1762
 
            # in our cache of "missing" keys we need to increment our key count
1763
 
            # by 1, because the reconsitituted SearchResult on the server will
1764
 
            # still consider NULL_REVISION to be an included key.
1765
 
            key_count += 1
1766
 
        included_keys = start_set.intersection(result_parents)
1767
 
        start_set.difference_update(included_keys)
 
2314
        if _DEFAULT_SEARCH_DEPTH <= 0:
 
2315
            (start_set, stop_keys,
 
2316
             key_count) = vf_search.search_result_from_parent_map(
 
2317
                parents_map, self._unstacked_provider.missing_keys)
 
2318
        else:
 
2319
            (start_set, stop_keys,
 
2320
             key_count) = vf_search.limited_search_result_from_parent_map(
 
2321
                parents_map, self._unstacked_provider.missing_keys,
 
2322
                keys, depth=_DEFAULT_SEARCH_DEPTH)
1768
2323
        recipe = ('manual', start_set, stop_keys, key_count)
1769
2324
        body = self._serialise_search_recipe(recipe)
1770
2325
        path = self.bzrdir._path_for_remote_call(self._client)
1819
2374
 
1820
2375
    @needs_read_lock
1821
2376
    def get_signature_text(self, revision_id):
1822
 
        self._ensure_real()
1823
 
        return self._real_repository.get_signature_text(revision_id)
 
2377
        path = self.bzrdir._path_for_remote_call(self._client)
 
2378
        try:
 
2379
            response_tuple, response_handler = self._call_expecting_body(
 
2380
                'Repository.get_revision_signature_text', path, revision_id)
 
2381
        except errors.UnknownSmartMethod:
 
2382
            self._ensure_real()
 
2383
            return self._real_repository.get_signature_text(revision_id)
 
2384
        except errors.NoSuchRevision, err:
 
2385
            for fallback in self._fallback_repositories:
 
2386
                try:
 
2387
                    return fallback.get_signature_text(revision_id)
 
2388
                except errors.NoSuchRevision:
 
2389
                    pass
 
2390
            raise err
 
2391
        else:
 
2392
            if response_tuple[0] != 'ok':
 
2393
                raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2394
            return response_handler.read_body_bytes()
1824
2395
 
1825
2396
    @needs_read_lock
1826
2397
    def _get_inventory_xml(self, revision_id):
 
2398
        # This call is used by older working tree formats,
 
2399
        # which stored a serialized basis inventory.
1827
2400
        self._ensure_real()
1828
2401
        return self._real_repository._get_inventory_xml(revision_id)
1829
2402
 
 
2403
    @needs_write_lock
1830
2404
    def reconcile(self, other=None, thorough=False):
1831
 
        self._ensure_real()
1832
 
        return self._real_repository.reconcile(other=other, thorough=thorough)
 
2405
        from bzrlib.reconcile import RepoReconciler
 
2406
        path = self.bzrdir._path_for_remote_call(self._client)
 
2407
        try:
 
2408
            response, handler = self._call_expecting_body(
 
2409
                'Repository.reconcile', path, self._lock_token)
 
2410
        except (errors.UnknownSmartMethod, errors.TokenLockingNotSupported):
 
2411
            self._ensure_real()
 
2412
            return self._real_repository.reconcile(other=other, thorough=thorough)
 
2413
        if response != ('ok', ):
 
2414
            raise errors.UnexpectedSmartServerResponse(response)
 
2415
        body = handler.read_body_bytes()
 
2416
        result = RepoReconciler(self)
 
2417
        for line in body.split('\n'):
 
2418
            if not line:
 
2419
                continue
 
2420
            key, val_text = line.split(':')
 
2421
            if key == "garbage_inventories":
 
2422
                result.garbage_inventories = int(val_text)
 
2423
            elif key == "inconsistent_parents":
 
2424
                result.inconsistent_parents = int(val_text)
 
2425
            else:
 
2426
                mutter("unknown reconcile key %r" % key)
 
2427
        return result
1833
2428
 
1834
2429
    def all_revision_ids(self):
1835
 
        self._ensure_real()
1836
 
        return self._real_repository.all_revision_ids()
 
2430
        path = self.bzrdir._path_for_remote_call(self._client)
 
2431
        try:
 
2432
            response_tuple, response_handler = self._call_expecting_body(
 
2433
                "Repository.all_revision_ids", path)
 
2434
        except errors.UnknownSmartMethod:
 
2435
            self._ensure_real()
 
2436
            return self._real_repository.all_revision_ids()
 
2437
        if response_tuple != ("ok", ):
 
2438
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2439
        revids = set(response_handler.read_body_bytes().splitlines())
 
2440
        for fallback in self._fallback_repositories:
 
2441
            revids.update(set(fallback.all_revision_ids()))
 
2442
        return list(revids)
 
2443
 
 
2444
    def _filtered_revision_trees(self, revision_ids, file_ids):
 
2445
        """Return Tree for a revision on this branch with only some files.
 
2446
 
 
2447
        :param revision_ids: a sequence of revision-ids;
 
2448
          a revision-id may not be None or 'null:'
 
2449
        :param file_ids: if not None, the result is filtered
 
2450
          so that only those file-ids, their parents and their
 
2451
          children are included.
 
2452
        """
 
2453
        inventories = self.iter_inventories(revision_ids)
 
2454
        for inv in inventories:
 
2455
            # Should we introduce a FilteredRevisionTree class rather
 
2456
            # than pre-filter the inventory here?
 
2457
            filtered_inv = inv.filter(file_ids)
 
2458
            yield InventoryRevisionTree(self, filtered_inv, filtered_inv.revision_id)
1837
2459
 
1838
2460
    @needs_read_lock
1839
2461
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1840
 
        self._ensure_real()
1841
 
        return self._real_repository.get_deltas_for_revisions(revisions,
1842
 
            specific_fileids=specific_fileids)
 
2462
        medium = self._client._medium
 
2463
        if medium._is_remote_before((1, 2)):
 
2464
            self._ensure_real()
 
2465
            for delta in self._real_repository.get_deltas_for_revisions(
 
2466
                    revisions, specific_fileids):
 
2467
                yield delta
 
2468
            return
 
2469
        # Get the revision-ids of interest
 
2470
        required_trees = set()
 
2471
        for revision in revisions:
 
2472
            required_trees.add(revision.revision_id)
 
2473
            required_trees.update(revision.parent_ids[:1])
 
2474
 
 
2475
        # Get the matching filtered trees. Note that it's more
 
2476
        # efficient to pass filtered trees to changes_from() rather
 
2477
        # than doing the filtering afterwards. changes_from() could
 
2478
        # arguably do the filtering itself but it's path-based, not
 
2479
        # file-id based, so filtering before or afterwards is
 
2480
        # currently easier.
 
2481
        if specific_fileids is None:
 
2482
            trees = dict((t.get_revision_id(), t) for
 
2483
                t in self.revision_trees(required_trees))
 
2484
        else:
 
2485
            trees = dict((t.get_revision_id(), t) for
 
2486
                t in self._filtered_revision_trees(required_trees,
 
2487
                specific_fileids))
 
2488
 
 
2489
        # Calculate the deltas
 
2490
        for revision in revisions:
 
2491
            if not revision.parent_ids:
 
2492
                old_tree = self.revision_tree(_mod_revision.NULL_REVISION)
 
2493
            else:
 
2494
                old_tree = trees[revision.parent_ids[0]]
 
2495
            yield trees[revision.revision_id].changes_from(old_tree)
1843
2496
 
1844
2497
    @needs_read_lock
1845
2498
    def get_revision_delta(self, revision_id, specific_fileids=None):
1846
 
        self._ensure_real()
1847
 
        return self._real_repository.get_revision_delta(revision_id,
1848
 
            specific_fileids=specific_fileids)
 
2499
        r = self.get_revision(revision_id)
 
2500
        return list(self.get_deltas_for_revisions([r],
 
2501
            specific_fileids=specific_fileids))[0]
1849
2502
 
1850
2503
    @needs_read_lock
1851
2504
    def revision_trees(self, revision_ids):
1852
 
        self._ensure_real()
1853
 
        return self._real_repository.revision_trees(revision_ids)
 
2505
        inventories = self.iter_inventories(revision_ids)
 
2506
        for inv in inventories:
 
2507
            yield InventoryRevisionTree(self, inv, inv.revision_id)
1854
2508
 
1855
2509
    @needs_read_lock
1856
2510
    def get_revision_reconcile(self, revision_id):
1864
2518
            callback_refs=callback_refs, check_repo=check_repo)
1865
2519
 
1866
2520
    def copy_content_into(self, destination, revision_id=None):
1867
 
        self._ensure_real()
1868
 
        return self._real_repository.copy_content_into(
1869
 
            destination, revision_id=revision_id)
 
2521
        """Make a complete copy of the content in self into destination.
 
2522
 
 
2523
        This is a destructive operation! Do not use it on existing
 
2524
        repositories.
 
2525
        """
 
2526
        interrepo = _mod_repository.InterRepository.get(self, destination)
 
2527
        return interrepo.copy_content(revision_id)
1870
2528
 
1871
2529
    def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1872
2530
        # get a tarball of the remote repository, and copy from that into the
1873
2531
        # destination
1874
 
        from bzrlib import osutils
1875
2532
        import tarfile
1876
2533
        # TODO: Maybe a progress bar while streaming the tarball?
1877
 
        note("Copying repository content as tarball...")
 
2534
        note(gettext("Copying repository content as tarball..."))
1878
2535
        tar_file = self._get_tarball('bz2')
1879
2536
        if tar_file is None:
1880
2537
            return None
1909
2566
    @needs_write_lock
1910
2567
    def pack(self, hint=None, clean_obsolete_packs=False):
1911
2568
        """Compress the data within the repository.
1912
 
 
1913
 
        This is not currently implemented within the smart server.
1914
2569
        """
1915
 
        self._ensure_real()
1916
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
2570
        if hint is None:
 
2571
            body = ""
 
2572
        else:
 
2573
            body = "".join([l+"\n" for l in hint])
 
2574
        path = self.bzrdir._path_for_remote_call(self._client)
 
2575
        try:
 
2576
            response, handler = self._call_with_body_bytes_expecting_body(
 
2577
                'Repository.pack', (path, self._lock_token,
 
2578
                    str(clean_obsolete_packs)), body)
 
2579
        except errors.UnknownSmartMethod:
 
2580
            self._ensure_real()
 
2581
            return self._real_repository.pack(hint=hint,
 
2582
                clean_obsolete_packs=clean_obsolete_packs)
 
2583
        handler.cancel_read_body()
 
2584
        if response != ('ok', ):
 
2585
            raise errors.UnexpectedSmartServerResponse(response)
1917
2586
 
1918
2587
    @property
1919
2588
    def revisions(self):
1920
2589
        """Decorate the real repository for now.
1921
2590
 
1922
 
        In the short term this should become a real object to intercept graph
1923
 
        lookups.
1924
 
 
1925
2591
        In the long term a full blown network facility is needed.
1926
2592
        """
1927
2593
        self._ensure_real()
1955
2621
 
1956
2622
    @needs_write_lock
1957
2623
    def sign_revision(self, revision_id, gpg_strategy):
1958
 
        self._ensure_real()
1959
 
        return self._real_repository.sign_revision(revision_id, gpg_strategy)
 
2624
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2625
        plaintext = testament.as_short_text()
 
2626
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1960
2627
 
1961
2628
    @property
1962
2629
    def texts(self):
1968
2635
        self._ensure_real()
1969
2636
        return self._real_repository.texts
1970
2637
 
 
2638
    def _iter_revisions_rpc(self, revision_ids):
 
2639
        body = "\n".join(revision_ids)
 
2640
        path = self.bzrdir._path_for_remote_call(self._client)
 
2641
        response_tuple, response_handler = (
 
2642
            self._call_with_body_bytes_expecting_body(
 
2643
            "Repository.iter_revisions", (path, ), body))
 
2644
        if response_tuple[0] != "ok":
 
2645
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2646
        serializer_format = response_tuple[1]
 
2647
        serializer = serializer_format_registry.get(serializer_format)
 
2648
        byte_stream = response_handler.read_streamed_body()
 
2649
        decompressor = zlib.decompressobj()
 
2650
        chunks = []
 
2651
        for bytes in byte_stream:
 
2652
            chunks.append(decompressor.decompress(bytes))
 
2653
            if decompressor.unused_data != "":
 
2654
                chunks.append(decompressor.flush())
 
2655
                yield serializer.read_revision_from_string("".join(chunks))
 
2656
                unused = decompressor.unused_data
 
2657
                decompressor = zlib.decompressobj()
 
2658
                chunks = [decompressor.decompress(unused)]
 
2659
        chunks.append(decompressor.flush())
 
2660
        text = "".join(chunks)
 
2661
        if text != "":
 
2662
            yield serializer.read_revision_from_string("".join(chunks))
 
2663
 
1971
2664
    @needs_read_lock
1972
2665
    def get_revisions(self, revision_ids):
1973
 
        self._ensure_real()
1974
 
        return self._real_repository.get_revisions(revision_ids)
 
2666
        if revision_ids is None:
 
2667
            revision_ids = self.all_revision_ids()
 
2668
        else:
 
2669
            for rev_id in revision_ids:
 
2670
                if not rev_id or not isinstance(rev_id, basestring):
 
2671
                    raise errors.InvalidRevisionId(
 
2672
                        revision_id=rev_id, branch=self)
 
2673
        try:
 
2674
            missing = set(revision_ids)
 
2675
            revs = {}
 
2676
            for rev in self._iter_revisions_rpc(revision_ids):
 
2677
                missing.remove(rev.revision_id)
 
2678
                revs[rev.revision_id] = rev
 
2679
        except errors.UnknownSmartMethod:
 
2680
            self._ensure_real()
 
2681
            return self._real_repository.get_revisions(revision_ids)
 
2682
        for fallback in self._fallback_repositories:
 
2683
            if not missing:
 
2684
                break
 
2685
            for revid in list(missing):
 
2686
                # XXX JRV 2011-11-20: It would be nice if there was a
 
2687
                # public method on Repository that could be used to query
 
2688
                # for revision objects *without* failing completely if one
 
2689
                # was missing. There is VersionedFileRepository._iter_revisions,
 
2690
                # but unfortunately that's private and not provided by
 
2691
                # all repository implementations.
 
2692
                try:
 
2693
                    revs[revid] = fallback.get_revision(revid)
 
2694
                except errors.NoSuchRevision:
 
2695
                    pass
 
2696
                else:
 
2697
                    missing.remove(revid)
 
2698
        if missing:
 
2699
            raise errors.NoSuchRevision(self, list(missing)[0])
 
2700
        return [revs[revid] for revid in revision_ids]
1975
2701
 
1976
2702
    def supports_rich_root(self):
1977
2703
        return self._format.rich_root_data
1978
2704
 
1979
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1980
 
    def iter_reverse_revision_history(self, revision_id):
1981
 
        self._ensure_real()
1982
 
        return self._real_repository.iter_reverse_revision_history(revision_id)
1983
 
 
1984
2705
    @property
1985
2706
    def _serializer(self):
1986
2707
        return self._format._serializer
1987
2708
 
 
2709
    @needs_write_lock
1988
2710
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1989
 
        self._ensure_real()
1990
 
        return self._real_repository.store_revision_signature(
1991
 
            gpg_strategy, plaintext, revision_id)
 
2711
        signature = gpg_strategy.sign(plaintext)
 
2712
        self.add_signature_text(revision_id, signature)
1992
2713
 
1993
2714
    def add_signature_text(self, revision_id, signature):
1994
 
        self._ensure_real()
1995
 
        return self._real_repository.add_signature_text(revision_id, signature)
 
2715
        if self._real_repository:
 
2716
            # If there is a real repository the write group will
 
2717
            # be in the real repository as well, so use that:
 
2718
            self._ensure_real()
 
2719
            return self._real_repository.add_signature_text(
 
2720
                revision_id, signature)
 
2721
        path = self.bzrdir._path_for_remote_call(self._client)
 
2722
        response, handler = self._call_with_body_bytes_expecting_body(
 
2723
            'Repository.add_signature_text', (path, self._lock_token,
 
2724
                revision_id) + tuple(self._write_group_tokens), signature)
 
2725
        handler.cancel_read_body()
 
2726
        self.refresh_data()
 
2727
        if response[0] != 'ok':
 
2728
            raise errors.UnexpectedSmartServerResponse(response)
 
2729
        self._write_group_tokens = response[1:]
1996
2730
 
1997
2731
    def has_signature_for_revision_id(self, revision_id):
1998
 
        self._ensure_real()
1999
 
        return self._real_repository.has_signature_for_revision_id(revision_id)
 
2732
        path = self.bzrdir._path_for_remote_call(self._client)
 
2733
        try:
 
2734
            response = self._call('Repository.has_signature_for_revision_id',
 
2735
                path, revision_id)
 
2736
        except errors.UnknownSmartMethod:
 
2737
            self._ensure_real()
 
2738
            return self._real_repository.has_signature_for_revision_id(
 
2739
                revision_id)
 
2740
        if response[0] not in ('yes', 'no'):
 
2741
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2742
        if response[0] == 'yes':
 
2743
            return True
 
2744
        for fallback in self._fallback_repositories:
 
2745
            if fallback.has_signature_for_revision_id(revision_id):
 
2746
                return True
 
2747
        return False
 
2748
 
 
2749
    @needs_read_lock
 
2750
    def verify_revision_signature(self, revision_id, gpg_strategy):
 
2751
        if not self.has_signature_for_revision_id(revision_id):
 
2752
            return gpg.SIGNATURE_NOT_SIGNED, None
 
2753
        signature = self.get_signature_text(revision_id)
 
2754
 
 
2755
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2756
        plaintext = testament.as_short_text()
 
2757
 
 
2758
        return gpg_strategy.verify(signature, plaintext)
2000
2759
 
2001
2760
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
2002
2761
        self._ensure_real()
2192
2951
 
2193
2952
    def _real_stream(self, repo, search):
2194
2953
        """Get a stream for search from repo.
2195
 
        
2196
 
        This never called RemoteStreamSource.get_stream, and is a heler
2197
 
        for RemoteStreamSource._get_stream to allow getting a stream 
 
2954
 
 
2955
        This never called RemoteStreamSource.get_stream, and is a helper
 
2956
        for RemoteStreamSource._get_stream to allow getting a stream
2198
2957
        reliably whether fallback back because of old servers or trying
2199
2958
        to stream from a non-RemoteRepository (which the stacked support
2200
2959
        code will do).
2242
3001
            except errors.UnknownSmartMethod:
2243
3002
                medium._remember_remote_is_before(version)
2244
3003
            except errors.UnknownErrorFromSmartServer, e:
2245
 
                if isinstance(search, graph.EverythingResult):
 
3004
                if isinstance(search, vf_search.EverythingResult):
2246
3005
                    error_verb = e.error_from_smart_server.error_verb
2247
3006
                    if error_verb == 'BadSearch':
2248
3007
                        # Pre-2.4 servers don't support this sort of search.
2340
3099
 
2341
3100
    def _ensure_real(self):
2342
3101
        if self._custom_format is None:
2343
 
            self._custom_format = branch.network_format_registry.get(
2344
 
                self._network_name)
 
3102
            try:
 
3103
                self._custom_format = branch.network_format_registry.get(
 
3104
                    self._network_name)
 
3105
            except KeyError:
 
3106
                raise errors.UnknownFormatError(kind='branch',
 
3107
                    format=self._network_name)
2345
3108
 
2346
3109
    def get_format_description(self):
2347
3110
        self._ensure_real()
2354
3117
        return a_bzrdir.open_branch(name=name, 
2355
3118
            ignore_fallbacks=ignore_fallbacks)
2356
3119
 
2357
 
    def _vfs_initialize(self, a_bzrdir, name):
 
3120
    def _vfs_initialize(self, a_bzrdir, name, append_revisions_only,
 
3121
                        repository=None):
2358
3122
        # Initialisation when using a local bzrdir object, or a non-vfs init
2359
3123
        # method is not available on the server.
2360
3124
        # self._custom_format is always set - the start of initialize ensures
2362
3126
        if isinstance(a_bzrdir, RemoteBzrDir):
2363
3127
            a_bzrdir._ensure_real()
2364
3128
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2365
 
                name)
 
3129
                name=name, append_revisions_only=append_revisions_only,
 
3130
                repository=repository)
2366
3131
        else:
2367
3132
            # We assume the bzrdir is parameterised; it may not be.
2368
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
3133
            result = self._custom_format.initialize(a_bzrdir, name=name,
 
3134
                append_revisions_only=append_revisions_only,
 
3135
                repository=repository)
2369
3136
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2370
3137
            not isinstance(result, RemoteBranch)):
2371
3138
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2372
3139
                                  name=name)
2373
3140
        return result
2374
3141
 
2375
 
    def initialize(self, a_bzrdir, name=None, repository=None):
 
3142
    def initialize(self, a_bzrdir, name=None, repository=None,
 
3143
                   append_revisions_only=None):
 
3144
        if name is None:
 
3145
            name = a_bzrdir._get_selected_branch()
2376
3146
        # 1) get the network name to use.
2377
3147
        if self._custom_format:
2378
3148
            network_name = self._custom_format.network_name()
2379
3149
        else:
2380
3150
            # Select the current bzrlib default and ask for that.
2381
 
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
 
3151
            reference_bzrdir_format = controldir.format_registry.get('default')()
2382
3152
            reference_format = reference_bzrdir_format.get_branch_format()
2383
3153
            self._custom_format = reference_format
2384
3154
            network_name = reference_format.network_name()
2385
3155
        # Being asked to create on a non RemoteBzrDir:
2386
3156
        if not isinstance(a_bzrdir, RemoteBzrDir):
2387
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
3157
            return self._vfs_initialize(a_bzrdir, name=name,
 
3158
                append_revisions_only=append_revisions_only,
 
3159
                repository=repository)
2388
3160
        medium = a_bzrdir._client._medium
2389
3161
        if medium._is_remote_before((1, 13)):
2390
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
3162
            return self._vfs_initialize(a_bzrdir, name=name,
 
3163
                append_revisions_only=append_revisions_only,
 
3164
                repository=repository)
2391
3165
        # Creating on a remote bzr dir.
2392
3166
        # 2) try direct creation via RPC
2393
3167
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2394
 
        if name is not None:
 
3168
        if name != "":
2395
3169
            # XXX JRV20100304: Support creating colocated branches
2396
3170
            raise errors.NoColocatedBranchSupport(self)
2397
3171
        verb = 'BzrDir.create_branch'
2400
3174
        except errors.UnknownSmartMethod:
2401
3175
            # Fallback - use vfs methods
2402
3176
            medium._remember_remote_is_before((1, 13))
2403
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
3177
            return self._vfs_initialize(a_bzrdir, name=name,
 
3178
                    append_revisions_only=append_revisions_only,
 
3179
                    repository=repository)
2404
3180
        if response[0] != 'ok':
2405
3181
            raise errors.UnexpectedSmartServerResponse(response)
2406
3182
        # Turn the response into a RemoteRepository object.
2427
3203
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2428
3204
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2429
3205
            format=format, setup_stacking=False, name=name)
 
3206
        if append_revisions_only:
 
3207
            remote_branch.set_append_revisions_only(append_revisions_only)
2430
3208
        # XXX: We know this is a new branch, so it must have revno 0, revid
2431
3209
        # NULL_REVISION. Creating the branch locked would make this be unable
2432
3210
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2465
3243
                return True
2466
3244
        return False
2467
3245
 
 
3246
 
 
3247
class RemoteBranchStore(_mod_config.IniFileStore):
 
3248
    """Branch store which attempts to use HPSS calls to retrieve branch store.
 
3249
 
 
3250
    Note that this is specific to bzr-based formats.
 
3251
    """
 
3252
 
 
3253
    def __init__(self, branch):
 
3254
        super(RemoteBranchStore, self).__init__()
 
3255
        self.branch = branch
 
3256
        self.id = "branch"
 
3257
        self._real_store = None
 
3258
 
 
3259
    def external_url(self):
 
3260
        return urlutils.join(self.branch.user_url, 'branch.conf')
 
3261
 
 
3262
    def _load_content(self):
 
3263
        path = self.branch._remote_path()
 
3264
        try:
 
3265
            response, handler = self.branch._call_expecting_body(
 
3266
                'Branch.get_config_file', path)
 
3267
        except errors.UnknownSmartMethod:
 
3268
            self._ensure_real()
 
3269
            return self._real_store._load_content()
 
3270
        if len(response) and response[0] != 'ok':
 
3271
            raise errors.UnexpectedSmartServerResponse(response)
 
3272
        return handler.read_body_bytes()
 
3273
 
 
3274
    def _save_content(self, content):
 
3275
        path = self.branch._remote_path()
 
3276
        try:
 
3277
            response, handler = self.branch._call_with_body_bytes_expecting_body(
 
3278
                'Branch.put_config_file', (path,
 
3279
                    self.branch._lock_token, self.branch._repo_lock_token),
 
3280
                content)
 
3281
        except errors.UnknownSmartMethod:
 
3282
            self._ensure_real()
 
3283
            return self._real_store._save_content(content)
 
3284
        handler.cancel_read_body()
 
3285
        if response != ('ok', ):
 
3286
            raise errors.UnexpectedSmartServerResponse(response)
 
3287
 
 
3288
    def _ensure_real(self):
 
3289
        self.branch._ensure_real()
 
3290
        if self._real_store is None:
 
3291
            self._real_store = _mod_config.BranchStore(self.branch)
 
3292
 
 
3293
 
2468
3294
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2469
3295
    """Branch stored on a server accessed by HPSS RPC.
2470
3296
 
2472
3298
    """
2473
3299
 
2474
3300
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2475
 
        _client=None, format=None, setup_stacking=True, name=None):
 
3301
        _client=None, format=None, setup_stacking=True, name=None,
 
3302
        possible_transports=None):
2476
3303
        """Create a RemoteBranch instance.
2477
3304
 
2478
3305
        :param real_branch: An optional local implementation of the branch
2490
3317
        # will try to assign to self.tags, which is a property in this subclass.
2491
3318
        # And the parent's __init__ doesn't do much anyway.
2492
3319
        self.bzrdir = remote_bzrdir
 
3320
        self.name = name
2493
3321
        if _client is not None:
2494
3322
            self._client = _client
2495
3323
        else:
2518
3346
        self._repo_lock_token = None
2519
3347
        self._lock_count = 0
2520
3348
        self._leave_lock = False
 
3349
        self.conf_store = None
2521
3350
        # Setup a format: note that we cannot call _ensure_real until all the
2522
3351
        # attributes above are set: This code cannot be moved higher up in this
2523
3352
        # function.
2543
3372
            hook(self)
2544
3373
        self._is_stacked = False
2545
3374
        if setup_stacking:
2546
 
            self._setup_stacking()
 
3375
            self._setup_stacking(possible_transports)
2547
3376
 
2548
 
    def _setup_stacking(self):
 
3377
    def _setup_stacking(self, possible_transports):
2549
3378
        # configure stacking into the remote repository, by reading it from
2550
3379
        # the vfs branch.
2551
3380
        try:
2554
3383
            errors.UnstackableRepositoryFormat), e:
2555
3384
            return
2556
3385
        self._is_stacked = True
2557
 
        self._activate_fallback_location(fallback_url)
 
3386
        if possible_transports is None:
 
3387
            possible_transports = []
 
3388
        else:
 
3389
            possible_transports = list(possible_transports)
 
3390
        possible_transports.append(self.bzrdir.root_transport)
 
3391
        self._activate_fallback_location(fallback_url,
 
3392
            possible_transports=possible_transports)
2558
3393
 
2559
3394
    def _get_config(self):
2560
3395
        return RemoteBranchConfig(self)
2561
3396
 
 
3397
    def _get_config_store(self):
 
3398
        if self.conf_store is None:
 
3399
            self.conf_store =  RemoteBranchStore(self)
 
3400
        return self.conf_store
 
3401
 
 
3402
    def store_uncommitted(self, creator):
 
3403
        self._ensure_real()
 
3404
        return self._real_branch.store_uncommitted(creator)
 
3405
 
 
3406
    def get_unshelver(self, tree):
 
3407
        self._ensure_real()
 
3408
        return self._real_branch.get_unshelver(tree)
 
3409
 
2562
3410
    def _get_real_transport(self):
2563
3411
        # if we try vfs access, return the real branch's vfs transport
2564
3412
        self._ensure_real()
2583
3431
            self.bzrdir._ensure_real()
2584
3432
            self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2585
3433
                ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
 
3434
            # The remote branch and the real branch shares the same store. If
 
3435
            # we don't, there will always be cases where one of the stores
 
3436
            # doesn't see an update made on the other.
 
3437
            self._real_branch.conf_store = self.conf_store
2586
3438
            if self.repository._real_repository is None:
2587
3439
                # Give the remote repository the matching real repo.
2588
3440
                real_repo = self._real_branch.repository
2627
3479
                self.bzrdir, self._client)
2628
3480
        return self._control_files
2629
3481
 
2630
 
    def _get_checkout_format(self):
2631
 
        self._ensure_real()
2632
 
        return self._real_branch._get_checkout_format()
2633
 
 
2634
3482
    def get_physical_lock_status(self):
2635
3483
        """See Branch.get_physical_lock_status()."""
2636
 
        # should be an API call to the server, as branches must be lockable.
2637
 
        self._ensure_real()
2638
 
        return self._real_branch.get_physical_lock_status()
 
3484
        try:
 
3485
            response = self._client.call('Branch.get_physical_lock_status',
 
3486
                self._remote_path())
 
3487
        except errors.UnknownSmartMethod:
 
3488
            self._ensure_real()
 
3489
            return self._real_branch.get_physical_lock_status()
 
3490
        if response[0] not in ('yes', 'no'):
 
3491
            raise errors.UnexpectedSmartServerResponse(response)
 
3492
        return (response[0] == 'yes')
2639
3493
 
2640
3494
    def get_stacked_on_url(self):
2641
3495
        """Get the URL this branch is stacked against.
2664
3518
 
2665
3519
    def set_stacked_on_url(self, url):
2666
3520
        branch.Branch.set_stacked_on_url(self, url)
 
3521
        # We need the stacked_on_url to be visible both locally (to not query
 
3522
        # it repeatedly) and remotely (so smart verbs can get it server side)
 
3523
        # Without the following line,
 
3524
        # bzrlib.tests.per_branch.test_create_clone.TestCreateClone
 
3525
        # .test_create_clone_on_transport_stacked_hooks_get_stacked_branch
 
3526
        # fails for remote branches -- vila 2012-01-04
 
3527
        self.conf_store.save_changes()
2667
3528
        if not url:
2668
3529
            self._is_stacked = False
2669
3530
        else:
2797
3658
        try:
2798
3659
            self._lock_count -= 1
2799
3660
            if not self._lock_count:
 
3661
                if self.conf_store is not None:
 
3662
                    self.conf_store.save_changes()
2800
3663
                self._clear_cached_state()
2801
3664
                mode = self._lock_mode
2802
3665
                self._lock_mode = None
2825
3688
            self.repository.unlock()
2826
3689
 
2827
3690
    def break_lock(self):
2828
 
        self._ensure_real()
2829
 
        return self._real_branch.break_lock()
 
3691
        try:
 
3692
            response = self._call(
 
3693
                'Branch.break_lock', self._remote_path())
 
3694
        except errors.UnknownSmartMethod:
 
3695
            self._ensure_real()
 
3696
            return self._real_branch.break_lock()
 
3697
        if response != ('ok',):
 
3698
            raise errors.UnexpectedSmartServerResponse(response)
2830
3699
 
2831
3700
    def leave_lock_in_place(self):
2832
3701
        if not self._lock_token:
2925
3794
            raise errors.UnexpectedSmartServerResponse(response)
2926
3795
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2927
3796
 
2928
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2929
 
    @needs_write_lock
2930
 
    def set_revision_history(self, rev_history):
2931
 
        """See Branch.set_revision_history."""
2932
 
        self._set_revision_history(rev_history)
2933
 
 
2934
 
    @needs_write_lock
2935
 
    def _set_revision_history(self, rev_history):
2936
 
        # Send just the tip revision of the history; the server will generate
2937
 
        # the full history from that.  If the revision doesn't exist in this
2938
 
        # branch, NoSuchRevision will be raised.
2939
 
        if rev_history == []:
2940
 
            rev_id = 'null:'
2941
 
        else:
2942
 
            rev_id = rev_history[-1]
2943
 
        self._set_last_revision(rev_id)
2944
 
        for hook in branch.Branch.hooks['set_rh']:
2945
 
            hook(self, rev_history)
2946
 
        self._cache_revision_history(rev_history)
2947
 
 
2948
3797
    def _get_parent_location(self):
2949
3798
        medium = self._client._medium
2950
3799
        if medium._is_remote_before((1, 13)):
3002
3851
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
3003
3852
            _override_hook_source_branch=self)
3004
3853
 
 
3854
    def peek_lock_mode(self):
 
3855
        return self._lock_mode
 
3856
 
3005
3857
    def is_locked(self):
3006
3858
        return self._lock_count >= 1
3007
3859
 
3008
3860
    @needs_read_lock
 
3861
    def revision_id_to_dotted_revno(self, revision_id):
 
3862
        """Given a revision id, return its dotted revno.
 
3863
 
 
3864
        :return: a tuple like (1,) or (400,1,3).
 
3865
        """
 
3866
        try:
 
3867
            response = self._call('Branch.revision_id_to_revno',
 
3868
                self._remote_path(), revision_id)
 
3869
        except errors.UnknownSmartMethod:
 
3870
            self._ensure_real()
 
3871
            return self._real_branch.revision_id_to_dotted_revno(revision_id)
 
3872
        if response[0] == 'ok':
 
3873
            return tuple([int(x) for x in response[1:]])
 
3874
        else:
 
3875
            raise errors.UnexpectedSmartServerResponse(response)
 
3876
 
 
3877
    @needs_read_lock
3009
3878
    def revision_id_to_revno(self, revision_id):
3010
 
        self._ensure_real()
3011
 
        return self._real_branch.revision_id_to_revno(revision_id)
 
3879
        """Given a revision id on the branch mainline, return its revno.
 
3880
 
 
3881
        :return: an integer
 
3882
        """
 
3883
        try:
 
3884
            response = self._call('Branch.revision_id_to_revno',
 
3885
                self._remote_path(), revision_id)
 
3886
        except errors.UnknownSmartMethod:
 
3887
            self._ensure_real()
 
3888
            return self._real_branch.revision_id_to_revno(revision_id)
 
3889
        if response[0] == 'ok':
 
3890
            if len(response) == 2:
 
3891
                return int(response[1])
 
3892
            raise NoSuchRevision(self, revision_id)
 
3893
        else:
 
3894
            raise errors.UnexpectedSmartServerResponse(response)
3012
3895
 
3013
3896
    @needs_write_lock
3014
3897
    def set_last_revision_info(self, revno, revision_id):
3051
3934
            except errors.UnknownSmartMethod:
3052
3935
                medium._remember_remote_is_before((1, 6))
3053
3936
        self._clear_cached_state_of_remote_branch_only()
3054
 
        self._set_revision_history(self._lefthand_history(revision_id,
3055
 
            last_rev=last_rev,other_branch=other_branch))
 
3937
        graph = self.repository.get_graph()
 
3938
        (last_revno, last_revid) = self.last_revision_info()
 
3939
        known_revision_ids = [
 
3940
            (last_revid, last_revno),
 
3941
            (_mod_revision.NULL_REVISION, 0),
 
3942
            ]
 
3943
        if last_rev is not None:
 
3944
            if not graph.is_ancestor(last_rev, revision_id):
 
3945
                # our previous tip is not merged into stop_revision
 
3946
                raise errors.DivergedBranches(self, other_branch)
 
3947
        revno = graph.find_distance_to_null(revision_id, known_revision_ids)
 
3948
        self.set_last_revision_info(revno, revision_id)
3056
3949
 
3057
3950
    def set_push_location(self, location):
3058
 
        self._ensure_real()
3059
 
        return self._real_branch.set_push_location(location)
 
3951
        self._set_config_location('push_location', location)
3060
3952
 
3061
3953
    def heads_to_fetch(self):
3062
3954
        if self._format._use_default_local_heads_to_fetch():
3118
4010
                value = section_obj.get(name, default)
3119
4011
        except errors.UnknownSmartMethod:
3120
4012
            value = self._vfs_get_option(name, section, default)
3121
 
        for hook in config.OldConfigHooks['get']:
 
4013
        for hook in _mod_config.OldConfigHooks['get']:
3122
4014
            hook(self, name, value)
3123
4015
        return value
3124
4016
 
3126
4018
        if len(response[0]) and response[0][0] != 'ok':
3127
4019
            raise errors.UnexpectedSmartServerResponse(response)
3128
4020
        lines = response[1].read_body_bytes().splitlines()
3129
 
        conf = config.ConfigObj(lines, encoding='utf-8')
3130
 
        for hook in config.OldConfigHooks['load']:
 
4021
        conf = _mod_config.ConfigObj(lines, encoding='utf-8')
 
4022
        for hook in _mod_config.OldConfigHooks['load']:
3131
4023
            hook(self)
3132
4024
        return conf
3133
4025
 
3243
4135
        return self._bzrdir._real_bzrdir
3244
4136
 
3245
4137
 
3246
 
 
3247
4138
def _extract_tar(tar, to_dir):
3248
4139
    """Extract all the contents of a tarfile object.
3249
4140
 
3253
4144
        tar.extract(tarinfo, to_dir)
3254
4145
 
3255
4146
 
 
4147
error_translators = registry.Registry()
 
4148
no_context_error_translators = registry.Registry()
 
4149
 
 
4150
 
3256
4151
def _translate_error(err, **context):
3257
4152
    """Translate an ErrorFromSmartServer into a more useful error.
3258
4153
 
3287
4182
                    'Missing key %r in context %r', key_err.args[0], context)
3288
4183
                raise err
3289
4184
 
3290
 
    if err.error_verb == 'NoSuchRevision':
3291
 
        raise NoSuchRevision(find('branch'), err.error_args[0])
3292
 
    elif err.error_verb == 'nosuchrevision':
3293
 
        raise NoSuchRevision(find('repository'), err.error_args[0])
3294
 
    elif err.error_verb == 'nobranch':
3295
 
        if len(err.error_args) >= 1:
3296
 
            extra = err.error_args[0]
3297
 
        else:
3298
 
            extra = None
3299
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
3300
 
            detail=extra)
3301
 
    elif err.error_verb == 'norepository':
3302
 
        raise errors.NoRepositoryPresent(find('bzrdir'))
3303
 
    elif err.error_verb == 'UnlockableTransport':
3304
 
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
3305
 
    elif err.error_verb == 'TokenMismatch':
3306
 
        raise errors.TokenMismatch(find('token'), '(remote token)')
3307
 
    elif err.error_verb == 'Diverged':
3308
 
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
3309
 
    elif err.error_verb == 'NotStacked':
3310
 
        raise errors.NotStacked(branch=find('branch'))
3311
 
    elif err.error_verb == 'PermissionDenied':
3312
 
        path = get_path()
3313
 
        if len(err.error_args) >= 2:
3314
 
            extra = err.error_args[1]
3315
 
        else:
3316
 
            extra = None
3317
 
        raise errors.PermissionDenied(path, extra=extra)
3318
 
    elif err.error_verb == 'ReadError':
3319
 
        path = get_path()
3320
 
        raise errors.ReadError(path)
3321
 
    elif err.error_verb == 'NoSuchFile':
3322
 
        path = get_path()
3323
 
        raise errors.NoSuchFile(path)
3324
 
    _translate_error_without_context(err)
3325
 
 
3326
 
 
3327
 
def _translate_error_without_context(err):
3328
 
    """Translate any ErrorFromSmartServer values that don't require context"""
3329
 
    if err.error_verb == 'IncompatibleRepositories':
3330
 
        raise errors.IncompatibleRepositories(err.error_args[0],
3331
 
            err.error_args[1], err.error_args[2])
3332
 
    elif err.error_verb == 'LockContention':
3333
 
        raise errors.LockContention('(remote lock)')
3334
 
    elif err.error_verb == 'LockFailed':
3335
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
3336
 
    elif err.error_verb == 'TipChangeRejected':
3337
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
3338
 
    elif err.error_verb == 'UnstackableBranchFormat':
3339
 
        raise errors.UnstackableBranchFormat(*err.error_args)
3340
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
3341
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
3342
 
    elif err.error_verb == 'FileExists':
3343
 
        raise errors.FileExists(err.error_args[0])
3344
 
    elif err.error_verb == 'DirectoryNotEmpty':
3345
 
        raise errors.DirectoryNotEmpty(err.error_args[0])
3346
 
    elif err.error_verb == 'ShortReadvError':
3347
 
        args = err.error_args
3348
 
        raise errors.ShortReadvError(
3349
 
            args[0], int(args[1]), int(args[2]), int(args[3]))
3350
 
    elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
 
4185
    try:
 
4186
        translator = error_translators.get(err.error_verb)
 
4187
    except KeyError:
 
4188
        pass
 
4189
    else:
 
4190
        raise translator(err, find, get_path)
 
4191
    try:
 
4192
        translator = no_context_error_translators.get(err.error_verb)
 
4193
    except KeyError:
 
4194
        raise errors.UnknownErrorFromSmartServer(err)
 
4195
    else:
 
4196
        raise translator(err)
 
4197
 
 
4198
 
 
4199
error_translators.register('NoSuchRevision',
 
4200
    lambda err, find, get_path: NoSuchRevision(
 
4201
        find('branch'), err.error_args[0]))
 
4202
error_translators.register('nosuchrevision',
 
4203
    lambda err, find, get_path: NoSuchRevision(
 
4204
        find('repository'), err.error_args[0]))
 
4205
 
 
4206
def _translate_nobranch_error(err, find, get_path):
 
4207
    if len(err.error_args) >= 1:
 
4208
        extra = err.error_args[0]
 
4209
    else:
 
4210
        extra = None
 
4211
    return errors.NotBranchError(path=find('bzrdir').root_transport.base,
 
4212
        detail=extra)
 
4213
 
 
4214
error_translators.register('nobranch', _translate_nobranch_error)
 
4215
error_translators.register('norepository',
 
4216
    lambda err, find, get_path: errors.NoRepositoryPresent(
 
4217
        find('bzrdir')))
 
4218
error_translators.register('UnlockableTransport',
 
4219
    lambda err, find, get_path: errors.UnlockableTransport(
 
4220
        find('bzrdir').root_transport))
 
4221
error_translators.register('TokenMismatch',
 
4222
    lambda err, find, get_path: errors.TokenMismatch(
 
4223
        find('token'), '(remote token)'))
 
4224
error_translators.register('Diverged',
 
4225
    lambda err, find, get_path: errors.DivergedBranches(
 
4226
        find('branch'), find('other_branch')))
 
4227
error_translators.register('NotStacked',
 
4228
    lambda err, find, get_path: errors.NotStacked(branch=find('branch')))
 
4229
 
 
4230
def _translate_PermissionDenied(err, find, get_path):
 
4231
    path = get_path()
 
4232
    if len(err.error_args) >= 2:
 
4233
        extra = err.error_args[1]
 
4234
    else:
 
4235
        extra = None
 
4236
    return errors.PermissionDenied(path, extra=extra)
 
4237
 
 
4238
error_translators.register('PermissionDenied', _translate_PermissionDenied)
 
4239
error_translators.register('ReadError',
 
4240
    lambda err, find, get_path: errors.ReadError(get_path()))
 
4241
error_translators.register('NoSuchFile',
 
4242
    lambda err, find, get_path: errors.NoSuchFile(get_path()))
 
4243
error_translators.register('TokenLockingNotSupported',
 
4244
    lambda err, find, get_path: errors.TokenLockingNotSupported(
 
4245
        find('repository')))
 
4246
error_translators.register('UnsuspendableWriteGroup',
 
4247
    lambda err, find, get_path: errors.UnsuspendableWriteGroup(
 
4248
        repository=find('repository')))
 
4249
error_translators.register('UnresumableWriteGroup',
 
4250
    lambda err, find, get_path: errors.UnresumableWriteGroup(
 
4251
        repository=find('repository'), write_groups=err.error_args[0],
 
4252
        reason=err.error_args[1]))
 
4253
no_context_error_translators.register('IncompatibleRepositories',
 
4254
    lambda err: errors.IncompatibleRepositories(
 
4255
        err.error_args[0], err.error_args[1], err.error_args[2]))
 
4256
no_context_error_translators.register('LockContention',
 
4257
    lambda err: errors.LockContention('(remote lock)'))
 
4258
no_context_error_translators.register('LockFailed',
 
4259
    lambda err: errors.LockFailed(err.error_args[0], err.error_args[1]))
 
4260
no_context_error_translators.register('TipChangeRejected',
 
4261
    lambda err: errors.TipChangeRejected(err.error_args[0].decode('utf8')))
 
4262
no_context_error_translators.register('UnstackableBranchFormat',
 
4263
    lambda err: errors.UnstackableBranchFormat(*err.error_args))
 
4264
no_context_error_translators.register('UnstackableRepositoryFormat',
 
4265
    lambda err: errors.UnstackableRepositoryFormat(*err.error_args))
 
4266
no_context_error_translators.register('FileExists',
 
4267
    lambda err: errors.FileExists(err.error_args[0]))
 
4268
no_context_error_translators.register('DirectoryNotEmpty',
 
4269
    lambda err: errors.DirectoryNotEmpty(err.error_args[0]))
 
4270
 
 
4271
def _translate_short_readv_error(err):
 
4272
    args = err.error_args
 
4273
    return errors.ShortReadvError(args[0], int(args[1]), int(args[2]),
 
4274
        int(args[3]))
 
4275
 
 
4276
no_context_error_translators.register('ShortReadvError',
 
4277
    _translate_short_readv_error)
 
4278
 
 
4279
def _translate_unicode_error(err):
3351
4280
        encoding = str(err.error_args[0]) # encoding must always be a string
3352
4281
        val = err.error_args[1]
3353
4282
        start = int(err.error_args[2])
3361
4290
            raise UnicodeDecodeError(encoding, val, start, end, reason)
3362
4291
        elif err.error_verb == 'UnicodeEncodeError':
3363
4292
            raise UnicodeEncodeError(encoding, val, start, end, reason)
3364
 
    elif err.error_verb == 'ReadOnlyError':
3365
 
        raise errors.TransportNotPossible('readonly transport')
3366
 
    elif err.error_verb == 'MemoryError':
3367
 
        raise errors.BzrError("remote server out of memory\n"
3368
 
            "Retry non-remotely, or contact the server admin for details.")
3369
 
    raise errors.UnknownErrorFromSmartServer(err)
 
4293
 
 
4294
no_context_error_translators.register('UnicodeEncodeError',
 
4295
    _translate_unicode_error)
 
4296
no_context_error_translators.register('UnicodeDecodeError',
 
4297
    _translate_unicode_error)
 
4298
no_context_error_translators.register('ReadOnlyError',
 
4299
    lambda err: errors.TransportNotPossible('readonly transport'))
 
4300
no_context_error_translators.register('MemoryError',
 
4301
    lambda err: errors.BzrError("remote server out of memory\n"
 
4302
        "Retry non-remotely, or contact the server admin for details."))
 
4303
no_context_error_translators.register('RevisionNotPresent',
 
4304
    lambda err: errors.RevisionNotPresent(err.error_args[0], err.error_args[1]))
 
4305
 
 
4306
no_context_error_translators.register('BzrCheckError',
 
4307
    lambda err: errors.BzrCheckError(msg=err.error_args[0]))
 
4308