class UnexpectedError(SecurityError):
"""Avoids exposing details of failures, unless in insecure_debug mode."""
message_format = _("An unexpected error prevented the server "
"from fulfilling your request.")
debug_message_format = _("An unexpected error prevented the server "
"from fulfilling your request: %(exception)s.")
class ValidationError(Error):
message_format = _("Expecting to find %(attribute)s in %(target)s."
" The server could not comply with the request"
" since it is either malformed or otherwise"
" incorrect. The client is assumed to be in error.")
code = int(http_client.BAD_REQUEST)
title = http_client.responses[http_client.BAD_REQUEST]
class SecurityError(Error):
"""Security error exception.
Avoids exposing details of security errors, unless in insecure_debug mode.
"""
amendment = _('(Disable insecure_debug mode to suppress these details.)')
def __deepcopy__(self):
"""Override the default deepcopy.
Keystone :class:`storeanalysis.exception.Error` accepts an optional message
that will be used when rendering the exception object as a string. If
not provided the object's message_format attribute is used instead.
:class:`storeanalysis.exception.SecurityError` is a little different in
that it only uses the message provided to the initializer when
storeanalysis is in `insecure_debug` mode. Instead it will use its
`message_format`. This is to ensure that sensitive details are not
leaked back to the caller in a production deployment.
This dual mode for string rendering causes some odd behaviour when
combined with oslo_i18n translation. Any object used as a value for
formatting a translated string is deep copied.
The copy causes an issue. The deep copy process actually creates a new
exception instance with the rendered string. Then when that new
instance is rendered as a string to use for substitution a warning is
logged. This is because the code tries to use the `message_format` in
secure mode, but the required kwargs are not in the deep copy.
The end result is not an error because when the KeyError is caught the
instance's ``message`` is used instead and this has the properly
translated message. The only indication that something is wonky is a
message in the warning log.
"""
return self
def _build_message(self, message, **kwargs):
"""Only returns detailed messages in insecure_debug mode."""
if message:
if isinstance(message, six.string_types):
# Only do replacement if message is string. The message is
# sometimes a different exception or bytes, which would raise
# TypeError.
message = _format_with_unicode_kwargs(message, kwargs)
return _('%(message)s %(amendment)s') % {
'message': message,
'amendment': self.amendment
}
return _format_with_unicode_kwargs(self.message_format, kwargs)
def _build_message(self, message, **kwargs):
"""Only returns detailed messages in insecure_debug mode."""
if message:
if isinstance(message, six.string_types):
# Only do replacement if message is string. The message is
# sometimes a different exception or bytes, which would raise
# TypeError.
message = _format_with_unicode_kwargs(message, kwargs)
return _('%(message)s %(amendment)s') % {
'message': message,
'amendment': self.amendment
}
return _format_with_unicode_kwargs(self.message_format, kwargs)
def _dispatch(req):
"""Dispatch the request to the appropriate controller.
Called by self._router after matching the incoming request to a route
and putting the information into req.environ. Either returns 404
or the routed WSGI app's response.
"""
match = req.environ['wsgiorg.routing_args'][1]
if not match:
msg = (_('(%(url)s): The resource could not be found.') % {
'url': req.url
})
return render_exception(exception.NotFound(msg),
request=req,
user_locale=None)
app = match['controller']
return app
class VersionNotFound(NotFound):
message_format = _("Could not find version: %(version)s.")
class NotFound(Error):
message_format = _("Could not find: %(target)s.")
code = int(http_client.NOT_FOUND)
title = http_client.responses[http_client.NOT_FOUND]
class ArgTypeError(Error):
message_format = _("Argument type error, which is not excepted.")
class ConfigFileNotFound(UnexpectedError):
debug_message_format = _("The Keystone configuration file %(config_file)s "
"could not be found.")