← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bundle/serializer/v4.py

  • Committer: Patch Queue Manager
  • Date: 2016-04-21 04:10:52 UTC
  • mfrom: (6616.1.1 fix-en-user-guide)
  • Revision ID: pqm@pqm.ubuntu.com-20160421041052-clcye7ns1qcl2n7w
(richard-wilbur) Ensure build of English use guide always uses English text
 even when user's locale specifies a different language. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bundle/serializer/v4.py
1
 
# Copyright (C) 2007 Canonical Ltd
 
1
# Copyright (C) 2007-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
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
from __future__ import absolute_import
16
18
 
17
19
from cStringIO import StringIO
18
20
import bz2
19
21
import re
20
22
 
21
23
from bzrlib import (
22
 
    diff,
23
24
    errors,
24
25
    iterablefile,
 
26
    lru_cache,
25
27
    multiparent,
26
28
    osutils,
27
29
    pack,
28
30
    revision as _mod_revision,
 
31
    serializer,
29
32
    trace,
30
 
    xml_serializer,
 
33
    ui,
 
34
    versionedfile as _mod_versionedfile,
31
35
    )
32
 
from bzrlib.bundle import bundle_data, serializer
33
 
from bzrlib.util import bencode
 
36
from bzrlib.bundle import bundle_data, serializer as bundle_serializer
 
37
from bzrlib.i18n import ngettext
 
38
from bzrlib import bencode
 
39
 
 
40
 
 
41
class _MPDiffInventoryGenerator(_mod_versionedfile._MPDiffGenerator):
 
42
    """Generate Inventory diffs serialized inventories."""
 
43
 
 
44
    def __init__(self, repo, inventory_keys):
 
45
        super(_MPDiffInventoryGenerator, self).__init__(repo.inventories,
 
46
            inventory_keys)
 
47
        self.repo = repo
 
48
        self.sha1s = {}
 
49
 
 
50
    def iter_diffs(self):
 
51
        """Compute the diffs one at a time."""
 
52
        # This is instead of compute_diffs() since we guarantee our ordering of
 
53
        # inventories, we don't have to do any buffering
 
54
        self._find_needed_keys()
 
55
        # We actually use a slightly different ordering. We grab all of the
 
56
        # parents first, and then grab the ordered requests.
 
57
        needed_ids = [k[-1] for k in self.present_parents]
 
58
        needed_ids.extend([k[-1] for k in self.ordered_keys])
 
59
        inv_to_str = self.repo._serializer.write_inventory_to_string
 
60
        for inv in self.repo.iter_inventories(needed_ids):
 
61
            revision_id = inv.revision_id
 
62
            key = (revision_id,)
 
63
            if key in self.present_parents:
 
64
                # Not a key we will transmit, which is a shame, since because
 
65
                # of that bundles don't work with stacked branches
 
66
                parent_ids = None
 
67
            else:
 
68
                parent_ids = [k[-1] for k in self.parent_map[key]]
 
69
            as_bytes = inv_to_str(inv)
 
70
            self._process_one_record(key, (as_bytes,))
 
71
            if parent_ids is None:
 
72
                continue
 
73
            diff = self.diffs.pop(key)
 
74
            sha1 = osutils.sha_string(as_bytes)
 
75
            yield revision_id, parent_ids, sha1, diff
34
76
 
35
77
 
36
78
class BundleWriter(object):
54
96
 
55
97
    def begin(self):
56
98
        """Start writing the bundle"""
57
 
        self._fileobj.write(serializer._get_bundle_header(
58
 
            serializer.v4_string))
 
99
        self._fileobj.write(bundle_serializer._get_bundle_header(
 
100
            bundle_serializer.v4_string))
59
101
        self._fileobj.write('#\n')
60
102
        self._container.begin()
61
103
 
107
149
    @staticmethod
108
150
    def encode_name(content_kind, revision_id, file_id=None):
109
151
        """Encode semantic ids as a container name"""
110
 
        assert content_kind in ('revision', 'file', 'inventory', 'signature',
111
 
                                'info')
112
 
 
 
