/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/multiparent.py

  • Committer: Jelmer Vernooij
  • Date: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/multiparent.py
1
 
# Copyright (C) 2007 Canonical Ltd
 
1
# Copyright (C) 2007-2011 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 bzrlib.lazy_import import lazy_import
 
17
from __future__ import absolute_import
 
18
 
 
19
import errno
 
20
import os
 
21
 
 
22
from .lazy_import import lazy_import
18
23
 
19
24
lazy_import(globals(), """
20
 
import errno
 
25
import gzip
21
26
import itertools
22
 
import os
23
 
from StringIO import StringIO
 
27
import patiencediff
24
28
 
25
 
from bzrlib import (
26
 
    errors,
27
 
    patiencediff,
28
 
    trace,
 
29
from breezy import (
 
30
    bencode,
29
31
    ui,
30
32
    )
31
 
from bzrlib import bencode
32
33
""")
33
 
from bzrlib.tuned_gzip import GzipFile
 
34
from . import (
 
35
    errors,
 
36
    )
 
37
from .i18n import gettext
 
38
from .sixish import (
 
39
    BytesIO,
 
40
    range,
 
41
    )
34
42
 
35
43
 
36
44
def topo_iter_keys(vf, keys=None):
39
47
    parents = vf.get_parent_map(keys)
40
48
    return _topo_iter(parents, keys)
41
49
 
 
50
 
42
51
def topo_iter(vf, versions=None):
43
52
    if versions is None:
44
53
        versions = vf.versions()
45
54
    parents = vf.get_parent_map(versions)
46
55
    return _topo_iter(parents, versions)
47
56
 
 
57
 
48
58
def _topo_iter(parents, versions):
49
59
    seen = set()
50
60
    descendants = {}
 
61
 
51
62
    def pending_parents(version):
52
63
        if parents[version] is None:
53
64
            return []
76
87
class MultiParent(object):
77
88
    """A multi-parent diff"""
78
89
 
 
90
    __slots__ = ['hunks']
 
91
 
79
92
    def __init__(self, hunks=None):
80
93
        if hunks is not None:
81
94
            self.hunks = hunks
109
122
        parent_text = []
110
123
        block_iter = [iter(i) for i in parent_comparisons]
111
124
        diff = MultiParent([])
 
125
 
112
126
        def next_block(p):
113
127
            try:
114
 
                return block_iter[p].next()
 
128
                return next(block_iter[p])
115
129
            except StopIteration:
116
130
                return None
117
131
        cur_block = [next_block(p) for p, i in enumerate(block_iter)]
162
176
        """Contruct a fulltext from this diff and its parents"""
163
177
        mpvf = MultiMemoryVersionedFile()
164
178
        for num, parent in enumerate(parents):
165
 
            mpvf.add_version(StringIO(parent).readlines(), num, [])
166
 
        mpvf.add_diff(self, 'a', range(len(parents)))
 
179
            mpvf.add_version(BytesIO(parent).readlines(), num, [])
 
180
        mpvf.add_diff(self, 'a', list(range(len(parents))))
167
181
        return mpvf.get_line_list(['a'])[0]
168
182
 
169
183
    @classmethod
170
184
    def from_texts(cls, text, parents=()):
171
185
        """Produce a MultiParent from a text and list of parent text"""
172
 
        return cls.from_lines(StringIO(text).readlines(),
173
 
                              [StringIO(p).readlines() for p in parents])
 
186
        return cls.from_lines(BytesIO(text).readlines(),
 
187
                              [BytesIO(p).readlines() for p in parents])
174
188
 
175
189
    def to_patch(self):
176
190
        """Yield text lines for a patch"""
179
193
                yield line
180
194
 
181
195
    def patch_len(self):
182
 
        return len(''.join(self.to_patch()))
 
196
        return len(b''.join(self.to_patch()))
183
197
 
184
198
    def zipped_patch_len(self):
185
199
        return len(gzip_string(self.to_patch()))
