← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

(gz) Fix deprecations of win32utils path function unicode wrappers (Martin
 Packman)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
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,
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
 
 
63
 
 
64
_DEFAULT_SEARCH_DEPTH = 100
49
65
 
50
66
 
51
67
class _RpcHelper(object):
110
126
 
111
127
    def get_format_description(self):
112
128
        if self._network_name:
113
 
            real_format = controldir.network_format_registry.get(self._network_name)
114
 
            return 'Remote: ' + real_format.get_format_description()
 
129
            try:
 
130
                real_format = controldir.network_format_registry.get(
 
131
                        self._network_name)
 
132
            except KeyError:
 
133
                pass
 
134
            else:
 
135
                return 'Remote: ' + real_format.get_format_description()
115
136
        return 'bzr remote bzrdir'
116
137
 
117
138
    def get_format_string(self):
327
348
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
328
349
 
329
350
 
 
351
class RemoteControlStore(config.IniFileStore):
 
352
    """Control store which attempts to use HPSS calls to retrieve control store.
 
353
 
 
354
    Note that this is specific to bzr-based formats.
 
355
    """
 
356
 
 
357
    def __init__(self, bzrdir):
 
358
        super(RemoteControlStore, self).__init__()
 
359
        self.bzrdir = bzrdir
 
360
        self._real_store = None
 
361
 
 
362
    def lock_write(self, token=None):
 
363
        self._ensure_real()
 
364
        return self._real_store.lock_write(token)
 
365
 
 
366
    def unlock(self):
 
367
        self._ensure_real()
 
368
        return self._real_store.unlock()
 
369
 
 
370
    @needs_write_lock
 
371
    def save(self):
 
372
        # We need to be able to override the undecorated implementation
 
373
        self.save_without_locking()
 
374
 
 
375
    def save_without_locking(self):
 
376
        super(RemoteControlStore, self).save()
 
377
 
 
378
    def _ensure_real(self):
 
379
        self.bzrdir._ensure_real()
 
380
        if self._real_store is None:
 
381
            self._real_store = config.ControlStore(self.bzrdir)
 
382
 
 
383
    def external_url(self):
 
384
        return self.bzrdir.user_url
 
385
 
 
386
    def _load_content(self):
 
387
        medium = self.bzrdir._client._medium
 
388
        path = self.bzrdir._path_for_remote_call(self.bzrdir._client)
 
389
        try:
 
390
            response, handler = self.bzrdir._call_expecting_body(
 
391
                'BzrDir.get_config_file', path)
 
392
        except errors.UnknownSmartMethod:
 
393
            self._ensure_real()
 
394
            return self._real_store._load_content()
 
395
        if len(response) and response[0] != 'ok':
 
396
            raise errors.UnexpectedSmartServerResponse(response)
 
397
        return handler.read_body_bytes()
 
398
 
 
399
    def _save_content(self, content):
 
400
        # FIXME JRV 2011-11-22: Ideally this should use a
 
401
        # HPSS call too, but at the moment it is not possible
 
402
        # to write lock control directories.
 
403
        self._ensure_real()
 
404
        return self._real_store._save_content(content)
 
405
 
 
406
 
330
407
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
331
408
    """Control directory on a remote server, accessed via bzr:// or similar."""
332
409
 
416
493
        self._next_open_branch_result = None
417
494
        return _mod_bzrdir.BzrDir.break_lock(self)
418
495
 
 
496
    def _vfs_checkout_metadir(self):
 
497
        self._ensure_real()
 
498
        return self._real_bzrdir.checkout_metadir()
 
499
 
 
500
    def checkout_metadir(self):
 
501
        """Retrieve the controldir format to use for checkouts of this one.
 
502
        """
 
503
        medium = self._client._medium
 
504
        if medium._is_remote_before((2, 5)):
 
505
            return self._vfs_checkout_metadir()
 
506
        path = self._path_for_remote_call(self._client)
 
507
        try:
 
508
            response = self._client.call('BzrDir.checkout_metadir',
 
509
                path)
 
510
        except errors.UnknownSmartMethod:
 
511
            medium._remember_remote_is_before((2, 5))
 
512
            return self._vfs_checkout_metadir()
 
513
        if len(response) != 3:
 
514
            raise errors.UnexpectedSmartServerResponse(response)
 
515
        control_name, repo_name, branch_name = response
 
516
        try:
 
517
            format = controldir.network_format_registry.get(control_name)
 
518
        except KeyError:
 
519
            raise errors.UnknownFormatError(kind='control',
 
520
                format=control_name)
 
521
        if repo_name:
 
522
            try:
 
523
                repo_format = _mod_repository.network_format_registry.get(
 
524
                    repo_name)
 
525
            except KeyError:
 
526
                raise errors.UnknownFormatError(kind='repository',
 
527
                    format=repo_name)
 
528
            format.repository_format = repo_format
 
529
        if branch_name:
 
530
            try:
 
531
                format.set_branch_format(
 
532
                    branch.network_format_registry.get(branch_name))
 
533
            except KeyError:
 
534
                raise errors.UnknownFormatError(kind='branch',
 
535
                    format=branch_name)
 
536
        return format
 
537
 
419
538
    def _vfs_cloning_metadir(self, require_stacking=False):
420
539
        self._ensure_real()
421
540
        return self._real_bzrdir.cloning_metadir(
451
570
        if len(branch_info) != 2:
452
571
            raise errors.UnexpectedSmartServerResponse(response)
453
572
        branch_ref, branch_name = branch_info
454
 
        format = controldir.network_format_registry.get(control_name)
 
573
        try:
 
574
            format = controldir.network_format_registry.get(control_name)
 
575
        except KeyError:
 
576
            raise errors.UnknownFormatError(kind='control', format=control_name)
 
577
 
455
578
        if repo_name:
456
 
            format.repository_format = _mod_repository.network_format_registry.get(
457
 
                repo_name)
 
579
            try:
 
580
                format.repository_format = _mod_repository.network_format_registry.get(
 
581
                    repo_name)
 
582
            except KeyError:
 
583
                raise errors.UnknownFormatError(kind='repository',
 
584
                    format=repo_name)
458
585
        if branch_ref == 'ref':
459
586
            # XXX: we need possible_transports here to avoid reopening the
460
587
            # connection to the referenced location
463
590
            format.set_branch_format(branch_format)
464
591
        elif branch_ref == 'branch':
465
592
            if branch_name:
466
 
                format.set_branch_format(
467
 
                    branch.network_format_registry.get(branch_name))
 
593
                try:
 
594
                    branch_format = branch.network_format_registry.get(
 
595
                        branch_name)
 
596
                except KeyError:
 
597
                    raise errors.UnknownFormatError(kind='branch',
 
598
                        format=branch_name)
 
599
                format.set_branch_format(branch_format)
468
600
        else:
469
601
            raise errors.UnexpectedSmartServerResponse(response)
470
602
        return format
480
612
 
481
613
    def destroy_repository(self):
482
614
        """See BzrDir.destroy_repository"""
483
 
        self._ensure_real()
484
 
        self._real_bzrdir.destroy_repository()
 
615
        path = self._path_for_remote_call(self._client)
 
616
        try:
 
617
            response = self._call('BzrDir.destroy_repository', path)
 
618
        except errors.UnknownSmartMethod:
 
619
            self._ensure_real()
 
620
            self._real_bzrdir.destroy_repository()
 
621
            return
 
622
        if response[0] != 'ok':
 
623
            raise SmartProtocolError('unexpected response code %s' % (response,))
485
624
 
486
 
    def create_branch(self, name=None, repository=None):
 
625
    def create_branch(self, name=None, repository=None,
 
626
                      append_revisions_only=None):
487
627
        # as per meta1 formats - just delegate to the format object which may
488
628
        # be parameterised.
489
629
        real_branch = self._format.get_branch_format().initialize(self,
490
 
            name=name, repository=repository)
 
630
            name=name, repository=repository,
 
631
            append_revisions_only=append_revisions_only)
491
632
        if not isinstance(real_branch, RemoteBranch):
492
633
            if not isinstance(repository, RemoteRepository):
493
634
                raise AssertionError(
507
648
 
508
649
    def destroy_branch(self, name=None):
509
650
        """See BzrDir.destroy_branch"""
510
 
        self._ensure_real()
511
 
        self._real_bzrdir.destroy_branch(name=name)
 
651
        path = self._path_for_remote_call(self._client)
 
652
        try:
 
653
            if name is not None:
 
654
                args = (name, )
 
655
            else:
 
656
                args = ()
 
657
            response = self._call('BzrDir.destroy_branch', path, *args)
 
658
        except errors.UnknownSmartMethod:
 
659
            self._ensure_real()
 
660
            self._real_bzrdir.destroy_branch(name=name)
 
661
            self._next_open_branch_result = None
 
662
            return
512
663
        self._next_open_branch_result = None
 
664
        if response[0] != 'ok':
 
665
            raise SmartProtocolError('unexpected response code %s' % (response,))
513
666
 
514
667
    def create_workingtree(self, revision_id=None, from_branch=None,
515
668
        accelerator_tree=None, hardlink=False):
569
722
        return None, self.open_branch(name=name)
570
723
 
571
724
    def open_branch(self, name=None, unsupported=False,
572
 
                    ignore_fallbacks=False):
 
725
                    ignore_fallbacks=False, possible_transports=None):
573
726
        if unsupported:
574
727
            raise NotImplementedError('unsupported flag support not implemented yet.')
575
728
        if self._next_open_branch_result is not None:
582
735
            # a branch reference, use the existing BranchReference logic.
583
736
            format = BranchReferenceFormat()
584
737
            return format.open(self, name=name, _found=True,
585
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
 
738
                location=response[1], ignore_fallbacks=ignore_fallbacks,
 
739
                possible_transports=possible_transports)
586
740
        branch_format_name = response[1]
587
741
        if not branch_format_name:
588
742
            branch_format_name = None
589
743
        format = RemoteBranchFormat(network_name=branch_format_name)