152
        if content_kind not in ('revision', 'file', 'inventory', 'signature',
 
153
                'info'):
 
154
            raise ValueError(content_kind)
113
155
        if content_kind == 'file':
114
 
            assert file_id is not None
 
156
            if file_id is None:
 
157
                raise AssertionError()
115
158
        else:
116
 
            assert file_id is None
 
159
            if file_id is not None:
 
160
                raise AssertionError()
117
161
        if content_kind == 'info':
118
 
            assert revision_id is None
119
 
        else:
120
 
            assert revision_id is not None
 
162
            if revision_id is not None:
 
163
                raise AssertionError()
 
164
        elif revision_id is None:
 
165
            raise AssertionError()
121
166
        names = [n.replace('/', '//') for n in
122
167
                 (content_kind, revision_id, file_id) if n is not None]
123
168
        return '/'.join(names)
160
205
            source_file = iterablefile.IterableFile(self.iter_decode(fileobj))
161
206
        else:
162
207
            source_file = StringIO(bz2.decompress(fileobj.read()))
163
 
        self._container = pack.ContainerReader(source_file)
 
208
        self._container_file = source_file
164
209
 
165
210
    @staticmethod
166
211
    def iter_decode(fileobj):
167
212
        """Iterate through decoded fragments of the file"""
168
213
        decompressor = bz2.BZ2Decompressor()
169
214
        for line in fileobj:
170
 
            yield decompressor.decompress(line)
 
215
            try:
 
216
                yield decompressor.decompress(line)
 
217
            except EOFError:
 
218
                return
171
219
 
172
220
    @staticmethod
173
221
    def decode_name(name):
199
247
        :return: a generator of (bytes, metadata, content_kind, revision_id,
200
248
            file_id)
201
249
        """
202
 
        iterator = self._container.iter_records()
203
 
        for names, meta_bytes in iterator:
 
250
        iterator = pack.iter_records_from_file(self._container_file)
 
251
        for names, bytes in iterator:
204
252
            if len(names) != 1:
205
253
                raise errors.BadBundle('Record has %d names instead of 1'
206
254
                                       % len(names))
207
 
            metadata = bencode.bdecode(meta_bytes(None))
 
255
            metadata = bencode.bdecode(bytes)
208
256
            if metadata['storage_kind'] == 'header':
209
257
                bytes = None
210
258
            else:
211
259
                _unused, bytes = iterator.next()
212
 
                bytes = bytes(None)
213
260
            yield (bytes, metadata) + self.decode_name(names[0][0])
214
261
 
215
262
 
216
 
class BundleSerializerV4(serializer.BundleSerializer):
 
263
class BundleSerializerV4(bundle_serializer.BundleSerializer):
217
264
    """Implement the high-level bundle interface"""
218
265
 
219
266
    def write(self, repository, revision_ids, forced_bases, fileobj):
245
292
    @staticmethod
246
293
    def get_source_serializer(info):
247
294
        """Retrieve the serializer for a given info object"""
248
 
        return xml_serializer.format_registry.get(info['serializer'])
 
295
        return serializer.format_registry.get(info['serializer'])
249
296
 
250
297
 
251
298
class BundleWriteOperation(object):
265
312
        self.repository = repository
266
313
        bundle = BundleWriter(fileobj)
267
314
        self.bundle = bundle
268
 
        self.base_ancestry = set(repository.get_ancestry(base,
269
 
                                                         topo_sorted=False))
270
315
        if revision_ids is not None:
271
316
            self.revision_ids = revision_ids
272
317
        else:
273
 
            revision_ids = set(repository.get_ancestry(target,
274
 
                                                       topo_sorted=False))
275
 
            self.revision_ids = revision_ids.difference(self.base_ancestry)
 
318
            graph = repository.get_graph()
 
319
            revision_ids = graph.find_unique_ancestors(target, [base])
 
320
            # Strip ghosts
 
321
            parents = graph.get_parent_map(revision_ids)
 
322
            self.revision_ids = [r for r in revision_ids if r in parents]
 
323
        self.revision_keys = set([(revid,) for revid in self.revision_ids])
276
324
 
277
325
    def do_write(self):
278
326
        """Write all data to the bundle"""
279
 
        self.bundle.begin()
280
 
        self.write_info()
281
 
        self.write_files()
282
 
        self.write_revisions()
283
 
        self.bundle.end()
 
327
        trace.note(ngettext('Bundling %d revision.', 'Bundling %d revisions.',
 
328
                            len(self.revision_ids)), len(self.revision_ids))
 
329
        self.repository.lock_read()
 
330
        try:
 
331
            self.bundle.begin()
 
332
            self.write_info()
 
333
            self.write_files()
 
334
            self.write_revisions()
 
335
            self.bundle.end()
 
336
        finally:
 
337
            self.repository.unlock()
284
338
        return self.revision_ids
285
339
 
286
340
    def write_info(self):
291
345
        self.bundle.add_info_record(serializer=serializer_format,
292
346
                                    supports_rich_root=supports_rich_root)
293
347
 
294
 
    def iter_file_revisions(self):
295
 
        """Iterate through all relevant revisions of all files.
