/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: Martin Pool
  • Date: 2007-08-15 04:33:34 UTC
  • mto: (2701.1.2 remove-should-cache)
  • mto: This revision was merged to the branch mainline in revision 2710.
  • Revision ID: mbp@sourcefrog.net-20070815043334-01dx9emb0vjiy29v
Remove things deprecated in 0.11 and earlier

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/fetch.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
18
"""Copying of history from one branch to another.
21
21
that has merged into it.  As the first step of a merge, pull, or
22
22
branch operation we copy history from the source into the destination
23
23
branch.
 
24
 
 
25
The copying is done in a slightly complicated order.  We don't want to
 
26
add a revision to the store until everything it refers to is also
 
27
stored, so that if a revision is present we can totally recreate it.
 
28
However, we can't know what files are included in a revision until we
 
29
read its inventory.  So we query the inventory store of the source for
 
30
the ids we need, and then pull those ids and finally actually join
 
31
the inventories.
24
32
"""
25
33
 
26
 
import operator
27
 
 
28
 
from bzrlib.lazy_import import lazy_import
29
 
lazy_import(globals(), """
30
 
from bzrlib import (
31
 
    tsort,
32
 
    versionedfile,
33
 
    )
34
 
""")
35
34
import bzrlib
36
 
from bzrlib import (
37
 
    errors,
38
 
    ui,
39
 
    )
 
35
import bzrlib.errors as errors
 
36
from bzrlib.errors import (InstallFailed,
 
37
                           )
 
38
from bzrlib.progress import ProgressPhase
40
39
from bzrlib.revision import NULL_REVISION
 
40
from bzrlib.symbol_versioning import (deprecated_function,
 
41
        deprecated_method,
 
42
        )
41
43
from bzrlib.trace import mutter
 
44
import bzrlib.ui
 
45
 
 
46
from bzrlib.lazy_import import lazy_import
 
47
 
 
48
# TODO: Avoid repeatedly opening weaves so many times.
 
49
 
 
50
# XXX: This doesn't handle ghost (not present in branch) revisions at
 
51
# all yet.  I'm not sure they really should be supported.
 
52
 
 
53
# NOTE: This doesn't copy revisions which may be present but not
 
54
# merged into the last revision.  I'm not sure we want to do that.
 
55
 
 
56
# - get a list of revisions that need to be pulled in
 
57
# - for each one, pull in that revision file
 
58
#   and get the inventory, and store the inventory with right
 
59
#   parents.
 
60
# - and get the ancestry, and store that with right parents too
 
61
# - and keep a note of all file ids and version seen
 
62
# - then go through all files; for each one get the weave,
 
63
#   and add in all file versions
42
64
 
43
65
 
44
66
class RepoFetcher(object):
45
67
    """Pull revisions and texts from one repository to another.
46
68
 
47
 
    This should not be used directly, it's essential a object to encapsulate
 
69
    last_revision
 
70
        if set, try to limit to the data this revision references.
 
71
 
 
72
    after running:
 
73
    count_copied -- number of revisions copied
 
74
 
 
75
    This should not be used directory, its essential a object to encapsulate
48
76
    the logic in InterRepository.fetch().
49
77
    """
50
 
 
51
 
    def __init__(self, to_repository, from_repository, last_revision=None,
52
 
        find_ghosts=True, fetch_spec=None):
53
 
        """Create a repo fetcher.
54
 
 
55
 
        :param last_revision: If set, try to limit to the data this revision
56
 
            references.
57
 
        :param find_ghosts: If True search the entire history for ghosts.
58
 
        """
59
 
        # repository.fetch has the responsibility for short-circuiting
60
 
        # attempts to copy between a repository and itself.
 
78
    def __init__(self, to_repository, from_repository, last_revision=None, pb=None):
 
79
        # result variables.
 
80
        self.failed_revisions = []
 
81
        self.count_copied = 0
 
82
        if to_repository.control_files._transport.base == from_repository.control_files._transport.base:
 
83
            # check that last_revision is in 'from' and then return a no-operation.
 
84
            if last_revision not in (None, NULL_REVISION):
 
85
                to_repository.get_revision(last_revision)
 
86
            return
61
87
        self.to_repository = to_repository
62
88
        self.from_repository = from_repository
63
 
        self.sink = to_repository._get_sink()
64
89
        # must not mutate self._last_revision as its potentially a shared instance
