/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

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

  • Committer: Jelmer Vernooij
  • Date: 2018-07-08 14:45:27 UTC
  • mto: This revision was merged to the branch mainline in revision 7036.
  • Revision ID: jelmer@jelmer.uk-20180708144527-codhlvdcdg9y0nji
Fix a bunch of merge tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
from cStringIO import StringIO
 
17
from __future__ import absolute_import
 
18
 
18
19
import bz2
19
20
import re
20
21
 
21
 
from bzrlib import (
22
 
    diff,
 
22
from ... import (
 
23
    bencode,
23
24
    errors,
24
25
    iterablefile,
25
26
    lru_cache,
26
27
    multiparent,
27
28
    osutils,
28
 
    pack,
29
29
    revision as _mod_revision,
30
 
    serializer,
31
30
    trace,
32
31
    ui,
33
32
    )
34
 
from bzrlib.bundle import bundle_data, serializer as bundle_serializer
35
 
from bzrlib import bencode
 
33
from ...bzr import (
 
34
    pack,
 
35
    serializer,
 
36
    versionedfile as _mod_versionedfile,
 
37
    )
 
38
from ...bundle import bundle_data, serializer as bundle_serializer
 
39
from ...i18n import ngettext
 
40
from ...sixish import (
 
41
    BytesIO,
 
42
    viewitems,
 
43
    )
 
44
 
 
45
 
 
46
class _MPDiffInventoryGenerator(_mod_versionedfile._MPDiffGenerator):
 
47
    """Generate Inventory diffs serialized inventories."""
 
48
 
 
49
    def __init__(self, repo, inventory_keys):
 
50
        super(_MPDiffInventoryGenerator, self).__init__(repo.inventories,
 
51
            inventory_keys)
 
52
        self.repo = repo
 
53
        self.sha1s = {}
 
54
 
 
55
    def iter_diffs(self):
 
56
        """Compute the diffs one at a time."""
 
57
        # This is instead of compute_diffs() since we guarantee our ordering of
 
58
        # inventories, we don't have to do any buffering
 
59
        self._find_needed_keys()
 
60
        # We actually use a slightly different ordering. We grab all of the
 
61
        # parents first, and then grab the ordered requests.
 
62
        needed_ids = [k[-1] for k in self.present_parents]
 
63
        needed_ids.extend([k[-1] for k in self.ordered_keys])
 
64
        inv_to_str = self.repo._serializer.write_inventory_to_string
 
65
        for inv in self.repo.iter_inventories(needed_ids):
 
66
            revision_id = inv.revision_id
 
67
            key = (revision_id,)
 
68
            if key in self.present_parents:
 
69
                # Not a key we will transmit, which is a shame, since because
 
70
                # of that bundles don't work with stacked branches
 
71
                parent_ids = None
 
72
            else:
 
73
                parent_ids = [k[-1] for k in self.parent_map[key]]
 
74
            as_bytes = inv_to_str(inv)
 
75
            self._process_one_record(key, (as_bytes,))
 
76
            if parent_ids is None:
 
77
                continue
 
78
            diff = self.diffs.pop(key)
 
79
            sha1 = osutils.sha_string(as_bytes)
 
80
            yield revision_id, parent_ids, sha1, diff
36
81
 
37
82
 
38
83
class BundleWriter(object):
56
101
 
57
102
    def begin(self):
58
103
        """Start writing the bundle"""
59
 
        self._fileobj.write(bundle_serializer._get_bundle_header(
60
 
            bundle_serializer.v4_string))
61
 
        self._fileobj.write('#\n')
 
104
        self._fileobj.write(bundle_serializer._get_bundle_header('4'))
 
105
        self._fileobj.write(b'#\n')
62
106
        self._container.begin()
63
107
 
64
108
    def end(self):
78
122
        :revision_id: The revision id of the mpdiff being added.
79
123
        :file_id: The file-id of the file, or None for inventories.
80
124
        """
81
 
        metadata = {'parents': parents,
82
 
                    'storage_kind': 'mpdiff',
83
 
                    'sha1': sha1}
 
125
        metadata = {b'parents': parents,
 
126
                    b'storage_kind': b'mpdiff',
 
127
                    b'sha1': sha1}
84
128
        self._add_record(mp_bytes, metadata, repo_kind, revision_id, file_id)
85
129
 
86
130
    def add_fulltext_record(self, bytes, parents, repo_kind, revision_id):
92
136
            'signature'
93
137
        :revision_id: The revision id of the fulltext being added.
94
138
        """
95
 
        metadata = {'parents': parents,
96
 
                    'storage_kind': 'mpdiff'}
97
 
        self._add_record(bytes, {'parents': parents,
98
 
            'storage_kind': 'fulltext'}, repo_kind, revision_id, None)
 
139
        metadata = {b'parents': parents,
 
140
                    b'storage_kind': b'mpdiff'}
 
141
        self._add_record(bytes, {b'parents': parents,
 
142
            b'storage_kind': b'fulltext'}, repo_kind, revision_id, None)
99
143
 
100
 
    def add_info_record(self, **kwargs):
 
144
    def add_info_record(self, kwargs):
101
145
        """Add an info record to the bundle
102
146
 
103
147
        Any parameters may be supplied, except 'self' and 'storage_kind'.
104
148
        Values must be lists, strings, integers, dicts, or a combination.
105
149
        """
106
 
        kwargs['storage_kind'] = 'header'
 
150
        kwargs[b'storage_kind'] = b'header'
107
151
        self._add_record(None, kwargs, 'info', None, None)
108
152
 
109
153
    @staticmethod
123
167
                raise AssertionError()
124
168
        elif revision_id is None:
125
169
            raise AssertionError()
126
 
        names = [n.replace('/', '//') for n in
127
 
                 (content_kind, revision_id, file_id) if n is not None]
128
 
        return '/'.join(names)
 
170
        names = [n.replace(b'/', b'//') for n in
 
171
                 (content_kind.encode('ascii'), revision_id, file_id) if n is not None]
 
172
        return b'/'.join(names)
129
173
 
130
174
    def _add_record(self, bytes, metadata, repo_kind, revision_id, file_id):
131
175
        """Add a bundle record to the container.
137
181
        name = self.encode_name(repo_kind, revision_id, file_id)
138
182
        encoded_metadata = bencode.bencode(metadata)
139
183
        self._container.add_bytes_record(encoded_metadata, [(name, )])
140
 
        if metadata['storage_kind'] != 'header':
 
184
        if metadata[b'storage_kind'] != b'header':
141
185
            self._container.add_bytes_record(bytes, [])
142
186
 
143
187
 
164
208
        if stream_input:
165
209
            source_file = iterablefile.IterableFile(self.iter_decode(fileobj))
166
210
        else:
167
 
            source_file = StringIO(bz2.decompress(fileobj.read()))
 
211
            source_file = BytesIO(bz2.decompress(fileobj.read()))
168
212
        self._container_file = source_file
169
213
 
170
214
    @staticmethod
183
227
 
184
228
        :retval: content_kind, revision_id, file_id
185
229
        """
186
 
        segments = re.split('(//?)', name)
187
 
        names = ['']
 
230
        segments = re.split(b'(//?)', name)
 
231
        names = [b'']
188
232
        for segment in segments:
189
 
            if segment == '//':
190
 
                names[-1] += '/'
191
 
            elif segment == '/':
192
 
                names.append('')
 
233
            if segment == b'//':
 
234
                names[-1] += b'/'
 
235
            elif segment == b'/':
 
236
                names.append(b'')
193
237
            else:
194
238
                names[-1] += segment
195
239
        content_kind = names[0]
199
243
            revision_id = names[1]
200
244
        if len(names) > 2:
201
245
            file_id = names[2]
202
 
        return content_kind, revision_id, file_id
 
246
        return content_kind.decode('ascii'), revision_id, file_id
203
247
 
204
248
    def iter_records(self):
205
249
        """Iterate through bundle records
213
257
                raise errors.BadBundle('Record has %d names instead of 1'
214
258
                                       % len(names))
215
259
            metadata = bencode.bdecode(bytes)
216
 
            if metadata['storage_kind'] == 'header':
 
260
            if metadata[b'storage_kind'] == b'header':
217
261
                bytes = None
218
262
            else:
219
 
                _unused, bytes = iterator.next()
 
263
                _unused, bytes = next(iterator)
220
264
            yield (bytes, metadata) + self.decode_name(names[0][0])
221
265
 
222
266
 
252
296
    @staticmethod
253
297
    def get_source_serializer(info):
254
298
        """Retrieve the serializer for a given info object"""
255
 
        return serializer.format_registry.get(info['serializer'])
 
299
        return serializer.format_registry.get(info[b'serializer'].decode('ascii'))
256
300
 
257
301
 
258
302
class BundleWriteOperation(object):
280
324
            # Strip ghosts
281
325
            parents = graph.get_parent_map(revision_ids)
282
326
            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])
 
327
        self.revision_keys = {(revid,) for revid in self.revision_ids}
284
328
 
285
329
    def do_write(self):
286
330
        """Write all data to the bundle"""
287
 
        trace.note('Bundling %d revision(s).', len(self.revision_ids))
288
 
        self.repository.lock_read()
289
 
        try:
 
331
        trace.note(ngettext('Bundling %d revision.', 'Bundling %d revisions.',
 
332
                            len(self.revision_ids)), len(self.revision_ids))
 
333
        with self.repository.lock_read():
290
334
            self.bundle.begin()
291
335
            self.write_info()
292
336
            self.write_files()
293
337
            self.write_revisions()
294
338
            self.bundle.end()
295
 
        finally:
296
 
            self.repository.unlock()
297
339
        return self.revision_ids
298
340
 
299
341
    def write_info(self):
301
343
        serializer_format = self.repository.get_serializer_format()
302
344
        supports_rich_root = {True: 1, False: 0}[
303
345
            self.repository.supports_rich_root()]
304
 
        self.bundle.add_info_record(serializer=serializer_format,
305
 
                                    supports_rich_root=supports_rich_root)
 
346
        self.bundle.add_info_record({b'serializer': serializer_format,
 
347
                                     b'supports_rich_root': supports_rich_root})
306
348
 
307
349
    def write_files(self):
308
350
        """Write bundle records for all revisions of all files"""
309
351
        text_keys = []
310
352
        altered_fileids = self.repository.fileids_altered_by_revision_ids(
311
353
                self.revision_ids)
312
 
        for file_id, revision_ids in altered_fileids.iteritems():
 
354
        for file_id, revision_ids in viewitems(altered_fileids):
313
355
            for revision_id in revision_ids:
314
356
                text_keys.append((file_id, revision_id))
315
357
        self._add_mp_records_keys('file', self.repository.texts, text_keys)
348
390
        the other side.
349
391
        """
350
392
        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
        generator = _MPDiffInventoryGenerator(self.repository,
 
394
                                              inventory_key_order)
 
395
        for revision_id, parent_ids, sha1, diff in generator.iter_diffs():
 
396
            text = b''.join(diff.to_patch())
393
397
            self.bundle.add_multiparent_record(text, sha1, parent_ids,
394
398
                                               'inventory', revision_id, None)
395
399
 
434
438
        for mpdiff, item_key, in zip(mpdiffs, ordered_keys):
435
439
            sha1 = sha1s[item_key]
436
440
            parents = [key[-1] for key in parent_map[item_key]]
437
 
            text = ''.join(mpdiff.to_patch())
 
441
            text = b''.join(mpdiff.to_patch())
438
442
            # Infer file id records as appropriate.
439
443
            if len(item_key) == 2:
440
444
                file_id = item_key[0]
464
468
            all into memory at once.  Reading it into memory all at once is
465
469
            (currently) faster.
466
470
        """
467
 
        repository.lock_write()
468
 
        try:
 
471
        with repository.lock_write():
469
472
            ri = RevisionInstaller(self.get_bundle_reader(stream_input),
470
473
                                   self._serializer, repository)
471
474
            return ri.install()
472
 
        finally:
473
 
            repository.unlock()
474
475
 
475
476
    def get_merge_request(self, target_repo):
476
477
        """Provide data for performing a merge
585
586
        """Extract data from an info record"""
586
587
        self._info = info
587
588
        self._source_serializer = self._serializer.get_source_serializer(info)
588
 
        if (info['supports_rich_root'] == 0 and
 
589
        if (info[b'supports_rich_root'] == 0 and
589
590
            self._repository.supports_rich_root()):
590
591
            self.update_root = True
591
592
        else:
612
613
                prefix = key[:1]
613
614
            else:
614
615
                prefix = ()
615
 
            parents = [prefix + (parent,) for parent in meta['parents']]
616
 
            vf_records.append((key, parents, meta['sha1'], d_func(text)))
 
616
            parents = [prefix + (parent,) for parent in meta[b'parents']]
 
617
            vf_records.append((key, parents, meta[b'sha1'], d_func(text)))
617
618
        versionedfile.add_mpdiffs(vf_records)
618
619
 
619
620
    def _get_parent_inventory_texts(self, inventory_text_cache,
657
658
        return parent_texts
658
659
 
659
660
    def _install_inventory_records(self, records):
660
 
        if (self._info['serializer'] == self._repository._serializer.format_num
 
661
        if (self._info[b'serializer'] == self._repository._serializer.format_num
661
662
            and self._repository._serializer.support_altered_by_hack):
662
663
            return self._install_mp_records_keys(self._repository.inventories,
663
664
                records)
670
671
        # inventory deltas to apply rather than calling add_inventory from
671
672
        # scratch each time.
672
673
        inventory_cache = lru_cache.LRUCache(10)
673
 
        pb = ui.ui_factory.nested_progress_bar()
674
 
        try:
 
674
        with ui.ui_factory.nested_progress_bar() as pb:
675
675
            num_records = len(records)
676
676
            for idx, (key, metadata, bytes) in enumerate(records):
677
677
                pb.update('installing inventory', idx, num_records)
678
678
                revision_id = key[-1]
679
 
                parent_ids = metadata['parents']
 
679
                parent_ids = metadata[b'parents']
680
680
                # Note: This assumes the local ghosts are identical to the
681
681
                #       ghosts in the source, as the Bundle serialization
682
682
                #       format doesn't record ghosts.
688
688
                # as lines and then cast back to a string.
689
689
                target_lines = multiparent.MultiParent.from_patch(bytes
690
690
                            ).to_lines(p_texts)
691
 
                inv_text = ''.join(target_lines)
 
691
                inv_text = b''.join(target_lines)
692
692
                del target_lines
693
693
                sha1 = osutils.sha_string(inv_text)
694
 
                if sha1 != metadata['sha1']:
 
694
                if sha1 != metadata[b'sha1']:
695
695
                    raise errors.BadBundle("Can't convert to target format")
696
696
                # Add this to the cache so we don't have to extract it again.
697
697
                inventory_text_cache[revision_id] = inv_text
712
712
                except errors.UnsupportedInventoryKind:
713
713
                    raise errors.IncompatibleRevision(repr(self._repository))
714
714
                inventory_cache[revision_id] = target_inv
715
 
        finally:
716
 
            pb.finished()
717
715
 
718
716
    def _handle_root(self, target_inv, parent_ids):
719
717
        revision_id = target_inv.revision_id