X-Git-Url: https://code.grnet.gr/git/ganeti-local/blobdiff_plain/a8083063386109da1f7d95cb441152cad79bc15f..19bed813438c89914ead80e5f3a8e57fcb5bd5f2:/lib/errors.py?ds=sidebyside diff --git a/lib/errors.py b/lib/errors.py index 7bcd564..9fd9868 100644 --- a/lib/errors.py +++ b/lib/errors.py @@ -1,4 +1,4 @@ -#!/usr/bin/python +# # # Copyright (C) 2006, 2007 Google Inc. @@ -98,17 +98,15 @@ class RemoteError(GenericError): pass -class InvalidOS(GenericError): - """Missing OS on node. - - This is raised when an OS exists on the master (or is otherwise - requested to the code) but not on the target node. +class SignatureError(GenericError): + """Error authenticating a remote message. - This exception has two arguments: - - the name of the os - - the reason why we consider this an invalid OS (text of error message) + This is raised when the hmac signature on a message doesn't verify correctly + to the message itself. It can happen because of network unreliability or + because of spurious traffic. """ + pass class ParameterError(GenericError): @@ -129,11 +127,19 @@ class OpPrereqError(GenericError): """ + class OpExecError(GenericError): """Error during OpCode execution. """ + +class OpRetryError(OpExecError): + """Error during OpCode execution, action can be retried. + + """ + + class OpCodeUnknown(GenericError): """Unknown opcode submitted. @@ -142,6 +148,29 @@ class OpCodeUnknown(GenericError): """ + +class JobLost(GenericError): + """Submitted job lost. + + The job was submitted but it cannot be found in the current job + list. + + """ + + +class ResolverError(GenericError): + """Host name cannot be resolved. + + This is not a normal situation for Ganeti, as we rely on having a + working resolver. + + The non-resolvable hostname is available as the first element of the + args tuple; the other two elements of the tuple are the first two + args of the socket.gaierror exception (error code and description). + + """ + + class HooksFailure(GenericError): """A generic hook failure. @@ -149,6 +178,7 @@ class HooksFailure(GenericError): """ + class HooksAbort(HooksFailure): """A required hook has failed. @@ -159,12 +189,185 @@ class HooksAbort(HooksFailure): """ + class UnitParseError(GenericError): """Unable to parse size unit. """ +class TypeEnforcementError(GenericError): + """Unable to enforce data type. + + """ + + class SshKeyError(GenericError): """Invalid SSH key. + + """ + + +class TagError(GenericError): + """Generic tag error. + + The argument to this exception will show the exact error. + + """ + + +class CommandError(GenericError): + """External command error. + + """ + + +class StorageError(GenericError): + """Storage-related exception. + + """ + + +class InotifyError(GenericError): + """Error raised when there is a failure setting up an inotify watcher. + + """ + + +class QuitGanetiException(Exception): + """Signal that Ganeti that it must quit. + + This is not necessarily an error (and thus not a subclass of + GenericError), but it's an exceptional circumstance and it is thus + treated. This instance should be instantiated with two values. The + first one will specify the return code to the caller, and the second + one will be the returned result (either as an error or as a normal + result). Usually only the leave cluster rpc call should return + status True (as there it's expected we quit), every other call will + return status False (as a critical error was encountered). + + Examples:: + + # Return a result of "True" to the caller, but quit ganeti afterwards + raise QuitGanetiException(True, None) + # Send an error to the caller, and quit ganeti + raise QuitGanetiException(False, "Fatal safety violation, shutting down") + + """ + + +class JobQueueError(GenericError): + """Job queue error. + + """ + + +class JobQueueDrainError(JobQueueError): + """Job queue is marked for drain error. + + This is raised when a job submission attempt is made but the queue + is marked for drain. + + """ + + +class JobQueueFull(JobQueueError): + """Job queue full error. + + Raised when job queue size reached its hard limit. + + """ + + +class ConfdFatalError(GenericError): + """A fatal failure in Ganeti confd. + + Events that compromise the ability of confd to proceed further. + (for example: inability to load the config file) + + """ + + +class ConfdRequestError(GenericError): + """A request error in Ganeti confd. + + Events that should make confd abort the current request and proceed serving + different ones. + + """ + + +class ConfdMagicError(GenericError): + """A magic fourcc error in Ganeti confd. + + Errors processing the fourcc in ganeti confd datagrams. + + """ + + +class ConfdClientError(GenericError): + """A magic fourcc error in Ganeti confd. + + Errors in the confd client library. + + """ + + +class UdpDataSizeError(GenericError): + """UDP payload too big. + + """ + + +# errors should be added above + + +def GetErrorClass(name): + """Return the class of an exception. + + Given the class name, return the class itself. + + @type name: str + @param name: the exception name + @rtype: class + @return: the actual class, or None if not found + + """ + item = globals().get(name, None) + if item is not None: + if not (isinstance(item, type(Exception)) and + issubclass(item, GenericError)): + item = None + return item + + +def EncodeException(err): + """Encodes an exception into a format that L{MaybeRaise} will recognise. + + The passed L{err} argument will be formatted as a tuple (exception + name, arguments) that the MaybeRaise function will recognise. + + @type err: GenericError child + @param err: usually a child of GenericError (but any exception + will be accepted) + @rtype: tuple + @return: tuple of (exception name, exception arguments) + + """ + return (err.__class__.__name__, err.args) + + +def MaybeRaise(result): + """Is this looks like an encoded Ganeti exception, raise it. + + This function tries to parse the passed argument and if it looks + like an encoding done by EncodeException, it will re-raise it. + """ + tlt = (tuple, list) + if (isinstance(result, tlt) and len(result) == 2 and + isinstance(result[1], tlt)): + # custom ganeti errors + err_class = GetErrorClass(result[0]) + if err_class is not None: + raise err_class, tuple(result[1])