# verify.py - repository integrity checking for Mercurial

#

# Copyright 2006, 2007 Matt Mackall <mpm@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.

from __future__ import absolute_import

import os

from .i18n import _

from .node import (

    nullid,

    short,

)

from . import (

    error,

    pycompat,

    revlog,

    util,

)

VERIFY_DEFAULT = 0

VERIFY_FULL = 1

def verify(repo, level=None):

    with repo.lock():

        v = verifier(repo, level)

        return v.verify()

def _normpath(f):

    # under hg < 2.4, convert didn't sanitize paths properly, so a

    # converted repo may contain repeated slashes

    return f

class verifier(object):

    def __init__(self, repo, level=None):

        self.repo = repo.unfiltered()

        self.ui = repo.ui

        self.match = repo.narrowmatch()

        if level is None:

            level = VERIFY_DEFAULT

        self._level = level

        self.badrevs = set()

        self.errors = 0

        self.warnings = 0

        self.havecl = len(repo.changelog) > 0

        self.havemf = len(repo.manifestlog.getstorage(b'')) > 0

        self.revlogv1 = repo.changelog.version != revlog.REVLOGV0

        self.lrugetctx = util.lrucachefunc(repo.__getitem__)

        self.refersmf = False

        self.fncachewarned = False

        # developer config: verify.skipflags

        self.warnorphanstorefiles = True

    def _warn(self, msg):

        """record a "warning" level issue"""

        self.warnings += 1

    def _err(self, linkrev, msg, filename=None):

        """record a "error" level issue"""

        if linkrev is not None:

            self.badrevs.add(linkrev)

        else:

        if filename:

        self.errors += 1

    def _exc(self, linkrev, msg, inst, filename=None):

        """record exception raised during the verify process"""

        fmsg = pycompat.bytestr(inst)

        if not fmsg:

            fmsg = pycompat.byterepr(inst)

    def _checkrevlog(self, obj, name, linkrev):

        """verify high level property of a revlog

        - revlog is present,

        - revlog is non-empty,

        - sizes (index and data) are correct,

        - revlog's format version is correct.

        """

        if not len(obj) and (self.havecl or self.havemf):

            return

        d = obj.checksize()

        if d[0]:

        if d[1]:

        if obj.version != revlog.REVLOGV0:

            if not self.revlogv1:

        elif self.revlogv1:

    def _checkentry(self, obj, i, node, seen, linkrevs, f):

        """verify a single revlog entry

        arguments are:

        - obj:      the source revlog

        - i:        the revision number

        - node:        the revision node id

        - seen:     nodes previously seen for this revlog

        - linkrevs: [changelog-revisions] introducing "node"

        - f:        string label ("changelog", "manifest", or filename)

        Performs the following checks:

        - linkrev points to an existing changelog revision,

        - linkrev points to a changelog revision that introduces this revision,

        - linkrev points to the lowest of these changesets,

        - both parents exist in the revlog,

        - the revision is not duplicated.

        Return the linkrev of the revision (or None for changelog's revisions).

        """

        lr = obj.linkrev(obj.rev(node))

        if lr < 0 or (self.havecl and lr not in linkrevs):

            if lr < 0 or lr >= len(self.repo.changelog):

            else:

            self._err(None, msg % (i, lr), f)

            if linkrevs:

                if f and len(linkrevs) > 1:

                    try:

                        # attempt to filter down to real linkrevs

                        linkrevs = [

                            l

                            for l in linkrevs

                            if self.lrugetctx(l)[f].filenode() == node

                        ]

                    except Exception:

                        pass

                self._warn(

                )

            lr = None  # can't be trusted

        try:

            p1, p2 = obj.parents(node)

            if p1 not in seen and p1 != nullid:

                self._err(

                    lr,

                    f,

                )

            if p2 not in seen and p2 != nullid:

                self._err(

                    lr,

                    f,

                )

        except Exception as inst:

        if node in seen:

        seen[node] = i

        return lr

    def verify(self):

        """verify the content of the Mercurial repository

        This method run all verifications, displaying issues as they are found.

        return 1 if any error have been encountered, 0 otherwise."""

        # initial validation and generic report

        repo = self.repo

        ui = repo.ui

        if ui.verbose or not self.revlogv1:

            ui.status(

                % (self.revlogv1 and 1 or 0)

            )

        # data verification

        mflinkrevs, filelinkrevs = self._verifychangelog()

        filenodes = self._verifymanifest(mflinkrevs)

        del mflinkrevs

        self._crosscheckfiles(filelinkrevs, filenodes)

        totalfiles, filerevisions = self._verifyfiles(filenodes, filelinkrevs)

        # final report

        ui.status(

            % (len(repo.changelog), filerevisions, totalfiles)

        )

        if self.warnings:

        if self.fncachewarned:

            ui.warn(

                _(

                )

            )

        if self.errors:

            if self.badrevs:

                ui.warn(

                    % min(self.badrevs)

                )

            return 1

        return 0

    def _verifychangelog(self):

        """verify the changelog of a repository

        The following checks are performed:

        - all of `_checkrevlog` checks,

        - all of `_checkentry` checks (for each revisions),

        - each revision can be read.

        The function returns some of the data observed in the changesets as a

        (mflinkrevs, filelinkrevs) tuples:

        - mflinkrevs:   is a { manifest-node -> [changelog-rev] } mapping

        - filelinkrevs: is a { file-path -> [changelog-rev] } mapping

        If a matcher was specified, filelinkrevs will only contains matched

        files.

        """

        ui = self.ui

        repo = self.repo

        match = self.match

        cl = repo.changelog

        mflinkrevs = {}

        filelinkrevs = {}

        seen = {}

        progress = ui.makeprogress(

        )

        for i in repo:

            progress.update(i)

            n = cl.node(i)

            try:

                changes = cl.read(n)

                if changes[0] != nullid:

                    mflinkrevs.setdefault(changes[0], []).append(i)

                    self.refersmf = True

                for f in changes[3]:

                    if match(f):

                        filelinkrevs.setdefault(_normpath(f), []).append(i)

            except Exception as inst:

                self.refersmf = True

        progress.complete()

        return mflinkrevs, filelinkrevs

    def _verifymanifest(

    ):

        """verify the manifestlog content

        Inputs:

        - mflinkrevs:     a {manifest-node -> [changelog-revisions]} mapping

        - dir:            a subdirectory to check (for tree manifest repo)

        - storefiles:     set of currently "orphan" files.

        - subdirprogress: a progress object

        This function checks:

        * all of `_checkrevlog` checks (for all manifest related revlogs)

        * all of `_checkentry` checks (for all manifest related revisions)

        * nodes for subdirectory exists in the sub-directory manifest

        * each manifest entries have a file path

        * each manifest node refered in mflinkrevs exist in the manifest log

        If tree manifest is in use and a matchers is specified, only the

        sub-directories matching it will be verified.

        return a two level mapping:

            {"path" -> { filenode -> changelog-revision}}

        This mapping primarily contains entries for every files in the

        repository. In addition, when tree-manifest is used, it also contains

        sub-directory entries.

        If a matcher is provided, only matching paths will be included.

        """

        repo = self.repo

        ui = self.ui

        match = self.match

        mfl = self.repo.manifestlog

        mf = mfl.getstorage(dir)

        if not dir:

        filenodes = {}

        subdirnodes = {}

        seen = {}

        if dir:

            label = dir

            revlogfiles = mf.files()

            storefiles.difference_update(revlogfiles)

            if subdirprogress:  # should be true since we're in a subdirectory

                subdirprogress.increment()

        if self.refersmf:

            # Do not check manifest if there are only changelog entries with

            # null manifests.

            self._checkrevlog(mf, label, 0)

        progress = ui.makeprogress(

        )

        for i in mf:

            if not dir:

                progress.update(i)

            n = mf.node(i)

            lr = self._checkentry(mf, i, n, seen, mflinkrevs.get(n, []), label)

            if n in mflinkrevs:

                del mflinkrevs[n]

            elif dir:

                self._err(

                    lr,

                    label,

                )

            else:

            try:

                mfdelta = mfl.get(dir, n).readdelta(shallow=True)

                for f, fn, fl in mfdelta.iterentries():

                    if not f:

                        continue

                    fullpath = dir + _normpath(f)

                        if not match.visitdir(fullpath):

                            continue

                            fn, []

                        ).append(lr)

                    else:

                        if not match(fullpath):

                            continue

                        filenodes.setdefault(fullpath, {}).setdefault(fn, lr)

            except Exception as inst: