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

  • Committer: Robert Collins
  • Date: 2010-05-06 23:41:35 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506234135-yivbzczw1sejxnxc
Lock methods on ``Tree``, ``Branch`` and ``Repository`` are now
expected to return an object which can be used to unlock them. This reduces
duplicate code when using cleanups. The previous 'tokens's returned by
``Branch.lock_write`` and ``Repository.lock_write`` are now attributes
on the result of the lock_write. ``repository.RepositoryWriteLockResult``
and ``branch.BranchWriteLockResult`` document this. (Robert Collins)

``log._get_info_for_log_files`` now takes an add_cleanup callable.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

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