296
 
 
297
 
        This is the correct implementation, but is not compatible with bzr.dev,
298
 
        because certain old revisions were not converted correctly, and have
299
 
        the wrong "revision" marker in inventories.
300
 
        """
301
 
        transaction = self.repository.get_transaction()
302
 
        altered = self.repository.fileids_altered_by_revision_ids(
303
 
            self.revision_ids)
304
 
        for file_id, file_revision_ids in altered.iteritems():
305
 
            vf = self.repository.weave_store.get_weave(file_id, transaction)
306
 
            yield vf, file_id, file_revision_ids
307
 
 
308
 
    def iter_file_revisions_aggressive(self):
309
 
        """Iterate through all relevant revisions of all files.
310
 
 
311
 
        This uses the standard iter_file_revisions to determine what revisions
312
 
        are referred to by inventories, but then uses the versionedfile to
313
 
        determine what the build-dependencies of each required revision.
314
 
 
315
 
        All build dependencies which are not ancestors of the base revision
316
 
        are emitted.
317
 
        """
318
 
        for vf, file_id, file_revision_ids in self.iter_file_revisions():
319
 
            new_revision_ids = set()
320
 
            pending = list(file_revision_ids)
321
 
            while len(pending) > 0:
322
 
                revision_id = pending.pop()
323
 
                if revision_id in new_revision_ids:
324
 
                    continue
325
 
                if revision_id in self.base_ancestry:
326
 
                    continue
327
 
                new_revision_ids.add(revision_id)
328
 
                pending.extend(vf.get_parents(revision_id))
329
 
            yield vf, file_id, new_revision_ids
330
 
 
331
348
    def write_files(self):
332
349
        """Write bundle records for all revisions of all files"""
333
 
        for vf, file_id, revision_ids in self.iter_file_revisions():
334
 
            self.add_mp_records('file', file_id, vf, revision_ids)
 
350
        text_keys = []
 
351
        altered_fileids = self.repository.fileids_altered_by_revision_ids(
 
352
                self.revision_ids)
 
353
        for file_id, revision_ids in altered_fileids.iteritems():
 
354
            for revision_id in revision_ids:
 
355
                text_keys.append((file_id, revision_id))
 
356
        self._add_mp_records_keys('file', self.repository.texts, text_keys)
335
357
 
336
358
    def write_revisions(self):
337
359
        """Write bundle records for all revisions and signatures"""
338
 
        inv_vf = self.repository.get_inventory_weave()
339
 
        revision_order = list(multiparent.topo_iter(inv_vf, self.revision_ids))
 
360
        inv_vf = self.repository.inventories
 
361
        topological_order = [key[-1] for key in multiparent.topo_iter_keys(
 
362
                                inv_vf, self.revision_keys)]
 
363
        revision_order = topological_order
340
364
        if self.target is not None and self.target in self.revision_ids:
 
365
            # Make sure the target revision is always the last entry
 
366
            revision_order = list(topological_order)
341
367
            revision_order.remove(self.target)
342
368
            revision_order.append(self.target)
343
 
        self.add_mp_records('inventory', None, inv_vf, revision_order)
344
 
        parents_list = self.repository.get_parents(revision_order)
345
 
        for parents, revision_id in zip(parents_list, revision_order):
346
 
            revision_text = self.repository.get_revision_xml(revision_id)
 
369
        if self.repository._serializer.support_altered_by_hack:
 
370
            # Repositories that support_altered_by_hack means that
 
371
            # inventories.make_mpdiffs() contains all the data about the tree
 
372
            # shape. Formats without support_altered_by_hack require
 
373
            # chk_bytes/etc, so we use a different code path.
 
374
            self._add_mp_records_keys('inventory', inv_vf,
 
375
                                      [(revid,) for revid in topological_order])
 
376
        else:
 
377
            # Inventories should always be added in pure-topological order, so
 
378
            # that we can apply the mpdiff for the child to the parent texts.
 
379
            self._add_inventory_mpdiffs_from_serializer(topological_order)
 
380
        self._add_revision_texts(revision_order)
 
381
 
 
382
    def _add_inventory_mpdiffs_from_serializer(self, revision_order):
 
383
        """Generate mpdiffs by serializing inventories.
 
