# upgrade.py - functions for in place upgrade of Mercurial repository

#

# Copyright (c) 2016-present, Gregory Szorc

#

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

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

import random

from ..i18n import _

from .. import (

    error,

    localrepo,

    requirements,

    revlog,

    util,

)

from ..utils import compression

# list of requirements that request a clone of all revlog if added/removed

RECLONES_REQUIREMENTS = {

    requirements.GENERALDELTA_REQUIREMENT,

    requirements.SPARSEREVLOG_REQUIREMENT,

    requirements.REVLOGV2_REQUIREMENT,

    requirements.CHANGELOGV2_REQUIREMENT,

}

def preservedrequirements(repo):

    preserved = {

        requirements.SHARED_REQUIREMENT,

        requirements.NARROW_REQUIREMENT,

    }

    return preserved & repo.requirements

FORMAT_VARIANT = b'deficiency'

OPTIMISATION = b'optimization'

class improvement:

    """Represents an improvement that can be made as part of an upgrade."""

    ### The following attributes should be defined for each subclass:

    # Either ``FORMAT_VARIANT`` or ``OPTIMISATION``.

    # A format variant is where we change the storage format. Not all format

    # variant changes are an obvious problem.

    # An optimization is an action (sometimes optional) that

    # can be taken to further improve the state of the repository.

    type = None

    # machine-readable string uniquely identifying this improvement. it will be

    # mapped to an action later in the upgrade process.

    name = None

    # message intended for humans explaining the improvement in more detail,

    # including the implications of it ``FORMAT_VARIANT`` types, should be

    # worded

    # in the present tense.

    description = None

    # message intended for humans explaining what an upgrade addressing this

    # issue will do. should be worded in the future tense.

    upgrademessage = None

    # value of current Mercurial default for new repository

    default = None

    # Message intended for humans which will be shown post an upgrade

    # operation when the improvement will be added

    postupgrademessage = None

    # Message intended for humans which will be shown post an upgrade

    # operation in which this improvement was removed

    postdowngrademessage = None

    # By default we assume that every improvement touches requirements and all revlogs

    # Whether this improvement touches filelogs

    touches_filelogs = True

    # Whether this improvement touches manifests

    touches_manifests = True

    # Whether this improvement touches changelog

    touches_changelog = True

    # Whether this improvement changes repository requirements

    touches_requirements = True

    # Whether this improvement touches the dirstate

    touches_dirstate = False

    # Can this action be run on a share instead of its mains repository

    compatible_with_share = False

allformatvariant = []  # type: List[Type['formatvariant']]

def registerformatvariant(cls):

    allformatvariant.append(cls)

    return cls

class formatvariant(improvement):

    """an improvement subclass dedicated to repository format"""

    type = FORMAT_VARIANT

    @staticmethod

    def fromrepo(repo):

        """current value of the variant in the repository"""

        raise NotImplementedError()

    @staticmethod

    def fromconfig(repo):

        """current value of the variant in the configuration"""

        raise NotImplementedError()

class requirementformatvariant(formatvariant):

    """formatvariant based on a 'requirement' name.

    Many format variant are controlled by a 'requirement'. We define a small

    subclass to factor the code.

    """

    # the requirement that control this format variant

    _requirement = None

    @staticmethod

    def _newreporequirements(ui):

        return localrepo.newreporequirements(

            ui, localrepo.defaultcreateopts(ui)

        )

    @classmethod

    def fromrepo(cls, repo):

        assert cls._requirement is not None

        return cls._requirement in repo.requirements

    @classmethod

    def fromconfig(cls, repo):

        assert cls._requirement is not None

        return cls._requirement in cls._newreporequirements(repo.ui)

@registerformatvariant

class fncache(requirementformatvariant):

    name = b'fncache'

    _requirement = requirements.FNCACHE_REQUIREMENT

    default = True

    description = _(

        b'long and reserved filenames may not work correctly; '

        b'repository performance is sub-optimal'

    )

    upgrademessage = _(

        b'repository will be more resilient to storing '

        b'certain paths and performance of certain '

        b'operations should be improved'

    )

@registerformatvariant

class dirstatev2(requirementformatvariant):

    name = b'dirstate-v2'

    _requirement = requirements.DIRSTATE_V2_REQUIREMENT

    default = False

    description = _(

        b'version 1 of the dirstate file format requires '

        b'reading and parsing it all at once.\n'

        b'Version 2 has a better structure,'

        b'better information and lighter update mechanism'

    )

    upgrademessage = _(b'"hg status" will be faster')

    touches_filelogs = False

    touches_manifests = False

    touches_changelog = False

    touches_requirements = True

    touches_dirstate = True

    compatible_with_share = True

@registerformatvariant

class dirstatetrackedkey(requirementformatvariant):

    name = b'tracked-hint'

    _requirement = requirements.DIRSTATE_TRACKED_HINT_V1

    default = False

    description = _(

        b'Add a small file to help external tooling that watch the tracked set'

    )

    upgrademessage = _(

        b'external tools will be informated of potential change in the tracked set'

    )

    touches_filelogs = False

    touches_manifests = False

    touches_changelog = False

    touches_requirements = True

    touches_dirstate = True

    compatible_with_share = True

@registerformatvariant

class dotencode(requirementformatvariant):

    name = b'dotencode'

    _requirement = requirements.DOTENCODE_REQUIREMENT

    default = True

    description = _(

        b'storage of filenames beginning with a period or '

        b'space may not work correctly'

    )

    upgrademessage = _(

        b'repository will be better able to store files '

        b'beginning with a space or period'

    )

@registerformatvariant

class generaldelta(requirementformatvariant):

    name = b'generaldelta'

    _requirement = requirements.GENERALDELTA_REQUIREMENT

    default = True

    description = _(

        b'deltas within internal storage are unable to '

        b'choose optimal revisions; repository is larger and '

        b'slower than it could be; interaction with other '

        b'repositories may require extra network and CPU '

        b'resources, making "hg push" and "hg pull" slower'

    )

    upgrademessage = _(

        b'repository storage will be able to create '

        b'optimal deltas; new repository data will be '

        b'smaller and read times should decrease; '

        b'interacting with other repositories using this '

        b'storage model should require less network and '

        b'CPU resources, making "hg push" and "hg pull" '

        b'faster'

    )

@registerformatvariant

class sharesafe(requirementformatvariant):

    name = b'share-safe'

    _requirement = requirements.SHARESAFE_REQUIREMENT

    default = True

    description = _(

        b'old shared repositories do not share source repository '

        b'requirements and config. This leads to various problems '

        b'when the source repository format is upgraded or some new '

        b'extensions are enabled.'

    )

    upgrademessage = _(

        b'Upgrades a repository to share-safe format so that future '

        b'shares of this repository share its requirements and configs.'

    )

    postdowngrademessage = _(

        b'repository downgraded to not use share safe mode, '

        b'existing shares will not work and need to be reshared.'

    )

    postupgrademessage = _(

        b'repository upgraded to share safe mode, existing'

        b' shares will still work in old non-safe mode. '

        b'Re-share existing shares to use them in safe mode'

        b' New shares will be created in safe mode.'

    )

    # upgrade only needs to change the requirements

    touches_filelogs = False

    touches_manifests = False

    touches_changelog = False

    touches_requirements = True

@registerformatvariant

class sparserevlog(requirementformatvariant):

    name = b'sparserevlog'

    _requirement = requirements.SPARSEREVLOG_REQUIREMENT

    default = True

    description = _(

        b'in order to limit disk reading and memory usage on older '

        b'version, the span of a delta chain from its root to its '

        b'end is limited, whatever the relevant data in this span. '

        b'This can severly limit Mercurial ability to build good '

        b'chain of delta resulting is much more storage space being '

        b'taken and limit reusability of on disk delta during '

        b'exchange.'

    )

    upgrademessage = _(

        b'Revlog supports delta chain with more unused data '

        b'between payload. These gaps will be skipped at read '

        b'time. This allows for better delta chains, making a '

        b'better compression and faster exchange with server.'

    )

