← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/fetch.py

  • Committer: John Arbash Meinel
  • Date: 2010-01-05 04:30:07 UTC
  • mfrom: (4932 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4934.
  • Revision ID: john@arbash-meinel.com-20100105043007-ehgbldqd3q0gtyws
Merge bzr.dev, resolve conflicts.

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, 2006, 2008, 2009 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
29
29
lazy_import(globals(), """
30
30
from bzrlib import (
31
31
    graph as _mod_graph,
 
32
    static_tuple,
32
33
    tsort,
33
34
    versionedfile,
34
35
    )
35
36
""")
 
37
import bzrlib
36
38
from bzrlib import (
37
39
    errors,
 
40
    symbol_versioning,
38
41
    ui,
39
42
    )
40
 
from bzrlib.i18n import gettext
41
43
from bzrlib.revision import NULL_REVISION
42
44
from bzrlib.trace import mutter
43
45
 
50
52
    """
51
53
 
52
54
    def __init__(self, to_repository, from_repository, last_revision=None,
53
 
        find_ghosts=True, fetch_spec=None):
 
55
        pb=None, find_ghosts=True, fetch_spec=None):
54
56
        """Create a repo fetcher.
55
57
 
56
58
        :param last_revision: If set, try to limit to the data this revision
57
59
            references.
58
 
        :param fetch_spec: A SearchResult specifying which revisions to fetch.
59
 
            If set, this overrides last_revision.
60
60
        :param find_ghosts: If True search the entire history for ghosts.
 
61
        :param pb: ProgressBar object to use; deprecated and ignored.
 
62
            This method will just create one on top of the stack.
61
63
        """
 
64
        if pb is not None:
 
65
            symbol_versioning.warn(
 
66
                symbol_versioning.deprecated_in((1, 14, 0))
 
67
                % "pb parameter to RepoFetcher.__init__")
 
68
            # and for simplicity it is in fact ignored
62
69
        # repository.fetch has the responsibility for short-circuiting
63
70
        # attempts to copy between a repository and itself.
64
71
        self.to_repository = to_repository
94
101
        pb = ui.ui_factory.nested_progress_bar()
95
102
        pb.show_pct = pb.show_count = False
96
103
        try:
97
 
            pb.update(gettext("Finding revisions"), 0, 2)
98
 
            search_result = self._revids_to_fetch()
99
 
            mutter('fetching: %s', search_result)
100
 
            if search_result.is_empty():
 
104
            pb.update("Finding revisions", 0, 2)
 
105
            search = self._revids_to_fetch()
 
106
            if search is None:
101
107
                return
102
 
            pb.update(gettext("Fetching revisions"), 1, 2)
103
 
            self._fetch_everything_for_search(search_result)
 
108
            pb.update("Fetching revisions", 1, 2)
 
109
            self._fetch_everything_for_search(search)
104
110
        finally:
105
111
            pb.finished()
106
112
 
129
135
            pb.update("Inserting stream")
130
136
            resume_tokens, missing_keys = self.sink.insert_stream(
131
137
                stream, from_format, [])
 
138
            if self.to_repository._fallback_repositories:
 
139
                missing_keys.update(
 
140
                    self._parent_inventories(search.get_keys()))
132
141
            if missing_keys:
133
142
                pb.update("Missing keys")
134
143
                stream = source.get_stream_for_missing_keys(missing_keys)
152
161
        """Determines the exact revisions needed from self.from_repository to
153
162
        install self._last_revision in self.to_repository.
154
163
 
155
 
        :returns: A SearchResult of some sort.  (Possibly a
156
 
            PendingAncestryResult, EmptySearchResult, etc.)
 
164
        If no revisions need to be fetched, then this just returns None.
157
165
        """
158
166
        if self._fetch_spec is not None:
159
 
            # The fetch spec is already a concrete search result.
160
167
            return self._fetch_spec
161
 
        elif self._last_revision == NULL_REVISION:
162
 
            # fetch_spec is None + last_revision is null => empty fetch.
 
168
        mutter('fetch up to rev {%s}', self._last_revision)
 
169
        if self._last_revision is NULL_REVISION:
163
170
            # explicit limit of no revisions needed
164
 
            return _mod_graph.EmptySearchResult()
165
 
        elif self._last_revision is not None:
166
 
            return _mod_graph.NotInOtherForRevs(self.to_repository,
167
 
                self.from_repository, [self._last_revision],
168
 
                find_ghosts=self.find_ghosts).execute()
169
 
        else: # self._last_revision is None:
170
 
            return _mod_graph.EverythingNotInOther(self.to_repository,
171
 
                self.from_repository,
172
 
                find_ghosts=self.find_ghosts).execute()
 
171
            return None
 
172
        return self.to_repository.search_missing_revision_ids(
 
173
            self.from_repository, self._last_revision,
 
174
            find_ghosts=self.find_ghosts)
 
175
 
 
176
    def _parent_inventories(self, revision_ids):
 
177
        # Find all the parent revisions referenced by the stream, but
 
178
        # not present in the stream, and make sure we send their
 
179
        # inventories.
 
180
        parent_maps = self.to_repository.get_parent_map(revision_ids)
 
181
        parents = set()
 
182
        map(parents.update, parent_maps.itervalues())
 
183
        parents.discard(NULL_REVISION)
 
184
        parents.difference_update(revision_ids)
 
185
        missing_keys = set(('inventories', rev_id) for rev_id in parents)
 
186
        return missing_keys
173
187
 
174
188
 
175
189
class Inter1and2Helper(object):
178
192
    This is for use by fetchers and converters.
179
193
    """
180
194
 
181
 
    # This is a class variable so that the test suite can override it.
182
 
    known_graph_threshold = 100
183
 
 
184
195
    def __init__(self, source):
185
196
        """Constructor.
186
197
 
242
253
        # yet, and are unlikely to in non-rich-root environments anyway.
243
254
        root_id_order.sort(key=operator.itemgetter(0))
244
255
        # Create a record stream containing the roots to create.
245
 
        if len(revs) > self.known_graph_threshold:
246
 
            graph = self.source.get_known_graph_ancestry(revs)
 
256
        if len(revs) > 100:
 
257
            graph = _get_rich_root_heads_graph(self.source_repo, revs)
247
258
        new_roots_stream = _new_root_data_stream(
248
259
            root_id_order, rev_id_to_root_id, parent_map, self.source, graph)
249
260
        return [('texts', new_roots_stream)]
250
261
 
251
262
 
 
263
def _get_rich_root_heads_graph(source_repo, revision_ids):
 
264
    """Get a Graph object suitable for asking heads() for new rich roots."""
 
265
    st = static_tuple.StaticTuple
 
266
    revision_keys = [st(r_id).intern() for r_id in revision_ids]
 
267
    known_graph = source_repo.revisions.get_known_graph_ancestry(
 
268
                    revision_keys)
 
269
    return _mod_graph.GraphThunkIdsToKeys(known_graph)
 
270
 
 
271
 
252
272
def _new_root_data_stream(
253
273
    root_keys_to_create, rev_id_to_root_id_map, parent_map, repo, graph=None):
254
274
    """Generate a texts substream of synthesised root entries.
318
338
                pass
319
339
            else:
320
340
                try:
321
 
                    parent_ids.append(tree.get_file_revision(root_id))
 
341
                    parent_ids.append(tree.inventory[root_id].revision)
322
342
                except errors.NoSuchId:
323
343
                    # not in the tree
324
344
                    pass
332
352
            selected_ids.append(parent_id)
333
353
    parent_keys = [(root_id, parent_id) for parent_id in selected_ids]
334
354
    return parent_keys
335
 
 
336
 
 
337
 
class TargetRepoKinds(object):
338
 
    """An enum-like set of constants.
339
 
    
340
 
    They are the possible values of FetchSpecFactory.target_repo_kinds.
341
 
    """
342
 
    
343
 
    PREEXISTING = 'preexisting'
344
 
    STACKED = 'stacked'
345
 
    EMPTY = 'empty'
346
 
 
347
 
 
348
 
class FetchSpecFactory(object):
349
 
    """A helper for building the best fetch spec for a sprout call.
350
 
 
351
 
    Factors that go into determining the sort of fetch to perform:
352
 
     * did the caller specify any revision IDs?
353
 
     * did the caller specify a source branch (need to fetch its
354
 
       heads_to_fetch(), usually the tip + tags)
355
 
     * is there an existing target repo (don't need to refetch revs it
356
 
       already has)
357
 
     * target is stacked?  (similar to pre-existing target repo: even if
358
 
       the target itself is new don't want to refetch existing revs)
359
 
 
360
 
    :ivar source_branch: the source branch if one specified, else None.
361
 
    :ivar source_branch_stop_revision_id: fetch up to this revision of
362
 
        source_branch, rather than its tip.
363
 
    :ivar source_repo: the source repository if one found, else None.
364
 
    :ivar target_repo: the target repository acquired by sprout.
365
 
    :ivar target_repo_kind: one of the TargetRepoKinds constants.
366
 
    """
367
 
 
368
 
    def __init__(self):
369
 
        self._explicit_rev_ids = set()
370
 
        self.source_branch = None
371
 
        self.source_branch_stop_revision_id = None
372
 
        self.source_repo = None
373
 
        self.target_repo = None
374
 
        self.target_repo_kind = None
375
 
        self.limit = None
376
 
 
377
 
    def add_revision_ids(self, revision_ids):
378
 
        """Add revision_ids to the set of revision_ids to be fetched."""
379
 
        self._explicit_rev_ids.update(revision_ids)
380
 
 
381
 
    def make_fetch_spec(self):
382
 
        """Build a SearchResult or PendingAncestryResult or etc."""
383
 
        if self.target_repo_kind is None or self.source_repo is None:
384
 
            raise AssertionError(
385
 
                'Incomplete FetchSpecFactory: %r' % (self.__dict__,))
386
 
        if len(self._explicit_rev_ids) == 0 and self.source_branch is None:
387
 
            if self.limit is not None:
388
 
                raise NotImplementedError(
389
 
                    "limit is only supported with a source branch set")
390
 
            # Caller hasn't specified any revisions or source branch
391
 
            if self.target_repo_kind == TargetRepoKinds.EMPTY:
392
 
                return _mod_graph.EverythingResult(self.source_repo)
393
 
            else:
394
 
                # We want everything not already in the target (or target's
395
 
                # fallbacks).
396
 
                return _mod_graph.EverythingNotInOther(
397
 
                    self.target_repo, self.source_repo).execute()
398
 
        heads_to_fetch = set(self._explicit_rev_ids)
399
 
        if self.source_branch is not None:
400
 
            must_fetch, if_present_fetch = self.source_branch.heads_to_fetch()
401
 
            if self.source_branch_stop_revision_id is not None:
402
 
                # Replace the tip rev from must_fetch with the stop revision
403
 
                # XXX: this might be wrong if the tip rev is also in the
404
 
                # must_fetch set for other reasons (e.g. it's the tip of
405
 
                # multiple loom threads?), but then it's pretty unclear what it
406
 
                # should mean to specify a stop_revision in that case anyway.
407
 
                must_fetch.discard(self.source_branch.last_revision())
408
 
                must_fetch.add(self.source_branch_stop_revision_id)
409
 
            heads_to_fetch.update(must_fetch)
410
 
        else:
411
 
            if_present_fetch = set()
412
 
        if self.target_repo_kind == TargetRepoKinds.EMPTY:
413
 
            # PendingAncestryResult does not raise errors if a requested head
414
 
            # is absent.  Ideally it would support the
415
 
            # required_ids/if_present_ids distinction, but in practice
416
 
            # heads_to_fetch will almost certainly be present so this doesn't
417
 
            # matter much.
418
 
            all_heads = heads_to_fetch.union(if_present_fetch)
419
 
            ret = _mod_graph.PendingAncestryResult(all_heads, self.source_repo)
420
 
            if self.limit is not None:
421
 
                graph = self.source_repo.get_graph()
422
 
                topo_order = list(graph.iter_topo_order(ret.get_keys()))
423
 
                result_set = topo_order[:self.limit]
424
 
                ret = self.source_repo.revision_ids_to_search_result(result_set)
425
 
            return ret
426
 
        else:
427
 
            return _mod_graph.NotInOtherForRevs(self.target_repo, self.source_repo,
428
 
                required_ids=heads_to_fetch, if_present_ids=if_present_fetch,
429
 
                limit=self.limit).execute()