← 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-10-13 00:26:41 UTC
  • mto: This revision was merged to the branch mainline in revision 5498.
  • Revision ID: andrew.bennetts@canonical.com-20101013002641-9tlh9k89mlj1666m
Keep docs-plain working.

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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
 
17
18
"""Copying of history from one branch to another.
18
19
 
19
20
The basic plan is that every branch knows the history of everything
22
23
branch.
23
24
"""
24
25
 
25
 
from __future__ import absolute_import
26
 
 
27
26
import operator
28
27
 
29
28
from bzrlib.lazy_import import lazy_import
31
30
from bzrlib import (
32
31
    tsort,
33
32
    versionedfile,
34
 
    vf_search,
35
33
    )
36
34
""")
 
35
import bzrlib
37
36
from bzrlib import (
38
37
    errors,
39
38
    ui,
40
39
    )
41
 
from bzrlib.i18n import gettext
42
40
from bzrlib.revision import NULL_REVISION
43
41
from bzrlib.trace import mutter
44
42
 
56
54
 
57
55
        :param last_revision: If set, try to limit to the data this revision
58
56
            references.
59
 
        :param fetch_spec: A SearchResult specifying which revisions to fetch.
60
 
            If set, this overrides last_revision.
61
57
        :param find_ghosts: If True search the entire history for ghosts.
62
58
        """
63
59
        # repository.fetch has the responsibility for short-circuiting
95
91
        pb = ui.ui_factory.nested_progress_bar()
96
92
        pb.show_pct = pb.show_count = False
97
93
        try:
98
 
            pb.update(gettext("Finding revisions"), 0, 2)
99
 
            search_result = self._revids_to_fetch()
100
 
            mutter('fetching: %s', search_result)
101
 
            if search_result.is_empty():
 
94
            pb.update("Finding revisions", 0, 2)
 
95
            search = self._revids_to_fetch()
 
96
            if search is None:
102
97
                return
103
 
            pb.update(gettext("Fetching revisions"), 1, 2)
104
 
            self._fetch_everything_for_search(search_result)
 
98
            pb.update("Fetching revisions", 1, 2)
 
99
            self._fetch_everything_for_search(search)
105
100
        finally:
106
101
            pb.finished()
107
102
 
130
125
            pb.update("Inserting stream")
131
126
            resume_tokens, missing_keys = self.sink.insert_stream(
132
127
                stream, from_format, [])
 
128
            if self.to_repository._fallback_repositories:
 
129
                missing_keys.update(
 
130
                    self._parent_inventories(search.get_keys()))
133
131
            if missing_keys:
134
132
                pb.update("Missing keys")
135
133
                stream = source.get_stream_for_missing_keys(missing_keys)
153
151
        """Determines the exact revisions needed from self.from_repository to
154
152
        install self._last_revision in self.to_repository.
155
153
 
156
 
        :returns: A SearchResult of some sort.  (Possibly a
157
 
            PendingAncestryResult, EmptySearchResult, etc.)
 
154
        If no revisions need to be fetched, then this just returns None.
158
155
        """
159
156
        if self._fetch_spec is not None:
160
 
            # The fetch spec is already a concrete search result.
161
157
            return self._fetch_spec
162
 
        elif self._last_revision == NULL_REVISION:
163
 
            # 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:
164
160
            # explicit limit of no revisions needed
165
 
            return vf_search.EmptySearchResult()
166
 
        elif self._last_revision is not None:
167
 
            return vf_search.NotInOtherForRevs(self.to_repository,
168
 
                self.from_repository, [self._last_revision],
169
 
                find_ghosts=self.find_ghosts).execute()
170
 
        else: # self._last_revision is None:
171
 
            return vf_search.EverythingNotInOther(self.to_repository,
172
 
                self.from_repository,
173
 
                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
174
177
 
175
178
 
176
179
class Inter1and2Helper(object):
319
322
                pass
320
323
            else:
321
324
                try:
322
 
                    parent_ids.append(tree.get_file_revision(root_id))
 
325
                    parent_ids.append(tree.inventory[root_id].revision)
323
326
                except errors.NoSuchId:
324
327
                    # not in the tree
325
328
                    pass
333
336
            selected_ids.append(parent_id)
334
337
    parent_keys = [(root_id, parent_id) for parent_id in selected_ids]
335
338
    return parent_keys
336
 
 
337
 
 
338
 
class TargetRepoKinds(object):
339
 
    """An enum-like set of constants.
340
 
    
341
 
    They are the possible values of FetchSpecFactory.target_repo_kinds.
342
 
    """
343
 
    
344
 
    PREEXISTING = 'preexisting'
345
 
    STACKED = 'stacked'
346
 
    EMPTY = 'empty'
347
 
 
348
 
 
349
 
class FetchSpecFactory(object):
350
 
    """A helper for building the best fetch spec for a sprout call.
351
 
 
352
 
    Factors that go into determining the sort of fetch to perform:
353
 
     * did the caller specify any revision IDs?
354
 
     * did the caller specify a source branch (need to fetch its
355
 
       heads_to_fetch(), usually the tip + tags)
356
 
     * is there an existing target repo (don't need to refetch revs it
357
 
       already has)
358
 
     * target is stacked?  (similar to pre-existing target repo: even if
359
 
       the target itself is new don't want to refetch existing revs)
360
 
 
361
 
    :ivar source_branch: the source branch if one specified, else None.
362
 
    :ivar source_branch_stop_revision_id: fetch up to this revision of
363
 
        source_branch, rather than its tip.
364
 
    :ivar source_repo: the source repository if one found, else None.
365
 
    :ivar target_repo: the target repository acquired by sprout.
366
 
    :ivar target_repo_kind: one of the TargetRepoKinds constants.
367
 
    """
368
 
 
369
 
    def __init__(self):
370
 
        self._explicit_rev_ids = set()
371
 
        self.source_branch = None
372
 
        self.source_branch_stop_revision_id = None
373
 
        self.source_repo = None
374
 
        self.target_repo = None
375
 
        self.target_repo_kind = None
376
 
        self.limit = None
377
 
 
378
 
    def add_revision_ids(self, revision_ids):
379
 
        """Add revision_ids to the set of revision_ids to be fetched."""
380
 
        self._explicit_rev_ids.update(revision_ids)
381
 
 
382
 
    def make_fetch_spec(self):
383
 
        """Build a SearchResult or PendingAncestryResult or etc."""
384
 
        if self.target_repo_kind is None or self.source_repo is None:
385
 
            raise AssertionError(
386
 
                'Incomplete FetchSpecFactory: %r' % (self.__dict__,))
387
 
        if len(self._explicit_rev_ids) == 0 and self.source_branch is None:
388
 
            if self.limit is not None:
389
 
                raise NotImplementedError(
390
 
                    "limit is only supported with a source branch set")
391
 
            # Caller hasn't specified any revisions or source branch
392
 
            if self.target_repo_kind == TargetRepoKinds.EMPTY:
393
 
                return vf_search.EverythingResult(self.source_repo)
394
 
            else:
395
 
                # We want everything not already in the target (or target's
396
 
                # fallbacks).
397
 
                return vf_search.EverythingNotInOther(
398
 
                    self.target_repo, self.source_repo).execute()
399
 
        heads_to_fetch = set(self._explicit_rev_ids)
400
 
        if self.source_branch is not None:
401
 
            must_fetch, if_present_fetch = self.source_branch.heads_to_fetch()
402
 
            if self.source_branch_stop_revision_id is not None:
403
 
                # Replace the tip rev from must_fetch with the stop revision
404
 
                # XXX: this might be wrong if the tip rev is also in the
405
 
                # must_fetch set for other reasons (e.g. it's the tip of
406
 
                # multiple loom threads?), but then it's pretty unclear what it
407
 
                # should mean to specify a stop_revision in that case anyway.
408
 
                must_fetch.discard(self.source_branch.last_revision())
409
 
                must_fetch.add(self.source_branch_stop_revision_id)
410
 
            heads_to_fetch.update(must_fetch)
411
 
        else:
412
 
            if_present_fetch = set()
413
 
        if self.target_repo_kind == TargetRepoKinds.EMPTY:
414
 
            # PendingAncestryResult does not raise errors if a requested head
415
 
            # is absent.  Ideally it would support the
416
 
            # required_ids/if_present_ids distinction, but in practice
417
 
            # heads_to_fetch will almost certainly be present so this doesn't
418
 
            # matter much.
419
 
            all_heads = heads_to_fetch.union(if_present_fetch)
420
 
            ret = vf_search.PendingAncestryResult(all_heads, self.source_repo)
421
 
            if self.limit is not None:
422
 
                graph = self.source_repo.get_graph()
423
 
                topo_order = list(graph.iter_topo_order(ret.get_keys()))
424
 
                result_set = topo_order[:self.limit]
425
 
                ret = self.source_repo.revision_ids_to_search_result(result_set)
426
 
            return ret
427
 
        else:
428
 
            return vf_search.NotInOtherForRevs(self.target_repo, self.source_repo,
429
 
                required_ids=heads_to_fetch, if_present_ids=if_present_fetch,
430
 
                limit=self.limit).execute()