~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/fetch.py

  • Committer: Robert Collins
  • Date: 2005-10-03 01:15:02 UTC
  • mfrom: (1092.2.28)
  • Revision ID: robertc@robertcollins.net-20051003011502-f579a509a136b774
mergeĀ fromĀ baz2bzr

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2008 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005 by Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
 
17
import os
 
18
from cStringIO import StringIO
 
19
 
 
20
import bzrlib.errors
 
21
from bzrlib.trace import mutter, note, warning
 
22
from bzrlib.branch import Branch
 
23
from bzrlib.progress import ProgressBar
 
24
from bzrlib.xml5 import serializer_v5
 
25
from bzrlib.osutils import sha_string, split_lines
 
26
from bzrlib.errors import InstallFailed, NoSuchRevision, WeaveError
17
27
 
18
28
"""Copying of history from one branch to another.
19
29
 
26
36
add a revision to the store until everything it refers to is also
27
37
stored, so that if a revision is present we can totally recreate it.
28
38
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 then return to the inventories.
 
39
read its inventory.  Therefore, we first pull the XML and hold it in
 
40
memory until we've updated all of the files referenced.
31
41
"""
32
42
 
33
 
import operator
34
 
 
35
 
import bzrlib
36
 
import bzrlib.errors as errors
37
 
from bzrlib.errors import InstallFailed
38
 
from bzrlib.progress import ProgressPhase
39
 
from bzrlib.revision import is_null, NULL_REVISION
40
 
from bzrlib.symbol_versioning import (deprecated_function,
41
 
        deprecated_method,
42
 
        )
43
 
from bzrlib.tsort import topo_sort
44
 
from bzrlib.trace import mutter
45
 
import bzrlib.ui
46
 
from bzrlib.versionedfile import filter_absent, FulltextContentFactory
47
 
 
48
43
# TODO: Avoid repeatedly opening weaves so many times.
49
44
 
50
45
# XXX: This doesn't handle ghost (not present in branch) revisions at
63
58
#   and add in all file versions
64
59
 
65
60
 
66
 
class RepoFetcher(object):
67
 
    """Pull revisions and texts from one repository to another.
68
 
 
69
 
    last_revision
70
 
        if set, try to limit to the data this revision references.
71
 
 
72
 
    after running:
 
61
 
 
62
def greedy_fetch(to_branch, from_branch, revision=None, pb=None):
 
63
    f = Fetcher(to_branch, from_branch, revision, pb)
 
64
    return f.count_copied, f.failed_revisions
 
65
 
 
66
 
 
67
 
 
68
class Fetcher(object):
 
69
    """Pull revisions and texts from one branch to another.
 
70
 
 
71
    This doesn't update the destination's history; that can be done
 
72
    separately if desired.  
 
73
 
 
74
    revision_limit
 
75
        If set, pull only up to this revision_id.
 
76
 
 
77
    After running:
 
78
 
 
79
    last_revision -- if last_revision
 
80
        is given it will be that, otherwise the last revision of
 
81
        from_branch
 
82
 
73
83
    count_copied -- number of revisions copied
74
84
 
75
 
    This should not be used directly, it's essential a object to encapsulate
76
 
    the logic in InterRepository.fetch().
 
85
    count_texts -- number of file texts copied
77
86
    """
78
 
 
79
 
    def __init__(self, to_repository, from_repository, last_revision=None, pb=None,
80
 
        find_ghosts=True):
81
 
        """Create a repo fetcher.
82
 
 
83
 
        :param find_ghosts: If True search the entire history for ghosts.
84
 
        :param _write_group_acquired_callable: Don't use; this parameter only
85
 
            exists to facilitate a hack done in InterPackRepo.fetch.  We would
86
 
            like to remove this parameter.