187
201
    @classmethod
188
202
    def from_patch(cls, text):
189
203
        """Create a MultiParent from its string form"""
190
 
        return cls._from_patch(StringIO(text))
 
204
        return cls._from_patch(BytesIO(text))
191
205
 
192
206
    @staticmethod
193
207
    def _from_patch(lines):
195
209
        line_iter = iter(lines)
196
210
        hunks = []
197
211
        cur_line = None
198
 
        while(True):
 
212
        while True:
199
213
            try:
200
 
                cur_line = line_iter.next()
 
214
                cur_line = next(line_iter)
201
215
            except StopIteration:
202
216
                break
203
 
            if cur_line[0] == 'i':
204
 
                num_lines = int(cur_line.split(' ')[1])
205
 
                hunk_lines = [line_iter.next() for x in xrange(num_lines)]
 
217
            first_char = cur_line[0:1]
 
218
            if first_char == b'i':
 
219
                num_lines = int(cur_line.split(b' ')[1])
 
220
                hunk_lines = [next(line_iter) for _ in range(num_lines)]
206
221
                hunk_lines[-1] = hunk_lines[-1][:-1]
207
222
                hunks.append(NewText(hunk_lines))
208
 
            elif cur_line[0] == '\n':
209
 
                hunks[-1].lines[-1] += '\n'
 
223
            elif first_char == b'\n':
 
224
                hunks[-1].lines[-1] += b'\n'
210
225
            else:
211
 
                if not (cur_line[0] == 'c'):
212
 
                    raise AssertionError(cur_line[0])
 
226
                if not (first_char == b'c'):
 
227
                    raise AssertionError(first_char)
213
228
                parent, parent_pos, child_pos, num_lines =\
214
 
                    [int(v) for v in cur_line.split(' ')[1:]]
 
229
                    [int(v) for v in cur_line.split(b' ')[1:]]
215
230
                hunks.append(ParentText(parent, parent_pos, child_pos,
216
231
                                        num_lines))
217
232
        return MultiParent(hunks)
244
259
        extra_n = 0
245
260
        for hunk in reversed(self.hunks):
246
261
            if isinstance(hunk, ParentText):
247
 
               return hunk.child_pos + hunk.num_lines + extra_n
 
262
                return hunk.child_pos + hunk.num_lines + extra_n
248
263
            extra_n += len(hunk.lines)
249
264
        return extra_n
250
265
 
258
273
class NewText(object):
259
274
    """The contents of text that is introduced by this text"""
260
275
 
 
276
    __slots__ = ['lines']
 
277
 
261
278
    def __init__(self, lines):
262
279
        self.lines = lines
263
280
 
270
287
        return 'NewText(%r)' % self.lines
271
288
 
272
289
    def to_patch(self):
273
 
        yield 'i %d\n' % len(self.lines)
 
290
        yield b'i %d\n' % len(self.lines)
274
291
        for line in self.lines:
275
292
            yield line
276
 
        yield '\n'
 
293
        yield b'\n'
277
294
 
278
295
 
279
296
class ParentText(object):
280
297
    """A reference to text present in a parent text"""
281
298
 
 
299
    __slots__ = ['parent', 'parent_pos', 'child_pos', 'num_lines']
 
300
 
282
301
    def __init__(self, parent, parent_pos, child_pos, num_lines):
283
302
        self.parent = parent
284
303
        self.parent_pos = parent_pos
285
304
        self.child_pos = child_pos
286
305
        self.num_lines = num_lines
287
306
 
 
307
    def _as_dict(self):
 
308
        return {b'parent': self.parent,
 
309
                b'parent_pos': self.parent_pos,
 
310
                b'child_pos': self.child_pos,
 
311
                b'num_lines': self.num_lines}
 
312
 
288
313
    def __repr__(self):
289
 
        return 'ParentText(%(parent)r, %(parent_pos)r, %(child_pos)r,'\
