/brz/remove-bazaar

# Copyright (C) 2006-2010 Canonical Ltd

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

from itertools import izip

    static_tuple,

    ui,

    sort_groupcompress,

_STREAM_MIN_BUFFER_SIZE = 5*1024*1024

        if ('-ft-' in self.storage_kind and

            storage_kind in ('chunked', 'fulltext')):

            adapter_key = (self.storage_kind, 'fulltext')

            adapter_factory = adapter_registry.get(adapter_key)

            adapter = adapter_factory(None)

            bytes = adapter.get_bytes(self)

            if storage_kind == 'chunked':

                return [bytes]

            else:

                return bytes

            # Not redundant with direct conversion above - that only handles

            # fulltext cases.

        if type(key) is tuple:

        return annotator.annotate_flat(key)

def _get_total_build_size(self, keys, positions):

    """Determine the total bytes to build these keys.

 

    (helper function because _KnitGraphIndex and _KndxIndex work the same, but

    don't inherit from a common base.)

 

    :param keys: Keys that we want to build

    :param positions: dict of {key, (info, index_memo, comp_parent)} (such

        as returned by _get_components_positions)

    :return: Number of bytes to build those keys

    """

    all_build_index_memos = {}

    build_keys = keys

    while build_keys:

        next_keys = set()

        for key in build_keys:

            # This is mostly for the 'stacked' case

            # Where we will be getting the data from a fallback

            if key not in positions:

                continue

            _, index_memo, compression_parent = positions[key]

            all_build_index_memos[key] = index_memo

            if compression_parent not in all_build_index_memos:

                next_keys.add(compression_parent)

        build_keys = next_keys

    return sum([index_memo[2] for index_memo

                in all_build_index_memos.itervalues()])

 

 

        line_bytes = ''.join(lines)

            parent_texts, left_matching_blocks, nostore_sha, random_id,

            line_bytes=line_bytes)

 

    def _add_text(self, key, parents, text, nostore_sha=None, random_id=False):

        """See VersionedFiles._add_text()."""

        self._index._check_write_ok()

        self._check_add(key, None, random_id, check_content=False)

        if text.__class__ is not str:

            raise errors.BzrBadParameterUnicode("text")

        if parents is None:

            # The caller might pass None if there is no graph data, but kndx

            # indexes can't directly store that, so we give them

            # an empty tuple instead.

            parents = ()

        return self._add(key, None, parents,

            None, None, nostore_sha, random_id,

            line_bytes=text)

        left_matching_blocks, nostore_sha, random_id,

        line_bytes):

 

        :param lines: A list of strings where each one is a single line (has a

            single newline at the end of the string) This is now optional

            (callers can pass None). It is left in its location for backwards

            compatibility. It should ''.join(lines) must == line_bytes

        :param line_bytes: A single string containing the content

 

        We pass both lines and line_bytes because different routes bring the

        values to this function. And for memory efficiency, we don't want to

        have to split/join on-demand.

        no_eol = False

        # Note: line_bytes is not modified to add a newline, that is tracked

        #       via the no_eol flag. 'lines' *is* modified, because that is the

        #       general values needed by the Content code.

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

            options.append('no-eol')

            no_eol = True

            # Copy the existing list, or create a new one

            if lines is None:

                lines = osutils.split_lines(line_bytes)

            else:

            # Replace the last line with one that ends in a final newline

            lines[-1] = lines[-1] + '\n'

        if lines is None:

            lines = osutils.split_lines(line_bytes)

        for element in key[:-1]:

            if type(element) is not str:

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

        if key[-1] is None:

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

        elif type(key[-1]) is not str:

        if no_eol:

            if self._factory.__class__ is KnitPlainFactory:

                dense_lines = [line_bytes]

                if no_eol:

                    dense_lines.append('\n')

                    lines, dense_lines)

    def get_annotator(self):

        return _KnitAnnotator(self)

 

    def check(self, progress_bar=None, keys=None):

        if keys is None:

            return self._logical_check()

        else:

            # At the moment, check does not extra work over get_record_stream

            return self.get_record_stream(keys, 'unordered', True)

 

    def _logical_check(self):

        if version_id is not None:

            if contains_whitespace(version_id):

                raise InvalidRevisionId(version_id, self)

            self.check_not_reserved_id(version_id)

    def get_known_graph_ancestry(self, keys):

        """Get a KnownGraph instance with the ancestry of keys."""

        parent_map, missing_keys = self._index.find_ancestry(keys)

        for fallback in self._fallback_vfs:

            if not missing_keys:

                break

            (f_parent_map, f_missing_keys) = fallback._index.find_ancestry(

                                                missing_keys)

            parent_map.update(f_parent_map)

            missing_keys = f_missing_keys

        kg = _mod_graph.KnownGraph(parent_map)

        return kg

 

                # 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))

    @classmethod

    def _split_by_prefix(cls, keys):

        The keys for a given file_id are kept in the same relative order.

        Ordering between file_ids is not, though prefix_order will return the

        order that the key was first seen.

 

        :return: (split_map, prefix_order)

            split_map       A dictionary mapping prefix => keys

            prefix_order    The order that we saw the various prefixes

        prefix_order = []

                prefix = ''

            else:

                prefix = key[0]

 

            if prefix in split_by_prefix:

                split_by_prefix[prefix].append(key)

            else:

                split_by_prefix[prefix] = [key]

                prefix_order.append(prefix)

        return split_by_prefix, prefix_order

 

    def _group_keys_for_io(self, keys, non_local_keys, positions,

                           _min_buffer_size=_STREAM_MIN_BUFFER_SIZE):

        """For the given keys, group them into 'best-sized' requests.

 

        The idea is to avoid making 1 request per file, but to never try to

        unpack an entire 1.5GB source tree in a single pass. Also when

        possible, we should try to group requests to the same pack file

        together.

 

        :return: list of (keys, non_local) tuples that indicate what keys

            should be fetched next.

        """

        # TODO: Ideally we would group on 2 factors. We want to extract texts

        #       from the same pack file together, and we want to extract all

        #       the texts for a given build-chain together. Ultimately it

        #       probably needs a better global view.

        total_keys = len(keys)

        prefix_split_keys, prefix_order = self._split_by_prefix(keys)

        prefix_split_non_local_keys, _ = self._split_by_prefix(non_local_keys)

        cur_keys = []

        cur_non_local = set()

        cur_size = 0

        result = []

        sizes = []

        for prefix in prefix_order:

            keys = prefix_split_keys[prefix]

            non_local = prefix_split_non_local_keys.get(prefix, [])

 

            this_size = self._index._get_total_build_size(keys, positions)

            cur_size += this_size

            cur_keys.extend(keys)

            cur_non_local.update(non_local)

            if cur_size > _min_buffer_size:

                result.append((cur_keys, cur_non_local))

                sizes.append(cur_size)

                cur_keys = []

                cur_non_local = set()

                cur_size = 0

        if cur_keys:

            result.append((cur_keys, cur_non_local))

            sizes.append(cur_size)

        return result

            # Cannot sort when no graph has been stored.

        if ordering in ('topological', 'groupcompress'):

            if ordering == 'topological':

                # Global topological sort

                present_keys = tsort.topo_sort(global_map)

            else:

                present_keys = sort_groupcompress(global_map)

                    ' "unordered", "groupcompress" or "topological" not: %r'

            for keys, non_local_keys in self._group_keys_for_io(present_keys,

                                                                non_local_keys,

                                                                positions):

                generator = _VFContentMapGenerator(self, keys, non_local_keys,

                                                   global_map,

                                                   ordering=ordering)

                    for key, raw_data in self._read_records_iter_unchecked(records):

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

            kind = record.storage_kind

            if kind.startswith('knit-') and kind.endswith('-gz'):

                # Check that the ID in the header of the raw knit bytes matches

                # the record metadata.

                raw_data = record._raw_record

                df, rec = self._parse_record_header(record.key, raw_data)

                df.close()

            buffered = False

                self._access.flush()

            if not buffered:

                added_keys = [record.key]

                while added_keys:

                    key = added_keys.pop(0)

                    if key in buffered_index_entries:

                        index_entries = buffered_index_entries[key]

                        self._index.add_records(index_entries)

                        added_keys.extend(

                            [index_entry[0] for index_entry in index_entries])

                        del buffered_index_entries[key]

            all_entries = []

                all_entries.extend(index_entries)

            self._index.add_records(

                all_entries, missing_compression_parents=True)

        :param pb: Progress bar supplied by caller.

            pb = ui.ui_factory.nested_progress_bar()

                    pb.update('Walking content', key_idx, total)

        pb.update('Walking content', total, total)

        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:

            if type(chunk) is not str:

                raise AssertionError(

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

        compressed_bytes = tuned_gzip.chunks_to_gzip(chunks)

    def __init__(self, ordering='unordered'):

        self._ordering = ordering

 

                self._ordering, True):

        if self._raw_record_map is None:

            raise AssertionError('_raw_record_map should have been filled')

        global_map=None, raw_record_map=None, ordering='unordered'):

        _ContentMapGenerator.__init__(self, ordering=ordering)

        that the compressed data starts at.

                    if type(line) is not str:

    def find_ancestry(self, keys):

        """See CombinedGraphIndex.find_ancestry()"""

        prefixes = set(key[:-1] for key in keys)

        self._load_prefixes(prefixes)

        result = {}

        parent_map = {}

        missing_keys = set()

        pending_keys = list(keys)

        # This assumes that keys will not reference parents in a different

        # prefix, which is accurate so far.

        while pending_keys:

            key = pending_keys.pop()

            if key in parent_map:

                continue

            prefix = key[:-1]

            try:

                suffix_parents = self._kndx_cache[prefix][0][key[-1]][4]

            except KeyError:

                missing_keys.add(key)

            else:

                parent_keys = tuple([prefix + (suffix,)

                                     for suffix in suffix_parents])

                parent_map[key] = parent_keys

                pending_keys.extend([p for p in parent_keys

                                        if p not in parent_map])

        return parent_map, missing_keys

 

        if type(self._mapper) is ConstantMapper:

                    if type(self._mapper) is ConstantMapper:

    _get_total_build_size = _get_total_build_size

 

class _KeyRefs(object):

 

    def __init__(self, track_new_keys=False):

        # dict mapping 'key' to 'set of keys referring to that key'

        self.refs = {}

        if track_new_keys:

            # set remembering all new keys

            self.new_keys = set()

        else:

            self.new_keys = None

 

    def clear(self):

        if self.refs:

            self.refs.clear()

        if self.new_keys:

            self.new_keys.clear()

 

    def add_references(self, key, refs):

        # Record the new references

        for referenced in refs:

            try:

                needed_by = self.refs[referenced]

            except KeyError:

                needed_by = self.refs[referenced] = set()

            needed_by.add(key)

        # Discard references satisfied by the new key

        self.add_key(key)

 

    def get_new_keys(self):

        return self.new_keys

    

    def get_unsatisfied_refs(self):

        return self.refs.iterkeys()

 

    def _satisfy_refs_for_key(self, key):

        try:

            del self.refs[key]

        except KeyError:

            # No keys depended on this key.  That's ok.

            pass

 

    def add_key(self, key):

        # satisfy refs for key, and remember that we've seen this key.

        self._satisfy_refs_for_key(key)

        if self.new_keys is not None:

            self.new_keys.add(key)

 

    def satisfy_refs_for_keys(self, keys):

        for key in keys:

            self._satisfy_refs_for_key(key)

 

    def get_referrers(self):

        result = set()

        for referrers in self.refs.itervalues():

            result.update(referrers)

        return result

 

 

        add_callback=None, track_external_parent_refs=False):

        :param track_external_parent_refs: If True, record all external parent

            references parents from added records.  These can be retrieved

            later by calling get_missing_parents().

        if track_external_parent_refs:

            self._key_dependencies = _KeyRefs()

        else:

            self._key_dependencies = None

        key_dependencies = self._key_dependencies

                if key_dependencies is not None:

                    key_dependencies.add_references(key, parents)

                parents = node_refs[:1]

                # Sometimes these are passed as a list rather than a tuple

                passed = static_tuple.as_tuples(keys[key])

                passed_parents = passed[1][:1]

                    parents != passed_parents):

                    node_refs = static_tuple.as_tuples(node_refs)

                        ": %s %s" % ((value, node_refs), passed))

        if self._key_dependencies is not None:

            # Add parent refs from graph_index (and discard parent refs that

            # the graph_index has).

            for node in graph_index.iter_all_entries():

                self._key_dependencies.add_references(node[1], node[3][0])

    def get_missing_parents(self):

        """Return the keys of missing parents."""

        # If updating this, you should also update

        # groupcompress._GCGraphIndex.get_missing_parents

        # We may have false positives, so filter those out.

        self._key_dependencies.satisfy_refs_for_keys(

            self.get_parent_map(self._key_dependencies.get_unsatisfied_refs()))

        return frozenset(self._key_dependencies.get_unsatisfied_refs())