upgrade: split definition and management of the actions from the main code

This is a second step to clarify and clean up this code. The code responsible
for definition which action exist, are possible and their compatibility if moved
into a sub module.

This clarify the main code and prepare further cleanup.

Differential Revision: https://phab.mercurial-scm.org/D9477

hgext/largefiles/overrides.py

@@ -1,1861 +1,1864 b''
 # Copyright 2009-2010 Gregory P. Ward
 # Copyright 2009-2010 Intelerad Medical Systems Incorporated
 # Copyright 2010-2011 Fog Creek Software
 # Copyright 2010-2011 Unity Technologies
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 '''Overridden Mercurial commands and functions for the largefiles extension'''
 from __future__ import absolute_import
 
 import copy
 import os
 
 from mercurial.i18n import _
 
 from mercurial.pycompat import open
 
 from mercurial.hgweb import webcommands
 
 from mercurial import (
     archival,
     cmdutil,
     copies as copiesmod,
     error,
     exchange,
     extensions,
     exthelper,
     filemerge,
     hg,
     logcmdutil,
     match as matchmod,
     merge,
     mergestate as mergestatemod,
     pathutil,
     pycompat,
     scmutil,
     smartset,
     subrepo,
-    upgrade,
     url as urlmod,
     util,
 )
 
