← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

resolve conflicts against trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
32
32
    static_tuple,
33
33
    symbol_versioning,
34
34
    urlutils,
35
 
)
 
35
    versionedfile,
 
36
    vf_repository,
 
37
    )
36
38
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
37
39
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
38
40
from bzrlib.errors import (
43
45
from bzrlib.smart import client, vfs, repository as smart_repo
44
46
from bzrlib.smart.client import _SmartClient
45
47
from bzrlib.revision import NULL_REVISION
46
 
from bzrlib.repository import RepositoryWriteLockResult
 
48
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
47
49
from bzrlib.trace import mutter, note, warning
48
50
 
49
51
 
700
702
        return RemoteBzrDirConfig(self)
701
703
 
702
704
 
703
 
class RemoteRepositoryFormat(_mod_repository.RepositoryFormat):
 
705
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
704
706
    """Format for repositories accessed over a _SmartClient.
705
707
 
706
708
    Instances of this repository are represented by RemoteRepository
729
731
        self._custom_format = None
730
732
        self._network_name = None
731
733
        self._creating_bzrdir = None
 
734
        self._revision_graph_can_have_wrong_parents = None
732
735
        self._supports_chks = None
733
736
        self._supports_external_lookups = None
734
737
        self._supports_tree_reference = None
782
785
                self._custom_format.supports_tree_reference
783
786
        return self._supports_tree_reference
784
787
 
 
788
    @property
 
789
    def revision_graph_can_have_wrong_parents(self):
 
790
        if self._revision_graph_can_have_wrong_parents is None:
 
791
            self._ensure_real()
 
792
            self._revision_graph_can_have_wrong_parents = \
 
793
                self._custom_format.revision_graph_can_have_wrong_parents
 
794
        return self._revision_graph_can_have_wrong_parents
 
795
 
785
796
    def _vfs_initialize(self, a_bzrdir, shared):
786
797
        """Helper for common code in initialize."""
787
798
        if self._custom_format:
1070
1081
    def find_text_key_references(self):
1071
1082
        """Find the text key references within the repository.
1072
1083
 
1073
 
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
1074
 
        revision_ids. Each altered file-ids has the exact revision_ids that
1075
 
        altered it listed explicitly.
1076
1084
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
1077
1085
            to whether they were referred to by the inventory of the
1078
1086
            revision_id that they contain. The inventory texts from all present
1126
1134
        return RemoteStreamSource(self, to_format)
1127
1135
 
1128
1136
    @needs_read_lock
 
1137
    def get_file_graph(self):
 
1138
        return graph.Graph(self.texts)
 
1139
 
 
1140
    @needs_read_lock
1129
1141
    def has_revision(self, revision_id):
1130
1142
        """True if this repository has a copy of the revision."""
1131
1143
        # Copy of bzrlib.repository.Repository.has_revision
1472
1484
 
1473
1485
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1474
1486
                           timezone=None, committer=None, revprops=None,
1475
 
                           revision_id=None):
 
1487
                           revision_id=None, lossy=False):
1476
1488
        # FIXME: It ought to be possible to call this without immediately
1477
1489
        # triggering _ensure_real.  For now it's the easiest thing to do.
1478
1490
        self._ensure_real()
1479
1491
        real_repo = self._real_repository
1480
1492
        builder = real_repo.get_commit_builder(branch, parents,
1481
1493
                config, timestamp=timestamp, timezone=timezone,
1482
 
                committer=committer, revprops=revprops, revision_id=revision_id)
 
1494
                committer=committer, revprops=revprops,
 
1495
                revision_id=revision_id, lossy=lossy)
1483
1496
        return builder
1484
1497
 
1485
1498
    def add_fallback_repository(self, repository):
1593
1606
    @needs_read_lock
1594
1607
    def search_missing_revision_ids(self, other,
1595
1608
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
1596
 
            find_ghosts=True, revision_ids=None, if_present_ids=None):
 
1609
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
1610
            limit=None):