87
 
        """
88
 
        # result variables.
 
87
    def __init__(self, to_branch, from_branch, last_revision=None, pb=None):
 
88
        if to_branch == from_branch:
 
89
            raise Exception("can't fetch from a branch to itself")
 
90
        self.to_branch = to_branch
 
91
        self.to_weaves = to_branch.weave_store
 
92
        self.to_control = to_branch.control_weaves
 
93
        self.from_branch = from_branch
 
94
        self.from_weaves = from_branch.weave_store
 
95
        self.from_control = from_branch.control_weaves
89
96
        self.failed_revisions = []
90
97
        self.count_copied = 0
91
 
        if to_repository.has_same_location(from_repository):
92
 
            # repository.fetch should be taking care of this case.
93
 
            raise errors.BzrError('RepoFetcher run '
94
 
                    'between two objects at the same location: '
95
 
                    '%r and %r' % (to_repository, from_repository))
96
 
        self.to_repository = to_repository
97
 
        self.from_repository = from_repository
98
 
        # must not mutate self._last_revision as its potentially a shared instance
99
 
        self._last_revision = last_revision
100
 
        self.find_ghosts = find_ghosts
 
98
        self.count_total = 0
 
99
        self.count_texts = 0
101
100
        if pb is None:
102
 
            self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
103
 
            self.nested_pb = self.pb
 
101
            self.pb = bzrlib.ui.ui_factory.progress_bar()
104
102
        else:
105
103
            self.pb = pb
106
 
            self.nested_pb = None
107
 
        self.from_repository.lock_read()
108
 
        try:
109
 
            self.to_repository.lock_write()
110
 
            try:
111
 
                self.to_repository.start_write_group()
112
 
                try:
113
 
                    self.__fetch()
114
 
                except:
115
 
                    self.to_repository.abort_write_group(suppress_errors=True)
116
 
                    raise
117
 
                else:
118
 
                    self.to_repository.commit_write_group()
119
 
            finally:
120
 
                try:
121
 
                    if self.nested_pb is not None:
122
 
                        self.nested_pb.finished()
123
 
                finally:
124
 
                    self.to_repository.unlock()
125
 
        finally:
126
 
            self.from_repository.unlock()
127
 
 
128
 
    def __fetch(self):
129
 
        """Primary worker function.
130
 
 
131
 
        This initialises all the needed variables, and then fetches the 
132
 
        requested revisions, finally clearing the progress bar.
