This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6566

abort: added logic for of hg abort
ClosedPublic

Authored by taapas1128 on Jun 23 2019, 1:42 PM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHGbb135a784b70: abort: added logic for of hg abort
Summary

This is part of GSoC19 project `Implement abort and
continue commands`. This patch is part of the abort plan.

This adds the basic logic for hg abort. This command
aborts an multistep operation like graft, histedit, rebase,
merge and unshelve if they are in an unfinished state.

The first part of the logic is determining the unfinished
operation from the state detection API under statemod.
This API is extended to support hg abort by adding a method
to register the abort logic as a function (here abortfunc).

Once the unfinished operation is determined the registered
logic is used to abort the command. The benefit of this kind
of framework is that any new extension developed can support
hg abort by registering the command and logic under
statedetection API.

hg abort currently supports --dry-run/-n flag only.
It is used to dry run hg abort

Further patches sequentially add support for graft, rebase,
unshelve, histedit and merge.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

taapas1128 created this revision.Jun 23 2019, 1:42 PM
martinvonz added a subscriber: martinvonz.Jun 23 2019, 5:29 PM

Need to set the parent of this patch

taapas1128 added a comment.Jun 24 2019, 5:47 AM

@martinvonz I wanted this as a seperate stack for now so that the previous stack can be committed first. Do you want me to update its parents and add it to the previous stack?

pulkit added a subscriber: pulkit.Jun 30 2019, 3:08 PM
pulkit added inline comments.
mercurial/commands.py
147

return state.abortfunc(ui, repo, **opts) instead of storing and calling that later.

152

we should pass opts to abortfunc too. I can think of --no-backup as a flag which tells not to store a backup when aborting.

A nice addition will be --dry-run flag which tells which operation will be aborted. Also, maybe add a message saying aborting <command>.

mercurial/state.py
99–100

the new argument needs documentation.

109

since we will be using this argument outside of this class, let's not prepend _ to the name.

taapas1128 updated this revision to Diff 15731.Jul 1 2019, 5:49 PM
taapas1128 marked 3 inline comments as done.Jul 1 2019, 5:58 PM
pulkit added inline comments.Jul 2 2019, 5:28 PM
mercurial/commands.py
164

Arguments for abort can increase in future. Rather pass the opts directly to abort functions for now and make related functions look for flag which they need.

I agree it's not nice, but seems like a good tradeoff to start and have better code.

171

should be ui.status() instead of error.Abort()

taapas1128 retitled this revision from abort: first prototype of hg abort to abort: added logic for of hg abort.Jul 3 2019, 7:01 PM
taapas1128 edited the summary of this revision. (Show Details)
taapas1128 updated this revision to Diff 15750.
taapas1128 marked 3 inline comments as done.Jul 3 2019, 7:04 PM
taapas1128 updated this revision to Diff 15775.Jul 5 2019, 2:21 PM
pulkit added inline comments.Jul 5 2019, 5:49 PM
mercurial/commands.py
134

Can you mark this command as experimental for now, we will be close to release soon. Marking this as experimental will help us take more time to smoothen things out.

135

This help should be 'do not save backup bundle' as similar to strip command.

141

s/an/a

153

need to prepend r'' in front of dry_run for py3 compat.

164

we should return here so that abortstate.abortfunc() is not called below in case of dry-run.

taapas1128 marked 4 inline comments as done.Jul 6 2019, 2:56 PM
pulkit added a comment.Jul 9 2019, 6:25 AM

hg abort currently supports --dry-run/-n flag only.
It is used to dry run hg abort

We should specify what does dry run does i.e. it prints the operation which will be aborted if hg abort is run.

mercurial/commands.py
138

You need a space between operation and (EXPERIMENTAL)

152

%s is in progress but does not support 'hg abort'.

157

Now that we don't have backup flag, and --dry-run is tackled before calling abortfunc, we can prevent passing **opts.

taapas1128 marked 3 inline comments as done.Jul 9 2019, 8:27 AM
taapas1128 updated this revision to Diff 15836.
pulkit accepted this revision.Jul 10 2019, 8:39 AM
This revision is now accepted and ready to land.Jul 10 2019, 8:39 AM
taapas1128 added a commit: rHGbb135a784b70: abort: added logic for of hg abort.Jul 10 2019, 9:13 AM
Closed by commit rHGbb135a784b70: abort: added logic for of hg abort (authored by taapas1128). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 15845

mercurial/commands.py

