# revlog.py - storage back-end for mercurial

# coding: utf8

#

# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

"""Storage back-end for Mercurial.

This provides efficient delta storage with O(1) retrieve and append

and O(changes) merge between branches.

"""

import binascii

import collections

import contextlib

import io

import os

import struct

import weakref

import zlib

# import stuff from node for others to import from revlog

from .node import (

    bin,

    hex,

    nullrev,

    sha1nodeconstants,

    short,

    wdirrev,

)

from .i18n import _

from .revlogutils.constants import (

    ALL_KINDS,

    CHANGELOGV2,

    COMP_MODE_DEFAULT,

    COMP_MODE_INLINE,

    COMP_MODE_PLAIN,

    DELTA_BASE_REUSE_NO,

    DELTA_BASE_REUSE_TRY,

    ENTRY_RANK,

    FEATURES_BY_VERSION,

    FLAG_GENERALDELTA,

    FLAG_INLINE_DATA,

    INDEX_HEADER,

    KIND_CHANGELOG,

    KIND_FILELOG,

    RANK_UNKNOWN,

    REVLOGV0,

    REVLOGV1,

    REVLOGV1_FLAGS,

    REVLOGV2,

    REVLOGV2_FLAGS,

    REVLOG_DEFAULT_FLAGS,

    REVLOG_DEFAULT_FORMAT,

    REVLOG_DEFAULT_VERSION,

    SUPPORTED_FLAGS,

)

from .revlogutils.flagutil import (

    REVIDX_DEFAULT_FLAGS,

    REVIDX_ELLIPSIS,

    REVIDX_EXTSTORED,

    REVIDX_FLAGS_ORDER,

    REVIDX_HASCOPIESINFO,

    REVIDX_ISCENSORED,

    REVIDX_RAWTEXT_CHANGING_FLAGS,

)

from .thirdparty import attr

from . import (

    ancestor,

    dagop,

    error,

    mdiff,

    policy,

    pycompat,

    revlogutils,

    templatefilters,

    util,

)

from .interfaces import (

    repository,

    util as interfaceutil,

)

from .revlogutils import (

    deltas as deltautil,

    docket as docketutil,

    flagutil,

    nodemap as nodemaputil,

    randomaccessfile,

    revlogv0,

    rewrite,

    sidedata as sidedatautil,

)

from .utils import (

    storageutil,

    stringutil,

)

# blanked usage of all the name to prevent pyflakes constraints

# We need these name available in the module for extensions.

REVLOGV0

REVLOGV1

REVLOGV2

CHANGELOGV2

FLAG_INLINE_DATA

FLAG_GENERALDELTA

REVLOG_DEFAULT_FLAGS

REVLOG_DEFAULT_FORMAT

REVLOG_DEFAULT_VERSION

REVLOGV1_FLAGS

REVLOGV2_FLAGS

REVIDX_ISCENSORED

REVIDX_ELLIPSIS

REVIDX_HASCOPIESINFO

REVIDX_EXTSTORED

REVIDX_DEFAULT_FLAGS

REVIDX_FLAGS_ORDER

REVIDX_RAWTEXT_CHANGING_FLAGS

parsers = policy.importmod('parsers')

rustancestor = policy.importrust('ancestor')

rustdagop = policy.importrust('dagop')

rustrevlog = policy.importrust('revlog')

# Aliased for performance.

_zlibdecompress = zlib.decompress

# max size of inline data embedded into a revlog

_maxinline = 131072

# Flag processors for REVIDX_ELLIPSIS.

def ellipsisreadprocessor(rl, text):

    return text, False

def ellipsiswriteprocessor(rl, text):

    return text, False

def ellipsisrawprocessor(rl, text):

    return False

ellipsisprocessor = (

    ellipsisreadprocessor,

    ellipsiswriteprocessor,

    ellipsisrawprocessor,

)

def _verify_revision(rl, skipflags, state, node):

    """Verify the integrity of the given revlog ``node`` while providing a hook

    point for extensions to influence the operation."""

    if skipflags:

        state[b'skipread'].add(node)

    else:

        # Side-effect: read content and verify hash.

        rl.revision(node)

