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

  • Committer: Jelmer Vernooij
  • Date: 2017-05-21 12:41:27 UTC
  • mto: This revision was merged to the branch mainline in revision 6623.
  • Revision ID: jelmer@jelmer.uk-20170521124127-iv8etg0vwymyai6y
s/bzr/brz/ in apport config.

Show diffs side-by-side

added added

removed removed

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