/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/fetch.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/fetch.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
28
28
from bzrlib.lazy_import import lazy_import
29
29
lazy_import(globals(), """
30
30
from bzrlib import (
31
 
    graph,
32
31
    tsort,
33
32
    versionedfile,
34
33
    )
94
93
        try:
95
94
            pb.update("Finding revisions", 0, 2)
96
95
            search = self._revids_to_fetch()
97
 
            mutter('fetching: %s', search)
98
 
            if search.is_empty():
 
96
            if search is None:
99
97
                return
100
98
            pb.update("Fetching revisions", 1, 2)
101
99
            self._fetch_everything_for_search(search)
127
125
            pb.update("Inserting stream")
128
126
            resume_tokens, missing_keys = self.sink.insert_stream(
129
127
                stream, from_format, [])
 
128
            if self.to_repository._fallback_repositories:
 
129
                missing_keys.update(
 
130
                    self._parent_inventories(search.get_keys()))
130
131
            if missing_keys:
131
132
                pb.update("Missing keys")
132
133
                stream = source.get_stream_for_missing_keys(missing_keys)
150
151
        """Determines the exact revisions needed from self.from_repository to
151
152
        install self._last_revision in self.to_repository.
152
153
 
153
 
        :returns: A SearchResult of some sort.  (Possibly a
154
 
        PendingAncestryResult, EmptySearchResult, etc.)
 
154
        If no revisions need to be fetched, then this just returns None.
155
155
        """
156
 
        mutter("self._fetch_spec, self._last_revision: %r, %r",
157
 
                self._fetch_spec, self._last_revision)
158
 
        get_search_result = getattr(self._fetch_spec, 'get_search_result', None)
159
 
        if get_search_result is not None:
160
 
            mutter(
161
 
                'resolving fetch_spec into search result: %s', self._fetch_spec)
162
 
            # This is EverythingNotInOther or a similar kind of fetch_spec.
163
 
            # Turn it into a search result.
164
 
            return get_search_result()
165
 
        elif self._fetch_spec is not None:
166
 
            # The fetch spec is already a concrete search result.
 
156
        if self._fetch_spec is not None:
167
157
            return self._fetch_spec
168
 
        elif self._last_revision == NULL_REVISION:
169
 
            # fetch_spec is None + last_revision is null => empty fetch.
 
158
        mutter('fetch up to rev {%s}', self._last_revision)
 
159
        if self._last_revision is NULL_REVISION:
170
160
            # explicit limit of no revisions needed
171
 
            return graph.EmptySearchResult()
172
 
        elif self._last_revision is not None:
173
 
            return graph.NotInOtherForRevs(self.to_repository,
174
 
                self.from_repository, [self._last_revision],
175
 
                find_ghosts=self.find_ghosts).get_search_result()
176
 
        else: # self._last_revision is None:
177
 
            return graph.EverythingNotInOther(self.to_repository,
178
 
                self.from_repository,
179
 
                find_ghosts=self.find_ghosts).get_search_result()
 
161
            return None
 
162
        return self.to_repository.search_missing_revision_ids(
 
163
            self.from_repository, self._last_revision,
 
164
            find_ghosts=self.find_ghosts)
 
165
 
 
166
    def _parent_inventories(self, revision_ids):
 
167
        # Find all the parent revisions referenced by the stream, but
 
168
        # not present in the stream, and make sure we send their
 
169
        # inventories.
 
170
        parent_maps = self.to_repository.get_parent_map(revision_ids)
 
171
        parents = set()
 
172
        map(parents.update, parent_maps.itervalues())
 
173
        parents.discard(NULL_REVISION)
 
174
        parents.difference_update(revision_ids)
 
175
        missing_keys = set(('inventories', rev_id) for rev_id in parents)
 
176
        return missing_keys
180
177
 
181
178
 
182
179
class Inter1and2Helper(object):
185
182
    This is for use by fetchers and converters.
186
183
    """
187
184
 
188
 
    # This is a class variable so that the test suite can override it.
189
 
    known_graph_threshold = 100
190
 
 
191
185
    def __init__(self, source):
192
186
        """Constructor.
193
187
 
249
243
        # yet, and are unlikely to in non-rich-root environments anyway.
250
244
        root_id_order.sort(key=operator.itemgetter(0))
251
245
        # Create a record stream containing the roots to create.
252
 
        if len(revs) > self.known_graph_threshold:
253
 
            graph = self.source.get_known_graph_ancestry(revs)
 
246
        if len(revs) > 100:
 
247
            # XXX: not covered by tests, should have a flag to always run
 
248
            # this. -- mbp 20100129
 
249
            graph = self.source_repo.get_known_graph_ancestry(revs)
254
250
        new_roots_stream = _new_root_data_stream(
255
251
            root_id_order, rev_id_to_root_id, parent_map, self.source, graph)
256
252
        return [('texts', new_roots_stream)]
257
253
 
258
254
 
 
255
def _get_rich_root_heads_graph(source_repo, revision_ids):
 
256
    """Get a Graph object suitable for asking heads() for new rich roots."""
 
257
    return 
 
258
 
 
259
 
259
260
def _new_root_data_stream(
260
261
    root_keys_to_create, rev_id_to_root_id_map, parent_map, repo, graph=None):
261
262
    """Generate a texts substream of synthesised root entries.