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

from .i18n import _

from . import (

    error,

    hg,

    localrepo,

    lock as lockmod,

    pycompat,

    requirements as requirementsmod,

    scmutil,

)

from .upgrade_utils import (

    actions as upgrade_actions,

    auto_upgrade,

    engine as upgrade_engine,

)

from .utils import (

    stringutil,

)

may_auto_upgrade = auto_upgrade.may_auto_upgrade

allformatvariant = upgrade_actions.allformatvariant

def upgraderepo(

    ui,

    repo,

    run=False,

    optimize=None,

    backup=True,

    manifest=None,

    changelog=None,

    filelogs=None,

):

    """Upgrade a repository in place."""

    if optimize is None:

        optimize = set()

    repo = repo.unfiltered()

    specified_revlogs = {}

    if changelog is not None:

        specified_revlogs[upgrade_engine.UPGRADE_CHANGELOG] = changelog

    if manifest is not None:

        specified_revlogs[upgrade_engine.UPGRADE_MANIFEST] = manifest

    if filelogs is not None:

        specified_revlogs[upgrade_engine.UPGRADE_FILELOGS] = filelogs

    # Ensure the repository can be upgraded.

    upgrade_actions.check_source_requirements(repo)

    default_options = localrepo.defaultcreateopts(repo.ui)

    newreqs = localrepo.newreporequirements(repo.ui, default_options)

    newreqs.update(upgrade_actions.preservedrequirements(repo))

    upgrade_actions.check_requirements_changes(repo, newreqs)

    # Find and validate all improvements that can be made.

    alloptimizations = upgrade_actions.findoptimizations(repo)

    # Apply and Validate arguments.

    optimizations = []

    for o in alloptimizations:

        if o.name in optimize:

            optimizations.append(o)

            optimize.discard(o.name)

    if optimize:  # anything left is unknown

        raise error.Abort(

            _(b'unknown optimization action requested: %s')

            % b', '.join(sorted(optimize)),

            hint=_(b'run without arguments to see valid optimizations'),

        )

    format_upgrades = upgrade_actions.find_format_upgrades(repo)

    up_actions = upgrade_actions.determine_upgrade_actions(

        repo, format_upgrades, optimizations, repo.requirements, newreqs

    )

    removed_actions = upgrade_actions.find_format_downgrades(repo)

    # check if we need to touch revlog and if so, which ones

    touched_revlogs = set()

    overwrite_msg = _(b'warning: ignoring %14s, as upgrade is changing: %s\n')

    select_msg = _(b'note:    selecting %s for processing to change: %s\n')

    msg_issued = 0

    FL = upgrade_engine.UPGRADE_FILELOGS

    MN = upgrade_engine.UPGRADE_MANIFEST

    CL = upgrade_engine.UPGRADE_CHANGELOG

    if optimizations:

        if any(specified_revlogs.values()):

            # we have some limitation on revlogs to be recloned

            for rl, enabled in specified_revlogs.items():

                if enabled:

                    touched_revlogs.add(rl)

        else:

            touched_revlogs = set(upgrade_engine.UPGRADE_ALL_REVLOGS)

            for rl, enabled in specified_revlogs.items():

                if not enabled:

                    touched_revlogs.discard(rl)

    if repo.shared():

        unsafe_actions = set()

        unsafe_actions.update(up_actions)

        unsafe_actions.update(removed_actions)

        unsafe_actions.update(optimizations)

        unsafe_actions = [

            a for a in unsafe_actions if not a.compatible_with_share

        ]

        unsafe_actions.sort(key=lambda a: a.name)

        if unsafe_actions:

            m = _(b'cannot use these actions on a share repository: %s')

            h = _(b'upgrade the main repository directly')

            actions = b', '.join(a.name for a in unsafe_actions)

            m %= actions

            raise error.Abort(m, hint=h)

    for action in sorted(up_actions + removed_actions, key=lambda a: a.name):

        # optimisation does not "requires anything, they just needs it.

        if action.type != upgrade_actions.FORMAT_VARIANT:

            continue

        if action.touches_filelogs and FL not in touched_revlogs:

            if FL in specified_revlogs:

                if not specified_revlogs[FL]:

                    msg = overwrite_msg % (b'--no-filelogs', action.name)

                    ui.warn(msg)

                    msg_issued = 2

            else:

                msg = select_msg % (b'all-filelogs', action.name)

                ui.status(msg)

                if not ui.quiet:

                    msg_issued = 1

            touched_revlogs.add(FL)

        if action.touches_manifests and MN not in touched_revlogs:

            if MN in specified_revlogs:

                if not specified_revlogs[MN]:

                    msg = overwrite_msg % (b'--no-manifest', action.name)

                    ui.warn(msg)

                    msg_issued = 2

            else:

                msg = select_msg % (b'all-manifestlogs', action.name)

                ui.status(msg)

                if not ui.quiet:

                    msg_issued = 1

            touched_revlogs.add(MN)

        if action.touches_changelog and CL not in touched_revlogs:

            if CL in specified_revlogs:

                if not specified_revlogs[CL]:

                    msg = overwrite_msg % (b'--no-changelog', action.name)

                    ui.warn(msg)

                    msg_issued = True

            else:

                msg = select_msg % (b'changelog', action.name)

                ui.status(msg)

                if not ui.quiet:

                    msg_issued = 1

            touched_revlogs.add(CL)

    if msg_issued >= 2:

        ui.warn((b"\n"))

    elif msg_issued >= 1:

        ui.status((b"\n"))

    upgrade_op = upgrade_actions.UpgradeOperation(

        ui,

        newreqs,

        repo.requirements,

        up_actions,

        removed_actions,

        touched_revlogs,

        backup,

    )

    if not run:

        fromconfig = []

        onlydefault = []

        for d in format_upgrades:

            if d.fromconfig(repo):

                fromconfig.append(d)

            elif d.default:

                onlydefault.append(d)

        if fromconfig or onlydefault:

            if fromconfig:

                ui.status(

                    _(

                        b'repository lacks features recommended by '

                        b'current config options:\n\n'

                    )

                )

                for i in fromconfig:

                    ui.status(b'%s\n   %s\n\n' % (i.name, i.description))

            if onlydefault:

                ui.status(

                    _(

                        b'repository lacks features used by the default '

                        b'config options:\n\n'

                    )

                )

                for i in onlydefault:

                    ui.status(b'%s\n   %s\n\n' % (i.name, i.description))

            ui.status(b'\n')

        else:

            ui.status(_(b'(no format upgrades found in existing repository)\n'))

        ui.status(

            _(

                b'performing an upgrade with "--run" will make the following '

                b'changes:\n\n'

            )

        )

        upgrade_op.print_requirements()

        upgrade_op.print_optimisations()

        upgrade_op.print_upgrade_actions()

        upgrade_op.print_affected_revlogs()

        if upgrade_op.unused_optimizations:

            ui.status(

                _(

                    b'additional optimizations are available by specifying '

                    b'"--optimize <name>":\n\n'

                )

            )

            upgrade_op.print_unused_optimizations()

        return

    if not (upgrade_op.upgrade_actions or upgrade_op.removed_actions):

        ui.status(_(b'nothing to do\n'))

        return

    # Else we're in the run=true case.

    ui.write(_(b'upgrade will perform the following actions:\n\n'))

    upgrade_op.print_requirements()

    upgrade_op.print_optimisations()

    upgrade_op.print_upgrade_actions()

    upgrade_op.print_affected_revlogs()

    ui.status(_(b'beginning upgrade...\n'))

    with repo.wlock(), repo.lock():

        ui.status(_(b'repository locked and read-only\n'))

        # Our strategy for upgrading the repository is to create a new,

        # temporary repository, write data to it, then do a swap of the

        # data. There are less heavyweight ways to do this, but it is easier

        # to create a new repo object than to instantiate all the components

        # (like the store) separately.

        tmppath = pycompat.mkdtemp(prefix=b'upgrade.', dir=repo.path)

        backuppath = None

        try:

            ui.status(

                _(

                    b'creating temporary repository to stage upgraded '

                    b'data: %s\n'

                )

                % tmppath

            )

            # clone ui without using ui.copy because repo.ui is protected

            repoui = repo.ui.__class__(repo.ui)

            dstrepo = hg.repository(repoui, path=tmppath, create=True)

            with dstrepo.wlock(), dstrepo.lock():

                backuppath = upgrade_engine.upgrade(

                    ui, repo, dstrepo, upgrade_op

                )

        finally:

            ui.status(_(b'removing temporary repository %s\n') % tmppath)

            repo.vfs.rmtree(tmppath, forcibly=True)

            if backuppath and not ui.quiet:

                ui.warn(

                    _(b'copy of old repository backed up at %s\n') % backuppath

                )

                ui.warn(

                    _(

                        b'the old repository will not be deleted; remove '

                        b'it to free up disk space once the upgraded '

                        b'repository is verified\n'

                    )

                )

            upgrade_op.print_post_op_messages()

