/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: Jelmer Vernooij
  • Date: 2011-12-19 10:58:39 UTC
  • mfrom: (6383 +trunk)
  • mto: This revision was merged to the branch mainline in revision 6386.
  • Revision ID: jelmer@canonical.com-20111219105839-uji05ck4rkm1mj4j
Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/fetch.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 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
from __future__ import absolute_import
17
18
 
18
19
"""Copying of history from one branch to another.
19
20
 
30
31
from bzrlib import (
31
32
    tsort,
32
33
    versionedfile,
 
34
    vf_search,
33
35
    )
34
36
""")
35
 
import bzrlib
36
37
from bzrlib import (
37
38
    errors,
38
39
    ui,
39
40
    )
 
41
from bzrlib.i18n import gettext
40
42
from bzrlib.revision import NULL_REVISION
41
43
from bzrlib.trace import mutter
42
44
 
54
56
 
55
57
        :param last_revision: If set, try to limit to the data this revision
56
58
            references.
 
59
        :param fetch_spec: A SearchResult specifying which revisions to fetch.
 
60
            If set, this overrides last_revision.
57
61
        :param find_ghosts: If True search the entire history for ghosts.
58
62
        """
59
63
        # repository.fetch has the responsibility for short-circuiting
91
95
        pb = ui.ui_factory.nested_progress_bar()
92
96
        pb.show_pct = pb.show_count = False
93
97
        try:
94
 
            pb.update("Finding revisions", 0, 2)
95
 
            search = self._revids_to_fetch()
96
 
            if search is None:
 
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():
97
102
                return
98
 
            pb.update("Fetching revisions", 1, 2)
99
 
            self._fetch_everything_for_search(search)
 
103
            pb.update(gettext("Fetching revisions"), 1, 2)
 
104
            self._fetch_everything_for_search(search_result)
100
105
        finally:
101
106
            pb.finished()
102
107
 
125
130
            pb.update("Inserting stream")
126
131
            resume_tokens, missing_keys = self.sink.insert_stream(
127
132
                stream, from_format, [])
128
 
            if self.to_repository._fallback_repositories:
129
 
                missing_keys.update(
130
 
                    self._parent_inventories(search.get_keys()))
131
133
            if missing_keys:
132
134
                pb.update("Missing keys")
133
135
                stream = source.get_stream_for_missing_keys(missing_keys)
151
153
        """Determines the exact revisions needed from self.from_repository to
152
154
        install self._last_revision in self.to_repository.
153
155
 
154
 
        If no revisions need to be fetched, then this just returns None.
 
156
        :returns: A SearchResult of some sort.  (Possibly a
 
157
            PendingAncestryResult, EmptySearchResult, etc.)
155
158
        """
156
159
        if self._fetch_spec is not None:
 
160
            # The fetch spec is already a concrete search result.
157
161
            return self._fetch_spec
158
 
        mutter('fetch up to rev {%s}', self._last_revision)
159
 
        if self._last_revision is NULL_REVISION:
 
162
        elif self._last_revision == NULL_REVISION:
 
163
            # fetch_spec is None + last_revision is null => empty fetch.
160
164
            # explicit limit of no revisions needed
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
 
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()
177
174
 
178
175
 
179
176
class Inter1and2Helper(object):
182
179
    This is for use by fetchers and converters.
183
180
    """
184
181
 
 
182
    # This is a class variable so that the test suite can override it.
 
183
    known_graph_threshold = 100
 
184
 
185
185
    def __init__(self, source):
186
186
        """Constructor.
187
187
 
243
243
        # yet, and are unlikely to in non-rich-root environments anyway.
244
244
        root_id_order.sort(key=operator.itemgetter(0))
245
245
        # Create a record stream containing the roots to create.
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
        if len(revs) > self.known_graph_threshold:
 
247
            graph = self.source.get_known_graph_ancestry(revs)
250
248
        new_roots_stream = _new_root_data_stream(
251
249
            root_id_order, rev_id_to_root_id, parent_map, self.source, graph)
252
250
        return [('texts', new_roots_stream)]
253
251
 
254
252
 
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
 
 
260
253
def _new_root_data_stream(
261
254
    root_keys_to_create, rev_id_to_root_id_map, parent_map, repo, graph=None):
262
255
    """Generate a texts substream of synthesised root entries.
326
319
                pass
327
320
            else:
328
321
                try:
329
 
                    parent_ids.append(tree.inventory[root_id].revision)
 
322
                    parent_ids.append(tree.get_file_revision(root_id))
330
323
                except errors.NoSuchId:
331
324
                    # not in the tree
332
325
                    pass
340
333
            selected_ids.append(parent_id)
341
334
    parent_keys = [(root_id, parent_id) for parent_id in selected_ids]
342
335
    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()