← 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: Aaron Bentley
  • Date: 2007-07-17 13:27:14 UTC
  • mfrom: (2624 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2631.
  • Revision ID: abentley@panoramicfeedback.com-20070717132714-tmzx9khmg9501k51
Merge from bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bundle/serializer/v4.py
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
from cStringIO import StringIO
18
18
import bz2
22
22
    diff,
23
23
    errors,
24
24
    iterablefile,
25
 
    lru_cache,
26
25
    multiparent,
27
26
    osutils,
28
27
    pack,
29
28
    revision as _mod_revision,
30
 
    serializer,
31
29
    trace,
32
 
    ui,
 
30
    xml_serializer,
33
31
    )
34
 
from bzrlib.bundle import bundle_data, serializer as bundle_serializer
35
 
from bzrlib import bencode
 
32
from bzrlib.bundle import bundle_data, serializer
 
33
from bzrlib.util import bencode
36
34
 
37
35
 
38
36
class BundleWriter(object):
56
54
 
57
55
    def begin(self):
58
56
        """Start writing the bundle"""
59
 
        self._fileobj.write(bundle_serializer._get_bundle_header(
60
 
            bundle_serializer.v4_string))
 
57
        self._fileobj.write(serializer._get_bundle_header(
 
58
            serializer.v4_string))
61
59
        self._fileobj.write('#\n')
62
60
        self._container.begin()
63
61
 
109
107
    @staticmethod
110
108
    def encode_name(content_kind, revision_id, file_id=None):
111
109
        """Encode semantic ids as a container name"""
112
 
        if content_kind not in ('revision', 'file', 'inventory', 'signature',
113
 
                'info'):
114
 
            raise ValueError(content_kind)
 
110
        assert content_kind in ('revision', 'file', 'inventory', 'signature',
 
111
                                'info')
 
112
 
115
113
        if content_kind == 'file':
116
 
            if file_id is None:
117
 
                raise AssertionError()
 
114
            assert file_id is not None
118
115
        else:
119
 
            if file_id is not None:
120
 
                raise AssertionError()
 
116
            assert file_id is None
121
117
        if content_kind == 'info':
122
 
            if revision_id is not None:
123
 
                raise AssertionError()
124
 
        elif revision_id is None:
125
 
            raise AssertionError()
 
118
            assert revision_id is None
 
119
        else:
 
120
            assert revision_id is not None
126
121
        names = [n.replace('/', '//') for n in
127
122
                 (content_kind, revision_id, file_id) if n is not None]
128
123
        return '/'.join(names)
136
131
        """
137
132
        name = self.encode_name(repo_kind, revision_id, file_id)
138
133
        encoded_metadata = bencode.bencode(metadata)
139
 
        self._container.add_bytes_record(encoded_metadata, [(name, )])
 
134
        self._container.add_bytes_record(encoded_metadata, [name])
140
135
        if metadata['storage_kind'] != 'header':
141
136
            self._container.add_bytes_record(bytes, [])
142
137
 
149
144
    body
150
145
    """
151
146
 
152
 
    def __init__(self, fileobj, stream_input=True):
153
 
        """Constructor
154
 
 
155
 
        :param fileobj: a file containing a bzip-encoded container
156
 
        :param stream_input: If True, the BundleReader stream input rather than
157
 
            reading it all into memory at once.  Reading it into memory all at
158
 
            once is (currently) faster.
159
 
        """
 
147
    def __init__(self, fileobj):
160
148
        line = fileobj.readline()
161
149
        if line != '\n':
162
150
            fileobj.readline()
163
151
        self.patch_lines = []
164
 
        if stream_input:
165
 
            source_file = iterablefile.IterableFile(self.iter_decode(fileobj))
166
 
        else:
167
 
            source_file = StringIO(bz2.decompress(fileobj.read()))
168
 
        self._container_file = source_file
 
152
        self._container = pack.ContainerReader(
 
153
            iterablefile.IterableFile(self.iter_decode(fileobj)))
