# taskflow.types.failure

# Source code for taskflow.types.failure

    #    Copyright (C) 2014 Yahoo! Inc. All Rights Reserved.
    #
    #    Licensed under the Apache License, Version 2.0 (the "License"); you may
    #    not use this file except in compliance with the License. You may obtain
    #    a copy of the License at
    #
    #         http://www.apache.org/licenses/LICENSE-2.0
    #
    #    Unless required by applicable law or agreed to in writing, software
    #    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
    #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
    #    License for the specific language governing permissions and limitations
    #    under the License.

    import collections
    import copy
    import io
    import os
    import sys
    import traceback

    from oslo_utils import reflection

    from taskflow import exceptions as exc
    from taskflow.utils import iter_utils
    from taskflow.utils import schema_utils as su

    def _copy_exc_info(exc_info):
        if exc_info is None:
            return None
        exc_type, exc_value, tb = exc_info
        # NOTE(imelnikov): there is no need to copy the exception type, and
        # a shallow copy of the value is fine and we can't copy the traceback since
        # it contains reference to the internal stack frames...
        return (exc_type, copy.copy(exc_value), tb)

    def _are_equal_exc_info_tuples(ei1, ei2):
        if ei1 == ei2:
            return True
        if ei1 is None or ei2 is None:
            return False  # if both are None, we returned True above

        # NOTE(imelnikov): we can't compare exceptions with '=='
        # because we want exc_info be equal to it's copy made with
        # copy_exc_info above.
        if ei1[0] is not ei2[0]:
            return False
        # NOTE(dhellmann): The flake8/pep8 error E721 does not apply here
        # because we want the types to be exactly the same, not just have
        # one be inherited from the other.
        if not all((type(ei1[1]) == type(ei2[1]),  # noqa: E721
                    str(ei1[1]) == str(ei2[1]),
                    repr(ei1[1]) == repr(ei2[1]))):
            return False
        if ei1[2] == ei2[2]:
            return True
        tb1 = traceback.format_tb(ei1[2])
        tb2 = traceback.format_tb(ei2[2])
        return tb1 == tb2

    class Failure():
        """An immutable object that represents failure.

        Failure objects encapsulate exception information so that they can be
        re-used later to re-raise, inspect, examine, log, print, serialize,
        deserialize...

        One example where they are depended upon is in the WBE engine. When a
        remote worker throws an exception, the WBE based engine will receive that
        exception and desire to reraise it to the user/caller of the WBE based
        engine for appropriate handling (this matches the behavior of non-remote
        engines). To accomplish this a failure object (or a
        :py:meth:`~.Failure.to_dict` form) would be sent over the WBE channel
        and the WBE based engine would deserialize it and use this objects
        :meth:`.reraise` method to cause an exception that contains
        similar/equivalent information as the original exception to be reraised,
        allowing the user (or the WBE engine itself) to then handle the worker
        failure/exception as they desire.

        For those who are curious, here are a few reasons why the original
        exception itself *may* not be reraised and instead a reraised wrapped
        failure exception object will be instead. These explanations are *only*
        applicable when a failure object is serialized and deserialized (when it is
        retained inside the python process that the exception was created in the
        the original exception can be reraised correctly without issue).

        * Traceback objects are not serializable/recreatable, since they contain
          references to stack frames at the location where the exception was
          raised. When a failure object is serialized and sent across a channel
          and recreated it is *not* possible to restore the original traceback and
          originating stack frames.
        * The original exception *type* can not be guaranteed to be found, workers
          can run code that is not accessible/available when the failure is being
          deserialized. Even if it was possible to use pickle safely it would not
          be possible to find the originating exception or associated code in this
          situation.
        * The original exception *type* can not be guaranteed to be constructed in
          a *correct* manner. At the time of failure object creation the exception
          has already been created and the failure object can not assume it has
          knowledge (or the ability) to recreate the original type of the captured
          exception (this is especially hard if the original exception was created
          via a complex process via some custom exception constructor).
        * The original exception *type* can not be guaranteed to be constructed in
          a *safe* manner. Importing *foreign* exception types dynamically can be
          problematic when not done correctly and in a safe manner; since failure
          objects can capture any exception it would be *unsafe* to try to import
          those exception types namespaces and modules on the receiver side
          dynamically (this would create similar issues as the ``pickle`` module in
          python has where foreign modules can be imported, causing those modules
          to have code ran when this happens, and this can cause issues and
          side-effects that the receiver would not have intended to have caused).

        TODO(harlowja): use parts of :pybug:`17911` and the
        backport at https://pypi.org/project/traceback2/ to (hopefully)
        simplify the methods and contents of this object...
        """
        DICT_VERSION = 1

        BASE_EXCEPTIONS = ('BaseException', 'Exception')
        """
        Root exceptions of all other python exceptions.

        See: https://docs.python.org/2/library/exceptions.html
        """

        #: Expected failure schema (in json schema format).
        SCHEMA = {
            "$ref": "#/definitions/cause",
            "definitions": {
                "cause": {
                    "type": "object",
                    'properties': {
                        'version': {
                            "type": "integer",
                            "minimum": 0,
                        },
                        'exc_args': {
                            "type": "array",
                            "minItems": 0,
                        },
                        'exception_str': {
                            "type": "string",
                        },
                        'traceback_str': {
                            "type": "string",
                        },
                        'exc_type_names': {
                            "type": "array",
                            "items": {
                                "type": "string",
                            },
                            "minItems": 1,
                        },
                        'causes': {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/cause",
                            },
                        }
                    },
                    "required": [
                        "exception_str",
                        'traceback_str',
                        'exc_type_names',
                    ],
                    "additionalProperties": True,
                },
            },
        }

        def __init__(self, exc_info=None, **kwargs):
            if not kwargs:
                if exc_info is None:
                    exc_info = sys.exc_info()
                else:
                    # This should always be the (type, value, traceback) tuple,
                    # either from a prior sys.exc_info() call or from some other
                    # creation...
                    if len(exc_info) != 3:
                        raise ValueError("Provided 'exc_info' must contain three"
                                         " elements")
                self._exc_info = exc_info
                self._exc_args = tuple(getattr(exc_info[1], 'args', []))
                self._exc_type_names = tuple(
                    reflection.get_all_class_names(exc_info[0], up_to=Exception))
                if not self._exc_type_names:
                    raise TypeError("Invalid exception type '%s' (%s)"
                                    % (exc_info[0], type(exc_info[0])))
                self._exception_str = str(self._exc_info[1])
                self._traceback_str = ''.join(
                    traceback.format_tb(self._exc_info[2]))
                self._causes = kwargs.pop('causes', None)
            else:
                self._causes = kwargs.pop('causes', None)
                self._exc_info = exc_info
                self._exc_args = tuple(kwargs.pop('exc_args', []))
                self._exception_str = kwargs.pop('exception_str')
                self._exc_type_names = tuple(kwargs.pop('exc_type_names', []))
                self._traceback_str = kwargs.pop('traceback_str', None)
                if kwargs:
                    raise TypeError(
                        'Failure.__init__ got unexpected keyword argument(s): %s'
                        % ', '.join(kwargs.keys()))

        @classmethod
        def from_exception(cls, exception):
            """Creates a failure object from a exception instance."""
            exc_info = (
                type(exception),
                exception,
                getattr(exception, '__traceback__', None)
            )
            return cls(exc_info=exc_info)

        @classmethod
        def validate(cls, data):
            """Validate input data matches expected failure ``dict`` format."""
            try:
                su.schema_validate(data, cls.SCHEMA)
            except su.ValidationError as e:
                raise exc.InvalidFormat("Failure data not of the"
                                        " expected format: %s" % (e.message), e)
            else:
                # Ensure that all 'exc_type_names' originate from one of
                # BASE_EXCEPTIONS, because those are the root exceptions that
                # python mandates/provides and anything else is invalid...
                causes = collections.deque([data])
                while causes:
                    cause = causes.popleft()
                    root_exc_type = cause['exc_type_names'][-1]
                    if root_exc_type not in cls.BASE_EXCEPTIONS:
                        raise exc.InvalidFormat(
                            "Failure data 'exc_type_names' must"
                            " have an initial exception type that is one"
                            " of %s types: '%s' is not one of those"
                            " types" % (cls.BASE_EXCEPTIONS, root_exc_type))
                    sub_causes = cause.get('causes')
                    if sub_causes:
                        causes.extend(sub_causes)

        def _matches(self, other):
            if self is other:
                return True
            return (self._exc_type_names == other._exc_type_names
                    and self.exception_args == other.exception_args
                    and self.exception_str == other.exception_str
                    and self.traceback_str == other.traceback_str
                    and self.causes == other.causes)

        def matches(self, other):
            """Checks if another object is equivalent to this object.

            :returns: checks if another object is equivalent to this object
            :rtype: boolean
            """
            if not isinstance(other, Failure):
                return False
            if self.exc_info is None or other.exc_info is None:
                return self._matches(other)
            else:
                return self == other

        def __eq__(self, other):
            if not isinstance(other, Failure):
                return NotImplemented
            return (self._matches(other) and
                    _are_equal_exc_info_tuples(self.exc_info, other.exc_info))

        def __ne__(self, other):
            return not (self == other)

        # NOTE(imelnikov): obj.__hash__() should return same values for equal
        # objects, so we should redefine __hash__. Failure equality semantics
        # is a bit complicated, so for now we just mark Failure objects as
        # unhashable. See python docs on object.__hash__  for more info:
        # http://docs.python.org/2/reference/datamodel.html#object.__hash__
        __hash__ = None

        @property
        def exception(self):
            """Exception value, or none if exception value is not present.

            Exception value may be lost during serialization.
            """
            if self._exc_info:
                return self._exc_info[1]
            else:
                return None

        @property
        def exception_str(self):
            """String representation of exception."""
            return self._exception_str

        @property
        def exception_args(self):
            """Tuple of arguments given to the exception constructor."""
            return self._exc_args

        @property
        def exc_info(self):
            """Exception info tuple or none.

            See: https://docs.python.org/2/library/sys.html#sys.exc_info for what
                 the contents of this tuple are (if none, then no contents can
                 be examined).
            """
            return self._exc_info

        @property
        def traceback_str(self):
            """Exception traceback as string."""
            return self._traceback_str

        @staticmethod
        def reraise_if_any(failures):
            """Re-raise exceptions if argument is not empty.

            If argument is empty list/tuple/iterator, this method returns
            None. If argument is converted into a list with a
            single ``Failure`` object in it, that failure is reraised. Else, a
            :class:`~taskflow.exceptions.WrappedFailure` exception
            is raised with the failure list as causes.
            """
            if not isinstance(failures, (list, tuple)):
                # Convert generators/other into a list...
                failures = list(failures)
            if len(failures) == 1:
                failures[0].reraise()
            elif len(failures) > 1:
                raise exc.WrappedFailure(failures)

        def reraise(self):
            """Re-raise captured exception."""
            if self._exc_info:
                tp, value, tb = self._exc_info
                if value is None:
                    value = tp()
                if value.__traceback__ is not tb:
                    raise value.with_traceback(tb)
                raise value
            else:
                raise exc.WrappedFailure([self])

        def check(self, *exc_classes):
            """Check if any of ``exc_classes`` caused the failure.

            Arguments of this method can be exception types or type
            names (stings). If captured exception is instance of
            exception of given type, the corresponding argument is
            returned. Else, None is returned.
            """
            for cls in exc_classes:
                if isinstance(cls, type):
                    err = reflection.get_class_name(cls)
                else:
                    err = cls
                if err in self._exc_type_names:
                    return cls
            return None

        @classmethod
        def _extract_causes_iter(cls, exc_val):
            seen = [exc_val]
            causes = [exc_val]
            while causes:
                exc_val = causes.pop()
                if exc_val is None:
                    continue
                # See: https://www.python.org/dev/peps/pep-3134/ for why/what
                # these are...
                #
                # '__cause__' attribute for explicitly chained exceptions
                # '__context__' attribute for implicitly chained exceptions
                # '__traceback__' attribute for the traceback
                #
                # See: https://www.python.org/dev/peps/pep-0415/ for why/what
                # the '__suppress_context__' is/means/implies...
                suppress_context = getattr(exc_val,
                                           '__suppress_context__', False)
                if suppress_context:
                    attr_lookups = ['__cause__']
                else:
                    attr_lookups = ['__cause__', '__context__']
                nested_exc_val = None
                for attr_name in attr_lookups:
                    attr_val = getattr(exc_val, attr_name, None)
                    if attr_val is None:
                        continue
                    if attr_val not in seen:
                        nested_exc_val = attr_val
                        break
                if nested_exc_val is not None:
                    exc_info = (
                        type(nested_exc_val),
                        nested_exc_val,
                        getattr(nested_exc_val, '__traceback__', None),
                    )
                    seen.append(nested_exc_val)
                    causes.append(nested_exc_val)
                    yield cls(exc_info=exc_info)

        @property
        def causes(self):
            """Tuple of all *inner* failure *causes* of this failure.

            NOTE(harlowja): Does **not** include the current failure (only
            returns connected causes of this failure, if any). This property
            is really only useful on 3.x or newer versions of python as older
            versions do **not** have associated causes (the tuple will **always**
            be empty on 2.x versions of python).

            Refer to :pep:`3134` and :pep:`409` and :pep:`415` for what
            this is examining to find failure causes.
            """
            if self._causes is not None:
                return self._causes
            else:
                self._causes = tuple(self._extract_causes_iter(self.exception))
                return self._causes

        def __str__(self):
            return self.pformat()

        def pformat(self, traceback=False):
            """Pretty formats the failure object into a string."""
            buf = io.StringIO()
            if not self._exc_type_names:
                buf.write('Failure: %s' % (self._exception_str))
            else:
                buf.write('Failure: {}: {}'.format(self._exc_type_names[0],
                                                   self._exception_str))
            if traceback:
                if self._traceback_str is not None:
                    traceback_str = self._traceback_str.rstrip()
                else:
                    traceback_str = None
                if traceback_str:
                    buf.write(os.linesep)
                    buf.write('Traceback (most recent call last):')
                    buf.write(os.linesep)
                    buf.write(traceback_str)
                else:
                    buf.write(os.linesep)
                    buf.write('Traceback not available.')
            return buf.getvalue()

        def __iter__(self):
            """Iterate over exception type names."""
            yield from self._exc_type_names

        def __getstate__(self):
            dct = self.to_dict()
            if self._exc_info:
                # Avoids 'TypeError: can't pickle traceback objects'
                dct['exc_info'] = self._exc_info[0:2]
            return dct

        def __setstate__(self, dct):
            self._exception_str = dct['exception_str']
            if 'exc_args' in dct:
                self._exc_args = tuple(dct['exc_args'])
            else:
                # Guess we got an older version somehow, before this
                # was added, so at that point just set to an empty tuple...
                self._exc_args = ()
            self._traceback_str = dct['traceback_str']
            self._exc_type_names = dct['exc_type_names']
            if 'exc_info' in dct:
                # Tracebacks can't be serialized/deserialized, but since we
                # provide a traceback string (and more) this should be
                # acceptable...
                #
                # TODO(harlowja): in the future we could do something like
                # what the twisted people have done, see for example
                # twisted-13.0.0/twisted/python/failure.py#L89 for how they
                # created a fake traceback object...
                self._exc_info = tuple(iter_utils.fill(dct['exc_info'], 3))
            else:
                self._exc_info = None
            causes = dct.get('causes')
            if causes is not None:
                causes = tuple(self.from_dict(d) for d in causes)
            self._causes = causes

        @classmethod
        def from_dict(cls, data):
            """Converts this from a dictionary to a object."""
            data = dict(data)
            version = data.pop('version', None)
            if version != cls.DICT_VERSION:
                raise ValueError('Invalid dict version of failure object: %r'
                                 % version)
            causes = data.get('causes')
            if causes is not None:
                data['causes'] = tuple(cls.from_dict(d) for d in causes)
            return cls(**data)

        def to_dict(self, include_args=True):
            """Converts this object to a dictionary.

            :param include_args: boolean indicating whether to include the
                                 exception args in the output.
            """
            return {
                'exception_str': self.exception_str,
                'traceback_str': self.traceback_str,
                'exc_type_names': list(self),
                'version': self.DICT_VERSION,
                'exc_args': self.exception_args if include_args else tuple(),
                'causes': [f.to_dict() for f in self.causes],
            }

        def copy(self):
            """Copies this object."""
            return Failure(exc_info=_copy_exc_info(self.exc_info),
                           exception_str=self.exception_str,
                           traceback_str=self.traceback_str,
                           exc_args=self.exception_args,
                           exc_type_names=self._exc_type_names[:],
                           causes=self._causes)

this page last updated: 2026-01-23 20:25:53

Except where otherwise noted, this document is licensed under Creative Commons Attribution 3.0 License. See all OpenStack Legal Documents.

found an error? report a bug