Source code for ironic_lib.exception

# Copyright 2010 United States Government as represented by the
# Administrator of the National Aeronautics and Space Administration.
# 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
#    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.

"""Ironic base exception handling.

Includes decorator for re-raising Ironic-type exceptions.

SHOULD include dedicated exception logging.


import collections
from http import client as http_client
import json
import logging

from oslo_config import cfg
from oslo_utils import excutils

from ironic_lib.common.i18n import _

LOG = logging.getLogger(__name__)

exc_log_opts = [
                help=_('Used if there is a formatting error when generating '
                       'an exception message (a programming error). If True, '
                       'raise an exception; if False, use the unformatted '

CONF.register_opts(exc_log_opts, group='ironic_lib')

[docs] def list_opts(): """Entry point for oslo-config-generator.""" return [('ironic_lib', exc_log_opts)]
def _ensure_exception_kwargs_serializable(exc_class_name, kwargs): """Ensure that kwargs are serializable Ensure that all kwargs passed to exception constructor can be passed over RPC, by trying to convert them to JSON, or, as a last resort, to string. If it is not possible, unserializable kwargs will be removed, letting the receiver to handle the exception string as it is configured to. :param exc_class_name: a IronicException class name. :param kwargs: a dictionary of keyword arguments passed to the exception constructor. :returns: a dictionary of serializable keyword arguments. """ serializers = [(json.dumps, _('when converting to JSON')), (str, _('when converting to string'))] exceptions = collections.defaultdict(list) serializable_kwargs = {} for k, v in kwargs.items(): for serializer, msg in serializers: try: serializable_kwargs[k] = serializer(v) exceptions.pop(k, None) break except Exception as e: exceptions[k].append( '(%(serializer_type)s) %(e_type)s: %(e_contents)s' % {'serializer_type': msg, 'e_contents': e, 'e_type': e.__class__.__name__}) if exceptions: LOG.error("One or more arguments passed to the %(exc_class)s " "constructor as kwargs can not be serialized. The " "serialized arguments: %(serialized)s. These " "unserialized kwargs were dropped because of the " "exceptions encountered during their " "serialization:\n%(errors)s", dict(errors=';\n'.join("%s: %s" % (k, '; '.join(v)) for k, v in exceptions.items()), exc_class=exc_class_name, serialized=serializable_kwargs)) # We might be able to actually put the following keys' values into # format string, but there is no guarantee, drop it just in case. for k in exceptions: del kwargs[k] return serializable_kwargs
[docs] class IronicException(Exception): """Base Ironic Exception To correctly use this class, inherit from it and define a '_msg_fmt' property. That _msg_fmt will get printf'd with the keyword arguments provided to the constructor. If you need to access the message from an exception you should use str(exc) """ _msg_fmt = _("An unknown exception occurred.") code = 500 headers = {} safe = False def __init__(self, message=None, **kwargs): self.kwargs = _ensure_exception_kwargs_serializable( self.__class__.__name__, kwargs) if 'code' not in self.kwargs: try: self.kwargs['code'] = self.code except AttributeError: pass else: self.code = int(kwargs['code']) if not message: try: message = self._msg_fmt % kwargs except Exception: with excutils.save_and_reraise_exception() as ctxt: # kwargs doesn't match a variable in the message # log the issue and the kwargs prs = ', '.join('%s=%s' % pair for pair in kwargs.items()) LOG.exception('Exception in string format operation ' '(arguments %s)', prs) if not CONF.ironic_lib.fatal_exception_format_errors: # at least get the core message out if something # happened message = self._msg_fmt ctxt.reraise = False super(IronicException, self).__init__(message)
[docs] class InstanceDeployFailure(IronicException): _msg_fmt = _("Failed to deploy instance: %(reason)s")
[docs] class FileSystemNotSupported(IronicException): _msg_fmt = _("Failed to create a file system. " "File system %(fs)s is not supported.")
[docs] class InvalidMetricConfig(IronicException): _msg_fmt = _("Invalid value for metrics config option: %(reason)s")
[docs] class ServiceLookupFailure(IronicException): _msg_fmt = _("Cannot find %(service)s service through multicast")
[docs] class ServiceRegistrationFailure(IronicException): _msg_fmt = _("Cannot register %(service)s service: %(error)s")
[docs] class BadRequest(IronicException): code = http_client.BAD_REQUEST
[docs] class Unauthorized(IronicException): code = http_client.UNAUTHORIZED headers = {'WWW-Authenticate': 'Basic realm="Baremetal API"'}
[docs] class ConfigInvalid(IronicException): _msg_fmt = _("Invalid configuration file. %(error_msg)s")
[docs] class CatalogNotFound(IronicException): _msg_fmt = _("Service type %(service_type)s with endpoint type " "%(endpoint_type)s not found in keystone service catalog.")
[docs] class KeystoneUnauthorized(IronicException): _msg_fmt = _("Not authorized in Keystone.")
[docs] class KeystoneFailure(IronicException): pass
[docs] class MetricsNotSupported(IronicException): _msg_fmt = _("Metrics action is not supported. You may need to " "adjust the [metrics] section in ironic.conf.")