← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/fetch.py

merge 2.0 branch rev 4647

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/fetch.py
25
25
 
26
26
import operator
27
27
 
 
28
from bzrlib.lazy_import import lazy_import
 
29
lazy_import(globals(), """
 
30
from bzrlib import (
 
31
    tsort,
 
32
    versionedfile,
 
33
    )
 
34
""")
28
35
import bzrlib
29
36
from bzrlib import (
30
37
    errors,
31
38
    symbol_versioning,
32
39
    )
33
40
from bzrlib.revision import NULL_REVISION
34
 
from bzrlib.tsort import topo_sort
35
41
from bzrlib.trace import mutter
36
42
import bzrlib.ui
37
 
from bzrlib.versionedfile import FulltextContentFactory
38
43
 
39
44
 
40
45
class RepoFetcher(object):
51
56
        :param last_revision: If set, try to limit to the data this revision
52
57
            references.
53
58
        :param find_ghosts: If True search the entire history for ghosts.
54
 
        :param _write_group_acquired_callable: Don't use; this parameter only
55
 
            exists to facilitate a hack done in InterPackRepo.fetch.  We would
56
 
            like to remove this parameter.
57
59
        :param pb: ProgressBar object to use; deprecated and ignored.
58
60
            This method will just create one on top of the stack.
59
61
        """
62
64
                symbol_versioning.deprecated_in((1, 14, 0))
63
65
                % "pb parameter to RepoFetcher.__init__")
64
66
            # and for simplicity it is in fact ignored
65
 
        if to_repository.has_same_location(from_repository):
66
 
            # repository.fetch should be taking care of this case.
67
 
            raise errors.BzrError('RepoFetcher run '
68
 
                    'between two objects at the same location: '
69
 
                    '%r and %r' % (to_repository, from_repository))
 
67
        # repository.fetch has the responsibility for short-circuiting
 
68
        # attempts to copy between a repository and itself.
70
69
        self.to_repository = to_repository
71
70
        self.from_repository = from_repository
72
71
        self.sink = to_repository._get_sink()
219
218
 
220
219
    def _find_root_ids(self, revs, parent_map, graph):
221
220
        revision_root = {}
222
 
        planned_versions = {}
223
221
        for tree in self.iter_rev_trees(revs):
224
222
            revision_id = tree.inventory.root.revision
225
223
            root_id = tree.get_root_id()
226
 
            planned_versions.setdefault(root_id, []).append(revision_id)
227
224
            revision_root[revision_id] = root_id
228
225
        # Find out which parents we don't already know root ids for
229
226
        parents = set()
235
232
        for tree in self.iter_rev_trees(parents):
236
233
            root_id = tree.get_root_id()
237
234
            revision_root[tree.get_revision_id()] = root_id
238
 
        return revision_root, planned_versions
 
235
        return revision_root
239
236
 
240
237
    def generate_root_texts(self, revs):
241
238
        """Generate VersionedFiles for all root ids.
244
241
        """
245
242
        graph = self.source.get_graph()
246
243
        parent_map = graph.get_parent_map(revs)
247
 
        rev_order = topo_sort(parent_map)
248
 
        rev_id_to_root_id, root_id_to_rev_ids = self._find_root_ids(
249
 
            revs, parent_map, graph)
 
244
        rev_order = tsort.topo_sort(parent_map)
 
245
        rev_id_to_root_id = self._find_root_ids(revs, parent_map, graph)
250
246
        root_id_order = [(rev_id_to_root_id[rev_id], rev_id) for rev_id in
251
247
            rev_order]
252
248
        # Guaranteed stable, this groups all the file id operations together
255
251
        # yet, and are unlikely to in non-rich-root environments anyway.
256
252
        root_id_order.sort(key=operator.itemgetter(0))
257
253
        # Create a record stream containing the roots to create.
258
 
        def yield_roots():
259
 
            for key in root_id_order:
260
 
                root_id, rev_id = key
261
 
                rev_parents = parent_map[rev_id]
262
 
                # We drop revision parents with different file-ids, because
263
 
                # that represents a rename of the root to a different location
264
 
                # - its not actually a parent for us. (We could look for that
265
 
                # file id in the revision tree at considerably more expense,
266
 
                # but for now this is sufficient (and reconcile will catch and
267
 
                # correct this anyway).
268
 
                # When a parent revision is a ghost, we guess that its root id
269
 
                # was unchanged (rather than trimming it from the parent list).
270
 
                parent_keys = tuple((root_id, parent) for parent in rev_parents
271
 
                    if parent != NULL_REVISION and
272
 
                        rev_id_to_root_id.get(parent, root_id) == root_id)
273
 
                yield FulltextContentFactory(key, parent_keys, None, '')
274
 
        return [('texts', yield_roots())]
 
254
        from bzrlib.graph import FrozenHeadsCache
 
255
        graph = FrozenHeadsCache(graph)
 
256
        new_roots_stream = _new_root_data_stream(
 
257
            root_id_order, rev_id_to_root_id, parent_map, self.source, graph)
 
258
        return [('texts', new_roots_stream)]
 
259
 
 
260
 
 
261
def _new_root_data_stream(
 
262
    root_keys_to_create, rev_id_to_root_id_map, parent_map, repo, graph=None):
 
263
    """Generate a texts substream of synthesised root entries.
 
