exception.py

Go to the documentation of this file.

# Copyright (c) 2013-2014 Rackspace, Inc.
#
# 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.
 
"""
Barbican exception subclasses
"""
 
from barbican import i18n as u
 
_FATAL_EXCEPTION_FORMAT_ERRORS = False
 
 
class BarbicanException(Exception):
    """Base Barbican Exception
 
    To correctly use this class, inherit from it and define
    a 'message' property. That message will get printf'd
    with the keyword arguments provided to the constructor.
    """
    message = u._("An unknown exception occurred")
 
    def __init__(self, message_arg=None, *args, **kwargs):
        if not message_arg:
            message_arg = self.messagemessage
        try:
            self.messagemessage = message_arg % kwargs
        except Exception as e:
            if _FATAL_EXCEPTION_FORMAT_ERRORS:
                raise e
            else:
                # at least get the core message out if something happened
                pass
        super(BarbicanException, self).__init__(self.messagemessage)
 
 
class BarbicanHTTPException(BarbicanException):
    """Base Barbican Exception to handle HTTP responses
 
    To correctly use this class, inherit from it and define the following
    properties:
 
    - message: The message that will be displayed in the server log.
    - client_message: The message that will actually be outputted to the
                      client.
    - status_code: The HTTP status code that should be returned.
                   The default status code is 500.
    """
    client_message = u._("failure seen - please contact site administrator.")
    status_code = 500
 
    def __init__(self, message_arg=None, client_message=None, *args, **kwargs):
        if not client_message:
            client_message = self.client_messageclient_message
        try:
            self.client_messageclient_message = client_message % kwargs
        except Exception as e:
            if _FATAL_EXCEPTION_FORMAT_ERRORS:
                raise e
            else:
                # at least get the core message out if something happened
                pass
        super(BarbicanHTTPException, self).__init__(
            message_arg, self.client_messageclient_message, *args, **kwargs)
 
 
class MissingArgumentError(BarbicanException):
    message = u._("Missing required argument.")
 
 
class MissingMetadataField(BarbicanHTTPException):
    message = u._("Missing required metadata field for %(required)s")
    client_message = message
    status_code = 400
 
 
class InvalidMetadataRequest(BarbicanHTTPException):
    message = u._("Invalid Metadata. Keys and Values must be Strings.")
    client_message = message
    status_code = 400
 
 
class InvalidMetadataKey(BarbicanHTTPException):
    message = u._("Invalid Key. Key must be URL safe.")
    client_message = message
    status_code = 400
 
 
class InvalidSubjectDN(BarbicanHTTPException):
    message = u._("Invalid subject DN: %(subject_dn)s")
    client_message = message
    status_code = 400
 
 
class InvalidContainer(BarbicanHTTPException):
    message = u._("Invalid container: %(reason)s")
    client_message = message
    status_code = 400
 
 
class InvalidExtensionsData(BarbicanHTTPException):
    message = u._("Invalid extensions data.")
    client_message = message
    status_code = 400
 
 
class InvalidCMCData(BarbicanHTTPException):
    message = u._("Invalid CMC Data")
    client_message = message
    status_code = 400
 
 
class InvalidPKCS10Data(BarbicanHTTPException):
    message = u._("Invalid PKCS10 Data: %(reason)s")
    client_message = message
    status_code = 400
 
 
class InvalidCertificateRequestType(BarbicanHTTPException):
    message = u._("Invalid Certificate Request Type")
    client_message = message
    status_code = 400
 
 
class CertificateExtensionsNotSupported(BarbicanHTTPException):
    message = u._("Extensions are not yet supported.  "
                  "Specify a valid profile instead.")
    client_message = message
    status_code = 400
 
 
class FullCMCNotSupported(BarbicanHTTPException):
    message = u._("Full CMC Requests are not yet supported.")
    client_message = message
    status_code = 400
 
 
class NotFound(BarbicanException):
    message = u._("An object with the specified identifier was not found.")
 
 
class ConstraintCheck(BarbicanException):
    message = u._("A defined SQL constraint check failed: %(error)s")
 
 
class NotSupported(BarbicanException):
    message = u._("Operation is not supported.")
 
 