169
154
 
170
155
    @staticmethod
171
156
    def iter_decode(fileobj):
172
157
        """Iterate through decoded fragments of the file"""
173
158
        decompressor = bz2.BZ2Decompressor()
174
159
        for line in fileobj:
175
 
            try:
176
 
                yield decompressor.decompress(line)
177
 
            except EOFError:
178
 
                return
 
160
            yield decompressor.decompress(line)
179
161
 
180
162
    @staticmethod
181
163
    def decode_name(name):
207
189
        :return: a generator of (bytes, metadata, content_kind, revision_id,
208
190
            file_id)
209
191
        """
210
 
        iterator = pack.iter_records_from_file(self._container_file)
211
 
        for names, bytes in iterator:
 
192
        iterator = self._container.iter_records()
 
193
        for names, meta_bytes in iterator:
212
194
            if len(names) != 1:
213
195
                raise errors.BadBundle('Record has %d names instead of 1'
214
196
                                       % len(names))
215
 
            metadata = bencode.bdecode(bytes)
 
197
            metadata = bencode.bdecode(meta_bytes(None))
216
198
            if metadata['storage_kind'] == 'header':
217
199
                bytes = None
218
200
            else:
219
201
                _unused, bytes = iterator.next()
220
 
            yield (bytes, metadata) + self.decode_name(names[0][0])
221
 
 
222
 
 
223
 
class BundleSerializerV4(bundle_serializer.BundleSerializer):
 
202
                bytes = bytes(None)
 
203
            yield (bytes, metadata) + self.decode_name(names[0])
 
204
 
 
205
 
 
206
class BundleSerializerV4(serializer.BundleSerializer):
224
207
    """Implement the high-level bundle interface"""
225
208
 
226
209
    def write(self, repository, revision_ids, forced_bases, fileobj):
252
235
    @staticmethod
253
236
    def get_source_serializer(info):
254
237
        """Retrieve the serializer for a given info object"""
255
 
        return serializer.format_registry.get(info['serializer'])
 
238
        return xml_serializer.format_registry.get(info['serializer'])
256
239
 
257
240
 
258
241
class BundleWriteOperation(object):
272
255
        self.repository = repository
273
256
        bundle = BundleWriter(fileobj)
274
257
        self.bundle = bundle
 
258
        self.base_ancestry = set(repository.get_ancestry(base,
 
259
                                                         topo_sorted=False))
275
260
        if revision_ids is not None:
276
261
            self.revision_ids = revision_ids
277
262
        else:
278
 
            graph = repository.get_graph()
279
 
            revision_ids = graph.find_unique_ancestors(target, [base])
280
 
            # Strip ghosts
281
 
            parents = graph.get_parent_map(revision_ids)
282
 
            self.revision_ids = [r for r in revision_ids if r in parents]
283
 
        self.revision_keys = set([(revid,) for revid in self.revision_ids])
 
263
            revision_ids = set(repository.get_ancestry(target,
 
264
                                                       topo_sorted=False))
 
265
            self.revision_ids = revision_ids.difference(self.base_ancestry)
284
266
 
285
267
    def do_write(self):
286
268
        """Write all data to the bundle"""
287
 
        trace.note('Bundling %d revision(s).', len(self.revision_ids))
288
 
        self.repository.lock_read()
289
 
        try:
290
 
            self.bundle.begin()
291
 
            self.write_info()
292
 
            self.write_files()
293
 
            self.write_revisions()
294
 
            self.bundle.end()
295
 
        finally:
296
 
            self.repository.unlock()
 
269
        self.bundle.begin()
 
270
        self.write_info()
 
271
        self.write_files()
 
272
        self.write_revisions()
 
273
        self.bundle.end()
297
274
        return self.revision_ids
298
275
 
299
276
    def write_info(self):
304
281
        self.bundle.add_info_record(serializer=serializer_format,
305
282
                                    supports_rich_root=supports_rich_root)
306
283
 
 
284
    def iter_file_revisions(self):
 
285
        """Iterate through all relevant revisions of all files.
 