590
744
        return RemoteBranch(self, self.find_repository(), format=format,
591
 
            setup_stacking=not ignore_fallbacks, name=name)
 
745
            setup_stacking=not ignore_fallbacks, name=name,
 
746
            possible_transports=possible_transports)
592
747
 
593
748
    def _open_repo_v1(self, path):
594
749
        verb = 'BzrDir.find_repository'
657
812
 
658
813
    def has_workingtree(self):
659
814
        if self._has_working_tree is None:
660
 
            self._ensure_real()
661
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
 
815
            path = self._path_for_remote_call(self._client)
 
816
            try:
 
817
                response = self._call('BzrDir.has_workingtree', path)
 
818
            except errors.UnknownSmartMethod:
 
819
                self._ensure_real()
 
820
                self._has_working_tree = self._real_bzrdir.has_workingtree()
 
821
            else:
 
822
                if response[0] not in ('yes', 'no'):
 
823
                    raise SmartProtocolError('unexpected response code %s' % (response,))
 
824
                self._has_working_tree = (response[0] == 'yes')
662
825
        return self._has_working_tree
663
826
 
664
827
    def open_workingtree(self, recommend_upgrade=True):
669
832
 
670
833
    def _path_for_remote_call(self, client):
671
834
        """Return the path to be used for this bzrdir in a remote call."""
672
 
        return client.remote_path_from_transport(self.root_transport)
 
835
        return urlutils.split_segment_parameters_raw(
 
836
            client.remote_path_from_transport(self.root_transport))[0]
673
837
 
674
838
    def get_branch_transport(self, branch_format, name=None):
675
839
        self._ensure_real()
691
855
        """Upgrading of remote bzrdirs is not supported yet."""
692
856
        return False
693
857
 
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
858
    def _get_config(self):
701
859
        return RemoteBzrDirConfig(self)
702
860
 
 
861
    def _get_config_store(self):
 
862
        return RemoteControlStore(self)
 
863
 
703
864
 
704
865
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
705
866
    """Format for repositories accessed over a _SmartClient.
735
896
        self._supports_external_lookups = None
736
897
        self._supports_tree_reference = None
737
898
        self._supports_funky_characters = None
 
899
        self._supports_nesting_repositories = None
738
900
        self._rich_root_data = None
739
901
 
740
902
    def __repr__(self):
777
939
        return self._supports_funky_characters
778
940
 
779
941
    @property
 
942
    def supports_nesting_repositories(self):
 
943
        if self._supports_nesting_repositories is None:
 
944
            self._ensure_real()
 
945
            self._supports_nesting_repositories = \
 
946
                self._custom_format.supports_nesting_repositories
 
947
        return self._supports_nesting_repositories
 
948
 
 
949
    @property
780
950
    def supports_tree_reference(self):
781
951
        if self._supports_tree_reference is None:
782
952
            self._ensure_real()
864
1034
 
865
1035
    def _ensure_real(self):
866
1036
        if self._custom_format is None:
867
 
            self._custom_format = _mod_repository.network_format_registry.get(
868
 
                self._network_name)
 
1037
            try:
 
1038
                self._custom_format = _mod_repository.network_format_registry.get(
 
1039
                    self._network_name)
 
1040
            except KeyError:
 
1041
                raise errors.UnknownFormatError(kind='repository',
 
1042
                    format=self._network_name)
869
1043
 
870
1044
    @property
871
1045
    def _fetch_order(self):
906
1080
        return self._custom_format._serializer
907
1081
 
908
1082
 
909
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
910
 
    controldir.ControlComponent):
 
1083
class RemoteRepository(_mod_repository.Repository, _RpcHelper,
 
1084
        lock._RelockDebugMixin):
911
1085
    """Repository accessed over rpc.
912
1086
 
913
1087
    For the moment most operations are performed using local transport-backed
937
1111
        self._format = format
938
1112
        self._lock_mode = None
939
1113
        self._lock_token = None
 
1114
        self._write_group_tokens = None
940
1115
        self._lock_count = 0
941
1116
        self._leave_lock = False
942
1117
        # Cache of revision parents; misses are cached during read locks, and
982
1157
 
983
1158
        :param suppress_errors: see Repository.abort_write_group.
984
1159
        """
985
 
        self._ensure_real()
986
 
        return self._real_repository.abort_write_group(
987
 
            suppress_errors=suppress_errors)
 
1160
        if self._real_repository:
 
1161
            self._ensure_real()
 
1162
            return self._real_repository.abort_write_group(
 
1163
                suppress_errors=suppress_errors)
 
1164
        if not self.is_in_write_group():
 
1165
            if suppress_errors:
 
1166
                mutter('(suppressed) not in write group')
 
1167
                return
 
1168
            raise errors.BzrError("not in write group")
 
1169
        path = self.bzrdir._path_for_remote_call(self._client)
 
1170
        try:
 
1171
            response = self._call('Repository.abort_write_group', path,
 
1172
                self._lock_token, self._write_group_tokens)
 
1173
        except Exception, exc:
 
1174
            self._write_group = None
 
1175
            if not suppress_errors:
 
1176
                raise
 
1177
            mutter('abort_write_group failed')
 
1178
            log_exception_quietly()
 
1179
            note(gettext('bzr: ERROR (ignored): %s'), exc)
 
1180
        else:
 
1181
            if response != ('ok', ):
 
1182
                raise errors.UnexpectedSmartServerResponse(response)
 
1183
            self._write_group_tokens = None
988
1184
 
989
1185
    @property
990
1186
    def chk_bytes(self):
1004
1200
        for older plugins that don't use e.g. the CommitBuilder
1005
1201
        facility.
1006
1202
        """
1007
 
        self._ensure_real()
1008
 
        return self._real_repository.commit_write_group()
 
1203
        if self._real_repository:
 
1204
            self._ensure_real()
 
1205
            return self._real_repository.commit_write_group()
 
1206
        if not self.is_in_write_group():
 
1207
            raise errors.BzrError("not in write group")
 
1208
        path = self.bzrdir._path_for_remote_call(self._client)
 
1209
        response = self._call('Repository.commit_write_group', path,
 
1210
            self._lock_token, self._write_group_tokens)
 
1211
        if response != ('ok', ):
 
1212
            raise errors.UnexpectedSmartServerResponse(response)
 
1213
        self._write_group_tokens = None
1009
1214
 
1010
1215
    def resume_write_group(self, tokens):
1011
 
        self._ensure_real()
1012
 
        return self._real_repository.resume_write_group(tokens)
 
1216
        if self._real_repository:
 
1217
            return self._real_repository.resume_write_group(tokens)
 
1218
        path = self.bzrdir._path_for_remote_call(self._client)
 
1219
        try:
 
1220
            response = self._call('Repository.check_write_group', path,
 
1221
               self._lock_token, tokens)
 
1222
        except errors.UnknownSmartMethod:
 
1223
            self._ensure_real()
 
1224
            return self._real_repository.resume_write_group(tokens)
 
1225
        if response != ('ok', ):
 
1226
            raise errors.UnexpectedSmartServerResponse(response)
 
1227
        self._write_group_tokens = tokens
1013
1228
 
1014
1229
    def suspend_write_group(self):
1015
 
        self._ensure_real()
1016
 
        return self._real_repository.suspend_write_group()
 
1230
        if self._real_repository:
 
1231
            return self._real_repository.suspend_write_group()
 
1232
        ret = self._write_group_tokens or []
 
1233
        self._write_group_tokens = None
 
1234
        return ret
1017
1235
 
1018
1236
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
1019
1237
        self._ensure_real()
1229
1447
 
1230
1448
    def get_physical_lock_status(self):
1231
1449
        """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()
 
1450
        path = self.bzrdir._path_for_remote_call(self._client)
 
1451
        try:
 
1452
            response = self._call('Repository.get_physical_lock_status', path)
 
1453
        except errors.UnknownSmartMethod:
 
1454
            self._ensure_real()
 
1455
            return self._real_repository.get_physical_lock_status()
 
1456
        if response[0] not in ('yes', 'no'):
 
1457
            raise errors.UnexpectedSmartServerResponse(response)
 
1458
        return (response[0] == 'yes')
1235
1459
 
1236
1460
    def is_in_write_group(self):
1237
1461
        """Return True if there is an open write group.
1238
1462
 
1239
1463
        write groups are only applicable locally for the smart server..
1240
1464
        """
 
1465
        if self._write_group_tokens is not None:
 
1466
            return True
1241
1467
        if self._real_repository:
1242
1468
            return self._real_repository.is_in_write_group()
1243
1469
 
1378
1604
            self._real_repository.lock_write(self._lock_token)
1379
1605
        elif self._lock_mode == 'r':
1380
1606
            self._real_repository.lock_read()
 
1607
        if self._write_group_tokens is not None:
 
1608
            # if we are already in a write group, resume it
 
1609
            self._real_repository.resume_write_group(self._write_group_tokens)
 
1610
            self._write_group_tokens = None
1381
1611
 
1382
1612
    def start_write_group(self):
1383
1613
        """Start a write group on the decorated repository.
1387
1617
        for older plugins that don't use e.g. the CommitBuilder
1388
1618
        facility.