class Invalid(BarbicanException):
    message = u._("Data supplied was not valid.")
 
 
class NoDataToProcess(BarbicanHTTPException):
    message = u._("No data supplied to process.")
    client_message = message
    status_code = 400
 
 
class LimitExceeded(BarbicanHTTPException):
    message = u._("The request returned a 413 Request Entity Too Large. This "
                  "generally means that rate limiting or a quota threshold "
                  "was breached.")
    client_message = u._("Provided information too large to process")
    status_code = 413
 
    def __init__(self, *args, **kwargs):
        super(LimitExceeded, self).__init__(*args, **kwargs)
        self.retry_afterretry_after = (int(kwargs['retry']) if kwargs.get('retry')
                            else None)
 
 
class InvalidObject(BarbicanHTTPException):
    status_code = 400
 
    def __init__(self, *args, **kwargs):
        self.invalid_propertyinvalid_property = kwargs.get('property')
        self.messagemessagemessage = u._("Failed to validate JSON information: ")
        self.client_messageclient_messageclient_message = u._("Provided object does not match "
                                  "schema '{schema}': "
                                  "{reason}. Invalid property: "
                                  "'{property}'").format(*args, **kwargs)
        self.messagemessagemessage = self.messagemessagemessage + self.client_messageclient_messageclient_message
        super(InvalidObject, self).__init__(*args, **kwargs)
 
 
class PayloadDecodingError(BarbicanHTTPException):
    status_code = 400
    message = u._("Error while attempting to decode payload.")
    client_message = u._("Unable to decode request data.")
 
 
class UnsupportedField(BarbicanHTTPException):
    message = u._("No support for value set on field '%(field)s' on "
                  "schema '%(schema)s': %(reason)s")
    client_message = u._("Provided field value is not supported")
    status_code = 400
 
    def __init__(self, *args, **kwargs):
        super(UnsupportedField, self).__init__(*args, **kwargs)
        self.invalid_fieldinvalid_field = kwargs.get('field')
 
 
class FeatureNotImplemented(BarbicanException):
    message = u._("Feature not implemented for value set on field "
                  "'%(field)s' on " "schema '%(schema)s': %(reason)s")
 
    def __init__(self, *args, **kwargs):
        super(FeatureNotImplemented, self).__init__(*args, **kwargs)
        self.invalid_fieldinvalid_field = kwargs.get('field')
 
 
class StoredKeyContainerNotFound(BarbicanException):
    message = u._("Container %(container_id)s does not exist for stored "
                  "key certificate generation.")
 
 
class StoredKeyPrivateKeyNotFound(BarbicanException):
    message = u._("Container %(container_id)s does not reference a private "
                  "key needed for stored key certificate generation.")
 
 
class ProvidedTransportKeyNotFound(BarbicanHTTPException):
    message = u._("Provided Transport key %(transport_key_id)s "
                  "could not be found")
    client_message = u._("Provided transport key was not found.")
    status_code = 400
 
 
class InvalidCAID(BarbicanHTTPException):
    message = u._("Invalid CA_ID: %(ca_id)s")
    client_message = u._("The ca_id provided in the request is invalid")
    status_code = 400
 
 
class CANotDefinedForProject(BarbicanHTTPException):
    message = u._("CA specified by ca_id %(ca_id)s not defined for project: "
                  "%(project_id)s")
    client_message = u._("The ca_id provided in the request is not defined "
                         "for this project")
    status_code = 403
 
 
class QuotaReached(BarbicanHTTPException):
    message = u._("Quota reached for project %(external_project_id)s. Only "
                  "%(quota)s %(resource_type)s are allowed.")
    client_message = u._("Creation not allowed because a quota has "
                         "been reached")
    status_code = 403
 
    def __init__(self, *args, **kwargs):
        super(QuotaReached, self).__init__(*args, **kwargs)
        self.external_project_idexternal_project_id = kwargs.get('external_project_id')
        self.quotaquota = kwargs.get('quota')
        self.resource_typeresource_type = kwargs.get('resource_type')
 
 
class InvalidParentCA(BarbicanHTTPException):
    message = u._("Invalid Parent CA: %(parent_ca_ref)s")
    client_message = message
    status_code = 400
 
 