290
 
            ' %(num_lines)r)' % self.__dict__
 
314
        return ('ParentText(%(parent)r, %(parent_pos)r, %(child_pos)r,'
 
315
                ' %(num_lines)r)' % self._as_dict())
291
316
 
292
317
    def __eq__(self, other):
293
318
        if self.__class__ is not other.__class__:
294
319
            return False
295
 
        return (self.__dict__ == other.__dict__)
 
320
        return self._as_dict() == other._as_dict()
296
321
 
297
322
    def to_patch(self):
298
 
        yield 'c %(parent)d %(parent_pos)d %(child_pos)d %(num_lines)d\n'\
299
 
            % self.__dict__
 
323
        yield (b'c %(parent)d %(parent_pos)d %(child_pos)d %(num_lines)d\n'
 
324
               % self._as_dict())
300
325
 
301
326
 
302
327
class BaseVersionedFile(object):
320
345
        if self.snapshot_interval is None:
321
346
            return False
322
347
        if self.max_snapshots is not None and\
323
 
            len(self._snapshots) == self.max_snapshots:
 
348
                len(self._snapshots) == self.max_snapshots:
324
349
            return False
325
350
        if len(parent_ids) == 0:
326
351
            return True
327
 
        for ignored in xrange(self.snapshot_interval):
 
352
        for ignored in range(self.snapshot_interval):
328
353
            if len(parent_ids) == 0:
329
354
                return False
330
355
            version_ids = parent_ids
388
413
            raise ValueError()
389
414
        revisions = set(vf.versions())
390
415
        total = len(revisions)
391
 
        pb = ui.ui_factory.nested_progress_bar()
392
 
        try:
 
416
        with ui.ui_factory.nested_progress_bar() as pb:
393
417
            while len(revisions) > 0:
394
418
                added = set()
395
419
                for revision in revisions:
396
420
                    parents = vf.get_parents(revision)
397
421
                    if [p for p in parents if p not in self._parents] != []:
398
422
                        continue
399
 
                    lines = [a + ' ' + l for a, l in
 
423
                    lines = [a + b' ' + l for a, l in
400
424
                             vf.annotate(revision)]
401
425
                    if snapshots is None:
402
426
                        force_snapshot = None
412
436
                            if not (lines == self.get_line_list([revision])[0]):
413
437
                                raise AssertionError()
414
438
                            self.clear_cache()
415
 
                    pb.update('Importing revisions',
 
439
                    pb.update(gettext('Importing revisions'),
416
440
                              (total - len(revisions)) + len(added), total)
417
441
                revisions = [r for r in revisions if r not in added]
418
 
        finally:
419
 
            pb.finished()
420
442
 
421
443
    def select_snapshots(self, vf):
422
444
        """Determine which versions to add as snapshots"""
423
445
        build_ancestors = {}
424
 
        descendants = {}
425
446
        snapshots = set()
426
447
        for version_id in topo_iter(vf):
427
448
            potential_build_ancestors = set(vf.get_parents(version_id))
448
469
    def get_size_ranking(self):
449
470
        """Get versions ranked by size"""
450
471
        versions = []
451
 
        new_snapshots = set()
452
472
        for version_id in self.versions():
453
473
            if version_id in self._snapshots:
454
474
                continue
482
502
        ranking = []
483
503
        while len(available_versions) > 0:
484
504
            available_versions.sort(key=lambda x:
485
 
                len(could_avoid[x]) *
486
 
                len(referenced_by.get(x, [])))
 
505
                                    len(could_avoid[x]) *
 
506
                                    len(referenced_by.get(x, [])))
487
507
            selected = available_versions.pop()
488
508
            ranking.append(selected)
489
509
            for version_id in referenced_by[selected]:
545
565
 
546
566
    def get_diff(self, version_id):
547
567
        start, count = self._diff_offset[version_id]
548
 
        infile = open(self._filename + '.mpknit', 'rb')
549
 
        try:
 
568
        with open(self._filename + '.mpknit', 'rb') as infile:
550
569
            infile.seek(start)
551
 
            sio = StringIO(infile.read(count))
552
 
        finally:
553
 
            infile.close()
554
 
        zip_file = GzipFile(None, mode='rb', fileobj=sio)
555
 
        try:
 
570
            sio = BytesIO(infile.read(count))
 
571
        with gzip.GzipFile(None, mode='rb', fileobj=sio) as zip_file:
556
572
            file_version_id = zip_file.readline()
557
 
            return MultiParent.from_patch(zip_file.read())
558
 
        finally:
559
 
            zip_file.close()
 
573
            content = zip_file.read()
 
574
            return MultiParent.from_patch(content)
560
575
 
561
576
    def add_diff(self, diff, version_id, parent_ids):
562
 
        outfile = open(self._filename + '.mpknit', 'ab')
563
 
        try:
 
577
        with open(self._filename + '.mpknit', 'ab') as outfile:
564
578
            outfile.seek(0, 2)      # workaround for windows bug:
565
 
                                    # .tell() for files opened in 'ab' mode
566
 
                                    # before any write returns 0
 
579
            # .tell() for files opened in 'ab' mode
 
580
            # before any write returns 0
567
581
            start = outfile.tell()
568
 
            try:
569
 
                zipfile = GzipFile(None, mode='ab', fileobj=outfile)
 
582
            with gzip.GzipFile(None, mode='ab', fileobj=outfile) as zipfile:
570
583
                zipfile.writelines(itertools.chain(
571
 
                    ['version %s\n' % version_id], diff.to_patch()))
572
 
            finally:
573
 
                zipfile.close()
 
584
                    [b'version %s\n' % version_id], diff.to_patch()))
