← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/fetch.py

  • Committer: Gordon Tyler
  • Date: 2011-01-21 23:51:15 UTC
  • mto: This revision was merged to the branch mainline in revision 5632.
  • Revision ID: gordon@doxxx.net-20110121235115-9sdqamejot1h0481
Replace usage of format function from python 2.6 with our own very simple formatting function.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/fetch.py
33
33
    versionedfile,
34
34
    )
35
35
""")
 
36
import bzrlib
36
37
from bzrlib import (
37
38
    errors,
38
39
    ui,
54
55
 
55
56
        :param last_revision: If set, try to limit to the data this revision
56
57
            references.
57
 
        :param fetch_spec: A SearchResult specifying which revisions to fetch.
58
 
            If set, this overrides last_revision.
59
58
        :param find_ghosts: If True search the entire history for ghosts.
60
59
        """
61
60
        # repository.fetch has the responsibility for short-circuiting
94
93
        pb.show_pct = pb.show_count = False
95
94
        try:
96
95
            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():
 
96
            search = self._revids_to_fetch()
 
97
            mutter('fetching: %s', search)
 
98
            if search.is_empty():
100
99
                return
101
100
            pb.update("Fetching revisions", 1, 2)
102
 
            self._fetch_everything_for_search(search_result)
 
101
            self._fetch_everything_for_search(search)
103
102
        finally:
104
103
            pb.finished()
105
104
 
152
151
        install self._last_revision in self.to_repository.
153
152
 
154
153
        :returns: A SearchResult of some sort.  (Possibly a
155
 
            PendingAncestryResult, EmptySearchResult, etc.)
 
154
        PendingAncestryResult, EmptySearchResult, etc.)
156
155
        """
157
 
        if self._fetch_spec is not None:
 
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:
158
166
            # The fetch spec is already a concrete search result.
159
167
            return self._fetch_spec
160
168
        elif self._last_revision == NULL_REVISION:
164
172
        elif self._last_revision is not None:
165
173
            return graph.NotInOtherForRevs(self.to_repository,
166
174
                self.from_repository, [self._last_revision],
167
 
                find_ghosts=self.find_ghosts).execute()
 
175
                find_ghosts=self.find_ghosts).get_search_result()
168
176
        else: # self._last_revision is None:
169
177
            return graph.EverythingNotInOther(self.to_repository,
170
178
                self.from_repository,
171
 
                find_ghosts=self.find_ghosts).execute()
 
179
                find_ghosts=self.find_ghosts).get_search_result()
172
180
 
173
181
 
174
182
class Inter1and2Helper(object):
317
325
                pass
318
326
            else:
319
327
                try:
320
 
                    parent_ids.append(tree.get_file_revision(root_id))
 
328
                    parent_ids.append(tree.inventory[root_id].revision)
321
329
                except errors.NoSuchId:
322
330
                    # not in the tree
323
331
                    pass
331
339
            selected_ids.append(parent_id)
332
340
    parent_keys = [(root_id, parent_id) for parent_id in selected_ids]
333
341
    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
 
 
375
 
    def add_revision_ids(self, revision_ids):
376
 
        """Add revision_ids to the set of revision_ids to be fetched."""
377
 
        self._explicit_rev_ids.update(revision_ids)
378
 
        
379
 
    def make_fetch_spec(self):
380
 
        """Build a SearchResult or PendingAncestryResult or etc."""
381
 
        if self.target_repo_kind is None or self.source_repo is None:
382
 
            raise AssertionError(
383
 
                'Incomplete FetchSpecFactory: %r' % (self.__dict__,))
384
 
        if len(self._explicit_rev_ids) == 0 and self.source_branch is None:
385
 
            # Caller hasn't specified any revisions or source branch
386
 
            if self.target_repo_kind == TargetRepoKinds.EMPTY:
387
 
                return graph.EverythingResult(self.source_repo)
388
 
            else:
389
 
                # We want everything not already in the target (or target's
390
 
                # fallbacks).
391
 
                return graph.EverythingNotInOther(
392
 
                    self.target_repo, self.source_repo).execute()
393
 
        heads_to_fetch = set(self._explicit_rev_ids)
394
 
        if self.source_branch is not None:
395
 
            must_fetch, if_present_fetch = self.source_branch.heads_to_fetch()
396
 
            if self.source_branch_stop_revision_id is not None:
397
 
                # Replace the tip rev from must_fetch with the stop revision
398
 
                # XXX: this might be wrong if the tip rev is also in the
399
 
                # must_fetch set for other reasons (e.g. it's the tip of
400
 
                # multiple loom threads?), but then it's pretty unclear what it
401
 
                # should mean to specify a stop_revision in that case anyway.
402
 
                must_fetch.discard(self.source_branch.last_revision())
403
 
                must_fetch.add(self.source_branch_stop_revision_id)
404
 
            heads_to_fetch.update(must_fetch)
405
 
        else:
406
 
            if_present_fetch = set()
407
 
        if self.target_repo_kind == TargetRepoKinds.EMPTY:
408
 
            # PendingAncestryResult does not raise errors if a requested head
409
 
            # is absent.  Ideally it would support the
410
 
            # required_ids/if_present_ids distinction, but in practice
411
 
            # heads_to_fetch will almost certainly be present so this doesn't
412
 
            # matter much.
413
 
            all_heads = heads_to_fetch.union(if_present_fetch)
414
 
            return graph.PendingAncestryResult(all_heads, self.source_repo)
415
 
        return graph.NotInOtherForRevs(self.target_repo, self.source_repo,
416
 
            required_ids=heads_to_fetch, if_present_ids=if_present_fetch
417
 
            ).execute()
418
 
 
419