class SubCAsNotSupported(BarbicanHTTPException):
    message = u._("Plugin does not support generation of subordinate CAs")
    client_message = message
    status_code = 400
 
 
class SubCANotCreated(BarbicanHTTPException):
    message = u._("Errors in creating subordinate CA: %(name)")
    client_message = message
 
 
class CannotDeleteBaseCA(BarbicanHTTPException):
    message = u._("Only subordinate CAs can be deleted.")
    status_code = 403
 
 
class UnauthorizedSubCA(BarbicanHTTPException):
    message = u._("Subordinate CA is not owned by this project")
    client_message = message
    status_code = 403
 
 
class CannotDeletePreferredCA(BarbicanHTTPException):
    message = u._("A new project preferred CA must be set "
                  "before this one can be deleted.")
    status_code = 409
 
 
class BadSubCACreationRequest(BarbicanHTTPException):
    message = u._("Errors returned by CA when attempting to "
                  "create subordinate CA: %(reason)s")
    client_message = message
    status_code = 400
 
 
class SubCACreationErrors(BarbicanHTTPException):
    message = u._("Errors returned by CA when attempting to create "
                  "subordinate CA: %(reason)s")
    client_message = message
 
 
class SubCADeletionErrors(BarbicanHTTPException):
    message = u._("Errors returned by CA when attempting to delete "
                  "subordinate CA: %(reason)s")
    client_message = message
 
 
class PKCS11Exception(BarbicanException):
    message = u._("There was an error with the PKCS#11 library.")
 
 
class P11CryptoPluginKeyException(PKCS11Exception):
    message = u._("More than one key found for label")
 
 
class P11CryptoPluginException(PKCS11Exception):
    message = u._("General exception")
 
 
class P11CryptoKeyHandleException(PKCS11Exception):
    message = u._("No key handle was found")
 
 
class P11CryptoTokenException(PKCS11Exception):
    message = u._("No token was found in slot %(slot_id)s")
 
 
class MultipleStorePreferredPluginMissing(BarbicanException):
    """Raised when a preferred plugin is missing in service configuration."""
    def __init__(self, store_name):
        super(MultipleStorePreferredPluginMissing, self).__init__(
            u._("Preferred Secret Store plugin '{store_name}' is not "
                "currently set in service configuration. This is probably a "
                "server misconfiguration.").format(
                store_name=store_name)
        )
        self.store_namestore_name = store_name
 
 
class MultipleStorePluginStillInUse(BarbicanException):
    """Raised when a used plugin is missing in service configuration."""
    def __init__(self, store_name):
        super(MultipleStorePluginStillInUse, self).__init__(
            u._("Secret Store plugin '{store_name}' is still in use and can "
                "not be removed. Its missing in service configuration. This is"
                " probably a server misconfiguration.").format(
                store_name=store_name)
        )
        self.store_namestore_name = store_name
 
 
class MultipleSecretStoreLookupFailed(BarbicanException):
    """Raised when a plugin lookup suffix is missing during config read."""
    def __init__(self):
        msg = u._("Plugin lookup property 'stores_lookup_suffix' is not "
                  "defined in service configuration")
        super(MultipleSecretStoreLookupFailed, self).__init__(msg)
 
 
class MultipleStoreIncorrectGlobalDefault(BarbicanException):
    """Raised when a global default for only one plugin is not set to True."""
    def __init__(self, occurrence):
        msg = None
        if occurrence > 1:
            msg = u._("There are {count} plugins with global default as "
                      "True in service configuration. Only one plugin can have"
                      " this as True").format(count=occurrence)
        else:
            msg = u._("There is no plugin defined with global default as True."
                      " One of plugin must be identified as global default")
 
        super(MultipleStoreIncorrectGlobalDefault, self).__init__(msg)
 
 
class MultipleStorePluginValueMissing(BarbicanException):
    """Raised when a store plugin value is missing in service configuration."""
    def __init__(self, section_name):
        super(MultipleStorePluginValueMissing, self).__init__(
            u._("In section '{0}', secret_store_plugin value is missing"
                ).format(section_name)
        )
        self.section_namesection_name = section_name