Mercurial > hg
view mercurial/upgrade.py @ 50336:cf4d2f31660d stable
chg: populate CHGHG if not set
Normally, chg determines which `hg` executable to use by first consulting the
`$CHGHG` and `$HG` environment variables, and if neither are present defaults
to the `hg` found in the user's `$PATH`. If built with the `HGPATHREL` compiler
flag, chg will instead assume that there exists an `hg` executable in the same
directory as the `chg` binary and attempt to use that.
This can cause problems in situations where there are multiple actively-used
Mercurial installations on the same system. When a `chg` client connects to a
running command server, the server process performs some basic validation to
determine whether a new command server needs to be spawned. These checks include
things like checking certain "sensitive" environment variables and config
sections, as well as checking whether the mtime of the extensions, hg's
`__version__.py` module, and the Python interpreter have changed.
Crucially, the command server doesn't explicitly check whether the executable it
is running from matches the executable that the `chg` client would have
otherwise invoked had there been no existing command server process. Without
`HGPATHREL`, this still gets implicitly checked during the validation step,
because the only way to specify an alternate hg executable (apart from `$PATH`)
is via the `$CHGHG` and `$HG` environment variables, both of which are checked.
With `HGPATHREL`, however, the command server has no way of knowing which hg
executable the client would have run. This means that a client located at
`/version_B/bin/chg` will happily connect to a command server running
`/version_A/bin/hg` instead of `/version_B/bin/hg` as expected. A simple
solution is to have the client set `$CHGHG` itself, which then allows the
command server's environment validation to work as intended.
I have tested this manually using two locally built hg installations and it
seems to work with no ill effects. That said, I'm not sure how to write an
automated test for this since the `chg` available to the tests isn't even built
with the `HGPATHREL` compiler flag to begin with.
author | Arun Kulshreshtha <akulshreshtha@janestreet.com> |
---|---|
date | Mon, 27 Mar 2023 17:30:14 -0400 |
parents | 4f04bb0d8deb |
children | 493034cc3265 |
line wrap: on
line source
# upgrade.py - functions for in place upgrade of Mercurial repository # # Copyright (c) 2016-present, Gregory Szorc # # This software may be used and distributed according to the terms of the # GNU General Public License version 2 or any later version. from .i18n import _ from . import ( error, hg, localrepo, lock as lockmod, pycompat, requirements as requirementsmod, scmutil, ) from .upgrade_utils import ( actions as upgrade_actions, auto_upgrade, engine as upgrade_engine, ) from .utils import ( stringutil, ) may_auto_upgrade = auto_upgrade.may_auto_upgrade allformatvariant = upgrade_actions.allformatvariant def upgraderepo( ui, repo, run=False, optimize=None, backup=True, manifest=None, changelog=None, filelogs=None, ): """Upgrade a repository in place.""" if optimize is None: optimize = set() repo = repo.unfiltered() specified_revlogs = {} if changelog is not None: specified_revlogs[upgrade_engine.UPGRADE_CHANGELOG] = changelog if manifest is not None: specified_revlogs[upgrade_engine.UPGRADE_MANIFEST] = manifest if filelogs is not None: specified_revlogs[upgrade_engine.UPGRADE_FILELOGS] = filelogs # Ensure the repository can be upgraded. upgrade_actions.check_source_requirements(repo) default_options = localrepo.defaultcreateopts(repo.ui) newreqs = localrepo.newreporequirements(repo.ui, default_options) newreqs.update(upgrade_actions.preservedrequirements(repo)) upgrade_actions.check_requirements_changes(repo, newreqs) # Find and validate all improvements that can be made. alloptimizations = upgrade_actions.findoptimizations(repo) # Apply and Validate arguments. optimizations = [] for o in alloptimizations: if o.name in optimize: optimizations.append(o) optimize.discard(o.name) if optimize: # anything left is unknown raise error.Abort( _(b'unknown optimization action requested: %s') % b', '.join(sorted(optimize)), hint=_(b'run without arguments to see valid optimizations'), ) format_upgrades = upgrade_actions.find_format_upgrades(repo) up_actions = upgrade_actions.determine_upgrade_actions( repo, format_upgrades, optimizations, repo.requirements, newreqs ) removed_actions = upgrade_actions.find_format_downgrades(repo) # check if we need to touch revlog and if so, which ones touched_revlogs = set() overwrite_msg = _(b'warning: ignoring %14s, as upgrade is changing: %s\n') select_msg = _(b'note: selecting %s for processing to change: %s\n') msg_issued = 0 FL = upgrade_engine.UPGRADE_FILELOGS MN = upgrade_engine.UPGRADE_MANIFEST CL = upgrade_engine.UPGRADE_CHANGELOG if optimizations: if any(specified_revlogs.values()): # we have some limitation on revlogs to be recloned for rl, enabled in specified_revlogs.items(): if enabled: touched_revlogs.add(rl) else: touched_revlogs = set(upgrade_engine.UPGRADE_ALL_REVLOGS) for rl, enabled in specified_revlogs.items(): if not enabled: touched_revlogs.discard(rl) if repo.shared(): unsafe_actions = set() unsafe_actions.update(up_actions) unsafe_actions.update(removed_actions) unsafe_actions.update(optimizations) unsafe_actions = [ a for a in unsafe_actions if not a.compatible_with_share ] unsafe_actions.sort(key=lambda a: a.name) if unsafe_actions: m = _(b'cannot use these actions on a share repository: %s') h = _(b'upgrade the main repository directly') actions = b', '.join(a.name for a in unsafe_actions) m %= actions raise error.Abort(m, hint=h) for action in sorted(up_actions + removed_actions, key=lambda a: a.name): # optimisation does not "requires anything, they just needs it. if action.type != upgrade_actions.FORMAT_VARIANT: continue if action.touches_filelogs and FL not in touched_revlogs: if FL in specified_revlogs: if not specified_revlogs[FL]: msg = overwrite_msg % (b'--no-filelogs', action.name) ui.warn(msg) msg_issued = 2 else: msg = select_msg % (b'all-filelogs', action.name) ui.status(msg) if not ui.quiet: msg_issued = 1 touched_revlogs.add(FL) if action.touches_manifests and MN not in touched_revlogs: if MN in specified_revlogs: if not specified_revlogs[MN]: msg = overwrite_msg % (b'--no-manifest', action.name) ui.warn(msg) msg_issued = 2 else: msg = select_msg % (b'all-manifestlogs', action.name) ui.status(msg) if not ui.quiet: msg_issued = 1 touched_revlogs.add(MN) if action.touches_changelog and CL not in touched_revlogs: if CL in specified_revlogs: if not specified_revlogs[CL]: msg = overwrite_msg % (b'--no-changelog', action.name) ui.warn(msg) msg_issued = True else: msg = select_msg % (b'changelog', action.name) ui.status(msg) if not ui.quiet: msg_issued = 1 touched_revlogs.add(CL) if msg_issued >= 2: ui.warn((b"\n")) elif msg_issued >= 1: ui.status((b"\n")) upgrade_op = upgrade_actions.UpgradeOperation( ui, newreqs, repo.requirements, up_actions, removed_actions, touched_revlogs, backup, ) if not run: fromconfig = [] onlydefault = [] for d in format_upgrades: if d.fromconfig(repo): fromconfig.append(d) elif d.default: onlydefault.append(d) if fromconfig or onlydefault: if fromconfig: ui.status( _( b'repository lacks features recommended by ' b'current config options:\n\n' ) ) for i in fromconfig: ui.status(b'%s\n %s\n\n' % (i.name, i.description)) if onlydefault: ui.status( _( b'repository lacks features used by the default ' b'config options:\n\n' ) ) for i in onlydefault: ui.status(b'%s\n %s\n\n' % (i.name, i.description)) ui.status(b'\n') else: ui.status(_(b'(no format upgrades found in existing repository)\n')) ui.status( _( b'performing an upgrade with "--run" will make the following ' b'changes:\n\n' ) ) upgrade_op.print_requirements() upgrade_op.print_optimisations() upgrade_op.print_upgrade_actions() upgrade_op.print_affected_revlogs() if upgrade_op.unused_optimizations: ui.status( _( b'additional optimizations are available by specifying ' b'"--optimize <name>":\n\n' ) ) upgrade_op.print_unused_optimizations() return if not (upgrade_op.upgrade_actions or upgrade_op.removed_actions): ui.status(_(b'nothing to do\n')) return # Else we're in the run=true case. ui.write(_(b'upgrade will perform the following actions:\n\n')) upgrade_op.print_requirements() upgrade_op.print_optimisations() upgrade_op.print_upgrade_actions() upgrade_op.print_affected_revlogs() ui.status(_(b'beginning upgrade...\n')) with repo.wlock(), repo.lock(): ui.status(_(b'repository locked and read-only\n')) # Our strategy for upgrading the repository is to create a new, # temporary repository, write data to it, then do a swap of the # data. There are less heavyweight ways to do this, but it is easier # to create a new repo object than to instantiate all the components # (like the store) separately. tmppath = pycompat.mkdtemp(prefix=b'upgrade.', dir=repo.path) backuppath = None try: ui.status( _( b'creating temporary repository to stage upgraded ' b'data: %s\n' ) % tmppath ) # clone ui without using ui.copy because repo.ui is protected repoui = repo.ui.__class__(repo.ui) dstrepo = hg.repository(repoui, path=tmppath, create=True) with dstrepo.wlock(), dstrepo.lock(): backuppath = upgrade_engine.upgrade( ui, repo, dstrepo, upgrade_op ) finally: ui.status(_(b'removing temporary repository %s\n') % tmppath) repo.vfs.rmtree(tmppath, forcibly=True) if backuppath and not ui.quiet: ui.warn( _(b'copy of old repository backed up at %s\n') % backuppath ) ui.warn( _( b'the old repository will not be deleted; remove ' b'it to free up disk space once the upgraded ' b'repository is verified\n' ) ) upgrade_op.print_post_op_messages() def upgrade_share_to_safe( ui, hgvfs, storevfs, current_requirements, mismatch_config, mismatch_warn, mismatch_verbose_upgrade, ): """Upgrades a share to use share-safe mechanism""" wlock = None store_requirements = localrepo._readrequires(storevfs, False) original_crequirements = current_requirements.copy() # after upgrade, store requires will be shared, so lets find # the requirements which are not present in store and # write them to share's .hg/requires diffrequires = current_requirements - store_requirements # add share-safe requirement as it will mark the share as share-safe diffrequires.add(requirementsmod.SHARESAFE_REQUIREMENT) current_requirements.add(requirementsmod.SHARESAFE_REQUIREMENT) # in `allow` case, we don't try to upgrade, we just respect the source # state, update requirements and continue if mismatch_config == b'allow': return try: wlock = lockmod.trylock(ui, hgvfs, b'wlock', 0, 0) # some process might change the requirement in between, re-read # and update current_requirements locked_requirements = localrepo._readrequires(hgvfs, True) if locked_requirements != original_crequirements: removed = current_requirements - locked_requirements # update current_requirements in place because it's passed # as reference current_requirements -= removed current_requirements |= locked_requirements diffrequires = current_requirements - store_requirements # add share-safe requirement as it will mark the share as share-safe diffrequires.add(requirementsmod.SHARESAFE_REQUIREMENT) current_requirements.add(requirementsmod.SHARESAFE_REQUIREMENT) scmutil.writerequires(hgvfs, diffrequires) if mismatch_verbose_upgrade: ui.warn(_(b'repository upgraded to use share-safe mode\n')) except error.LockError as e: hint = _( b"see `hg help config.format.use-share-safe` for more information" ) if mismatch_config == b'upgrade-abort': raise error.Abort( _(b'failed to upgrade share, got error: %s') % stringutil.forcebytestr(e.strerror), hint=hint, ) elif mismatch_warn: ui.warn( _(b'failed to upgrade share, got error: %s\n') % stringutil.forcebytestr(e.strerror), hint=hint, ) finally: if wlock: wlock.release() def downgrade_share_to_non_safe( ui, hgvfs, sharedvfs, current_requirements, mismatch_config, mismatch_warn, mismatch_verbose_upgrade, ): """Downgrades a share which use share-safe to not use it""" wlock = None source_requirements = localrepo._readrequires(sharedvfs, True) original_crequirements = current_requirements.copy() # we cannot be 100% sure on which requirements were present in store when # the source supported share-safe. However, we do know that working # directory requirements were not there. Hence we remove them source_requirements -= requirementsmod.WORKING_DIR_REQUIREMENTS current_requirements |= source_requirements current_requirements.remove(requirementsmod.SHARESAFE_REQUIREMENT) if mismatch_config == b'allow': return try: wlock = lockmod.trylock(ui, hgvfs, b'wlock', 0, 0) # some process might change the requirement in between, re-read # and update current_requirements locked_requirements = localrepo._readrequires(hgvfs, True) if locked_requirements != original_crequirements: removed = current_requirements - locked_requirements # update current_requirements in place because it's passed # as reference current_requirements -= removed current_requirements |= locked_requirements current_requirements |= source_requirements current_requirements -= set(requirementsmod.SHARESAFE_REQUIREMENT) scmutil.writerequires(hgvfs, current_requirements) if mismatch_verbose_upgrade: ui.warn(_(b'repository downgraded to not use share-safe mode\n')) except error.LockError as e: hint = _( b"see `hg help config.format.use-share-safe` for more information" ) # If upgrade-abort is set, abort when upgrade fails, else let the # process continue as `upgrade-allow` is set if mismatch_config == b'downgrade-abort': raise error.Abort( _(b'failed to downgrade share, got error: %s') % stringutil.forcebytestr(e.strerror), hint=hint, ) elif mismatch_warn: ui.warn( _(b'failed to downgrade share, got error: %s\n') % stringutil.forcebytestr(e.strerror), hint=hint, ) finally: if wlock: wlock.release()