+from mercurial.upgrade_utils import (
+    actions as upgrade_actions,
+)
+
 from . import (
     lfcommands,
     lfutil,
     storefactory,
 )
 
 eh = exthelper.exthelper()
 
 lfstatus = lfutil.lfstatus
 
 MERGE_ACTION_LARGEFILE_MARK_REMOVED = b'lfmr'
 
 # -- Utility functions: commonly/repeatedly needed functionality ---------------
 
 
 def composelargefilematcher(match, manifest):
     """create a matcher that matches only the largefiles in the original
     matcher"""
     m = copy.copy(match)
     lfile = lambda f: lfutil.standin(f) in manifest
     m._files = [lf for lf in m._files if lfile(lf)]
     m._fileset = set(m._files)
     m.always = lambda: False
     origmatchfn = m.matchfn
     m.matchfn = lambda f: lfile(f) and origmatchfn(f)
     return m
 
 
 def composenormalfilematcher(match, manifest, exclude=None):
     excluded = set()
     if exclude is not None:
         excluded.update(exclude)
 
     m = copy.copy(match)
     notlfile = lambda f: not (
         lfutil.isstandin(f) or lfutil.standin(f) in manifest or f in excluded
     )
     m._files = [lf for lf in m._files if notlfile(lf)]
     m._fileset = set(m._files)
     m.always = lambda: False
     origmatchfn = m.matchfn
     m.matchfn = lambda f: notlfile(f) and origmatchfn(f)
     return m
 
 
 def addlargefiles(ui, repo, isaddremove, matcher, uipathfn, **opts):
     large = opts.get('large')
     lfsize = lfutil.getminsize(
         ui, lfutil.islfilesrepo(repo), opts.get('lfsize')
     )
 
     lfmatcher = None
     if lfutil.islfilesrepo(repo):
         lfpats = ui.configlist(lfutil.longname, b'patterns')
         if lfpats:
             lfmatcher = matchmod.match(repo.root, b'', list(lfpats))
 
     lfnames = []
     m = matcher
 
     wctx = repo[None]
     for f in wctx.walk(matchmod.badmatch(m, lambda x, y: None)):
         exact = m.exact(f)
         lfile = lfutil.standin(f) in wctx
         nfile = f in wctx
         exists = lfile or nfile
 
         # Don't warn the user when they attempt to add a normal tracked file.
         # The normal add code will do that for us.
         if exact and exists:
             if lfile:
                 ui.warn(_(b'%s already a largefile\n') % uipathfn(f))
             continue
 
         if (exact or not exists) and not lfutil.isstandin(f):
             # In case the file was removed previously, but not committed
             # (issue3507)
             if not repo.wvfs.exists(f):
                 continue
 
             abovemin = (
                 lfsize and repo.wvfs.lstat(f).st_size >= lfsize * 1024 * 1024
             )
             if large or abovemin or (lfmatcher and lfmatcher(f)):
                 lfnames.append(f)
                 if ui.verbose or not exact:
                     ui.status(_(b'adding %s as a largefile\n') % uipathfn(f))
 
     bad = []
 
     # Need to lock, otherwise there could be a race condition between
     # when standins are created and added to the repo.
     with repo.wlock():
         if not opts.get('dry_run'):
             standins = []
             lfdirstate = lfutil.openlfdirstate(ui, repo)
             for f in lfnames:
                 standinname = lfutil.standin(f)
                 lfutil.writestandin(
                     repo,
                     standinname,
                     hash=b'',
                     executable=lfutil.getexecutable(repo.wjoin(f)),
                 )
                 standins.append(standinname)
                 if lfdirstate[f] == b'r':
                     lfdirstate.normallookup(f)
                 else:
                     lfdirstate.add(f)
             lfdirstate.write()
             bad += [
                 lfutil.splitstandin(f)
                 for f in repo[None].add(standins)
                 if f in m.files()
             ]
 
         added = [f for f in lfnames if f not in bad]
     return added, bad
 
 
 def removelargefiles(ui, repo, isaddremove, matcher, uipathfn, dryrun, **opts):
     after = opts.get('after')
     m = composelargefilematcher(matcher, repo[None].manifest())
     with lfstatus(repo):
         s = repo.status(match=m, clean=not isaddremove)
     manifest = repo[None].manifest()
     modified, added, deleted, clean = [
         [f for f in list if lfutil.standin(f) in manifest]
         for list in (s.modified, s.added, s.deleted, s.clean)
     ]
 
     def warn(files, msg):
         for f in files:
             ui.warn(msg % uipathfn(f))
         return int(len(files) > 0)
 
     if after:
         remove = deleted
         result = warn(
             modified + added + clean, _(b'not removing %s: file still exists\n')
         )
     else:
         remove = deleted + clean
         result = warn(
             modified,
             _(
                 b'not removing %s: file is modified (use -f'
                 b' to force removal)\n'
             ),
         )
         result = (
             warn(
                 added,
                 _(
                     b'not removing %s: file has been marked for add'
                     b' (use forget to undo)\n'
                 ),
             )
             or result
         )
 
     # Need to lock because standin files are deleted then removed from the
     # repository and we could race in-between.
     with repo.wlock():
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         for f in sorted(remove):
             if ui.verbose or not m.exact(f):
                 ui.status(_(b'removing %s\n') % uipathfn(f))
 
             if not dryrun:
                 if not after:
                     repo.wvfs.unlinkpath(f, ignoremissing=True)
 
         if dryrun:
             return result
 
         remove = [lfutil.standin(f) for f in remove]
         # If this is being called by addremove, let the original addremove
         # function handle this.
         if not isaddremove:
             for f in remove:
                 repo.wvfs.unlinkpath(f, ignoremissing=True)
         repo[None].forget(remove)
 
         for f in remove:
             lfutil.synclfdirstate(
                 repo, lfdirstate, lfutil.splitstandin(f), False
             )
 
         lfdirstate.write()
 
     return result
 
 
 # For overriding mercurial.hgweb.webcommands so that largefiles will
 # appear at their right place in the manifests.
 @eh.wrapfunction(webcommands, b'decodepath')
 def decodepath(orig, path):
     return lfutil.splitstandin(path) or path
 
 
 # -- Wrappers: modify existing commands --------------------------------
 
 
 @eh.wrapcommand(
     b'add',
     opts=[
         (b'', b'large', None, _(b'add as largefile')),
         (b'', b'normal', None, _(b'add as normal file')),
         (
             b'',
             b'lfsize',
             b'',
             _(
                 b'add all files above this size (in megabytes) '
                 b'as largefiles (default: 10)'
             ),
         ),
     ],
 )
 def overrideadd(orig, ui, repo, *pats, **opts):
     if opts.get('normal') and opts.get('large'):
         raise error.Abort(_(b'--normal cannot be used with --large'))
     return orig(ui, repo, *pats, **opts)
 
 
 @eh.wrapfunction(cmdutil, b'add')
 def cmdutiladd(orig, ui, repo, matcher, prefix, uipathfn, explicitonly, **opts):
     # The --normal flag short circuits this override
     if opts.get('normal'):
         return orig(ui, repo, matcher, prefix, uipathfn, explicitonly, **opts)
 
     ladded, lbad = addlargefiles(ui, repo, False, matcher, uipathfn, **opts)
     normalmatcher = composenormalfilematcher(
         matcher, repo[None].manifest(), ladded
     )
     bad = orig(ui, repo, normalmatcher, prefix, uipathfn, explicitonly, **opts)
 
     bad.extend(f for f in lbad)
     return bad
 
 
 @eh.wrapfunction(cmdutil, b'remove')
 def cmdutilremove(
     orig, ui, repo, matcher, prefix, uipathfn, after, force, subrepos, dryrun
 ):
     normalmatcher = composenormalfilematcher(matcher, repo[None].manifest())
     result = orig(
         ui,
         repo,
         normalmatcher,
         prefix,
         uipathfn,
         after,
         force,
         subrepos,
         dryrun,
     )
     return (
         removelargefiles(
             ui, repo, False, matcher, uipathfn, dryrun, after=after, force=force
         )
         or result
     )
 
 
 @eh.wrapfunction(subrepo.hgsubrepo, b'status')
 def overridestatusfn(orig, repo, rev2, **opts):
     with lfstatus(repo._repo):
         return orig(repo, rev2, **opts)
 
 
 @eh.wrapcommand(b'status')
 def overridestatus(orig, ui, repo, *pats, **opts):
     with lfstatus(repo):
         return orig(ui, repo, *pats, **opts)
 
 
 @eh.wrapfunction(subrepo.hgsubrepo, b'dirty')
 def overridedirty(orig, repo, ignoreupdate=False, missing=False):
     with lfstatus(repo._repo):
         return orig(repo, ignoreupdate=ignoreupdate, missing=missing)
 
 
 @eh.wrapcommand(b'log')
 def overridelog(orig, ui, repo, *pats, **opts):
     def overridematchandpats(
         orig,
         ctx,
         pats=(),
         opts=None,
         globbed=False,
         default=b'relpath',
         badfn=None,
     ):
         """Matcher that merges root directory with .hglf, suitable for log.
         It is still possible to match .hglf directly.
         For any listed files run log on the standin too.
         matchfn tries both the given filename and with .hglf stripped.
         """
         if opts is None:
             opts = {}
         matchandpats = orig(ctx, pats, opts, globbed, default, badfn=badfn)
         m, p = copy.copy(matchandpats)
 
         if m.always():
             # We want to match everything anyway, so there's no benefit trying
             # to add standins.
             return matchandpats
 
         pats = set(p)
 
         def fixpats(pat, tostandin=lfutil.standin):
             if pat.startswith(b'set:'):
                 return pat
 
             kindpat = matchmod._patsplit(pat, None)
 
             if kindpat[0] is not None:
                 return kindpat[0] + b':' + tostandin(kindpat[1])
             return tostandin(kindpat[1])
 
         cwd = repo.getcwd()
         if cwd:
             hglf = lfutil.shortname
             back = util.pconvert(repo.pathto(hglf)[: -len(hglf)])
 
             def tostandin(f):
                 # The file may already be a standin, so truncate the back
                 # prefix and test before mangling it.  This avoids turning
                 # 'glob:../.hglf/foo*' into 'glob:../.hglf/../.hglf/foo*'.
                 if f.startswith(back) and lfutil.splitstandin(f[len(back) :]):
                     return f
 
                 # An absolute path is from outside the repo, so truncate the
                 # path to the root before building the standin.  Otherwise cwd
                 # is somewhere in the repo, relative to root, and needs to be
                 # prepended before building the standin.
                 if os.path.isabs(cwd):
                     f = f[len(back) :]
                 else:
                     f = cwd + b'/' + f
                 return back + lfutil.standin(f)
 
         else:
 
             def tostandin(f):
                 if lfutil.isstandin(f):
                     return f
                 return lfutil.standin(f)
 
         pats.update(fixpats(f, tostandin) for f in p)
 
         for i in range(0, len(m._files)):
             # Don't add '.hglf' to m.files, since that is already covered by '.'
             if m._files[i] == b'.':
                 continue
             standin = lfutil.standin(m._files[i])
             # If the "standin" is a directory, append instead of replace to
             # support naming a directory on the command line with only
             # largefiles.  The original directory is kept to support normal
             # files.
             if standin in ctx:
                 m._files[i] = standin
             elif m._files[i] not in ctx and repo.wvfs.isdir(standin):
                 m._files.append(standin)
 
         m._fileset = set(m._files)
         m.always = lambda: False
         origmatchfn = m.matchfn
 
         def lfmatchfn(f):
             lf = lfutil.splitstandin(f)
             if lf is not None and origmatchfn(lf):
                 return True
             r = origmatchfn(f)
             return r
 
         m.matchfn = lfmatchfn
 
         ui.debug(b'updated patterns: %s\n' % b', '.join(sorted(pats)))
         return m, pats
 
     # For hg log --patch, the match object is used in two different senses:
     # (1) to determine what revisions should be printed out, and
     # (2) to determine what files to print out diffs for.
     # The magic matchandpats override should be used for case (1) but not for
     # case (2).
     oldmatchandpats = scmutil.matchandpats
 
     def overridemakefilematcher(orig, repo, pats, opts, badfn=None):
         wctx = repo[None]
         match, pats = oldmatchandpats(wctx, pats, opts, badfn=badfn)
         return lambda ctx: match
 
     wrappedmatchandpats = extensions.wrappedfunction(
         scmutil, b'matchandpats', overridematchandpats
     )
     wrappedmakefilematcher = extensions.wrappedfunction(
         logcmdutil, b'_makenofollowfilematcher', overridemakefilematcher
     )
     with wrappedmatchandpats, wrappedmakefilematcher:
         return orig(ui, repo, *pats, **opts)
 
 
 @eh.wrapcommand(
     b'verify',
     opts=[
         (
             b'',
             b'large',
             None,
             _(b'verify that all largefiles in current revision exists'),
         ),
         (
             b'',
             b'lfa',
             None,
             _(b'verify largefiles in all revisions, not just current'),
         ),
         (
             b'',
             b'lfc',
             None,
             _(b'verify local largefile contents, not just existence'),
         ),
     ],
 )
 def overrideverify(orig, ui, repo, *pats, **opts):
     large = opts.pop('large', False)
     all = opts.pop('lfa', False)
     contents = opts.pop('lfc', False)
 
     result = orig(ui, repo, *pats, **opts)
     if large or all or contents:
         result = result or lfcommands.verifylfiles(ui, repo, all, contents)
     return result
 
 
 @eh.wrapcommand(
     b'debugstate',
     opts=[(b'', b'large', None, _(b'display largefiles dirstate'))],
 )
 def overridedebugstate(orig, ui, repo, *pats, **opts):
     large = opts.pop('large', False)
     if large:
 
         class fakerepo(object):
             dirstate = lfutil.openlfdirstate(ui, repo)
 
         orig(ui, fakerepo, *pats, **opts)
     else:
         orig(ui, repo, *pats, **opts)
 
 
 # Before starting the manifest merge, merge.updates will call
 # _checkunknownfile to check if there are any files in the merged-in
 # changeset that collide with unknown files in the working copy.
 #
 # The largefiles are seen as unknown, so this prevents us from merging
 # in a file 'foo' if we already have a largefile with the same name.
 #
 # The overridden function filters the unknown files by removing any
 # largefiles. This makes the merge proceed and we can then handle this
 # case further in the overridden calculateupdates function below.
 @eh.wrapfunction(merge, b'_checkunknownfile')
 def overridecheckunknownfile(origfn, repo, wctx, mctx, f, f2=None):
     if lfutil.standin(repo.dirstate.normalize(f)) in wctx:
         return False
     return origfn(repo, wctx, mctx, f, f2)
 
 
 # The manifest merge handles conflicts on the manifest level. We want
 # to handle changes in largefile-ness of files at this level too.
 #
 # The strategy is to run the original calculateupdates and then process
 # the action list it outputs. There are two cases we need to deal with:
 #
 # 1. Normal file in p1, largefile in p2. Here the largefile is
 #    detected via its standin file, which will enter the working copy
 #    with a "get" action. It is not "merge" since the standin is all
 #    Mercurial is concerned with at this level -- the link to the
 #    existing normal file is not relevant here.
 #
 # 2. Largefile in p1, normal file in p2. Here we get a "merge" action
 #    since the largefile will be present in the working copy and
 #    different from the normal file in p2. Mercurial therefore
 #    triggers a merge action.
 #
 # In both cases, we prompt the user and emit new actions to either
 # remove the standin (if the normal file was kept) or to remove the
 # normal file and get the standin (if the largefile was kept). The
 # default prompt answer is to use the largefile version since it was
 # presumably changed on purpose.
 #
 # Finally, the merge.applyupdates function will then take care of
 # writing the files into the working copy and lfcommands.updatelfiles
 # will update the largefiles.
 @eh.wrapfunction(merge, b'calculateupdates')
 def overridecalculateupdates(
     origfn, repo, p1, p2, pas, branchmerge, force, acceptremote, *args, **kwargs
 ):
     overwrite = force and not branchmerge
     mresult = origfn(
         repo, p1, p2, pas, branchmerge, force, acceptremote, *args, **kwargs
     )
 
     if overwrite:
         return mresult
 
     # Convert to dictionary with filename as key and action as value.
     lfiles = set()
     for f in mresult.files():
         splitstandin = lfutil.splitstandin(f)
         if splitstandin is not None and splitstandin in p1:
             lfiles.add(splitstandin)
         elif lfutil.standin(f) in p1:
             lfiles.add(f)
 
     for lfile in sorted(lfiles):
         standin = lfutil.standin(lfile)
         (lm, largs, lmsg) = mresult.getfile(lfile, (None, None, None))
         (sm, sargs, smsg) = mresult.getfile(standin, (None, None, None))
         if sm in (b'g', b'dc') and lm != b'r':
             if sm == b'dc':
                 f1, f2, fa, move, anc = sargs
                 sargs = (p2[f2].flags(), False)
             # Case 1: normal file in the working copy, largefile in
             # the second parent
             usermsg = (
                 _(
                     b'remote turned local normal file %s into a largefile\n'
                     b'use (l)argefile or keep (n)ormal file?'
                     b'$$ &Largefile $$ &Normal file'
                 )
                 % lfile
             )
             if repo.ui.promptchoice(usermsg, 0) == 0:  # pick remote largefile
                 mresult.addfile(lfile, b'r', None, b'replaced by standin')
                 mresult.addfile(standin, b'g', sargs, b'replaces standin')
             else:  # keep local normal file
                 mresult.addfile(lfile, b'k', None, b'replaces standin')
                 if branchmerge:
                     mresult.addfile(
                         standin,
                         b'k',
                         None,
                         b'replaced by non-standin',
                     )
                 else:
                     mresult.addfile(
                         standin,
                         b'r',
                         None,
                         b'replaced by non-standin',
                     )
         elif lm in (b'g', b'dc') and sm != b'r':
             if lm == b'dc':
                 f1, f2, fa, move, anc = largs
                 largs = (p2[f2].flags(), False)
             # Case 2: largefile in the working copy, normal file in
             # the second parent
             usermsg = (
                 _(
                     b'remote turned local largefile %s into a normal file\n'
                     b'keep (l)argefile or use (n)ormal file?'
                     b'$$ &Largefile $$ &Normal file'
                 )
                 % lfile
             )
             if repo.ui.promptchoice(usermsg, 0) == 0:  # keep local largefile
                 if branchmerge:
                     # largefile can be restored from standin safely
                     mresult.addfile(
                         lfile,
                         b'k',
                         None,
                         b'replaced by standin',
                     )
                     mresult.addfile(standin, b'k', None, b'replaces standin')
                 else:
                     # "lfile" should be marked as "removed" without
                     # removal of itself
                     mresult.addfile(
                         lfile,
                         MERGE_ACTION_LARGEFILE_MARK_REMOVED,
                         None,
                         b'forget non-standin largefile',
                     )
 
                     # linear-merge should treat this largefile as 're-added'
                     mresult.addfile(standin, b'a', None, b'keep standin')
             else:  # pick remote normal file
                 mresult.addfile(lfile, b'g', largs, b'replaces standin')
                 mresult.addfile(
                     standin,
                     b'r',
                     None,
                     b'replaced by non-standin',
                 )
 
     return mresult
 
 
 @eh.wrapfunction(mergestatemod, b'recordupdates')
 def mergerecordupdates(orig, repo, actions, branchmerge, getfiledata):
     if MERGE_ACTION_LARGEFILE_MARK_REMOVED in actions:
         lfdirstate = lfutil.openlfdirstate(repo.ui, repo)
         for lfile, args, msg in actions[MERGE_ACTION_LARGEFILE_MARK_REMOVED]:
             # this should be executed before 'orig', to execute 'remove'
             # before all other actions
             repo.dirstate.remove(lfile)
             # make sure lfile doesn't get synclfdirstate'd as normal
             lfdirstate.add(lfile)
         lfdirstate.write()
 
     return orig(repo, actions, branchmerge, getfiledata)
 
 
 # Override filemerge to prompt the user about how they wish to merge
 # largefiles. This will handle identical edits without prompting the user.
 @eh.wrapfunction(filemerge, b'_filemerge')
 def overridefilemerge(
     origfn, premerge, repo, wctx, mynode, orig, fcd, fco, fca, labels=None
 ):
     if not lfutil.isstandin(orig) or fcd.isabsent() or fco.isabsent():
         return origfn(
             premerge, repo, wctx, mynode, orig, fcd, fco, fca, labels=labels
         )
 
     ahash = lfutil.readasstandin(fca).lower()
     dhash = lfutil.readasstandin(fcd).lower()
     ohash = lfutil.readasstandin(fco).lower()
     if (
         ohash != ahash
         and ohash != dhash
         and (
             dhash == ahash
             or repo.ui.promptchoice(
                 _(
                     b'largefile %s has a merge conflict\nancestor was %s\n'
                     b'you can keep (l)ocal %s or take (o)ther %s.\n'
                     b'what do you want to do?'
                     b'$$ &Local $$ &Other'
                 )
                 % (lfutil.splitstandin(orig), ahash, dhash, ohash),
                 0,
             )
             == 1
         )
     ):
         repo.wwrite(fcd.path(), fco.data(), fco.flags())
     return True, 0, False
 
 
 @eh.wrapfunction(copiesmod, b'pathcopies')
 def copiespathcopies(orig, ctx1, ctx2, match=None):
     copies = orig(ctx1, ctx2, match=match)
     updated = {}
 
     for k, v in pycompat.iteritems(copies):
         updated[lfutil.splitstandin(k) or k] = lfutil.splitstandin(v) or v
 
     return updated
 
 
 # Copy first changes the matchers to match standins instead of
 # largefiles.  Then it overrides util.copyfile in that function it
 # checks if the destination largefile already exists. It also keeps a
 # list of copied files so that the largefiles can be copied and the
 # dirstate updated.
 @eh.wrapfunction(cmdutil, b'copy')
 def overridecopy(orig, ui, repo, pats, opts, rename=False):
     # doesn't remove largefile on rename
     if len(pats) < 2:
         # this isn't legal, let the original function deal with it
         return orig(ui, repo, pats, opts, rename)
 
     # This could copy both lfiles and normal files in one command,
     # but we don't want to do that. First replace their matcher to
     # only match normal files and run it, then replace it to just
     # match largefiles and run it again.
     nonormalfiles = False
     nolfiles = False
     manifest = repo[None].manifest()
 
     def normalfilesmatchfn(
         orig,
         ctx,
         pats=(),
         opts=None,
         globbed=False,
         default=b'relpath',
         badfn=None,
     ):
         if opts is None:
             opts = {}
         match = orig(ctx, pats, opts, globbed, default, badfn=badfn)
         return composenormalfilematcher(match, manifest)
 
     with extensions.wrappedfunction(scmutil, b'match', normalfilesmatchfn):
         try:
             result = orig(ui, repo, pats, opts, rename)
         except error.Abort as e:
             if e.message != _(b'no files to copy'):
                 raise e
             else:
                 nonormalfiles = True
             result = 0
 
     # The first rename can cause our current working directory to be removed.
     # In that case there is nothing left to copy/rename so just quit.
     try:
         repo.getcwd()
     except OSError:
         return result
 
     def makestandin(relpath):
         path = pathutil.canonpath(repo.root, repo.getcwd(), relpath)
         return repo.wvfs.join(lfutil.standin(path))
 
     fullpats = scmutil.expandpats(pats)
     dest = fullpats[-1]
 
     if os.path.isdir(dest):
         if not os.path.isdir(makestandin(dest)):
             os.makedirs(makestandin(dest))
 
     try:
         # When we call orig below it creates the standins but we don't add
         # them to the dir state until later so lock during that time.
         wlock = repo.wlock()
 
         manifest = repo[None].manifest()
 
         def overridematch(
             orig,
             ctx,
             pats=(),
             opts=None,
             globbed=False,
             default=b'relpath',
             badfn=None,
         ):
             if opts is None:
                 opts = {}
             newpats = []
             # The patterns were previously mangled to add the standin
             # directory; we need to remove that now
             for pat in pats:
                 if matchmod.patkind(pat) is None and lfutil.shortname in pat:
                     newpats.append(pat.replace(lfutil.shortname, b''))
                 else:
                     newpats.append(pat)
             match = orig(ctx, newpats, opts, globbed, default, badfn=badfn)
             m = copy.copy(match)
             lfile = lambda f: lfutil.standin(f) in manifest
             m._files = [lfutil.standin(f) for f in m._files if lfile(f)]
             m._fileset = set(m._files)
             origmatchfn = m.matchfn
 
             def matchfn(f):
                 lfile = lfutil.splitstandin(f)
                 return (
                     lfile is not None
                     and (f in manifest)
                     and origmatchfn(lfile)
                     or None
                 )
 
             m.matchfn = matchfn
             return m
 
         listpats = []
         for pat in pats:
             if matchmod.patkind(pat) is not None:
                 listpats.append(pat)
             else:
                 listpats.append(makestandin(pat))
 
         copiedfiles = []
 
         def overridecopyfile(orig, src, dest, *args, **kwargs):
             if lfutil.shortname in src and dest.startswith(
                 repo.wjoin(lfutil.shortname)
             ):
                 destlfile = dest.replace(lfutil.shortname, b'')
                 if not opts[b'force'] and os.path.exists(destlfile):
                     raise IOError(
                         b'', _(b'destination largefile already exists')
                     )
             copiedfiles.append((src, dest))
             orig(src, dest, *args, **kwargs)
 
         with extensions.wrappedfunction(util, b'copyfile', overridecopyfile):
             with extensions.wrappedfunction(scmutil, b'match', overridematch):
                 result += orig(ui, repo, listpats, opts, rename)
 
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         for (src, dest) in copiedfiles:
             if lfutil.shortname in src and dest.startswith(
                 repo.wjoin(lfutil.shortname)
             ):
                 srclfile = src.replace(repo.wjoin(lfutil.standin(b'')), b'')
                 destlfile = dest.replace(repo.wjoin(lfutil.standin(b'')), b'')
                 destlfiledir = repo.wvfs.dirname(repo.wjoin(destlfile)) or b'.'
                 if not os.path.isdir(destlfiledir):
                     os.makedirs(destlfiledir)
                 if rename:
                     os.rename(repo.wjoin(srclfile), repo.wjoin(destlfile))
 
                     # The file is gone, but this deletes any empty parent
                     # directories as a side-effect.
                     repo.wvfs.unlinkpath(srclfile, ignoremissing=True)
                     lfdirstate.remove(srclfile)
                 else:
                     util.copyfile(repo.wjoin(srclfile), repo.wjoin(destlfile))
 
                 lfdirstate.add(destlfile)
         lfdirstate.write()
     except error.Abort as e:
         if e.message != _(b'no files to copy'):
             raise e
         else:
             nolfiles = True
     finally:
         wlock.release()
 
     if nolfiles and nonormalfiles:
         raise error.Abort(_(b'no files to copy'))
 
     return result
 
 
 # When the user calls revert, we have to be careful to not revert any
 # changes to other largefiles accidentally. This means we have to keep
 # track of the largefiles that are being reverted so we only pull down
 # the necessary largefiles.
 #
 # Standins are only updated (to match the hash of largefiles) before
 # commits. Update the standins then run the original revert, changing
 # the matcher to hit standins instead of largefiles. Based on the
 # resulting standins update the largefiles.
 @eh.wrapfunction(cmdutil, b'revert')
 def overriderevert(orig, ui, repo, ctx, *pats, **opts):
     # Because we put the standins in a bad state (by updating them)
     # and then return them to a correct state we need to lock to
     # prevent others from changing them in their incorrect state.
     with repo.wlock():
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         s = lfutil.lfdirstatestatus(lfdirstate, repo)
         lfdirstate.write()
         for lfile in s.modified:
             lfutil.updatestandin(repo, lfile, lfutil.standin(lfile))
         for lfile in s.deleted:
             fstandin = lfutil.standin(lfile)
             if repo.wvfs.exists(fstandin):
                 repo.wvfs.unlink(fstandin)
 
         oldstandins = lfutil.getstandinsstate(repo)
 
         def overridematch(
             orig,
             mctx,
             pats=(),
             opts=None,
             globbed=False,
             default=b'relpath',
             badfn=None,
         ):
             if opts is None:
                 opts = {}
             match = orig(mctx, pats, opts, globbed, default, badfn=badfn)
             m = copy.copy(match)
 
             # revert supports recursing into subrepos, and though largefiles
             # currently doesn't work correctly in that case, this match is
             # called, so the lfdirstate above may not be the correct one for
             # this invocation of match.
             lfdirstate = lfutil.openlfdirstate(
                 mctx.repo().ui, mctx.repo(), False
             )
 
             wctx = repo[None]
             matchfiles = []
             for f in m._files:
                 standin = lfutil.standin(f)
                 if standin in ctx or standin in mctx:
                     matchfiles.append(standin)
                 elif standin in wctx or lfdirstate[f] == b'r':
                     continue
                 else:
                     matchfiles.append(f)
             m._files = matchfiles
             m._fileset = set(m._files)
             origmatchfn = m.matchfn
 
             def matchfn(f):
                 lfile = lfutil.splitstandin(f)
                 if lfile is not None:
                     return origmatchfn(lfile) and (f in ctx or f in mctx)
                 return origmatchfn(f)
 
             m.matchfn = matchfn
             return m
 
         with extensions.wrappedfunction(scmutil, b'match', overridematch):
             orig(ui, repo, ctx, *pats, **opts)
 
         newstandins = lfutil.getstandinsstate(repo)
         filelist = lfutil.getlfilestoupdate(oldstandins, newstandins)
         # lfdirstate should be 'normallookup'-ed for updated files,
         # because reverting doesn't touch dirstate for 'normal' files
         # when target revision is explicitly specified: in such case,
         # 'n' and valid timestamp in dirstate doesn't ensure 'clean'
         # of target (standin) file.
         lfcommands.updatelfiles(
             ui, repo, filelist, printmessage=False, normallookup=True
         )
 
 
 # after pulling changesets, we need to take some extra care to get
 # largefiles updated remotely
 @eh.wrapcommand(
     b'pull',
     opts=[
         (
             b'',
             b'all-largefiles',
             None,
             _(b'download all pulled versions of largefiles (DEPRECATED)'),
         ),
         (
             b'',
             b'lfrev',
             [],
             _(b'download largefiles for these revisions'),
             _(b'REV'),
         ),
     ],
 )
 def overridepull(orig, ui, repo, source=None, **opts):
     revsprepull = len(repo)
     if not source:
         source = b'default'
     repo.lfpullsource = source
     result = orig(ui, repo, source, **opts)
     revspostpull = len(repo)
     lfrevs = opts.get('lfrev', [])
     if opts.get('all_largefiles'):
         lfrevs.append(b'pulled()')
     if lfrevs and revspostpull > revsprepull:
         numcached = 0
         repo.firstpulled = revsprepull  # for pulled() revset expression
         try:
             for rev in scmutil.revrange(repo, lfrevs):
                 ui.note(_(b'pulling largefiles for revision %d\n') % rev)
                 (cached, missing) = lfcommands.cachelfiles(ui, repo, rev)
                 numcached += len(cached)
         finally:
             del repo.firstpulled
         ui.status(_(b"%d largefiles cached\n") % numcached)
     return result
 
 
 @eh.wrapcommand(
     b'push',
     opts=[
         (
             b'',
             b'lfrev',
             [],
             _(b'upload largefiles for these revisions'),
             _(b'REV'),
         )
     ],
 )
 def overridepush(orig, ui, repo, *args, **kwargs):
     """Override push command and store --lfrev parameters in opargs"""
     lfrevs = kwargs.pop('lfrev', None)
     if lfrevs:
         opargs = kwargs.setdefault('opargs', {})
         opargs[b'lfrevs'] = scmutil.revrange(repo, lfrevs)
     return orig(ui, repo, *args, **kwargs)
 
 
 @eh.wrapfunction(exchange, b'pushoperation')
 def exchangepushoperation(orig, *args, **kwargs):
     """Override pushoperation constructor and store lfrevs parameter"""
     lfrevs = kwargs.pop('lfrevs', None)
     pushop = orig(*args, **kwargs)
     pushop.lfrevs = lfrevs
     return pushop
 
 
 @eh.revsetpredicate(b'pulled()')
 def pulledrevsetsymbol(repo, subset, x):
     """Changesets that just has been pulled.
 
     Only available with largefiles from pull --lfrev expressions.
 
     .. container:: verbose
 
       Some examples:
 
       - pull largefiles for all new changesets::
 
           hg pull -lfrev "pulled()"
 
       - pull largefiles for all new branch heads::
 
           hg pull -lfrev "head(pulled()) and not closed()"
 
     """
 
     try:
         firstpulled = repo.firstpulled
     except AttributeError:
         raise error.Abort(_(b"pulled() only available in --lfrev"))
     return smartset.baseset([r for r in subset if r >= firstpulled])
 
 
 @eh.wrapcommand(
     b'clone',
     opts=[
         (
             b'',
             b'all-largefiles',
             None,
             _(b'download all versions of all largefiles'),
         )
     ],
 )
 def overrideclone(orig, ui, source, dest=None, **opts):
     d = dest
     if d is None:
         d = hg.defaultdest(source)
     if opts.get('all_largefiles') and not hg.islocal(d):
         raise error.Abort(
             _(b'--all-largefiles is incompatible with non-local destination %s')
             % d
         )
 
     return orig(ui, source, dest, **opts)
 
 
 @eh.wrapfunction(hg, b'clone')
 def hgclone(orig, ui, opts, *args, **kwargs):
     result = orig(ui, opts, *args, **kwargs)
 
     if result is not None:
         sourcerepo, destrepo = result
         repo = destrepo.local()
 
         # When cloning to a remote repo (like through SSH), no repo is available
         # from the peer.   Therefore the largefiles can't be downloaded and the
         # hgrc can't be updated.
         if not repo:
             return result
 
         # Caching is implicitly limited to 'rev' option, since the dest repo was
         # truncated at that point.  The user may expect a download count with
         # this option, so attempt whether or not this is a largefile repo.
         if opts.get(b'all_largefiles'):
             success, missing = lfcommands.downloadlfiles(ui, repo)
 
             if missing != 0:
                 return None
 
     return result
 
 
 @eh.wrapcommand(b'rebase', extension=b'rebase')
 def overriderebasecmd(orig, ui, repo, **opts):
     if not util.safehasattr(repo, b'_largefilesenabled'):
         return orig(ui, repo, **opts)
 
     resuming = opts.get('continue')
     repo._lfcommithooks.append(lfutil.automatedcommithook(resuming))
     repo._lfstatuswriters.append(lambda *msg, **opts: None)
     try:
         with ui.configoverride(
             {(b'rebase', b'experimental.inmemory'): False}, b"largefiles"
         ):
             return orig(ui, repo, **opts)
     finally:
         repo._lfstatuswriters.pop()
         repo._lfcommithooks.pop()
 
 
 @eh.extsetup
 def overriderebase(ui):
     try:
         rebase = extensions.find(b'rebase')
     except KeyError:
         pass
     else:
 
         def _dorebase(orig, *args, **kwargs):
             kwargs['inmemory'] = False
             return orig(*args, **kwargs)
 
         extensions.wrapfunction(rebase, b'_dorebase', _dorebase)
 
 
 @eh.wrapcommand(b'archive')
 def overridearchivecmd(orig, ui, repo, dest, **opts):
     with lfstatus(repo.unfiltered()):
         return orig(ui, repo.unfiltered(), dest, **opts)
 
 
 @eh.wrapfunction(webcommands, b'archive')
 def hgwebarchive(orig, web):
     with lfstatus(web.repo):
         return orig(web)
 
 
 @eh.wrapfunction(archival, b'archive')
 def overridearchive(
     orig,
     repo,
     dest,
     node,
     kind,
     decode=True,
     match=None,
     prefix=b'',
     mtime=None,
     subrepos=None,
 ):
     # For some reason setting repo.lfstatus in hgwebarchive only changes the
     # unfiltered repo's attr, so check that as well.
     if not repo.lfstatus and not repo.unfiltered().lfstatus:
         return orig(
             repo, dest, node, kind, decode, match, prefix, mtime, subrepos
         )
 
     # No need to lock because we are only reading history and
     # largefile caches, neither of which are modified.
     if node is not None:
         lfcommands.cachelfiles(repo.ui, repo, node)
 
     if kind not in archival.archivers:
         raise error.Abort(_(b"unknown archive type '%s'") % kind)
 
     ctx = repo[node]
 
     if kind == b'files':
         if prefix:
             raise error.Abort(_(b'cannot give prefix when archiving to files'))
     else:
         prefix = archival.tidyprefix(dest, kind, prefix)
 
     def write(name, mode, islink, getdata):
         if match and not match(name):
             return
         data = getdata()
         if decode:
             data = repo.wwritedata(name, data)
         archiver.addfile(prefix + name, mode, islink, data)
 
     archiver = archival.archivers[kind](dest, mtime or ctx.date()[0])
 
     if repo.ui.configbool(b"ui", b"archivemeta"):
         write(
             b'.hg_archival.txt',
             0o644,
             False,
             lambda: archival.buildmetadata(ctx),
         )
 
     for f in ctx:
         ff = ctx.flags(f)
         getdata = ctx[f].data
         lfile = lfutil.splitstandin(f)
         if lfile is not None:
             if node is not None:
                 path = lfutil.findfile(repo, getdata().strip())
 
                 if path is None:
                     raise error.Abort(
                         _(
                             b'largefile %s not found in repo store or system cache'
                         )
                         % lfile
                     )
             else:
                 path = lfile
 
             f = lfile
 
             getdata = lambda: util.readfile(path)
         write(f, b'x' in ff and 0o755 or 0o644, b'l' in ff, getdata)
 
     if subrepos:
         for subpath in sorted(ctx.substate):
             sub = ctx.workingsub(subpath)
             submatch = matchmod.subdirmatcher(subpath, match)
             subprefix = prefix + subpath + b'/'
 
             # TODO: Only hgsubrepo instances have `_repo`, so figure out how to
             # infer and possibly set lfstatus in hgsubrepoarchive.  That would
             # allow only hgsubrepos to set this, instead of the current scheme
             # where the parent sets this for the child.
             with (
                 util.safehasattr(sub, '_repo')
                 and lfstatus(sub._repo)
                 or util.nullcontextmanager()
             ):
                 sub.archive(archiver, subprefix, submatch)
 
     archiver.done()
 
 
 @eh.wrapfunction(subrepo.hgsubrepo, b'archive')
 def hgsubrepoarchive(orig, repo, archiver, prefix, match=None, decode=True):
     lfenabled = util.safehasattr(repo._repo, b'_largefilesenabled')
     if not lfenabled or not repo._repo.lfstatus:
         return orig(repo, archiver, prefix, match, decode)
 
     repo._get(repo._state + (b'hg',))
     rev = repo._state[1]
     ctx = repo._repo[rev]
 
     if ctx.node() is not None:
         lfcommands.cachelfiles(repo.ui, repo._repo, ctx.node())
 
     def write(name, mode, islink, getdata):
         # At this point, the standin has been replaced with the largefile name,
         # so the normal matcher works here without the lfutil variants.
         if match and not match(f):
             return
         data = getdata()
         if decode:
             data = repo._repo.wwritedata(name, data)
 
         archiver.addfile(prefix + name, mode, islink, data)
 
     for f in ctx:
         ff = ctx.flags(f)
         getdata = ctx[f].data
         lfile = lfutil.splitstandin(f)
         if lfile is not None:
             if ctx.node() is not None:
                 path = lfutil.findfile(repo._repo, getdata().strip())
 
                 if path is None:
                     raise error.Abort(
                         _(
                             b'largefile %s not found in repo store or system cache'
                         )
                         % lfile
                     )
             else:
                 path = lfile
 
             f = lfile
 
             getdata = lambda: util.readfile(os.path.join(prefix, path))
 
         write(f, b'x' in ff and 0o755 or 0o644, b'l' in ff, getdata)
 
     for subpath in sorted(ctx.substate):
         sub = ctx.workingsub(subpath)
         submatch = matchmod.subdirmatcher(subpath, match)
         subprefix = prefix + subpath + b'/'
         # TODO: Only hgsubrepo instances have `_repo`, so figure out how to
         # infer and possibly set lfstatus at the top of this function.  That
         # would allow only hgsubrepos to set this, instead of the current scheme
         # where the parent sets this for the child.
         with (
             util.safehasattr(sub, '_repo')
             and lfstatus(sub._repo)
             or util.nullcontextmanager()
         ):
             sub.archive(archiver, subprefix, submatch, decode)
 
 
 # If a largefile is modified, the change is not reflected in its
 # standin until a commit. cmdutil.bailifchanged() raises an exception
 # if the repo has uncommitted changes. Wrap it to also check if
 # largefiles were changed. This is used by bisect, backout and fetch.
 @eh.wrapfunction(cmdutil, b'bailifchanged')
 def overridebailifchanged(orig, repo, *args, **kwargs):
     orig(repo, *args, **kwargs)
     with lfstatus(repo):
         s = repo.status()
     if s.modified or s.added or s.removed or s.deleted:
         raise error.Abort(_(b'uncommitted changes'))
 
 
 @eh.wrapfunction(cmdutil, b'postcommitstatus')
 def postcommitstatus(orig, repo, *args, **kwargs):
     with lfstatus(repo):
         return orig(repo, *args, **kwargs)
 
 
 @eh.wrapfunction(cmdutil, b'forget')
 def cmdutilforget(
     orig, ui, repo, match, prefix, uipathfn, explicitonly, dryrun, interactive
 ):
     normalmatcher = composenormalfilematcher(match, repo[None].manifest())
     bad, forgot = orig(
         ui,
         repo,
         normalmatcher,
         prefix,
         uipathfn,
         explicitonly,
         dryrun,
         interactive,
     )
     m = composelargefilematcher(match, repo[None].manifest())
 
     with lfstatus(repo):
         s = repo.status(match=m, clean=True)
     manifest = repo[None].manifest()
     forget = sorted(s.modified + s.added + s.deleted + s.clean)
     forget = [f for f in forget if lfutil.standin(f) in manifest]
 
     for f in forget:
         fstandin = lfutil.standin(f)
         if fstandin not in repo.dirstate and not repo.wvfs.isdir(fstandin):
             ui.warn(
                 _(b'not removing %s: file is already untracked\n') % uipathfn(f)
             )
             bad.append(f)
 
     for f in forget:
         if ui.verbose or not m.exact(f):
             ui.status(_(b'removing %s\n') % uipathfn(f))
 
     # Need to lock because standin files are deleted then removed from the
     # repository and we could race in-between.
     with repo.wlock():
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         for f in forget:
             if lfdirstate[f] == b'a':
                 lfdirstate.drop(f)
             else:
                 lfdirstate.remove(f)
         lfdirstate.write()
         standins = [lfutil.standin(f) for f in forget]
         for f in standins:
             repo.wvfs.unlinkpath(f, ignoremissing=True)
         rejected = repo[None].forget(standins)
 
     bad.extend(f for f in rejected if f in m.files())
     forgot.extend(f for f in forget if f not in rejected)
     return bad, forgot
 
 
 def _getoutgoings(repo, other, missing, addfunc):
     """get pairs of filename and largefile hash in outgoing revisions
     in 'missing'.
 
     largefiles already existing on 'other' repository are ignored.
 
     'addfunc' is invoked with each unique pairs of filename and
     largefile hash value.
     """
     knowns = set()
     lfhashes = set()
 
     def dedup(fn, lfhash):
         k = (fn, lfhash)
         if k not in knowns:
             knowns.add(k)
             lfhashes.add(lfhash)
 
     lfutil.getlfilestoupload(repo, missing, dedup)
     if lfhashes:
         lfexists = storefactory.openstore(repo, other).exists(lfhashes)
         for fn, lfhash in knowns:
             if not lfexists[lfhash]:  # lfhash doesn't exist on "other"
                 addfunc(fn, lfhash)
 
 
 def outgoinghook(ui, repo, other, opts, missing):
     if opts.pop(b'large', None):
         lfhashes = set()
         if ui.debugflag:
             toupload = {}
 
             def addfunc(fn, lfhash):
                 if fn not in toupload:
                     toupload[fn] = []
                 toupload[fn].append(lfhash)
                 lfhashes.add(lfhash)
 
             def showhashes(fn):
                 for lfhash in sorted(toupload[fn]):
                     ui.debug(b'    %s\n' % lfhash)
 
         else:
             toupload = set()
 
             def addfunc(fn, lfhash):
                 toupload.add(fn)
                 lfhashes.add(lfhash)
 
             def showhashes(fn):
                 pass
 
         _getoutgoings(repo, other, missing, addfunc)
 
         if not toupload:
             ui.status(_(b'largefiles: no files to upload\n'))
         else:
             ui.status(
                 _(b'largefiles to upload (%d entities):\n') % (len(lfhashes))
             )
             for file in sorted(toupload):
                 ui.status(lfutil.splitstandin(file) + b'\n')
                 showhashes(file)
             ui.status(b'\n')
 
 
 @eh.wrapcommand(
     b'outgoing', opts=[(b'', b'large', None, _(b'display outgoing largefiles'))]
 )
 def _outgoingcmd(orig, *args, **kwargs):
     # Nothing to do here other than add the extra help option- the hook above
     # processes it.
     return orig(*args, **kwargs)
 
 
 def summaryremotehook(ui, repo, opts, changes):
     largeopt = opts.get(b'large', False)
     if changes is None:
         if largeopt:
             return (False, True)  # only outgoing check is needed
         else:
             return (False, False)
     elif largeopt:
         url, branch, peer, outgoing = changes[1]
         if peer is None:
             # i18n: column positioning for "hg summary"
             ui.status(_(b'largefiles: (no remote repo)\n'))
             return
 
         toupload = set()
         lfhashes = set()
 
         def addfunc(fn, lfhash):
             toupload.add(fn)
             lfhashes.add(lfhash)
 
         _getoutgoings(repo, peer, outgoing.missing, addfunc)
 
         if not toupload:
             # i18n: column positioning for "hg summary"
             ui.status(_(b'largefiles: (no files to upload)\n'))
         else:
             # i18n: column positioning for "hg summary"
             ui.status(
                 _(b'largefiles: %d entities for %d files to upload\n')
                 % (len(lfhashes), len(toupload))
             )
 
 
 @eh.wrapcommand(
     b'summary', opts=[(b'', b'large', None, _(b'display outgoing largefiles'))]
 )
 def overridesummary(orig, ui, repo, *pats, **opts):
     with lfstatus(repo):
         orig(ui, repo, *pats, **opts)
 
 
 @eh.wrapfunction(scmutil, b'addremove')
 def scmutiladdremove(orig, repo, matcher, prefix, uipathfn, opts=None):
     if opts is None:
         opts = {}
     if not lfutil.islfilesrepo(repo):
         return orig(repo, matcher, prefix, uipathfn, opts)
     # Get the list of missing largefiles so we can remove them
     lfdirstate = lfutil.openlfdirstate(repo.ui, repo)
     unsure, s = lfdirstate.status(
         matchmod.always(),
         subrepos=[],
         ignored=False,
         clean=False,
         unknown=False,
     )
 
     # Call into the normal remove code, but the removing of the standin, we want
     # to have handled by original addremove.  Monkey patching here makes sure
     # we don't remove the standin in the largefiles code, preventing a very
     # confused state later.
     if s.deleted:
         m = copy.copy(matcher)
 
         # The m._files and m._map attributes are not changed to the deleted list
         # because that affects the m.exact() test, which in turn governs whether
         # or not the file name is printed, and how.  Simply limit the original
         # matches to those in the deleted status list.
         matchfn = m.matchfn
         m.matchfn = lambda f: f in s.deleted and matchfn(f)
 
         removelargefiles(
             repo.ui,
             repo,
             True,
             m,
             uipathfn,
             opts.get(b'dry_run'),
             **pycompat.strkwargs(opts)
         )
     # Call into the normal add code, and any files that *should* be added as
     # largefiles will be
     added, bad = addlargefiles(
         repo.ui, repo, True, matcher, uipathfn, **pycompat.strkwargs(opts)
     )
     # Now that we've handled largefiles, hand off to the original addremove
     # function to take care of the rest.  Make sure it doesn't do anything with
     # largefiles by passing a matcher that will ignore them.
     matcher = composenormalfilematcher(matcher, repo[None].manifest(), added)
     return orig(repo, matcher, prefix, uipathfn, opts)
 
 
 # Calling purge with --all will cause the largefiles to be deleted.
 # Override repo.status to prevent this from happening.
 @eh.wrapcommand(b'purge', extension=b'purge')
 def overridepurge(orig, ui, repo, *dirs, **opts):
     # XXX Monkey patching a repoview will not work. The assigned attribute will
     # be set on the unfiltered repo, but we will only lookup attributes in the
     # unfiltered repo if the lookup in the repoview object itself fails. As the
     # monkey patched method exists on the repoview class the lookup will not
     # fail. As a result, the original version will shadow the monkey patched
     # one, defeating the monkey patch.
     #
     # As a work around we use an unfiltered repo here. We should do something
     # cleaner instead.
     repo = repo.unfiltered()
     oldstatus = repo.status
 
     def overridestatus(
         node1=b'.',
         node2=None,
         match=None,
         ignored=False,
         clean=False,
         unknown=False,
         listsubrepos=False,
     ):
         r = oldstatus(
             node1, node2, match, ignored, clean, unknown, listsubrepos
         )
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         unknown = [f for f in r.unknown if lfdirstate[f] == b'?']
         ignored = [f for f in r.ignored if lfdirstate[f] == b'?']
         return scmutil.status(
             r.modified, r.added, r.removed, r.deleted, unknown, ignored, r.clean
         )
 
     repo.status = overridestatus
     orig(ui, repo, *dirs, **opts)
     repo.status = oldstatus
 
 
 @eh.wrapcommand(b'rollback')
 def overriderollback(orig, ui, repo, **opts):
     with repo.wlock():
         before = repo.dirstate.parents()
         orphans = {
             f
             for f in repo.dirstate
             if lfutil.isstandin(f) and repo.dirstate[f] != b'r'
         }
         result = orig(ui, repo, **opts)
         after = repo.dirstate.parents()
         if before == after:
             return result  # no need to restore standins
 
         pctx = repo[b'.']
         for f in repo.dirstate:
             if lfutil.isstandin(f):
                 orphans.discard(f)
                 if repo.dirstate[f] == b'r':
                     repo.wvfs.unlinkpath(f, ignoremissing=True)
                 elif f in pctx:
                     fctx = pctx[f]
                     repo.wwrite(f, fctx.data(), fctx.flags())
                 else:
                     # content of standin is not so important in 'a',
                     # 'm' or 'n' (coming from the 2nd parent) cases
                     lfutil.writestandin(repo, f, b'', False)
         for standin in orphans:
             repo.wvfs.unlinkpath(standin, ignoremissing=True)
 
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         orphans = set(lfdirstate)
         lfiles = lfutil.listlfiles(repo)
         for file in lfiles:
             lfutil.synclfdirstate(repo, lfdirstate, file, True)
             orphans.discard(file)
         for lfile in orphans:
             lfdirstate.drop(lfile)
         lfdirstate.write()
     return result
 
 
 @eh.wrapcommand(b'transplant', extension=b'transplant')
 def overridetransplant(orig, ui, repo, *revs, **opts):
     resuming = opts.get('continue')
     repo._lfcommithooks.append(lfutil.automatedcommithook(resuming))
     repo._lfstatuswriters.append(lambda *msg, **opts: None)
     try:
         result = orig(ui, repo, *revs, **opts)
     finally:
         repo._lfstatuswriters.pop()
         repo._lfcommithooks.pop()
     return result
 
 
 @eh.wrapcommand(b'cat')
 def overridecat(orig, ui, repo, file1, *pats, **opts):
     opts = pycompat.byteskwargs(opts)
     ctx = scmutil.revsingle(repo, opts.get(b'rev'))
     err = 1
     notbad = set()
     m = scmutil.match(ctx, (file1,) + pats, opts)
     origmatchfn = m.matchfn
 
     def lfmatchfn(f):
         if origmatchfn(f):
             return True
         lf = lfutil.splitstandin(f)
         if lf is None:
             return False
         notbad.add(lf)
         return origmatchfn(lf)
 
     m.matchfn = lfmatchfn
     origbadfn = m.bad
 
     def lfbadfn(f, msg):
         if not f in notbad:
             origbadfn(f, msg)
 
     m.bad = lfbadfn
 
     origvisitdirfn = m.visitdir
 
     def lfvisitdirfn(dir):
         if dir == lfutil.shortname:
             return True
         ret = origvisitdirfn(dir)
         if ret:
             return ret
         lf = lfutil.splitstandin(dir)
         if lf is None:
             return False
         return origvisitdirfn(lf)
 
     m.visitdir = lfvisitdirfn
 
     for f in ctx.walk(m):
         with cmdutil.makefileobj(ctx, opts.get(b'output'), pathname=f) as fp:
             lf = lfutil.splitstandin(f)
             if lf is None or origmatchfn(f):
                 # duplicating unreachable code from commands.cat
                 data = ctx[f].data()
                 if opts.get(b'decode'):
                     data = repo.wwritedata(f, data)
                 fp.write(data)
             else:
                 hash = lfutil.readasstandin(ctx[f])
                 if not lfutil.inusercache(repo.ui, hash):
                     store = storefactory.openstore(repo)
                     success, missing = store.get([(lf, hash)])
                     if len(success) != 1:
                         raise error.Abort(
                             _(
                                 b'largefile %s is not in cache and could not be '
                                 b'downloaded'
                             )
                             % lf
                         )
                 path = lfutil.usercachepath(repo.ui, hash)
                 with open(path, b"rb") as fpin:
                     for chunk in util.filechunkiter(fpin):
                         fp.write(chunk)
         err = 0
     return err
 
 
 @eh.wrapfunction(merge, b'_update')
 def mergeupdate(orig, repo, node, branchmerge, force, *args, **kwargs):
     matcher = kwargs.get('matcher', None)
     # note if this is a partial update
     partial = matcher and not matcher.always()
     with repo.wlock():
         # branch |       |         |
         #  merge | force | partial | action
         # -------+-------+---------+--------------
         #    x   |   x   |    x    | linear-merge
         #    o   |   x   |    x    | branch-merge
         #    x   |   o   |    x    | overwrite (as clean update)
         #    o   |   o   |    x    | force-branch-merge (*1)
         #    x   |   x   |    o    |   (*)
         #    o   |   x   |    o    |   (*)
         #    x   |   o   |    o    | overwrite (as revert)
         #    o   |   o   |    o    |   (*)
         #
         # (*) don't care
         # (*1) deprecated, but used internally (e.g: "rebase --collapse")
 
         lfdirstate = lfutil.openlfdirstate(repo.ui, repo)
         unsure, s = lfdirstate.status(
             matchmod.always(),
             subrepos=[],
             ignored=False,
             clean=True,
             unknown=False,
         )
         oldclean = set(s.clean)
         pctx = repo[b'.']
         dctx = repo[node]
         for lfile in unsure + s.modified:
             lfileabs = repo.wvfs.join(lfile)
             if not repo.wvfs.exists(lfileabs):
                 continue
             lfhash = lfutil.hashfile(lfileabs)
             standin = lfutil.standin(lfile)
             lfutil.writestandin(
                 repo, standin, lfhash, lfutil.getexecutable(lfileabs)
             )
             if standin in pctx and lfhash == lfutil.readasstandin(
                 pctx[standin]
             ):
                 oldclean.add(lfile)
         for lfile in s.added:
             fstandin = lfutil.standin(lfile)
             if fstandin not in dctx:
                 # in this case, content of standin file is meaningless
                 # (in dctx, lfile is unknown, or normal file)
                 continue
             lfutil.updatestandin(repo, lfile, fstandin)
         # mark all clean largefiles as dirty, just in case the update gets
         # interrupted before largefiles and lfdirstate are synchronized
         for lfile in oldclean:
             lfdirstate.normallookup(lfile)
         lfdirstate.write()
 
         oldstandins = lfutil.getstandinsstate(repo)
         wc = kwargs.get('wc')
         if wc and wc.isinmemory():
             # largefiles is not a good candidate for in-memory merge (large
             # files, custom dirstate, matcher usage).
             raise error.ProgrammingError(
                 b'largefiles is not compatible with in-memory merge'
             )
         result = orig(repo, node, branchmerge, force, *args, **kwargs)
 
         newstandins = lfutil.getstandinsstate(repo)
         filelist = lfutil.getlfilestoupdate(oldstandins, newstandins)
 
         # to avoid leaving all largefiles as dirty and thus rehash them, mark
         # all the ones that didn't change as clean
         for lfile in oldclean.difference(filelist):
             lfdirstate.normal(lfile)
         lfdirstate.write()
 
         if branchmerge or force or partial:
             filelist.extend(s.deleted + s.removed)
 
         lfcommands.updatelfiles(
             repo.ui, repo, filelist=filelist, normallookup=partial
         )
 
         return result
 
 
 @eh.wrapfunction(scmutil, b'marktouched')
 def scmutilmarktouched(orig, repo, files, *args, **kwargs):
     result = orig(repo, files, *args, **kwargs)
 
     filelist = []
     for f in files:
         lf = lfutil.splitstandin(f)
         if lf is not None:
             filelist.append(lf)
     if filelist:
         lfcommands.updatelfiles(
             repo.ui,
             repo,
             filelist=filelist,
             printmessage=False,
             normallookup=True,
         )
 
     return result
 
 
