/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 breezy/fetch.py

  • Committer: Jelmer Vernooij
  • Date: 2017-06-10 02:09:46 UTC
  • mto: This revision was merged to the branch mainline in revision 6690.
  • Revision ID: jelmer@jelmer.uk-20170610020946-nxnwagf535b3lctb
Move breezy.repofmt contents to  breezy.bzr.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/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
 
 
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
 
from bzrlib.lazy_import import lazy_import
 
29
from .lazy_import import lazy_import
29
30
lazy_import(globals(), """
30
 
from bzrlib import (
 
31
from breezy import (
31
32
    tsort,
 
33
    )
 
34
from breezy.bzr import (
32
35
    versionedfile,
 
36
    vf_search,
33
37
    )
34
38
""")
35
 
import bzrlib
36
 
from bzrlib import (
 
39
from . import (
37
40
    errors,
38
41
    ui,
39
42
    )
40
 
from bzrlib.revision import NULL_REVISION
41
 
from bzrlib.trace import mutter
 
43
from .i18n import gettext
 
44
from .revision import NULL_REVISION
 
45
from .sixish import (
 
46
    viewvalues,
 
47
    )
 
48
from .trace import mutter
42
49
 
43
50
 
44
51
class RepoFetcher(object):
54
61
 
55
62
        :param last_revision: If set, try to limit to the data this revision
56
63
            references.
 
64
        :param fetch_spec: A SearchResult specifying which revisions to fetch.
 
65
            If set, this overrides last_revision.
57
66
        :param find_ghosts: If True search the entire history for ghosts.
58
67
        """
59
68
        # repository.fetch has the responsibility for short-circuiting
91
100
        pb = ui.ui_factory.nested_progress_bar()
92
101
        pb.show_pct = pb.show_count = False
93
102
        try:
94
 
            pb.update("Finding revisions", 0, 2)
95
 
            search = self._revids_to_fetch()
96
 
            if search is None:
 
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():
97
107
                return
98
 
            pb.update("Fetching revisions", 1, 2)
99
 
            self._fetch_everything_for_search(search)
 
108
            pb.update(gettext("Fetching revisions"), 1, 2)
 
109
            self._fetch_everything_for_search(search_result)
100
110
        finally:
101
111
            pb.finished()
102
112
 
125
135
            pb.update("Inserting stream")
126
136
            resume_tokens, missing_keys = self.sink.insert_stream(
127
137
                stream, from_format, [])
128
 
            if self.to_repository._fallback_repositories:
129
 
                missing_keys.update(
130
 
                    self._parent_inventories(search.get_keys()))
131
138
            if missing_keys:
132
139
                pb.update("Missing keys")
133
140
                stream = source.get_stream_for_missing_keys(missing_keys)
151
158
        """Determines the exact revisions needed from self.from_repository to
152
159
        install self._last_revision in self.to_repository.
153
160
 
154
 
        If no revisions need to be fetched, then this just returns None.
 
161
        :returns: A SearchResult of some sort.  (Possibly a
 
162
            PendingAncestryResult, EmptySearchResult, etc.)
155
163
        """
156
164
        if self._fetch_spec is not None:
 
165
            # The fetch spec is already a concrete search result.
157
166
            return self._fetch_spec
158
 
        mutter('fetch up to rev {%s}', self._last_revision)
159
 
        if self._last_revision is NULL_REVISION:
 
167
        elif self._last_revision == NULL_REVISION:
 
168
            # fetch_spec is None + last_revision is null => empty fetch.
160
169
            # 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
 
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()
177
179
 
178
180
 
179
181
class Inter1and2Helper(object):
182
184
    This is for use by fetchers and converters.
183
185
    """
184
186
 
 
187
    # This is a class variable so that the test suite can override it.
 
188
    known_graph_threshold = 100
 
189
 
185
190
    def __init__(self, source):
186
191
        """Constructor.
187
192
 
203
208
        revs = list(revs)
204
209
        while revs:
205
210
            for tree in self.source.revision_trees(revs[:100]):
206
 
                if tree.inventory.revision_id is None:
207
 
                    tree.inventory.revision_id = tree.get_revision_id()
 
211
                if tree.root_inventory.revision_id is None:
 
212
                    tree.root_inventory.revision_id = tree.get_revision_id()
208
213
                yield tree
209
214
            revs = revs[100:]
210
215
 
211
216
    def _find_root_ids(self, revs, parent_map, graph):
212
217
        revision_root = {}
213
218
        for tree in self.iter_rev_trees(revs):
214
 
            revision_id = tree.inventory.root.revision
215
219
            root_id = tree.get_root_id()
 
220
            revision_id = tree.get_file_revision(root_id, u"")
216
221
            revision_root[revision_id] = root_id
217
222
        # Find out which parents we don't already know root ids for
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])
 
223
        parents = set(viewvalues(parent_map))
 
224
        parents.difference_update(revision_root)
 
225
        parents.discard(NULL_REVISION)
222
226
        # Limit to revisions present in the versionedfile
223
 
        parents = graph.get_parent_map(parents).keys()
 
227
        parents = graph.get_parent_map(parents)
224
228
        for tree in self.iter_rev_trees(parents):
225
229
            root_id = tree.get_root_id()
226
230
            revision_root[tree.get_revision_id()] = root_id
243
247
        # yet, and are unlikely to in non-rich-root environments anyway.
244
248
        root_id_order.sort(key=operator.itemgetter(0))
245
249
        # 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)
 
250
        if len(revs) > self.known_graph_threshold:
 
251
            graph = self.source.get_known_graph_ancestry(revs)
250
252
        new_roots_stream = _new_root_data_stream(
251
253
            root_id_order, rev_id_to_root_id, parent_map, self.source, graph)
252
254
        return [('texts', new_roots_stream)]
253
255
 
254
256
 
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
257
def _new_root_data_stream(
261
258
    root_keys_to_create, rev_id_to_root_id_map, parent_map, repo, graph=None):
262
259
    """Generate a texts substream of synthesised root entries.
326
323
                pass
327
324
            else:
328
325
                try:
329
 
                    parent_ids.append(tree.inventory[root_id].revision)
 
326
                    parent_ids.append(tree.get_file_revision(root_id))
330
327
                except errors.NoSuchId:
331
328
                    # not in the tree
332
329
                    pass
340
337
            selected_ids.append(parent_id)
341
338
    parent_keys = [(root_id, parent_id) for parent_id in selected_ids]
342
339
    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()