133
 
        """
134
 
        self.count_total = 0
135
 
        self.file_ids_names = {}
136
 
        pp = ProgressPhase('Transferring', 4, self.pb)
137
 
        try:
138
 
            pp.next_phase()
139
 
            search = self._revids_to_fetch()
140
 
            if search is None:
141
 
                return
142
 
            if getattr(self, '_fetch_everything_for_search', None) is not None:
143
 
                self._fetch_everything_for_search(search, pp)
144
 
            else:
145
 
                # backward compatibility
146
 
                self._fetch_everything_for_revisions(search.get_keys, pp)
147
 
        finally:
148
 
            self.pb.clear()
149
 
 
150
 
    def _fetch_everything_for_search(self, search, pp):
151
 
        """Fetch all data for the given set of revisions."""
152
 
        # The first phase is "file".  We pass the progress bar for it directly
153
 
        # into item_keys_introduced_by, which has more information about how
154
 
        # that phase is progressing than we do.  Progress updates for the other
155
 
        # phases are taken care of in this function.
156
 
        # XXX: there should be a clear owner of the progress reporting.  Perhaps
157
 
        # item_keys_introduced_by should have a richer API than it does at the
158
 
        # moment, so that it can feed the progress information back to this
159
 
        # function?
160
 
        phase = 'file'
161
 
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
162
 
        try:
163
 
            revs = search.get_keys()
164
 
            graph = self.from_repository.get_graph()
165
 
            revs = list(graph.iter_topo_order(revs))
166
 
            data_to_fetch = self.from_repository.item_keys_introduced_by(revs,
167
 
                                                                         pb)
168
 
            text_keys = []
169
 
            for knit_kind, file_id, revisions in data_to_fetch:
170
 
                if knit_kind != phase:
171
 
                    phase = knit_kind
172
 
                    # Make a new progress bar for this phase
173
 
                    pb.finished()
174
 
                    pp.next_phase()
175
 
                    pb = bzrlib.ui.ui_factory.nested_progress_bar()
176
 
                if knit_kind == "file":
177
 
                    # Accumulate file texts
178
 
                    text_keys.extend([(file_id, revision) for revision in
179
 
                        revisions])
180
 
                elif knit_kind == "inventory":
181
 
                    # Now copy the file texts.
182
 
                    to_texts = self.to_repository.texts
183
 
                    from_texts = self.from_repository.texts
184
 
                    to_texts.insert_record_stream(from_texts.get_record_stream(
185
 
                        text_keys, self.to_repository._fetch_order,
186
 
                        not self.to_repository._fetch_uses_deltas))
187
 
                    # Cause an error if a text occurs after we have done the
188
 
                    # copy.
189
 
                    text_keys = None
190
 
                    # Before we process the inventory we generate the root
191
 
                    # texts (if necessary) so that the inventories references
192
 
                    # will be valid.
193
 
                    self._generate_root_texts(revs)
194
 
                    # NB: This currently reopens the inventory weave in source;
195
 
                    # using a single stream interface instead would avoid this.
196
 
                    self._fetch_inventory_weave(revs, pb)
197
 
                elif knit_kind == "signatures":
198
 
                    # Nothing to do here; this will be taken care of when
199
 
                    # _fetch_revision_texts happens.
200
 
                    pass
201
 
                elif knit_kind == "revisions":
202
 
                    self._fetch_revision_texts(revs, pb)
203
 
                else:
204
 
                    raise AssertionError("Unknown knit kind %r" % knit_kind)
205
 
            if self.to_repository._fetch_reconcile:
206
 
                self.to_repository.reconcile()
207
 
        finally:
208
 
            if pb is not None:
209
 
                pb.finished()
210
 
        self.count_copied += len(revs)
211
 
        
212
 
    def _revids_to_fetch(self):
213
 
        """Determines the exact revisions needed from self.from_repository to
214
 
        install self._last_revision in self.to_repository.
215
 
 
216
 
        If no revisions need to be fetched, then this just returns None.
217
 
        """
218
 
        mutter('fetch up to rev {%s}', self._last_revision)
219
 
        if self._last_revision is NULL_REVISION:
220
 
            # explicit limit of no revisions needed
221
 
            return None
222
 
        if (self._last_revision is not None and
223
 
            self.to_repository.has_revision(self._last_revision)):
224
 
            return None
225
 
        try:
226
 
            return self.to_repository.search_missing_revision_ids(
227
 
                self.from_repository, self._last_revision,
228
 
                find_ghosts=self.find_ghosts)
229
 
        except errors.NoSuchRevision, e:
230
 
            raise InstallFailed([self._last_revision])
231
 
 
232
 
    def _fetch_inventory_weave(self, revs, pb):
233
 
        pb.update("fetch inventory", 0, 2)
234
 
        to_weave = self.to_repository.inventories
235
 
        # just merge, this is optimisable and its means we don't
236
 
        # copy unreferenced data such as not-needed inventories.
237
 
        pb.update("fetch inventory", 1, 3)
238
 
        from_weave = self.from_repository.inventories
239
 
        pb.update("fetch inventory", 2, 3)
240
 
        # we fetch only the referenced inventories because we do not
241
 
        # know for unselected inventories whether all their required
242
 
        # texts are present in the other repository - it could be
243
 
        # corrupt.
244
 
        to_weave.insert_record_stream(from_weave.get_record_stream(
245
 
            [(rev_id,) for rev_id in revs],
246
 
            self.to_repository._fetch_order,
247
 
            not self.to_repository._fetch_uses_deltas))
248
 
 
249
 
    def _fetch_revision_texts(self, revs, pb):
250
 
        # fetch signatures first and then the revision texts
251
 
        # may need to be a InterRevisionStore call here.
252
 
        to_sf = self.to_repository.signatures
253
 
        from_sf = self.from_repository.signatures
254
 
        # A missing signature is just skipped.
255
 
        to_sf.insert_record_stream(filter_absent(from_sf.get_record_stream(
256
 
            [(rev_id,) for rev_id in revs],
257
 
            self.to_repository._fetch_order,
258
 
            not self.to_repository._fetch_uses_deltas)))
259
 
        self._fetch_just_revision_texts(revs)
260
 
 
261
 
    def _fetch_just_revision_texts(self, version_ids):
262
 
        to_rf = self.to_repository.revisions
263
 
        from_rf = self.from_repository.revisions
264
 
        # If a revision has a delta, this is actually expanded inside the
265
 
        # insert_record_stream code now, which is an alternate fix for
266
 
        # bug #261339
267
 
        to_rf.insert_record_stream(from_rf.get_record_stream(
268
 
            [(rev_id,) for rev_id in version_ids],
269
 
            self.to_repository._fetch_order,
270
 
            not self.to_repository._fetch_uses_deltas))
271
 
 
272
 
    def _generate_root_texts(self, revs):
273
 
        """This will be called by __fetch between fetching weave texts and
274
 
        fetching the inventory weave.
275
 
 
276
 
        Subclasses should override this if they need to generate root texts
277
 
        after fetching weave texts.
278
 
        """
279
 
        pass
280
 
 
281
 
 
282
 
class Inter1and2Helper(object):
283
 
    """Helper for operations that convert data from model 1 and 2
284
 
    
285
 
    This is for use by fetchers and converters.
286
 
    """
287
 
 
288
 
    def __init__(self, source, target):
289
 
        """Constructor.
290
 
 
291
 
        :param source: The repository data comes from
292
 
        :param target: The repository data goes to
293
 
        """
294
 
        self.source = source
295
 
        self.target = target
296
 
 
297
 
    def iter_rev_trees(self, revs):
298
 
        """Iterate through RevisionTrees efficiently.
299
 
 
300
 
        Additionally, the inventory's revision_id is set if unset.
301
 
 
302
 
        Trees are retrieved in batches of 100, and then yielded in the order
303
 
        they were requested.
304
 
 
305
 
        :param revs: A list of revision ids
306
 
        """
307
 
        # In case that revs is not a list.
308
 
        revs = list(revs)
309
 
        while revs:
310
 
            for tree in self.source.revision_trees(revs[:100]):
311
 
                if tree.inventory.revision_id is None:
312
 
                    tree.inventory.revision_id = tree.get_revision_id()
313
 
                yield tree
314
 
            revs = revs[100:]
315
 
 
316
 
    def _find_root_ids(self, revs, parent_map, graph):
317
 
        revision_root = {}
318
 
        planned_versions = {}
319
 
        for tree in self.iter_rev_trees(revs):
320
 
            revision_id = tree.inventory.root.revision
321
 
            root_id = tree.get_root_id()
322
 
            planned_versions.setdefault(root_id, []).append(revision_id)
323
 
            revision_root[revision_id] = root_id
324
 
        # Find out which parents we don't already know root ids for
325
 
        parents = set()
326
 
        for revision_parents in parent_map.itervalues():
327
 
            parents.update(revision_parents)
328
 
        parents.difference_update(revision_root.keys() + [NULL_REVISION])
329
 
        # Limit to revisions present in the versionedfile
330
 
        parents = graph.get_parent_map(parents).keys()
331
 
        for tree in self.iter_rev_trees(parents):
332
 
            root_id = tree.get_root_id()
333
 
            revision_root[tree.get_revision_id()] = root_id
334
 
        return revision_root, planned_versions
335
 
 
336
 
    def generate_root_texts(self, revs):
337
 
        """Generate VersionedFiles for all root ids.
