← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/fetch.py

  • Committer: Robert Collins
  • Date: 2010-05-06 23:41:35 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506234135-yivbzczw1sejxnxc
Lock methods on ``Tree``, ``Branch`` and ``Repository`` are now
expected to return an object which can be used to unlock them. This reduces
duplicate code when using cleanups. The previous 'tokens's returned by
``Branch.lock_write`` and ``Repository.lock_write`` are now attributes
on the result of the lock_write. ``repository.RepositoryWriteLockResult``
and ``branch.BranchWriteLockResult`` document this. (Robert Collins)

``log._get_info_for_log_files`` now takes an add_cleanup callable.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/fetch.py
1
 
# Copyright (C) 2005, 2006, 2008, 2009 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
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
 
    symbol_versioning,
 
38
    ui,
32
39
    )
33
 
from bzrlib.errors import InstallFailed
34
 
from bzrlib.progress import ProgressPhase
35
40
from bzrlib.revision import NULL_REVISION
36
 
from bzrlib.tsort import topo_sort
37
41
from bzrlib.trace import mutter
38
 
import bzrlib.ui
39
 
from bzrlib.versionedfile import FulltextContentFactory
40
42
 
41
43
 
42
44
class RepoFetcher(object):
47
49
    """
48
50
 
49
51
    def __init__(self, to_repository, from_repository, last_revision=None,
50
 
        pb=None, find_ghosts=True, fetch_spec=None):
 
52
        find_ghosts=True, fetch_spec=None):
51
53
        """Create a repo fetcher.
52
54
 
53
55
        :param last_revision: If set, try to limit to the data this revision
54
56
            references.
55
57
        :param find_ghosts: If True search the entire history for ghosts.
56
 
        :param _write_group_acquired_callable: Don't use; this parameter only
57
 
            exists to facilitate a hack done in InterPackRepo.fetch.  We would
58
 
            like to remove this parameter.
59
 
        :param pb: ProgressBar object to use; deprecated and ignored.
60
 
            This method will just create one on top of the stack.
61
58
        """
62
 
        if pb is not None:
63
 
            symbol_versioning.warn(
64
 
                symbol_versioning.deprecated_in((1, 14, 0))
65
 
                % "pb parameter to RepoFetcher.__init__")
66
 
            # and for simplicity it is in fact ignored
67
 
        if to_repository.has_same_location(from_repository):
68
 
            # repository.fetch should be taking care of this case.
69
 
            raise errors.BzrError('RepoFetcher run '
70
 
                    'between two objects at the same location: '
71
 
                    '%r and %r' % (to_repository, from_repository))
 
59
        # repository.fetch has the responsibility for short-circuiting
 
60
        # attempts to copy between a repository and itself.
72
61
        self.to_repository = to_repository
73
62
        self.from_repository = from_repository
74
63
        self.sink = to_repository._get_sink()
99
88
        # assert not missing
100
89
        self.count_total = 0
101
90
        self.file_ids_names = {}
102
 
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
91
        pb = ui.ui_factory.nested_progress_bar()
103
92
        pb.show_pct = pb.show_count = False
104
93
        try:
105
94
            pb.update("Finding revisions", 0, 2)
126
115
            raise errors.IncompatibleRepositories(
127
116
                self.from_repository, self.to_repository,
128
117
                "different rich-root support")
129
 
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
118
        pb = ui.ui_factory.nested_progress_bar()
130
119
        try:
131
120
            pb.update("Get stream source")
132
121
            source = self.from_repository._get_source(
136
125
            pb.update("Inserting stream")
137
126
            resume_tokens, missing_keys = self.sink.insert_stream(
138
127
                stream, from_format, [])
 
128
            if self.to_repository._fallback_repositories:
 
129
                missing_keys.update(
 
130
                    self._parent_inventories(search.get_keys()))
139
131
            if missing_keys:
140
132
                pb.update("Missing keys")
141
133
                stream = source.get_stream_for_missing_keys(missing_keys)
167
159
        if self._last_revision is NULL_REVISION:
168
160
            # explicit limit of no revisions needed
169
161
            return None
170
 
        if (self._last_revision is not None and
171
 
            self.to_repository.has_revision(self._last_revision)):
172
 
            return None
173
 
        try:
174
 
            return self.to_repository.search_missing_revision_ids(
175
 
                self.from_repository, self._last_revision,
176
 
                find_ghosts=self.find_ghosts)
177
 
        except errors.NoSuchRevision, e:
178
 
            raise InstallFailed([self._last_revision])
 
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):
212
210
 
213
211
    def _find_root_ids(self, revs, parent_map, graph):
214
212
        revision_root = {}
215
 
        planned_versions = {}
216
213
        for tree in self.iter_rev_trees(revs):
217
214
            revision_id = tree.inventory.root.revision
218
215
            root_id = tree.get_root_id()
219
 
            planned_versions.setdefault(root_id, []).append(revision_id)
220
216
            revision_root[revision_id] = root_id
221
217
        # Find out which parents we don't already know root ids for
222
218
        parents = set()
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
231
 
        return revision_root, planned_versions
 
227
        return revision_root
232
228
 
233
229
    def generate_root_texts(self, revs):
234
230
        """Generate VersionedFiles for all root ids.
