← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/fetch.py

  • Committer: Patch Queue Manager
  • Date: 2012-03-14 14:39:16 UTC
  • mfrom: (6027.1.18 deprecations)
  • Revision ID: pqm@pqm.ubuntu.com-20120314143916-dggf9d1d26j3kizq
(vila) Remove some code deprecated in series older than 2.4 (inclusive)
 (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/fetch.py
1
 
# Copyright (C) 2005, 2006, 2008, 2009, 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
 
 
18
17
"""Copying of history from one branch to another.
19
18
 
20
19
The basic plan is that every branch knows the history of everything
23
22
branch.
24
23
"""
25
24
 
 
25
from __future__ import absolute_import
 
26
 
26
27
import operator
27
28
 
28
29
from bzrlib.lazy_import import lazy_import
29
30
lazy_import(globals(), """
30
31
from bzrlib import (
31
 
    graph as _mod_graph,
32
 
    static_tuple,
33
32
    tsort,
34
33
    versionedfile,
 
34
    vf_search,
35
35
    )
36
36
""")
37
 
import bzrlib
38
37
from bzrlib import (
39
38
    errors,
40
 
    symbol_versioning,
41
39
    ui,
42
40
    )
 
41
from bzrlib.i18n import gettext
43
42
from bzrlib.revision import NULL_REVISION
44
43
from bzrlib.trace import mutter
45
44
 
52
51
    """
53
52
 
54
53
    def __init__(self, to_repository, from_repository, last_revision=None,
55
 
        pb=None, find_ghosts=True, fetch_spec=None):
 
54
        find_ghosts=True, fetch_spec=None):
56
55
        """Create a repo fetcher.
57
56
 
58
57
        :param last_revision: If set, try to limit to the data this revision
59
58
            references.
 
59
        :param fetch_spec: A SearchResult specifying which revisions to fetch.
 
60
            If set, this overrides last_revision.
60
61
        :param find_ghosts: If True search the entire history for ghosts.
61
 
        :param pb: ProgressBar object to use; deprecated and ignored.
62
 
            This method will just create one on top of the stack.
63
62
        """
64
 
        if pb is not None:
65
 
            symbol_versioning.warn(
66
 
                symbol_versioning.deprecated_in((1, 14, 0))
67
 
                % "pb parameter to RepoFetcher.__init__")
68
 
            # and for simplicity it is in fact ignored
69
63
        # repository.fetch has the responsibility for short-circuiting
70
64
        # attempts to copy between a repository and itself.
71
65
        self.to_repository = to_repository
101
95
        pb = ui.ui_factory.nested_progress_bar()
102
96
        pb.show_pct = pb.show_count = False
103
97
        try:
104
 
            pb.update("Finding revisions", 0, 2)
105
 
            search = self._revids_to_fetch()
106
 
            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():
107
102
                return
108
 
            pb.update("Fetching revisions", 1, 2)
109
 
            self._fetch_everything_for_search(search)
 
103
            pb.update(gettext("Fetching revisions"), 1, 2)
 
104
            self._fetch_everything_for_search(search_result)
110
105
        finally:
111
106
            pb.finished()
112
107
 
135
130
            pb.update("Inserting stream")
136
131
            resume_tokens, missing_keys = self.sink.insert_stream(
137
132
                stream, from_format, [])
138
 
            if self.to_repository._fallback_repositories:
139
 
                missing_keys.update(
140
 
                    self._parent_inventories(search.get_keys()))
141
133
            if missing_keys:
142
134
                pb.update("Missing keys")
143
135
                stream = source.get_stream_for_missing_keys(missing_keys)
161
153
        """Determines the exact revisions needed from self.from_repository to
162
154
        install self._last_revision in self.to_repository.
163
155
 
164
 
        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.)