1389
1619
        """
1390
 
        self._ensure_real()
1391
 
        return self._real_repository.start_write_group()
 
1620
        if self._real_repository:
 
1621
            self._ensure_real()
 
1622
            return self._real_repository.start_write_group()
 
1623
        if not self.is_write_locked():
 
1624
            raise errors.NotWriteLocked(self)
 
1625
        if self._write_group_tokens is not None:
 
1626
            raise errors.BzrError('already in a write group')
 
1627
        path = self.bzrdir._path_for_remote_call(self._client)
 
1628
        try:
 
1629
            response = self._call('Repository.start_write_group', path,
 
1630
                self._lock_token)
 
1631
        except (errors.UnknownSmartMethod, errors.UnsuspendableWriteGroup):
 
1632
            self._ensure_real()
 
1633
            return self._real_repository.start_write_group()
 
1634
        if response[0] != 'ok':
 
1635
            raise errors.UnexpectedSmartServerResponse(response)
 
1636
        self._write_group_tokens = response[1]
1392
1637
 
1393
1638
    def _unlock(self, token):
1394
1639
        path = self.bzrdir._path_for_remote_call(self._client)
1421
1666
            # This is just to let the _real_repository stay up to date.
1422
1667
            if self._real_repository is not None:
1423
1668
                self._real_repository.unlock()
 
1669
            elif self._write_group_tokens is not None:
 
1670
                self.abort_write_group()
1424
1671
        finally:
1425
1672
            # The rpc-level lock should be released even if there was a
1426
1673
            # problem releasing the vfs-based lock.
1438
1685
 
1439
1686
    def break_lock(self):
1440
1687
        # should hand off to the network
1441
 
        self._ensure_real()
1442
 
        return self._real_repository.break_lock()
 
1688
        path = self.bzrdir._path_for_remote_call(self._client)
 
1689
        try:
 
1690
            response = self._call("Repository.break_lock", path)
 
1691
        except errors.UnknownSmartMethod:
 
1692
            self._ensure_real()
 
1693
            return self._real_repository.break_lock()
 
1694
        if response != ('ok',):
 
1695
            raise errors.UnexpectedSmartServerResponse(response)
1443
1696
 
1444
1697
    def _get_tarball(self, compression):
1445
1698
        """Return a TemporaryFile containing a repository tarball.
1463
1716
            return t
1464
1717
        raise errors.UnexpectedSmartServerResponse(response)
1465
1718
 
 
1719
    @needs_read_lock
1466
1720
    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)
 
1721
        """Create a descendent repository for new development.
 
1722
 
 
1723
        Unlike clone, this does not copy the settings of the repository.
 
1724
        """
 
1725
        dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
1471
1726
        dest_repo.fetch(self, revision_id=revision_id)
1472
1727
        return dest_repo
1473
1728
 
 
1729
    def _create_sprouting_repo(self, a_bzrdir, shared):
 
1730
        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
 
1731
            # use target default format.
 
1732
            dest_repo = a_bzrdir.create_repository()
 
1733
        else:
 
1734
            # Most control formats need the repository to be specifically
 
1735
            # created, but on some old all-in-one formats it's not needed
 
1736
            try:
 
1737
                dest_repo = self._format.initialize(a_bzrdir, shared=shared)
 
1738
            except errors.UninitializableFormat:
 
1739
                dest_repo = a_bzrdir.open_repository()
 
1740
        return dest_repo
 
1741
 
1474
1742
    ### These methods are just thin shims to the VFS object for now.
1475
1743
 
 
1744
    @needs_read_lock
1476
1745
    def revision_tree(self, revision_id):
1477
 
        self._ensure_real()
1478
 
        return self._real_repository.revision_tree(revision_id)
 
1746
        revision_id = _mod_revision.ensure_null(revision_id)
 
1747
        if revision_id == _mod_revision.NULL_REVISION:
 
1748
            return InventoryRevisionTree(self,
 
1749
                Inventory(root_id=None), _mod_revision.NULL_REVISION)
 
1750
        else:
 
1751
            return list(self.revision_trees([revision_id]))[0]
1479
1752
 
1480
1753
    def get_serializer_format(self):
1481
 
        self._ensure_real()
1482
 
        return self._real_repository.get_serializer_format()
 
1754
        path = self.bzrdir._path_for_remote_call(self._client)
 
1755
        try:
 
1756
            response = self._call('VersionedFileRepository.get_serializer_format',
 
1757
                path)
 
1758
        except errors.UnknownSmartMethod:
 
1759
            self._ensure_real()
 
1760
            return self._real_repository.get_serializer_format()
 
1761
        if response[0] != 'ok':
 
1762
            raise errors.UnexpectedSmartServerResponse(response)
 
1763
        return response[1]
1483
1764
 
1484
1765
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1485
1766
                           timezone=None, committer=None, revprops=None,
1505
1786
        # We need to accumulate additional repositories here, to pass them in
1506
1787
        # on various RPC's.
1507
1788
        #
 
1789
        # Make the check before we lock: this raises an exception.
 
1790
        self._check_fallback_repository(repository)
1508
1791
        if self.is_locked():
1509
1792
            # We will call fallback.unlock() when we transition to the unlocked
1510
1793
            # state, so always add a lock here. If a caller passes us a locked
1511
1794
            # repository, they are responsible for unlocking it later.
1512
1795
            repository.lock_read()
1513
 
        self._check_fallback_repository(repository)
1514
1796
        self._fallback_repositories.append(repository)
1515
1797
        # If self._real_repository was parameterised already (e.g. because a
1516
1798
        # _real_branch had its get_stacked_on_url method called), then the
1549
1831
 
1550
1832
    @needs_read_lock
1551
1833
    def get_inventory(self, revision_id):
 
1834
        return list(self.iter_inventories([revision_id]))[0]
 
1835
 
 
1836
    def _iter_inventories_rpc(self, revision_ids, ordering):
 
1837
        if ordering is None:
 
1838
            ordering = 'unordered'
 
1839
        path = self.bzrdir._path_for_remote_call(self._client)
 
1840
        body = "\n".join(revision_ids)
 
1841
        response_tuple, response_handler = (
 
1842
            self._call_with_body_bytes_expecting_body(
 
1843
                "VersionedFileRepository.get_inventories",
 
1844
                (path, ordering), body))
 
1845
        if response_tuple[0] != "ok":
 
1846
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
1847
        deserializer = inventory_delta.InventoryDeltaDeserializer()
 
1848
        byte_stream = response_handler.read_streamed_body()
 
1849
        decoded = smart_repo._byte_stream_to_stream(byte_stream)
 
1850
        if decoded is None:
 
1851
            # no results whatsoever
 
1852
            return
 
1853
        src_format, stream = decoded
 
1854
        if src_format.network_name() != self._format.network_name():
 
1855
            raise AssertionError(
 
1856
                "Mismatched RemoteRepository and stream src %r, %r" % (
 
1857
                src_format.network_name(), self._format.network_name()))
 
1858
        # ignore the src format, it's not really relevant
 
1859
        prev_inv = Inventory(root_id=None,
 
1860
            revision_id=_mod_revision.NULL_REVISION)
 
1861
        # there should be just one substream, with inventory deltas
 
1862
        substream_kind, substream = stream.next()
 
1863
        if substream_kind != "inventory-deltas":
 
1864
            raise AssertionError(
 
1865
                 "Unexpected stream %r received" % substream_kind)
 
1866
        for record in substream:
 
1867
            (parent_id, new_id, versioned_root, tree_references, invdelta) = (
 
1868
                deserializer.parse_text_bytes(record.get_bytes_as("fulltext")))
 
1869
            if parent_id != prev_inv.revision_id:
 
1870
                raise AssertionError("invalid base %r != %r" % (parent_id,
 
1871
                    prev_inv.revision_id))
 
1872
            inv = prev_inv.create_by_apply_delta(invdelta, new_id)
 
1873
            yield inv, inv.revision_id
 
1874
            prev_inv = inv
 
1875
 
 
1876
    def _iter_inventories_vfs(self, revision_ids, ordering=None):
1552
1877
        self._ensure_real()
1553
 
        return self._real_repository.get_inventory(revision_id)
 
1878
        return self._real_repository._iter_inventories(revision_ids, ordering)
1554
1879
 
1555
1880
    def iter_inventories(self, revision_ids, ordering=None):
1556
 
        self._ensure_real()
1557
 
        return self._real_repository.iter_inventories(revision_ids, ordering)
 
1881
        """Get many inventories by revision_ids.
 
1882
 
 
1883
        This will buffer some or all of the texts used in constructing the
 
1884
        inventories in memory, but will only parse a single inventory at a
 
1885
        time.
 
1886
 
 
1887
        :param revision_ids: The expected revision ids of the inventories.
 
1888
        :param ordering: optional ordering, e.g. 'topological'.  If not
 
1889
            specified, the order of revision_ids will be preserved (by
 
1890
            buffering if necessary).
 
1891
        :return: An iterator of inventories.
 
1892
        """
 
1893
        if ((None in revision_ids)
 
1894
            or (_mod_revision.NULL_REVISION in revision_ids)):
 
1895
            raise ValueError('cannot get null revision inventory')
 
1896
        for inv, revid in self._iter_inventories(revision_ids, ordering):
 
1897
            if inv is None:
 
1898
                raise errors.NoSuchRevision(self, revid)
 
1899
            yield inv
 
1900
 
 
1901
    def _iter_inventories(self, revision_ids, ordering=None):
 
1902
        if len(revision_ids) == 0:
 
1903
            return
 
1904
        missing = set(revision_ids)
 
1905
        if ordering is None:
 
1906
            order_as_requested = True
 
1907
            invs = {}
 
1908
            order = list(revision_ids)
 
1909
            order.reverse()
 
1910
            next_revid = order.pop()
 
1911
        else:
 
1912
            order_as_requested = False
 
1913
            if ordering != 'unordered' and self._fallback_repositories:
 
1914
                raise ValueError('unsupported ordering %r' % ordering)
 
1915
        iter_inv_fns = [self._iter_inventories_rpc] + [
 
1916
            fallback._iter_inventories for fallback in
 
1917
            self._fallback_repositories]
 
1918
        try:
 
1919
            for iter_inv in iter_inv_fns:
 
1920
                request = [revid for revid in revision_ids if revid in missing]
 
1921
                for inv, revid in iter_inv(request, ordering):
 
1922
                    if inv is None:
 
1923
                        continue
 
1924
                    missing.remove(inv.revision_id)
 
1925
                    if ordering != 'unordered':
 
1926
                        invs[revid] = inv
 
1927
                    else:
 
1928
                        yield inv, revid
 
1929
                if order_as_requested:
 
1930
                    # Yield as many results as we can while preserving order.
 
1931
                    while next_revid in invs:
 
1932
                        inv = invs.pop(next_revid)
 
