/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: Vincent Ladeuil
  • Date: 2011-08-16 13:12:40 UTC
  • mfrom: (6071 +trunk)
  • mto: This revision was merged to the branch mainline in revision 6076.
  • Revision ID: v.ladeuil+lp@free.fr-20110816131240-gcyn9cik86dxwgz3
Merge into trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/fetch.py
28
28
from bzrlib.lazy_import import lazy_import
29
29
lazy_import(globals(), """
30
30
from bzrlib import (
31
 
    graph,
 
31
    graph as _mod_graph,
32
32
    tsort,
33
33
    versionedfile,
34
34
    )
35
35
""")
36
 
import bzrlib
37
36
from bzrlib import (
38
37
    errors,
39
38
    ui,
55
54
 
56
55
        :param last_revision: If set, try to limit to the data this revision
57
56
            references.
 
57
        :param fetch_spec: A SearchResult specifying which revisions to fetch.
 
58
            If set, this overrides last_revision.
58
59
        :param find_ghosts: If True search the entire history for ghosts.
59
60
        """
60
61
        # repository.fetch has the responsibility for short-circuiting
93
94
        pb.show_pct = pb.show_count = False
94
95
        try:
95
96
            pb.update("Finding revisions", 0, 2)
96
 
            search = self._revids_to_fetch()
97
 
            mutter('fetching: %s', search)
98
 
            if search.is_empty():
 
97
            search_result = self._revids_to_fetch()
 
98
            mutter('fetching: %s', search_result)
 
99
            if search_result.is_empty():
99
100
                return
100
101
            pb.update("Fetching revisions", 1, 2)
101
 
            self._fetch_everything_for_search(search)
 
102
            self._fetch_everything_for_search(search_result)
102
103
        finally:
103
104
            pb.finished()
104
105
 
151
152
        install self._last_revision in self.to_repository.
152
153
 
153
154
        :returns: A SearchResult of some sort.  (Possibly a
154
 
        PendingAncestryResult, EmptySearchResult, etc.)
 
155
            PendingAncestryResult, EmptySearchResult, etc.)
155
156
        """
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:
 
157
        if self._fetch_spec is not None:
166
158
            # The fetch spec is already a concrete search result.
167
159
            return self._fetch_spec
168
160
        elif self._last_revision == NULL_REVISION:
169
161
            # fetch_spec is None + last_revision is null => empty fetch.
170
162
            # explicit limit of no revisions needed
171
 
            return graph.EmptySearchResult()
 
163
            return _mod_graph.EmptySearchResult()
172
164
        elif self._last_revision is not None:
173
 
            return graph.NotInOtherForRevs(self.to_repository,
 
165
            return _mod_graph.NotInOtherForRevs(self.to_repository,
174
166
                self.from_repository, [self._last_revision],
175
 
                find_ghosts=self.find_ghosts).get_search_result()
 
167
                find_ghosts=self.find_ghosts).execute()
176
168
        else: # self._last_revision is None:
177
 
            return graph.EverythingNotInOther(self.to_repository,
 
169
            return _mod_graph.EverythingNotInOther(self.to_repository,
178
170
                self.from_repository,
179
 
                find_ghosts=self.find_ghosts).get_search_result()
 
171
                find_ghosts=self.find_ghosts).execute()
180
172
 
181
173
 
182
174
class Inter1and2Helper(object):
325
317
                pass
326
318
            else:
327
319
                try:
328
 
                    parent_ids.append(tree.inventory[root_id].revision)
 
320
                    parent_ids.append(tree.get_file_revision(root_id))
329
321
                except errors.NoSuchId:
330
322
                    # not in the tree
331
323
                    pass
339
331
            selected_ids.append(parent_id)
340
332
    parent_keys = [(root_id, parent_id) for parent_id in selected_ids]
341
333
    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()