338
 
 
339
 
        :param revs: the revisions to include
340
 
        """
341
 
        to_texts = self.target.texts
342
 
        graph = self.source.get_graph()
343
 
        parent_map = graph.get_parent_map(revs)
344
 
        rev_order = topo_sort(parent_map)
345
 
        rev_id_to_root_id, root_id_to_rev_ids = self._find_root_ids(
346
 
            revs, parent_map, graph)
347
 
        root_id_order = [(rev_id_to_root_id[rev_id], rev_id) for rev_id in
348
 
            rev_order]
349
 
        # Guaranteed stable, this groups all the file id operations together
350
 
        # retaining topological order within the revisions of a file id.
351
 
        # File id splits and joins would invalidate this, but they don't exist
352
 
        # yet, and are unlikely to in non-rich-root environments anyway.
353
 
        root_id_order.sort(key=operator.itemgetter(0))
354
 
        # Create a record stream containing the roots to create.
355
 
        def yield_roots():
356
 
            for key in root_id_order:
357
 
                root_id, rev_id = key
358
 
                rev_parents = parent_map[rev_id]
359
 
                # We drop revision parents with different file-ids, because
360
 
                # that represents a rename of the root to a different location
361
 
                # - its not actually a parent for us. (We could look for that
362
 
                # file id in the revision tree at considerably more expense,
363
 
                # but for now this is sufficient (and reconcile will catch and
364
 
                # correct this anyway).
365
 
                # When a parent revision is a ghost, we guess that its root id
366
 
                # was unchanged (rather than trimming it from the parent list).
367
 
                parent_keys = tuple((root_id, parent) for parent in rev_parents
368
 
                    if parent != NULL_REVISION and
369
 
                        rev_id_to_root_id.get(parent, root_id) == root_id)
370
 
                yield FulltextContentFactory(key, parent_keys, None, '')
371
 
        to_texts.insert_record_stream(yield_roots())
372
 
 
373
 
    def regenerate_inventory(self, revs):
374
 
        """Generate a new inventory versionedfile in target, convertin data.
375
 
        
376
 
        The inventory is retrieved from the source, (deserializing it), and
377
 
        stored in the target (reserializing it in a different format).
378
 
        :param revs: The revisions to include
379
 
        """
380
 
        for tree in self.iter_rev_trees(revs):
381
 
            parents = tree.get_parent_ids()
382
 
            self.target.add_inventory(tree.get_revision_id(), tree.inventory,
383
 
                                      parents)
384
 
 
385
 
    def fetch_revisions(self, revision_ids):
386
 
        # TODO: should this batch them up rather than requesting 10,000
387
 
        #       revisions at once?
388
 
        for revision in self.source.get_revisions(revision_ids):
389
 
            self.target.add_revision(revision.revision_id, revision)
390
 
 
391
 
 
392
 
class Model1toKnit2Fetcher(RepoFetcher):
393
 
    """Fetch from a Model1 repository into a Knit2 repository