1933
                        yield inv, inv.revision_id
 
1934
                        try:
 
1935
                            next_revid = order.pop()
 
1936
                        except IndexError:
 
1937
                            # We still want to fully consume the stream, just
 
1938
                            # in case it is not actually finished at this point
 
1939
                            next_revid = None
 
1940
                            break
 
1941
        except errors.UnknownSmartMethod:
 
1942
            for inv, revid in self._iter_inventories_vfs(revision_ids, ordering):
 
1943
                yield inv, revid
 
1944
            return
 
1945
        # Report missing
 
1946
        if order_as_requested:
 
1947
            if next_revid is not None:
 
1948
                yield None, next_revid
 
1949
            while order:
 
1950
                revid = order.pop()
 
1951
                yield invs.get(revid), revid
 
1952
        else:
 
1953
            while missing:
 
1954
                yield None, missing.pop()
1558
1955
 
1559
1956
    @needs_read_lock
1560
1957
    def get_revision(self, revision_id):
1561
 
        self._ensure_real()
1562
 
        return self._real_repository.get_revision(revision_id)
 
1958
        return self.get_revisions([revision_id])[0]
1563
1959
 
1564
1960
    def get_transaction(self):
1565
1961
        self._ensure_real()
1567
1963
 
1568
1964
    @needs_read_lock
1569
1965
    def clone(self, a_bzrdir, revision_id=None):
1570
 
        self._ensure_real()
1571
 
        return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
 
1966
        dest_repo = self._create_sprouting_repo(
 
1967
            a_bzrdir, shared=self.is_shared())
 
1968
        self.copy_content_into(dest_repo, revision_id)
 
1969
        return dest_repo
1572
1970
 
1573
1971
    def make_working_trees(self):
1574
1972
        """See Repository.make_working_trees"""
1575
 
        self._ensure_real()
1576
 
        return self._real_repository.make_working_trees()
 
1973
        path = self.bzrdir._path_for_remote_call(self._client)
 
1974
        try:
 
1975
            response = self._call('Repository.make_working_trees', path)
 
1976
        except errors.UnknownSmartMethod:
 
1977
            self._ensure_real()
 
1978
            return self._real_repository.make_working_trees()
 
1979
        if response[0] not in ('yes', 'no'):
 
1980
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
1981
        return response[0] == 'yes'
1577
1982
 
1578
1983
    def refresh_data(self):
1579
1984
        """Re-read any data needed to synchronise with disk.
1598
2003
        included_keys = result_set.intersection(result_parents)
1599
2004
        start_keys = result_set.difference(included_keys)
1600
2005
        exclude_keys = result_parents.difference(result_set)
1601
 
        result = graph.SearchResult(start_keys, exclude_keys,
 
2006
        result = vf_search.SearchResult(start_keys, exclude_keys,
1602
2007
            len(result_set), result_set)
1603
2008
        return result
1604
2009
 
1652
2057
        # the InterRepository base class, which raises an
1653
2058
        # IncompatibleRepositories when asked to fetch.
1654
2059
        inter = _mod_repository.InterRepository.get(source, self)
 
2060
        if (fetch_spec is not None and
 
2061
            not getattr(inter, "supports_fetch_spec", False)):
 
2062
            raise errors.UnsupportedOperation(
 
2063
                "fetch_spec not supported for %r" % inter)
1655
2064
        return inter.fetch(revision_id=revision_id,
1656
2065
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1657
2066
 
1675
2084
        return self._real_repository._get_versioned_file_checker(
1676
2085
            revisions, revision_versions_cache)
1677
2086
 
 
2087
    def _iter_files_bytes_rpc(self, desired_files, absent):
 
2088
        path = self.bzrdir._path_for_remote_call(self._client)
 
2089
        lines = []
 
2090
        identifiers = []
 
2091
        for (file_id, revid, identifier) in desired_files:
 
2092
            lines.append("%s\0%s" % (
 
2093
                osutils.safe_file_id(file_id),
 
2094
                osutils.safe_revision_id(revid)))
 
2095
            identifiers.append(identifier)
 
2096
        (response_tuple, response_handler) = (
 
2097
            self._call_with_body_bytes_expecting_body(
 
2098
            "Repository.iter_files_bytes", (path, ), "\n".join(lines)))
 
2099
        if response_tuple != ('ok', ):
 
2100
            response_handler.cancel_read_body()
 
2101
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2102
        byte_stream = response_handler.read_streamed_body()
 
2103
        def decompress_stream(start, byte_stream, unused):
 
2104
            decompressor = zlib.decompressobj()
 
2105
            yield decompressor.decompress(start)
 
2106
            while decompressor.unused_data == "":
 
2107
                try:
 
2108
                    data = byte_stream.next()
 
2109
                except StopIteration:
 
2110
                    break
 
2111
                yield decompressor.decompress(data)
 
2112
            yield decompressor.flush()
 
2113
            unused.append(decompressor.unused_data)
 
2114
        unused = ""
 
2115
        while True:
 
2116
            while not "\n" in unused:
 
2117
                unused += byte_stream.next()
 
2118
            header, rest = unused.split("\n", 1)
 
2119
            args = header.split("\0")
 
2120
            if args[0] == "absent":
 
2121
                absent[identifiers[int(args[3])]] = (args[1], args[2])
 
2122
                unused = rest
 
2123
                continue
 
2124
            elif args[0] == "ok":
 
2125
                idx = int(args[1])
 
2126
            else:
 
2127
                raise errors.UnexpectedSmartServerResponse(args)
 
2128
            unused_chunks = []
 
2129
            yield (identifiers[idx],
 
2130
                decompress_stream(rest, byte_stream, unused_chunks))
 
2131
            unused = "".join(unused_chunks)
 
2132
 
1678
2133
    def iter_files_bytes(self, desired_files):
1679
2134
        """See Repository.iter_file_bytes.
1680
2135
        """
1681
 
        self._ensure_real()
1682
 
        return self._real_repository.iter_files_bytes(desired_files)
 
2136
        try:
 
2137
            absent = {}
 
2138
            for (identifier, bytes_iterator) in self._iter_files_bytes_rpc(
 
2139
                    desired_files, absent):
 
2140
                yield identifier, bytes_iterator
 
2141
            for fallback in self._fallback_repositories:
 
2142
                if not absent:
 
2143
                    break
 
2144
                desired_files = [(key[0], key[1], identifier) for
 
2145
                    (identifier, key) in absent.iteritems()]
 
2146
                for (identifier, bytes_iterator) in fallback.iter_files_bytes(desired_files):
 
2147
                    del absent[identifier]
 
2148
                    yield identifier, bytes_iterator
 
2149
            if absent:
 
2150
                # There may be more missing items, but raise an exception
 
2151
                # for just one.
 
2152
                missing_identifier = absent.keys()[0]
 
2153
                missing_key = absent[missing_identifier]
 
2154
                raise errors.RevisionNotPresent(revision_id=missing_key[1],
 
2155
                    file_id=missing_key[0])
 
2156
        except errors.UnknownSmartMethod:
 
2157
            self._ensure_real()
 
2158
            for (identifier, bytes_iterator) in (
 
2159
                self._real_repository.iter_files_bytes(desired_files)):
 
2160
                yield identifier, bytes_iterator
 
2161
 
 
2162
    def get_cached_parent_map(self, revision_ids):
 
2163
        """See bzrlib.CachingParentsProvider.get_cached_parent_map"""
 
2164
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
1683
2165
 
1684
2166
    def get_parent_map(self, revision_ids):
1685
2167
        """See bzrlib.Graph.get_parent_map()."""
1744
2226
        if parents_map is None:
1745
2227
            # Repository is not locked, so there's no cache.
1746
2228
            parents_map = {}
1747
 
        # start_set is all the keys in the cache
1748
 
        start_set = set(parents_map)
1749
 
        # result set is all the references to keys in the cache
1750
 
        result_parents = set()
1751
 
        for parents in parents_map.itervalues():
1752
 
            result_parents.update(parents)
1753
 
        stop_keys = result_parents.difference(start_set)
1754
 
        # We don't need to send ghosts back to the server as a position to
1755
 
        # stop either.
1756
 
        stop_keys.difference_update(self._unstacked_provider.missing_keys)
1757
 
        key_count = len(parents_map)
1758
 
        if (NULL_REVISION in result_parents
1759
 
            and NULL_REVISION in self._unstacked_provider.missing_keys):
1760
 
            # If we pruned NULL_REVISION from the stop_keys because it's also
1761
 
            # in our cache of "missing" keys we need to increment our key count
1762
 
            # by 1, because the reconsitituted SearchResult on the server will
1763
 
            # still consider NULL_REVISION to be an included key.
1764
 
            key_count += 1
1765
 
        included_keys = start_set.intersection(result_parents)
1766
 
        start_set.difference_update(included_keys)
 
2229
        if _DEFAULT_SEARCH_DEPTH <= 0:
 
2230
            (start_set, stop_keys,
 
2231
             key_count) = vf_search.search_result_from_parent_map(
 
2232
                parents_map, self._unstacked_provider.missing_keys)
 
2233
        else:
 
2234
            (start_set, stop_keys,
 
2235
             key_count) = vf_search.limited_search_result_from_parent_map(
 
2236
                parents_map, self._unstacked_provider.missing_keys,
 
2237
                keys, depth=_DEFAULT_SEARCH_DEPTH)
1767
2238
        recipe = ('manual', start_set, stop_keys, key_count)
1768
2239
        body = self._serialise_search_recipe(recipe)
1769
2240
        path = self.bzrdir._path_for_remote_call(self._client)
1818
2289
 
1819
2290
    @needs_read_lock
1820
2291
    def get_signature_text(self, revision_id):
1821
 
        self._ensure_real()
1822
 
        return self._real_repository.get_signature_text(revision_id)
 
2292
        path = self.bzrdir._path_for_remote_call(self._client)
 
2293
        try:
 
2294
            response_tuple, response_handler = self._call_expecting_body(
 
2295
                'Repository.get_revision_signature_text', path, revision_id)
 
2296
        except errors.UnknownSmartMethod:
 
2297
            self._ensure_real()
 
2298
            return self._real_repository.get_signature_text(revision_id)
 
2299
        except errors.NoSuchRevision, err:
 
2300
            for fallback in self._fallback_repositories:
 
2301
                try:
 
2302
                    return fallback.get_signature_text(revision_id)
 
2303
                except errors.NoSuchRevision:
 
2304
                    pass
 
2305
            raise err
 
2306
        else:
 
2307
            if response_tuple[0] != 'ok':
 
2308
                raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2309
            return response_handler.read_body_bytes()
1823
2310
 
1824
2311
    @needs_read_lock
1825
2312
    def _get_inventory_xml(self, revision_id):
 
2313
        # This call is used by older working tree formats,
 
2314
        # which stored a serialized basis inventory.
1826
2315
        self._ensure_real()
1827
2316
        return self._real_repository._get_inventory_xml(revision_id)
1828
2317
 
 
2318
    @needs_write_lock
1829
2319
    def reconcile(self, other=None, thorough=False):
1830
 
        self._ensure_real()
1831
 
        return self._real_repository.reconcile(other=other, thorough=thorough)
 
2320
        from bzrlib.reconcile import RepoReconciler
 
2321
        path = self.bzrdir._path_for_remote_call(self._client)
 
2322
        try:
 
2323
            response, handler = self._call_expecting_body(
 
2324
                'Repository.reconcile', path, self._lock_token)
 
2325
        except (errors.UnknownSmartMethod, errors.TokenLockingNotSupported):
 
2326
            self._ensure_real()
 
2327
            return self._real_repository.reconcile(other=other, thorough=thorough)
 
2328
        if response != ('ok', ):
 
2329
            raise errors.UnexpectedSmartServerResponse(response)
 
2330
        body = handler.read_body_bytes()
 
2331
        result = RepoReconciler(self)
 
2332
        for line in body.split('\n'):
 
2333
            if not line:
 
2334
                continue
 
2335
            key, val_text = line.split(':')
 
2336
            if key == "garbage_inventories":
 
2337
                result.garbage_inventories = int(val_text)
 
2338
            elif key == "inconsistent_parents":
 
2339
                result.inconsistent_parents = int(val_text)
 
2340
            else:
 
2341
                mutter("unknown reconcile key %r" % key)
 
2342
        return result
1832
2343
 
1833
2344
    def all_revision_ids(self):
1834
 
        self._ensure_real()
1835
 
        return self._real_repository.all_revision_ids()
 
2345
        path = self.bzrdir._path_for_remote_call(self._client)
 
2346
        try:
 
2347
            response_tuple, response_handler = self._call_expecting_body(
 
2348
                "Repository.all_revision_ids", path)
 
2349
        except errors.UnknownSmartMethod:
 
2350
            self._ensure_real()
 
2351
            return self._real_repository.all_revision_ids()
 
2352
        if response_tuple != ("ok", ):
 
2353
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2354
        revids = set(response_handler.read_body_bytes().splitlines())
 
2355
        for fallback in self._fallback_repositories:
 
2356
            revids.update(set(fallback.all_revision_ids()))
 
2357
        return list(revids)
 
2358
 
 
2359
    def _filtered_revision_trees(self, revision_ids, file_ids):
 
2360
        """Return Tree for a revision on this branch with only some files.
 
