/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: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

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
 
from .lazy_import import lazy_import
 
28
from bzrlib.lazy_import import lazy_import
30
29
lazy_import(globals(), """
31
 
from breezy import (
 
30
from bzrlib import (
32
31
    tsort,
33
 
    )
34
 
from breezy.bzr import (
35
32
    versionedfile,
36
 
    vf_search,
37
33
    )
38
34
""")
39
 
from . import (
 
35
import bzrlib
 
36
from bzrlib import (
40
37
    errors,
41
38
    ui,
42
39
    )
43
 
from .i18n import gettext
44
 
from .revision import NULL_REVISION
45
 
from .sixish import (
46
 
    viewvalues,
47
 
    )
48
 
from .trace import mutter
 
40
from bzrlib.revision import NULL_REVISION
 
41
from bzrlib.trace import mutter
49
42
 
50
43
 
51
44
class RepoFetcher(object):
61
54
 
62
55
        :param last_revision: If set, try to limit to the data this revision
63
56
            references.
64
 
        :param fetch_spec: A SearchResult specifying which revisions to fetch.
65
 
            If set, this overrides last_revision.
66
57
        :param find_ghosts: If True search the entire history for ghosts.
67
58
        """
68
59
        # repository.fetch has the responsibility for short-circuiting
100
91
        pb = ui.ui_factory.nested_progress_bar()
101
92
        pb.show_pct = pb.show_count = False
102
93
        try:
103
 
            pb.update(gettext("Finding revisions"), 0, 2)
104
 
            search_result = self._revids_to_fetch()
105
 
            mutter('fetching: %s', search_result)
106
 
            if search_result.is_empty():
 
94
            pb.update("Finding revisions", 0, 2)
 
95
            search = self._revids_to_fetch()
 
96
            if search is None:
107
97
                return
108
 
            pb.update(gettext("Fetching revisions"), 1, 2)
109
 
            self._fetch_everything_for_search(search_result)
 
98
            pb.update("Fetching revisions", 1, 2)
 
99
            self._fetch_everything_for_search(search)
110
100
        finally:
111
101
            pb.finished()
112
102
 
135
125
            pb.update("Inserting stream")
136
126
            resume_tokens, missing_keys = self.sink.insert_stream(
137
127
                stream, from_format, [])
 
128
            if self.to_repository._fallback_repositories:
 
129
                missing_keys.update(
 
130
                    self._parent_inventories(search.get_keys()))
138
131
            if missing_keys:
139
132
                pb.update("Missing keys")
140
133
                stream = source.get_stream_for_missing_keys(missing_keys)
158
151
        """Determines the exact revisions needed from self.from_repository to
159
152
        install self._last_revision in self.to_repository.
160
153
 
161
 
        :returns: A SearchResult of some sort.  (Possibly a
162
 
            PendingAncestryResult, EmptySearchResult, etc.)
 
154
        If no revisions need to be fetched, then this just returns None.
163
155
        """
164
156
        if self._fetch_spec is not None:
165
 
            # The fetch spec is already a concrete search result.
166
157
            return self._fetch_spec
167
 
        elif self._last_revision == NULL_REVISION:
168
 
            # 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:
169
160
            # explicit limit of no revisions needed
170
 
            return vf_search.EmptySearchResult()
171
 
        elif self._last_revision is not None:
172
 
            return vf_search.NotInOtherForRevs(self.to_repository,
173
 
                self.from_repository, [self._last_revision],
174
 
                find_ghosts=self.find_ghosts).execute()
175
 
        else: # self._last_revision is None:
176
 
            return vf_search.EverythingNotInOther(self.to_repository,
177
 
                self.from_repository,
178
 
                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
179
177
 
180
178
 
181
179
class Inter1and2Helper(object):
184
182
    This is for use by fetchers and converters.
185
183
    """
186
184
 
187
 
    # This is a class variable so that the test suite can override it.
188
 
    known_graph_threshold = 100
189
 
 
190
185
    def __init__(self, source):
191
186
        """Constructor.
192
187
 
208
203
        revs = list(revs)
209
204
        while revs:
210
205
            for tree in self.source.revision_trees(revs[:100]):
211
 
                if tree.root_inventory.revision_id is None:
212
 
                    tree.root_inventory.revision_id = tree.get_revision_id()
 
206
                if tree.inventory.revision_id is None:
 
207
                    tree.inventory.revision_id = tree.get_revision_id()
213
208
                yield tree
214
209
            revs = revs[100:]
215
210
 
216
211
    def _find_root_ids(self, revs, parent_map, graph):
217
212
        revision_root = {}
218
213
        for tree in self.iter_rev_trees(revs):
 
214
            revision_id = tree.inventory.root.revision
219
215
            root_id = tree.get_root_id()
220
 
            revision_id = tree.get_file_revision(root_id, u"")
221
216
            revision_root[revision_id] = root_id
222
217
        # Find out which parents we don't already know root ids for
223
 
        parents = set(viewvalues(parent_map))
224
 
        parents.difference_update(revision_root)
225
 
        parents.discard(NULL_REVISION)
 
218
        parents = set()
 
219
        for revision_parents in parent_map.itervalues():
 
220
            parents.update(revision_parents)
 
221
        parents.difference_update(revision_root.keys() + [NULL_REVISION])
226
222
        # Limit to revisions present in the versionedfile
227
 
        parents = graph.get_parent_map(parents)
 
223
        parents = graph.get_parent_map(parents).keys()
228
224
        for tree in self.iter_rev_trees(parents):
229
225
            root_id = tree.get_root_id()
230
226
            revision_root[tree.get_revision_id()] = root_id
247
243
        # yet, and are unlikely to in non-rich-root environments anyway.
248
244
        root_id_order.sort(key=operator.itemgetter(0))
249
245
        # Create a record stream containing the roots to create.
250
 
        if len(revs) > self.known_graph_threshold:
251
 
            graph = self.source.get_known_graph_ancestry(revs)
 
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)
252
250
        new_roots_stream = _new_root_data_stream(
253
251
            root_id_order, rev_id_to_root_id, parent_map, self.source, graph)
254
252
        return [('texts', new_roots_stream)]
255
253
 
256
254
 
 
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
 
257
260
def _new_root_data_stream(
258
261
    root_keys_to_create, rev_id_to_root_id_map, parent_map, repo, graph=None):
259
262
    """Generate a texts substream of synthesised root entries.
323
326
                pass
324
327
            else:
325
328
                try:
326
 
                    parent_ids.append(tree.get_file_revision(root_id))
 
329
                    parent_ids.append(tree.inventory[root_id].revision)
327
330
                except errors.NoSuchId:
328
331
                    # not in the tree
329
332
                    pass
337
340
            selected_ids.append(parent_id)
338
341
    parent_keys = [(root_id, parent_id) for parent_id in selected_ids]
339
342
    return parent_keys
340
 
 
341
 
 
342
 
class TargetRepoKinds(object):
343
 
    """An enum-like set of constants.
344
 
    
345
 
    They are the possible values of FetchSpecFactory.target_repo_kinds.
346
 
    """
347
 
    
348
 
    PREEXISTING = 'preexisting'
349
 
    STACKED = 'stacked'
350
 
    EMPTY = 'empty'
351
 
 
352
 
 
353
 
class FetchSpecFactory(object):
354
 
    """A helper for building the best fetch spec for a sprout call.
355
 
 
356
 
    Factors that go into determining the sort of fetch to perform:
357
 
     * did the caller specify any revision IDs?
358
 
     * did the caller specify a source branch (need to fetch its
359
 
       heads_to_fetch(), usually the tip + tags)
360
 
     * is there an existing target repo (don't need to refetch revs it
361
 
       already has)
362
 
     * target is stacked?  (similar to pre-existing target repo: even if
363
 
       the target itself is new don't want to refetch existing revs)
364
 
 
365
 
    :ivar source_branch: the source branch if one specified, else None.
366
 
    :ivar source_branch_stop_revision_id: fetch up to this revision of
367
 
        source_branch, rather than its tip.
368
 
    :ivar source_repo: the source repository if one found, else None.
369
 
    :ivar target_repo: the target repository acquired by sprout.
370
 
    :ivar target_repo_kind: one of the TargetRepoKinds constants.
371
 
    """
372
 
 
373
 
    def __init__(self):
374
 
        self._explicit_rev_ids = set()
375
 
        self.source_branch = None
376
 
        self.source_branch_stop_revision_id = None
377
 
        self.source_repo = None
378
 
        self.target_repo = None
379
 
        self.target_repo_kind = None
380
 
        self.limit = None
381
 
 
382
 
    def add_revision_ids(self, revision_ids):
383
 
        """Add revision_ids to the set of revision_ids to be fetched."""
384
 
        self._explicit_rev_ids.update(revision_ids)
385
 
 
386
 
    def make_fetch_spec(self):
387
 
        """Build a SearchResult or PendingAncestryResult or etc."""
388
 
        if self.target_repo_kind is None or self.source_repo is None:
389
 
            raise AssertionError(
390
 
                'Incomplete FetchSpecFactory: %r' % (self.__dict__,))
391
 
        if len(self._explicit_rev_ids) == 0 and self.source_branch is None:
392
 
            if self.limit is not None:
393
 
                raise NotImplementedError(
394
 
                    "limit is only supported with a source branch set")
395
 
            # Caller hasn't specified any revisions or source branch
396
 
            if self.target_repo_kind == TargetRepoKinds.EMPTY:
397
 
                return vf_search.EverythingResult(self.source_repo)
398
 
            else:
399
 
                # We want everything not already in the target (or target's
400
 
                # fallbacks).
401
 
                return vf_search.EverythingNotInOther(
402
 
                    self.target_repo, self.source_repo).execute()
403
 
        heads_to_fetch = set(self._explicit_rev_ids)
404
 
        if self.source_branch is not None:
405
 
            must_fetch, if_present_fetch = self.source_branch.heads_to_fetch()
406
 
            if self.source_branch_stop_revision_id is not None:
407
 
                # Replace the tip rev from must_fetch with the stop revision
408
 
                # XXX: this might be wrong if the tip rev is also in the
409
 
                # must_fetch set for other reasons (e.g. it's the tip of
410
 
                # multiple loom threads?), but then it's pretty unclear what it
411
 
                # should mean to specify a stop_revision in that case anyway.
412
 
                must_fetch.discard(self.source_branch.last_revision())
413
 
                must_fetch.add(self.source_branch_stop_revision_id)
414
 
            heads_to_fetch.update(must_fetch)
415
 
        else:
416
 
            if_present_fetch = set()
417
 
        if self.target_repo_kind == TargetRepoKinds.EMPTY:
418
 
            # PendingAncestryResult does not raise errors if a requested head
419
 
            # is absent.  Ideally it would support the
420
 
            # required_ids/if_present_ids distinction, but in practice
421
 
            # heads_to_fetch will almost certainly be present so this doesn't
422
 
            # matter much.
423
 
            all_heads = heads_to_fetch.union(if_present_fetch)
424
 
            ret = vf_search.PendingAncestryResult(all_heads, self.source_repo)
425
 
            if self.limit is not None:
426
 
                graph = self.source_repo.get_graph()
427
 
                topo_order = list(graph.iter_topo_order(ret.get_keys()))
428
 
                result_set = topo_order[:self.limit]
429
 
                ret = self.source_repo.revision_ids_to_search_result(result_set)
430
 
            return ret
431
 
        else:
432
 
            return vf_search.NotInOtherForRevs(self.target_repo, self.source_repo,
433
 
                required_ids=heads_to_fetch, if_present_ids=if_present_fetch,
434
 
                limit=self.limit).execute()