This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10737

errors: make InterventionRequired subclass Abort
ClosedPublic

Authored by martinvonz on May 19 2021, 1:47 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHGd9c71bbe20f7: errors: make InterventionRequired subclass Abort
Summary

The docstring for Abort says that it's for errors raised by commands
and InterventionRequired is definitely something raised by commands,
so it seems that it should be an Abort. This patch makes it so. It
adds a coarse_exit_code (in addition to the already existing
detailed_exit_code) to Abort to achieve that, since
InterventionRequired should result in a special exit code even when
the ui.detailed-exit-code config is not set.

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

martinvonz created this revision.May 19 2021, 1:47 AM
pulkit accepted this revision.May 20 2021, 4:42 AM
This revision is now accepted and ready to land.May 20 2021, 4:42 AM
martinvonz added a commit: rHGd9c71bbe20f7: errors: make InterventionRequired subclass Abort.May 20 2021, 9:21 AM
Closed by commit rHGd9c71bbe20f7: errors: make InterventionRequired subclass Abort (authored by martinvonz). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/error.py (21 lines)
Mmercurial/scmutil.py (8 lines)

Diff 28142

mercurial/error.py

def __init__(self, *args, **kw): def __init__(self, *args, **kw):
self.hint = kw.pop('hint', None) self.hint = kw.pop('hint', None)
super(Hint, self).__init__(*args, **kw) super(Hint, self).__init__(*args, **kw)
class Abort(Hint, Exception): class Abort(Hint, Exception):
"""Raised if a command needs to print an error and exit.""" """Raised if a command needs to print an error and exit."""
def __init__(self, message, hint=None, detailed_exit_code=None): def __init__(
self, message, hint=None, coarse_exit_code=None, detailed_exit_code=None
):
# type: (bytes, Optional[bytes]) -> None # type: (bytes, Optional[bytes]) -> None
self.message = message self.message = message
self.hint = hint self.hint = hint
self.coarse_exit_code = coarse_exit_code
self.detailed_exit_code = detailed_exit_code self.detailed_exit_code = detailed_exit_code
# Pass the message into the Exception constructor to help extensions # Pass the message into the Exception constructor to help extensions
# that look for exc.args[0]. # that look for exc.args[0].
Exception.__init__(self, message) Exception.__init__(self, message)
def __bytes__(self): def __bytes__(self):
return self.message return self.message
# type: (int) -> None # type: (int) -> None
self.status_code = status_code self.status_code = status_code
# Pass status code to superclass just so it becomes part of __bytes__ # Pass status code to superclass just so it becomes part of __bytes__
super(WorkerError, self).__init__(status_code) super(WorkerError, self).__init__(status_code)
__bytes__ = _tobytes __bytes__ = _tobytes
class InterventionRequired(Hint, Exception): class InterventionRequired(Abort):
"""Exception raised when a command requires human intervention.""" """Exception raised when a command requires human intervention."""
__bytes__ = _tobytes def __init__(self, message, hint=None):
super(InterventionRequired, self).__init__(
message, hint=hint, coarse_exit_code=1, detailed_exit_code=240
)
def format(self):
# type: () -> bytes
from .i18n import _
message = _(b"%s\n") % self.message
if self.hint:
message += _(b"(%s)\n") % self.hint
return message
class ConflictResolutionRequired(InterventionRequired): class ConflictResolutionRequired(InterventionRequired):
"""Exception raised when a continuable command required merge conflict resolution.""" """Exception raised when a continuable command required merge conflict resolution."""
def __init__(self, opname): def __init__(self, opname):
# type: (bytes) -> None # type: (bytes) -> None
from .i18n import _ from .i18n import _

mercurial/scmutil.py

ui.error(b"\n%r\n" % pycompat.bytestr(stringutil.ellipsis(msg))) ui.error(b"\n%r\n" % pycompat.bytestr(stringutil.ellipsis(msg)))
except error.CensoredNodeError as inst: except error.CensoredNodeError as inst:
ui.error(_(b"abort: file censored %s\n") % inst) ui.error(_(b"abort: file censored %s\n") % inst)
except error.StorageError as inst: except error.StorageError as inst:
ui.error(_(b"abort: %s\n") % inst) ui.error(_(b"abort: %s\n") % inst)
if inst.hint: if inst.hint:
ui.error(_(b"(%s)\n") % inst.hint) ui.error(_(b"(%s)\n") % inst.hint)
detailed_exit_code = 50 detailed_exit_code = 50
except error.InterventionRequired as inst:
ui.error(b"%s\n" % inst)
if inst.hint:
ui.error(_(b"(%s)\n") % inst.hint)
detailed_exit_code = 240
coarse_exit_code = 1
except error.WdirUnsupported: except error.WdirUnsupported:
ui.error(_(b"abort: working directory revision cannot be specified\n")) ui.error(_(b"abort: working directory revision cannot be specified\n"))
except error.Abort as inst: except error.Abort as inst:
if inst.detailed_exit_code is not None: if inst.detailed_exit_code is not None:
detailed_exit_code = inst.detailed_exit_code detailed_exit_code = inst.detailed_exit_code
if inst.coarse_exit_code is not None:
coarse_exit_code = inst.coarse_exit_code
ui.error(inst.format()) ui.error(inst.format())
except error.WorkerError as inst: except error.WorkerError as inst:
# Don't print a message -- the worker already should have # Don't print a message -- the worker already should have
return inst.status_code return inst.status_code
except ImportError as inst: except ImportError as inst:
ui.error(_(b"abort: %s\n") % stringutil.forcebytestr(inst)) ui.error(_(b"abort: %s\n") % stringutil.forcebytestr(inst))
m = stringutil.forcebytestr(inst).split()[-1] m = stringutil.forcebytestr(inst).split()[-1]
if m in b"mpatch bdiff".split(): if m in b"mpatch bdiff".split():