2361
 
 
2362
        :param revision_ids: a sequence of revision-ids;
 
2363
          a revision-id may not be None or 'null:'
 
2364
        :param file_ids: if not None, the result is filtered
 
2365
          so that only those file-ids, their parents and their
 
2366
          children are included.
 
2367
        """
 
2368
        inventories = self.iter_inventories(revision_ids)
 
2369
        for inv in inventories:
 
2370
            # Should we introduce a FilteredRevisionTree class rather
 
2371
            # than pre-filter the inventory here?
 
2372
            filtered_inv = inv.filter(file_ids)
 
2373
            yield InventoryRevisionTree(self, filtered_inv, filtered_inv.revision_id)
1836
2374
 
1837
2375
    @needs_read_lock
1838
2376
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1839
 
        self._ensure_real()
1840
 
        return self._real_repository.get_deltas_for_revisions(revisions,
1841
 
            specific_fileids=specific_fileids)
 
2377
        medium = self._client._medium
 
2378
        if medium._is_remote_before((1, 2)):
 
2379
            self._ensure_real()
 
2380
            for delta in self._real_repository.get_deltas_for_revisions(
 
2381
                    revisions, specific_fileids):
 
2382
                yield delta
 
2383
            return
 
2384
        # Get the revision-ids of interest
 
2385
        required_trees = set()
 
2386
        for revision in revisions:
 
2387
            required_trees.add(revision.revision_id)
 
2388
            required_trees.update(revision.parent_ids[:1])
 
2389
 
 
2390
        # Get the matching filtered trees. Note that it's more
 
2391
        # efficient to pass filtered trees to changes_from() rather
 
2392
        # than doing the filtering afterwards. changes_from() could
 
2393
        # arguably do the filtering itself but it's path-based, not
 
2394
        # file-id based, so filtering before or afterwards is
 
2395
        # currently easier.
 
2396
        if specific_fileids is None:
 
2397
            trees = dict((t.get_revision_id(), t) for
 
2398
                t in self.revision_trees(required_trees))
 
2399
        else:
 
2400
            trees = dict((t.get_revision_id(), t) for
 
2401
                t in self._filtered_revision_trees(required_trees,
 
2402
                specific_fileids))
 
2403
 
 
2404
        # Calculate the deltas
 
2405
        for revision in revisions:
 
2406
            if not revision.parent_ids:
 
2407
                old_tree = self.revision_tree(_mod_revision.NULL_REVISION)
 
2408
            else:
 
2409
                old_tree = trees[revision.parent_ids[0]]
 
2410
            yield trees[revision.revision_id].changes_from(old_tree)
1842
2411
 
1843
2412
    @needs_read_lock
1844
2413
    def get_revision_delta(self, revision_id, specific_fileids=None):
1845
 
        self._ensure_real()
1846
 
        return self._real_repository.get_revision_delta(revision_id,
1847
 
            specific_fileids=specific_fileids)
 
2414
        r = self.get_revision(revision_id)
 
2415
        return list(self.get_deltas_for_revisions([r],
 
2416
            specific_fileids=specific_fileids))[0]
1848
2417
 
1849
2418
    @needs_read_lock
1850
2419
    def revision_trees(self, revision_ids):
1851
 
        self._ensure_real()
1852
 
        return self._real_repository.revision_trees(revision_ids)
 
2420
        inventories = self.iter_inventories(revision_ids)
 
2421
        for inv in inventories:
 
2422
            yield InventoryRevisionTree(self, inv, inv.revision_id)
1853
2423
 
1854
2424
    @needs_read_lock
1855
2425
    def get_revision_reconcile(self, revision_id):
1863
2433
            callback_refs=callback_refs, check_repo=check_repo)
1864
2434
 
1865
2435
    def copy_content_into(self, destination, revision_id=None):
1866
 
        self._ensure_real()
1867
 
        return self._real_repository.copy_content_into(
1868
 
            destination, revision_id=revision_id)
 
2436
        """Make a complete copy of the content in self into destination.
 
2437
 
 
2438
        This is a destructive operation! Do not use it on existing
 
2439
        repositories.
 
2440
        """
 
2441
        interrepo = _mod_repository.InterRepository.get(self, destination)
 
2442
        return interrepo.copy_content(revision_id)
1869
2443
 
1870
2444
    def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1871
2445
        # get a tarball of the remote repository, and copy from that into the
1872
2446
        # destination
1873
 
        from bzrlib import osutils
1874
2447
        import tarfile
1875
2448
        # TODO: Maybe a progress bar while streaming the tarball?
1876
 
        note("Copying repository content as tarball...")
 
2449
        note(gettext("Copying repository content as tarball..."))
1877
2450
        tar_file = self._get_tarball('bz2')
1878
2451
        if tar_file is None:
1879
2452
            return None
1908
2481
    @needs_write_lock
1909
2482
    def pack(self, hint=None, clean_obsolete_packs=False):
1910
2483
        """Compress the data within the repository.
1911
 
 
1912
 
        This is not currently implemented within the smart server.
1913
2484
        """
1914
 
        self._ensure_real()
1915
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
2485
        if hint is None:
 
2486
            body = ""
 
2487
        else:
 
2488
            body = "".join([l+"\n" for l in hint])
 
2489
        path = self.bzrdir._path_for_remote_call(self._client)
 
2490
        try:
 
2491
            response, handler = self._call_with_body_bytes_expecting_body(
 
2492
                'Repository.pack', (path, self._lock_token,
 
2493
                    str(clean_obsolete_packs)), body)
 
2494
        except errors.UnknownSmartMethod:
 
2495
            self._ensure_real()
 
2496
            return self._real_repository.pack(hint=hint,
 
2497
                clean_obsolete_packs=clean_obsolete_packs)
 
2498
        handler.cancel_read_body()
 
2499
        if response != ('ok', ):
 
2500
            raise errors.UnexpectedSmartServerResponse(response)
1916
2501
 
1917
2502
    @property
1918
2503
    def revisions(self):
1919
2504
        """Decorate the real repository for now.
1920
2505
 
1921
 
        In the short term this should become a real object to intercept graph
1922
 
        lookups.
1923
 
 
1924
2506
        In the long term a full blown network facility is needed.