[e-mail](upgrade, b'preservedrequirements')
[e-mail](upgrade, b'supporteddestrequirements')
[e-mail](upgrade_actions, b'preservedrequirements')
[e-mail](upgrade_actions, b'supporteddestrequirements')
 def upgraderequirements(orig, repo):
     reqs = orig(repo)
     if b'largefiles' in repo.requirements:
         reqs.add(b'largefiles')
     return reqs
 
 
 _lfscheme = b'largefile://'
 
 
 @eh.wrapfunction(urlmod, b'open')
 def openlargefile(orig, ui, url_, data=None):
     if url_.startswith(_lfscheme):
         if data:
             msg = b"cannot use data on a 'largefile://' url"
             raise error.ProgrammingError(msg)
         lfid = url_[len(_lfscheme) :]
         return storefactory.getlfile(ui, lfid)
     else:
         return orig(ui, url_, data=data)

hgext/lfs/wrapper.py

@@ -1,548 +1,550 b''
 # wrapper.py - methods wrapping core mercurial logic
 #
 # Copyright 2017 Facebook, Inc.
 #
 # 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 hashlib
 
 from mercurial.i18n import _
 from mercurial.node import bin, hex, nullid, short
 from mercurial.pycompat import (
     getattr,
     setattr,
 )
 
 from mercurial import (
     bundle2,
     changegroup,
     cmdutil,
     context,
     error,
     exchange,
     exthelper,
     localrepo,
     pycompat,
     revlog,
     scmutil,
-    upgrade,
     util,
     vfs as vfsmod,
     wireprotov1server,
 )
 