1597
1611
        """Return the revision ids that other has that this does not.
1598
1612
 
1599
1613
        These are returned in topological order.
1613
1627
        inter_repo = _mod_repository.InterRepository.get(other, self)
1614
1628
        return inter_repo.search_missing_revision_ids(
1615
1629
            find_ghosts=find_ghosts, revision_ids=revision_ids,
1616
 
            if_present_ids=if_present_ids)
 
1630
            if_present_ids=if_present_ids, limit=limit)
1617
1631
 
1618
1632
    def fetch(self, source, revision_id=None, find_ghosts=False,
1619
1633
            fetch_spec=None):
1986
2000
        return self._real_repository.item_keys_introduced_by(revision_ids,
1987
2001
            _files_pb=_files_pb)
1988
2002
 
1989
 
    def revision_graph_can_have_wrong_parents(self):
1990
 
        # The answer depends on the remote repo format.
1991
 
        self._ensure_real()
1992
 
        return self._real_repository.revision_graph_can_have_wrong_parents()
1993
 
 
1994
2003
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1995
2004
        self._ensure_real()
1996
2005
        return self._real_repository._find_inconsistent_revision_parents(
2004
2013
        providers = [self._unstacked_provider]
2005
2014
        if other is not None:
2006
2015
            providers.insert(0, other)
2007
 
        providers.extend(r._make_parents_provider() for r in
2008
 
                         self._fallback_repositories)
2009
 
        return graph.StackedParentsProvider(providers)
 
2016
        return graph.StackedParentsProvider(_LazyListJoin(
 
2017
            providers, self._fallback_repositories))
2010
2018
 
2011
2019
    def _serialise_search_recipe(self, recipe):
2012
2020
        """Serialise a graph search recipe.
2036
2044
            raise errors.UnexpectedSmartServerResponse(response)
2037
2045
 
2038
2046
 
2039
 
class RemoteStreamSink(_mod_repository.StreamSink):
 
2047
class RemoteStreamSink(vf_repository.StreamSink):
2040
2048
 
2041
2049
    def _insert_real(self, stream, src_format, resume_tokens):
2042
2050
        self.target_repo._ensure_real()
2154
2162
                yield substream_kind, substream
2155
2163
 
2156
2164
 
2157
 
class RemoteStreamSource(_mod_repository.StreamSource):
 
2165
class RemoteStreamSource(vf_repository.StreamSource):
2158
2166
    """Stream data from a remote server."""
2159
2167
 
2160
2168
    def get_stream(self, search):
2845
2853
            missing_parent = parent_map[missing_parent]
2846
2854
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2847
2855
 
2848
 
    def _last_revision_info(self):
 
2856
    def _read_last_revision_info(self):
2849
2857
        response = self._call('Branch.last_revision_info', self._remote_path())
2850
2858
        if response[0] != 'ok':
2851
2859
            raise SmartProtocolError('unexpected response code %s' % (response,))
2914
2922
            raise errors.UnexpectedSmartServerResponse(response)
2915
2923
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2916
2924
 
 
2925
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2917
2926
    @needs_write_lock
2918
2927
    def set_revision_history(self, rev_history):
 
2928
        """See Branch.set_revision_history."""
 
2929
        self._set_revision_history(rev_history)
 
2930
 
 
2931
    @needs_write_lock
 
2932
    def _set_revision_history(self, rev_history):
2919
2933
        # Send just the tip revision of the history; the server will generate
2920
2934
        # the full history from that.  If the revision doesn't exist in this
2921
2935
        # branch, NoSuchRevision will be raised.
2979
2993
            _override_hook_target=self, **kwargs)
2980
2994
 
2981
2995
    @needs_read_lock
2982
 
    def push(self, target, overwrite=False, stop_revision=None):
 
2996
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2983
2997
        self._ensure_real()
2984
2998
        return self._real_branch.push(
2985
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
2999
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2986
3000
            _override_hook_source_branch=self)
2987
3001
 
2988
3002
    def is_locked(self):
2998
3012
        # XXX: These should be returned by the set_last_revision_info verb
2999
3013
        old_revno, old_revid = self.last_revision_info()
3000
3014
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
3001
 
        revision_id = _mod_revision.ensure_null(revision_id)
 
3015
        if not revision_id or not isinstance(revision_id, basestring):
 
3016
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
3002
3017
        try:
3003
3018
            response = self._call('Branch.set_last_revision_info',
3004
3019
                self._remote_path(), self._lock_token, self._repo_lock_token,
3033
3048
            except errors.UnknownSmartMethod:
3034
3049
                medium._remember_remote_is_before((1, 6))
3035
3050
        self._clear_cached_state_of_remote_branch_only()
3036
 
        self.set_revision_history(self._lefthand_history(revision_id,
 
3051
        self._set_revision_history(self._lefthand_history(revision_id,
3037
3052
            last_rev=last_rev,other_branch=other_branch))
3038
3053
 
3039
3054
    def set_push_location(self, location):