574
585
            end = outfile.tell()
575
 
        finally:
576
 
            outfile.close()
577
 
        self._diff_offset[version_id] = (start, end-start)
 
586
        self._diff_offset[version_id] = (start, end - start)
578
587
        self._parents[version_id] = parent_ids
579
588
 
580
589
    def destroy(self):
581
590
        try:
582
591
            os.unlink(self._filename + '.mpknit')
583
 
        except OSError, e:
 
592
        except OSError as e:
584
593
            if e.errno != errno.ENOENT:
585
594
                raise
586
595
        try:
587
596
            os.unlink(self._filename + '.mpidx')
588
 
        except OSError, e:
 
597
        except OSError as e:
589
598
            if e.errno != errno.ENOENT:
590
599
                raise
591
600
 
631
640
                start, end, kind, data, iterator = self.cursor[req_version_id]
632
641
            except KeyError:
633
642
                iterator = self.diffs.get_diff(req_version_id).range_iterator()
634
 
                start, end, kind, data = iterator.next()
 
643
                start, end, kind, data = next(iterator)
635
644
            if start > req_start:
636
645
                iterator = self.diffs.get_diff(req_version_id).range_iterator()
637
 
                start, end, kind, data = iterator.next()
 
646
                start, end, kind, data = next(iterator)
638
647
 
639
648
            # find the first hunk relevant to the request
640
649
            while end <= req_start:
641
 
                start, end, kind, data = iterator.next()
 
650
                start, end, kind, data = next(iterator)
642
651
            self.cursor[req_version_id] = start, end, kind, data, iterator
643
652
            # if the hunk can't satisfy the whole request, split it in two,
644
653
            # and leave the second half for later.
662
671
 
663
672
 
664
673
def gzip_string(lines):
665
 
    sio = StringIO()
666
 
    data_file = GzipFile(None, mode='wb', fileobj=sio)
667
 
    data_file.writelines(lines)
668
 
    data_file.close()
 
674
    sio = BytesIO()
 
675
    with gzip.GzipFile(None, mode='wb', fileobj=sio) as data_file:
 
676
        data_file.writelines(lines)
669
677
    return sio.getvalue()