384
 
 
385
        The current repository only has part of the tree shape information in
 
386
        the 'inventories' vf. So we use serializer.write_inventory_to_string to
 
387
        get a 'full' representation of the tree shape, and then generate
 
388
        mpdiffs on that data stream. This stream can then be reconstructed on
 
389
        the other side.
 
390
        """
 
391
        inventory_key_order = [(r,) for r in revision_order]
 
392
        generator = _MPDiffInventoryGenerator(self.repository,
 
393
                                              inventory_key_order)
 
394
        for revision_id, parent_ids, sha1, diff in generator.iter_diffs():
 
395
            text = ''.join(diff.to_patch())
 
396
            self.bundle.add_multiparent_record(text, sha1, parent_ids,
 
397
                                               'inventory', revision_id, None)
 
398
 
 
399
    def _add_revision_texts(self, revision_order):
 
400
        parent_map = self.repository.get_parent_map(revision_order)
 
401
        revision_to_str = self.repository._serializer.write_revision_to_string
 
402
        revisions = self.repository.get_revisions(revision_order)
 
403
        for revision in revisions:
 
404
            revision_id = revision.revision_id
 
405
            parents = parent_map.get(revision_id, None)
 
406
            revision_text = revision_to_str(revision)
347
407
            self.bundle.add_fulltext_record(revision_text, parents,
348
408
                                       'revision', revision_id)
349
409
            try:
368
428
                base = parents[0]
369
429
        return base, target
370
430
 
371
 
    def add_mp_records(self, repo_kind, file_id, vf, revision_ids):
 
431
    def _add_mp_records_keys(self, repo_kind, vf, keys):
372
432
        """Add multi-parent diff records to a bundle"""
373
 
        revision_ids = list(multiparent.topo_iter(vf, revision_ids))
374
 
        mpdiffs = vf.make_mpdiffs(revision_ids)
375
 
        sha1s = vf.get_sha1s(revision_ids)
376
 
        for mpdiff, revision_id, sha1, in zip(mpdiffs, revision_ids, sha1s):
377
 
            parents = vf.get_parents(revision_id)
 
433
        ordered_keys = list(multiparent.topo_iter_keys(vf, keys))
 
434
        mpdiffs = vf.make_mpdiffs(ordered_keys)
 
435
        sha1s = vf.get_sha1s(ordered_keys)
 
436
        parent_map = vf.get_parent_map(ordered_keys)
 
437
        for mpdiff, item_key, in zip(mpdiffs, ordered_keys):
 
438
            sha1 = sha1s[item_key]
 
439
            parents = [key[-1] for key in parent_map[item_key]]
378
440
            text = ''.join(mpdiff.to_patch())
 
441
            # Infer file id records as appropriate.
 
442
            if len(item_key) == 2:
 
443
                file_id = item_key[0]
 
444
            else:
 
445
                file_id = None
379
446
            self.bundle.add_multiparent_record(text, sha1, parents, repo_kind,
380
 
                                               revision_id, file_id)
 
447
                                               item_key[-1], file_id)
381
448
 
382
449
 
383
450
class BundleInfoV4(object):
467
534
 
468
535
    def install(self):
469
536
        """Perform the installation.
