|
|
# chainsaw.py
|
|
|
#
|
|
|
# Copyright 2022 Georges Racinet <georges.racinet@octobus.net>
|
|
|
#
|
|
|
# This software may be used and distributed according to the terms of the
|
|
|
# GNU General Public License version 2 or any later version.
|
|
|
"""chainsaw is a collection of single-minded and dangerous tools. (EXPERIMENTAL)
|
|
|
|
|
|
"Don't use a chainsaw to cut your food!"
|
|
|
|
|
|
The chainsaw extension provides commands that are so much geared towards a
|
|
|
specific use case in a specific context or environment that they are totally
|
|
|
inappropriate and **really dangerous** in other contexts.
|
|
|
|
|
|
The help text of each command explicitly summarizes its context of application
|
|
|
and the wanted end result.
|
|
|
|
|
|
It is recommended to run these commands with the ``HGPLAIN`` environment
|
|
|
variable (see :hg:`help scripting`).
|
|
|
"""
|
|
|
|
|
|
import shutil
|
|
|
|
|
|
from mercurial.i18n import _
|
|
|
from mercurial import (
|
|
|
cmdutil,
|
|
|
commands,
|
|
|
error,
|
|
|
localrepo,
|
|
|
registrar,
|
|
|
)
|
|
|
from mercurial.utils import (
|
|
|
urlutil,
|
|
|
)
|
|
|
|
|
|
cmdtable = {}
|
|
|
command = registrar.command(cmdtable)
|
|
|
# Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
|
|
|
# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
|
|
|
# be specifying the version(s) of Mercurial they are tested with, or
|
|
|
# leave the attribute unspecified.
|
|
|
testedwith = b'ships-with-hg-core'
|
|
|
|
|
|
|
|
|
@command(
|
|
|
b'admin::chainsaw-update',
|
|
|
[
|
|
|
(
|
|
|
b'',
|
|
|
b'purge-unknown',
|
|
|
True,
|
|
|
_(
|
|
|
b'Remove unversioned files before update. Disabling this can '
|
|
|
b'in some cases interfere with the update.'
|
|
|
b'See also :hg:`purge`.'
|
|
|
),
|
|
|
),
|
|
|
(
|
|
|
b'',
|
|
|
b'purge-ignored',
|
|
|
True,
|
|
|
_(
|
|
|
b'Remove ignored files before update. Disable this for '
|
|
|
b'instance to reuse previous compiler object files. '
|
|
|
b'See also :hg:`purge`.'
|
|
|
),
|
|
|
),
|
|
|
(
|
|
|
b'',
|
|
|
b'rev',
|
|
|
b'',
|
|
|
_(b'revision to update to'),
|
|
|
),
|
|
|
(
|
|
|
b'',
|
|
|
b'source',
|
|
|
b'',
|
|
|
_(b'repository to clone from'),
|
|
|
),
|
|
|
(
|
|
|
b'',
|
|
|
b'dest',
|
|
|
b'',
|
|
|
_(b'repository to update to REV (possibly cloning)'),
|
|
|
),
|
|
|
(
|
|
|
b'',
|
|
|
b'initial-clone-minimal',
|
|
|
False,
|
|
|
_(
|
|
|
b'Pull only the prescribed revision upon initial cloning. '
|
|
|
b'This has the side effect of ignoring clone-bundles, '
|
|
|
b'which if often slower on the client side and stressful '
|
|
|
b'to the server than applying available clone bundles.'
|
|
|
),
|
|
|
),
|
|
|
],
|
|
|
_(
|
|
|
b'hg admin::chainsaw-update [OPTION] --rev REV --source SOURCE --dest DEST'
|
|
|
),
|
|
|
helpbasic=True,
|
|
|
norepo=True,
|
|
|
)
|
|
|
def update(ui, **opts):
|
|
|
"""pull and update to a given revision, no matter what, (EXPERIMENTAL)
|
|
|
|
|
|
Context of application: *some* Continuous Integration (CI) systems,
|
|
|
packaging or deployment tools.
|
|
|
|
|
|
Wanted end result: local repository at the given REPO_PATH, having the
|
|
|
latest changes to the given revision and with a clean working directory
|
|
|
updated at the given revision.
|
|
|
|
|
|
chainsaw-update pulls from one source, then updates the working directory
|
|
|
to the given revision, overcoming anything that would stand in the way.
|
|
|
|
|
|
By default, it will:
|
|
|
|
|
|
- clone if the local repo does not exist yet, **removing any directory
|
|
|
at the given path** that would not be a Mercurial repository.
|
|
|
The initial clone is full by default, so that clonebundles can be
|
|
|
applied. Use the --initial-clone-minimal flag to avoid this.
|
|
|
- break locks if needed, leading to possible corruption if there
|
|
|
is a concurrent write access.
|
|
|
- perform recovery actions if needed
|
|
|
- revert any local modification.
|
|
|
- purge unknown and ignored files.
|
|
|
- go as far as to reclone if everything else failed (not implemented yet).
|
|
|
|
|
|
DO NOT use it for anything else than performing a series
|
|
|
of unattended updates, with full exclusive repository access each time
|
|
|
and without any other local work than running build scripts.
|
|
|
In case the local repository is a share (see :hg:`help share`), exclusive
|
|
|
write access to the share source is also mandatory.
|
|
|
|
|
|
It is recommended to run these commands with the ``HGPLAIN`` environment
|
|
|
variable (see :hg:`scripting`).
|
|
|
|
|
|
Motivation: in Continuous Integration and Delivery systems (CI/CD), the
|
|
|
occasional remnant or bogus lock are common sources of waste of time (both
|
|
|
working time and calendar time). CI/CD scripts tend to grow with counter-
|
|
|
measures, often done in urgency. Also, whilst it is neat to keep
|
|
|
repositories from one job to the next (especially with large
|
|
|
repositories), an exceptional recloning is better than missing a release
|
|
|
deadline.
|
|
|
"""
|
|
|
rev = opts['rev']
|
|
|
source = opts['source']
|
|
|
repo_path = opts['dest']
|
|
|
if not rev:
|
|
|
raise error.InputError(_(b'specify a target revision with --rev'))
|
|
|
if not source:
|
|
|
raise error.InputError(_(b'specify a pull path with --source'))
|
|
|
if not repo_path:
|
|
|
raise error.InputError(_(b'specify a repo path with --dest'))
|
|
|
repo_path = urlutil.urllocalpath(repo_path)
|
|
|
|
|
|
try:
|
|
|
repo = localrepo.instance(ui, repo_path, create=False)
|
|
|
repo_created = False
|
|
|
ui.status(_(b'loaded repository at "%s"\n' % repo_path))
|
|
|
except error.RepoError:
|
|
|
try:
|
|
|
shutil.rmtree(repo_path)
|
|
|
except FileNotFoundError:
|
|
|
ui.status(_(b'no such directory: "%s"\n' % repo_path))
|
|
|
else:
|
|
|
ui.status(
|
|
|
_(
|
|
|
b'removed non-repository file or directory '
|
|
|
b'at "%s"' % repo_path
|
|
|
)
|
|
|
)
|
|
|
|
|
|
ui.status(_(b'creating repository at "%s"\n' % repo_path))
|
|
|
repo = localrepo.instance(ui, repo_path, create=True)
|
|
|
repo_created = True
|
|
|
|
|
|
if repo.svfs.tryunlink(b'lock'):
|
|
|
ui.status(_(b'had to break store lock\n'))
|
|
|
if repo.vfs.tryunlink(b'wlock'):
|
|
|
ui.status(_(b'had to break working copy lock\n'))
|
|
|
# If another process relock after the breacking above, the next locking
|
|
|
# will have to wait.
|
|
|
with repo.wlock(), repo.lock():
|
|
|
ui.status(_(b'recovering after interrupted transaction, if any\n'))
|
|
|
repo.recover()
|
|
|
|
|
|
ui.status(_(b'pulling from %s\n') % source)
|
|
|
if repo_created and not opts.get('initial_clone_minimal'):
|
|
|
pull_revs = []
|
|
|
else:
|
|
|
pull_revs = [rev]
|
|
|
overrides = {(b'ui', b'quiet'): True}
|
|
|
with repo.ui.configoverride(overrides, b'chainsaw-update'):
|
|
|
pull = cmdutil.findcmd(b'pull', commands.table)[1][0]
|
|
|
ret = pull(
|
|
|
repo.ui,
|
|
|
repo,
|
|
|
source,
|
|
|
rev=pull_revs,
|
|
|
remote_hidden=False,
|
|
|
)
|
|
|
if ret:
|
|
|
return ret
|
|
|
|
|
|
purge = cmdutil.findcmd(b'purge', commands.table)[1][0]
|
|
|
ret = purge(
|
|
|
ui,
|
|
|
repo,
|
|
|
dirs=True,
|
|
|
all=opts.get('purge_ignored'),
|
|
|
files=opts.get('purge_unknown'),
|
|
|
confirm=False,
|
|
|
)
|
|
|
if ret:
|
|
|
return ret
|
|
|
|
|
|
ui.status(_(b'updating to revision \'%s\'\n') % rev)
|
|
|
update = cmdutil.findcmd(b'update', commands.table)[1][0]
|
|
|
ret = update(ui, repo, rev=rev, clean=True)
|
|
|
if ret:
|
|
|
return ret
|
|
|
|
|
|
ui.status(
|
|
|
_(
|
|
|
b'chainsaw-update to revision \'%s\' '
|
|
|
b'for repository at \'%s\' done\n'
|
|
|
)
|
|
|
% (rev, repo.root)
|
|
|
)
|
|
|
|