1925
2507
        """
1926
2508
        self._ensure_real()
1954
2536
 
1955
2537
    @needs_write_lock
1956
2538
    def sign_revision(self, revision_id, gpg_strategy):
1957
 
        self._ensure_real()
1958
 
        return self._real_repository.sign_revision(revision_id, gpg_strategy)
 
2539
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2540
        plaintext = testament.as_short_text()
 
2541
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1959
2542
 
1960
2543
    @property
1961
2544
    def texts(self):
1967
2550
        self._ensure_real()
1968
2551
        return self._real_repository.texts
1969
2552
 
 
2553
    def _iter_revisions_rpc(self, revision_ids):
 
2554
        body = "\n".join(revision_ids)
 
2555
        path = self.bzrdir._path_for_remote_call(self._client)
 
2556
        response_tuple, response_handler = (
 
2557
            self._call_with_body_bytes_expecting_body(
 
2558
            "Repository.iter_revisions", (path, ), body))
 
2559
        if response_tuple[0] != "ok":
 
2560
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2561
        serializer_format = response_tuple[1]
 
2562
        serializer = serializer_format_registry.get(serializer_format)
 
2563
        byte_stream = response_handler.read_streamed_body()
 
2564
        decompressor = zlib.decompressobj()
 
2565
        chunks = []
 
2566
        for bytes in byte_stream:
 
2567
            chunks.append(decompressor.decompress(bytes))
 
2568
            if decompressor.unused_data != "":
 
2569
                chunks.append(decompressor.flush())
 
2570
                yield serializer.read_revision_from_string("".join(chunks))
 
2571
                unused = decompressor.unused_data
 
2572
                decompressor = zlib.decompressobj()
 
2573
                chunks = [decompressor.decompress(unused)]
 
2574
        chunks.append(decompressor.flush())
 
2575
        text = "".join(chunks)
 
2576
        if text != "":
 
2577
            yield serializer.read_revision_from_string("".join(chunks))
 
2578
 
1970
2579
    @needs_read_lock
1971
2580
    def get_revisions(self, revision_ids):
1972
 
        self._ensure_real()
1973
 
        return self._real_repository.get_revisions(revision_ids)
 
2581
        if revision_ids is None:
 
2582
            revision_ids = self.all_revision_ids()
 
2583
        else:
 
2584
            for rev_id in revision_ids:
 
2585
                if not rev_id or not isinstance(rev_id, basestring):
 
2586
                    raise errors.InvalidRevisionId(
 
2587
                        revision_id=rev_id, branch=self)
 
2588
        try:
 
2589
            missing = set(revision_ids)
 
2590
            revs = {}
 
2591
            for rev in self._iter_revisions_rpc(revision_ids):
 
2592
                missing.remove(rev.revision_id)
 
2593
                revs[rev.revision_id] = rev
 
2594
        except errors.UnknownSmartMethod:
 
2595
            self._ensure_real()
 
2596
            return self._real_repository.get_revisions(revision_ids)
 
2597
        for fallback in self._fallback_repositories:
 
2598
            if not missing:
 
2599
                break
 
2600
            for revid in list(missing):
 
2601
                # XXX JRV 2011-11-20: It would be nice if there was a
 
2602
                # public method on Repository that could be used to query
 
2603
                # for revision objects *without* failing completely if one
 
2604
                # was missing. There is VersionedFileRepository._iter_revisions,
 
2605
                # but unfortunately that's private and not provided by
 
2606
                # all repository implementations.
 
2607
                try:
 
2608
                    revs[revid] = fallback.get_revision(revid)
 
2609
                except errors.NoSuchRevision:
 
2610
                    pass
 
2611
                else:
 
2612
                    missing.remove(revid)
 
2613
        if missing:
 
2614
            raise errors.NoSuchRevision(self, list(missing)[0])
 
2615
        return [revs[revid] for revid in revision_ids]
1974
2616
 
1975
2617
    def supports_rich_root(self):
1976
2618
        return self._format.rich_root_data
1984
2626
    def _serializer(self):
1985
2627
        return self._format._serializer
1986
2628
 
 
2629
    @needs_write_lock
1987
2630
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1988
 
        self._ensure_real()
1989
 
        return self._real_repository.store_revision_signature(
1990
 
            gpg_strategy, plaintext, revision_id)
 
2631
        signature = gpg_strategy.sign(plaintext)
 
2632
        self.add_signature_text(revision_id, signature)
1991
2633
 
1992
2634
    def add_signature_text(self, revision_id, signature):
1993
 
        self._ensure_real()
1994
 
        return self._real_repository.add_signature_text(revision_id, signature)
 
2635
        if self._real_repository:
 
2636
            # If there is a real repository the write group will
 
2637
            # be in the real repository as well, so use that:
 
2638
            self._ensure_real()
 
2639
            return self._real_repository.add_signature_text(
 
2640
                revision_id, signature)
 
2641
        path = self.bzrdir._path_for_remote_call(self._client)
 
2642
        response, handler = self._call_with_body_bytes_expecting_body(
 
2643
            'Repository.add_signature_text', (path, self._lock_token,
 
2644
                revision_id) + tuple(self._write_group_tokens), signature)
 
2645
        handler.cancel_read_body()
 
2646
        self.refresh_data()
 
2647
        if response[0] != 'ok':
 
2648
            raise errors.UnexpectedSmartServerResponse(response)
 
2649
        self._write_group_tokens = response[1:]
1995
2650
 
1996
2651
    def has_signature_for_revision_id(self, revision_id):
1997
 
        self._ensure_real()
1998
 
        return self._real_repository.has_signature_for_revision_id(revision_id)
 
2652
        path = self.bzrdir._path_for_remote_call(self._client)
 
2653
        try:
 
2654
            response = self._call('Repository.has_signature_for_revision_id',
 
2655
                path, revision_id)
 
2656
        except errors.UnknownSmartMethod:
 
2657
            self._ensure_real()
 
2658
            return self._real_repository.has_signature_for_revision_id(
 
2659
                revision_id)
 
2660
        if response[0] not in ('yes', 'no'):
 
2661
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2662
        if response[0] == 'yes':
 
2663
            return True
 
2664
        for fallback in self._fallback_repositories:
 
2665
            if fallback.has_signature_for_revision_id(revision_id):
 
2666
                return True
 
2667
        return False
 
2668
 
 
2669
    @needs_read_lock
 
2670
    def verify_revision_signature(self, revision_id, gpg_strategy):
 
2671
        if not self.has_signature_for_revision_id(revision_id):
 
2672
            return gpg.SIGNATURE_NOT_SIGNED, None
 
2673
        signature = self.get_signature_text(revision_id)
 
2674
 
 
2675
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2676
        plaintext = testament.as_short_text()
 
2677
 
 
2678
        return gpg_strategy.verify(signature, plaintext)
1999
2679
 
2000
2680
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
2001
2681
        self._ensure_real()
2191
2871
 
2192
2872
    def _real_stream(self, repo, search):
2193
2873
        """Get a stream for search from repo.
2194
 
        
2195
 
        This never called RemoteStreamSource.get_stream, and is a heler
2196
 
        for RemoteStreamSource._get_stream to allow getting a stream 
 
2874
 
 
2875
        This never called RemoteStreamSource.get_stream, and is a helper
 
2876
        for RemoteStreamSource._get_stream to allow getting a stream
2197
2877
        reliably whether fallback back because of old servers or trying
2198
2878
        to stream from a non-RemoteRepository (which the stacked support
2199
2879
        code will do).
2241
2921
            except errors.UnknownSmartMethod:
2242
2922
                medium._remember_remote_is_before(version)
2243
2923
            except errors.UnknownErrorFromSmartServer, e:
2244
 
                if isinstance(search, graph.EverythingResult):
 
2924
                if isinstance(search, vf_search.EverythingResult):
2245
2925
                    error_verb = e.error_from_smart_server.error_verb
2246
2926
                    if error_verb == 'BadSearch':
2247
2927
                        # Pre-2.4 servers don't support this sort of search.
2339
3019
 
2340
3020
    def _ensure_real(self):
2341
3021
        if self._custom_format is None:
2342
 
            self._custom_format = branch.network_format_registry.get(
2343
 
                self._network_name)
 
3022
            try:
 
3023
                self._custom_format = branch.network_format_registry.get(
 
3024
                    self._network_name)
 
3025
            except KeyError:
 
3026
                raise errors.UnknownFormatError(kind='branch',
 
3027
                    format=self._network_name)
2344
3028
 
2345
3029
    def get_format_description(self):
2346
3030
        self._ensure_real()
2353
3037
        return a_bzrdir.open_branch(name=name, 
2354
3038
            ignore_fallbacks=ignore_fallbacks)
2355
3039
 
2356
 
    def _vfs_initialize(self, a_bzrdir, name):
 
3040
    def _vfs_initialize(self, a_bzrdir, name, append_revisions_only):
2357
3041
        # Initialisation when using a local bzrdir object, or a non-vfs init
2358
3042
        # method is not available on the server.
2359
3043
        # self._custom_format is always set - the start of initialize ensures
2361
3045
        if isinstance(a_bzrdir, RemoteBzrDir):
2362
3046
            a_bzrdir._ensure_real()
2363
3047
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2364
 
                name)
 
3048
                name, append_revisions_only=append_revisions_only)
2365
3049
        else:
2366
3050
            # We assume the bzrdir is parameterised; it may not be.
2367
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
3051
            result = self._custom_format.initialize(a_bzrdir, name,
 
3052
                append_revisions_only=append_revisions_only)
2368
3053
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2369
3054
            not isinstance(result, RemoteBranch)):
2370
3055
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2371
3056
                                  name=name)
2372
3057
        return result
2373
3058
 
2374
 
    def initialize(self, a_bzrdir, name=None, repository=None):
 
3059
    def initialize(self, a_bzrdir, name=None, repository=None,
 
3060
                   append_revisions_only=None):
2375
3061
        # 1) get the network name to use.
2376
3062
        if self._custom_format:
2377
3063
            network_name = self._custom_format.network_name()
2383
3069
            network_name = reference_format.network_name()
2384
3070
        # Being asked to create on a non RemoteBzrDir:
2385
3071
        if not isinstance(a_bzrdir, RemoteBzrDir):
2386
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
3072
            return self._vfs_initialize(a_bzrdir, name=name,
 
3073
                append_revisions_only=append_revisions_only)
2387
3074
        medium = a_bzrdir._client._medium
2388
3075
        if medium._is_remote_before((1, 13)):
