16
16
# You should have received a copy of the GNU General Public License
17
17
# along with this program; if not, write to the Free Software
18
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
20
"""Versioned text file storage api."""
23
from cStringIO import StringIO
26
from zlib import adler32
22
28
from bzrlib.lazy_import import lazy_import
23
29
lazy_import(globals(), """
25
32
from bzrlib import (
43
from bzrlib.graph import DictParentsProvider, Graph, StackedParentsProvider
32
44
from bzrlib.transport.memory import MemoryTransport
35
46
from bzrlib.inter import InterObject
47
from bzrlib.registry import Registry
48
from bzrlib.symbol_versioning import *
36
49
from bzrlib.textmerge import TextMerge
37
from bzrlib.symbol_versioning import (deprecated_function,
50
from bzrlib import bencode
53
adapter_registry = Registry()
54
adapter_registry.register_lazy(('knit-delta-gz', 'fulltext'), 'bzrlib.knit',
55
'DeltaPlainToFullText')
56
adapter_registry.register_lazy(('knit-ft-gz', 'fulltext'), 'bzrlib.knit',
58
adapter_registry.register_lazy(('knit-annotated-delta-gz', 'knit-delta-gz'),
59
'bzrlib.knit', 'DeltaAnnotatedToUnannotated')
60
adapter_registry.register_lazy(('knit-annotated-delta-gz', 'fulltext'),
61
'bzrlib.knit', 'DeltaAnnotatedToFullText')
62
adapter_registry.register_lazy(('knit-annotated-ft-gz', 'knit-ft-gz'),
63
'bzrlib.knit', 'FTAnnotatedToUnannotated')
64
adapter_registry.register_lazy(('knit-annotated-ft-gz', 'fulltext'),
65
'bzrlib.knit', 'FTAnnotatedToFullText')
66
# adapter_registry.register_lazy(('knit-annotated-ft-gz', 'chunked'),
67
# 'bzrlib.knit', 'FTAnnotatedToChunked')
70
class ContentFactory(object):
71
"""Abstract interface for insertion and retrieval from a VersionedFile.
73
:ivar sha1: None, or the sha1 of the content fulltext.
74
:ivar storage_kind: The native storage kind of this factory. One of
75
'mpdiff', 'knit-annotated-ft', 'knit-annotated-delta', 'knit-ft',
76
'knit-delta', 'fulltext', 'knit-annotated-ft-gz',
77
'knit-annotated-delta-gz', 'knit-ft-gz', 'knit-delta-gz'.
78
:ivar key: The key of this content. Each key is a tuple with a single
80
:ivar parents: A tuple of parent keys for self.key. If the object has
81
no parent information, None (as opposed to () for an empty list of
86
"""Create a ContentFactory."""
88
self.storage_kind = None
93
class ChunkedContentFactory(ContentFactory):
94
"""Static data content factory.
96
This takes a 'chunked' list of strings. The only requirement on 'chunked' is
97
that ''.join(lines) becomes a valid fulltext. A tuple of a single string
98
satisfies this, as does a list of lines.
100
:ivar sha1: None, or the sha1 of the content fulltext.
101
:ivar storage_kind: The native storage kind of this factory. Always
103
:ivar key: The key of this content. Each key is a tuple with a single
105
:ivar parents: A tuple of parent keys for self.key. If the object has
106
no parent information, None (as opposed to () for an empty list of
110
def __init__(self, key, parents, sha1, chunks):
111
"""Create a ContentFactory."""
113
self.storage_kind = 'chunked'
115
self.parents = parents
116
self._chunks = chunks
118
def get_bytes_as(self, storage_kind):
119
if storage_kind == 'chunked':
121
elif storage_kind == 'fulltext':
122
return ''.join(self._chunks)
123
raise errors.UnavailableRepresentation(self.key, storage_kind,
127
class FulltextContentFactory(ContentFactory):
128
"""Static data content factory.
130
This takes a fulltext when created and just returns that during
131
get_bytes_as('fulltext').
133
:ivar sha1: None, or the sha1 of the content fulltext.
134
:ivar storage_kind: The native storage kind of this factory. Always
136
:ivar key: The key of this content. Each key is a tuple with a single
138
:ivar parents: A tuple of parent keys for self.key. If the object has
139
no parent information, None (as opposed to () for an empty list of
143
def __init__(self, key, parents, sha1, text):
144
"""Create a ContentFactory."""
146
self.storage_kind = 'fulltext'
148
self.parents = parents
151
def get_bytes_as(self, storage_kind):
152
if storage_kind == self.storage_kind:
154
elif storage_kind == 'chunked':
156
raise errors.UnavailableRepresentation(self.key, storage_kind,
160
class AbsentContentFactory(ContentFactory):
161
"""A placeholder content factory for unavailable texts.
164
:ivar storage_kind: 'absent'.
165
:ivar key: The key of this content. Each key is a tuple with a single
170
def __init__(self, key):
171
"""Create a ContentFactory."""
173
self.storage_kind = 'absent'
178
class AdapterFactory(ContentFactory):
179
"""A content factory to adapt between key prefix's."""
181
def __init__(self, key, parents, adapted):
182
"""Create an adapter factory instance."""
184
self.parents = parents
185
self._adapted = adapted
187
def __getattr__(self, attr):
188
"""Return a member from the adapted object."""
189
if attr in ('key', 'parents'):
190
return self.__dict__[attr]
192
return getattr(self._adapted, attr)
195
def filter_absent(record_stream):
196
"""Adapt a record stream to remove absent records."""
197
for record in record_stream:
198
if record.storage_kind != 'absent':
43
202
class VersionedFile(object):
44
203
"""Versioned text file storage.
46
205
A versioned file manages versions of line-based text files,
47
206
keeping track of the originating version for each line.
180
332
if '\n' in line[:-1]:
181
333
raise errors.BzrBadParameterContainsNewline("lines")
183
def _check_write_ok(self):
184
"""Is the versioned file marked as 'finished' ? Raise if it is."""
186
raise errors.OutSideTransaction()
187
if self._access_mode != 'w':
188
raise errors.ReadOnlyObjectDirtiedError(self)
190
def enable_cache(self):
191
"""Tell this versioned file that it should cache any data it reads.
193
This is advisory, implementations do not have to support caching.
197
def clear_cache(self):
198
"""Remove any data cached in the versioned file object.
200
This only needs to be supported if caches are supported
204
def clone_text(self, new_version_id, old_version_id, parents):
205
"""Add an identical text to old_version_id as new_version_id.
207
Must raise RevisionNotPresent if the old version or any of the
208
parents are not present in file history.
210
Must raise RevisionAlreadyPresent if the new version is
211
already present in file history."""
212
new_version_id = osutils.safe_revision_id(new_version_id)
213
old_version_id = osutils.safe_revision_id(old_version_id)
214
self._check_write_ok()
215
return self._clone_text(new_version_id, old_version_id, parents)
217
def _clone_text(self, new_version_id, old_version_id, parents):
218
"""Helper function to do the _clone_text work."""
219
raise NotImplementedError(self.clone_text)
221
def create_empty(self, name, transport, mode=None):
222
"""Create a new versioned file of this exact type.
224
:param name: the file name
225
:param transport: the transport
226
:param mode: optional file mode.
228
raise NotImplementedError(self.create_empty)
230
def fix_parents(self, version_id, new_parents):
231
"""Fix the parents list for version.
233
This is done by appending a new version to the index
234
with identical data except for the parents list.
235
the parents list must be a superset of the current
238
version_id = osutils.safe_revision_id(version_id)
239
new_parents = [osutils.safe_revision_id(p) for p in new_parents]
240
self._check_write_ok()
241
return self._fix_parents(version_id, new_parents)
243
def _fix_parents(self, version_id, new_parents):
244
"""Helper for fix_parents."""
245
raise NotImplementedError(self.fix_parents)
247
def get_delta(self, version):
248
"""Get a delta for constructing version from some other version.
250
:return: (delta_parent, sha1, noeol, delta)
251
Where delta_parent is a version id or None to indicate no parent.
253
raise NotImplementedError(self.get_delta)
255
def get_deltas(self, version_ids):
256
"""Get multiple deltas at once for constructing versions.
258
:return: dict(version_id:(delta_parent, sha1, noeol, delta))
259
Where delta_parent is a version id or None to indicate no parent, and
260
version_id is the version_id created by that delta.
263
for version_id in version_ids:
264
result[version_id] = self.get_delta(version_id)
267
def get_sha1(self, version_id):
268
"""Get the stored sha1 sum for the given revision.
270
:param name: The name of the version to lookup
272
raise NotImplementedError(self.get_sha1)
274
def get_suffixes(self):
275
"""Return the file suffixes associated with this versioned file."""
276
raise NotImplementedError(self.get_suffixes)
335
def get_format_signature(self):
336
"""Get a text description of the data encoding in this file.
340
raise NotImplementedError(self.get_format_signature)
342
def make_mpdiffs(self, version_ids):
343
"""Create multiparent diffs for specified versions."""
344
knit_versions = set()
345
knit_versions.update(version_ids)
346
parent_map = self.get_parent_map(version_ids)
347
for version_id in version_ids:
349
knit_versions.update(parent_map[version_id])
351
raise errors.RevisionNotPresent(version_id, self)
352
# We need to filter out ghosts, because we can't diff against them.
353
knit_versions = set(self.get_parent_map(knit_versions).keys())
354
lines = dict(zip(knit_versions,
355
self._get_lf_split_line_list(knit_versions)))
357
for version_id in version_ids:
358
target = lines[version_id]
360
parents = [lines[p] for p in parent_map[version_id] if p in
363
# I don't know how this could ever trigger.
364
# parent_map[version_id] was already triggered in the previous
365
# for loop, and lines[p] has the 'if p in knit_versions' check,
366
# so we again won't have a KeyError.
367
raise errors.RevisionNotPresent(version_id, self)
369
left_parent_blocks = self._extract_blocks(version_id,
372
left_parent_blocks = None
373
diffs.append(multiparent.MultiParent.from_lines(target, parents,
377
def _extract_blocks(self, version_id, source, target):
380
def add_mpdiffs(self, records):
381
"""Add mpdiffs to this VersionedFile.
383
Records should be iterables of version, parents, expected_sha1,
384
mpdiff. mpdiff should be a MultiParent instance.
386
# Does this need to call self._check_write_ok()? (IanC 20070919)
388
mpvf = multiparent.MultiMemoryVersionedFile()
390
for version, parent_ids, expected_sha1, mpdiff in records:
391
versions.append(version)
392
mpvf.add_diff(mpdiff, version, parent_ids)
393
needed_parents = set()
394
for version, parent_ids, expected_sha1, mpdiff in records:
395
needed_parents.update(p for p in parent_ids
396
if not mpvf.has_version(p))
397
present_parents = set(self.get_parent_map(needed_parents).keys())
398
for parent_id, lines in zip(present_parents,
399
self._get_lf_split_line_list(present_parents)):
400
mpvf.add_version(lines, parent_id, [])
401
for (version, parent_ids, expected_sha1, mpdiff), lines in\
402
zip(records, mpvf.get_line_list(versions)):
403
if len(parent_ids) == 1:
404
left_matching_blocks = list(mpdiff.get_matching_blocks(0,
405
mpvf.get_diff(parent_ids[0]).num_lines()))
407
left_matching_blocks = None
409
_, _, version_text = self.add_lines_with_ghosts(version,
410
parent_ids, lines, vf_parents,
411
left_matching_blocks=left_matching_blocks)
412
except NotImplementedError:
413
# The vf can't handle ghosts, so add lines normally, which will
414
# (reasonably) fail if there are ghosts in the data.
415
_, _, version_text = self.add_lines(version,
416
parent_ids, lines, vf_parents,
417
left_matching_blocks=left_matching_blocks)
418
vf_parents[version] = version_text
419
sha1s = self.get_sha1s(versions)
420
for version, parent_ids, expected_sha1, mpdiff in records:
421
if expected_sha1 != sha1s[version]:
422
raise errors.VersionedFileInvalidChecksum(version)
278
424
def get_text(self, version_id):
279
425
"""Return version contents as a text string.
488
542
unchanged Alive in both a and b (possibly created in both)
489
543
new-a Created in a
490
544
new-b Created in b
491
ghost-a Killed in a, unborn in b
545
ghost-a Killed in a, unborn in b
492
546
ghost-b Killed in b, unborn in a
493
547
irrelevant Not in either revision
495
549
raise NotImplementedError(VersionedFile.plan_merge)
497
551
def weave_merge(self, plan, a_marker=TextMerge.A_MARKER,
498
552
b_marker=TextMerge.B_MARKER):
499
553
return PlanWeaveMerge(plan, a_marker, b_marker).merge_lines()[0]
556
class RecordingVersionedFilesDecorator(object):
557
"""A minimal versioned files that records calls made on it.
559
Only enough methods have been added to support tests using it to date.
561
:ivar calls: A list of the calls made; can be reset at any time by
565
def __init__(self, backing_vf):
566
"""Create a RecordingVersionedFilesDecorator decorating backing_vf.
568
:param backing_vf: The versioned file to answer all methods.
570
self._backing_vf = backing_vf
573
def add_lines(self, key, parents, lines, parent_texts=None,
574
left_matching_blocks=None, nostore_sha=None, random_id=False,
576
self.calls.append(("add_lines", key, parents, lines, parent_texts,
577
left_matching_blocks, nostore_sha, random_id, check_content))
578
return self._backing_vf.add_lines(key, parents, lines, parent_texts,
579
left_matching_blocks, nostore_sha, random_id, check_content)
582
self._backing_vf.check()
584
def get_parent_map(self, keys):
585
self.calls.append(("get_parent_map", copy(keys)))
586
return self._backing_vf.get_parent_map(keys)
588
def get_record_stream(self, keys, sort_order, include_delta_closure):
589
self.calls.append(("get_record_stream", list(keys), sort_order,
590
include_delta_closure))
591
return self._backing_vf.get_record_stream(keys, sort_order,
592
include_delta_closure)
594
def get_sha1s(self, keys):
595
self.calls.append(("get_sha1s", copy(keys)))
596
return self._backing_vf.get_sha1s(keys)
598
def iter_lines_added_or_present_in_keys(self, keys, pb=None):
599
self.calls.append(("iter_lines_added_or_present_in_keys", copy(keys)))
600
return self._backing_vf.iter_lines_added_or_present_in_keys(keys, pb=pb)
603
self.calls.append(("keys",))
604
return self._backing_vf.keys()
607
class OrderingVersionedFilesDecorator(RecordingVersionedFilesDecorator):
608
"""A VF that records calls, and returns keys in specific order.
610
:ivar calls: A list of the calls made; can be reset at any time by
614
def __init__(self, backing_vf, key_priority):
615
"""Create a RecordingVersionedFilesDecorator decorating backing_vf.
617
:param backing_vf: The versioned file to answer all methods.
618
:param key_priority: A dictionary defining what order keys should be
619
returned from an 'unordered' get_record_stream request.
620
Keys with lower priority are returned first, keys not present in
621
the map get an implicit priority of 0, and are returned in
622
lexicographical order.
624
RecordingVersionedFilesDecorator.__init__(self, backing_vf)
625
self._key_priority = key_priority
627
def get_record_stream(self, keys, sort_order, include_delta_closure):
628
self.calls.append(("get_record_stream", list(keys), sort_order,
629
include_delta_closure))
630
if sort_order == 'unordered':
632
return (self._key_priority.get(key, 0), key)
633
# Use a defined order by asking for the keys one-by-one from the
635
for key in sorted(keys, key=sort_key):
636
for record in self._backing_vf.get_record_stream([key],
637
'unordered', include_delta_closure):
640
for record in self._backing_vf.get_record_stream(keys, sort_order,
641
include_delta_closure):
645
class KeyMapper(object):
646
"""KeyMappers map between keys and underlying partitioned storage."""
649
"""Map key to an underlying storage identifier.
651
:param key: A key tuple e.g. ('file-id', 'revision-id').
652
:return: An underlying storage identifier, specific to the partitioning
655
raise NotImplementedError(self.map)
657
def unmap(self, partition_id):
658
"""Map a partitioned storage id back to a key prefix.
660
:param partition_id: The underlying partition id.
661
:return: As much of a key (or prefix) as is derivable from the partition
664
raise NotImplementedError(self.unmap)
667
class ConstantMapper(KeyMapper):
668
"""A key mapper that maps to a constant result."""
670
def __init__(self, result):
671
"""Create a ConstantMapper which will return result for all maps."""
672
self._result = result
675
"""See KeyMapper.map()."""
679
class URLEscapeMapper(KeyMapper):
680
"""Base class for use with transport backed storage.
682
This provides a map and unmap wrapper that respectively url escape and
683
unescape their outputs and inputs.
687
"""See KeyMapper.map()."""
688
return urllib.quote(self._map(key))
690
def unmap(self, partition_id):
691
"""See KeyMapper.unmap()."""
692
return self._unmap(urllib.unquote(partition_id))
695
class PrefixMapper(URLEscapeMapper):
696
"""A key mapper that extracts the first component of a key.
698
This mapper is for use with a transport based backend.
702
"""See KeyMapper.map()."""
705
def _unmap(self, partition_id):
706
"""See KeyMapper.unmap()."""
707
return (partition_id,)
710
class HashPrefixMapper(URLEscapeMapper):
711
"""A key mapper that combines the first component of a key with a hash.
713
This mapper is for use with a transport based backend.
717
"""See KeyMapper.map()."""
718
prefix = self._escape(key[0])
719
return "%02x/%s" % (adler32(prefix) & 0xff, prefix)
721
def _escape(self, prefix):
722
"""No escaping needed here."""
725
def _unmap(self, partition_id):
726
"""See KeyMapper.unmap()."""
727
return (self._unescape(osutils.basename(partition_id)),)
729
def _unescape(self, basename):
730
"""No unescaping needed for HashPrefixMapper."""
734
class HashEscapedPrefixMapper(HashPrefixMapper):
735
"""Combines the escaped first component of a key with a hash.
737
This mapper is for use with a transport based backend.
740
_safe = "abcdefghijklmnopqrstuvwxyz0123456789-_@,."
742
def _escape(self, prefix):
743
"""Turn a key element into a filesystem safe string.
745
This is similar to a plain urllib.quote, except
746
it uses specific safe characters, so that it doesn't
747
have to translate a lot of valid file ids.
749
# @ does not get escaped. This is because it is a valid
750
# filesystem character we use all the time, and it looks
751
# a lot better than seeing %40 all the time.
752
r = [((c in self._safe) and c or ('%%%02x' % ord(c)))
756
def _unescape(self, basename):
757
"""Escaped names are easily unescaped by urlutils."""
758
return urllib.unquote(basename)
761
def make_versioned_files_factory(versioned_file_factory, mapper):
762
"""Create a ThunkedVersionedFiles factory.
764
This will create a callable which when called creates a
765
ThunkedVersionedFiles on a transport, using mapper to access individual
766
versioned files, and versioned_file_factory to create each individual file.
768
def factory(transport):
769
return ThunkedVersionedFiles(transport, versioned_file_factory, mapper,
774
class VersionedFiles(object):
775
"""Storage for many versioned files.
777
This object allows a single keyspace for accessing the history graph and
778
contents of named bytestrings.
780
Currently no implementation allows the graph of different key prefixes to
781
intersect, but the API does allow such implementations in the future.
783
The keyspace is expressed via simple tuples. Any instance of VersionedFiles
784
may have a different length key-size, but that size will be constant for
785
all texts added to or retrieved from it. For instance, bzrlib uses
786
instances with a key-size of 2 for storing user files in a repository, with
787
the first element the fileid, and the second the version of that file.
789
The use of tuples allows a single code base to support several different
790
uses with only the mapping logic changing from instance to instance.
793
def add_lines(self, key, parents, lines, parent_texts=None,
794
left_matching_blocks=None, nostore_sha=None, random_id=False,
796
"""Add a text to the store.
798
:param key: The key tuple of the text to add. If the last element is
799
None, a CHK string will be generated during the addition.
800
:param parents: The parents key tuples of the text to add.
801
:param lines: A list of lines. Each line must be a bytestring. And all
802
of them except the last must be terminated with \n and contain no
803
other \n's. The last line may either contain no \n's or a single
804
terminating \n. If the lines list does meet this constraint the add
805
routine may error or may succeed - but you will be unable to read
806
the data back accurately. (Checking the lines have been split
807
correctly is expensive and extremely unlikely to catch bugs so it
808
is not done at runtime unless check_content is True.)
809
:param parent_texts: An optional dictionary containing the opaque
810
representations of some or all of the parents of version_id to
811
allow delta optimisations. VERY IMPORTANT: the texts must be those
812
returned by add_lines or data corruption can be caused.
813
:param left_matching_blocks: a hint about which areas are common
814
between the text and its left-hand-parent. The format is
815
the SequenceMatcher.get_matching_blocks format.
816
:param nostore_sha: Raise ExistingContent and do not add the lines to
817
the versioned file if the digest of the lines matches this.
818
:param random_id: If True a random id has been selected rather than
819
an id determined by some deterministic process such as a converter
820
from a foreign VCS. When True the backend may choose not to check
821
for uniqueness of the resulting key within the versioned file, so
822
this should only be done when the result is expected to be unique
824
:param check_content: If True, the lines supplied are verified to be
825
bytestrings that are correctly formed lines.
826
:return: The text sha1, the number of bytes in the text, and an opaque
827
representation of the inserted version which can be provided
828
back to future add_lines calls in the parent_texts dictionary.
830
raise NotImplementedError(self.add_lines)
832
def _add_text(self, key, parents, text, nostore_sha=None, random_id=False):
833
"""Add a text to the store.
835
This is a private function for use by CommitBuilder.
837
:param key: The key tuple of the text to add. If the last element is
838
None, a CHK string will be generated during the addition.
839
:param parents: The parents key tuples of the text to add.
840
:param text: A string containing the text to be committed.
841
:param nostore_sha: Raise ExistingContent and do not add the lines to
842
the versioned file if the digest of the lines matches this.
843
:param random_id: If True a random id has been selected rather than
844
an id determined by some deterministic process such as a converter
845
from a foreign VCS. When True the backend may choose not to check
846
for uniqueness of the resulting key within the versioned file, so
847
this should only be done when the result is expected to be unique
849
:param check_content: If True, the lines supplied are verified to be
850
bytestrings that are correctly formed lines.
851
:return: The text sha1, the number of bytes in the text, and an opaque
852
representation of the inserted version which can be provided
853
back to future _add_text calls in the parent_texts dictionary.
855
# The default implementation just thunks over to .add_lines(),
856
# inefficient, but it works.
857
return self.add_lines(key, parents, osutils.split_lines(text),
858
nostore_sha=nostore_sha,
862
def add_mpdiffs(self, records):
863
"""Add mpdiffs to this VersionedFile.
865
Records should be iterables of version, parents, expected_sha1,
866
mpdiff. mpdiff should be a MultiParent instance.
869
mpvf = multiparent.MultiMemoryVersionedFile()
871
for version, parent_ids, expected_sha1, mpdiff in records:
872
versions.append(version)
873
mpvf.add_diff(mpdiff, version, parent_ids)
874
needed_parents = set()
875
for version, parent_ids, expected_sha1, mpdiff in records:
876
needed_parents.update(p for p in parent_ids
877
if not mpvf.has_version(p))
878
# It seems likely that adding all the present parents as fulltexts can
879
# easily exhaust memory.
880
chunks_to_lines = osutils.chunks_to_lines
881
for record in self.get_record_stream(needed_parents, 'unordered',
883
if record.storage_kind == 'absent':
885
mpvf.add_version(chunks_to_lines(record.get_bytes_as('chunked')),
887
for (key, parent_keys, expected_sha1, mpdiff), lines in\
888
zip(records, mpvf.get_line_list(versions)):
889
if len(parent_keys) == 1:
890
left_matching_blocks = list(mpdiff.get_matching_blocks(0,
891
mpvf.get_diff(parent_keys[0]).num_lines()))
893
left_matching_blocks = None
894
version_sha1, _, version_text = self.add_lines(key,
895
parent_keys, lines, vf_parents,
896
left_matching_blocks=left_matching_blocks)
897
if version_sha1 != expected_sha1:
898
raise errors.VersionedFileInvalidChecksum(version)
899
vf_parents[key] = version_text
901
def annotate(self, key):
902
"""Return a list of (version-key, line) tuples for the text of key.
904
:raise RevisionNotPresent: If the key is not present.
906
raise NotImplementedError(self.annotate)
908
def check(self, progress_bar=None):
909
"""Check this object for integrity."""
910
raise NotImplementedError(self.check)
913
def check_not_reserved_id(version_id):
914
revision.check_not_reserved_id(version_id)
916
def _check_lines_not_unicode(self, lines):
917
"""Check that lines being added to a versioned file are not unicode."""
919
if line.__class__ is not str:
920
raise errors.BzrBadParameterUnicode("lines")
922
def _check_lines_are_lines(self, lines):
923
"""Check that the lines really are full lines without inline EOL."""
925
if '\n' in line[:-1]:
926
raise errors.BzrBadParameterContainsNewline("lines")
928
def get_parent_map(self, keys):
929
"""Get a map of the parents of keys.
931
:param keys: The keys to look up parents for.
932
:return: A mapping from keys to parents. Absent keys are absent from
935
raise NotImplementedError(self.get_parent_map)
937
def get_record_stream(self, keys, ordering, include_delta_closure):
938
"""Get a stream of records for keys.
940
:param keys: The keys to include.
941
:param ordering: Either 'unordered' or 'topological'. A topologically
942
sorted stream has compression parents strictly before their
944
:param include_delta_closure: If True then the closure across any
945
compression parents will be included (in the opaque data).
946
:return: An iterator of ContentFactory objects, each of which is only
947
valid until the iterator is advanced.
949
raise NotImplementedError(self.get_record_stream)
951
def get_sha1s(self, keys):
952
"""Get the sha1's of the texts for the given keys.
954
:param keys: The names of the keys to lookup
955
:return: a dict from key to sha1 digest. Keys of texts which are not
956
present in the store are not present in the returned
959
raise NotImplementedError(self.get_sha1s)
961
has_key = index._has_key_from_parent_map
963
def get_missing_compression_parent_keys(self):
964
"""Return an iterable of keys of missing compression parents.
966
Check this after calling insert_record_stream to find out if there are
967
any missing compression parents. If there are, the records that
968
depend on them are not able to be inserted safely. The precise
969
behaviour depends on the concrete VersionedFiles class in use.
971
Classes that do not support this will raise NotImplementedError.
973
raise NotImplementedError(self.get_missing_compression_parent_keys)
975
def insert_record_stream(self, stream):
976
"""Insert a record stream into this container.
978
:param stream: A stream of records to insert.
980
:seealso VersionedFile.get_record_stream:
982
raise NotImplementedError
984
def iter_lines_added_or_present_in_keys(self, keys, pb=None):
985
"""Iterate over the lines in the versioned files from keys.
987
This may return lines from other keys. Each item the returned
988
iterator yields is a tuple of a line and a text version that that line
989
is present in (not introduced in).
991
Ordering of results is in whatever order is most suitable for the
992
underlying storage format.
994
If a progress bar is supplied, it may be used to indicate progress.
995
The caller is responsible for cleaning up progress bars (because this
999
* Lines are normalised by the underlying store: they will all have \n
1001
* Lines are returned in arbitrary order.
1003
:return: An iterator over (line, key).
1005
raise NotImplementedError(self.iter_lines_added_or_present_in_keys)
1008
"""Return a iterable of the keys for all the contained texts."""
1009
raise NotImplementedError(self.keys)
1011
def make_mpdiffs(self, keys):
1012
"""Create multiparent diffs for specified keys."""
1013
keys_order = tuple(keys)
1014
keys = frozenset(keys)
1015
knit_keys = set(keys)
1016
parent_map = self.get_parent_map(keys)
1017
for parent_keys in parent_map.itervalues():
1019
knit_keys.update(parent_keys)
1020
missing_keys = keys - set(parent_map)
1022
raise errors.RevisionNotPresent(list(missing_keys)[0], self)
1023
# We need to filter out ghosts, because we can't diff against them.
1024
maybe_ghosts = knit_keys - keys
1025
ghosts = maybe_ghosts - set(self.get_parent_map(maybe_ghosts))
1026
knit_keys.difference_update(ghosts)
1028
chunks_to_lines = osutils.chunks_to_lines
1029
for record in self.get_record_stream(knit_keys, 'topological', True):
1030
lines[record.key] = chunks_to_lines(record.get_bytes_as('chunked'))
1031
# line_block_dict = {}
1032
# for parent, blocks in record.extract_line_blocks():
1033
# line_blocks[parent] = blocks
1034
# line_blocks[record.key] = line_block_dict
1036
for key in keys_order:
1038
parents = parent_map[key] or []
1039
# Note that filtering knit_keys can lead to a parent difference
1040
# between the creation and the application of the mpdiff.
1041
parent_lines = [lines[p] for p in parents if p in knit_keys]
1042
if len(parent_lines) > 0:
1043
left_parent_blocks = self._extract_blocks(key, parent_lines[0],
1046
left_parent_blocks = None
1047
diffs.append(multiparent.MultiParent.from_lines(target,
1048
parent_lines, left_parent_blocks))
1051
missing_keys = index._missing_keys_from_parent_map
1053
def _extract_blocks(self, version_id, source, target):
1057
class ThunkedVersionedFiles(VersionedFiles):
1058
"""Storage for many versioned files thunked onto a 'VersionedFile' class.
1060
This object allows a single keyspace for accessing the history graph and
1061
contents of named bytestrings.
1063
Currently no implementation allows the graph of different key prefixes to
1064
intersect, but the API does allow such implementations in the future.
1067
def __init__(self, transport, file_factory, mapper, is_locked):
1068
"""Create a ThunkedVersionedFiles."""
1069
self._transport = transport
1070
self._file_factory = file_factory
1071
self._mapper = mapper
1072
self._is_locked = is_locked
1074
def add_lines(self, key, parents, lines, parent_texts=None,
1075
left_matching_blocks=None, nostore_sha=None, random_id=False,
1076
check_content=True):
1077
"""See VersionedFiles.add_lines()."""
1078
path = self._mapper.map(key)
1079
version_id = key[-1]
1080
parents = [parent[-1] for parent in parents]
1081
vf = self._get_vf(path)
1084
return vf.add_lines_with_ghosts(version_id, parents, lines,
1085
parent_texts=parent_texts,
1086
left_matching_blocks=left_matching_blocks,
1087
nostore_sha=nostore_sha, random_id=random_id,
1088
check_content=check_content)
1089
except NotImplementedError:
1090
return vf.add_lines(version_id, parents, lines,
1091
parent_texts=parent_texts,
1092
left_matching_blocks=left_matching_blocks,
1093
nostore_sha=nostore_sha, random_id=random_id,
1094
check_content=check_content)
1095
except errors.NoSuchFile:
1096
# parent directory may be missing, try again.
1097
self._transport.mkdir(osutils.dirname(path))
1099
return vf.add_lines_with_ghosts(version_id, parents, lines,
1100
parent_texts=parent_texts,
1101
left_matching_blocks=left_matching_blocks,
1102
nostore_sha=nostore_sha, random_id=random_id,
1103
check_content=check_content)
1104
except NotImplementedError:
1105
return vf.add_lines(version_id, parents, lines,
1106
parent_texts=parent_texts,
1107
left_matching_blocks=left_matching_blocks,
1108
nostore_sha=nostore_sha, random_id=random_id,
1109
check_content=check_content)
1111
def annotate(self, key):
1112
"""Return a list of (version-key, line) tuples for the text of key.
1114
:raise RevisionNotPresent: If the key is not present.
1117
path = self._mapper.map(prefix)
1118
vf = self._get_vf(path)
1119
origins = vf.annotate(key[-1])
1121
for origin, line in origins:
1122
result.append((prefix + (origin,), line))
1125
def check(self, progress_bar=None):
1126
"""See VersionedFiles.check()."""
1127
for prefix, vf in self._iter_all_components():
1130
def get_parent_map(self, keys):
1131
"""Get a map of the parents of keys.
1133
:param keys: The keys to look up parents for.
1134
:return: A mapping from keys to parents. Absent keys are absent from
1137
prefixes = self._partition_keys(keys)
1139
for prefix, suffixes in prefixes.items():
1140
path = self._mapper.map(prefix)
1141
vf = self._get_vf(path)
1142
parent_map = vf.get_parent_map(suffixes)
1143
for key, parents in parent_map.items():
1144
result[prefix + (key,)] = tuple(
1145
prefix + (parent,) for parent in parents)
1148
def _get_vf(self, path):
1149
if not self._is_locked():
1150
raise errors.ObjectNotLocked(self)
1151
return self._file_factory(path, self._transport, create=True,
1152
get_scope=lambda:None)
1154
def _partition_keys(self, keys):
1155
"""Turn keys into a dict of prefix:suffix_list."""
1158
prefix_keys = result.setdefault(key[:-1], [])
1159
prefix_keys.append(key[-1])
1162
def _get_all_prefixes(self):
1163
# Identify all key prefixes.
1164
# XXX: A bit hacky, needs polish.
1165
if type(self._mapper) == ConstantMapper:
1166
paths = [self._mapper.map(())]
1170
for quoted_relpath in self._transport.iter_files_recursive():
1171
path, ext = os.path.splitext(quoted_relpath)
1173
paths = list(relpaths)
1174
prefixes = [self._mapper.unmap(path) for path in paths]
1175
return zip(paths, prefixes)
1177
def get_record_stream(self, keys, ordering, include_delta_closure):
1178
"""See VersionedFiles.get_record_stream()."""
1179
# Ordering will be taken care of by each partitioned store; group keys
1182
for prefix, suffixes, vf in self._iter_keys_vf(keys):
1183
suffixes = [(suffix,) for suffix in suffixes]
1184
for record in vf.get_record_stream(suffixes, ordering,
1185
include_delta_closure):
1186
if record.parents is not None:
1187
record.parents = tuple(
1188
prefix + parent for parent in record.parents)
1189
record.key = prefix + record.key
1192
def _iter_keys_vf(self, keys):
1193
prefixes = self._partition_keys(keys)
1195
for prefix, suffixes in prefixes.items():
1196
path = self._mapper.map(prefix)
1197
vf = self._get_vf(path)
1198
yield prefix, suffixes, vf
1200
def get_sha1s(self, keys):
1201
"""See VersionedFiles.get_sha1s()."""
1203
for prefix,suffixes, vf in self._iter_keys_vf(keys):
1204
vf_sha1s = vf.get_sha1s(suffixes)
1205
for suffix, sha1 in vf_sha1s.iteritems():
1206
sha1s[prefix + (suffix,)] = sha1
1209
def insert_record_stream(self, stream):
1210
"""Insert a record stream into this container.
1212
:param stream: A stream of records to insert.
1214
:seealso VersionedFile.get_record_stream:
1216
for record in stream:
1217
prefix = record.key[:-1]
1218
key = record.key[-1:]
1219
if record.parents is not None:
1220
parents = [parent[-1:] for parent in record.parents]
1223
thunk_record = AdapterFactory(key, parents, record)
1224
path = self._mapper.map(prefix)
1225
# Note that this parses the file many times; we can do better but
1226
# as this only impacts weaves in terms of performance, it is
1228
vf = self._get_vf(path)
1229
vf.insert_record_stream([thunk_record])
1231
def iter_lines_added_or_present_in_keys(self, keys, pb=None):
1232
"""Iterate over the lines in the versioned files from keys.
1234
This may return lines from other keys. Each item the returned
1235
iterator yields is a tuple of a line and a text version that that line
1236
is present in (not introduced in).
1238
Ordering of results is in whatever order is most suitable for the
1239
underlying storage format.
1241
If a progress bar is supplied, it may be used to indicate progress.
1242
The caller is responsible for cleaning up progress bars (because this
1246
* Lines are normalised by the underlying store: they will all have \n
1248
* Lines are returned in arbitrary order.
1250
:return: An iterator over (line, key).
1252
for prefix, suffixes, vf in self._iter_keys_vf(keys):
1253
for line, version in vf.iter_lines_added_or_present_in_versions(suffixes):
1254
yield line, prefix + (version,)
1256
def _iter_all_components(self):
1257
for path, prefix in self._get_all_prefixes():
1258
yield prefix, self._get_vf(path)
1261
"""See VersionedFiles.keys()."""
1263
for prefix, vf in self._iter_all_components():
1264
for suffix in vf.versions():
1265
result.add(prefix + (suffix,))
1269
class _PlanMergeVersionedFile(VersionedFiles):
1270
"""A VersionedFile for uncommitted and committed texts.
1272
It is intended to allow merges to be planned with working tree texts.
1273
It implements only the small part of the VersionedFiles interface used by
1274
PlanMerge. It falls back to multiple versionedfiles for data not stored in
1275
_PlanMergeVersionedFile itself.
1277
:ivar: fallback_versionedfiles a list of VersionedFiles objects that can be
1278
queried for missing texts.
1281
def __init__(self, file_id):
1282
"""Create a _PlanMergeVersionedFile.
1284
:param file_id: Used with _PlanMerge code which is not yet fully
1285
tuple-keyspace aware.
1287
self._file_id = file_id
1288
# fallback locations
1289
self.fallback_versionedfiles = []
1290
# Parents for locally held keys.
1292
# line data for locally held keys.
1294
# key lookup providers
1295
self._providers = [DictParentsProvider(self._parents)]
1297
def plan_merge(self, ver_a, ver_b, base=None):
1298
"""See VersionedFile.plan_merge"""
1299
from bzrlib.merge import _PlanMerge
1301
return _PlanMerge(ver_a, ver_b, self, (self._file_id,)).plan_merge()
1302
old_plan = list(_PlanMerge(ver_a, base, self, (self._file_id,)).plan_merge())
1303
new_plan = list(_PlanMerge(ver_a, ver_b, self, (self._file_id,)).plan_merge())
1304
return _PlanMerge._subtract_plans(old_plan, new_plan)
1306
def plan_lca_merge(self, ver_a, ver_b, base=None):
1307
from bzrlib.merge import _PlanLCAMerge
1309
new_plan = _PlanLCAMerge(ver_a, ver_b, self, (self._file_id,), graph).plan_merge()
1312
old_plan = _PlanLCAMerge(ver_a, base, self, (self._file_id,), graph).plan_merge()
1313
return _PlanLCAMerge._subtract_plans(list(old_plan), list(new_plan))
1315
def add_lines(self, key, parents, lines):
1316
"""See VersionedFiles.add_lines
1318
Lines are added locally, not to fallback versionedfiles. Also, ghosts
1319
are permitted. Only reserved ids are permitted.
1321
if type(key) is not tuple:
1322
raise TypeError(key)
1323
if not revision.is_reserved_id(key[-1]):
1324
raise ValueError('Only reserved ids may be used')
1326
raise ValueError('Parents may not be None')
1328
raise ValueError('Lines may not be None')
1329
self._parents[key] = tuple(parents)
1330
self._lines[key] = lines
1332
def get_record_stream(self, keys, ordering, include_delta_closure):
1335
if key in self._lines:
1336
lines = self._lines[key]
1337
parents = self._parents[key]
1339
yield ChunkedContentFactory(key, parents, None, lines)
1340
for versionedfile in self.fallback_versionedfiles:
1341
for record in versionedfile.get_record_stream(
1342
pending, 'unordered', True):
1343
if record.storage_kind == 'absent':
1346
pending.remove(record.key)
1350
# report absent entries
1352
yield AbsentContentFactory(key)
1354
def get_parent_map(self, keys):
1355
"""See VersionedFiles.get_parent_map"""
1356
# We create a new provider because a fallback may have been added.
1357
# If we make fallbacks private we can update a stack list and avoid
1358
# object creation thrashing.
1361
if revision.NULL_REVISION in keys:
1362
keys.remove(revision.NULL_REVISION)
1363
result[revision.NULL_REVISION] = ()
1364
self._providers = self._providers[:1] + self.fallback_versionedfiles
1366
StackedParentsProvider(self._providers).get_parent_map(keys))
1367
for key, parents in result.iteritems():
1369
result[key] = (revision.NULL_REVISION,)
502
1373
class PlanWeaveMerge(TextMerge):
503
1374
"""Weave merge that takes a plan as its input.
505
1376
This exists so that VersionedFile.plan_merge is implementable.
506
1377
Most callers will want to use WeaveMerge instead.
556
1427
elif state == 'new-b':
558
1429
lines_b.append(line)
1430
elif state == 'conflicted-a':
1432
lines_a.append(line)
1433
elif state == 'conflicted-b':
1435
lines_b.append(line)
1436
elif state == 'killed-both':
1437
# This counts as a change, even though there is no associated
560
assert state in ('irrelevant', 'ghost-a', 'ghost-b',
561
'killed-base', 'killed-both'), state
1441
if state not in ('irrelevant', 'ghost-a', 'ghost-b',
1443
raise AssertionError(state)
562
1444
for struct in outstanding_struct():
566
1448
class WeaveMerge(PlanWeaveMerge):
567
"""Weave merge that takes a VersionedFile and two versions as its input"""
1449
"""Weave merge that takes a VersionedFile and two versions as its input."""
569
def __init__(self, versionedfile, ver_a, ver_b,
1451
def __init__(self, versionedfile, ver_a, ver_b,
570
1452
a_marker=PlanWeaveMerge.A_MARKER, b_marker=PlanWeaveMerge.B_MARKER):
571
1453
plan = versionedfile.plan_merge(ver_a, ver_b)
572
1454
PlanWeaveMerge.__init__(self, plan, a_marker, b_marker)
575
class InterVersionedFile(InterObject):
576
"""This class represents operations taking place between two versionedfiles..
578
Its instances have methods like join, and contain
579
references to the source and target versionedfiles these operations can be
582
Often we will provide convenience methods on 'versionedfile' which carry out
583
operations with another versionedfile - they will always forward to
584
InterVersionedFile.get(other).method_name(parameters).
588
"""The available optimised InterVersionedFile types."""
590
def join(self, pb=None, msg=None, version_ids=None, ignore_missing=False):
591
"""Integrate versions from self.source into self.target.
593
If version_ids is None all versions from source should be
594
incorporated into this versioned file.
596
Must raise RevisionNotPresent if any of the specified versions
597
are not present in the other files history unless ignore_missing is
598
supplied when they are silently skipped.
601
# - if the target is empty, just add all the versions from
602
# source to target, otherwise:
603
# - make a temporary versioned file of type target
604
# - insert the source content into it one at a time
606
if not self.target.versions():
1457
class VirtualVersionedFiles(VersionedFiles):
1458
"""Dummy implementation for VersionedFiles that uses other functions for
1459
obtaining fulltexts and parent maps.
1461
This is always on the bottom of the stack and uses string keys
1462
(rather than tuples) internally.
1465
def __init__(self, get_parent_map, get_lines):
1466
"""Create a VirtualVersionedFiles.
1468
:param get_parent_map: Same signature as Repository.get_parent_map.
1469
:param get_lines: Should return lines for specified key or None if
1472
super(VirtualVersionedFiles, self).__init__()
1473
self._get_parent_map = get_parent_map
1474
self._get_lines = get_lines
1476
def check(self, progressbar=None):
1477
"""See VersionedFiles.check.
1479
:note: Always returns True for VirtualVersionedFiles.
1483
def add_mpdiffs(self, records):
1484
"""See VersionedFiles.mpdiffs.
1486
:note: Not implemented for VirtualVersionedFiles.
1488
raise NotImplementedError(self.add_mpdiffs)
1490
def get_parent_map(self, keys):
1491
"""See VersionedFiles.get_parent_map."""
1492
return dict([((k,), tuple([(p,) for p in v]))
1493
for k,v in self._get_parent_map([k for (k,) in keys]).iteritems()])
1495
def get_sha1s(self, keys):
1496
"""See VersionedFiles.get_sha1s."""
1499
lines = self._get_lines(k)
1500
if lines is not None:
1501
if not isinstance(lines, list):
1502
raise AssertionError
1503
ret[(k,)] = osutils.sha_strings(lines)
1506
def get_record_stream(self, keys, ordering, include_delta_closure):
1507
"""See VersionedFiles.get_record_stream."""
1508
for (k,) in list(keys):
1509
lines = self._get_lines(k)
1510
if lines is not None:
1511
if not isinstance(lines, list):
1512
raise AssertionError
1513
yield ChunkedContentFactory((k,), None,
1514
sha1=osutils.sha_strings(lines),
1517
yield AbsentContentFactory((k,))
1519
def iter_lines_added_or_present_in_keys(self, keys, pb=None):
1520
"""See VersionedFile.iter_lines_added_or_present_in_versions()."""
1521
for i, (key,) in enumerate(keys):
1523
pb.update("Finding changed lines", i, len(keys))
1524
for l in self._get_lines(key):
1528
def network_bytes_to_kind_and_offset(network_bytes):
1529
"""Strip of a record kind from the front of network_bytes.
1531
:param network_bytes: The bytes of a record.
1532
:return: A tuple (storage_kind, offset_of_remaining_bytes)
1534
line_end = network_bytes.find('\n')
1535
storage_kind = network_bytes[:line_end]
1536
return storage_kind, line_end + 1
1539
class NetworkRecordStream(object):
1540
"""A record_stream which reconstitures a serialised stream."""
1542
def __init__(self, bytes_iterator):
1543
"""Create a NetworkRecordStream.
1545
:param bytes_iterator: An iterator of bytes. Each item in this
1546
iterator should have been obtained from a record_streams'
1547
record.get_bytes_as(record.storage_kind) call.
1549
self._bytes_iterator = bytes_iterator
1550
self._kind_factory = {'knit-ft-gz':knit.knit_network_to_record,
1551
'knit-delta-gz':knit.knit_network_to_record,
1552
'knit-annotated-ft-gz':knit.knit_network_to_record,
1553
'knit-annotated-delta-gz':knit.knit_network_to_record,
1554
'knit-delta-closure':knit.knit_delta_closure_to_records,
1555
'fulltext':fulltext_network_to_record,
1556
'groupcompress-block':groupcompress.network_block_to_records,
1562
:return: An iterator as per VersionedFiles.get_record_stream().
1564
for bytes in self._bytes_iterator:
1565
storage_kind, line_end = network_bytes_to_kind_and_offset(bytes)
1566
for record in self._kind_factory[storage_kind](
1567
storage_kind, bytes, line_end):
1571
def fulltext_network_to_record(kind, bytes, line_end):
1572
"""Convert a network fulltext record to record."""
1573
meta_len, = struct.unpack('!L', bytes[line_end:line_end+4])
1574
record_meta = bytes[line_end+4:line_end+4+meta_len]
1575
key, parents = bencode.bdecode_as_tuple(record_meta)
1576
if parents == 'nil':
1578
fulltext = bytes[line_end+4+meta_len:]
1579
return [FulltextContentFactory(key, parents, None, fulltext)]
1582
def _length_prefix(bytes):
1583
return struct.pack('!L', len(bytes))
1586
def record_to_fulltext_bytes(record):
1587
if record.parents is None:
1590
parents = record.parents
1591
record_meta = bencode.bencode((record.key, parents))
1592
record_content = record.get_bytes_as('fulltext')
1593
return "fulltext\n%s%s%s" % (
1594
_length_prefix(record_meta), record_meta, record_content)
1597
def sort_groupcompress(parent_map):
1598
"""Sort and group the keys in parent_map into groupcompress order.
1600
groupcompress is defined (currently) as reverse-topological order, grouped
1603
:return: A sorted-list of keys
1605
# gc-optimal ordering is approximately reverse topological,
1606
# properly grouped by file-id.
1608
for item in parent_map.iteritems():
1610
if isinstance(key, str) or len(key) == 1:
609
# Make a new target-format versioned file.
610
temp_source = self.target.create_empty("temp", MemoryTransport())
612
version_ids = self._get_source_version_ids(version_ids, ignore_missing)
613
graph = self.source.get_graph(version_ids)
614
order = tsort.topo_sort(graph.items())
615
pb = ui.ui_factory.nested_progress_bar()
618
# TODO for incremental cross-format work:
619
# make a versioned file with the following content:
620
# all revisions we have been asked to join
621
# all their ancestors that are *not* in target already.
622
# the immediate parents of the above two sets, with
623
# empty parent lists - these versions are in target already
624
# and the incorrect version data will be ignored.
625
# TODO: for all ancestors that are present in target already,
626
# check them for consistent data, this requires moving sha1 from
628
# TODO: remove parent texts when they are not relevant any more for
629
# memory pressure reduction. RBC 20060313
630
# pb.update('Converting versioned data', 0, len(order))
631
# deltas = self.source.get_deltas(order)
632
for index, version in enumerate(order):
633
pb.update('Converting versioned data', index, len(order))
634
parent_text = target.add_lines(version,
635
self.source.get_parents(version),
636
self.source.get_lines(version),
637
parent_texts=parent_texts)
638
parent_texts[version] = parent_text
639
#delta_parent, sha1, noeol, delta = deltas[version]
640
#target.add_delta(version,
641
# self.source.get_parents(version),
646
#target.get_lines(version)
648
# this should hit the native code path for target
649
if target is not self.target:
650
return self.target.join(temp_source,
658
def _get_source_version_ids(self, version_ids, ignore_missing):
659
"""Determine the version ids to be used from self.source.
661
:param version_ids: The caller-supplied version ids to check. (None
662
for all). If None is in version_ids, it is stripped.
663
:param ignore_missing: if True, remove missing ids from the version
664
list. If False, raise RevisionNotPresent on
665
a missing version id.
666
:return: A set of version ids.
668
if version_ids is None:
669
# None cannot be in source.versions
670
return set(self.source.versions())
672
version_ids = [osutils.safe_revision_id(v) for v in version_ids]
674
return set(self.source.versions()).intersection(set(version_ids))
676
new_version_ids = set()
677
for version in version_ids:
680
if not self.source.has_version(version):
681
raise errors.RevisionNotPresent(version, str(self.source))
683
new_version_ids.add(version)
684
return new_version_ids
1615
per_prefix_map[prefix].append(item)
1617
per_prefix_map[prefix] = [item]
1620
for prefix in sorted(per_prefix_map):
1621
present_keys.extend(reversed(tsort.topo_sort(per_prefix_map[prefix])))
added
removed
bzrlib/versionedfile.py
