This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10758

errors: make exit codes class variables instead
ClosedPublic

Authored by martinvonz on May 20 2021, 11:21 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG73f52278a158: errors: make exit codes class variables instead
Summary

Kyle pointed out to me that we can simply make the exit codes class
variables. Python provides some magic for making them accessible as
instance variables.

This also makes it easier to let subclasses of existing errors
override the exit codes by letting them simply define their own values
as class variables. That means that there's no need to pass them into
the superclass's constructor arguments, so the superclass doesn't need
to expose the them as arguments. (Making a subclass set a different
exit code for a subclass of StorageError was actually the goal with
my recent series.)

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 20 2021, 11:21 AM
martinvonz added a commit: rHG73f52278a158: errors: make exit codes class variables instead.May 21 2021, 12:35 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG73f52278a158: errors: make exit codes class variables instead (authored by martinvonz). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/error.py (62 lines)

Diff 28178

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 Error(Hint, Exception): class Error(Hint, Exception):
"""Base class for Mercurial errors.""" """Base class for Mercurial errors."""
def __init__( coarse_exit_code = None
self, message, hint=None, coarse_exit_code=None, detailed_exit_code=None detailed_exit_code = None
):
def __init__(self, message, hint=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
# 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
if pycompat.ispy3: if pycompat.ispy3:
class StorageError(Error): class StorageError(Error):
"""Raised when an error occurs in a storage layer. """Raised when an error occurs in a storage layer.
Usually subclassed by a storage-specific exception. Usually subclassed by a storage-specific exception.
""" """
def __init__(self, message, hint=None): detailed_exit_code = 50
super(StorageError, self).__init__(
message, hint=hint, detailed_exit_code=50
)
class RevlogError(StorageError): class RevlogError(StorageError):
pass pass
class SidedataHashError(RevlogError): class SidedataHashError(RevlogError):
def __init__(self, key, expected, got): def __init__(self, key, expected, got):
super(WorkerError, self).__init__(status_code) super(WorkerError, self).__init__(status_code)
__bytes__ = _tobytes __bytes__ = _tobytes
class InterventionRequired(Abort): class InterventionRequired(Abort):
"""Exception raised when a command requires human intervention.""" """Exception raised when a command requires human intervention."""
def __init__(self, message, hint=None): coarse_exit_code = 1
super(InterventionRequired, self).__init__( detailed_exit_code = 240
message, hint=hint, coarse_exit_code=1, detailed_exit_code=240
)
def format(self): def format(self):
# type: () -> bytes # type: () -> bytes
from .i18n import _ from .i18n import _
message = _(b"%s\n") % self.message message = _(b"%s\n") % self.message
if self.hint: if self.hint:
message += _(b"(%s)\n") % self.hint message += _(b"(%s)\n") % self.hint
class InputError(Abort): class InputError(Abort):
"""Indicates that the user made an error in their input. """Indicates that the user made an error in their input.
Examples: Invalid command, invalid flags, invalid revision. Examples: Invalid command, invalid flags, invalid revision.
""" """
def __init__(self, message, hint=None): detailed_exit_code = 10
super(InputError, self).__init__(
message, hint=hint, detailed_exit_code=10
)
class StateError(Abort): class StateError(Abort):
"""Indicates that the operation might work if retried in a different state. """Indicates that the operation might work if retried in a different state.
Examples: Unresolved merge conflicts, unfinished operations. Examples: Unresolved merge conflicts, unfinished operations.
""" """
def __init__(self, message, hint=None): detailed_exit_code = 20
super(StateError, self).__init__(
message, hint=hint, detailed_exit_code=20
)
class CanceledError(Abort): class CanceledError(Abort):
"""Indicates that the user canceled the operation. """Indicates that the user canceled the operation.
Examples: Close commit editor with error status, quit chistedit. Examples: Close commit editor with error status, quit chistedit.
""" """
def __init__(self, message, hint=None): detailed_exit_code = 250
super(CanceledError, self).__init__(
message, hint=hint, detailed_exit_code=250
)
class SecurityError(Abort): class SecurityError(Abort):
"""Indicates that some aspect of security failed. """Indicates that some aspect of security failed.
Examples: Bad server credentials, expired local credentials for network Examples: Bad server credentials, expired local credentials for network
filesystem, mismatched GPG signature, DoS protection. filesystem, mismatched GPG signature, DoS protection.
""" """
def __init__(self, message, hint=None): detailed_exit_code = 150
super(SecurityError, self).__init__(
message, hint=hint, detailed_exit_code=150
)
class HookLoadError(Abort): class HookLoadError(Abort):
"""raised when loading a hook fails, aborting an operation """raised when loading a hook fails, aborting an operation
Exists to allow more specialized catching.""" Exists to allow more specialized catching."""
class HookAbort(Abort): class HookAbort(Abort):
"""raised when a validation hook fails, aborting an operation """raised when a validation hook fails, aborting an operation
Exists to allow more specialized catching.""" Exists to allow more specialized catching."""
def __init__(self, message, hint=None): detailed_exit_code = 40
super(HookAbort, self).__init__(
message, hint=hint, detailed_exit_code=40
)
class ConfigError(Abort): class ConfigError(Abort):
"""Exception raised when parsing config files""" """Exception raised when parsing config files"""
detailed_exit_code = 30
def __init__(self, message, location=None, hint=None): def __init__(self, message, location=None, hint=None):
# type: (bytes, Optional[bytes], Optional[bytes]) -> None # type: (bytes, Optional[bytes], Optional[bytes]) -> None
super(ConfigError, self).__init__( super(ConfigError, self).__init__(message, hint=hint)
message, hint=hint, detailed_exit_code=30
)
self.location = location self.location = location
def format(self): def format(self):
# type: () -> bytes # type: () -> bytes
from .i18n import _ from .i18n import _
if self.location is not None: if self.location is not None:
message = _(b"config error at %s: %s\n") % ( message = _(b"config error at %s: %s\n") % (
from .i18n import _ from .i18n import _
Abort.__init__(self, _(b'response expected')) Abort.__init__(self, _(b'response expected'))
class RemoteError(Abort): class RemoteError(Abort):
"""Exception raised when interacting with a remote repo fails""" """Exception raised when interacting with a remote repo fails"""
def __init__(self, message, hint=None): detailed_exit_code = 100
super(RemoteError, self).__init__(
message, hint=hint, detailed_exit_code=100
)
class OutOfBandError(RemoteError): class OutOfBandError(RemoteError):
"""Exception raised when a remote repo reports failure""" """Exception raised when a remote repo reports failure"""
def __init__(self, message=None, hint=None): def __init__(self, message=None, hint=None):
from .i18n import _ from .i18n import _
if message: if message:
# Abort.format() adds a trailing newline # Abort.format() adds a trailing newline
message = _(b"remote error:\n%s") % message.rstrip(b'\n') message = _(b"remote error:\n%s") % message.rstrip(b'\n')
else: else:
message = _(b"remote error") message = _(b"remote error")
super(OutOfBandError, self).__init__(message, hint=hint) super(OutOfBandError, self).__init__(message, hint=hint)
class ParseError(Abort): class ParseError(Abort):
"""Raised when parsing config files and {rev,file}sets (msg[, pos])""" """Raised when parsing config files and {rev,file}sets (msg[, pos])"""
detailed_exit_code = 10
def __init__(self, message, location=None, hint=None): def __init__(self, message, location=None, hint=None):
# type: (bytes, Optional[Union[bytes, int]], Optional[bytes]) -> None # type: (bytes, Optional[Union[bytes, int]], Optional[bytes]) -> None
super(ParseError, self).__init__( super(ParseError, self).__init__(message, hint=hint)
message, hint=hint, detailed_exit_code=10
)
self.location = location self.location = location
def format(self): def format(self):
# type: () -> bytes # type: () -> bytes
from .i18n import _ from .i18n import _
if self.location is not None: if self.location is not None:
message = _(b"hg: parse error at %s: %s\n") % ( message = _(b"hg: parse error at %s: %s\n") % (