286
 
 
287
        This is the correct implementation, but is not compatible with bzr.dev,
 
288
        because certain old revisions were not converted correctly, and have
 
289
        the wrong "revision" marker in inventories.
 
290
        """
 
291
        transaction = self.repository.get_transaction()
 
292
        altered = self.repository.fileids_altered_by_revision_ids(
 
293
            self.revision_ids)
 
294
        for file_id, file_revision_ids in altered.iteritems():
 
295
            vf = self.repository.weave_store.get_weave(file_id, transaction)
 
296
            yield vf, file_id, file_revision_ids
 
297
 
 
298
    def iter_file_revisions_aggressive(self):
 
299
        """Iterate through all relevant revisions of all files.
 
300
 
 
301
        This uses the standard iter_file_revisions to determine what revisions
 
302
        are referred to by inventories, but then uses the versionedfile to
 
303
        determine what the build-dependencies of each required revision.
 
304
 
 
305
        All build dependencies which are not ancestors of the base revision
 
306
        are emitted.
 
307
        """
 
308
        for vf, file_id, file_revision_ids in self.iter_file_revisions():
 
309
            new_revision_ids = set()
 
310
            pending = list(file_revision_ids)
 
311
            while len(pending) > 0:
 
312
                revision_id = pending.pop()
 
313
                if revision_id in new_revision_ids:
 
314
                    continue
 
315
                if revision_id in self.base_ancestry:
 
316
                    continue
 
317
                new_revision_ids.add(revision_id)
 
318
                pending.extend(vf.get_parents(revision_id))
 
319
            yield vf, file_id, new_revision_ids
 
320
 
307
321
    def write_files(self):
308
322
        """Write bundle records for all revisions of all files"""
309
 
        text_keys = []
310
 
        altered_fileids = self.repository.fileids_altered_by_revision_ids(
311
 
                self.revision_ids)
312
 
        for file_id, revision_ids in altered_fileids.iteritems():
313
 
            for revision_id in revision_ids:
314
 
                text_keys.append((file_id, revision_id))
315
 
        self._add_mp_records_keys('file', self.repository.texts, text_keys)
 
323
        for vf, file_id, revision_ids in self.iter_file_revisions_aggressive():
 
324
            self.add_mp_records('file', file_id, vf, revision_ids)
316
325
 
317
326
    def write_revisions(self):
318
327
        """Write bundle records for all revisions and signatures"""
319
 
        inv_vf = self.repository.inventories
320
 
        topological_order = [key[-1] for key in multiparent.topo_iter_keys(
321
 
                                inv_vf, self.revision_keys)]
322
 
        revision_order = topological_order
 
328
        inv_vf = self.repository.get_inventory_weave()
 
329
        revision_order = list(multiparent.topo_iter(inv_vf, self.revision_ids))
323
330
        if self.target is not None and self.target in self.revision_ids:
324
 
            # Make sure the target revision is always the last entry
325
 
            revision_order = list(topological_order)
326
331
            revision_order.remove(self.target)
327
332
            revision_order.append(self.target)
328
 
        if self.repository._serializer.support_altered_by_hack:
329
 
            # Repositories that support_altered_by_hack means that
330
 
            # inventories.make_mpdiffs() contains all the data about the tree
331
 
            # shape. Formats without support_altered_by_hack require
332
 
            # chk_bytes/etc, so we use a different code path.
333
 
            self._add_mp_records_keys('inventory', inv_vf,
334
 
                                      [(revid,) for revid in topological_order])
335
 
        else:
336
 
            # Inventories should always be added in pure-topological order, so
337
 
            # that we can apply the mpdiff for the child to the parent texts.
338
 
            self._add_inventory_mpdiffs_from_serializer(topological_order)
339
 
        self._add_revision_texts(revision_order)
340
 
 
341
 
    def _add_inventory_mpdiffs_from_serializer(self, revision_order):
342
 
        """Generate mpdiffs by serializing inventories.