2389
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
3076
            return self._vfs_initialize(a_bzrdir, name=name,
 
3077
                append_revisions_only=append_revisions_only)
2390
3078
        # Creating on a remote bzr dir.
2391
3079
        # 2) try direct creation via RPC
2392
3080
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2399
3087
        except errors.UnknownSmartMethod:
2400
3088
            # Fallback - use vfs methods
2401
3089
            medium._remember_remote_is_before((1, 13))
2402
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
3090
            return self._vfs_initialize(a_bzrdir, name=name,
 
3091
                    append_revisions_only=append_revisions_only)
2403
3092
        if response[0] != 'ok':
2404
3093
            raise errors.UnexpectedSmartServerResponse(response)
2405
3094
        # Turn the response into a RemoteRepository object.
2426
3115
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2427
3116
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2428
3117
            format=format, setup_stacking=False, name=name)
 
3118
        if append_revisions_only:
 
3119
            remote_branch.set_append_revisions_only(append_revisions_only)
2429
3120
        # XXX: We know this is a new branch, so it must have revno 0, revid
2430
3121
        # NULL_REVISION. Creating the branch locked would make this be unable
2431
3122
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2464
3155
                return True
2465
3156
        return False
2466
3157
 
 
3158
 
 
3159
class RemoteBranchStore(config.IniFileStore):
 
3160
    """Branch store which attempts to use HPSS calls to retrieve branch store.
 
3161
 
 
3162
    Note that this is specific to bzr-based formats.
 
3163
    """
 
3164
 
 
3165
    def __init__(self, branch):
 
3166
        super(RemoteBranchStore, self).__init__()
 
3167
        self.branch = branch
 
3168
        self.id = "branch"
 
3169
        self._real_store = None
 
3170
 
 
3171
    def lock_write(self, token=None):
 
3172
        return self.branch.lock_write(token)
 
3173
 
 
3174
    def unlock(self):
 
3175
        return self.branch.unlock()
 
3176
 
 
3177
    @needs_write_lock
 
3178
    def save(self):
 
3179
        # We need to be able to override the undecorated implementation
 
3180
        self.save_without_locking()
 
3181
 
 
3182
    def save_without_locking(self):
 
3183
        super(RemoteBranchStore, self).save()
 
3184
 
 
3185
    def external_url(self):
 
3186
        return self.branch.user_url
 
3187
 
 
3188
    def _load_content(self):
 
3189
        path = self.branch._remote_path()
 
3190
        try:
 
3191
            response, handler = self.branch._call_expecting_body(
 
3192
                'Branch.get_config_file', path)
 
3193
        except errors.UnknownSmartMethod:
 
3194
            self._ensure_real()
 
3195
            return self._real_store._load_content()
 
3196
        if len(response) and response[0] != 'ok':
 
3197
            raise errors.UnexpectedSmartServerResponse(response)
 
3198
        return handler.read_body_bytes()
 
3199
 
 
3200
    def _save_content(self, content):
 
3201
        path = self.branch._remote_path()
 
3202
        try:
 
3203
            response, handler = self.branch._call_with_body_bytes_expecting_body(
 
3204
                'Branch.put_config_file', (path,
 
3205
                    self.branch._lock_token, self.branch._repo_lock_token),
 
3206
                content)
 
3207
        except errors.UnknownSmartMethod:
 
3208
            self._ensure_real()
 
3209
            return self._real_store._save_content(content)
 
3210
        handler.cancel_read_body()
 
3211
        if response != ('ok', ):
 
3212
            raise errors.UnexpectedSmartServerResponse(response)
 
3213
 
 
3214
    def _ensure_real(self):
 
3215
        self.branch._ensure_real()
 
3216
        if self._real_store is None:
 
3217
            self._real_store = config.BranchStore(self.branch)
 
3218
 
 
3219
 
2467
3220
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2468
3221
    """Branch stored on a server accessed by HPSS RPC.
2469
3222
 
2471
3224
    """
2472
3225
 
2473
3226
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2474
 
        _client=None, format=None, setup_stacking=True, name=None):
 
3227
        _client=None, format=None, setup_stacking=True, name=None,
 
3228
        possible_transports=None):
2475
3229
        """Create a RemoteBranch instance.
2476
3230
 
2477
3231
        :param real_branch: An optional local implementation of the branch
2542
3296
            hook(self)
2543
3297
        self._is_stacked = False
2544
3298
        if setup_stacking:
2545
 
            self._setup_stacking()
 
3299
            self._setup_stacking(possible_transports)
2546
3300
 
2547
 
    def _setup_stacking(self):
 
3301
    def _setup_stacking(self, possible_transports):
2548
3302
        # configure stacking into the remote repository, by reading it from
2549
3303
        # the vfs branch.
2550
3304
        try:
2553
3307
            errors.UnstackableRepositoryFormat), e:
2554
3308
            return
2555
3309
        self._is_stacked = True
2556
 
        self._activate_fallback_location(fallback_url)
 
3310
        if possible_transports is None:
 
3311
            possible_transports = []
 
3312
        else:
 
3313
            possible_transports = list(possible_transports)
 
3314
        possible_transports.append(self.bzrdir.root_transport)
 
3315
        self._activate_fallback_location(fallback_url,
 
3316
            possible_transports=possible_transports)
2557
3317
 
2558
3318
    def _get_config(self):
2559
3319
        return RemoteBranchConfig(self)
2560
3320
 
 
3321
    def _get_config_store(self):
 
3322
        return RemoteBranchStore(self)
 
3323
 
2561
3324
    def _get_real_transport(self):
2562
3325
        # if we try vfs access, return the real branch's vfs transport
2563
3326
        self._ensure_real()
2626
3389
                self.bzrdir, self._client)
2627
3390
        return self._control_files
2628
3391
 
2629
 
    def _get_checkout_format(self):
2630
 
        self._ensure_real()
2631
 
        return self._real_branch._get_checkout_format()
2632
 
 
2633
3392
    def get_physical_lock_status(self):
2634
3393
        """See Branch.get_physical_lock_status()."""
2635
 
        # should be an API call to the server, as branches must be lockable.
2636
 
        self._ensure_real()
2637
 
        return self._real_branch.get_physical_lock_status()
 
3394
        try:
 
3395
            response = self._client.call('Branch.get_physical_lock_status',
 
3396
                self._remote_path())
 
3397
        except errors.UnknownSmartMethod:
 
3398
            self._ensure_real()
 
3399
            return self._real_branch.get_physical_lock_status()
 
3400
        if response[0] not in ('yes', 'no'):
 
3401
            raise errors.UnexpectedSmartServerResponse(response)
 
3402
        return (response[0] == 'yes')
2638
3403
 
2639
3404
    def get_stacked_on_url(self):
2640
3405
        """Get the URL this branch is stacked against.
2824
3589
            self.repository.unlock()
2825
3590
 
2826
3591
    def break_lock(self):
2827
 
        self._ensure_real()
2828
 
        return self._real_branch.break_lock()
 
3592
        try:
 
3593
            response = self._call(
 
3594
                'Branch.break_lock', self._remote_path())
 
3595
        except errors.UnknownSmartMethod:
 
3596
            self._ensure_real()
 
3597
            return self._real_branch.break_lock()
 
3598
        if response != ('ok',):
 
3599
            raise errors.UnexpectedSmartServerResponse(response)
2829
3600
 
2830
3601
    def leave_lock_in_place(self):
2831
3602
        if not self._lock_token:
3005
3776
        return self._lock_count >= 1
3006
3777
 
3007
3778
    @needs_read_lock
 
3779
    def revision_id_to_dotted_revno(self, revision_id):
 
3780
        """Given a revision id, return its dotted revno.
 
3781
 
 
3782
        :return: a tuple like (1,) or (400,1,3).
 
3783
        """
 
3784
        try:
 
3785
            response = self._call('Branch.revision_id_to_revno',
 
3786
                self._remote_path(), revision_id)
 
3787
        except errors.UnknownSmartMethod:
 
3788
            self._ensure_real()
 
3789
            return self._real_branch.revision_id_to_dotted_revno(revision_id)
 
3790
        if response[0] == 'ok':
 
3791
            return tuple([int(x) for x in response[1:]])
 
3792
        else:
 
3793
            raise errors.UnexpectedSmartServerResponse(response)
 
3794
 
 
3795
    @needs_read_lock
3008
3796
    def revision_id_to_revno(self, revision_id):
3009
 
        self._ensure_real()
3010
 
        return self._real_branch.revision_id_to_revno(revision_id)
 
3797
        """Given a revision id on the branch mainline, return its revno.
 
3798
 
 
3799
        :return: an integer
 
3800
        """
 
3801
        try:
 
3802
            response = self._call('Branch.revision_id_to_revno',
 
3803
                self._remote_path(), revision_id)
 
3804
        except errors.UnknownSmartMethod:
 
3805
            self._ensure_real()
 
3806
            return self._real_branch.revision_id_to_revno(revision_id)
 
3807
        if response[0] == 'ok':
 
3808
            if len(response) == 2:
 
3809
                return int(response[1])
 
3810
            raise NoSuchRevision(self, revision_id)
 
3811
        else:
 
3812
            raise errors.UnexpectedSmartServerResponse(response)
3011
3813
 
3012
3814
    @needs_write_lock
3013
3815
    def set_last_revision_info(self, revno, revision_id):
3242
4044
        return self._bzrdir._real_bzrdir
3243
4045
 
3244
4046
 
3245
 
 
3246
4047
def _extract_tar(tar, to_dir):
3247
4048
    """Extract all the contents of a tarfile object.
3248
4049
 
3252
4053
        tar.extract(tarinfo, to_dir)
3253
4054
 
3254
4055
 
 
4056
error_translators = registry.Registry()
 
4057
no_context_error_translators = registry.Registry()
 
4058
 
 
4059
 
3255
4060
def _translate_error(err, **context):
3256
4061
    """Translate an ErrorFromSmartServer into a more useful error.
3257
4062
 