diffopts2 = cmdutil.diffopts2 diffopts2 = cmdutil.diffopts2
mergetoolopts = cmdutil.mergetoolopts mergetoolopts = cmdutil.mergetoolopts
similarityopts = cmdutil.similarityopts similarityopts = cmdutil.similarityopts
subrepoopts = cmdutil.subrepoopts subrepoopts = cmdutil.subrepoopts
debugrevlogopts = cmdutil.debugrevlogopts debugrevlogopts = cmdutil.debugrevlogopts
# Commands start here, listed alphabetically # Commands start here, listed alphabetically
@command('abort',
pulkitUnsubmitted
Done

Can you mark this command as experimental for now, we will be close to release soon. Marking this as experimental will help us take more time to smoothen things out.

pulkit: Can you mark this command as experimental for now, we will be close to release soon. Marking…
dryrunopts, helpcategory=command.CATEGORY_CHANGE_MANAGEMENT,
pulkitUnsubmitted
Done

This help should be 'do not save backup bundle' as similar to strip command.

pulkit: This help should be `'do not save backup bundle'` as similar to strip command.
helpbasic=True)
def abort(ui, repo, **opts):
"""abort an unfinished operation (EXPERIMENTAL)
pulkitUnsubmitted
Done

You need a space between operation and (EXPERIMENTAL)

pulkit: You need a space between operation and (EXPERIMENTAL)
Aborts a multistep operation like graft, histedit, rebase, merge,
and unshelve if they are in an unfinished state.
pulkitUnsubmitted
Done

s/an/a

pulkit: s/an/a
use --dry-run/-n to dry run the command.
A new operation can be added to this by registering the operation and
abort logic in the unfinishedstates list under statemod.
"""
dryrun = opts.get(r'dry_run')
pulkitUnsubmitted
Done

return state.abortfunc(ui, repo, **opts) instead of storing and calling that later.

pulkit: `return state.abortfunc(ui, repo, **opts)` instead of storing and calling that later.
abortstate = cmdutil.getunfinishedstate(repo)
if not abortstate:
raise error.Abort(_('no operation in progress'))
if not abortstate.abortfunc:
raise error.Abort((_("%s in progress but does not support 'hg abort'") %
pulkitUnsubmitted
Done

we should pass opts to abortfunc too. I can think of --no-backup as a flag which tells not to store a backup when aborting.

A nice addition will be --dry-run flag which tells which operation will be aborted. Also, maybe add a message saying aborting <command>.

pulkit: we should pass opts to abortfunc too. I can think of `--no-backup` as a flag which tells not to…
pulkitUnsubmitted
Done

%s is in progress but does not support 'hg abort'.

pulkit: `%s is in progress but does not support 'hg abort'`.
(abortstate._opname)), hint=abortstate.hint())
pulkitUnsubmitted
Done

need to prepend r'' in front of dry_run for py3 compat.

pulkit: need to prepend `r''` in front of dry_run for py3 compat.
if dryrun:
ui.status(_('%s in progress, will be aborted\n') % (abortstate._opname))
return
return abortstate.abortfunc(ui, repo)
pulkitUnsubmitted
Done

Now that we don't have backup flag, and --dry-run is tackled before calling abortfunc, we can prevent passing **opts.

pulkit: Now that we don't have backup flag, and --dry-run is tackled before calling abortfunc, we can…
@command('add', @command('add',
walkopts + subrepoopts + dryrunopts, walkopts + subrepoopts + dryrunopts,
_('[OPTION]... [FILE]...'), _('[OPTION]... [FILE]...'),
helpcategory=command.CATEGORY_WORKING_DIRECTORY, helpcategory=command.CATEGORY_WORKING_DIRECTORY,
helpbasic=True, inferrepo=True) helpbasic=True, inferrepo=True)
def add(ui, repo, *pats, **opts): def add(ui, repo, *pats, **opts):
pulkitUnsubmitted
Done

Arguments for abort can increase in future. Rather pass the opts directly to abort functions for now and make related functions look for flag which they need.

I agree it's not nice, but seems like a good tradeoff to start and have better code.

pulkit: Arguments for abort can increase in future. Rather pass the opts directly to abort functions…
pulkitUnsubmitted
Not Done

we should return here so that abortstate.abortfunc() is not called below in case of dry-run.

pulkit: we should return here so that `abortstate.abortfunc()` is not called below in case of dry-run.
"""add the specified files on the next commit """add the specified files on the next commit
Schedule files to be version controlled and added to the Schedule files to be version controlled and added to the
repository. repository.
The files will be added to the repository at the next commit. To The files will be added to the repository at the next commit. To
undo an add before that, see :hg:`forget`. undo an add before that, see :hg:`forget`.
pulkitUnsubmitted
Done