65
90
        self._last_revision = last_revision
66
 
        self._fetch_spec = fetch_spec
67
 
        self.find_ghosts = find_ghosts
 
91
        if pb is None:
 
92
            self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
93
            self.nested_pb = self.pb
 
94
        else:
 
95
            self.pb = pb
 
96
            self.nested_pb = None
68
97
        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
98
        try:
73
 
            self.__fetch()
 
99
            self.to_repository.lock_write()
 
100
            try:
 
101
                self.to_repository.start_write_group()
 
102
                try:
 
103
                    self.__fetch()
 
104
                except:
 
105
                    self.to_repository.abort_write_group()
 
106
                    raise
 
107
                else:
 
108
                    self.to_repository.commit_write_group()
 
109
            finally:
 
110
                if self.nested_pb is not None:
 
111
                    self.nested_pb.finished()
 
112
                self.to_repository.unlock()
74
113
        finally:
75
114
            self.from_repository.unlock()
76
115
 
77
116
    def __fetch(self):
78
117
        """Primary worker function.
79
118
 
80
 
        This initialises all the needed variables, and then fetches the
 
119
        This initialises all the needed variables, and then fetches the 
81
120
        requested revisions, finally clearing the progress bar.
82
121
        """
83
 
        # Roughly this is what we're aiming for fetch to become:
84
 
        #
85
 
        # missing = self.sink.insert_stream(self.source.get_stream(search))
86
 
        # if missing:
87
 
        #     missing = self.sink.insert_stream(self.source.get_items(missing))
88
 
        # assert not missing
 
122
        self.to_weaves = self.to_repository.weave_store
 
123
        self.to_control = self.to_repository.control_weaves
 
124
        self.from_weaves = self.from_repository.weave_store
 
125
        self.from_control = self.from_repository.control_weaves
89
126
        self.count_total = 0
90
127
        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
 
                return
98
 
            pb.update("Fetching revisions", 1, 2)
99
 
            self._fetch_everything_for_search(search)
100
 
        finally:
101
 
            pb.finished()
102
 
 
103
 
    def _fetch_everything_for_search(self, search):
104
 
        """Fetch all data for the given set of revisions."""
105
 
        # The first phase is "file".  We pass the progress bar for it directly
106
 
        # into item_keys_introduced_by, which has more information about how
107
 
        # that phase is progressing than we do.  Progress updates for the other
108
 
        # phases are taken care of in this function.
109
 
        # XXX: there should be a clear owner of the progress reporting.  Perhaps
110
 
        # item_keys_introduced_by should have a richer API than it does at the
111
 
        # moment, so that it can feed the progress information back to this
112
 
        # function?
113
 
        if (self.from_repository._format.rich_root_data and
114
 
            not self.to_repository._format.rich_root_data):
115
 
            raise errors.IncompatibleRepositories(
116
 
                self.from_repository, self.to_repository,
117
 
                "different rich-root support")
118
 
        pb = ui.ui_factory.nested_progress_bar()
119
 
        try:
120
 
            pb.update("Get stream source")
121
 
            source = self.from_repository._get_source(
122
 
                self.to_repository._format)
123
 
            stream = source.get_stream(search)
124
 
            from_format = self.from_repository._format
125
 
            pb.update("Inserting stream")
126
 
            resume_tokens, missing_keys = self.sink.insert_stream(
127
 
                stream, from_format, [])
128
 
            if self.to_repository._fallback_repositories:
129
 
                missing_keys.update(
130
 
                    self._parent_inventories(search.get_keys()))
131
 
            if missing_keys:
132
 
                pb.update("Missing keys")
133
 
                stream = source.get_stream_for_missing_keys(missing_keys)
134
 
                pb.update("Inserting missing keys")
135
 
                resume_tokens, missing_keys = self.sink.insert_stream(
136
 
                    stream, from_format, resume_tokens)
137
 
            if missing_keys:
138
 
                raise AssertionError(
139
 
                    "second push failed to complete a fetch %r." % (
140
 
                        missing_keys,))
141
 
            if resume_tokens:
142
 
                raise AssertionError(
143
 
                    "second push failed to commit the fetch %r." % (
144
 
                        resume_tokens,))
145
 
            pb.update("Finishing stream")
146
 
            self.sink.finished()
147
 
        finally:
148
 
            pb.finished()
 