def upgrade_share_to_safe(

    ui,

    hgvfs,

    storevfs,

    current_requirements,

    mismatch_config,

    mismatch_warn,

    mismatch_verbose_upgrade,

):

    """Upgrades a share to use share-safe mechanism"""

    wlock = None

    store_requirements = localrepo._readrequires(storevfs, False)

    original_crequirements = current_requirements.copy()

    # after upgrade, store requires will be shared, so lets find

    # the requirements which are not present in store and

    # write them to share's .hg/requires

    diffrequires = current_requirements - store_requirements

    # add share-safe requirement as it will mark the share as share-safe

    diffrequires.add(requirementsmod.SHARESAFE_REQUIREMENT)

    current_requirements.add(requirementsmod.SHARESAFE_REQUIREMENT)

    # in `allow` case, we don't try to upgrade, we just respect the source

    # state, update requirements and continue

    if mismatch_config == b'allow':

        return

    try:

        wlock = lockmod.trylock(ui, hgvfs, b'wlock', 0, 0)

        # some process might change the requirement in between, re-read

        # and update current_requirements

        locked_requirements = localrepo._readrequires(hgvfs, True)

        if locked_requirements != original_crequirements:

            removed = current_requirements - locked_requirements

            # update current_requirements in place because it's passed

            # as reference

            current_requirements -= removed

            current_requirements |= locked_requirements

            diffrequires = current_requirements - store_requirements

            # add share-safe requirement as it will mark the share as share-safe

            diffrequires.add(requirementsmod.SHARESAFE_REQUIREMENT)

            current_requirements.add(requirementsmod.SHARESAFE_REQUIREMENT)

        scmutil.writerequires(hgvfs, diffrequires)

        if mismatch_verbose_upgrade:

            ui.warn(_(b'repository upgraded to use share-safe mode\n'))

    except error.LockError as e:

        hint = _(

            b"see `hg help config.format.use-share-safe` for more information"

        )

        if mismatch_config == b'upgrade-abort':

            raise error.Abort(

                _(b'failed to upgrade share, got error: %s')

                % stringutil.forcebytestr(e.strerror),

                hint=hint,

            )

        elif mismatch_warn:

            ui.warn(

                _(b'failed to upgrade share, got error: %s\n')

                % stringutil.forcebytestr(e.strerror),

                hint=hint,

            )

    finally:

        if wlock:

            wlock.release()

def downgrade_share_to_non_safe(

    ui,

    hgvfs,

    sharedvfs,

    current_requirements,

    mismatch_config,

    mismatch_warn,

    mismatch_verbose_upgrade,

):

    """Downgrades a share which use share-safe to not use it"""

    wlock = None

    source_requirements = localrepo._readrequires(sharedvfs, True)

    original_crequirements = current_requirements.copy()

    # we cannot be 100% sure on which requirements were present in store when

    # the source supported share-safe. However, we do know that working

    # directory requirements were not there. Hence we remove them

    source_requirements -= requirementsmod.WORKING_DIR_REQUIREMENTS

    current_requirements |= source_requirements

    current_requirements.remove(requirementsmod.SHARESAFE_REQUIREMENT)

    if mismatch_config == b'allow':