should be ui.status() instead of error.Abort()

pulkit: should be `ui.status()` instead of `error.Abort()`
If no names are given, add all files to the repository (except If no names are given, add all files to the repository (except
files matching ``.hgignore``). files matching ``.hgignore``).
.. container:: verbose .. container:: verbose
Examples: Examples:

mercurial/state.py

class _statecheck(object): class _statecheck(object):
"""a utility class that deals with multistep operations like graft, """a utility class that deals with multistep operations like graft,
histedit, bisect, update etc and check whether such commands histedit, bisect, update etc and check whether such commands
are in an unfinished conditition or not and return appropriate message are in an unfinished conditition or not and return appropriate message
and hint. and hint.
It also has the ability to register and determine the states of any new It also has the ability to register and determine the states of any new
multistep operation or multistep command extension. multistep operation or multistep command extension.
""" """
def __init__(self, opname, fname, clearable, allowcommit, reportonly, def __init__(self, opname, fname, clearable, allowcommit, reportonly,
pulkitUnsubmitted
Done

the new argument needs documentation.

pulkit: the new argument needs documentation.
continueflag, stopflag, cmdmsg, cmdhint, statushint): continueflag, stopflag, cmdmsg, cmdhint, statushint,
abortfunc):
self._opname = opname self._opname = opname
self._fname = fname self._fname = fname
self._clearable = clearable self._clearable = clearable
self._allowcommit = allowcommit self._allowcommit = allowcommit
self._reportonly = reportonly self._reportonly = reportonly
self._continueflag = continueflag self._continueflag = continueflag
self._stopflag = stopflag self._stopflag = stopflag
pulkitUnsubmitted
Done

since we will be using this argument outside of this class, let's not prepend _ to the name.