-from mercurial.upgrade_utils import engine as upgrade_engine
+from mercurial.upgrade_utils import (
+    actions as upgrade_actions,
+    engine as upgrade_engine,
+)
 
 from mercurial.interfaces import repository
 
 from mercurial.utils import (
     storageutil,
     stringutil,
 )
 
 from ..largefiles import lfutil
 
 from . import (
     blobstore,
     pointer,
 )
 
 eh = exthelper.exthelper()
 
 
 @eh.wrapfunction(localrepo, b'makefilestorage')
 def localrepomakefilestorage(orig, requirements, features, **kwargs):
     if b'lfs' in requirements:
         features.add(repository.REPO_FEATURE_LFS)
 
     return orig(requirements=requirements, features=features, **kwargs)
 
 
 @eh.wrapfunction(changegroup, b'allsupportedversions')
 def allsupportedversions(orig, ui):
     versions = orig(ui)
     versions.add(b'03')
     return versions
 
 
 @eh.wrapfunction(wireprotov1server, b'_capabilities')
 def _capabilities(orig, repo, proto):
     '''Wrap server command to announce lfs server capability'''
     caps = orig(repo, proto)
     if util.safehasattr(repo.svfs, b'lfslocalblobstore'):
         # Advertise a slightly different capability when lfs is *required*, so
         # that the client knows it MUST load the extension.  If lfs is not
         # required on the server, there's no reason to autoload the extension
         # on the client.
         if b'lfs' in repo.requirements:
             caps.append(b'lfs-serve')
 
         caps.append(b'lfs')
     return caps
 
 
 def bypasscheckhash(self, text):
     return False
 
 
 def readfromstore(self, text):
     """Read filelog content from local blobstore transform for flagprocessor.
 
     Default tranform for flagprocessor, returning contents from blobstore.
     Returns a 2-typle (text, validatehash) where validatehash is True as the
     contents of the blobstore should be checked using checkhash.
     """
     p = pointer.deserialize(text)
     oid = p.oid()
     store = self.opener.lfslocalblobstore
     if not store.has(oid):
         p.filename = self.filename
         self.opener.lfsremoteblobstore.readbatch([p], store)
 
     # The caller will validate the content
     text = store.read(oid, verify=False)
 
     # pack hg filelog metadata
     hgmeta = {}
     for k in p.keys():
         if k.startswith(b'x-hg-'):
             name = k[len(b'x-hg-') :]
             hgmeta[name] = p[k]
     if hgmeta or text.startswith(b'\1\n'):
         text = storageutil.packmeta(hgmeta, text)
 
     return (text, True, {})
 
 
 def writetostore(self, text, sidedata):
     # hg filelog metadata (includes rename, etc)
     hgmeta, offset = storageutil.parsemeta(text)
     if offset and offset > 0:
         # lfs blob does not contain hg filelog metadata
         text = text[offset:]
 
     # git-lfs only supports sha256
     oid = hex(hashlib.sha256(text).digest())
     self.opener.lfslocalblobstore.write(oid, text)
 
     # replace contents with metadata
     longoid = b'sha256:%s' % oid
     metadata = pointer.gitlfspointer(oid=longoid, size=b'%d' % len(text))
 
     # by default, we expect the content to be binary. however, LFS could also
     # be used for non-binary content. add a special entry for non-binary data.
     # this will be used by filectx.isbinary().
     if not stringutil.binary(text):
         # not hg filelog metadata (affecting commit hash), no "x-hg-" prefix
         metadata[b'x-is-binary'] = b'0'
 
     # translate hg filelog metadata to lfs metadata with "x-hg-" prefix
     if hgmeta is not None:
         for k, v in pycompat.iteritems(hgmeta):
             metadata[b'x-hg-%s' % k] = v
 
     rawtext = metadata.serialize()
     return (rawtext, False)
 
 
 def _islfs(rlog, node=None, rev=None):
     if rev is None:
         if node is None:
             # both None - likely working copy content where node is not ready
             return False
         rev = rlog.rev(node)
     else:
         node = rlog.node(rev)
     if node == nullid:
         return False
     flags = rlog.flags(rev)
     return bool(flags & revlog.REVIDX_EXTSTORED)
 
 
 # Wrapping may also be applied by remotefilelog
 def filelogaddrevision(
     orig,
     self,
     text,
     transaction,
     link,
     p1,
     p2,
     cachedelta=None,
     node=None,
     flags=revlog.REVIDX_DEFAULT_FLAGS,
     **kwds
 ):
     # The matcher isn't available if reposetup() wasn't called.
     lfstrack = self._revlog.opener.options.get(b'lfstrack')
 
     if lfstrack:
         textlen = len(text)
         # exclude hg rename meta from file size
         meta, offset = storageutil.parsemeta(text)
         if offset:
             textlen -= offset
 
         if lfstrack(self._revlog.filename, textlen):
             flags |= revlog.REVIDX_EXTSTORED
 
     return orig(
         self,
         text,
         transaction,
         link,
         p1,
         p2,
         cachedelta=cachedelta,
         node=node,
         flags=flags,
         **kwds
     )
 
 
 # Wrapping may also be applied by remotefilelog
 def filelogrenamed(orig, self, node):
     if _islfs(self._revlog, node):
         rawtext = self._revlog.rawdata(node)
         if not rawtext:
             return False
         metadata = pointer.deserialize(rawtext)
         if b'x-hg-copy' in metadata and b'x-hg-copyrev' in metadata:
             return metadata[b'x-hg-copy'], bin(metadata[b'x-hg-copyrev'])
         else:
             return False
     return orig(self, node)
 
 
 # Wrapping may also be applied by remotefilelog
 def filelogsize(orig, self, rev):
     if _islfs(self._revlog, rev=rev):
         # fast path: use lfs metadata to answer size
         rawtext = self._revlog.rawdata(rev)
         metadata = pointer.deserialize(rawtext)
         return int(metadata[b'size'])
     return orig(self, rev)
 
 
 @eh.wrapfunction(revlog, b'_verify_revision')
 def _verify_revision(orig, rl, skipflags, state, node):
     if _islfs(rl, node=node):
         rawtext = rl.rawdata(node)
         metadata = pointer.deserialize(rawtext)
 
         # Don't skip blobs that are stored locally, as local verification is
         # relatively cheap and there's no other way to verify the raw data in
         # the revlog.
         if rl.opener.lfslocalblobstore.has(metadata.oid()):
             skipflags &= ~revlog.REVIDX_EXTSTORED
         elif skipflags & revlog.REVIDX_EXTSTORED:
             # The wrapped method will set `skipread`, but there's enough local
             # info to check renames.
             state[b'safe_renamed'].add(node)
 
     orig(rl, skipflags, state, node)
 
 
 @eh.wrapfunction(context.basefilectx, b'cmp')
 def filectxcmp(orig, self, fctx):
     """returns True if text is different than fctx"""
     # some fctx (ex. hg-git) is not based on basefilectx and do not have islfs
     if self.islfs() and getattr(fctx, 'islfs', lambda: False)():
         # fast path: check LFS oid
         p1 = pointer.deserialize(self.rawdata())
         p2 = pointer.deserialize(fctx.rawdata())
         return p1.oid() != p2.oid()
     return orig(self, fctx)
 
 
 @eh.wrapfunction(context.basefilectx, b'isbinary')
 def filectxisbinary(orig, self):
     if self.islfs():
         # fast path: use lfs metadata to answer isbinary
         metadata = pointer.deserialize(self.rawdata())
         # if lfs metadata says nothing, assume it's binary by default
         return bool(int(metadata.get(b'x-is-binary', 1)))
     return orig(self)
 
 
 def filectxislfs(self):
     return _islfs(self.filelog()._revlog, self.filenode())
 
 
 @eh.wrapfunction(cmdutil, b'_updatecatformatter')
 def _updatecatformatter(orig, fm, ctx, matcher, path, decode):
     orig(fm, ctx, matcher, path, decode)
     fm.data(rawdata=ctx[path].rawdata())
 
 
 @eh.wrapfunction(scmutil, b'wrapconvertsink')
 def convertsink(orig, sink):
     sink = orig(sink)
     if sink.repotype == b'hg':
 
         class lfssink(sink.__class__):
             def putcommit(
                 self,
                 files,
                 copies,
                 parents,
                 commit,
                 source,
                 revmap,
                 full,
                 cleanp2,
             ):
                 pc = super(lfssink, self).putcommit
                 node = pc(
                     files,
                     copies,
                     parents,
                     commit,
                     source,
                     revmap,
                     full,
                     cleanp2,
                 )
 
                 if b'lfs' not in self.repo.requirements:
                     ctx = self.repo[node]
 
                     # The file list may contain removed files, so check for
                     # membership before assuming it is in the context.
                     if any(f in ctx and ctx[f].islfs() for f, n in files):
                         self.repo.requirements.add(b'lfs')
                         scmutil.writereporequirements(self.repo)
 
                 return node
 
         sink.__class__ = lfssink
 
     return sink
 
 
 # bundlerepo uses "vfsmod.readonlyvfs(othervfs)", we need to make sure lfs
 # options and blob stores are passed from othervfs to the new readonlyvfs.
 @eh.wrapfunction(vfsmod.readonlyvfs, b'__init__')
 def vfsinit(orig, self, othervfs):
     orig(self, othervfs)
     # copy lfs related options
     for k, v in othervfs.options.items():
         if k.startswith(b'lfs'):
             self.options[k] = v
     # also copy lfs blobstores. note: this can run before reposetup, so lfs
     # blobstore attributes are not always ready at this time.
     for name in [b'lfslocalblobstore', b'lfsremoteblobstore']:
         if util.safehasattr(othervfs, name):
             setattr(self, name, getattr(othervfs, name))
 
 
 def _prefetchfiles(repo, revmatches):
     """Ensure that required LFS blobs are present, fetching them as a group if
     needed."""
     if not util.safehasattr(repo.svfs, b'lfslocalblobstore'):
         return
 
     pointers = []
     oids = set()
     localstore = repo.svfs.lfslocalblobstore
 
     for rev, match in revmatches:
         ctx = repo[rev]
         for f in ctx.walk(match):
             p = pointerfromctx(ctx, f)
             if p and p.oid() not in oids and not localstore.has(p.oid()):
                 p.filename = f
                 pointers.append(p)
                 oids.add(p.oid())
 
     if pointers:
         # Recalculating the repo store here allows 'paths.default' that is set
         # on the repo by a clone command to be used for the update.
         blobstore.remote(repo).readbatch(pointers, localstore)
 
 
 def _canskipupload(repo):
     # Skip if this hasn't been passed to reposetup()
     if not util.safehasattr(repo.svfs, b'lfsremoteblobstore'):
         return True
 
     # if remotestore is a null store, upload is a no-op and can be skipped
     return isinstance(repo.svfs.lfsremoteblobstore, blobstore._nullremote)
 
 
 def candownload(repo):
     # Skip if this hasn't been passed to reposetup()
     if not util.safehasattr(repo.svfs, b'lfsremoteblobstore'):
         return False
 
     # if remotestore is a null store, downloads will lead to nothing
     return not isinstance(repo.svfs.lfsremoteblobstore, blobstore._nullremote)
 
 
 def uploadblobsfromrevs(repo, revs):
     """upload lfs blobs introduced by revs
 
     Note: also used by other extensions e. g. infinitepush. avoid renaming.
     """
     if _canskipupload(repo):
         return
     pointers = extractpointers(repo, revs)
     uploadblobs(repo, pointers)
 
 
 def prepush(pushop):
     """Prepush hook.
 
     Read through the revisions to push, looking for filelog entries that can be
     deserialized into metadata so that we can block the push on their upload to
     the remote blobstore.
     """
     return uploadblobsfromrevs(pushop.repo, pushop.outgoing.missing)
 
 
 @eh.wrapfunction(exchange, b'push')
 def push(orig, repo, remote, *args, **kwargs):
     """bail on push if the extension isn't enabled on remote when needed, and
     update the remote store based on the destination path."""
     if b'lfs' in repo.requirements:
         # If the remote peer is for a local repo, the requirement tests in the
         # base class method enforce lfs support.  Otherwise, some revisions in
         # this repo use lfs, and the remote repo needs the extension loaded.
         if not remote.local() and not remote.capable(b'lfs'):
             # This is a copy of the message in exchange.push() when requirements
             # are missing between local repos.
             m = _(b"required features are not supported in the destination: %s")
             raise error.Abort(
                 m % b'lfs', hint=_(b'enable the lfs extension on the server')
             )
 
         # Repositories where this extension is disabled won't have the field.
         # But if there's a requirement, then the extension must be loaded AND
         # there may be blobs to push.
         remotestore = repo.svfs.lfsremoteblobstore
         try:
             repo.svfs.lfsremoteblobstore = blobstore.remote(repo, remote.url())
             return orig(repo, remote, *args, **kwargs)
         finally:
             repo.svfs.lfsremoteblobstore = remotestore
     else:
         return orig(repo, remote, *args, **kwargs)
 
 
 # when writing a bundle via "hg bundle" command, upload related LFS blobs
 @eh.wrapfunction(bundle2, b'writenewbundle')
 def writenewbundle(
     orig, ui, repo, source, filename, bundletype, outgoing, *args, **kwargs
 ):
     """upload LFS blobs added by outgoing revisions on 'hg bundle'"""
     uploadblobsfromrevs(repo, outgoing.missing)
     return orig(
         ui, repo, source, filename, bundletype, outgoing, *args, **kwargs
     )
 
 
 def extractpointers(repo, revs):
     """return a list of lfs pointers added by given revs"""
     repo.ui.debug(b'lfs: computing set of blobs to upload\n')
     pointers = {}
 
     makeprogress = repo.ui.makeprogress
     with makeprogress(
         _(b'lfs search'), _(b'changesets'), len(revs)
     ) as progress:
         for r in revs:
             ctx = repo[r]
             for p in pointersfromctx(ctx).values():
                 pointers[p.oid()] = p
             progress.increment()
         return sorted(pointers.values(), key=lambda p: p.oid())
 
 
 def pointerfromctx(ctx, f, removed=False):
     """return a pointer for the named file from the given changectx, or None if
     the file isn't LFS.
 
     Optionally, the pointer for a file deleted from the context can be returned.
     Since no such pointer is actually stored, and to distinguish from a non LFS
     file, this pointer is represented by an empty dict.
     """
     _ctx = ctx
     if f not in ctx:
         if not removed:
             return None
         if f in ctx.p1():
             _ctx = ctx.p1()
         elif f in ctx.p2():
             _ctx = ctx.p2()
         else:
             return None
     fctx = _ctx[f]
     if not _islfs(fctx.filelog()._revlog, fctx.filenode()):
         return None
     try:
         p = pointer.deserialize(fctx.rawdata())
         if ctx == _ctx:
             return p
         return {}
     except pointer.InvalidPointer as ex:
         raise error.Abort(
             _(b'lfs: corrupted pointer (%s@%s): %s\n')
             % (f, short(_ctx.node()), ex)
         )
 
 
 def pointersfromctx(ctx, removed=False):
     """return a dict {path: pointer} for given single changectx.
 
     If ``removed`` == True and the LFS file was removed from ``ctx``, the value
     stored for the path is an empty dict.
     """
     result = {}
     m = ctx.repo().narrowmatch()
 
     # TODO: consider manifest.fastread() instead
     for f in ctx.files():
         if not m(f):
             continue
         p = pointerfromctx(ctx, f, removed=removed)
         if p is not None:
             result[f] = p
     return result
 
 
 def uploadblobs(repo, pointers):
     """upload given pointers from local blobstore"""
     if not pointers:
         return
 
     remoteblob = repo.svfs.lfsremoteblobstore
     remoteblob.writebatch(pointers, repo.svfs.lfslocalblobstore)
 
 
 @eh.wrapfunction(upgrade_engine, b'_finishdatamigration')
 def upgradefinishdatamigration(orig, ui, srcrepo, dstrepo, requirements):
     orig(ui, srcrepo, dstrepo, requirements)
 
     # Skip if this hasn't been passed to reposetup()
     if util.safehasattr(
         srcrepo.svfs, b'lfslocalblobstore'
     ) and util.safehasattr(dstrepo.svfs, b'lfslocalblobstore'):
         srclfsvfs = srcrepo.svfs.lfslocalblobstore.vfs
         dstlfsvfs = dstrepo.svfs.lfslocalblobstore.vfs
 
         for dirpath, dirs, files in srclfsvfs.walk():
             for oid in files:
                 ui.write(_(b'copying lfs blob %s\n') % oid)
                 lfutil.link(srclfsvfs.join(oid), dstlfsvfs.join(oid))
 
 
