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

from ..i18n import _

from ..pycompat import getattr

from .. import (

    changelog,

    error,

    filelog,

    manifest,

    metadata,

    pycompat,

    requirements,

    scmutil,

    store,

    util,

    vfs as vfsmod,

)

from ..revlogutils import (

    constants as revlogconst,

    flagutil,

    nodemap,

    sidedata as sidedatamod,

)

from . import actions as upgrade_actions

def get_sidedata_helpers(srcrepo, dstrepo):

    use_w = srcrepo.ui.configbool(b'experimental', b'worker.repository-upgrade')

    sequential = pycompat.iswindows or not use_w

    if not sequential:

        srcrepo.register_sidedata_computer(

            revlogconst.KIND_CHANGELOG,

            sidedatamod.SD_FILES,

            (sidedatamod.SD_FILES,),

            metadata._get_worker_sidedata_adder(srcrepo, dstrepo),

            flagutil.REVIDX_HASCOPIESINFO,

            replace=True,

        )

    return sidedatamod.get_sidedata_helpers(srcrepo, dstrepo._wanted_sidedata)

def _revlogfrompath(repo, rl_type, path):

    """Obtain a revlog from a repo path.

    An instance of the appropriate class is returned.

    """

    if rl_type & store.FILEFLAGS_CHANGELOG:

        return changelog.changelog(repo.svfs)

    elif rl_type & store.FILEFLAGS_MANIFESTLOG:

        mandir = b''

        if b'/' in path:

            mandir = path.rsplit(b'/', 1)[0]

        return manifest.manifestrevlog(

            repo.nodeconstants, repo.svfs, tree=mandir

        )

    else:

        # drop the extension and the `data/` prefix

        path_part = path.rsplit(b'.', 1)[0].split(b'/', 1)

        if len(path_part) < 2:

            msg = _(b'cannot recognize revlog from filename: %s')

            msg %= path

            raise error.Abort(msg)

        path = path_part[1]

        return filelog.filelog(repo.svfs, path)

def _copyrevlog(tr, destrepo, oldrl, rl_type, unencodedname):

    """copy all relevant files for `oldrl` into `destrepo` store

    Files are copied "as is" without any transformation. The copy is performed

    without extra checks. Callers are responsible for making sure the copied

    content is compatible with format of the destination repository.

    """

    oldrl = getattr(oldrl, '_revlog', oldrl)

    newrl = _revlogfrompath(destrepo, rl_type, unencodedname)

    newrl = getattr(newrl, '_revlog', newrl)

    oldvfs = oldrl.opener

    newvfs = newrl.opener

    oldindex = oldvfs.join(oldrl._indexfile)

    newindex = newvfs.join(newrl._indexfile)

    olddata = oldvfs.join(oldrl._datafile)

    newdata = newvfs.join(newrl._datafile)

    with newvfs(newrl._indexfile, b'w'):

        pass  # create all the directories

    util.copyfile(oldindex, newindex)

    copydata = oldrl.opener.exists(oldrl._datafile)

    if copydata:

        util.copyfile(olddata, newdata)

    if rl_type & store.FILEFLAGS_FILELOG:

        destrepo.svfs.fncache.add(unencodedname)

        if copydata:

            destrepo.svfs.fncache.add(unencodedname[:-2] + b'.d')

UPGRADE_CHANGELOG = b"changelog"

UPGRADE_MANIFEST = b"manifest"

UPGRADE_FILELOGS = b"all-filelogs"

UPGRADE_ALL_REVLOGS = frozenset(

    [UPGRADE_CHANGELOG, UPGRADE_MANIFEST, UPGRADE_FILELOGS]

)

