# revlog.py - storage back-end for mercurial

#

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

import binascii

import collections

import contextlib

import errno

import io

import os

import struct

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 .pycompat import getattr

from .revlogutils.constants import (

    FLAG_GENERALDELTA,

    FLAG_INLINE_DATA,

    INDEX_ENTRY_V0,

    INDEX_ENTRY_V1,

    INDEX_ENTRY_V2,

    INDEX_HEADER,

    REVLOGV0,

    REVLOGV1,

    REVLOGV1_FLAGS,

    REVLOGV2,

    REVLOGV2_FLAGS,

    REVLOG_DEFAULT_FLAGS,

    REVLOG_DEFAULT_FORMAT,

    REVLOG_DEFAULT_VERSION,

)

from .revlogutils.flagutil import (

    REVIDX_DEFAULT_FLAGS,

    REVIDX_ELLIPSIS,

    REVIDX_EXTSTORED,

    REVIDX_FLAGS_ORDER,

    REVIDX_HASCOPIESINFO,

    REVIDX_ISCENSORED,

    REVIDX_RAWTEXT_CHANGING_FLAGS,

    REVIDX_SIDEDATA,

)

from .thirdparty import attr

from . import (

    ancestor,

    dagop,

    error,

    mdiff,

    policy,

    pycompat,

    templatefilters,

    util,

)

from .interfaces import (

    repository,

    util as interfaceutil,

)

from .revlogutils import (

    deltas as deltautil,

    flagutil,

    nodemap as nodemaputil,

    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

FLAG_INLINE_DATA

FLAG_GENERALDELTA

REVLOG_DEFAULT_FLAGS

REVLOG_DEFAULT_FORMAT

REVLOG_DEFAULT_VERSION

REVLOGV1_FLAGS

REVLOGV2_FLAGS

REVIDX_ISCENSORED

REVIDX_ELLIPSIS

REVIDX_SIDEDATA

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 revlog with inline data

_maxinline = 131072

_chunksize = 1048576

# 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 getoffset(q):

    return int(q >> 16)

def gettype(q):

    return int(q & 0xFFFF)

def offset_type(offset, type):

    if (type & ~flagutil.REVIDX_KNOWN_FLAGS) != 0:

        raise ValueError(b'unknown revlog index flags')

    return int(int(offset) << 16 | type)

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 util.safehasattr(

    parsers, 'BaseIndexObject'

)

@attr.s(slots=True, frozen=True)

class _revisioninfo(object):

    """Information about a revision that allows building its fulltext

    node:       expected hash of the revision

    p1, p2:     parent revs of the revision

    btext:      built text cache consisting of a one-element list

    cachedelta: (baserev, uncompressed_delta) or None

    flags:      flags associated to the revision storage

    One of btext[0] or cachedelta must be set.

    """

    node = attr.ib()

    p1 = attr.ib()

    p2 = attr.ib()

    btext = attr.ib()

    textlen = attr.ib()

    cachedelta = attr.ib()

    flags = attr.ib()

@interfaceutil.implementer(repository.irevisiondelta)

@attr.s(slots=True)

class revlogrevisiondelta(object):

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

    linknode = attr.ib(default=None)

@interfaceutil.implementer(repository.iverifyproblem)

@attr.s(frozen=True)

class revlogproblem(object):

    warning = attr.ib(default=None)

    error = attr.ib(default=None)

    node = attr.ib(default=None)

class revlogoldindex(list):

    entry_size = INDEX_ENTRY_V0.size

    @property

    def nodemap(self):

        msg = b"index.nodemap is deprecated, use index.[has_node|rev|get_rev]"

        util.nouideprecwarn(msg, b'5.3', stacklevel=2)

        return self._nodemap

    @util.propertycache

    def _nodemap(self):

        for r in range(0, len(self)):

            n = self[r][7]

            nodemap[n] = r

        return nodemap

    def has_node(self, node):

        """return True if the node exist in the index"""

        return node in self._nodemap

    def rev(self, node):

        """return a revision for a node

        If the node is unknown, raise a RevlogError"""

        return self._nodemap[node]

    def get_rev(self, node):

        """return a revision for a node

        If the node is unknown, return None"""

        return self._nodemap.get(node)

    def append(self, tup):

        self._nodemap[tup[7]] = len(self)

        super(revlogoldindex, self).append(tup)

    def __delitem__(self, i):

        if not isinstance(i, slice) or not i.stop == -1 or i.step is not None:

            raise ValueError(b"deleting slices only supports a:-1 with step 1")

        for r in pycompat.xrange(i.start, len(self)):

            del self._nodemap[self[r][7]]

        super(revlogoldindex, self).__delitem__(i)

    def clearcaches(self):

        self.__dict__.pop('_nodemap', None)

    def __getitem__(self, i):

        if i == -1:

        return list.__getitem__(self, i)

class revlogoldio(object):

    def parseindex(self, data, inline):

        s = INDEX_ENTRY_V0.size

        index = []

        n = off = 0

        l = len(data)

        while off + s <= l:

            cur = data[off : off + s]

            off += s

            e = INDEX_ENTRY_V0.unpack(cur)

            # transform to revlogv1 format

            e2 = (

                offset_type(e[0], 0),

                e[1],

                -1,

                e[2],

                e[3],

                nodemap.get(e[4], nullrev),

                nodemap.get(e[5], nullrev),

                e[6],

            )

            index.append(e2)

            nodemap[e[6]] = n

            n += 1

        index = revlogoldindex(index)

        return index, None

    def packentry(self, entry, node, version, rev):

        """return the binary representation of an entry

        entry:   a tuple containing all the values (see index.__getitem__)

        node:    a callback to convert a revision to nodeid

        version: the changelog version

        rev:     the revision number

        """

        if gettype(entry[0]):

            raise error.RevlogError(

                _(b'index entry flags need revlog version 1')

            )

        e2 = (

            getoffset(entry[0]),

            entry[1],

            entry[3],

            entry[4],

            node(entry[5]),

            node(entry[6]),

            entry[7],

        )

        return INDEX_ENTRY_V0.pack(*e2)

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

# signed integer)

_maxentrysize = 0x7FFFFFFF

class revlogio(object):

    def parseindex(self, data, inline):

        # call the C implementation to parse the index data

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

        return index, cache

    def packentry(self, entry, node, version, rev):

        p = INDEX_ENTRY_V1.pack(*entry)

        if rev == 0:

            p = INDEX_HEADER.pack(version) + p[4:]

        return p

class revlogv2io(object):

    def parseindex(self, data, inline):

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

        return index, cache

    def packentry(self, entry, node, version, rev):

        p = INDEX_ENTRY_V2.pack(*entry)

        if rev == 0:

            p = INDEX_HEADER.pack(version) + p[4:]

        return p

NodemapRevlogIO = None

if util.safehasattr(parsers, 'parse_index_devel_nodemap'):

    class NodemapRevlogIO(revlogio):

        """A debug oriented IO class that return a PersistentNodeMapIndexObject

        The PersistentNodeMapIndexObject object is meant to test the persistent nodemap feature.

        """

        def parseindex(self, data, inline):

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

            return index, cache

class rustrevlogio(revlogio):

    def parseindex(self, data, inline):

        index, cache = super(rustrevlogio, self).parseindex(data, inline)

        return rustrevlog.MixedIndex(index), cache

class revlog(object):

    """

    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