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

  • Committer: Jelmer Vernooij
  • Date: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/bzr/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):
49
56
    """
50
57
 
51
58
    def __init__(self, to_repository, from_repository, last_revision=None,
52
 
        find_ghosts=True, fetch_spec=None):
 
59
                 find_ghosts=True, fetch_spec=None):
53
60
        """Create a repo fetcher.
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
65
74
        self._last_revision = last_revision
66
75
        self._fetch_spec = fetch_spec
67
76
        self.find_ghosts = find_ghosts
68
 
        self.from_repository.lock_read()
69
 
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
70
 
               self.from_repository, self.from_repository._format,
71
 
               self.to_repository, self.to_repository._format)
72
 
        try:
 
77
        with self.from_repository.lock_read():
 
78
            mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
79
                   str(self.from_repository), str(self.from_repository._format),
 
80
                   str(self.to_repository), str(self.to_repository._format))
73
81
            self.__fetch()
74
 
        finally:
75
 
            self.from_repository.unlock()
76
82
 
77
83
    def __fetch(self):
78
84
        """Primary worker function.
88
94
        # assert not missing
89
95
        self.count_total = 0
90
96
        self.file_ids_names = {}
91
 
        pb = ui.ui_factory.nested_progress_bar()
92
 
        pb.show_pct = pb.show_count = False
93
 
        try:
94
 
            pb.update("Finding revisions", 0, 2)
95
 
            search = self._revids_to_fetch()
96
 
            if search is None:
 
97
        with ui.ui_factory.nested_progress_bar() as pb:
 
98
            pb.show_pct = pb.show_count = False
 
99
            pb.update(gettext("Finding revisions"), 0, 2)
 
100
            search_result = self._revids_to_fetch()
 
101
            mutter('fetching: %s', str(search_result))
 
102
            if search_result.is_empty():
97
103
                return
98
 
            pb.update("Fetching revisions", 1, 2)
99
 
            self._fetch_everything_for_search(search)
100
 
        finally:
101
 
            pb.finished()
 
104
            pb.update(gettext("Fetching revisions"), 1, 2)
 
105
            self._fetch_everything_for_search(search_result)
102
106
 
103
107
    def _fetch_everything_for_search(self, search):
104
108
        """Fetch all data for the given set of revisions."""
111
115
        # moment, so that it can feed the progress information back to this
112
116
        # function?
113
117
        if (self.from_repository._format.rich_root_data and
114
 
            not self.to_repository._format.rich_root_data):
 
118
                not self.to_repository._format.rich_root_data):
115
119
            raise errors.IncompatibleRepositories(
116
120
                self.from_repository, self.to_repository,
117
121
                "different rich-root support")
118
 
        pb = ui.ui_factory.nested_progress_bar()
119
 
        try:
 
122
        with ui.ui_factory.nested_progress_bar() as pb:
120
123
            pb.update("Get stream source")
121
124
            source = self.from_repository._get_source(
122
125
                self.to_repository._format)
125
128
            pb.update("Inserting stream")
126
129
            resume_tokens, missing_keys = self.sink.insert_stream(
127
130
                stream, from_format, [])
128
 
            if self.to_repository._fallback_repositories:
129
 
                missing_keys.update(
130
 
                    self._parent_inventories(search.get_keys()))
131
131
            if missing_keys:
132
132
                pb.update("Missing keys")
133
133
                stream = source.get_stream_for_missing_keys(missing_keys)
144
144
                        resume_tokens,))
145
145
            pb.update("Finishing stream")
146
146
            self.sink.finished()
147
 
        finally:
148
 
            pb.finished()
149
147
 
150
148
    def _revids_to_fetch(self):
151
149
        """Determines the exact revisions needed from self.from_repository to
152
150
        install self._last_revision in self.to_repository.
153
151
 
154
 
        If no revisions need to be fetched, then this just returns None.
 
152
        :returns: A SearchResult of some sort.  (Possibly a
 
153
            PendingAncestryResult, EmptySearchResult, etc.)
155
154
        """
156
155
        if self._fetch_spec is not None:
 
156
            # The fetch spec is already a concrete search result.
157
157
            return self._fetch_spec
158
 
        mutter('fetch up to rev {%s}', self._last_revision)
159
 
        if self._last_revision is NULL_REVISION:
 
158
        elif self._last_revision == NULL_REVISION:
 
159
            # fetch_spec is None + last_revision is null => empty fetch.
160
160
            # 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
 
161
            return vf_search.EmptySearchResult()
 
162
        elif self._last_revision is not None:
 
163
            return vf_search.NotInOtherForRevs(self.to_repository,
 
164
                                               self.from_repository, [
 
165
                                                   self._last_revision],
 
166
                                               find_ghosts=self.find_ghosts).execute()
 
167
        else:  # self._last_revision is None:
 
168
            return vf_search.EverythingNotInOther(self.to_repository,
 
169
                                                  self.from_repository,
 
170
                                                  find_ghosts=self.find_ghosts).execute()
177
171
 
178
172
 
179
173
class Inter1and2Helper(object):
182
176
    This is for use by fetchers and converters.
183
177
    """
184
178
 
 
179
    # This is a class variable so that the test suite can override it.
 
180
    known_graph_threshold = 100
 
181
 
185
182
    def __init__(self, source):