[e-mail](upgrade, b'preservedrequirements')
[e-mail](upgrade, b'supporteddestrequirements')
[e-mail](upgrade_actions, b'preservedrequirements')
[e-mail](upgrade_actions, b'supporteddestrequirements')
 def upgraderequirements(orig, repo):
     reqs = orig(repo)
     if b'lfs' in repo.requirements:
         reqs.add(b'lfs')
     return reqs

mercurial/upgrade.py

@@ -1,1012 +1,378 b''
 # 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 __future__ import absolute_import
 
 from .i18n import _
 from . import (
     error,
     hg,
     localrepo,
     pycompat,
-    requirements,
-    util,
 )
 
 from .upgrade_utils import (
+    actions as upgrade_actions,
     engine as upgrade_engine,
 )
 
-from .utils import compression
-
-# list of requirements that request a clone of all revlog if added/removed
-RECLONES_REQUIREMENTS = {
-    b'generaldelta',
-    requirements.SPARSEREVLOG_REQUIREMENT,
-}
-
-
-def requiredsourcerequirements(repo):
-    """Obtain requirements required to be present to upgrade a repo.
-
-    An upgrade will not be allowed if the repository doesn't have the
-    requirements returned by this function.
-    """
-    return {
-        # Introduced in Mercurial 0.9.2.
-        b'revlogv1',
-        # Introduced in Mercurial 0.9.2.
-        b'store',
-    }
-
-
-def blocksourcerequirements(repo):
-    """Obtain requirements that will prevent an upgrade from occurring.
-
-    An upgrade cannot be performed if the source repository contains a
-    requirements in the returned set.
-    """
-    return {
-        # The upgrade code does not yet support these experimental features.
-        # This is an artificial limitation.
-        requirements.TREEMANIFEST_REQUIREMENT,
-        # This was a precursor to generaldelta and was never enabled by default.
-        # It should (hopefully) not exist in the wild.
-        b'parentdelta',
-        # Upgrade should operate on the actual store, not the shared link.
-        requirements.SHARED_REQUIREMENT,
-    }
-
-
-def supportremovedrequirements(repo):
-    """Obtain requirements that can be removed during an upgrade.
-
-    If an upgrade were to create a repository that dropped a requirement,
-    the dropped requirement must appear in the returned set for the upgrade
-    to be allowed.
-    """
-    supported = {
-        requirements.SPARSEREVLOG_REQUIREMENT,
-        requirements.SIDEDATA_REQUIREMENT,
-        requirements.COPIESSDC_REQUIREMENT,
-        requirements.NODEMAP_REQUIREMENT,
-        requirements.SHARESAFE_REQUIREMENT,
-    }
-    for name in compression.compengines:
-        engine = compression.compengines[name]
-        if engine.available() and engine.revlogheader():
-            supported.add(b'exp-compression-%s' % name)
-            if engine.name() == b'zstd':
-                supported.add(b'revlog-compression-zstd')
-    return supported
-
-
-def supporteddestrequirements(repo):
-    """Obtain requirements that upgrade supports in the destination.
-
-    If the result of the upgrade would create requirements not in this set,
-    the upgrade is disallowed.
-
-    Extensions should monkeypatch this to add their custom requirements.
-    """
-    supported = {
-        b'dotencode',
-        b'fncache',
-        b'generaldelta',
-        b'revlogv1',
-        b'store',
-        requirements.SPARSEREVLOG_REQUIREMENT,
-        requirements.SIDEDATA_REQUIREMENT,
-        requirements.COPIESSDC_REQUIREMENT,
-        requirements.NODEMAP_REQUIREMENT,
-        requirements.SHARESAFE_REQUIREMENT,
-    }
-    for name in compression.compengines:
-        engine = compression.compengines[name]
-        if engine.available() and engine.revlogheader():
-            supported.add(b'exp-compression-%s' % name)
-            if engine.name() == b'zstd':
-                supported.add(b'revlog-compression-zstd')
-    return supported
-
-
-def allowednewrequirements(repo):
-    """Obtain requirements that can be added to a repository during upgrade.
-
-    This is used to disallow proposed requirements from being added when
-    they weren't present before.
-
-    We use a list of allowed requirement additions instead of a list of known
-    bad additions because the whitelist approach is safer and will prevent
-    future, unknown requirements from accidentally being added.
-    """
-    supported = {
-        b'dotencode',
-        b'fncache',
-        b'generaldelta',
-        requirements.SPARSEREVLOG_REQUIREMENT,
-        requirements.SIDEDATA_REQUIREMENT,
-        requirements.COPIESSDC_REQUIREMENT,
-        requirements.NODEMAP_REQUIREMENT,
-        requirements.SHARESAFE_REQUIREMENT,
-    }
-    for name in compression.compengines:
-        engine = compression.compengines[name]
-        if engine.available() and engine.revlogheader():
-            supported.add(b'exp-compression-%s' % name)
-            if engine.name() == b'zstd':
-                supported.add(b'revlog-compression-zstd')
-    return supported
-
-
-def preservedrequirements(repo):
-    return set()
-
-
-DEFICIENCY = b'deficiency'
-OPTIMISATION = b'optimization'
-
-
-class improvement(object):
-    """Represents an improvement that can be made as part of an upgrade.
-
-    The following attributes are defined on each instance:
-
-    name
-       Machine-readable string uniquely identifying this improvement. It
-       will be mapped to an action later in the upgrade process.
-
-    type
-       Either ``DEFICIENCY`` or ``OPTIMISATION``. A deficiency is an obvious
-       problem. An optimization is an action (sometimes optional) that
-       can be taken to further improve the state of the repository.
-
-    description
-       Message intended for humans explaining the improvement in more detail,
-       including the implications of it. For ``DEFICIENCY`` types, should be
-       worded in the present tense. For ``OPTIMISATION`` types, should be
-       worded in the future tense.
-
-    upgrademessage
-       Message intended for humans explaining what an upgrade addressing this
-       issue will do. Should be worded in the future tense.
-    """
-
-    def __init__(self, name, type, description, upgrademessage):
-        self.name = name
-        self.type = type
-        self.description = description
-        self.upgrademessage = upgrademessage
-
-    def __eq__(self, other):
-        if not isinstance(other, improvement):
-            # This is what python tell use to do
-            return NotImplemented
-        return self.name == other.name
-
-    def __ne__(self, other):
-        return not (self == other)
-
-    def __hash__(self):
-        return hash(self.name)
-
-
-allformatvariant = []
-
-
-def registerformatvariant(cls):
-    allformatvariant.append(cls)
-    return cls
-
-
-class formatvariant(improvement):
-    """an improvement subclass dedicated to repository format"""
-
-    type = DEFICIENCY
-    ### The following attributes should be defined for each class:
-
-    # 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 ``DEFICIENCY`` 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
-
-    def __init__(self):
-        raise NotImplementedError()
-
-    @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 = b'fncache'
-
-    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 dotencode(requirementformatvariant):
-    name = b'dotencode'
-
-    _requirement = b'dotencode'
-
-    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 = b'generaldelta'
-
-    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 sharedsafe(requirementformatvariant):
-    name = b'exp-sharesafe'
-    _requirement = requirements.SHARESAFE_REQUIREMENT
-
-    default = False
-
-    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.'
-    )
-
-
-@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 sidedata(requirementformatvariant):
-    name = b'sidedata'
-
-    _requirement = requirements.SIDEDATA_REQUIREMENT
-
-    default = False
-
-    description = _(
-        b'Allows storage of extra data alongside a revision, '
-        b'unlocking various caching options.'
-    )
-
-    upgrademessage = _(b'Allows storage of extra data alongside a revision.')
-
-
-@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 ' b'copy tracing.'
-    )
-
-
-@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.changelog
-        chainbase = cl.chainbase
-        return all(rev == chainbase(rev) for rev in cl)
-
-    @staticmethod
-    def fromconfig(repo):
-        return True
-
-
-@registerformatvariant
-class compressionengine(formatvariant):
-    name = b'compression'
-    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:
-                return comp
-
-        # no valide compression found lets display it all for clarity
-        return b','.join(compengines)
-
-
-@registerformatvariant
-class compressionlevel(formatvariant):
-    name = b'compression-level'
-    default = b'default'
-
-    description = _(b'compression level')
-
-    upgrademessage = _(b'revlog content will be recompressed')
-
-    @classmethod
-    def fromrepo(cls, repo):
-        comp = compressionengine.fromrepo(repo)
-        level = None
-        if comp == b'zlib':
-            level = repo.ui.configint(b'storage', b'revlog.zlib.level')
-        elif comp == b'zstd':
-            level = repo.ui.configint(b'storage', b'revlog.zstd.level')
-        if level is None:
-            return b'default'
-        return bytes(level)
-
-    @classmethod
-    def fromconfig(cls, repo):
-        comp = compressionengine.fromconfig(repo)
-        level = None
-        if comp == b'zlib':
-            level = repo.ui.configint(b'storage', b'revlog.zlib.level')
-        elif comp == b'zstd':
-            level = repo.ui.configint(b'storage', b'revlog.zstd.level')
-        if level is None:
-            return b'default'
-        return bytes(level)
-
-
-def finddeficiencies(repo):
-    """returns a list of deficiencies that the repo suffer from"""
-    deficiencies = []
-
-    # We could detect lack of revlogv1 and store here, but they were added
-    # in 0.9.2 and we don't support upgrading repos without these
-    # requirements, so let's not bother.
-
-    for fv in allformatvariant:
-        if not fv.fromrepo(repo):
-            deficiencies.append(fv)
-
-    return deficiencies
-
+allformatvariant = upgrade_actions.allformatvariant
 
 # search without '-' to support older form on newer client.
 #
 # We don't enforce backward compatibility for debug command so this
 # might eventually be dropped. However, having to use two different
 # forms in script when comparing result is anoying enough to add
 # backward compatibility for a while.
 legacy_opts_map = {
     b'redeltaparent': b're-delta-parent',
     b'redeltamultibase': b're-delta-multibase',
     b'redeltaall': b're-delta-all',
     b'redeltafulladd': b're-delta-fulladd',
 }
 