128
        pp = ProgressPhase('Fetch phase', 4, self.pb)
 
129
        try:
 
130
            pp.next_phase()
 
131
            revs = self._revids_to_fetch()
 
132
            # something to do ?
 
133
            if revs:
 
134
                pp.next_phase()
 
135
                self._fetch_weave_texts(revs)
 
136
                pp.next_phase()
 
137
                self._fetch_inventory_weave(revs)
 
138
                pp.next_phase()
 
139
                self._fetch_revision_texts(revs)
 
140
                self.count_copied += len(revs)
 
141
        finally:
 
142
            self.pb.clear()
149
143
 
150
144
    def _revids_to_fetch(self):
151
 
        """Determines the exact revisions needed from self.from_repository to
152
 
        install self._last_revision in self.to_repository.
153
 
 
154
 
        If no revisions need to be fetched, then this just returns None.
155
 
        """
156
 
        if self._fetch_spec is not None:
157
 
            return self._fetch_spec
158
145
        mutter('fetch up to rev {%s}', self._last_revision)
159
146
        if self._last_revision is NULL_REVISION:
160
147
            # explicit limit of no revisions needed
161
148
            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
 
149
        if (self._last_revision is not None and
 
150
            self.to_repository.has_revision(self._last_revision)):
 
151
            return None
 
152
            
 
153
        try:
 
154
            return self.to_repository.missing_revision_ids(self.from_repository,
 
155
                                                           self._last_revision)
 
156
        except errors.NoSuchRevision:
 
157
            raise InstallFailed([self._last_revision])
 
158
 
 
159
    def _fetch_weave_texts(self, revs):
 
160
        texts_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
161
        try:
 
162
            # fileids_altered_by_revision_ids requires reading the inventory
 
163
            # weave, we will need to read the inventory weave again when
 
164
            # all this is done, so enable caching for that specific weave
 
165
            inv_w = self.from_repository.get_inventory_weave()
 
166
            inv_w.enable_cache()
 
167
            file_ids = self.from_repository.fileids_altered_by_revision_ids(revs)
 
168
            count = 0
 
169
            num_file_ids = len(file_ids)
 
170
            for file_id, required_versions in file_ids.items():
 
171
                texts_pb.update("fetch texts", count, num_file_ids)
 
172
                count +=1
 
173
                to_weave = self.to_weaves.get_weave_or_empty(file_id,
 
174
                    self.to_repository.get_transaction())
 
175
                from_weave = self.from_weaves.get_weave(file_id,
 
176
                    self.from_repository.get_transaction())
 
177
                # we fetch all the texts, because texts do
 
178
                # not reference anything, and its cheap enough
 
179
                to_weave.join(from_weave, version_ids=required_versions)
 
180
                # we don't need *all* of this data anymore, but we dont know
 
181
                # what we do. This cache clearing will result in a new read 
 
182
                # of the knit data when we do the checkout, but probably we
 
183
                # want to emit the needed data on the fly rather than at the
 
184
                # end anyhow.
 
185
                # the from weave should know not to cache data being joined,
 
186
                # but its ok to ask it to clear.
 
187
                from_weave.clear_cache()
 
188
                to_weave.clear_cache()
 
189
        finally:
 
190
            texts_pb.finished()
 
191
 
 
192
    def _fetch_inventory_weave(self, revs):
 
193
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
194
        try:
 
195
            pb.update("fetch inventory", 0, 2)
 
196
            to_weave = self.to_control.get_weave('inventory',
 
197
                    self.to_repository.get_transaction())
 
198
    
 
199
            child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
200
            try:
 
201
                # just merge, this is optimisable and its means we don't
 
202
                # copy unreferenced data such as not-needed inventories.
 
203
                pb.update("fetch inventory", 1, 3)
 
204
                from_weave = self.from_repository.get_inventory_weave()
 
205
                pb.update("fetch inventory", 2, 3)
 
206
                # we fetch only the referenced inventories because we do not
 
207
                # know for unselected inventories whether all their required
 
208
                # texts are present in the other repository - it could be
 
209
                # corrupt.
 
210
                to_weave.join(from_weave, pb=child_pb, msg='merge inventory',
 
211
                              version_ids=revs)
 
212
                from_weave.clear_cache()
 
213
            finally:
 
214
                child_pb.finished()
 
215
        finally:
 
216
            pb.finished()
 
