/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: Breezy landing bot
  • Author(s): Colin Watson
  • Date: 2020-11-16 21:47:08 UTC
  • mfrom: (7521.1.1 remove-lp-workaround)
  • Revision ID: breezy.the.bot@gmail.com-20201116214708-jos209mgxi41oy15
Remove breezy.git workaround for bazaar.launchpad.net.

Merged from https://code.launchpad.net/~cjwatson/brz/remove-lp-workaround/+merge/393710

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/multiparent.py
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 __future__ import absolute_import
 
17
import errno
 
18
from io import (
 
19
    BytesIO,
 
20
    )
 
21
import os
18
22
 
19
 
from bzrlib.lazy_import import lazy_import
 
23
from .lazy_import import lazy_import
20
24
 
21
25
lazy_import(globals(), """
22
 
import errno
23
26
import gzip
24
27
import itertools
25
 
import os
26
 
from StringIO import StringIO
 
28
import patiencediff
27
29
 
28
 
from bzrlib import (
 
30
from breezy import (
29
31
    bencode,
30
 
    errors,
31
 
    patiencediff,
32
32
    ui,
33
33
    )
34
34
""")
 
35
from . import (
 
36
    errors,
 
37
    )
 
38
from .i18n import gettext
35
39
 
36
40
 
37
41
def topo_iter_keys(vf, keys=None):
40
44
    parents = vf.get_parent_map(keys)
41
45
    return _topo_iter(parents, keys)
42
46
 
 
47
 
43
48
def topo_iter(vf, versions=None):
44
49
    if versions is None:
45
50
        versions = vf.versions()
46
51
    parents = vf.get_parent_map(versions)
47
52
    return _topo_iter(parents, versions)
48
53
 
 
54
 
49
55
def _topo_iter(parents, versions):
50
56
    seen = set()
51
57
    descendants = {}
 
58
 
52
59
    def pending_parents(version):
53
60
        if parents[version] is None:
54
61
            return []
112
119
        parent_text = []
113
120
        block_iter = [iter(i) for i in parent_comparisons]
114
121
        diff = MultiParent([])
 
122
 
115
123
        def next_block(p):
116
124
            try:
117
 
                return block_iter[p].next()
 
125
                return next(block_iter[p])
118
126
            except StopIteration:
119
127
                return None
120
128
        cur_block = [next_block(p) for p, i in enumerate(block_iter)]
165
173
        """Contruct a fulltext from this diff and its parents"""
166
174
        mpvf = MultiMemoryVersionedFile()
167
175
        for num, parent in enumerate(parents):
168
 
            mpvf.add_version(StringIO(parent).readlines(), num, [])
169
 
        mpvf.add_diff(self, 'a', range(len(parents)))
 
176
            mpvf.add_version(BytesIO(parent).readlines(), num, [])
 
177
        mpvf.add_diff(self, 'a', list(range(len(parents))))
170
178
        return mpvf.get_line_list(['a'])[0]
171
179
 
172
180
    @classmethod
173
181
    def from_texts(cls, text, parents=()):
174
182
        """Produce a MultiParent from a text and list of parent text"""
175
 
        return cls.from_lines(StringIO(text).readlines(),
176
 
                              [StringIO(p).readlines() for p in parents])
 
183
        return cls.from_lines(BytesIO(text).readlines(),
 
184
                              [BytesIO(p).readlines() for p in parents])
177
185
 
178
186
    def to_patch(self):
179
187
        """Yield text lines for a patch"""
182
190
                yield line
183
191
 
184
192
    def patch_len(self):
185
 
        return len(''.join(self.to_patch()))
 
193
        return len(b''.join(self.to_patch()))
186
194
 
187
195
    def zipped_patch_len(self):
188
196
        return len(gzip_string(self.to_patch()))
190
198
    @classmethod
191
199
    def from_patch(cls, text):
192
200
        """Create a MultiParent from its string form"""
193
 
        return cls._from_patch(StringIO(text))
 
201
        return cls._from_patch(BytesIO(text))
194
202
 
195
203
    @staticmethod
196
204
    def _from_patch(lines):
198
206
        line_iter = iter(lines)
199
207
        hunks = []
200
208
        cur_line = None
201
 
        while(True):
 
209
        while True:
202
210
            try:
203
 
                cur_line = line_iter.next()
 
211
                cur_line = next(line_iter)
204
212
            except StopIteration:
205
213
                break
206
 
            if cur_line[0] == 'i':
207
 
                num_lines = int(cur_line.split(' ')[1])
208
 
                hunk_lines = [line_iter.next() for x in xrange(num_lines)]
 
214
            first_char = cur_line[0:1]
 
215
            if first_char == b'i':
 
216
                num_lines = int(cur_line.split(b' ')[1])
 
217
                hunk_lines = [next(line_iter) for _ in range(num_lines)]
209
218
                hunk_lines[-1] = hunk_lines[-1][:-1]
210
219
                hunks.append(NewText(hunk_lines))
211
 
            elif cur_line[0] == '\n':
212
 
                hunks[-1].lines[-1] += '\n'
 
220
            elif first_char == b'\n':
 
221
                hunks[-1].lines[-1] += b'\n'
213
222
            else:
214
 
                if not (cur_line[0] == 'c'):
215
 
                    raise AssertionError(cur_line[0])
 
223
                if not (first_char == b'c'):
 
224
                    raise AssertionError(first_char)
216
225
                parent, parent_pos, child_pos, num_lines =\
217
 
                    [int(v) for v in cur_line.split(' ')[1:]]
 
226
                    [int(v) for v in cur_line.split(b' ')[1:]]
218
227
                hunks.append(ParentText(parent, parent_pos, child_pos,
219
228
                                        num_lines))
220
229
        return MultiParent(hunks)
247
256
        extra_n = 0
248
257
        for hunk in reversed(self.hunks):
249
258
            if isinstance(hunk, ParentText):
250
 
               return hunk.child_pos + hunk.num_lines + extra_n
 
259
                return hunk.child_pos + hunk.num_lines + extra_n
251
260
            extra_n += len(hunk.lines)
252
261
        return extra_n
253
262
 
275
284
        return 'NewText(%r)' % self.lines
276
285
 
277
286
    def to_patch(self):
278
 
        yield 'i %d\n' % len(self.lines)
 
287
        yield b'i %d\n' % len(self.lines)
279
288
        for line in self.lines:
280
289
            yield line
281
 
        yield '\n'
 
290
        yield b'\n'
282
291
 
283
292
 
284
293
class ParentText(object):
293
302
        self.num_lines = num_lines
294
303
 
295
304
    def _as_dict(self):
296
 
        return dict(parent=self.parent, parent_pos=self.parent_pos,
297
 
                    child_pos=self.child_pos, num_lines=self.num_lines)
 
305
        return {b'parent': self.parent,
 
306
                b'parent_pos': self.parent_pos,
 
307
                b'child_pos': self.child_pos,
 
308
                b'num_lines': self.num_lines}
298
309
 
299
310
    def __repr__(self):
300
311
        return ('ParentText(%(parent)r, %(parent_pos)r, %(child_pos)r,'
306
317
        return self._as_dict() == other._as_dict()
307
318
 
308
319
    def to_patch(self):
309
 
        yield ('c %(parent)d %(parent_pos)d %(child_pos)d %(num_lines)d\n'
 
320
        yield (b'c %(parent)d %(parent_pos)d %(child_pos)d %(num_lines)d\n'
310
321
               % self._as_dict())
311
322
 
312
323
 
331
342
        if self.snapshot_interval is None:
332
343
            return False
333
344
        if self.max_snapshots is not None and\
334
 
            len(self._snapshots) == self.max_snapshots:
 
345
                len(self._snapshots) == self.max_snapshots:
335
346
            return False
336
347
        if len(parent_ids) == 0:
337
348
            return True
338
 
        for ignored in xrange(self.snapshot_interval):
 
349
        for ignored in range(self.snapshot_interval):
339
350
            if len(parent_ids) == 0:
340
351
                return False
341
352
            version_ids = parent_ids
399
410
            raise ValueError()
400
411
        revisions = set(vf.versions())
401
412
        total = len(revisions)
402
 
        pb = ui.ui_factory.nested_progress_bar()
403
 
        try:
 
413
        with ui.ui_factory.nested_progress_bar() as pb:
404
414
            while len(revisions) > 0:
405
415
                added = set()
406
416
                for revision in revisions:
407
417
                    parents = vf.get_parents(revision)
408
418
                    if [p for p in parents if p not in self._parents] != []:
409
419
                        continue
410
 
                    lines = [a + ' ' + l for a, l in
 
420
                    lines = [a + b' ' + l for a, l in
411
421
                             vf.annotate(revision)]
412
422
                    if snapshots is None:
413
423
                        force_snapshot = None
426
436
                    pb.update(gettext('Importing revisions'),
427
437
                              (total - len(revisions)) + len(added), total)
428
438
                revisions = [r for r in revisions if r not in added]
429
 
        finally:
430
 
            pb.finished()
431
439
 
432
440
    def select_snapshots(self, vf):
433
441
        """Determine which versions to add as snapshots"""
434
442
        build_ancestors = {}
435
 
        descendants = {}
436
443
        snapshots = set()
437
444
        for version_id in topo_iter(vf):
438
445
            potential_build_ancestors = set(vf.get_parents(version_id))
459
466
    def get_size_ranking(self):
460
467
        """Get versions ranked by size"""
461
468
        versions = []
462
 
        new_snapshots = set()
463
469
        for version_id in self.versions():
464
470
            if version_id in self._snapshots:
465
471
                continue
493
499
        ranking = []
494
500
        while len(available_versions) > 0:
495
501
            available_versions.sort(key=lambda x:
496
 
                len(could_avoid[x]) *
497
 
                len(referenced_by.get(x, [])))
 
502
                                    len(could_avoid[x]) *
 
503
                                    len(referenced_by.get(x, [])))
498
504
            selected = available_versions.pop()
499
505
            ranking.append(selected)
500
506
            for version_id in referenced_by[selected]:
556
562
 
557
563
    def get_diff(self, version_id):
558
564
        start, count = self._diff_offset[version_id]
559
 
        infile = open(self._filename + '.mpknit', 'rb')
560
 
        try:
 
565
        with open(self._filename + '.mpknit', 'rb') as infile:
561
566
            infile.seek(start)
562
 
            sio = StringIO(infile.read(count))
563
 
        finally:
564
 
            infile.close()
565
 
        zip_file = gzip.GzipFile(None, mode='rb', fileobj=sio)
566
 
        try:
 
567
            sio = BytesIO(infile.read(count))
 
568
        with gzip.GzipFile(None, mode='rb', fileobj=sio) as zip_file:
567
569
            file_version_id = zip_file.readline()
568
570
            content = zip_file.read()
569
571
            return MultiParent.from_patch(content)
570
 
        finally:
571
 
            zip_file.close()
572
572
 
573
573
    def add_diff(self, diff, version_id, parent_ids):
574
 
        outfile = open(self._filename + '.mpknit', 'ab')
575
 
        try:
 
574
        with open(self._filename + '.mpknit', 'ab') as outfile:
576
575
            outfile.seek(0, 2)      # workaround for windows bug:
577
 
                                    # .tell() for files opened in 'ab' mode
578
 
                                    # before any write returns 0
 
576
            # .tell() for files opened in 'ab' mode
 
577
            # before any write returns 0
579
578
            start = outfile.tell()
580
 
            try:
581
 
                zipfile = gzip.GzipFile(None, mode='ab', fileobj=outfile)
 
579
            with gzip.GzipFile(None, mode='ab', fileobj=outfile) as zipfile:
582
580
                zipfile.writelines(itertools.chain(
583
 
                    ['version %s\n' % version_id], diff.to_patch()))
584
 
            finally:
585
 
                zipfile.close()
 
581
                    [b'version %s\n' % version_id], diff.to_patch()))
586
582
            end = outfile.tell()
587
 
        finally:
588
 
            outfile.close()
589
 
        self._diff_offset[version_id] = (start, end-start)
 
583
        self._diff_offset[version_id] = (start, end - start)
590
584
        self._parents[version_id] = parent_ids
591
585
 
592
586
    def destroy(self):
593
587
        try:
594
588
            os.unlink(self._filename + '.mpknit')
595
 
        except OSError, e:
 
589
        except OSError as e:
596
590
            if e.errno != errno.ENOENT:
597
591
                raise
598
592
        try:
599
593
            os.unlink(self._filename + '.mpidx')
600
 
        except OSError, e:
 
594
        except OSError as e:
601
595
            if e.errno != errno.ENOENT:
602
596
                raise
603
597
 
643
637
                start, end, kind, data, iterator = self.cursor[req_version_id]
644
638
            except KeyError:
645
639
                iterator = self.diffs.get_diff(req_version_id).range_iterator()
646
 
                start, end, kind, data = iterator.next()
 
640
                start, end, kind, data = next(iterator)
647
641
            if start > req_start:
648
642
                iterator = self.diffs.get_diff(req_version_id).range_iterator()
649
 
                start, end, kind, data = iterator.next()
 
643
                start, end, kind, data = next(iterator)
650
644
 
651
645
            # find the first hunk relevant to the request
652
646
            while end <= req_start:
653
 
                start, end, kind, data = iterator.next()
 
647
                start, end, kind, data = next(iterator)
654
648
            self.cursor[req_version_id] = start, end, kind, data, iterator
655
649
            # if the hunk can't satisfy the whole request, split it in two,
656
650
            # and leave the second half for later.
674
668
 
675
669
 
676
670
def gzip_string(lines):
677
 
    sio = StringIO()
678
 
    data_file = gzip.GzipFile(None, mode='wb', fileobj=sio)
679
 
    data_file.writelines(lines)
680
 
    data_file.close()
 
671
    sio = BytesIO()
 
672
    with gzip.GzipFile(None, mode='wb', fileobj=sio) as data_file:
 
673
        data_file.writelines(lines)
681
674
    return sio.getvalue()