-ALL_OPTIMISATIONS = []
-
-
-def register_optimization(obj):
-    ALL_OPTIMISATIONS.append(obj)
-    return obj
-
-
-register_optimization(
-    improvement(
-        name=b're-delta-parent',
-        type=OPTIMISATION,
-        description=_(
-            b'deltas within internal storage will be recalculated to '
-            b'choose an optimal base revision where this was not '
-            b'already done; the size of the repository may shrink and '
-            b'various operations may become faster; the first time '
-            b'this optimization is performed could slow down upgrade '
-            b'execution considerably; subsequent invocations should '
-            b'not run noticeably slower'
-        ),
-        upgrademessage=_(
-            b'deltas within internal storage will choose a new '
-            b'base revision if needed'
-        ),
-    )
-)
-
-register_optimization(
-    improvement(
-        name=b're-delta-multibase',
-        type=OPTIMISATION,
-        description=_(
-            b'deltas within internal storage will be recalculated '
-            b'against multiple base revision and the smallest '
-            b'difference will be used; the size of the repository may '
-            b'shrink significantly when there are many merges; this '
-            b'optimization will slow down execution in proportion to '
-            b'the number of merges in the repository and the amount '
-            b'of files in the repository; this slow down should not '
-            b'be significant unless there are tens of thousands of '
-            b'files and thousands of merges'
-        ),
-        upgrademessage=_(
-            b'deltas within internal storage will choose an '
-            b'optimal delta by computing deltas against multiple '
-            b'parents; may slow down execution time '
-            b'significantly'
-        ),
-    )
-)
-
-register_optimization(
-    improvement(
-        name=b're-delta-all',
-        type=OPTIMISATION,
-        description=_(
-            b'deltas within internal storage will always be '
-            b'recalculated without reusing prior deltas; this will '
-            b'likely make execution run several times slower; this '
-            b'optimization is typically not needed'
-        ),
-        upgrademessage=_(
-            b'deltas within internal storage will be fully '
-            b'recomputed; this will likely drastically slow down '
-            b'execution time'
-        ),
-    )
-)
-
-register_optimization(
-    improvement(
-        name=b're-delta-fulladd',
-        type=OPTIMISATION,
-        description=_(
-            b'every revision will be re-added as if it was new '
-            b'content. It will go through the full storage '
-            b'mechanism giving extensions a chance to process it '
-            b'(eg. lfs). This is similar to "re-delta-all" but even '
-            b'slower since more logic is involved.'
-        ),
-        upgrademessage=_(
-            b'each revision will be added as new content to the '
-            b'internal storage; this will likely drastically slow '
-            b'down execution time, but some extensions might need '
-            b'it'
-        ),
-    )
-)
-
-
-def findoptimizations(repo):
-    """Determine optimisation that could be used during upgrade"""
-    # These are unconditionally added. There is logic later that figures out
-    # which ones to apply.
-    return list(ALL_OPTIMISATIONS)
-
-
-def determineactions(repo, deficiencies, sourcereqs, destreqs):
-    """Determine upgrade actions that will be performed.
-
-    Given a list of improvements as returned by ``finddeficiencies`` and
-    ``findoptimizations``, determine the list of upgrade actions that
-    will be performed.
-
-    The role of this function is to filter improvements if needed, apply
-    recommended optimizations from the improvements list that make sense,
-    etc.
-
-    Returns a list of action names.
-    """
-    newactions = []
-
-    for d in deficiencies:
-        name = d._requirement
-
-        # If the action is a requirement that doesn't show up in the
-        # destination requirements, prune the action.
-        if name is not None and name not in destreqs:
-            continue
-
-        newactions.append(d)
-
-    # FUTURE consider adding some optimizations here for certain transitions.
-    # e.g. adding generaldelta could schedule parent redeltas.
-
-    return newactions
-
 
 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 = []
     optimize = {legacy_opts_map.get(o, o) for o in optimize}
     repo = repo.unfiltered()
 
     revlogs = set(upgrade_engine.UPGRADE_ALL_REVLOGS)
     specentries = (
         (upgrade_engine.UPGRADE_CHANGELOG, changelog),
         (upgrade_engine.UPGRADE_MANIFEST, manifest),
         (upgrade_engine.UPGRADE_FILELOGS, filelogs),
     )
     specified = [(y, x) for (y, x) in specentries if x is not None]
     if specified:
         # we have some limitation on revlogs to be recloned
         if any(x for y, x in specified):
             revlogs = set()
             for upgrade, enabled in specified:
                 if enabled:
                     revlogs.add(upgrade)
         else:
             # none are enabled
             for upgrade, __ in specified:
                 revlogs.discard(upgrade)
 
     # Ensure the repository can be upgraded.