217
 
 
218
 
 
219
class GenericRepoFetcher(RepoFetcher):
 
220
    """This is a generic repo to repo fetcher.
 
221
 
 
222
    This makes minimal assumptions about repo layout and contents.
 
223
    It triggers a reconciliation after fetching to ensure integrity.
 
224
    """
 
225
 
 
226
    def _fetch_revision_texts(self, revs):
 
227
        """Fetch revision object texts"""
 
228
        rev_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
229
        try:
 
230
            to_txn = self.to_transaction = self.to_repository.get_transaction()
 
231
            count = 0
 
232
            total = len(revs)
 
233
            to_store = self.to_repository._revision_store
 
234
            for rev in revs:
 
235
                pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
236
                try:
 
237
                    pb.update('copying revisions', count, total)
 
238
                    try:
 
239
                        sig_text = self.from_repository.get_signature_text(rev)
 
240
                        to_store.add_revision_signature_text(rev, sig_text, to_txn)
 
241
                    except errors.NoSuchRevision:
 
242
                        # not signed.
 
243
                        pass
 
244
                    to_store.add_revision(self.from_repository.get_revision(rev),
 
245
                                          to_txn)
 
246
                    count += 1
 
247
                finally:
 
248
                    pb.finished()
 
249
            # fixup inventory if needed: 
 
250
            # this is expensive because we have no inverse index to current ghosts.
 
251
            # but on local disk its a few seconds and sftp push is already insane.
 
252
            # so we just-do-it.
 
253
            # FIXME: repository should inform if this is needed.
 
254
            self.to_repository.reconcile()
 
255
        finally:
 
256
            rev_pb.finished()
 
257
    
 
258
 
 
259
class KnitRepoFetcher(RepoFetcher):
 
260
    """This is a knit format repository specific fetcher.
 
261
 
 
262
    This differs from the GenericRepoFetcher by not doing a 
 
263
    reconciliation after copying, and using knit joining to
 
264
    copy revision texts.
 
265
    """
 
266
 
 
267
    def _fetch_revision_texts(self, revs):
 
268
        # may need to be a InterRevisionStore call here.
 
269
        from_transaction = self.from_repository.get_transaction()
 
270
        to_transaction = self.to_repository.get_transaction()
 
271
        to_sf = self.to_repository._revision_store.get_signature_file(
 
272
            to_transaction)
 
273
        from_sf = self.from_repository._revision_store.get_signature_file(
 
274
            from_transaction)
 
275
        to_sf.join(from_sf, version_ids=revs, ignore_missing=True)
 
276
        to_rf = self.to_repository._revision_store.get_revision_file(
 
277
            to_transaction)
 
278
        from_rf = self.from_repository._revision_store.get_revision_file(
 
279
            from_transaction)
 
280
        to_rf.join(from_rf, version_ids=revs)
177
281
 
178
282
 
179
283
class Inter1and2Helper(object):
180
284
    """Helper for operations that convert data from model 1 and 2
181
 
 
 
285
    
182
286
    This is for use by fetchers and converters.
183
287
    """
184
288
 
185
 
    def __init__(self, source):
 
289
    def __init__(self, source, target):
186
290
        """Constructor.
187
291
 
188
292
        :param source: The repository data comes from
 
293
        :param target: The repository data goes to
189
294
        """
190
295
        self.source = source
 
296
        self.target = target
191
297
 
192
298
    def iter_rev_trees(self, revs):
193
299
        """Iterate through RevisionTrees efficiently.
199
305
 
200
306
        :param revs: A list of revision ids
201
307
        """
202
 
        # In case that revs is not a list.
203
 
        revs = list(revs)
204
308
        while revs:
205
309
            for tree in self.source.revision_trees(revs[:100]):
206
310
                if tree.inventory.revision_id is None:
208
312
                yield tree
209
313
            revs = revs[100:]
210
314
 
211
 
    def _find_root_ids(self, revs, parent_map, graph):
212
 
        revision_root = {}
213
 
        for tree in self.iter_rev_trees(revs):
214
 
            revision_id = tree.inventory.root.revision
215
 
            root_id = tree.get_root_id()
216
 
            revision_root[revision_id] = root_id
217
 
        # 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])
222
 
        # Limit to revisions present in the versionedfile
223
 
        parents = graph.get_parent_map(parents).keys()