def matchrevlog(revlogfilter, rl_type):

    """check if a revlog is selected for cloning.

    In other words, are there any updates which need to be done on revlog

    or it can be blindly copied.

    The store entry is checked against the passed filter"""

    if rl_type & store.FILEFLAGS_CHANGELOG:

        return UPGRADE_CHANGELOG in revlogfilter

    elif rl_type & store.FILEFLAGS_MANIFESTLOG:

        return UPGRADE_MANIFEST in revlogfilter

    assert rl_type & store.FILEFLAGS_FILELOG

    return UPGRADE_FILELOGS in revlogfilter

def _perform_clone(

    ui,

    dstrepo,

    tr,

    old_revlog,

    rl_type,

    unencoded,

    upgrade_op,

    sidedata_helpers,

    oncopiedrevision,

):

    """returns the new revlog object created"""

    newrl = None

    if matchrevlog(upgrade_op.revlogs_to_process, rl_type):

        ui.note(

            _(b'cloning %d revisions from %s\n') % (len(old_revlog), unencoded)

        )

        newrl = _revlogfrompath(dstrepo, rl_type, unencoded)

        old_revlog.clone(

            tr,

            newrl,

            addrevisioncb=oncopiedrevision,

            deltareuse=upgrade_op.delta_reuse_mode,

            forcedeltabothparents=upgrade_op.force_re_delta_both_parents,

            sidedata_helpers=sidedata_helpers,

        )

    else:

        msg = _(b'blindly copying %s containing %i revisions\n')

        ui.note(msg % (unencoded, len(old_revlog)))

        _copyrevlog(tr, dstrepo, old_revlog, rl_type, unencoded)

        newrl = _revlogfrompath(dstrepo, rl_type, unencoded)

    return newrl

