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

  • Committer: Jelmer Vernooij
  • Date: 2010-04-30 11:03:59 UTC
  • mto: This revision was merged to the branch mainline in revision 5197.
  • Revision ID: jelmer@samba.org-20100430110359-ow3e3grh7sxy93pa
Remove more unused imports.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/fetch.py
 
1
# Copyright (C) 2005-2010 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
 
 
18
"""Copying of history from one branch to another.
 
19
 
 
20
The basic plan is that every branch knows the history of everything
 
21
that has merged into it.  As the first step of a merge, pull, or
 
22
branch operation we copy history from the source into the destination
 
23
branch.
 
24
"""
 
25
 
 
26
import operator
 
27
 
 
28
from bzrlib.lazy_import import lazy_import
 
29
lazy_import(globals(), """
 
30
from bzrlib import (
 
31
    graph as _mod_graph,
 
32
    static_tuple,
 
33
    tsort,
 
34
    versionedfile,
 
35
    )
 
36
""")
 
37
import bzrlib
 
38
from bzrlib import (
 
39
    errors,
 
40
    ui,
 
41
    )
 
42
from bzrlib.revision import NULL_REVISION
 
43
from bzrlib.trace import mutter
 
44
 
 
45
 
 
46
class RepoFetcher(object):
 
47
    """Pull revisions and texts from one repository to another.
 
48
 
 
49
    This should not be used directly, it's essential a object to encapsulate
 
50
    the logic in InterRepository.fetch().
 
51
    """
 
52
 
 
53
    def __init__(self, to_repository, from_repository, last_revision=None,
 
54
        find_ghosts=True, fetch_spec=None):
 
55
        """Create a repo fetcher.
 
56
 
 
57
        :param last_revision: If set, try to limit to the data this revision
 
58
            references.
 
59
        :param find_ghosts: If True search the entire history for ghosts.
 
60
        """
 
61
        # repository.fetch has the responsibility for short-circuiting
 
62
        # attempts to copy between a repository and itself.
 
63
        self.to_repository = to_repository
 
64
        self.from_repository = from_repository
 
65
        self.sink = to_repository._get_sink()
 
66
        # must not mutate self._last_revision as its potentially a shared instance
 
67
        self._last_revision = last_revision
 
68
        self._fetch_spec = fetch_spec
 
69
        self.find_ghosts = find_ghosts
 
70
        self.from_repository.lock_read()
 
71
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
72
               self.from_repository, self.from_repository._format,
 
73
               self.to_repository, self.to_repository._format)
 
74
        try:
 
75
            self.__fetch()
 
76
        finally:
 
77
            self.from_repository.unlock()
 
78
 
 
79
    def __fetch(self):
 
80
        """Primary worker function.
 
81
 
 
82
        This initialises all the needed variables, and then fetches the
 
83
        requested revisions, finally clearing the progress bar.
 
84
        """
 
85
        # Roughly this is what we're aiming for fetch to become:
 
86
        #
 
87
        # missing = self.sink.insert_stream(self.source.get_stream(search))
 
88
        # if missing:
 
89
        #     missing = self.sink.insert_stream(self.source.get_items(missing))
 
90
        # assert not missing
 
91
        self.count_total = 0
 
92
        self.file_ids_names = {}
 
93
        pb = ui.ui_factory.nested_progress_bar()
 
94
        pb.show_pct = pb.show_count = False
 
95
        try:
 
96
            pb.update("Finding revisions", 0, 2)
 
97
            search = self._revids_to_fetch()
 
98
            if search is None:
 
99
                return
 
100
            pb.update("Fetching revisions", 1, 2)
 
101
            self._fetch_everything_for_search(search)
 
102
        finally:
 
103
            pb.finished()
 
104
 
 
105
    def _fetch_everything_for_search(self, search):
 
106
        """Fetch all data for the given set of revisions."""
 
107
        # The first phase is "file".  We pass the progress bar for it directly
 
108
        # into item_keys_introduced_by, which has more information about how
 
109
        # that phase is progressing than we do.  Progress updates for the other
 
110
        # phases are taken care of in this function.
 
111
        # XXX: there should be a clear owner of the progress reporting.  Perhaps
 
112
        # item_keys_introduced_by should have a richer API than it does at the
 
113
        # moment, so that it can feed the progress information back to this
 
114
        # function?
 
115
        if (self.from_repository._format.rich_root_data and
 
116
            not self.to_repository._format.rich_root_data):
 
117
            raise errors.IncompatibleRepositories(
 
118
                self.from_repository, self.to_repository,
 
119
                "different rich-root support")
 
120
        pb = ui.ui_factory.nested_progress_bar()
 
121
        try:
 
122
            pb.update("Get stream source")
 
123
            source = self.from_repository._get_source(
 
124
                self.to_repository._format)
 
125
            stream = source.get_stream(search)
 
126
            from_format = self.from_repository._format
 
127
            pb.update("Inserting stream")
 
128
            resume_tokens, missing_keys = self.sink.insert_stream(
 
129
                stream, from_format, [])
 
130
            if self.to_repository._fallback_repositories:
 
131
                missing_keys.update(
 
132
                    self._parent_inventories(search.get_keys()))
 
133
            if missing_keys:
 
134
                pb.update("Missing keys")
 
135
                stream = source.get_stream_for_missing_keys(missing_keys)
 
136
                pb.update("Inserting missing keys")
 
137
                resume_tokens, missing_keys = self.sink.insert_stream(
 
138
                    stream, from_format, resume_tokens)
 
139
            if missing_keys:
 
140
                raise AssertionError(
 
141
                    "second push failed to complete a fetch %r." % (
 
142
                        missing_keys,))
 
143
            if resume_tokens:
 
144
                raise AssertionError(
 
145
                    "second push failed to commit the fetch %r." % (
 
146
                        resume_tokens,))
 
147
            pb.update("Finishing stream")
 
148
            self.sink.finished()
 
149
        finally:
 
150
            pb.finished()
 
151
 
 
152
    def _revids_to_fetch(self):
 
153
        """Determines the exact revisions needed from self.from_repository to
 
154
        install self._last_revision in self.to_repository.
 
155
 
 
156
        If no revisions need to be fetched, then this just returns None.
 
157
        """
 
158
        if self._fetch_spec is not None:
 
159
            return self._fetch_spec
 
160
        mutter('fetch up to rev {%s}', self._last_revision)
 
161
        if self._last_revision is NULL_REVISION:
 
162
            # explicit limit of no revisions needed
 
163
            return None
 
164
        return self.to_repository.search_missing_revision_ids(
 
165
            self.from_repository, self._last_revision,
 
166
            find_ghosts=self.find_ghosts)
 
167
 
 
168
    def _parent_inventories(self, revision_ids):
 
169
        # Find all the parent revisions referenced by the stream, but
 
170
        # not present in the stream, and make sure we send their
 
171
        # inventories.
 
172
        parent_maps = self.to_repository.get_parent_map(revision_ids)
 
173
        parents = set()
 
174
        map(parents.update, parent_maps.itervalues())
 
175
        parents.discard(NULL_REVISION)
 
176
        parents.difference_update(revision_ids)
 
177
        missing_keys = set(('inventories', rev_id) for rev_id in parents)
 
178
        return missing_keys
 
179
 
 
180
 
 
181
class Inter1and2Helper(object):
 
182
    """Helper for operations that convert data from model 1 and 2
 
183
 
 
184
    This is for use by fetchers and converters.
 
185
    """
 
186
 
 
187
    def __init__(self, source):
 
188
        """Constructor.
 
189
 
 
190
        :param source: The repository data comes from
 
191
        """
 
192
        self.source = source
 
193
 
 
194
    def iter_rev_trees(self, revs):
 
195
        """Iterate through RevisionTrees efficiently.
 
196
 
 
197
        Additionally, the inventory's revision_id is set if unset.
 
198
 
 
199
        Trees are retrieved in batches of 100, and then yielded in the order
 
200
        they were requested.
 
201
 
 
202
        :param revs: A list of revision ids
 
203
        """
 
204
        # In case that revs is not a list.
 
205
        revs = list(revs)
 
206
        while revs:
 
207
            for tree in self.source.revision_trees(revs[:100]):
 
208
                if tree.inventory.revision_id is None:
 
209
                    tree.inventory.revision_id = tree.get_revision_id()
 
210
                yield tree
 
211
            revs = revs[100:]
 
212
 
 
213
    def _find_root_ids(self, revs, parent_map, graph):
 
214
        revision_root = {}
 
215
        for tree in self.iter_rev_trees(revs):
 
216
            revision_id = tree.inventory.root.revision
 
217
            root_id = tree.get_root_id()
 
218
            revision_root[revision_id] = root_id
 
219
        # Find out which parents we don't already know root ids for
 
220
        parents = set()
 
221
        for revision_parents in parent_map.itervalues():
 
222
            parents.update(revision_parents)
 
223
        parents.difference_update(revision_root.keys() + [NULL_REVISION])
 
224
        # Limit to revisions present in the versionedfile
 
225
        parents = graph.get_parent_map(parents).keys()
 
226
        for tree in self.iter_rev_trees(parents):
 
227
            root_id = tree.get_root_id()
 
228
            revision_root[tree.get_revision_id()] = root_id
 
229
        return revision_root
 
230
 
 
231
    def generate_root_texts(self, revs):
 
232
        """Generate VersionedFiles for all root ids.
 
233
 
 
234
        :param revs: the revisions to include
 
235
        """
 
236
        graph = self.source.get_graph()
 
237
        parent_map = graph.get_parent_map(revs)
 
238
        rev_order = tsort.topo_sort(parent_map)
 
239
        rev_id_to_root_id = self._find_root_ids(revs, parent_map, graph)
 
240
        root_id_order = [(rev_id_to_root_id[rev_id], rev_id) for rev_id in
 
241
            rev_order]
 
242
        # Guaranteed stable, this groups all the file id operations together
 
243
        # retaining topological order within the revisions of a file id.
 
244
        # File id splits and joins would invalidate this, but they don't exist
 