343
 
 
344
 
        The current repository only has part of the tree shape information in
345
 
        the 'inventories' vf. So we use serializer.write_inventory_to_string to
346
 
        get a 'full' representation of the tree shape, and then generate
347
 
        mpdiffs on that data stream. This stream can then be reconstructed on
348
 
        the other side.
349
 
        """
350
 
        inventory_key_order = [(r,) for r in revision_order]
351
 
        parent_map = self.repository.inventories.get_parent_map(
352
 
                            inventory_key_order)
353
 
        missing_keys = set(inventory_key_order).difference(parent_map)
354
 
        if missing_keys:
355
 
            raise errors.RevisionNotPresent(list(missing_keys)[0],
356
 
                                            self.repository.inventories)
357
 
        inv_to_str = self.repository._serializer.write_inventory_to_string
358
 
        # Make sure that we grab the parent texts first
359
 
        just_parents = set()
360
 
        map(just_parents.update, parent_map.itervalues())
361
 
        just_parents.difference_update(parent_map)
362
 
        # Ignore ghost parents
363
 
        present_parents = self.repository.inventories.get_parent_map(
364
 
                            just_parents)
365
 
        ghost_keys = just_parents.difference(present_parents)
366
 
        needed_inventories = list(present_parents) + inventory_key_order
367
 
        needed_inventories = [k[-1] for k in needed_inventories]
368
 
        all_lines = {}
369
 
        for inv in self.repository.iter_inventories(needed_inventories):
370
 
            revision_id = inv.revision_id
371
 
            key = (revision_id,)
372
 
            as_bytes = inv_to_str(inv)
373
 
            # The sha1 is validated as the xml/textual form, not as the
374
 
            # form-in-the-repository
375
 
            sha1 = osutils.sha_string(as_bytes)
376
 
            as_lines = osutils.split_lines(as_bytes)
377
 
            del as_bytes
378
 
            all_lines[key] = as_lines
379
 
            if key in just_parents:
380
 
                # We don't transmit those entries
381
 
                continue
382
 
            # Create an mpdiff for this text, and add it to the output
383
 
            parent_keys = parent_map[key]
384
 
            # See the comment in VF.make_mpdiffs about how this effects
385
 
            # ordering when there are ghosts present. I think we have a latent
386
 
            # bug
387
 
            parent_lines = [all_lines[p_key] for p_key in parent_keys
388
 
                            if p_key not in ghost_keys]
389
 
            diff = multiparent.MultiParent.from_lines(
390
 
                as_lines, parent_lines)
391
 
            text = ''.join(diff.to_patch())
392
 
            parent_ids = [k[-1] for k in parent_keys]
393
 
            self.bundle.add_multiparent_record(text, sha1, parent_ids,
394
 
                                               'inventory', revision_id, None)
395
 
 
396
 
    def _add_revision_texts(self, revision_order):
397
 
        parent_map = self.repository.get_parent_map(revision_order)
398
 
        revision_to_str = self.repository._serializer.write_revision_to_string
399
 
        revisions = self.repository.get_revisions(revision_order)
400
 
        for revision in revisions:
401
 
            revision_id = revision.revision_id
402
 
            parents = parent_map.get(revision_id, None)
403
 
            revision_text = revision_to_str(revision)
 
333
        self.add_mp_records('inventory', None, inv_vf, revision_order)
 
334
        parents_list = self.repository.get_parents(revision_order)
 
335
        for parents, revision_id in zip(parents_list, revision_order):
 
336
            revision_text = self.repository.get_revision_xml(revision_id)
404
337
            self.bundle.add_fulltext_record(revision_text, parents,
405
338
                                       'revision', revision_id)
406
339
            try:
425
358
                base = parents[0]
426
359
        return base, target
427
360
 
428
 
    def _add_mp_records_keys(self, repo_kind, vf, keys):
 
361
    def add_mp_records(self, repo_kind, file_id, vf, revision_ids):
429
362
        """Add multi-parent diff records to a bundle"""
430
 
        ordered_keys = list(multiparent.topo_iter_keys(vf, keys))
431
 
        mpdiffs = vf.make_mpdiffs(ordered_keys)
432
 
        sha1s = vf.get_sha1s(ordered_keys)
433
 
        parent_map = vf.get_parent_map(ordered_keys)
434
 
        for mpdiff, item_key, in zip(mpdiffs, ordered_keys):
435
 
            sha1 = sha1s[item_key]
436
 
            parents = [key[-1] for key in parent_map[item_key]]
 
363
        revision_ids = list(multiparent.topo_iter(vf, revision_ids))
 
364
        mpdiffs = vf.make_mpdiffs(revision_ids)
 
365
        sha1s = vf.get_sha1s(revision_ids)
 
366
        for mpdiff, revision_id, sha1, in zip(mpdiffs, revision_ids, sha1s):
 
367
            parents = vf.get_parents(revision_id)
437
368
            text = ''.join(mpdiff.to_patch())
438
 
            # Infer file id records as appropriate.
439
 
            if len(item_key) == 2:
440
 
                file_id = item_key[0]
441
 
            else:
442
 
                file_id = None
443
369
            self.bundle.add_multiparent_record(text, sha1, parents, repo_kind,
444
 
                                               item_key[-1], file_id)
 
370
                                               revision_id, file_id)
445
371
 
446
372
 
447
373
class BundleInfoV4(object):
456
382
    def install(self, repository):
457
383
        return self.install_revisions(repository)
458
384
 
459
 
    def install_revisions(self, repository, stream_input=True):
460
 
        """Install this bundle's revisions into the specified repository