3286
4091
                    'Missing key %r in context %r', key_err.args[0], context)
3287
4092
                raise err
3288
4093
 
3289
 
    if err.error_verb == 'NoSuchRevision':
3290
 
        raise NoSuchRevision(find('branch'), err.error_args[0])
3291
 
    elif err.error_verb == 'nosuchrevision':
3292
 
        raise NoSuchRevision(find('repository'), err.error_args[0])
3293
 
    elif err.error_verb == 'nobranch':
3294
 
        if len(err.error_args) >= 1:
3295
 
            extra = err.error_args[0]
3296
 
        else:
3297
 
            extra = None
3298
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
3299
 
            detail=extra)
3300
 
    elif err.error_verb == 'norepository':
3301
 
        raise errors.NoRepositoryPresent(find('bzrdir'))
3302
 
    elif err.error_verb == 'UnlockableTransport':
3303
 
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
3304
 
    elif err.error_verb == 'TokenMismatch':
3305
 
        raise errors.TokenMismatch(find('token'), '(remote token)')
3306
 
    elif err.error_verb == 'Diverged':
3307
 
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
3308
 
    elif err.error_verb == 'NotStacked':
3309
 
        raise errors.NotStacked(branch=find('branch'))
3310
 
    elif err.error_verb == 'PermissionDenied':
3311
 
        path = get_path()
3312
 
        if len(err.error_args) >= 2:
3313
 
            extra = err.error_args[1]
3314
 
        else:
3315
 
            extra = None
3316
 
        raise errors.PermissionDenied(path, extra=extra)
3317
 
    elif err.error_verb == 'ReadError':
3318
 
        path = get_path()
3319
 
        raise errors.ReadError(path)
3320
 
    elif err.error_verb == 'NoSuchFile':
3321
 
        path = get_path()
3322
 
        raise errors.NoSuchFile(path)
3323
 
    _translate_error_without_context(err)
3324
 
 
3325
 
 
3326
 
def _translate_error_without_context(err):
3327
 
    """Translate any ErrorFromSmartServer values that don't require context"""
3328
 
    if err.error_verb == 'IncompatibleRepositories':
3329
 
        raise errors.IncompatibleRepositories(err.error_args[0],
3330
 
            err.error_args[1], err.error_args[2])
3331
 
    elif err.error_verb == 'LockContention':
3332
 
        raise errors.LockContention('(remote lock)')
3333
 
    elif err.error_verb == 'LockFailed':
3334
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
3335
 
    elif err.error_verb == 'TipChangeRejected':
3336
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
3337
 
    elif err.error_verb == 'UnstackableBranchFormat':
3338
 
        raise errors.UnstackableBranchFormat(*err.error_args)
3339
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
3340
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
3341
 
    elif err.error_verb == 'FileExists':
3342
 
        raise errors.FileExists(err.error_args[0])
3343
 
    elif err.error_verb == 'DirectoryNotEmpty':
3344
 
        raise errors.DirectoryNotEmpty(err.error_args[0])
3345
 
    elif err.error_verb == 'ShortReadvError':
3346
 
        args = err.error_args
3347
 
        raise errors.ShortReadvError(
3348
 
            args[0], int(args[1]), int(args[2]), int(args[3]))
3349
 
    elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
 
4094
    try:
 
4095
        translator = error_translators.get(err.error_verb)
 
4096
    except KeyError:
 
4097
        pass
 
4098
    else:
 
4099
        raise translator(err, find, get_path)
 
4100
    try:
 
4101
        translator = no_context_error_translators.get(err.error_verb)
 
4102
    except KeyError:
 
4103
        raise errors.UnknownErrorFromSmartServer(err)
 
4104
    else:
 
4105
        raise translator(err)
 
4106
 
 
4107
 
 
4108
error_translators.register('NoSuchRevision',
 
4109
    lambda err, find, get_path: NoSuchRevision(
 
4110
        find('branch'), err.error_args[0]))
 
4111
error_translators.register('nosuchrevision',
 
4112
    lambda err, find, get_path: NoSuchRevision(
 
4113
        find('repository'), err.error_args[0]))
 
4114
 
 
4115
def _translate_nobranch_error(err, find, get_path):
 
4116
    if len(err.error_args) >= 1:
 
4117
        extra = err.error_args[0]
 
4118
    else:
 
4119
        extra = None
 
4120
    return errors.NotBranchError(path=find('bzrdir').root_transport.base,
 
4121
        detail=extra)
 
4122
 
 
4123
error_translators.register('nobranch', _translate_nobranch_error)
 
4124
error_translators.register('norepository',
 
4125
    lambda err, find, get_path: errors.NoRepositoryPresent(
 
4126
        find('bzrdir')))
 
4127
error_translators.register('UnlockableTransport',
 
4128
    lambda err, find, get_path: errors.UnlockableTransport(
 
4129
        find('bzrdir').root_transport))
 
4130
error_translators.register('TokenMismatch',
 
4131
    lambda err, find, get_path: errors.TokenMismatch(
 
4132
        find('token'), '(remote token)'))
 
4133
error_translators.register('Diverged',
 
4134
    lambda err, find, get_path: errors.DivergedBranches(
 
4135
        find('branch'), find('other_branch')))
 
4136
error_translators.register('NotStacked',
 
4137
    lambda err, find, get_path: errors.NotStacked(branch=find('branch')))
 
4138
 
 
4139
def _translate_PermissionDenied(err, find, get_path):
 
4140
    path = get_path()
 
4141
    if len(err.error_args) >= 2:
 
4142
        extra = err.error_args[1]
 
4143
    else:
 
4144
        extra = None
 
4145
    return errors.PermissionDenied(path, extra=extra)
 
4146
 
 
4147
error_translators.register('PermissionDenied', _translate_PermissionDenied)
 
4148
error_translators.register('ReadError',
 
4149
    lambda err, find, get_path: errors.ReadError(get_path()))
 
4150
error_translators.register('NoSuchFile',
 
4151
    lambda err, find, get_path: errors.NoSuchFile(get_path()))
 
4152
error_translators.register('TokenLockingNotSupported',
 
4153
    lambda err, find, get_path: errors.TokenLockingNotSupported(
 
4154
        find('repository')))
 
4155
error_translators.register('UnsuspendableWriteGroup',
 
4156
    lambda err, find, get_path: errors.UnsuspendableWriteGroup(
 
4157
        repository=find('repository')))
 
4158
error_translators.register('UnresumableWriteGroup',
 
4159
    lambda err, find, get_path: errors.UnresumableWriteGroup(
 
4160
        repository=find('repository'), write_groups=err.error_args[0],
 
4161
        reason=err.error_args[1]))
 
4162
no_context_error_translators.register('IncompatibleRepositories',
 
4163
    lambda err: errors.IncompatibleRepositories(
 
4164
        err.error_args[0], err.error_args[1], err.error_args[2]))
 
4165
no_context_error_translators.register('LockContention',
 
4166
    lambda err: errors.LockContention('(remote lock)'))
 
4167
no_context_error_translators.register('LockFailed',
 
4168
    lambda err: errors.LockFailed(err.error_args[0], err.error_args[1]))
 
4169
no_context_error_translators.register('TipChangeRejected',
 
4170
    lambda err: errors.TipChangeRejected(err.error_args[0].decode('utf8')))
 
4171
no_context_error_translators.register('UnstackableBranchFormat',
 
4172
    lambda err: errors.UnstackableBranchFormat(*err.error_args))
 
4173
no_context_error_translators.register('UnstackableRepositoryFormat',
 
4174
    lambda err: errors.UnstackableRepositoryFormat(*err.error_args))
 
4175
no_context_error_translators.register('FileExists',
 
4176
    lambda err: errors.FileExists(err.error_args[0]))
 
4177
no_context_error_translators.register('DirectoryNotEmpty',
 
4178
    lambda err: errors.DirectoryNotEmpty(err.error_args[0]))
 
4179
 
 
4180
def _translate_short_readv_error(err):
 
4181
    args = err.error_args
 
4182
    return errors.ShortReadvError(args[0], int(args[1]), int(args[2]),
 
4183
        int(args[3]))
 
4184
 
 
4185
no_context_error_translators.register('ShortReadvError',
 
4186
    _translate_short_readv_error)
 
4187
 
 
4188
def _translate_unicode_error(err):
3350
4189
        encoding = str(err.error_args[0]) # encoding must always be a string
3351
4190
        val = err.error_args[1]
3352
4191
        start = int(err.error_args[2])
3360
4199
            raise UnicodeDecodeError(encoding, val, start, end, reason)
3361
4200
        elif err.error_verb == 'UnicodeEncodeError':
3362
4201
            raise UnicodeEncodeError(encoding, val, start, end, reason)
3363
 
    elif err.error_verb == 'ReadOnlyError':
3364
 
        raise errors.TransportNotPossible('readonly transport')
3365
 
    elif err.error_verb == 'MemoryError':
3366
 
        raise errors.BzrError("remote server out of memory\n"
3367
 
            "Retry non-remotely, or contact the server admin for details.")
3368
 
    raise errors.UnknownErrorFromSmartServer(err)
 
4202
 
 
4203
no_context_error_translators.register('UnicodeEncodeError',
 
4204
    _translate_unicode_error)
 
4205
no_context_error_translators.register('UnicodeDecodeError',
 
4206
    _translate_unicode_error)
 
4207
no_context_error_translators.register('ReadOnlyError',
 
4208
    lambda err: errors.TransportNotPossible('readonly transport'))
 
4209
no_context_error_translators.register('MemoryError',
 
4210
    lambda err: errors.BzrError("remote server out of memory\n"
 
4211
        "Retry non-remotely, or contact the server admin for details."))
 
4212
no_context_error_translators.register('RevisionNotPresent',
 
4213
    lambda err: errors.RevisionNotPresent(err.error_args[0], err.error_args[1]))
 
4214
 
 
4215
no_context_error_translators.register('BzrCheckError',
 
4216
    lambda err: errors.BzrCheckError(msg=err.error_args[0]))
 
4217