245
        # yet, and are unlikely to in non-rich-root environments anyway.
 
246
        root_id_order.sort(key=operator.itemgetter(0))
 
247
        # Create a record stream containing the roots to create.
 
248
        if len(revs) > 100:
 
249
            # XXX: not covered by tests, should have a flag to always run
 
250
            # this. -- mbp 20100129
 
251
            graph = _get_rich_root_heads_graph(self.source, revs)
 
252
        new_roots_stream = _new_root_data_stream(
 
253
            root_id_order, rev_id_to_root_id, parent_map, self.source, graph)
 
254
        return [('texts', new_roots_stream)]
 
255
 
 
256
 
 
257
def _get_rich_root_heads_graph(source_repo, revision_ids):
 
258
    """Get a Graph object suitable for asking heads() for new rich roots."""
 
259
    st = static_tuple.StaticTuple
 
260
    revision_keys = [st(r_id).intern() for r_id in revision_ids]
 
261
    known_graph = source_repo.revisions.get_known_graph_ancestry(
 
262
                    revision_keys)
 
263
    return _mod_graph.GraphThunkIdsToKeys(known_graph)
 
264
 
 
265
 
 
266
def _new_root_data_stream(
 
267
    root_keys_to_create, rev_id_to_root_id_map, parent_map, repo, graph=None):
 
268
    """Generate a texts substream of synthesised root entries.
 
269
 
 
270
    Used in fetches that do rich-root upgrades.
 
271
    
 
272
    :param root_keys_to_create: iterable of (root_id, rev_id) pairs describing
 
273
        the root entries to create.
 
274
    :param rev_id_to_root_id_map: dict of known rev_id -> root_id mappings for
 
275
        calculating the parents.  If a parent rev_id is not found here then it
 
276
        will be recalculated.
 
277
    :param parent_map: a parent map for all the revisions in
 
278
        root_keys_to_create.
 
279
    :param graph: a graph to use instead of repo.get_graph().
 
280
    """
 
281
    for root_key in root_keys_to_create:
 
282
        root_id, rev_id = root_key
 
283
        parent_keys = _parent_keys_for_root_version(
 
284
            root_id, rev_id, rev_id_to_root_id_map, parent_map, repo, graph)
 
285
        yield versionedfile.FulltextContentFactory(
 
286
            root_key, parent_keys, None, '')
 
287
 
 
288
 
 
289
def _parent_keys_for_root_version(
 
290
    root_id, rev_id, rev_id_to_root_id_map, parent_map, repo, graph=None):
 
291
    """Get the parent keys for a given root id.
 
292
    
 
293
    A helper function for _new_root_data_stream.
 
294
    """
 
295
    # Include direct parents of the revision, but only if they used the same
 
296
    # root_id and are heads.
 
297
    rev_parents = parent_map[rev_id]
 
298
    parent_ids = []
 
299
    for parent_id in rev_parents:
 
300
        if parent_id == NULL_REVISION:
 
301
            continue
 
302
        if parent_id not in rev_id_to_root_id_map:
 
303
            # We probably didn't read this revision, go spend the extra effort
 
304
            # to actually check
 
305
            try:
 
306
                tree = repo.revision_tree(parent_id)
 
307
            except errors.NoSuchRevision:
 
308
                # Ghost, fill out rev_id_to_root_id in case we encounter this
 
309
                # again.
 
310
                # But set parent_root_id to None since we don't really know
 
311
                parent_root_id = None
 
312
            else:
 
313
                parent_root_id = tree.get_root_id()
 
314
            rev_id_to_root_id_map[parent_id] = None
 
315
            # XXX: why not:
 
316
            #   rev_id_to_root_id_map[parent_id] = parent_root_id
 
317
            # memory consumption maybe?
 
318
        else:
 
319
            parent_root_id = rev_id_to_root_id_map[parent_id]
 
320
        if root_id == parent_root_id:
 
321
            # With stacking we _might_ want to refer to a non-local revision,
 
322
            # but this code path only applies when we have the full content
 
323
            # available, so ghosts really are ghosts, not just the edge of
 
324
            # local data.
 
325
            parent_ids.append(parent_id)
 
326
        else:
 
327
            # root_id may be in the parent anyway.
 
328
            try:
 
329
                tree = repo.revision_tree(parent_id)
 
330
            except errors.NoSuchRevision:
 
331
                # ghost, can't refer to it.
 
332
                pass
 
333
            else:
 
334
                try:
 
335
                    parent_ids.append(tree.inventory[root_id].revision)
 
336
                except errors.NoSuchId:
 
337
                    # not in the tree
 
338
                    pass
 
339
    # Drop non-head parents
 
340
    if graph is None:
 
341
        graph = repo.get_graph()
 
342
    heads = graph.heads(parent_ids)
 
343
    selected_ids = []
 
344
    for parent_id in parent_ids:
 
345
        if parent_id in heads and parent_id not in selected_ids:
 
346
            selected_ids.append(parent_id)
 
347
    parent_keys = [(root_id, parent_id) for parent_id in selected_ids]
 
348
    return parent_keys