-    missingreqs = requiredsourcerequirements(repo) - repo.requirements
+    missingreqs = (
+        upgrade_actions.requiredsourcerequirements(repo) - repo.requirements
+    )
     if missingreqs:
         raise error.Abort(
             _(b'cannot upgrade repository; requirement missing: %s')
             % _(b', ').join(sorted(missingreqs))
         )
 
-    blockedreqs = blocksourcerequirements(repo) & repo.requirements
+    blockedreqs = (
+        upgrade_actions.blocksourcerequirements(repo) & repo.requirements
+    )
     if blockedreqs:
         raise error.Abort(
             _(
                 b'cannot upgrade repository; unsupported source '
                 b'requirement: %s'
             )
             % _(b', ').join(sorted(blockedreqs))
         )
 
     # FUTURE there is potentially a need to control the wanted requirements via
     # command arguments or via an extension hook point.
     newreqs = localrepo.newreporequirements(
         repo.ui, localrepo.defaultcreateopts(repo.ui)
     )
-    newreqs.update(preservedrequirements(repo))
+    newreqs.update(upgrade_actions.preservedrequirements(repo))
 
     noremovereqs = (
-        repo.requirements - newreqs - supportremovedrequirements(repo)
+        repo.requirements
+        - newreqs
+        - upgrade_actions.supportremovedrequirements(repo)
     )
     if noremovereqs:
         raise error.Abort(
             _(
                 b'cannot upgrade repository; requirement would be '
                 b'removed: %s'
             )
             % _(b', ').join(sorted(noremovereqs))
         )
 
-    noaddreqs = newreqs - repo.requirements - allowednewrequirements(repo)
+    noaddreqs = (
+        newreqs
+        - repo.requirements
+        - upgrade_actions.allowednewrequirements(repo)
+    )
     if noaddreqs:
         raise error.Abort(
             _(
                 b'cannot upgrade repository; do not support adding '
                 b'requirement: %s'
             )
             % _(b', ').join(sorted(noaddreqs))
         )
 
-    unsupportedreqs = newreqs - supporteddestrequirements(repo)
+    unsupportedreqs = newreqs - upgrade_actions.supporteddestrequirements(repo)
     if unsupportedreqs:
         raise error.Abort(
             _(
                 b'cannot upgrade repository; do not support '
                 b'destination requirement: %s'
             )
             % _(b', ').join(sorted(unsupportedreqs))
         )
 
     # Find and validate all improvements that can be made.
-    alloptimizations = findoptimizations(repo)
+    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'),
         )
 
-    deficiencies = finddeficiencies(repo)
-    actions = determineactions(repo, deficiencies, repo.requirements, newreqs)
+    deficiencies = upgrade_actions.finddeficiencies(repo)
+    actions = upgrade_actions.determineactions(
+        repo, deficiencies, repo.requirements, newreqs
+    )
     actions.extend(
         o
         for o in sorted(optimizations)
         # determineactions could have added optimisation
         if o not in actions
     )
 
     removedreqs = repo.requirements - newreqs
     addedreqs = newreqs - repo.requirements
 
     if revlogs != upgrade_engine.UPGRADE_ALL_REVLOGS:
-        incompatible = RECLONES_REQUIREMENTS & (removedreqs | addedreqs)
+        incompatible = upgrade_actions.RECLONES_REQUIREMENTS & (
+            removedreqs | addedreqs
+        )
         if incompatible:
             msg = _(
                 b'ignoring revlogs selection flags, format requirements '
                 b'change: %s\n'
             )
             ui.warn(msg % b', '.join(sorted(incompatible)))
             revlogs = upgrade_engine.UPGRADE_ALL_REVLOGS
 
     def write_labeled(l, label):
         first = True
         for r in sorted(l):
             if not first:
                 ui.write(b', ')
             ui.write(r, label=label)
             first = False
 
     def printrequirements():
         ui.write(_(b'requirements\n'))
         ui.write(_(b'   preserved: '))
         write_labeled(
             newreqs & repo.requirements, "upgrade-repo.requirement.preserved"
         )
         ui.write((b'\n'))
         removed = repo.requirements - newreqs
         if repo.requirements - newreqs:
             ui.write(_(b'   removed: '))
             write_labeled(removed, "upgrade-repo.requirement.removed")
             ui.write((b'\n'))
         added = newreqs - repo.requirements
         if added:
             ui.write(_(b'   added: '))
             write_labeled(added, "upgrade-repo.requirement.added")
             ui.write((b'\n'))
         ui.write(b'\n')
 
     def printoptimisations():
-        optimisations = [a for a in actions if a.type == OPTIMISATION]
+        optimisations = [
+            a for a in actions if a.type == upgrade_actions.OPTIMISATION
+        ]
         optimisations.sort(key=lambda a: a.name)
         if optimisations:
             ui.write(_(b'optimisations: '))
             write_labeled(
                 [a.name for a in optimisations],
                 "upgrade-repo.optimisation.performed",
             )
             ui.write(b'\n\n')
 
     def printupgradeactions():
         for a in actions:
             ui.status(b'%s\n   %s\n\n' % (a.name, a.upgrademessage))
 
     def print_affected_revlogs():
         if not revlogs:
             ui.write((b'no revlogs to process\n'))
         else:
             ui.write((b'processed revlogs:\n'))
             for r in sorted(revlogs):
                 ui.write((b'  - %s\n' % r))
         ui.write((b'\n'))
 
     if not run:
         fromconfig = []
         onlydefault = []
 
         for d in deficiencies:
             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 feature deficiencies found in existing '
                     b'repository)\n'
                 )
             )
 
         ui.status(
             _(
                 b'performing an upgrade with "--run" will make the following '
                 b'changes:\n\n'
             )
         )
 
         printrequirements()
         printoptimisations()
         printupgradeactions()
         print_affected_revlogs()
 
         unusedoptimize = [i for i in alloptimizations if i not in actions]
 
         if unusedoptimize:
             ui.status(
                 _(
                     b'additional optimizations are available by specifying '
                     b'"--optimize <name>":\n\n'
                 )
             )
             for i in unusedoptimize:
                 ui.status(_(b'%s\n   %s\n\n') % (i.name, i.description))
         return
 
     # Else we're in the run=true case.
     ui.write(_(b'upgrade will perform the following actions:\n\n'))
     printrequirements()
     printoptimisations()
     printupgradeactions()
     print_affected_revlogs()
 
     upgradeactions = [a.name for a in actions]
 
     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 migrated '
                     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, newreqs, upgradeactions, revlogs=revlogs
                 )
             if not (backup or backuppath is None):
                 ui.status(
                     _(b'removing old repository content%s\n') % backuppath
                 )
                 repo.vfs.rmtree(backuppath, forcibly=True)
                 backuppath = None
 
         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'
                     )
                 )
 
-            if sharedsafe.name in addedreqs:
+            if upgrade_actions.sharesafe.name in addedreqs:
                 ui.warn(
                     _(
                         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.\n'
                     )
                 )
-            if sharedsafe.name in removedreqs:
+            if upgrade_actions.sharesafe.name in removedreqs:
                 ui.warn(
                     _(
                         b'repository downgraded to not use share safe mode, '
                         b'existing shares will not work and needs to'
                         b' be reshared.\n'
                     )
                 )

mercurial/upgrade_utils/actions.py

@@ -1,1012 +1,666 b''
 # 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 __future__ import absolute_import
 
-from .i18n import _
-from . import (
-    error,
-    hg,
+from ..i18n import _
+from .. import (
     localrepo,
-    pycompat,
     requirements,
     util,
 )
 
-from .upgrade_utils import (
-    engine as upgrade_engine,
-)
-
-from .utils import compression
+from ..utils import compression
 
 # list of requirements that request a clone of all revlog if added/removed
 RECLONES_REQUIREMENTS = {
     b'generaldelta',
     requirements.SPARSEREVLOG_REQUIREMENT,
 }
 
 
 def requiredsourcerequirements(repo):
     """Obtain requirements required to be present to upgrade a repo.
 
     An upgrade will not be allowed if the repository doesn't have the
     requirements returned by this function.
     """
     return {
         # Introduced in Mercurial 0.9.2.
         b'revlogv1',
         # Introduced in Mercurial 0.9.2.
         b'store',
     }
 
 
 def blocksourcerequirements(repo):
     """Obtain requirements that will prevent an upgrade from occurring.
 
     An upgrade cannot be performed if the source repository contains a
     requirements in the returned set.
     """
     return {
         # The upgrade code does not yet support these experimental features.
         # This is an artificial limitation.
         requirements.TREEMANIFEST_REQUIREMENT,
         # This was a precursor to generaldelta and was never enabled by default.
         # It should (hopefully) not exist in the wild.
         b'parentdelta',
         # Upgrade should operate on the actual store, not the shared link.
         requirements.SHARED_REQUIREMENT,
     }
 
 
 def supportremovedrequirements(repo):
     """Obtain requirements that can be removed during an upgrade.
 
     If an upgrade were to create a repository that dropped a requirement,
     the dropped requirement must appear in the returned set for the upgrade
     to be allowed.
     """
     supported = {
         requirements.SPARSEREVLOG_REQUIREMENT,
         requirements.SIDEDATA_REQUIREMENT,
         requirements.COPIESSDC_REQUIREMENT,
         requirements.NODEMAP_REQUIREMENT,
         requirements.SHARESAFE_REQUIREMENT,
     }
     for name in compression.compengines:
         engine = compression.compengines[name]
         if engine.available() and engine.revlogheader():
             supported.add(b'exp-compression-%s' % name)
             if engine.name() == b'zstd':
                 supported.add(b'revlog-compression-zstd')
     return supported
 
 
 def supporteddestrequirements(repo):
     """Obtain requirements that upgrade supports in the destination.
 
     If the result of the upgrade would create requirements not in this set,
     the upgrade is disallowed.
 
     Extensions should monkeypatch this to add their custom requirements.
     """
     supported = {
         b'dotencode',
         b'fncache',
         b'generaldelta',
         b'revlogv1',
         b'store',
         requirements.SPARSEREVLOG_REQUIREMENT,
         requirements.SIDEDATA_REQUIREMENT,
         requirements.COPIESSDC_REQUIREMENT,
         requirements.NODEMAP_REQUIREMENT,
         requirements.SHARESAFE_REQUIREMENT,
     }
     for name in compression.compengines:
         engine = compression.compengines[name]
         if engine.available() and engine.revlogheader():
             supported.add(b'exp-compression-%s' % name)
             if engine.name() == b'zstd':
                 supported.add(b'revlog-compression-zstd')
     return supported
 
 
 def allowednewrequirements(repo):
     """Obtain requirements that can be added to a repository during upgrade.
 
     This is used to disallow proposed requirements from being added when
     they weren't present before.
 
     We use a list of allowed requirement additions instead of a list of known
     bad additions because the whitelist approach is safer and will prevent
     future, unknown requirements from accidentally being added.
     """
     supported = {
         b'dotencode',
         b'fncache',
         b'generaldelta',
         requirements.SPARSEREVLOG_REQUIREMENT,
         requirements.SIDEDATA_REQUIREMENT,
         requirements.COPIESSDC_REQUIREMENT,
         requirements.NODEMAP_REQUIREMENT,
         requirements.SHARESAFE_REQUIREMENT,
     }
     for name in compression.compengines:
         engine = compression.compengines[name]
         if engine.available() and engine.revlogheader():
             supported.add(b'exp-compression-%s' % name)
             if engine.name() == b'zstd':
                 supported.add(b'revlog-compression-zstd')
     return supported
 
 
 def preservedrequirements(repo):
     return set()
 
 
 DEFICIENCY = b'deficiency'
 OPTIMISATION = b'optimization'
 
 
 class improvement(object):
     """Represents an improvement that can be made as part of an upgrade.
 
     The following attributes are defined on each instance:
 
     name
        Machine-readable string uniquely identifying this improvement. It
        will be mapped to an action later in the upgrade process.
 
     type
        Either ``DEFICIENCY`` or ``OPTIMISATION``. A deficiency is an obvious
        problem. An optimization is an action (sometimes optional) that
        can be taken to further improve the state of the repository.
 
     description
        Message intended for humans explaining the improvement in more detail,
        including the implications of it. For ``DEFICIENCY`` types, should be
        worded in the present tense. For ``OPTIMISATION`` types, should be
        worded in the future tense.
 
     upgrademessage
        Message intended for humans explaining what an upgrade addressing this
        issue will do. Should be worded in the future tense.
     """
 
     def __init__(self, name, type, description, upgrademessage):
         self.name = name
         self.type = type
         self.description = description
         self.upgrademessage = upgrademessage
 
     def __eq__(self, other):
         if not isinstance(other, improvement):
             # This is what python tell use to do
             return NotImplemented
         return self.name == other.name
 
     def __ne__(self, other):
         return not (self == other)
 
     def __hash__(self):
         return hash(self.name)
 
 
 allformatvariant = []
 
 
 def registerformatvariant(cls):
     allformatvariant.append(cls)
     return cls
 
 
 class formatvariant(improvement):
     """an improvement subclass dedicated to repository format"""
 
     type = DEFICIENCY
     ### The following attributes should be defined for each class:
 
     # 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 ``DEFICIENCY`` 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
 
     def __init__(self):
         raise NotImplementedError()
 
     @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 = b'fncache'
 
     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 dotencode(requirementformatvariant):
     name = b'dotencode'
 
     _requirement = b'dotencode'
 
     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 = b'generaldelta'
 
     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 sharedsafe(requirementformatvariant):
+class sharesafe(requirementformatvariant):
     name = b'exp-sharesafe'
     _requirement = requirements.SHARESAFE_REQUIREMENT
 
     default = False
 
     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.'
     )
 
 
 @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 sidedata(requirementformatvariant):
     name = b'sidedata'
 
     _requirement = requirements.SIDEDATA_REQUIREMENT
 
     default = False
 
     description = _(
         b'Allows storage of extra data alongside a revision, '
         b'unlocking various caching options.'
     )
 
     upgrademessage = _(b'Allows storage of extra data alongside a revision.')
 
 
 @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 ' b'copy tracing.'
     )
 
 
 @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.changelog
         chainbase = cl.chainbase
         return all(rev == chainbase(rev) for rev in cl)
 
     @staticmethod
     def fromconfig(repo):
         return True
 
 
 @registerformatvariant
 class compressionengine(formatvariant):
     name = b'compression'
     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:
                 return comp
 
         # no valide compression found lets display it all for clarity
         return b','.join(compengines)
 
 
 @registerformatvariant
 class compressionlevel(formatvariant):
     name = b'compression-level'
     default = b'default'
 
     description = _(b'compression level')
 
     upgrademessage = _(b'revlog content will be recompressed')
 
     @classmethod
     def fromrepo(cls, repo):
         comp = compressionengine.fromrepo(repo)
         level = None
         if comp == b'zlib':
             level = repo.ui.configint(b'storage', b'revlog.zlib.level')
         elif comp == b'zstd':
             level = repo.ui.configint(b'storage', b'revlog.zstd.level')
         if level is None:
             return b'default'
         return bytes(level)
 
     @classmethod
     def fromconfig(cls, repo):
         comp = compressionengine.fromconfig(repo)
         level = None
         if comp == b'zlib':
             level = repo.ui.configint(b'storage', b'revlog.zlib.level')
         elif comp == b'zstd':
             level = repo.ui.configint(b'storage', b'revlog.zstd.level')
         if level is None:
             return b'default'
         return bytes(level)
 
 
 def finddeficiencies(repo):
     """returns a list of deficiencies that the repo suffer from"""
     deficiencies = []
 
     # We could detect lack of revlogv1 and store here, but they were added
     # in 0.9.2 and we don't support upgrading repos without these
     # requirements, so let's not bother.
 
     for fv in allformatvariant:
         if not fv.fromrepo(repo):
             deficiencies.append(fv)
 
     return deficiencies
 
 
