← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/fetch.py

  • Committer: Andrew Bennetts
  • Date: 2010-08-17 06:45:33 UTC
  • mfrom: (5050.17.9 2.2)
  • mto: This revision was merged to the branch mainline in revision 5379.
  • Revision ID: andrew.bennetts@canonical.com-20100817064533-kof2i2f3r6mr4ayb
Merge lp:bzr/2.2 into lp:bzr, including fixes for #192859, #224373, #300062, #585667, #614404, #617503.

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 as _mod_graph,
32
31
    tsort,
33
32
    versionedfile,
34
33
    )
35
34
""")
 
35
import bzrlib
36
36
from bzrlib import (
37
37
    errors,
38
38
    ui,
54
54
 
55
55
        :param last_revision: If set, try to limit to the data this revision
56
56
            references.
57
 
        :param fetch_spec: A SearchResult specifying which revisions to fetch.
58
 
            If set, this overrides last_revision.
59
57
        :param find_ghosts: If True search the entire history for ghosts.
60
58
        """
61
59
        # repository.fetch has the responsibility for short-circuiting
94
92
        pb.show_pct = pb.show_count = False
95
93
        try:
96
94
            pb.update("Finding revisions", 0, 2)
97
 
            search_result = self._revids_to_fetch()
98
 
            mutter('fetching: %s', search_result)
99
 
            if search_result.is_empty():
 
95
            search = self._revids_to_fetch()
 
96
            if search is None:
100
97
                return
101
98
            pb.update("Fetching revisions", 1, 2)
102
 
            self._fetch_everything_for_search(search_result)
 
99
            self._fetch_everything_for_search(search)
103
100
        finally:
104
101
            pb.finished()
105
102
 
128
125
            pb.update("Inserting stream")
129
126
            resume_tokens, missing_keys = self.sink.insert_stream(
130
127
                stream, from_format, [])
 
128
            if self.to_repository._fallback_repositories:
 
129
                missing_keys.update(
 
130
                    self._parent_inventories(search.get_keys()))
131
131
            if missing_keys:
132
132
                pb.update("Missing keys")
133
133
                stream = source.get_stream_for_missing_keys(missing_keys)
151
151
        """Determines the exact revisions needed from self.from_repository to
152
152
        install self._last_revision in self.to_repository.
153
153
 
154
 
        :returns: A SearchResult of some sort.  (Possibly a
155
 
            PendingAncestryResult, EmptySearchResult, etc.)
 
154
        If no revisions need to be fetched, then this just returns None.
156
155
        """
157
156
        if self._fetch_spec is not None:
158
 
            # The fetch spec is already a concrete search result.
159
157
            return self._fetch_spec
160
 
        elif self._last_revision == NULL_REVISION:
161
 
            # 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:
162
160
            # explicit limit of no revisions needed
163
 
            return _mod_graph.EmptySearchResult()
164
 
        elif self._last_revision is not None:
165
 
            return _mod_graph.NotInOtherForRevs(self.to_repository,
166
 
                self.from_repository, [self._last_revision],
167
 
                find_ghosts=self.find_ghosts).execute()
168
 
        else: # self._last_revision is None:
169
 
            return _mod_graph.EverythingNotInOther(self.to_repository,
170
 
                self.from_repository,
171
 
                find_ghosts=self.find_ghosts).execute()
 
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
172
177
 
173
178
 
174
179
class Inter1and2Helper(object):
177
182
    This is for use by fetchers and converters.
178
183
    """
179
184
 
180
 
    # This is a class variable so that the test suite can override it.
181
 
    known_graph_threshold = 100
182
 
 
183
185
    def __init__(self, source):
184
186
        """Constructor.
185
187
 
241
243
        # yet, and are unlikely to in non-rich-root environments anyway.
242
244
        root_id_order.sort(key=operator.itemgetter(0))
243
245
        # Create a record stream containing the roots to create.
244
 
        if len(revs) > self.known_graph_threshold:
245
 
            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)
246
250
        new_roots_stream = _new_root_data_stream(
247
251
            root_id_order, rev_id_to_root_id, parent_map, self.source, graph)
248
252
        return [('texts', new_roots_stream)]
249
253
 
250
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
 
251
260
def _new_root_data_stream(
252
261
    root_keys_to_create, rev_id_to_root_id_map, parent_map, repo, graph=None):
253
262
    """Generate a texts substream of synthesised root entries.
317
326
                pass
318
327
            else:
319
328
                try:
320
 
                    parent_ids.append(tree.get_file_revision(root_id))
 
329
                    parent_ids.append(tree.inventory[root_id].revision)
321
330
                except errors.NoSuchId:
322
331
                    # not in the tree
323
332
                    pass
331
340
            selected_ids.append(parent_id)
332
341
    parent_keys = [(root_id, parent_id) for parent_id in selected_ids]
333
342
    return parent_keys
334
 
 
335
 
 
336
 
class TargetRepoKinds(object):
337
 
    """An enum-like set of constants.