470
 
        
 
537
 
471
538
        Must be called with the Repository locked.
472
539
        """
473
540
        self._repository.start_write_group()
490
557
        for bytes, metadata, repo_kind, revision_id, file_id in\
491
558
            self._container.iter_records():
492
559
            if repo_kind == 'info':
493
 
                assert self._info is None
 
560
                if self._info is not None:
 
561
                    raise AssertionError()
494
562
                self._handle_info(metadata)
495
 
            if (repo_kind, file_id) != ('file', current_file):
496
 
                if len(pending_file_records) > 0:
497
 
                    self._install_mp_records(current_versionedfile,
498
 
                                             pending_file_records)
 
563
            if (pending_file_records and
 
564
                (repo_kind, file_id) != ('file', current_file)):
 
565
                # Flush the data for a single file - prevents memory
 
566
                # spiking due to buffering all files in memory.
 
567
                self._install_mp_records_keys(self._repository.texts,
 
568
                    pending_file_records)
499
569
                current_file = None
500
 
                current_versionedfile = None
501
 
                pending_file_records = []
 
570
                del pending_file_records[:]
502
571
            if len(pending_inventory_records) > 0 and repo_kind != 'inventory':
503
 
                self._install_inventory_records(inventory_vf,
504
 
                                                pending_inventory_records)
 
572
                self._install_inventory_records(pending_inventory_records)
505
573
                pending_inventory_records = []
506
574
            if repo_kind == 'inventory':
507
 
                if inventory_vf is None:
508
 
                    inventory_vf = self._repository.get_inventory_weave()
509
 
                if revision_id not in inventory_vf:
510
 
                    pending_inventory_records.append((revision_id, metadata,
511
 
                                                      bytes))
 
575
                pending_inventory_records.append(((revision_id,), metadata, bytes))
512
576
            if repo_kind == 'revision':
513
577
                target_revision = revision_id
514
578
                self._install_revision(revision_id, metadata, bytes)
516
580
                self._install_signature(revision_id, metadata, bytes)
517
581
            if repo_kind == 'file':
518
582
                current_file = file_id
519
 
                if current_versionedfile is None:
520
 
                    current_versionedfile = \
521
 
                        self._repository.weave_store.get_weave_or_empty(
522
 
                        file_id, self._repository.get_transaction())
523
 
                    pending_file_records = []
524
 
                if revision_id in current_versionedfile:
525
 
                    continue
526
 
                pending_file_records.append((revision_id, metadata, bytes))
527
 
        self._install_mp_records(current_versionedfile, pending_file_records)
 
583
                pending_file_records.append(((file_id, revision_id), metadata, bytes))
 
584
        self._install_mp_records_keys(self._repository.texts, pending_file_records)
528
585
        return target_revision
529
586
 
530
587
    def _handle_info(self, info):
545
602
                      records if r not in versionedfile]
546
603
        versionedfile.add_mpdiffs(vf_records)
547
604
 
548
 
    def _install_inventory_records(self, vf, records):
549
 
        if self._info['serializer'] == self._repository._serializer.format_num:
550
 
            return self._install_mp_records(vf, records)
551
 
        for revision_id, metadata, bytes in records:
552
 
            parent_ids = metadata['parents']
553
 
            parents = [self._repository.get_inventory(p)
554
 
                       for p in parent_ids]
555
 
            p_texts = [self._source_serializer.write_inventory_to_string(p)
556
 
                       for p in parents]
557
 
            target_lines = multiparent.MultiParent.from_patch(bytes).to_lines(
558
 
                p_texts)
559
 
            sha1 = osutils.sha_strings(target_lines)
560
 
            if sha1 != metadata['sha1']:
561
 
                raise errors.BadBundle("Can't convert to target format")
562
 
            target_inv = self._source_serializer.read_inventory_from_string(
563
 
                ''.join(target_lines))
564
 
            self._handle_root(target_inv, parent_ids)
565
 
            try:
566
 
                self._repository.add_inventory(revision_id, target_inv,
567
 
                                               parent_ids)
568
 
            except errors.UnsupportedInventoryKind:
569
 
                raise errors.IncompatibleRevision(repr(self._repository))
 
605
    def _install_mp_records_keys(self, versionedfile, records):
 
606
        d_func = multiparent.MultiParent.from_patch
 
607
        vf_records = []
 
608
        for key, meta, text in records:
 
609
            # Adapt to tuple interface: A length two key is a file_id,
 
610
            # revision_id pair, a length 1 key is a
 
611
            # revision/signature/inventory. We need to do this because
 
612
            # the metadata extraction from the bundle has not yet been updated
 
613
            # to use the consistent tuple interface itself.
 
614
            if len(key) == 2:
 
615
                prefix = key[:1]
 
616
            else:
 
617
                prefix = ()
 
618
            parents = [prefix + (parent,) for parent in meta['parents']]
 
619
            vf_records.append((key, parents, meta['sha1'], d_func(text)))
 
620
        versionedfile.add_mpdiffs(vf_records)
 
621
 
 
622
    def _get_parent_inventory_texts(self, inventory_text_cache,
 
623
                                    inventory_cache, parent_ids):
 
624
        cached_parent_texts = {}
 
625
        remaining_parent_ids = []
 
626
        for parent_id in parent_ids:
 
627
            p_text = inventory_text_cache.get(parent_id, None)
 
628
            if p_text is None:
 
629
                remaining_parent_ids.append(parent_id)
 
630
            else:
 
631
                cached_parent_texts[parent_id] = p_text
 
632
        ghosts = ()
 
633
        # TODO: Use inventory_cache to grab inventories we already have in
 
634
        #       memory
 
635
        if remaining_parent_ids:
 
636
            # first determine what keys are actually present in the local
 
637
            # inventories object (don't use revisions as they haven't been
 
638
            # installed yet.)
 
639
            parent_keys = [(r,) for r in remaining_parent_ids]
 
640
            present_parent_map = self._repository.inventories.get_parent_map(
 
641
                                        parent_keys)
 
642
            present_parent_ids = []
 
643
            ghosts = set()
 
644
            for p_id in remaining_parent_ids:
 
645
                if (p_id,) in present_parent_map:
 
646
                    present_parent_ids.append(p_id)
 
647
                else:
 
648
                    ghosts.add(p_id)
 
649
            to_string = self._source_serializer.write_inventory_to_string
 
650
            for parent_inv in self._repository.iter_inventories(
 
651
                                    present_parent_ids):
 
652
                p_text = to_string(parent_inv)
 
653
                inventory_cache[parent_inv.revision_id] = parent_inv
 
654
                cached_parent_texts[parent_inv.revision_id] = p_text
 
655
                inventory_text_cache[parent_inv.revision_id] = p_text
 
656
 
 
657
        parent_texts = [cached_parent_texts[parent_id]
 
658
                        for parent_id in parent_ids
 
659
                         if parent_id not in ghosts]
 
660
        return parent_texts
 
661
 
 
662
    def _install_inventory_records(self, records):
 
663
        if (self._info['serializer'] == self._repository._serializer.format_num
 
664
            and self._repository._serializer.support_altered_by_hack):
 
665
            return self._install_mp_records_keys(self._repository.inventories,
 
666
                records)
 
667
        # Use a 10MB text cache, since these are string xml inventories. Note
 
668
        # that 10MB is fairly small for large projects (a single inventory can
 
669
        # be >5MB). Another possibility is to cache 10-20 inventory texts
 
670
        # instead
 
671
        inventory_text_cache = lru_cache.LRUSizeCache(10*1024*1024)
 
672
        # Also cache the in-memory representation. This allows us to create
 
673
        # inventory deltas to apply rather than calling add_inventory from
 
674
        # scratch each time.
 
675
        inventory_cache = lru_cache.LRUCache(10)
 
676
        pb = ui.ui_factory.nested_progress_bar()
 
677
        try:
 
678
            num_records = len(records)
 
679
            for idx, (key, metadata, bytes) in enumerate(records):
 
680
                pb.update('installing inventory', idx, num_records)
 
681
                revision_id = key[-1]
 
682
                parent_ids = metadata['parents']
 
683
                # Note: This assumes the local ghosts are identical to the
 
684
                #       ghosts in the source, as the Bundle serialization
 
685
                #       format doesn't record ghosts.
 
686
                p_texts = self._get_parent_inventory_texts(inventory_text_cache,
 
687
                                                           inventory_cache,
 
688
                                                           parent_ids)
 
689
                # Why does to_lines() take strings as the source, it seems that
 
690
                # it would have to cast to a list of lines, which we get back
 
691
                # as lines and then cast back to a string.
 
692
                target_lines = multiparent.MultiParent.from_patch(bytes
 
693
                            ).to_lines(p_texts)
 
694
                inv_text = ''.join(target_lines)
 
695
                del target_lines
 
696
                sha1 = osutils.sha_string(inv_text)
 
697
                if sha1 != metadata['sha1']:
 
698
                    raise errors.BadBundle("Can't convert to target format")
 
699
                # Add this to the cache so we don't have to extract it again.
 
700
                inventory_text_cache[revision_id] = inv_text
 
701
                target_inv = self._source_serializer.read_inventory_from_string(
 
702
                    inv_text)
 
703
                self._handle_root(target_inv, parent_ids)
 
704
                parent_inv = None
 
705
                if parent_ids:
 
706
                    parent_inv = inventory_cache.get(parent_ids[0], None)
 
707
                try:
 
708
                    if parent_inv is None:
 
709
                        self._repository.add_inventory(revision_id, target_inv,
 
710
                                                       parent_ids)
 
711
                    else:
 
712
                        delta = target_inv._make_delta(parent_inv)
 
713
                        self._repository.add_inventory_by_delta(parent_ids[0],
 
714
                            delta, revision_id, parent_ids)
 
715
                except errors.UnsupportedInventoryKind:
 
716
                    raise errors.IncompatibleRevision(repr(self._repository))
 
717
                inventory_cache[revision_id] = target_inv
 
718
        finally:
 
719
            pb.finished()
570
720
 
571
721
    def _handle_root(self, target_inv, parent_ids):
572
722
        revision_id = target_inv.revision_id
573
723
        if self.update_root:
574
 
            target_inv.root.revision = revision_id
575
 
            store = self._repository.weave_store
576
 
            transaction = self._repository.get_transaction()
577
 
            vf = store.get_weave_or_empty(target_inv.root.file_id, transaction)
578
 
            vf.add_lines(revision_id, parent_ids, [])
 
724
            text_key = (target_inv.root.file_id, revision_id)
 
725
            parent_keys = [(target_inv.root.file_id, parent) for
 
726
                parent in parent_ids]
 
727
            self._repository.texts.add_lines(text_key, parent_keys, [])
579
728
        elif not self._repository.supports_rich_root():
580
729
            if target_inv.root.revision != revision_id:
581
730
                raise errors.IncompatibleRevision(repr(self._repository))
582
731
 
583
 
 
584
732
    def _install_revision(self, revision_id, metadata, text):
585
733
        if self._repository.has_revision(revision_id):
586
734
            return
587
 
        self._repository._add_revision_text(revision_id, text)
 
735
        revision = self._source_serializer.read_revision_from_string(text)
 
736
        self._repository.add_revision(revision.revision_id, revision)
588
737
 
589
738
    def _install_signature(self, revision_id, metadata, text):
590
739
        transaction = self._repository.get_transaction()
591
 
        if self._repository._revision_store.has_signature(revision_id,
592
 
                                                          transaction):
 
740
        if self._repository.has_signature_for_revision_id(revision_id):
593
741
            return
594
 
        self._repository._revision_store.add_revision_signature_text(
595
 
            revision_id, text, transaction)
 
742
        self._repository.add_signature_text(revision_id, text)