224
 
        for tree in self.iter_rev_trees(parents):
225
 
            root_id = tree.get_root_id()
226
 
            revision_root[tree.get_revision_id()] = root_id
227
 
        return revision_root
228
 
 
229
315
    def generate_root_texts(self, revs):
230
316
        """Generate VersionedFiles for all root ids.
231
 
 
 
317
        
232
318
        :param revs: the revisions to include
233
319
        """
234
 
        graph = self.source.get_graph()
235
 
        parent_map = graph.get_parent_map(revs)
236
 
        rev_order = tsort.topo_sort(parent_map)
237
 
        rev_id_to_root_id = self._find_root_ids(revs, parent_map, graph)
238
 
        root_id_order = [(rev_id_to_root_id[rev_id], rev_id) for rev_id in
239
 
            rev_order]
240
 
        # Guaranteed stable, this groups all the file id operations together
241
 
        # retaining topological order within the revisions of a file id.
242
 
        # File id splits and joins would invalidate this, but they don't exist
243
 
        # yet, and are unlikely to in non-rich-root environments anyway.
244
 
        root_id_order.sort(key=operator.itemgetter(0))
245
 
        # 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
 
        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
 
320
        inventory_weave = self.source.get_inventory_weave()
 
321
        parent_texts = {}
 
322
        versionedfile = {}
 
323
        to_store = self.target.weave_store
 
324
        for tree in self.iter_rev_trees(revs):
 
325
            revision_id = tree.inventory.root.revision
 
326
            root_id = tree.inventory.root.file_id
 
327
            parents = inventory_weave.get_parents(revision_id)
 
328
            if root_id not in versionedfile:
 
329
                versionedfile[root_id] = to_store.get_weave_or_empty(root_id, 
 
330
                    self.target.get_transaction())
 
331
            parent_texts[root_id] = versionedfile[root_id].add_lines(
 
332
                revision_id, parents, [], parent_texts)
 
333
 
 
334
    def regenerate_inventory(self, revs):
 
335
        """Generate a new inventory versionedfile in target, convertin data.
 
336
        
 
337
        The inventory is retrieved from the source, (deserializing it), and
 
338
        stored in the target (reserializing it in a different format).
 
339
        :param revs: The revisions to include
 
340
        """
 
341
        inventory_weave = self.source.get_inventory_weave()
 
342
        for tree in self.iter_rev_trees(revs):
 
343
            parents = inventory_weave.get_parents(tree.get_revision_id())
 
344
            self.target.add_inventory(tree.get_revision_id(), tree.inventory,
 
345
                                      parents)
 
346
 
 
347
 
 
348
class Model1toKnit2Fetcher(GenericRepoFetcher):
 
349
    """Fetch from a Model1 repository into a Knit2 repository
 
350
    """
 
351
    def __init__(self, to_repository, from_repository, last_revision=None, 
 
352
                 pb=None):
 
353
        self.helper = Inter1and2Helper(from_repository, to_repository)
 
354
        GenericRepoFetcher.__init__(self, to_repository, from_repository,
 
355
                                    last_revision, pb)
 
356
 
 
357
    def _fetch_weave_texts(self, revs):
 
358
        GenericRepoFetcher._fetch_weave_texts(self, revs)
 
359
        # Now generate a weave for the tree root
 
360
        self.helper.generate_root_texts(revs)
 
361
 
 
362
    def _fetch_inventory_weave(self, revs):
 
363
        self.helper.regenerate_inventory(revs)
 
364
 
 
365
 
 
366
class Knit1to2Fetcher(KnitRepoFetcher):
 
367
    """Fetch from a Knit1 repository into a Knit2 repository"""
 
368
 
 
369
    def __init__(self, to_repository, from_repository, last_revision=None, 
 
370
                 pb=None):
 
371
        self.helper = Inter1and2Helper(from_repository, to_repository)
 
372
        KnitRepoFetcher.__init__(self, to_repository, from_repository,
 
373
                                 last_revision, pb)
 
374
 
 
375
    def _fetch_weave_texts(self, revs):
 
376
        KnitRepoFetcher._fetch_weave_texts(self, revs)
 
377
        # Now generate a weave for the tree root
 
378
        self.helper.generate_root_texts(revs)
 
379
 
 
380
    def _fetch_inventory_weave(self, revs):
 
381
        self.helper.regenerate_inventory(revs)