338
 
    
339
 
    They are the possible values of FetchSpecFactory.target_repo_kinds.
340
 
    """
341
 
    
342
 
    PREEXISTING = 'preexisting'
343
 
    STACKED = 'stacked'
344
 
    EMPTY = 'empty'
345
 
 
346
 
 
347
 
class FetchSpecFactory(object):
348
 
    """A helper for building the best fetch spec for a sprout call.
349
 
 
350
 
    Factors that go into determining the sort of fetch to perform:
351
 
     * did the caller specify any revision IDs?
352
 
     * did the caller specify a source branch (need to fetch its
353
 
       heads_to_fetch(), usually the tip + tags)
354
 
     * is there an existing target repo (don't need to refetch revs it
355
 
       already has)
356
 
     * target is stacked?  (similar to pre-existing target repo: even if
357
 
       the target itself is new don't want to refetch existing revs)
358
 
 
359
 
    :ivar source_branch: the source branch if one specified, else None.
360
 
    :ivar source_branch_stop_revision_id: fetch up to this revision of
361
 
        source_branch, rather than its tip.
362
 
    :ivar source_repo: the source repository if one found, else None.
363
 
    :ivar target_repo: the target repository acquired by sprout.
364
 
    :ivar target_repo_kind: one of the TargetRepoKinds constants.
365
 
    """
366
 
 
367
 
    def __init__(self):
368
 
        self._explicit_rev_ids = set()
369
 
        self.source_branch = None
370
 
        self.source_branch_stop_revision_id = None
371
 
        self.source_repo = None
372
 
        self.target_repo = None
373
 
        self.target_repo_kind = None
374
 
        self.limit = None
375
 
 
376
 
    def add_revision_ids(self, revision_ids):
377
 
        """Add revision_ids to the set of revision_ids to be fetched."""
378
 
        self._explicit_rev_ids.update(revision_ids)
379
 
 
380
 
    def make_fetch_spec(self):
381
 
        """Build a SearchResult or PendingAncestryResult or etc."""
382
 
        if self.target_repo_kind is None or self.source_repo is None:
383
 
            raise AssertionError(
384
 
                'Incomplete FetchSpecFactory: %r' % (self.__dict__,))
385
 
        if len(self._explicit_rev_ids) == 0 and self.source_branch is None:
386
 
            if self.limit is not None:
387
 
                raise NotImplementedError(
388
 
                    "limit is only supported with a source branch set")
389
 
            # Caller hasn't specified any revisions or source branch
390
 
            if self.target_repo_kind == TargetRepoKinds.EMPTY:
391
 
                return _mod_graph.EverythingResult(self.source_repo)
392
 
            else:
393
 
                # We want everything not already in the target (or target's
394
 
                # fallbacks).
395
 
                return _mod_graph.EverythingNotInOther(
396
 
                    self.target_repo, self.source_repo).execute()
397
 
        heads_to_fetch = set(self._explicit_rev_ids)
398
 
        if self.source_branch is not None:
399
 
            must_fetch, if_present_fetch = self.source_branch.heads_to_fetch()
400
 
            if self.source_branch_stop_revision_id is not None:
401
 
                # Replace the tip rev from must_fetch with the stop revision
402
 
                # XXX: this might be wrong if the tip rev is also in the
403
 
                # must_fetch set for other reasons (e.g. it's the tip of
404
 
                # multiple loom threads?), but then it's pretty unclear what it
405
 
                # should mean to specify a stop_revision in that case anyway.
406
 
                must_fetch.discard(self.source_branch.last_revision())
407
 
                must_fetch.add(self.source_branch_stop_revision_id)
408
 
            heads_to_fetch.update(must_fetch)
409
 
        else:
410
 
            if_present_fetch = set()
411
 
        if self.target_repo_kind == TargetRepoKinds.EMPTY:
412
 
            # PendingAncestryResult does not raise errors if a requested head
413
 
            # is absent.  Ideally it would support the
414
 
            # required_ids/if_present_ids distinction, but in practice
415
 
            # heads_to_fetch will almost certainly be present so this doesn't
416
 
            # matter much.
417
 
            all_heads = heads_to_fetch.union(if_present_fetch)
418
 
            ret = _mod_graph.PendingAncestryResult(all_heads, self.source_repo)
419
 
            if self.limit is not None:
420
 
                graph = self.source_repo.get_graph()
421
 
                topo_order = list(graph.iter_topo_order(ret.get_keys()))
422
 
                result_set = topo_order[:self.limit]
423
 
                ret = self.source_repo.revision_ids_to_search_result(result_set)
424
 
            return ret
425
 
        else:
426
 
            return _mod_graph.NotInOtherForRevs(self.target_repo, self.source_repo,
427
 
                required_ids=heads_to_fetch, if_present_ids=if_present_fetch,
428
 
                limit=self.limit).execute()