264
 
 
265
    Used in fetches that do rich-root upgrades.
 
266
    
 
267
    :param root_keys_to_create: iterable of (root_id, rev_id) pairs describing
 
268
        the root entries to create.
 
269
    :param rev_id_to_root_id_map: dict of known rev_id -> root_id mappings for
 
270
        calculating the parents.  If a parent rev_id is not found here then it
 
271
        will be recalculated.
 
272
    :param parent_map: a parent map for all the revisions in
 
273
        root_keys_to_create.
 
274
    :param graph: a graph to use instead of repo.get_graph().
 
275
    """
 
276
    for root_key in root_keys_to_create:
 
277
        root_id, rev_id = root_key
 
278
        parent_keys = _parent_keys_for_root_version(
 
279
            root_id, rev_id, rev_id_to_root_id_map, parent_map, repo, graph)
 
280
        yield versionedfile.FulltextContentFactory(
 
281
            root_key, parent_keys, None, '')
 
282
 
 
283
 
 
284
def _parent_keys_for_root_version(
 
285
    root_id, rev_id, rev_id_to_root_id_map, parent_map, repo, graph=None):
 
286
    """Get the parent keys for a given root id.
 
287
    
 
288
    A helper function for _new_root_data_stream.
 
289
    """
 
290
    # Include direct parents of the revision, but only if they used the same
 
291
    # root_id and are heads.
 
292
    rev_parents = parent_map[rev_id]
 
293
    parent_ids = []
 
294
    for parent_id in rev_parents:
 
295
        if parent_id == NULL_REVISION:
 
296
            continue
 
297
        if parent_id not in rev_id_to_root_id_map:
 
298
            # We probably didn't read this revision, go spend the extra effort
 
299
            # to actually check
 
300
            try:
 
301
                tree = repo.revision_tree(parent_id)
 
302
            except errors.NoSuchRevision:
 
303
                # Ghost, fill out rev_id_to_root_id in case we encounter this
 
304
                # again.
 
305
                # But set parent_root_id to None since we don't really know
 
306
                parent_root_id = None
 
307
            else:
 
308
                parent_root_id = tree.get_root_id()
 
309
            rev_id_to_root_id_map[parent_id] = None
 
310
            # XXX: why not:
 
311
            #   rev_id_to_root_id_map[parent_id] = parent_root_id
 
312
            # memory consumption maybe?
 
313
        else:
 
314
            parent_root_id = rev_id_to_root_id_map[parent_id]
 
315
        if root_id == parent_root_id:
 
316
            # With stacking we _might_ want to refer to a non-local revision,
 
317
            # but this code path only applies when we have the full content
 
318
            # available, so ghosts really are ghosts, not just the edge of
 
319
            # local data.
 
320
            parent_ids.append(parent_id)
 
321
        else:
 
322
            # root_id may be in the parent anyway.
 
323
            try:
 
324
                tree = repo.revision_tree(parent_id)
 
325
            except errors.NoSuchRevision:
 
326
                # ghost, can't refer to it.
 
327
                pass
 
328
            else:
 
329
                try:
 
330
                    parent_ids.append(tree.inventory[root_id].revision)
 
331
                except errors.NoSuchId:
 
332
                    # not in the tree
 
333
                    pass
 
334
    # Drop non-head parents
 
335
    if graph is None:
 
336
        graph = repo.get_graph()
 
337
    heads = graph.heads(parent_ids)
 
338
    selected_ids = []
 
339
    for parent_id in parent_ids:
 
340
        if parent_id in heads and parent_id not in selected_ids:
 
341
            selected_ids.append(parent_id)
 
342
    parent_keys = [(root_id, parent_id) for parent_id in selected_ids]
 
343
    return parent_keys