186
183
        """Constructor.
187
184
 
203
200
        revs = list(revs)
204
201
        while revs:
205
202
            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()
 
203
                if tree.root_inventory.revision_id is None:
 
204
                    tree.root_inventory.revision_id = tree.get_revision_id()
208
205
                yield tree
209
206
            revs = revs[100:]
210
207
 
211
208
    def _find_root_ids(self, revs, parent_map, graph):
212
209
        revision_root = {}
213
210
        for tree in self.iter_rev_trees(revs):
214
 
            revision_id = tree.inventory.root.revision
215
 
            root_id = tree.get_root_id()
 
211
            root_id = tree.path2id('')
 
212
            revision_id = tree.get_file_revision(u'')
216
213
            revision_root[revision_id] = root_id
217
214
        # 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])
 
215
        parents = set(viewvalues(parent_map))
 
216
        parents.difference_update(revision_root)
 
217
        parents.discard(NULL_REVISION)
222
218
        # Limit to revisions present in the versionedfile
223
 
        parents = graph.get_parent_map(parents).keys()
 
219
        parents = graph.get_parent_map(parents)
224
220
        for tree in self.iter_rev_trees(parents):
225
 
            root_id = tree.get_root_id()
 
221
            root_id = tree.path2id('')
226
222
            revision_root[tree.get_revision_id()] = root_id
227
223
        return revision_root
228
224
 
236
232
        rev_order = tsort.topo_sort(parent_map)
237
233
        rev_id_to_root_id = self._find_root_ids(revs, parent_map, graph)
238
234
        root_id_order = [(rev_id_to_root_id[rev_id], rev_id) for rev_id in
239
 
            rev_order]
 
235
                         rev_order]
240
236
        # Guaranteed stable, this groups all the file id operations together
241
237
        # retaining topological order within the revisions of a file id.
242
238
        # File id splits and joins would invalidate this, but they don't exist
243
239
        # yet, and are unlikely to in non-rich-root environments anyway.
244
240
        root_id_order.sort(key=operator.itemgetter(0))
245
241
        # 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)
 
242
        if len(revs) > self.known_graph_threshold:
 
243
            graph = self.source.get_known_graph_ancestry(revs)
250
244
        new_roots_stream = _new_root_data_stream(
251
245
            root_id_order, rev_id_to_root_id, parent_map, self.source, graph)
252
246
        return [('texts', new_roots_stream)]
253
247
 
254
248
 
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
249
def _new_root_data_stream(
261
 
    root_keys_to_create, rev_id_to_root_id_map, parent_map, repo, graph=None):
 
250
        root_keys_to_create, rev_id_to_root_id_map, parent_map, repo, graph=None):
262
251
    """Generate a texts substream of synthesised root entries.
263
252
 
264
253
    Used in fetches that do rich-root upgrades.
265
 
    
 
254
 
266
255
    :param root_keys_to_create: iterable of (root_id, rev_id) pairs describing
267
256
        the root entries to create.
268
257
    :param rev_id_to_root_id_map: dict of known rev_id -> root_id mappings for
276
265
        root_id, rev_id = root_key
277
266
        parent_keys = _parent_keys_for_root_version(
278
267
            root_id, rev_id, rev_id_to_root_id_map, parent_map, repo, graph)
279
 
        yield versionedfile.FulltextContentFactory(
280
 
            root_key, parent_keys, None, '')
 
268
        yield versionedfile.ChunkedContentFactory(
 
269
            root_key, parent_keys, None, [])
281
270
 
282
271
 
283
272
def _parent_keys_for_root_version(
284
 
    root_id, rev_id, rev_id_to_root_id_map, parent_map, repo, graph=None):
 
273
        root_id, rev_id, rev_id_to_root_id_map, parent_map, repo, graph=None):
285
274
    """Get the parent keys for a given root id.
286
 
    
 
275
 
287
276
    A helper function for _new_root_data_stream.
288
277
    """
289
278
    # Include direct parents of the revision, but only if they used the same
304
293
                # But set parent_root_id to None since we don't really know
305
294
                parent_root_id = None
306
295
            else:
307
 
                parent_root_id = tree.get_root_id()
 
296
                parent_root_id = tree.path2id('')
308
297
            rev_id_to_root_id_map[parent_id] = None
309
298
            # XXX: why not:
310
299
            #   rev_id_to_root_id_map[parent_id] = parent_root_id
326
315
                pass
327
316
            else:
328
317
                try:
329
 
                    parent_ids.append(tree.inventory[root_id].revision)
 
318
                    parent_ids.append(
 
319
                        tree.get_file_revision(
 
320
                            tree.id2path(root_id, recurse='none')))
330
321
                except errors.NoSuchId:
331
322
                    # not in the tree
332
323
                    pass
340
331
            selected_ids.append(parent_id)
341
332
    parent_keys = [(root_id, parent_id) for parent_id in selected_ids]
342
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 vf_search.EverythingResult(self.source_repo)
 
392
            else:
 
393
                # We want everything not already in the target (or target's
 
394
                # fallbacks).
 
395
                return vf_search.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 = vf_search.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(
 
424
                    result_set)
 
425
            return ret
 
426
        else:
 
427
            return vf_search.NotInOtherForRevs(self.target_repo, self.source_repo,
 
428
                                               required_ids=heads_to_fetch, if_present_ids=if_present_fetch,
 
429
                                               limit=self.limit).execute()