pulkit: since we will be using this argument outside of this class, let's not prepend `_` to the name.
self._cmdmsg = cmdmsg self._cmdmsg = cmdmsg
self._cmdhint = cmdhint self._cmdhint = cmdhint
self._statushint = statushint self._statushint = statushint
self.abortfunc = abortfunc
def statusmsg(self): def statusmsg(self):
"""returns the hint message corresponding to the command for """returns the hint message corresponding to the command for
hg status --verbose hg status --verbose
""" """
if not self._statushint: if not self._statushint:
hint = (_('To continue: hg %s --continue\n' hint = (_('To continue: hg %s --continue\n'
'To abort: hg %s --abort') % (self._opname, 'To abort: hg %s --abort') % (self._opname,
else: else:
return repo.vfs.exists(self._fname) return repo.vfs.exists(self._fname)
# A list of statecheck objects for multistep operations like graft. # A list of statecheck objects for multistep operations like graft.
_unfinishedstates = [] _unfinishedstates = []
def addunfinished(opname, fname, clearable=False, allowcommit=False, def addunfinished(opname, fname, clearable=False, allowcommit=False,
reportonly=False, continueflag=False, stopflag=False, reportonly=False, continueflag=False, stopflag=False,
cmdmsg="", cmdhint="", statushint=""): cmdmsg="", cmdhint="", statushint="", abortfunc=None):
"""this registers a new command or operation to unfinishedstates """this registers a new command or operation to unfinishedstates
opname is the name the command or operation opname is the name the command or operation
fname is the file name in which data should be stored in .hg directory. fname is the file name in which data should be stored in .hg directory.
It is None for merge command. It is None for merge command.
clearable boolean determines whether or not interrupted states can be clearable boolean determines whether or not interrupted states can be
cleared by running `hg update -C .` which in turn deletes the cleared by running `hg update -C .` which in turn deletes the
state file. state file.
allowcommit boolean decides whether commit is allowed during interrupted allowcommit boolean decides whether commit is allowed during interrupted
state or not. state or not.
reportonly flag is used for operations like bisect where we just reportonly flag is used for operations like bisect where we just
need to detect the operation using 'hg status --verbose' need to detect the operation using 'hg status --verbose'
continueflag is a boolean determines whether or not a command supports continueflag is a boolean determines whether or not a command supports
`--continue` option or not. `--continue` option or not.
stopflag is a boolean that determines whether or not a command supports stopflag is a boolean that determines whether or not a command supports
--stop flag --stop flag
cmdmsg is used to pass a different status message in case standard cmdmsg is used to pass a different status message in case standard
message of the format "abort: cmdname in progress" is not desired. message of the format "abort: cmdname in progress" is not desired.
cmdhint is used to pass a different hint message in case standard cmdhint is used to pass a different hint message in case standard
message of the format "To continue: hg cmdname --continue message of the format "To continue: hg cmdname --continue
To abort: hg cmdname --abort" is not desired. To abort: hg cmdname --abort" is not desired.
statushint is used to pass a different status message in case standard statushint is used to pass a different status message in case standard
message of the format ('To continue: hg cmdname --continue' message of the format ('To continue: hg cmdname --continue'
'To abort: hg cmdname --abort') is not desired 'To abort: hg cmdname --abort') is not desired
abortfunc stores the function required to abort an unfinished state.
""" """
statecheckobj = _statecheck(opname, fname, clearable, allowcommit, statecheckobj = _statecheck(opname, fname, clearable, allowcommit,
reportonly, continueflag, stopflag, cmdmsg, reportonly, continueflag, stopflag, cmdmsg,
cmdhint, statushint) cmdhint, statushint, abortfunc)
if opname == 'merge': if opname == 'merge':
_unfinishedstates.append(statecheckobj) _unfinishedstates.append(statecheckobj)
else: else:
_unfinishedstates.insert(0, statecheckobj) _unfinishedstates.insert(0, statecheckobj)
addunfinished( addunfinished(
'graft', fname='graftstate', clearable=True, stopflag=True, 'graft', fname='graftstate', clearable=True, stopflag=True,
continueflag=True, continueflag=True,

tests/test-blackbox.t

setup setup
$ cat > myextension.py <<EOF $ cat > myextension.py <<EOF
> from mercurial import error, registrar > from mercurial import error, registrar
> cmdtable = {} > cmdtable = {}
> command = registrar.command(cmdtable) > command = registrar.command(cmdtable)
> @command(b'crash', [], b'hg crash') > @command(b'crash', [], b'hg crash')
> def crash(ui, *args, **kwargs): > def crash(ui, *args, **kwargs):
> raise Exception("oops") > raise Exception("oops")
> @command(b'abort', [], b'hg abort') > @command(b'abortcmd', [], b'hg abortcmd')
> def abort(ui, *args, **kwargs): > def abort(ui, *args, **kwargs):
> raise error.Abort(b"oops") > raise error.Abort(b"oops")
> EOF > EOF
$ abspath=`pwd`/myextension.py $ abspath=`pwd`/myextension.py
$ cat >> $HGRCPATH <<EOF $ cat >> $HGRCPATH <<EOF
> [extensions] > [extensions]
> blackbox= > blackbox=
[1] [1]
$ hg blackbox $ hg blackbox
1970/01/01 00:00:00 bob @0000000000000000000000000000000000000000 (5000)> add non-existent 1970/01/01 00:00:00 bob @0000000000000000000000000000000000000000 (5000)> add non-existent
1970/01/01 00:00:00 bob @0000000000000000000000000000000000000000 (5000)> add non-existent exited 1 after * seconds (glob) 1970/01/01 00:00:00 bob @0000000000000000000000000000000000000000 (5000)> add non-existent exited 1 after * seconds (glob)
1970/01/01 00:00:00 bob @0000000000000000000000000000000000000000 (5000)> blackbox 1970/01/01 00:00:00 bob @0000000000000000000000000000000000000000 (5000)> blackbox
abort exit code abort exit code
$ rm ./.hg/blackbox.log $ rm ./.hg/blackbox.log
$ hg abort 2> /dev/null $ hg abortcmd 2> /dev/null
[255] [255]
$ hg blackbox -l 2 $ hg blackbox -l 2
1970/01/01 00:00:00 bob @0000000000000000000000000000000000000000 (5000)> abort exited 255 after * seconds (glob) 1970/01/01 00:00:00 bob @0000000000000000000000000000000000000000 (5000)> abortcmd exited 255 after * seconds (glob)
1970/01/01 00:00:00 bob @0000000000000000000000000000000000000000 (5000)> blackbox -l 2 1970/01/01 00:00:00 bob @0000000000000000000000000000000000000000 (5000)> blackbox -l 2
unhandled exception unhandled exception
$ rm ./.hg/blackbox.log $ rm ./.hg/blackbox.log
$ hg crash 2> /dev/null $ hg crash 2> /dev/null
[1] [1]
$ hg blackbox -l 2 $ hg blackbox -l 2
1970/01/01 00:00:00 bob @0000000000000000000000000000000000000000 (5000)> crash exited 1 after * seconds (glob) 1970/01/01 00:00:00 bob @0000000000000000000000000000000000000000 (5000)> crash exited 1 after * seconds (glob)

tests/test-completion.t

Show all commands except debug commands Show all commands except debug commands
$ hg debugcomplete $ hg debugcomplete
abort
add add
addremove addremove
annotate annotate
archive archive
backout backout
bisect bisect
bookmarks bookmarks
branch branch
unbundle unbundle
unshelve unshelve
update update
verify verify
version version
Show all commands that start with "a" Show all commands that start with "a"
$ hg debugcomplete a $ hg debugcomplete a
abort
add add
addremove addremove
annotate annotate
archive archive
Do not show debug commands if there are other candidates Do not show debug commands if there are other candidates
$ hg debugcomplete d $ hg debugcomplete d
diff diff
Show an error if we use --options with an ambiguous abbreviation Show an error if we use --options with an ambiguous abbreviation
$ hg debugcomplete --options s $ hg debugcomplete --options s
hg: command 's' is ambiguous: hg: command 's' is ambiguous:
serve shelve showconfig status summary serve shelve showconfig status summary
[255] [255]
Show all commands + options Show all commands + options
$ hg debugcommands $ hg debugcommands
abort: dry-run
add: include, exclude, subrepos, dry-run add: include, exclude, subrepos, dry-run
addremove: similarity, subrepos, include, exclude, dry-run addremove: similarity, subrepos, include, exclude, dry-run
annotate: rev, follow, no-follow, text, user, file, date, number, changeset, line-number, skip, ignore-all-space, ignore-space-change, ignore-blank-lines, ignore-space-at-eol, include, exclude, template annotate: rev, follow, no-follow, text, user, file, date, number, changeset, line-number, skip, ignore-all-space, ignore-space-change, ignore-blank-lines, ignore-space-at-eol, include, exclude, template
archive: no-decode, prefix, rev, type, subrepos, include, exclude archive: no-decode, prefix, rev, type, subrepos, include, exclude
backout: merge, commit, no-commit, parent, rev, edit, tool, include, exclude, message, logfile, date, user backout: merge, commit, no-commit, parent, rev, edit, tool, include, exclude, message, logfile, date, user
bisect: reset, good, bad, skip, extend, command, noupdate bisect: reset, good, bad, skip, extend, command, noupdate
bookmarks: force, rev, delete, rename, inactive, list, template bookmarks: force, rev, delete, rename, inactive, list, template
branch: force, clean, rev branch: force, clean, rev

tests/test-help.t

Test short command list with verbose option Test short command list with verbose option
$ hg -v help shortlist $ hg -v help shortlist
Mercurial Distributed SCM Mercurial Distributed SCM
basic commands: basic commands:
abort abort an unfinished operation (EXPERIMENTAL)
add add the specified files on the next commit add add the specified files on the next commit
annotate, blame annotate, blame
show changeset information by line for each file show changeset information by line for each file
clone make a copy of an existing repository clone make a copy of an existing repository
commit, ci commit the specified files or all outstanding changes commit, ci commit the specified files or all outstanding changes
diff diff repository (or selected files) diff diff repository (or selected files)
export dump the header and diffs for one or more changesets export dump the header and diffs for one or more changesets
forget forget the specified files on the next commit forget forget the specified files on the next commit
</td><td> </td><td>
This is the topic to test omit indicating. This is the topic to test omit indicating.
</td></tr> </td></tr>
<tr><td colspan="2"><h2><a name="main" href="#main">Main Commands</a></h2></td></tr> <tr><td colspan="2"><h2><a name="main" href="#main">Main Commands</a></h2></td></tr>
<tr><td> <tr><td>
<a href="/help/abort">
abort
</a>
</td><td>
abort an unfinished operation (EXPERIMENTAL)
</td></tr>
<tr><td>
<a href="/help/add"> <a href="/help/add">
add add
</a> </a>
</td><td> </td><td>
add the specified files on the next commit add the specified files on the next commit
</td></tr> </td></tr>
<tr><td> <tr><td>
<a href="/help/annotate"> <a href="/help/annotate">

tests/test-hgweb-json.t

help/ shows help topics help/ shows help topics
$ request json-help $ request json-help
200 Script output follows 200 Script output follows
{ {
"earlycommands": [ "earlycommands": [
{ {
"summary": "abort an unfinished operation (EXPERIMENTAL)",
"topic": "abort"
},
{
"summary": "add the specified files on the next commit", "summary": "add the specified files on the next commit",
"topic": "add" "topic": "add"
}, },
{ {
"summary": "show changeset information by line for each file", "summary": "show changeset information by line for each file",
"topic": "annotate" "topic": "annotate"
}, },
{ {