461
 
 
462
 
        :param target_repo: The repository to install into
463
 
        :param stream_input: If True, will stream input rather than reading it
464
 
            all into memory at once.  Reading it into memory all at once is
465
 
            (currently) faster.
466
 
        """
 
385
    def install_revisions(self, repository):
 
386
        """Install this bundle's revisions into the specified repository"""
467
387
        repository.lock_write()
468
388
        try:
469
 
            ri = RevisionInstaller(self.get_bundle_reader(stream_input),
 
389
            ri = RevisionInstaller(self.get_bundle_reader(),
470
390
                                   self._serializer, repository)
471
391
            return ri.install()
472
392
        finally:
479
399
        """
480
400
        return None, self.target, 'inapplicable'
481
401
 
482
 
    def get_bundle_reader(self, stream_input=True):
483
 
        """Return a new BundleReader for the associated bundle
484
 
 
485
 
        :param stream_input: If True, the BundleReader stream input rather than
486
 
            reading it all into memory at once.  Reading it into memory all at
487
 
            once is (currently) faster.
488
 
        """
 
402
    def get_bundle_reader(self):
489
403
        self._fileobj.seek(0)
490
 
        return BundleReader(self._fileobj, stream_input)
 
404
        return BundleReader(self._fileobj)
491
405
 
492
406
    def _get_real_revisions(self):
493
407
        if self.__real_revisions is None:
530
444
        self._info = None
531
445
 
532
446
    def install(self):
533
 
        """Perform the installation.
534
 
 
535
 
        Must be called with the Repository locked.
536
 
        """
537
 
        self._repository.start_write_group()
538
 
        try:
539
 
            result = self._install_in_write_group()
540
 
        except:
541
 
            self._repository.abort_write_group()
542
 
            raise
543
 
        self._repository.commit_write_group()
544
 
        return result
545
 
 
546
 
    def _install_in_write_group(self):
 
447
        """Perform the installation"""
547
448
        current_file = None
548
449
        current_versionedfile = None
549
450
        pending_file_records = []
550
 
        inventory_vf = None
551
 
        pending_inventory_records = []
552
451
        added_inv = set()
553
452
        target_revision = None
554
453
        for bytes, metadata, repo_kind, revision_id, file_id in\
555
454
            self._container.iter_records():
556
455
            if repo_kind == 'info':
557
 
                if self._info is not None:
558
 
                    raise AssertionError()
 
456
                assert self._info is None
559
457
                self._handle_info(metadata)
560
 
            if (pending_file_records and
561
 
                (repo_kind, file_id) != ('file', current_file)):
562
 
                # Flush the data for a single file - prevents memory
563
 
                # spiking due to buffering all files in memory.
564
 
                self._install_mp_records_keys(self._repository.texts,
 
458
            if repo_kind != 'file':
 
459
                self._install_mp_records(current_versionedfile,
565
460
                    pending_file_records)
566
461
                current_file = None
567
 
                del pending_file_records[:]
568
 
            if len(pending_inventory_records) > 0 and repo_kind != 'inventory':
569
 
                self._install_inventory_records(pending_inventory_records)
570
 
                pending_inventory_records = []
571
 
            if repo_kind == 'inventory':
572
 
                pending_inventory_records.append(((revision_id,), metadata, bytes))
573
 
            if repo_kind == 'revision':
574
 
                target_revision = revision_id
575
 
                self._install_revision(revision_id, metadata, bytes)
576
 
            if repo_kind == 'signature':
577
 
                self._install_signature(revision_id, metadata, bytes)
 
462
                current_versionedfile = None
 
463
                pending_file_records = []
 
464
                if repo_kind == 'inventory':
 
465
                    self._install_inventory(revision_id, metadata, bytes)
 
466
                if repo_kind == 'revision':
 
467
                    target_revision = revision_id
 
468
                    self._install_revision(revision_id, metadata, bytes)
 
469
                if repo_kind == 'signature':
 
470
                    self._install_signature(revision_id, metadata, bytes)
578
471
            if repo_kind == 'file':
579
 
                current_file = file_id
580
 
                pending_file_records.append(((file_id, revision_id), metadata, bytes))
581
 
        self._install_mp_records_keys(self._repository.texts, pending_file_records)
 
472
                if file_id != current_file:
 
473
                    self._install_mp_records(current_versionedfile,
 
474
                        pending_file_records)
 
475
                    current_file = file_id
 
476
                    current_versionedfile = \
 
477
                        self._repository.weave_store.get_weave_or_empty(
 
478
                        file_id, self._repository.get_transaction())
 
479
                    pending_file_records = []
 
480
                if revision_id in current_versionedfile:
 
481
                    continue
 
482
                pending_file_records.append((revision_id, metadata, bytes))
 
483
        self._install_mp_records(current_versionedfile, pending_file_records)
582
484
        return target_revision
583
485
 
584
486
    def _handle_info(self, info):
599
501
                      records if r not in versionedfile]
600
502
        versionedfile.add_mpdiffs(vf_records)
601
503
 
602
 
    def _install_mp_records_keys(self, versionedfile, records):
603
 
        d_func = multiparent.MultiParent.from_patch
604
 
        vf_records = []
605
 
        for key, meta, text in records:
606
 
            # Adapt to tuple interface: A length two key is a file_id,
607
 
            # revision_id pair, a length 1 key is a
608
 
            # revision/signature/inventory. We need to do this because
609
 
            # the metadata extraction from the bundle has not yet been updated
610
 
            # to use the consistent tuple interface itself.
611
 
            if len(key) == 2:
612
 
                prefix = key[:1]
613
 
            else:
614
 
                prefix = ()
615
 
            parents = [prefix + (parent,) for parent in meta['parents']]
616
 
            vf_records.append((key, parents, meta['sha1'], d_func(text)))
617
 
        versionedfile.add_mpdiffs(vf_records)
618
 
 
619
 
    def _get_parent_inventory_texts(self, inventory_text_cache,
620
 
                                    inventory_cache, parent_ids):
621
 
        cached_parent_texts = {}
622
 
        remaining_parent_ids = []
623
 
        for parent_id in parent_ids:
624
 
            p_text = inventory_text_cache.get(parent_id, None)
625
 
            if p_text is None:
626
 
                remaining_parent_ids.append(parent_id)
627
 
            else:
628
 
                cached_parent_texts[parent_id] = p_text
629
 
        ghosts = ()
630
 
        # TODO: Use inventory_cache to grab inventories we already have in
631
 
        #       memory
632
 
        if remaining_parent_ids:
633
 
            # first determine what keys are actually present in the local
634
 
            # inventories object (don't use revisions as they haven't been
635
 
            # installed yet.)
636
 
            parent_keys = [(r,) for r in remaining_parent_ids]
637
 
            present_parent_map = self._repository.inventories.get_parent_map(
638
 
                                        parent_keys)
639
 
            present_parent_ids = []
640
 
            ghosts = set()
641
 
            for p_id in remaining_parent_ids:
642
 
                if (p_id,) in present_parent_map:
643
 
                    present_parent_ids.append(p_id)
644
 
                else:
645
 
                    ghosts.add(p_id)
646
 
            to_string = self._source_serializer.write_inventory_to_string
647
 
            for parent_inv in self._repository.iter_inventories(
648
 
                                    present_parent_ids):
649
 
                p_text = to_string(parent_inv)
650
 
                inventory_cache[parent_inv.revision_id] = parent_inv
651
 
                cached_parent_texts[parent_inv.revision_id] = p_text
652
 
                inventory_text_cache[parent_inv.revision_id] = p_text
653
 
 
654
 
        parent_texts = [cached_parent_texts[parent_id]
655
 
                        for parent_id in parent_ids
656
 
                         if parent_id not in ghosts]
657
 
        return parent_texts
658
 
 
659
 
    def _install_inventory_records(self, records):
660
 
        if (self._info['serializer'] == self._repository._serializer.format_num
661
 
            and self._repository._serializer.support_altered_by_hack):
662
 
            return self._install_mp_records_keys(self._repository.inventories,
663
 
                records)
664
 
        # Use a 10MB text cache, since these are string xml inventories. Note
665
 
        # that 10MB is fairly small for large projects (a single inventory can
666
 
        # be >5MB). Another possibility is to cache 10-20 inventory texts
667
 
        # instead
668
 
        inventory_text_cache = lru_cache.LRUSizeCache(10*1024*1024)
669
 
        # Also cache the in-memory representation. This allows us to create
670
 
        # inventory deltas to apply rather than calling add_inventory from
671
 
        # scratch each time.
672
 
        inventory_cache = lru_cache.LRUCache(10)
673
 
        pb = ui.ui_factory.nested_progress_bar()
 
504
    def _install_inventory(self, revision_id, metadata, text):
 
505
        vf = self._repository.get_inventory_weave()
 
506
        if revision_id in vf:
 
507
            return
 
508
        parent_ids = metadata['parents']
 
509
        if self._info['serializer'] == self._repository._serializer.format_num:
 
510
            return self._install_mp_records(vf, [(revision_id, metadata,
 
511
                                                  text)])
 
512
        parents = [self._repository.get_inventory(p)
 
513
                   for p in parent_ids]
 
514
        parent_texts = [self._source_serializer.write_inventory_to_string(p)
 
515
                        for p in parents]
 
516
        target_lines = multiparent.MultiParent.from_patch(text).to_lines(
 
517
            parent_texts)
 
518
        sha1 = osutils.sha_strings(target_lines)
 
519
        if sha1 != metadata['sha1']:
 
520
            raise errors.BadBundle("Can't convert to target format")
 
521
        target_inv = self._source_serializer.read_inventory_from_string(
 
522
            ''.join(target_lines))
 
523
        self._handle_root(target_inv, parent_ids)
674
524
        try:
675
 
            num_records = len(records)
676
 
            for idx, (key, metadata, bytes) in enumerate(records):
677
 
                pb.update('installing inventory', idx, num_records)
678
 
                revision_id = key[-1]
679
 
                parent_ids = metadata['parents']
680
 
                # Note: This assumes the local ghosts are identical to the
681
 
                #       ghosts in the source, as the Bundle serialization
682
 
                #       format doesn't record ghosts.
683
 
                p_texts = self._get_parent_inventory_texts(inventory_text_cache,
684
 
                                                           inventory_cache,
685
 
                                                           parent_ids)
686
 
                # Why does to_lines() take strings as the source, it seems that
687
 
                # it would have to cast to a list of lines, which we get back
688
 
                # as lines and then cast back to a string.
689
 
                target_lines = multiparent.MultiParent.from_patch(bytes
690
 
                            ).to_lines(p_texts)
691
 
                inv_text = ''.join(target_lines)
692
 
                del target_lines
693
 
                sha1 = osutils.sha_string(inv_text)
694
 
                if sha1 != metadata['sha1']:
695
 
                    raise errors.BadBundle("Can't convert to target format")
696
 
                # Add this to the cache so we don't have to extract it again.
697
 
                inventory_text_cache[revision_id] = inv_text
698
 
                target_inv = self._source_serializer.read_inventory_from_string(
699
 
                    inv_text)
700
 
                self._handle_root(target_inv, parent_ids)
701
 
                parent_inv = None
702
 
                if parent_ids:
703
 
                    parent_inv = inventory_cache.get(parent_ids[0], None)
704
 
                try:
705
 
                    if parent_inv is None:
706
 
                        self._repository.add_inventory(revision_id, target_inv,
707
 
                                                       parent_ids)
708
 
                    else:
709
 
                        delta = target_inv._make_delta(parent_inv)
710
 
                        self._repository.add_inventory_by_delta(parent_ids[0],
711
 
                            delta, revision_id, parent_ids)
712
 
                except errors.UnsupportedInventoryKind:
713
 
                    raise errors.IncompatibleRevision(repr(self._repository))
714
 
                inventory_cache[revision_id] = target_inv
715
 
        finally:
716
 
            pb.finished()
 
525
            self._repository.add_inventory(revision_id, target_inv, parent_ids)
 
526
        except errors.UnsupportedInventoryKind:
 
527
            raise errors.IncompatibleRevision(repr(self._repository))
717
528
 
718
529
    def _handle_root(self, target_inv, parent_ids):
719
530
        revision_id = target_inv.revision_id
720
531
        if self.update_root:
721
 
            text_key = (target_inv.root.file_id, revision_id)
722
 
            parent_keys = [(target_inv.root.file_id, parent) for
723
 
                parent in parent_ids]
724
 
            self._repository.texts.add_lines(text_key, parent_keys, [])
 
532
            target_inv.root.revision = revision_id
 
533
            store = self._repository.weave_store
 
534
            transaction = self._repository.get_transaction()
 
535
            vf = store.get_weave_or_empty(target_inv.root.file_id, transaction)
 
536
            vf.add_lines(revision_id, parent_ids, [])
725
537
        elif not self._repository.supports_rich_root():
726
538
            if target_inv.root.revision != revision_id:
727
539
                raise errors.IncompatibleRevision(repr(self._repository))
728
540
 
 
541
 
729
542
    def _install_revision(self, revision_id, metadata, text):
730
543
        if self._repository.has_revision(revision_id):
731
544
            return
732
 
        revision = self._source_serializer.read_revision_from_string(text)
733
 
        self._repository.add_revision(revision.revision_id, revision)
 
545
        self._repository._add_revision_text(revision_id, text)
734
546
 
735
547
    def _install_signature(self, revision_id, metadata, text):
736
548
        transaction = self._repository.get_transaction()
737
 
        if self._repository.has_signature_for_revision_id(revision_id):
 
549
        if self._repository._revision_store.has_signature(revision_id,
 
550
                                                          transaction):
738
551
            return
739
 
        self._repository.add_signature_text(revision_id, text)
 
552
        self._repository._revision_store.add_revision_signature_text(
 
553
            revision_id, text, transaction)