← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Andrew Bennetts
  • Date: 2008-01-16 00:05:07 UTC
  • mfrom: (3184 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3186.
  • Revision ID: andrew.bennetts@canonical.com-20080116000507-r6qkryj0l4ontqky
Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
22
22
from bzrlib import (
23
23
    branch,
24
24
    errors,
 
25
    graph,
25
26
    lockdir,
26
27
    repository,
27
28
    revision,
264
265
        self._lock_token = None
265
266
        self._lock_count = 0
266
267
        self._leave_lock = False
 
268
        # A cache of looked up revision parent data; reset at unlock time.
 
269
        self._parents_map = None
267
270
        # For tests:
268
271
        # These depend on the actual remote format, so force them off for
269
272
        # maximum compatibility. XXX: In future these should depend on the
390
393
        
391
394
    def get_graph(self, other_repository=None):
392
395
        """Return the graph for this repository format"""
393
 
        self._ensure_real()
394
 
        return self._real_repository.get_graph(other_repository)
 
396
        parents_provider = self
 
397
        if (other_repository is not None and
 
398
            other_repository.bzrdir.transport.base !=
 
399
            self.bzrdir.transport.base):
 
400
            parents_provider = graph._StackedParentsProvider(
 
401
                [parents_provider, other_repository._make_parents_provider()])
 
402
        return graph.Graph(parents_provider)
395
403
 
396
404
    def gather_stats(self, revid=None, committers=None):
397
405
        """See Repository.gather_stats()."""
462
470
        if not self._lock_mode:
463
471
            self._lock_mode = 'r'
464
472
            self._lock_count = 1
 
473
            self._parents_map = {}
465
474
            if self._real_repository is not None:
466
475
                self._real_repository.lock_read()
467
476
        else:
499
508
                self._leave_lock = False
500
509
            self._lock_mode = 'w'
501
510
            self._lock_count = 1
 
511
            self._parents_map = {}
502
512
        elif self._lock_mode == 'r':
503
513
            raise errors.ReadOnlyError(self)
504
514
        else:
558
568
        self._lock_count -= 1
559
569
        if self._lock_count > 0:
560
570
            return
 
571
        self._parents_map = None
561
572
        old_mode = self._lock_mode
562
573
        self._lock_mode = None
563
574
        try:
726
737
        self._ensure_real()
727
738
        return self._real_repository.iter_files_bytes(desired_files)
728
739
 
 
740
    def get_parent_map(self, keys):
 
741
        """See bzrlib.Graph.get_parent_map()."""
 
742
        # Hack to build up the caching logic.
 
743
        ancestry = self._parents_map
 
744
        missing_revisions = set(key for key in keys if key not in ancestry)
 
745
        if missing_revisions:
 
746
            self._parents_map.update(self._get_parent_map(missing_revisions))
 
747
        return dict((k, ancestry[k]) for k in keys if k in ancestry)
 
748
 
 
749
    def _response_is_unknown_method(self, response, verb):
 
750
        """Return True if response is an unknonwn method response to verb.
 
751
        
 
752
        :param response: The response from a smart client call_expecting_body
 
753
            call.
 
754
        :param verb: The verb used in that call.
 
755
        :return: True if an unknown method was encountered.
 
756
        """
 
757
        # This might live better on
 
758
        # bzrlib.smart.protocol.SmartClientRequestProtocolOne
 
759
        if (response[0] == ('error', "Generic bzr smart protocol error: "
 
760
                "bad request '%s'" % verb) or
 
761
              response[0] == ('error', "Generic bzr smart protocol error: "
 
762
                "bad request u'%s'" % verb)):
 
763
           response[1].cancel_read_body()
 
764
           return True
 
765
        return False
 
766
 
 
767
    def _get_parent_map(self, keys):
 
768
        """Helper for get_parent_map that performs the RPC."""
 
769
        keys = set(keys)
 
770
        if NULL_REVISION in keys:
 
771
            keys.discard(NULL_REVISION)
 
772
            found_parents = {NULL_REVISION:()}
 
773
            if not keys:
 
774
                return found_parents
 
775
        else:
 
776
            found_parents = {}
 
777
        path = self.bzrdir._path_for_remote_call(self._client)
 
778
        for key in keys:
 
779
            assert type(key) is str
 
780
        verb = 'Repository.get_parent_map'
 
781
        response = self._client.call_expecting_body(
 
782
            verb, path, *keys)
 
783
        if self._response_is_unknown_method(response, verb):
 
784
            # Server that does not support this method, get the whole graph.
 
785
            response = self._client.call_expecting_body(
 
786
                'Repository.get_revision_graph', path, '')
 
787
            if response[0][0] not in ['ok', 'nosuchrevision']:
 
788
                reponse[1].cancel_read_body()
 
789
                raise errors.UnexpectedSmartServerResponse(response[0])
 
790
        elif response[0][0] not in ['ok']:
 
791
            reponse[1].cancel_read_body()
 
792
            raise errors.UnexpectedSmartServerResponse(response[0])
 
793
        if response[0][0] == 'ok':
 
794
            coded = response[1].read_body_bytes()
 
795
            if coded == '':
 
796
                # no revisions found
 
797
                return {}
 
798
            lines = coded.split('\n')
 
799
            revision_graph = {}
 
800
            for line in lines:
 
801
                d = tuple(line.split())
 
802
                if len(d) > 1:
 
803
                    revision_graph[d[0]] = d[1:]
 
804
                else:
 
805
                    # No parents - so give the Graph result (NULL_REVISION,).
 
806
                    revision_graph[d[0]] = (NULL_REVISION,)
 
807
            return revision_graph
 
808
 
729
809
    @needs_read_lock
730
810
    def get_signature_text(self, revision_id):
731
811
        self._ensure_real()
918
998
        return self._real_repository._check_for_inconsistent_revision_parents()
919
999
 
920
1000
    def _make_parents_provider(self):
921
 
        self._ensure_real()
922
 
        return self._real_repository._make_parents_provider()
 
1001
        return self
923
1002
 
924
1003
 
925
1004
class RemoteBranchLockableFiles(LockableFiles):