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

"""

from __future__ import annotations

import binascii

import collections

import contextlib

import functools

import io

import os

import struct

import typing

import weakref

import zlib

from typing import (

    Iterable,

    Iterator,

    Optional,

    Tuple,

)

# 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

# Force pytype to use the non-vendored package

if typing.TYPE_CHECKING:

    # noinspection PyPackageRequirements

    import attr

from . import (

    ancestor,

    dagop,

    error,

    mdiff,

    policy,

    pycompat,

    revlogutils,

    templatefilters,

    util,

    vfs as vfsmod,

)

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'

)

@attr.s(slots=True)

    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)

@attr.s(frozen=True)

class RevLogProblem:

    warning = attr.ib(default=None, type=Optional[bytes])

    error = attr.ib(default=None, type=Optional[bytes])

    node = attr.ib(default=None, type=Optional[bytes])

revlogproblem = interfaceutil.implementer(repository.iverifyproblem)(

    RevLogProblem

)

if typing.TYPE_CHECKING:

    revlogproblem = RevLogProblem

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_rust(data, inline, default_header):

    cache = (0, data) if inline else None

    return rustrevlog.Index(data, default_header), 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)

    # The size of the uncompressed cache compared to the largest revision seen.

    uncompressed_cache_factor = attr.ib(default=None)

    # The number of chunk cached

    uncompressed_cache_count = attr.ib(default=None)

    # 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 _InnerRevlog:

    """An inner layer of the revlog object

    That layer exist to be able to delegate some operation to Rust, its

    boundaries are arbitrary and based on what we can delegate to Rust.

    """

    opener: vfsmod.vfs

    def __init__(

        self,

        opener: vfsmod.vfs,

        index,

        index_file,

        data_file,

        sidedata_file,

        inline,

        data_config,

        delta_config,

        feature_config,

        chunk_cache,

        default_compression_header,

    ):

        self.opener = opener

        self.index = index

        self.index_file = index_file

        self.data_file = data_file

        self.sidedata_file = sidedata_file

        self.inline = inline

        self.data_config = data_config

        self.delta_config = delta_config

        self.feature_config = feature_config

        # used during diverted write.

        self._orig_index_file = None

        self._default_compression_header = default_compression_header

        # index

        # 3-tuple of file handles being used for active writing.

        self._writinghandles = None

        self._segmentfile = randomaccessfile.randomaccessfile(

            self.opener,

            (self.index_file if self.inline else self.data_file),

            self.data_config.chunk_cache_size,

            chunk_cache,

        )

        self._segmentfile_sidedata = randomaccessfile.randomaccessfile(

            self.opener,

            self.sidedata_file,

            self.data_config.chunk_cache_size,

        )

        # revlog header -> revlog compressor

        self._decompressors = {}

        # 3-tuple of (node, rev, text) for a raw revision.

        self._revisioncache = None

        # cache some uncompressed chunks

        # rev → uncompressed_chunk

        #

        # the max cost is dynamically updated to be proportionnal to the

        # size of revision we actually encounter.

        self._uncompressed_chunk_cache = None

        if self.data_config.uncompressed_cache_factor is not None:

            self._uncompressed_chunk_cache = util.lrucachedict(

                self.data_config.uncompressed_cache_count,

                maxcost=65536,  # some arbitrary initial value

            )

        self._delay_buffer = None

    def __len__(self):

        return len(self.index)

    def clear_cache(self):

        assert not self.is_delaying

        self._revisioncache = None

        if self._uncompressed_chunk_cache is not None:

            self._uncompressed_chunk_cache.clear()

        self._segmentfile.clear_cache()

        self._segmentfile_sidedata.clear_cache()

    @property

    def canonical_index_file(self):

        if self._orig_index_file is not None:

            return self._orig_index_file

        return self.index_file

    @property

    def is_delaying(self):

        """is the revlog is currently delaying the visibility of written data?

        The delaying mechanism can be either in-memory or written on disk in a

        side-file."""

        return (self._delay_buffer is not None) or (

            self._orig_index_file is not None

        )

    # Derived from index values.

    def start(self, rev):

        """the offset of the data chunk for this revision"""

        return int(self.index[rev][0] >> 16)

    def length(self, rev):

        """the length of the data chunk for this revision"""

        return self.index[rev][1]

    def end(self, rev):

        """the end of the data chunk for this revision"""

        return self.start(rev) + self.length(rev)