def _clonerevlogs(

    ui,

    srcrepo,

    dstrepo,

    tr,

    upgrade_op,

):

    """Copy revlogs between 2 repos."""

    revcount = 0

    srcsize = 0

    srcrawsize = 0

    dstsize = 0

    fcount = 0

    frevcount = 0

    fsrcsize = 0

    frawsize = 0

    fdstsize = 0

    mcount = 0

    mrevcount = 0

    msrcsize = 0

    mrawsize = 0

    mdstsize = 0

    crevcount = 0

    csrcsize = 0

    crawsize = 0

    cdstsize = 0

    alldatafiles = list(srcrepo.store.walk())

    # mapping of data files which needs to be cloned

    # key is unencoded filename

    # value is revlog_object_from_srcrepo

    manifests = {}

    changelogs = {}

    filelogs = {}

    # Perform a pass to collect metadata. This validates we can open all

    # source files and allows a unified progress bar to be displayed.

    for rl_type, unencoded, size in alldatafiles:

        if not rl_type & store.FILEFLAGS_REVLOG_MAIN:

            continue

        # the store.walk function will wrongly pickup transaction backup and

        # get confused. As a quick fix for 5.9 release, we ignore those.

        # (this is not a module constants because it seems better to keep the

        # hack together)

        skip_undo = (

            b'undo.backup.00changelog.i',

            b'undo.backup.00manifest.i',

        )

        if unencoded in skip_undo:

            continue

        rl = _revlogfrompath(srcrepo, rl_type, unencoded)

        info = rl.storageinfo(

            exclusivefiles=True,

            revisionscount=True,

            trackedsize=True,

            storedsize=True,

        )

        revcount += info[b'revisionscount'] or 0

        datasize = info[b'storedsize'] or 0

        rawsize = info[b'trackedsize'] or 0

        srcsize += datasize

        srcrawsize += rawsize

        # This is for the separate progress bars.

        if rl_type & store.FILEFLAGS_CHANGELOG:

            changelogs[unencoded] = (rl_type, rl)

            crevcount += len(rl)

            csrcsize += datasize

            crawsize += rawsize

        elif rl_type & store.FILEFLAGS_MANIFESTLOG:

            manifests[unencoded] = (rl_type, rl)

            mcount += 1

            mrevcount += len(rl)

            msrcsize += datasize

            mrawsize += rawsize

        elif rl_type & store.FILEFLAGS_FILELOG:

            filelogs[unencoded] = (rl_type, rl)

            fcount += 1

            frevcount += len(rl)

            fsrcsize += datasize

            frawsize += rawsize

        else:

            error.ProgrammingError(b'unknown revlog type')

    if not revcount:

        return

    ui.status(

        _(

            b'migrating %d total revisions (%d in filelogs, %d in manifests, '

            b'%d in changelog)\n'

        )

        % (revcount, frevcount, mrevcount, crevcount)

    )

    ui.status(

        _(b'migrating %s in store; %s tracked data\n')

        % ((util.bytecount(srcsize), util.bytecount(srcrawsize)))

    )

    # Used to keep track of progress.

    progress = None

    def oncopiedrevision(rl, rev, node):

        progress.increment()

    sidedata_helpers = get_sidedata_helpers(srcrepo, dstrepo)

    # Migrating filelogs

    ui.status(

        _(

            b'migrating %d filelogs containing %d revisions '

            b'(%s in store; %s tracked data)\n'

        )

        % (

            fcount,

            frevcount,

            util.bytecount(fsrcsize),

            util.bytecount(frawsize),

        )

    )

    progress = srcrepo.ui.makeprogress(_(b'file revisions'), total=frevcount)

    for unencoded, (rl_type, oldrl) in sorted(filelogs.items()):

        newrl = _perform_clone(

            ui,

            dstrepo,

            tr,

            oldrl,

            rl_type,

            unencoded,

            upgrade_op,

            sidedata_helpers,

            oncopiedrevision,

        )

        info = newrl.storageinfo(storedsize=True)

        fdstsize += info[b'storedsize'] or 0

    ui.status(

        _(

            b'finished migrating %d filelog revisions across %d '

            b'filelogs; change in size: %s\n'

        )

        % (frevcount, fcount, util.bytecount(fdstsize - fsrcsize))

    )

    # Migrating manifests

    ui.status(

        _(

            b'migrating %d manifests containing %d revisions '

            b'(%s in store; %s tracked data)\n'

        )

        % (

            mcount,

            mrevcount,

            util.bytecount(msrcsize),

            util.bytecount(mrawsize),

        )

    )

    if progress:

        progress.complete()

    progress = srcrepo.ui.makeprogress(

        _(b'manifest revisions'), total=mrevcount

    )

    for unencoded, (rl_type, oldrl) in sorted(manifests.items()):

        newrl = _perform_clone(

            ui,

            dstrepo,

            tr,

            oldrl,

            rl_type,

            unencoded,

            upgrade_op,

            sidedata_helpers,

            oncopiedrevision,

        )

        info = newrl.storageinfo(storedsize=True)

        mdstsize += info[b'storedsize'] or 0

    ui.status(

        _(

            b'finished migrating %d manifest revisions across %d '

            b'manifests; change in size: %s\n'

        )

        % (mrevcount, mcount, util.bytecount(mdstsize - msrcsize))

    )

    # Migrating changelog

    ui.status(

        _(

            b'migrating changelog containing %d revisions '

            b'(%s in store; %s tracked data)\n'

        )

        % (

            crevcount,

            util.bytecount(csrcsize),

            util.bytecount(crawsize),

        )

    )

    if progress:

        progress.complete()

    progress = srcrepo.ui.makeprogress(

        _(b'changelog revisions'), total=crevcount

    )

    for unencoded, (rl_type, oldrl) in sorted(changelogs.items()):

        newrl = _perform_clone(

            ui,

            dstrepo,

            tr,

            oldrl,

            rl_type,

            unencoded,

            upgrade_op,

            sidedata_helpers,

            oncopiedrevision,

        )

        info = newrl.storageinfo(storedsize=True)

        cdstsize += info[b'storedsize'] or 0

    progress.complete()

    ui.status(

        _(

            b'finished migrating %d changelog revisions; change in size: '

            b'%s\n'

        )