@registerformatvariant

class persistentnodemap(requirementformatvariant):

    name = b'persistent-nodemap'

    _requirement = requirements.NODEMAP_REQUIREMENT

    default = False

    description = _(

        b'persist the node -> rev mapping on disk to speedup lookup'

    )

    upgrademessage = _(b'Speedup revision lookup by node id.')

@registerformatvariant

class copiessdc(requirementformatvariant):

    name = b'copies-sdc'

    _requirement = requirements.COPIESSDC_REQUIREMENT

    default = False

    description = _(b'Stores copies information alongside changesets.')

    upgrademessage = _(

        b'Allows to use more efficient algorithm to deal with copy tracing.'

    )

    touches_filelogs = False

    touches_manifests = False

@registerformatvariant

class revlogv2(requirementformatvariant):

    name = b'revlog-v2'

    _requirement = requirements.REVLOGV2_REQUIREMENT

    default = False

    description = _(b'Version 2 of the revlog.')

    upgrademessage = _(b'very experimental')

@registerformatvariant

class changelogv2(requirementformatvariant):

    name = b'changelog-v2'

    _requirement = requirements.CHANGELOGV2_REQUIREMENT

    default = False

    description = _(b'An iteration of the revlog focussed on changelog needs.')

    upgrademessage = _(b'quite experimental')

    touches_filelogs = False

    touches_manifests = False

@registerformatvariant

class removecldeltachain(formatvariant):

    name = b'plain-cl-delta'

    default = True

    description = _(

        b'changelog storage is using deltas instead of '

        b'raw entries; changelog reading and any '

        b'operation relying on changelog data are slower '

        b'than they could be'

    )

    upgrademessage = _(

        b'changelog storage will be reformated to '

        b'store raw entries; changelog reading will be '

        b'faster; changelog size may be reduced'

    )

    @staticmethod

    def fromrepo(repo):

        # Mercurial 4.0 changed changelogs to not use delta chains. Search for

        # changelogs with deltas.

        cl = repo.unfiltered().changelog

        if len(cl) <= 1000:

            some_rev = list(cl)

        else:

            # do a random sampling to speeds things up Scanning the whole

            # repository can get really slow on bigger repo.

            some_rev = sorted(

                {random.randint(0, len(cl) - 1) for x in range(1000)}

            )

        chainbase = cl.chainbase

        return all(rev == chainbase(rev) for rev in some_rev)

    @staticmethod

    def fromconfig(repo):

        return True

_has_zstd = (

    b'zstd' in util.compengines

    and util.compengines[b'zstd'].available()

    and util.compengines[b'zstd'].revlogheader()

)

@registerformatvariant

class compressionengine(formatvariant):

    name = b'compression'

    if _has_zstd:

        default = b'zstd'

    else:

        default = b'zlib'

    description = _(

        b'Compresion algorithm used to compress data. '

        b'Some engine are faster than other'

    )

    upgrademessage = _(

        b'revlog content will be recompressed with the new algorithm.'

    )

    @classmethod

    def fromrepo(cls, repo):

        # we allow multiple compression engine requirement to co-exist because

        # strickly speaking, revlog seems to support mixed compression style.

        #

        # The compression used for new entries will be "the last one"

        compression = b'zlib'

        for req in repo.requirements:

            prefix = req.startswith

            if prefix(b'revlog-compression-') or prefix(b'exp-compression-'):

                compression = req.split(b'-', 2)[2]

        return compression

    @classmethod

    def fromconfig(cls, repo):

        compengines = repo.ui.configlist(b'format', b'revlog-compression')

        # return the first valid value as the selection code would do

        for comp in compengines:

            if comp in util.compengines:

                e = util.compengines[comp]

                if e.available() and e.revlogheader():

                    return comp

        # no valide compression found lets display it all for clarity

        return b','.join(compengines)