# True if a fast implementation for persistent-nodemap is available

#

# We also consider we have a "fast" implementation in "pure" python because

# people using pure don't really have performance consideration (and a

# wheelbarrow of other slowness source)

HAS_FAST_PERSISTENT_NODEMAP = rustrevlog is not None or hasattr(

    parsers, 'BaseIndexObject'

)

@interfaceutil.implementer(repository.irevisiondelta)

@attr.s(slots=True)

class revlogrevisiondelta:

    node = attr.ib()

    p1node = attr.ib()

    p2node = attr.ib()

    basenode = attr.ib()

    flags = attr.ib()

    baserevisionsize = attr.ib()

    revision = attr.ib()

    delta = attr.ib()

    sidedata = attr.ib()

    protocol_flags = attr.ib()

    linknode = attr.ib(default=None)

@interfaceutil.implementer(repository.iverifyproblem)

@attr.s(frozen=True)

class revlogproblem:

    warning = attr.ib(default=None)

    error = attr.ib(default=None)

    node = attr.ib(default=None)

def parse_index_v1(data, inline):

    # call the C implementation to parse the index data

    index, cache = parsers.parse_index2(data, inline)

    return index, cache

def parse_index_v2(data, inline):

    # call the C implementation to parse the index data

    index, cache = parsers.parse_index2(data, inline, format=REVLOGV2)

    return index, cache

def parse_index_cl_v2(data, inline):

    # call the C implementation to parse the index data

    index, cache = parsers.parse_index2(data, inline, format=CHANGELOGV2)

    return index, cache

if hasattr(parsers, 'parse_index_devel_nodemap'):

    def parse_index_v1_nodemap(data, inline):

        index, cache = parsers.parse_index_devel_nodemap(data, inline)

        return index, cache

else:

    parse_index_v1_nodemap = None

def parse_index_v1_mixed(data, inline):

    index, cache = parse_index_v1(data, inline)

    return rustrevlog.MixedIndex(index), cache

# corresponds to uncompressed length of indexformatng (2 gigs, 4-byte

# signed integer)

_maxentrysize = 0x7FFFFFFF

FILE_TOO_SHORT_MSG = _(

    b'cannot read from revlog %s;'

    b'  expected %d bytes from offset %d, data size is %d'

)

hexdigits = b'0123456789abcdefABCDEF'

class _Config:

    def copy(self):

        return self.__class__(**self.__dict__)

@attr.s()

class FeatureConfig(_Config):

    """Hold configuration values about the available revlog features"""

    # the default compression engine

    compression_engine = attr.ib(default=b'zlib')

    # compression engines options

    compression_engine_options = attr.ib(default=attr.Factory(dict))

    # can we use censor on this revlog

    censorable = attr.ib(default=False)

    # does this revlog use the "side data" feature

    has_side_data = attr.ib(default=False)

    # might remove rank configuration once the computation has no impact

    compute_rank = attr.ib(default=False)

    # parent order is supposed to be semantically irrelevant, so we

    # normally resort parents to ensure that the first parent is non-null,

    # if there is a non-null parent at all.

    # filelog abuses the parent order as flag to mark some instances of

    # meta-encoded files, so allow it to disable this behavior.

    canonical_parent_order = attr.ib(default=False)

    # can ellipsis commit be used

    enable_ellipsis = attr.ib(default=False)

    def copy(self):

        new = super().copy()

        new.compression_engine_options = self.compression_engine_options.copy()

        return new

@attr.s()

class DataConfig(_Config):

    """Hold configuration value about how the revlog data are read"""

    # should we try to open the "pending" version of the revlog

    try_pending = attr.ib(default=False)

    # should we try to open the "splitted" version of the revlog

    try_split = attr.ib(default=False)

    #  When True, indexfile should be opened with checkambig=True at writing,

    #  to avoid file stat ambiguity.

    check_ambig = attr.ib(default=False)

    # If true, use mmap instead of reading to deal with large index

    mmap_large_index = attr.ib(default=False)

    # how much data is large

    mmap_index_threshold = attr.ib(default=None)

    # How much data to read and cache into the raw revlog data cache.

    chunk_cache_size = attr.ib(default=65536)

    # Allow sparse reading of the revlog data

    with_sparse_read = attr.ib(default=False)

    # minimal density of a sparse read chunk

    sr_density_threshold = attr.ib(default=0.50)

    # minimal size of data we skip when performing sparse read

    sr_min_gap_size = attr.ib(default=262144)

    # are delta encoded against arbitrary bases.

    generaldelta = attr.ib(default=False)

@attr.s()

class DeltaConfig(_Config):

    """Hold configuration value about how new delta are computed

    Some attributes are duplicated from DataConfig to help havign each object

    self contained.

    """

    # can delta be encoded against arbitrary bases.

    general_delta = attr.ib(default=False)

    # Allow sparse writing of the revlog data

    sparse_revlog = attr.ib(default=False)

    # maximum length of a delta chain

    max_chain_len = attr.ib(default=None)

    # Maximum distance between delta chain base start and end

    max_deltachain_span = attr.ib(default=-1)

    # If `upper_bound_comp` is not None, this is the expected maximal gain from

    # compression for the data content.

    upper_bound_comp = attr.ib(default=None)

    # Should we try a delta against both parent

    delta_both_parents = attr.ib(default=True)

    # Test delta base candidate group by chunk of this maximal size.

    candidate_group_chunk_size = attr.ib(default=0)

    # Should we display debug information about delta computation

    debug_delta = attr.ib(default=False)

    # trust incoming delta by default

    lazy_delta = attr.ib(default=True)

    # trust the base of incoming delta by default

    lazy_delta_base = attr.ib(default=False)

class revlog:

    """

    the underlying revision storage object

    A revlog consists of two parts, an index and the revision data.

    The index is a file with a fixed record size containing

    information on each revision, including its nodeid (hash), the

    nodeids of its parents, the position and offset of its data within

    the data file, and the revision it's based on. Finally, each entry

    contains a linkrev entry that can serve as a pointer to external

    data.

    The revision data itself is a linear collection of data chunks.

    Each chunk represents a revision and is usually represented as a

    delta against the previous chunk. To bound lookup time, runs of

    deltas are limited to about 2 times the length of the original

    version data. This makes retrieval of a version proportional to

    its size, or O(1) relative to the number of revisions.

    Both pieces of the revlog are written to in an append-only

    fashion, which means we never need to rewrite a file to insert or

    remove data, and can use some simple techniques to avoid the need

    for locking while reading.

    If checkambig, indexfile is opened with checkambig=True at

    writing, to avoid file stat ambiguity.

    If mmaplargeindex is True, and an mmapindexthreshold is set, the

    index will be mmapped rather than read if it is larger than the

    configured threshold.

    If censorable is True, the revlog can have censored revisions.

    If `upperboundcomp` is not None, this is the expected maximal gain from

    compression for the data content.

    `concurrencychecker` is an optional function that receives 3 arguments: a

    file handle, a filename, and an expected position. It should check whether

    the current position in the file handle is valid, and log/warn/fail (by

    raising).

    See mercurial/revlogutils/contants.py for details about the content of an

    index entry.

    """

    _flagserrorclass = error.RevlogError

    @staticmethod

    def is_inline_index(header_bytes):

        """Determine if a revlog is inline from the initial bytes of the index"""

        header = INDEX_HEADER.unpack(header_bytes)[0]

        _format_flags = header & ~0xFFFF

        _format_version = header & 0xFFFF

        features = FEATURES_BY_VERSION[_format_version]

        return features[b'inline'](_format_flags)

    def __init__(

        self,

        opener,

        target,

        radix,

        postfix=None,  # only exist for `tmpcensored` now

        checkambig=False,

        mmaplargeindex=False,

        censorable=False,

        upperboundcomp=None,

        persistentnodemap=False,

        concurrencychecker=None,

        trypending=False,

        try_split=False,