394
 
    """
395
 
    def __init__(self, to_repository, from_repository, last_revision=None,
396
 
                 pb=None, find_ghosts=True):
397
 
        self.helper = Inter1and2Helper(from_repository, to_repository)
398
 
        RepoFetcher.__init__(self, to_repository, from_repository,
399
 
            last_revision, pb, find_ghosts)
400
 
 
401
 
    def _generate_root_texts(self, revs):
402
 
        self.helper.generate_root_texts(revs)
403
 
 
404
 
    def _fetch_inventory_weave(self, revs, pb):
405
 
        self.helper.regenerate_inventory(revs)
406
 
 
407
 
    def _fetch_revision_texts(self, revs, pb):
408
 
        """Fetch revision object texts"""
409
 
        count = 0
410
 
        total = len(revs)
411
 
        for rev in revs:
412
 
            pb.update('copying revisions', count, total)
413
 
            try:
414
 
                sig_text = self.from_repository.get_signature_text(rev)
415
 
                self.to_repository.add_signature_text(rev, sig_text)
416
 
            except errors.NoSuchRevision:
417
 
                # not signed.
418
 
                pass
419
 
            self._copy_revision(rev)
420
 
            count += 1
421
 
 
422
 
    def _copy_revision(self, rev):
423
 
        self.helper.fetch_revisions([rev])
424
 
 
425
 
 
426
 
class Knit1to2Fetcher(RepoFetcher):
427
 
    """Fetch from a Knit1 repository into a Knit2 repository"""
428
 
 
429
 
    def __init__(self, to_repository, from_repository, last_revision=None,
430
 
                 pb=None, find_ghosts=True):
431
 
        self.helper = Inter1and2Helper(from_repository, to_repository)
432
 
        RepoFetcher.__init__(self, to_repository, from_repository,
433
 
            last_revision, pb, find_ghosts)
434
 
 
435
 
    def _generate_root_texts(self, revs):
436
 
        self.helper.generate_root_texts(revs)
437
 
 
438
 
    def _fetch_inventory_weave(self, revs, pb):
439
 
        self.helper.regenerate_inventory(revs)
440
 
 
441
 
    def _fetch_just_revision_texts(self, version_ids):
442
 
        self.helper.fetch_revisions(version_ids)
 
104
        try:
 
105
            self.last_revision = self._find_last_revision(last_revision)
 
106
        except NoSuchRevision, e:
 
107
            mutter('failed getting last revision: %s', e)
 
108
            raise InstallFailed([last_revision])
 
109
        mutter('fetch up to rev {%s}', self.last_revision)
 
110
        try:
 
111
            revs_to_fetch = self._compare_ancestries()
 
112
        except WeaveError:
 
113
            raise InstallFailed([self.last_revision])
 
114
        self._copy_revisions(revs_to_fetch)
 
115
        self.new_ancestry = revs_to_fetch
 
116
 
 
117
 
 
118
    def _find_last_revision(self, last_revision):
 
119
        """Find the limiting source revision.
 
120
 
 
121
        Every ancestor of that revision will be merged across.
 
122
 
 
123
        Returns the revision_id, or returns None if there's no history
 
124
        in the source branch."""
 
125
        self.pb.update('get source history')
 
126
        from_history = self.from_branch.revision_history()
 
127
        self.pb.update('get destination history')
 
128
        if last_revision:
 
129
            self.from_branch.get_revision(last_revision)
 
130
            return last_revision
 
131
        elif from_history:
 
132
            return from_history[-1]
 
133
        else:
 
134
            return None                 # no history in the source branch
 
135
            
 
136
 
 
137
    def _compare_ancestries(self):
 
138
        """Get a list of revisions that must be copied.
 
139
 
 
140
        That is, every revision that's in the ancestry of the source
 
