/brz/remove-bazaar

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

 

"""

 

 

import operator

import os

 

lazy_import(globals(), """

    debug,

    diff,

    graph as _mod_graph,

    index as _mod_index,

    pack,

    static_tuple,

    trace,

    tsort,

    tuned_gzip,

    ui,

    )

""")

    errors,

    osutils,

    )

    NoSuchFile,

    InvalidRevisionId,

    KnitCorrupt,

    KnitHeaderError,

    RevisionNotPresent,

    SHA1KnitCorrupt,

    )

    contains_whitespace,

    sha_string,

    sha_strings,

    split_lines,

    )

    AbsentContentFactory,

    adapter_registry,

    ConstantMapper,

    ContentFactory,

    sort_groupcompress,

    )

 

 

        delta = self._annotate_factory.parse_line_delta(contents, rec[1],

            plain=True)

        compression_parent = factory.parents[0]

        if basis_entry.storage_kind == 'absent':

            raise errors.RevisionNotPresent(compression_parent, self._basis_vf)

        basis_chunks = basis_entry.get_bytes_as('chunked')

        delta = self._plain_factory.parse_line_delta(contents, rec[1])

        compression_parent = factory.parents[0]

        # XXX: string splitting overhead.

        if basis_entry.storage_kind == 'absent':

            raise errors.RevisionNotPresent(compression_parent, self._basis_vf)

        basis_chunks = basis_entry.get_bytes_as('chunked')

class KnitContent(object):

    """Content of a knit version to which deltas can be applied.

 

    plus a flag saying if the final ending is really there or not, because that

    corresponds to the on-disk knit representation.

    """

 

    def __init__(self, lines):

        KnitContent.__init__(self)

 

    def annotate(self):

        """Return a list of (origin, text) for each content line."""

    def text(self):

        try:

            lines = [text for origin, text in self._lines]

            # most commonly (only?) caused by the internal form of the knit

            # missing annotation information because of a bug - see thread

            # around 20071015

        return lines

 

    def copy(self):

 

 

class PlainKnitContent(KnitContent):

        #       but the code itself doesn't really depend on that.

        #       Figure out a way to not require the overhead of turning the

        #       list back into tuples.

        return AnnotatedKnitContent(lines)

 

    def parse_line_delta_iter(self, lines):

        """

        result = []

        lines = iter(lines)

 

        cache = {}

        def cache_and_return(line):

        if plain:

            for header in lines:

                start, end, count = [int(n) for n in header.split(',')]

                result.append((start, end, count, contents))

        else:

            for header in lines:

                start, end, count = [int(n) for n in header.split(',')]

                result.append((start, end, count, contents))

        return result

 

        Only the actual content lines.

        """

        lines = iter(lines)

        for header in lines:

            header = header.split(',')

            count = int(header[2])

                yield text

 

    def lower_fulltext(self, content):

        content = knit._get_content(key)

        # adjust for the fact that serialised annotations are only key suffixes

        # for this factory.

            prefix = key[:-1]

            origins = content.annotate()

            result = []

        Only the actual content lines.

        """

        lines = iter(lines)

        for header in lines:

            header = header.split(',')

            count = int(header[2])

 

    def lower_fulltext(self, content):

        return content.text()

        writer.begin()

        index = _KnitGraphIndex(graph_index, lambda:True, parents=parents,

            deltas=delta, add_callback=graph_index.add_nodes)

        access.set_writer(writer, graph_index, (transport, 'newpack'))

        result = KnitVersionedFiles(index, access,

            max_delta_chain=max_delta_chain)

            if compression_parent not in all_build_index_memos:

                next_keys.add(compression_parent)

        build_keys = next_keys

    """Storage for many versioned files using knit compression.

 

    Backend storage is managed by indices and data objects.

            stored during insertion.

        :param reload_func: An function that can be called if we think we need

            to reload the pack listing and try again. See

        """

        self._index = index

        self._access = data_access

            self._factory = KnitAnnotateFactory()

        else:

            self._factory = KnitPlainFactory()

        self._reload_func = reload_func

 

    def __repr__(self):

            self._index,

            self._access)

 

    def add_fallback_versioned_files(self, a_versioned_files):

        """Add a source of texts for texts not present in this knit.

 

        :param a_versioned_files: A VersionedFiles object.

        """

 

    def add_lines(self, key, parents, lines, parent_texts=None,

        left_matching_blocks=None, nostore_sha=None, random_id=False,

            lines = osutils.split_lines(line_bytes)

 

        for element in key[:-1]:

                raise TypeError("key contains non-strings: %r" % (key,))

        if key[-1] is None:

            key = key[:-1] + ('sha1:' + digest,)

                raise TypeError("key contains non-strings: %r" % (key,))

        # Knit hunks are still last-element only

        version_id = key[-1]

                    raise errors.KnitCorrupt(self,

                        "Missing basis parent %s for %s" % (

                        compression_parent, key))

            fallback_vfs.check()

 

    def _check_add(self, key, lines, random_id, check_content):

        """

        delta_size = 0

        fulltext_size = None

            try:

                # Note that this only looks in the index of this particular

                # KnitVersionedFiles, not in the fallbacks.  This ensures that

                # boundaries.

                build_details = self._index.get_build_details([parent])

                parent_details = build_details[parent]

                # Some basis is not locally present: always fulltext

                return False

            index_memo, compression_parent, _, _ = parent_details

 

        A dict of key to (record_details, index_memo, next, parents) is

        returned.

        """

        component_data = {}

        pending_components = keys

            build_details = self._index.get_build_details(pending_components)

            current_components = set(pending_components)

            pending_components = set()

                (index_memo, compression_parent, parents,

                 record_details) = details

                method = record_details[0]

        generator = _VFContentMapGenerator(self, [key])

        return generator._get_content(key)

 

    def get_parent_map(self, keys):

        """Get a map of the graph parents of keys.

 

            and so on.

        """

        result = {}

        source_results = []

        missing = set(keys)

        for source in sources:

        """Produce a dictionary of knit records.

 

        :return: {key:(record, record_details, digest, next)}

                Will be None if the record is not a delta.

        :param keys: The keys to build a map for

        :param allow_missing: If some records are missing, rather than

            error, just return the data that could be generated.

                # key = component_id, r = record_details, i_m = index_memo,

                # n = next

                records = [(key, i_m) for key, (r, i_m, n)

                # Sort by the index memo, so that we request records from the

                # same pack file together, and in forward-sorted order

                records.sort(key=operator.itemgetter(1))

                    (record_details, index_memo, next) = position_map[key]

                    raw_record_map[key] = data, record_details, next

                return raw_record_map

                self._access.reload_or_raise(e)

 

    @classmethod

                    remaining_keys.discard(content_factory.key)

                    yield content_factory

                return

                self._access.reload_or_raise(e)

 

    def _get_remaining_record_stream(self, keys, ordering,

            # map from key to

            # (record_details, access_memo, compression_parent_key)

            positions = dict((key, self._build_details_to_components(details))

        absent_keys = keys.difference(set(positions))

        # There may be more absent keys : if we're missing the basis component

        # and are trying to include the delta closure.

                        yield KnitContentFactory(key, global_map[key],

                            record_details, None, raw_data, self._factory.annotated, None)

                else:

                    for record in vf.get_record_stream(keys, ordering,

                        include_delta_closure):

                        yield record

        missing = set(keys)

        record_map = self._get_record_map(missing, allow_missing=True)

        result = {}

            if key not in missing:

                continue

            # record entry 2 is the 'digest'.

            result[key] = details[2]

        missing.difference_update(set(result))

            if not missing:

                break

            new_result = source.get_sha1s(missing)

        else:

            # self is not annotated, but we can strip annotations cheaply.

            annotated = ""

            if self._max_delta_chain:

                delta_types.add("knit-annotated-delta-gz")

                convertibles.add("knit-annotated-delta-gz")

                raise RevisionNotPresent([record.key], self)

            elif ((record.storage_kind in knit_types)

                  and (compression_parent is None

                # we can insert the knit record literally if either it has no

                # compression parent OR we already have its basis in this kvf

                # OR the basis is not present even in the fallbacks.  In the

                # will be well, or it won't turn up at all and we'll raise an

                # error at the end.

                #

                # asks if it's only present in the fallbacks. -- mbp 20081119

                if record.storage_kind not in native_types:

                    try:

                    #

                    # They're required to be physically in this

                    # KnitVersionedFiles, not in a fallback.

                        pending = buffered_index_entries.setdefault(

                            compression_parent, [])

                        pending.append(index_entry)

                # we need key, position, length

                key_records = []

                build_details = self._index.get_build_details(keys)

                    if key in keys:

                        key_records.append((key, details[0]))

                records_iter = enumerate(self._read_records_iter(key_records))

                for (key_idx, (key, data, sha_value)) in records_iter:

                    compression_parent = build_details[key][1]

                    if compression_parent is None:

                        # fulltext

                    for line in line_iterator:

                        yield line, key

                done = True

                self._access.reload_or_raise(e)

        # If there are still keys we've not yet found, we look in the fallback

        # vfs, and hope to find them there.  Note that if the keys are found

        # but had no changes or no content, the fallback may not return

        # anything.

            # XXX: strictly the second parameter is meant to be the file id

            # but it's not easily accessible here.

            raise RevisionNotPresent(keys, repr(self))

            if not keys:

                break

            source_keys = set()

                source_keys.add(key)

                yield line, key

            keys.difference_update(source_keys)

 

    def _make_line_delta(self, delta_seq, new_content):

        """Generate a line delta from delta_seq and new_content."""

        :return: the header and the decompressor stream.

                 as (stream, header_record)

        """

        try:

            # Current serialise

            rec = self._check_header(key, df.readline())

            raise KnitCorrupt(self,

                              "While reading {%s} got %s(%s)"

                              % (key, e.__class__.__name__, str(e)))

        # 4168 calls in 2880 217 internal

        # 4168 calls to _parse_record_header in 2121

        # 4168 calls to readlines in 330

        try:

            record_contents = df.readlines()

            raise KnitCorrupt(self, "Corrupt compressed record %r, got %s(%s)" %

                (data, e.__class__.__name__, str(e)))

        header = record_contents.pop(0)

        The result will be returned in whatever is the fastest to read.

        Not by the order requested. Also, multiple requests for the same

        record will only yield 1 response.

        :param records: A list of (key, access_memo) entries

        :return: Yields (key, contents, digest) in the order

                 read, not the order requested

        raw_data = self._access.get_raw_records(

            [index_memo for key, index_memo in needed_records])

 

            content, digest = self._parse_record(key[-1], data)

            yield key, content, digest

 

            raw_records = self._access.get_raw_records(needed_offsets)

 

        for key, index_memo in records:

            yield key, data

 

    def _record_to_data(self, key, digest, lines, dense_lines=None):

        :param key: The key of the record. Currently keys are always serialised

            using just the trailing component.

        :param dense_lines: The bytes of lines but in a denser form. For

        """

        chunks = ["version %s %d %s\n" % (key[-1], len(lines), digest)]

        chunks.extend(dense_lines or lines)

        chunks.append("end %s\n" % key[-1])

        for chunk in chunks:

                raise AssertionError(

                    'data must be plain bytes was %s' % type(chunk))

        if lines and lines[-1][-1] != '\n':

        """See VersionedFiles.keys."""

        if 'evil' in debug.debug_flags:

            trace.mutter_callsite(2, "keys scales with size of history")

        result = set()

        for source in sources:

            result.update(source.keys())

        # Note that _get_content is only called when the _ContentMapGenerator

        # has been constructed with just one key requested for reconstruction.

        if key in self.nonlocal_keys:

            # Create a content object on the fly

            lines = osutils.chunks_to_lines(record.get_bytes_as('chunked'))

            return PlainKnitContent(lines, record.key)

 

        missing_keys = set(nonlocal_keys)

        # Read from remote versioned file instances and provide to our caller.

            if not missing_keys:

                break

            # Loop over fallback repositories asking them for texts - ignore

        # one line with next ('' for None)

        # one line with byte count of the record bytes

        # the record bytes

            key_bytes = '\x00'.join(key)

            parents = self.global_map.get(key, None)

            if parents is None:

                    line = "\n%s %s %s %s %s :" % (

                        key[-1], ','.join(options), pos, size,

                        self._dictionary_compress(parents))

                        raise AssertionError(

                            'data must be utf8 was %s' % type(line))

                    lines.append(line)

        entry = self._kndx_cache[prefix][0][suffix]

        return key, entry[2], entry[3]

 

 

    def _init_index(self, path, extra_lines=[]):

        """Initialize an index."""

        sio.write(self.HEADER)

        sio.writelines(extra_lines)

        sio.seek(0)

        result = set()

        # Identify all key prefixes.

        # XXX: A bit hacky, needs polish.

            prefixes = [()]

        else:

            relpaths = set()

                    del self._history

                except NoSuchFile:

                    self._kndx_cache[prefix] = ({}, [])

                        # preserve behaviour for revisions.kndx etc.

                        self._init_index(path)

                    del self._cache

        return key[:-1], key[-1]