237
233
        """
238
234
        graph = self.source.get_graph()
239
235
        parent_map = graph.get_parent_map(revs)
240
 
        rev_order = topo_sort(parent_map)
241
 
        rev_id_to_root_id, root_id_to_rev_ids = self._find_root_ids(
242
 
            revs, parent_map, graph)
 
236
        rev_order = tsort.topo_sort(parent_map)
 
237
        rev_id_to_root_id = self._find_root_ids(revs, parent_map, graph)
243
238
        root_id_order = [(rev_id_to_root_id[rev_id], rev_id) for rev_id in
244
239
            rev_order]
245
240
        # Guaranteed stable, this groups all the file id operations together
248
243
        # yet, and are unlikely to in non-rich-root environments anyway.
249
244
        root_id_order.sort(key=operator.itemgetter(0))
250
245
        # Create a record stream containing the roots to create.
251
 
        def yield_roots():
252
 
            for key in root_id_order:
253
 
                root_id, rev_id = key
254
 
                rev_parents = parent_map[rev_id]
255
 
                # We drop revision parents with different file-ids, because
256
 
                # that represents a rename of the root to a different location
257
 
                # - its not actually a parent for us. (We could look for that
258
 
                # file id in the revision tree at considerably more expense,
259
 
                # but for now this is sufficient (and reconcile will catch and
260
 
                # correct this anyway).
261
 
                # When a parent revision is a ghost, we guess that its root id
262
 
                # was unchanged (rather than trimming it from the parent list).
263
 
                parent_keys = tuple((root_id, parent) for parent in rev_parents
264
 
                    if parent != NULL_REVISION and
265
 
                        rev_id_to_root_id.get(parent, root_id) == root_id)
266
 
                yield FulltextContentFactory(key, parent_keys, None, '')
267
 
        return [('texts', yield_roots())]
 
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
        new_roots_stream = _new_root_data_stream(
 
251
            root_id_order, rev_id_to_root_id, parent_map, self.source, graph)
 
252
        return [('texts', new_roots_stream)]
 
253
 
 
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
 
 
260
def _new_root_data_stream(
 
261
    root_keys_to_create, rev_id_to_root_id_map, parent_map, repo, graph=None):
 
262
    """Generate a texts substream of synthesised root entries.
 
263
 
 
264
    Used in fetches that do rich-root upgrades.
 
265
    
 
266
    :param root_keys_to_create: iterable of (root_id, rev_id) pairs describing
 
267
        the root entries to create.
 
268
    :param rev_id_to_root_id_map: dict of known rev_id -> root_id mappings for
 
269
        calculating the parents.  If a parent rev_id is not found here then it
 
270
        will be recalculated.
 
271
    :param parent_map: a parent map for all the revisions in
 
272
        root_keys_to_create.
 
273
    :param graph: a graph to use instead of repo.get_graph().
 
274
    """
 
275
    for root_key in root_keys_to_create:
 
276
        root_id, rev_id = root_key
 
277
        parent_keys = _parent_keys_for_root_version(
 
278
            root_id, rev_id, rev_id_to_root_id_map, parent_map, repo, graph)
 
279
        yield versionedfile.FulltextContentFactory(
 
280
            root_key, parent_keys, None, '')
 
281
 
 
282
 
 
283
def _parent_keys_for_root_version(
 
284
    root_id, rev_id, rev_id_to_root_id_map, parent_map, repo, graph=None):
 
285
    """Get the parent keys for a given root id.
 
286
    
 
287
    A helper function for _new_root_data_stream.
 
288
    """
 
289
    # Include direct parents of the revision, but only if they used the same
 
290
    # root_id and are heads.
 
291
    rev_parents = parent_map[rev_id]
 
292
    parent_ids = []
 
293
    for parent_id in rev_parents:
 
294
        if parent_id == NULL_REVISION:
 
295
            continue
 
296
        if parent_id not in rev_id_to_root_id_map:
 
297
            # We probably didn't read this revision, go spend the extra effort
 
298
            # to actually check
 
299
            try:
 
300
                tree = repo.revision_tree(parent_id)
 
301
            except errors.NoSuchRevision:
 
302
                # Ghost, fill out rev_id_to_root_id in case we encounter this
 
303
                # again.
 
304
                # But set parent_root_id to None since we don't really know
 
305
                parent_root_id = None
 
306
            else:
 
307
                parent_root_id = tree.get_root_id()
 
308
            rev_id_to_root_id_map[parent_id] = None
 
309
            # XXX: why not:
 
310
            #   rev_id_to_root_id_map[parent_id] = parent_root_id
 
311
            # memory consumption maybe?
 
312
        else:
 
313
            parent_root_id = rev_id_to_root_id_map[parent_id]
 
314
        if root_id == parent_root_id:
 
315
            # With stacking we _might_ want to refer to a non-local revision,
 
316
            # but this code path only applies when we have the full content
 
317
            # available, so ghosts really are ghosts, not just the edge of
 
318
            # local data.
 
319
            parent_ids.append(parent_id)
 
320
        else:
 
321
            # root_id may be in the parent anyway.
 
322
            try:
 
323
                tree = repo.revision_tree(parent_id)
 
324
            except errors.NoSuchRevision:
 
325
                # ghost, can't refer to it.
 
326
                pass
 
327
            else:
 
328
                try:
 
329
                    parent_ids.append(tree.inventory[root_id].revision)
 
330
                except errors.NoSuchId:
 
331
                    # not in the tree
 
332
                    pass
 
333
    # Drop non-head parents
 
334
    if graph is None:
 
335
        graph = repo.get_graph()
 
336
    heads = graph.heads(parent_ids)
 
337
    selected_ids = []
 
338
    for parent_id in parent_ids:
 
339
        if parent_id in heads and parent_id not in selected_ids:
 
340
            selected_ids.append(parent_id)
 
341
    parent_keys = [(root_id, parent_id) for parent_id in selected_ids]
 
342
    return parent_keys