141
        branch and not in the destination branch."""
 
142
        self.pb.update('get source ancestry')
 
143
        self.from_ancestry = self.from_branch.get_ancestry(self.last_revision)
 
144
 
 
145
        dest_last_rev = self.to_branch.last_revision()
 
146
        self.pb.update('get destination ancestry')
 
147
        if dest_last_rev:
 
148
            dest_ancestry = self.to_branch.get_ancestry(dest_last_rev)
 
149
        else:
 
150
            dest_ancestry = []
 
151
        ss = set(dest_ancestry)
 
152
        to_fetch = []
 
153
        for rev_id in self.from_ancestry:
 
154
            if rev_id not in ss:
 
155
                to_fetch.append(rev_id)
 
156
                mutter('need to get revision {%s}', rev_id)
 
157
        mutter('need to get %d revisions in total', len(to_fetch))
 
158
        self.count_total = len(to_fetch)
 
159
        return to_fetch
 
160
 
 
161
    def _copy_revisions(self, revs_to_fetch):
 
162
        i = 0
 
163
        for rev_id in revs_to_fetch:
 
164
            i += 1
 
165
            if rev_id is None:
 
166
                continue
 
167
            if self.to_branch.has_revision(rev_id):
 
168
                continue
 
169
            self.pb.update('fetch revision', i, self.count_total)
 
170
            self._copy_one_revision(rev_id)
 
171
            self.count_copied += 1
 
172
 
 
173
 
 
174
    def _copy_one_revision(self, rev_id):
 
175
        """Copy revision and everything referenced by it."""
 
176
        mutter('copying revision {%s}', rev_id)
 
177
        rev_xml = self.from_branch.get_revision_xml(rev_id)
 
178
        inv_xml = self.from_branch.get_inventory_xml(rev_id)
 
179
        rev = serializer_v5.read_revision_from_string(rev_xml)
 
180
        inv = serializer_v5.read_inventory_from_string(inv_xml)
 
181
        assert rev.revision_id == rev_id
 
182
        assert rev.inventory_sha1 == sha_string(inv_xml)
 
183
        mutter('  commiter %s, %d parents',
 
184
               rev.committer,
 
185
               len(rev.parent_ids))
 
186
        self._copy_new_texts(rev_id, inv)
 
187
        parents = rev.parent_ids
 
188
        for parent in parents:
 
189
            if not self.to_branch.has_revision(parent):
 
190
                parents.pop(parents.index(parent))
 
191
        self._copy_inventory(rev_id, inv_xml, parents)
 
192
        self._copy_ancestry(rev_id, parents)
 
193
        self.to_branch.revision_store.add(StringIO(rev_xml), rev_id)
 
194
 
 
195
 
 
196
    def _copy_inventory(self, rev_id, inv_xml, parent_ids):
 
197
        self.to_control.add_text('inventory', rev_id,
 
198
                                split_lines(inv_xml), parent_ids)
 
199
 
 
200
 
 
201
    def _copy_ancestry(self, rev_id, parent_ids):
 
202
        ancestry_lines = self.from_control.get_lines('ancestry', rev_id)
 
203
        self.to_control.add_text('ancestry', rev_id, ancestry_lines,
 
204
                                 parent_ids)
 
205
 
 
206
        
 
207
    def _copy_new_texts(self, rev_id, inv):
 
208
        """Copy any new texts occuring in this revision."""
 
209
        # TODO: Rather than writing out weaves every time, hold them
 
210
        # in memory until everything's done?  But this way is nicer
 
211
        # if it's interrupted.
 
212
        for path, ie in inv.iter_entries():
 
213
            if ie.kind != 'file':
 
214
                continue
 
215
            if ie.revision != rev_id:
 
216
                continue
 
217
            mutter('%s {%s} is changed in this revision',
 
218
                   path, ie.file_id)
 
219
            self._copy_one_text(rev_id, ie.file_id)
 
220
 
 
221
 
 
222
    def _copy_one_text(self, rev_id, file_id):
 
223
        """Copy one file text."""
 
224
        mutter('copy text version {%s} of file {%s}',
 
225
               rev_id, file_id)
 
226
        from_weave = self.from_weaves.get_weave(file_id)
 
227
        from_idx = from_weave.lookup(rev_id)
 
228
        from_parents = map(from_weave.idx_to_name, from_weave.parents(from_idx))
 
229
        text_lines = from_weave.get(from_idx)
 
230
        to_weave = self.to_weaves.get_weave_or_empty(file_id)
 
231
        to_parents = map(to_weave.lookup, from_parents)
 
232
        # it's ok to add even if the text is already there
 
233
        to_weave.add(rev_id, to_parents, text_lines)
 
234
        self.to_weaves.put_weave(file_id, to_weave)
 
235
        self.count_texts += 1
 
236
 
 
237
 
 
238
fetch = Fetcher