-# search without '-' to support older form on newer client.
-#
-# We don't enforce backward compatibility for debug command so this
-# might eventually be dropped. However, having to use two different
-# forms in script when comparing result is anoying enough to add
-# backward compatibility for a while.
-legacy_opts_map = {
-    b'redeltaparent': b're-delta-parent',
-    b'redeltamultibase': b're-delta-multibase',
-    b'redeltaall': b're-delta-all',
-    b'redeltafulladd': b're-delta-fulladd',
-}
-
 ALL_OPTIMISATIONS = []
 
 
 def register_optimization(obj):
     ALL_OPTIMISATIONS.append(obj)
     return obj
 
 
 register_optimization(
     improvement(
         name=b're-delta-parent',
         type=OPTIMISATION,
         description=_(
             b'deltas within internal storage will be recalculated to '
             b'choose an optimal base revision where this was not '
             b'already done; the size of the repository may shrink and '
             b'various operations may become faster; the first time '
             b'this optimization is performed could slow down upgrade '
             b'execution considerably; subsequent invocations should '
             b'not run noticeably slower'
         ),
         upgrademessage=_(
             b'deltas within internal storage will choose a new '
             b'base revision if needed'
         ),
     )
 )
 
 register_optimization(
     improvement(
         name=b're-delta-multibase',
         type=OPTIMISATION,
         description=_(
             b'deltas within internal storage will be recalculated '
             b'against multiple base revision and the smallest '
             b'difference will be used; the size of the repository may '
             b'shrink significantly when there are many merges; this '
             b'optimization will slow down execution in proportion to '
             b'the number of merges in the repository and the amount '
             b'of files in the repository; this slow down should not '
             b'be significant unless there are tens of thousands of '
             b'files and thousands of merges'
         ),
         upgrademessage=_(
             b'deltas within internal storage will choose an '
             b'optimal delta by computing deltas against multiple '
             b'parents; may slow down execution time '
             b'significantly'
         ),
     )
 )
 
 register_optimization(
     improvement(
         name=b're-delta-all',
         type=OPTIMISATION,
         description=_(
             b'deltas within internal storage will always be '
             b'recalculated without reusing prior deltas; this will '
             b'likely make execution run several times slower; this '
             b'optimization is typically not needed'
         ),
         upgrademessage=_(
             b'deltas within internal storage will be fully '
             b'recomputed; this will likely drastically slow down '
             b'execution time'
         ),
     )
 )
 
 register_optimization(
     improvement(
         name=b're-delta-fulladd',
         type=OPTIMISATION,
         description=_(
             b'every revision will be re-added as if it was new '
             b'content. It will go through the full storage '
             b'mechanism giving extensions a chance to process it '
             b'(eg. lfs). This is similar to "re-delta-all" but even '
             b'slower since more logic is involved.'
         ),
         upgrademessage=_(
             b'each revision will be added as new content to the '
             b'internal storage; this will likely drastically slow '
             b'down execution time, but some extensions might need '
             b'it'
         ),
     )
 )
 
 
 def findoptimizations(repo):
     """Determine optimisation that could be used during upgrade"""
     # These are unconditionally added. There is logic later that figures out
     # which ones to apply.
     return list(ALL_OPTIMISATIONS)
 
 
 def determineactions(repo, deficiencies, sourcereqs, destreqs):
     """Determine upgrade actions that will be performed.
 
     Given a list of improvements as returned by ``finddeficiencies`` and
     ``findoptimizations``, determine the list of upgrade actions that
     will be performed.
 
     The role of this function is to filter improvements if needed, apply
     recommended optimizations from the improvements list that make sense,
     etc.
 
     Returns a list of action names.
     """
     newactions = []
 
     for d in deficiencies:
         name = d._requirement
 
         # If the action is a requirement that doesn't show up in the
         # destination requirements, prune the action.
         if name is not None and name not in destreqs:
             continue
 
         newactions.append(d)
 
     # FUTURE consider adding some optimizations here for certain transitions.
     # e.g. adding generaldelta could schedule parent redeltas.
 
     return newactions
-
-
-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 = []
-    optimize = {legacy_opts_map.get(o, o) for o in optimize}
-    repo = repo.unfiltered()
-
-    revlogs = set(upgrade_engine.UPGRADE_ALL_REVLOGS)
-    specentries = (
-        (upgrade_engine.UPGRADE_CHANGELOG, changelog),
-        (upgrade_engine.UPGRADE_MANIFEST, manifest),
-        (upgrade_engine.UPGRADE_FILELOGS, filelogs),
-    )
-    specified = [(y, x) for (y, x) in specentries if x is not None]
-    if specified:
-        # we have some limitation on revlogs to be recloned
-        if any(x for y, x in specified):
-            revlogs = set()
-            for upgrade, enabled in specified:
-                if enabled:
-                    revlogs.add(upgrade)
-        else:
-            # none are enabled
-            for upgrade, __ in specified:
-                revlogs.discard(upgrade)
-
-    # Ensure the repository can be upgraded.
-    missingreqs = requiredsourcerequirements(repo) - repo.requirements
-    if missingreqs:
-        raise error.Abort(
-            _(b'cannot upgrade repository; requirement missing: %s')
-            % _(b', ').join(sorted(missingreqs))
-        )
-
-    blockedreqs = blocksourcerequirements(repo) & repo.requirements
-    if blockedreqs:
-        raise error.Abort(
-            _(
-                b'cannot upgrade repository; unsupported source '
-                b'requirement: %s'
-            )
-            % _(b', ').join(sorted(blockedreqs))
-        )
-
-    # FUTURE there is potentially a need to control the wanted requirements via
-    # command arguments or via an extension hook point.
-    newreqs = localrepo.newreporequirements(
-        repo.ui, localrepo.defaultcreateopts(repo.ui)
-    )
-    newreqs.update(preservedrequirements(repo))
-
-    noremovereqs = (
-        repo.requirements - newreqs - supportremovedrequirements(repo)
-    )
-    if noremovereqs:
-        raise error.Abort(
-            _(
-                b'cannot upgrade repository; requirement would be '
-                b'removed: %s'
-            )
-            % _(b', ').join(sorted(noremovereqs))
-        )
-
-    noaddreqs = newreqs - repo.requirements - allowednewrequirements(repo)
-    if noaddreqs:
-        raise error.Abort(
-            _(
-                b'cannot upgrade repository; do not support adding '
-                b'requirement: %s'
-            )
-            % _(b', ').join(sorted(noaddreqs))
-        )
-
-    unsupportedreqs = newreqs - supporteddestrequirements(repo)
-    if unsupportedreqs:
-        raise error.Abort(
-            _(
-                b'cannot upgrade repository; do not support '
-                b'destination requirement: %s'
-            )
-            % _(b', ').join(sorted(unsupportedreqs))
-        )
-
-    # Find and validate all improvements that can be made.
-    alloptimizations = 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'),
-        )
-
-    deficiencies = finddeficiencies(repo)
-    actions = determineactions(repo, deficiencies, repo.requirements, newreqs)
-    actions.extend(
-        o
-        for o in sorted(optimizations)
-        # determineactions could have added optimisation
-        if o not in actions
-    )
-
-    removedreqs = repo.requirements - newreqs
-    addedreqs = newreqs - repo.requirements
-
-    if revlogs != upgrade_engine.UPGRADE_ALL_REVLOGS:
-        incompatible = RECLONES_REQUIREMENTS & (removedreqs | addedreqs)
-        if incompatible:
-            msg = _(
-                b'ignoring revlogs selection flags, format requirements '
-                b'change: %s\n'
-            )
-            ui.warn(msg % b', '.join(sorted(incompatible)))
-            revlogs = upgrade_engine.UPGRADE_ALL_REVLOGS
-
-    def write_labeled(l, label):
-        first = True
-        for r in sorted(l):
-            if not first:
-                ui.write(b', ')
-            ui.write(r, label=label)
-            first = False
-
-    def printrequirements():
-        ui.write(_(b'requirements\n'))
-        ui.write(_(b'   preserved: '))
-        write_labeled(
-            newreqs & repo.requirements, "upgrade-repo.requirement.preserved"
-        )
-        ui.write((b'\n'))
-        removed = repo.requirements - newreqs
-        if repo.requirements - newreqs:
-            ui.write(_(b'   removed: '))
-            write_labeled(removed, "upgrade-repo.requirement.removed")
-            ui.write((b'\n'))
-        added = newreqs - repo.requirements
-        if added:
-            ui.write(_(b'   added: '))
-            write_labeled(added, "upgrade-repo.requirement.added")
-            ui.write((b'\n'))
-        ui.write(b'\n')
-
-    def printoptimisations():
-        optimisations = [a for a in actions if a.type == OPTIMISATION]
-        optimisations.sort(key=lambda a: a.name)
-        if optimisations:
-            ui.write(_(b'optimisations: '))
-            write_labeled(
-                [a.name for a in optimisations],
-                "upgrade-repo.optimisation.performed",
-            )
-            ui.write(b'\n\n')
-
-    def printupgradeactions():
-        for a in actions:
-            ui.status(b'%s\n   %s\n\n' % (a.name, a.upgrademessage))
-
-    def print_affected_revlogs():
-        if not revlogs:
-            ui.write((b'no revlogs to process\n'))
-        else:
-            ui.write((b'processed revlogs:\n'))
-            for r in sorted(revlogs):
-                ui.write((b'  - %s\n' % r))
-        ui.write((b'\n'))
-
-    if not run:
-        fromconfig = []
-        onlydefault = []
-
-        for d in deficiencies:
-            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 feature deficiencies found in existing '
-                    b'repository)\n'
-                )
-            )
-
-        ui.status(
-            _(
-                b'performing an upgrade with "--run" will make the following '
-                b'changes:\n\n'
-            )
-        )
-
-        printrequirements()
-        printoptimisations()
-        printupgradeactions()
-        print_affected_revlogs()
-
-        unusedoptimize = [i for i in alloptimizations if i not in actions]
-
-        if unusedoptimize:
-            ui.status(
-                _(
-                    b'additional optimizations are available by specifying '
-                    b'"--optimize <name>":\n\n'
-                )
-            )
-            for i in unusedoptimize:
-                ui.status(_(b'%s\n   %s\n\n') % (i.name, i.description))
-        return
-
-    # Else we're in the run=true case.
-    ui.write(_(b'upgrade will perform the following actions:\n\n'))
-    printrequirements()
-    printoptimisations()
-    printupgradeactions()
-    print_affected_revlogs()
-
-    upgradeactions = [a.name for a in actions]
-
-    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 migrated '
-                    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, newreqs, upgradeactions, revlogs=revlogs
-                )
-            if not (backup or backuppath is None):
-                ui.status(
-                    _(b'removing old repository content%s\n') % backuppath
-                )
-                repo.vfs.rmtree(backuppath, forcibly=True)
-                backuppath = None
-
-        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'
-                    )
-                )
-
-            if sharedsafe.name in addedreqs:
-                ui.warn(
-                    _(
-                        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.\n'
-                    )
-                )
-            if sharedsafe.name in removedreqs:
-                ui.warn(
-                    _(
-                        b'repository downgraded to not use share safe mode, '
-                        b'existing shares will not work and needs to'
-                        b' be reshared.\n'
-                    )
-                )