165
158
        """
166
159
        if self._fetch_spec is not None:
 
160
            # The fetch spec is already a concrete search result.
167
161
            return self._fetch_spec
168
 
        mutter('fetch up to rev {%s}', self._last_revision)
169
 
        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.
170
164
            # explicit limit of no revisions needed
171
 
            return None
172
 
        return self.to_repository.search_missing_revision_ids(
173
 
            self.from_repository, self._last_revision,
174
 
            find_ghosts=self.find_ghosts)
175
 
 
176
 
    def _parent_inventories(self, revision_ids):
177
 
        # Find all the parent revisions referenced by the stream, but
178
 
        # not present in the stream, and make sure we send their
179
 
        # inventories.
180
 
        parent_maps = self.to_repository.get_parent_map(revision_ids)
181
 
        parents = set()
182
 
        map(parents.update, parent_maps.itervalues())
183
 
        parents.discard(NULL_REVISION)
184
 
        parents.difference_update(revision_ids)
185
 
        missing_keys = set(('inventories', rev_id) for rev_id in parents)
186
 
        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()
187
174
 
188
175
 
189
176
class Inter1and2Helper(object):
192
179
    This is for use by fetchers and converters.
193
180
    """
194
181
 
 
182
    # This is a class variable so that the test suite can override it.
 
183
    known_graph_threshold = 100
 
184
 
195
185
    def __init__(self, source):
196
186
        """Constructor.
197
187
 
213
203
        revs = list(revs)
214
204
        while revs:
215
205
            for tree in self.source.revision_trees(revs[:100]):
216
 
                if tree.inventory.revision_id is None:
217
 
                    tree.inventory.revision_id = tree.get_revision_id()
 
206
                if tree.root_inventory.revision_id is None:
 
207
                    tree.root_inventory.revision_id = tree.get_revision_id()
218
208
                yield tree
219
209
            revs = revs[100:]
220
210
 
221
211
    def _find_root_ids(self, revs, parent_map, graph):
222
212
        revision_root = {}
223
213
        for tree in self.iter_rev_trees(revs):
224
 
            revision_id = tree.inventory.root.revision
225
214
            root_id = tree.get_root_id()
 
215
            revision_id = tree.get_file_revision(root_id, u"")
226
216
            revision_root[revision_id] = root_id
227
217
        # Find out which parents we don't already know root ids for
228
218
        parents = set()
253
243
        # yet, and are unlikely to in non-rich-root environments anyway.
254
244
        root_id_order.sort(key=operator.itemgetter(0))
255
245
        # Create a record stream containing the roots to create.
256
 
        if len(revs) > 100:
257
 
            # XXX: not covered by tests, should have a flag to always run
258
 
            # this. -- mbp 20100129
259
 
            graph = _get_rich_root_heads_graph(self.source, revs)
 
246
        if len(revs) > self.known_graph_threshold:
 
247
            graph = self.source.get_known_graph_ancestry(revs)
260
248
        new_roots_stream = _new_root_data_stream(
261
249
            root_id_order, rev_id_to_root_id, parent_map, self.source, graph)
262
250
        return [('texts', new_roots_stream)]
263
251
 
264
252
 
265
 
def _get_rich_root_heads_graph(source_repo, revision_ids):
266
 
    """Get a Graph object suitable for asking heads() for new rich roots."""
267
 
    st = static_tuple.StaticTuple
268
 
    revision_keys = [st(r_id).intern() for r_id in revision_ids]
269
 
    known_graph = source_repo.revisions.get_known_graph_ancestry(
270
 
                    revision_keys)
271
 
    return _mod_graph.GraphThunkIdsToKeys(known_graph)
272
 
 
273
 
 
274
253
def _new_root_data_stream(
275
254
    root_keys_to_create, rev_id_to_root_id_map, parent_map, repo, graph=None):
276
255
    """Generate a texts substream of synthesised root entries.
340
319
                pass
341
320
            else:
342
321
                try:
343
 
                    parent_ids.append(tree.inventory[root_id].revision)
 
322
                    parent_ids.append(tree.get_file_revision(root_id))
344
323
                except errors.NoSuchId:
345
324
                    # not in the tree
346
325
                    pass
354
333
            selected_ids.append(parent_id)
355
334
    parent_keys = [(root_id, parent_id) for parent_id in selected_ids]
356
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()