438 lines
12 KiB
Python
438 lines
12 KiB
Python
# Copyright 2010 Jacob Kaplan-Moss
|
|
# Copyright 2011 Nebula, 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.
|
|
"""Exception definitions."""
|
|
|
|
from keystoneauth1 import exceptions as _exc
|
|
|
|
from keystoneclient.i18n import _
|
|
|
|
|
|
ClientException = _exc.ClientException
|
|
"""The base exception class for all exceptions this library raises.
|
|
|
|
An alias of :py:exc:`keystoneauth1.exceptions.base.ClientException`
|
|
"""
|
|
|
|
ConnectionError = _exc.ConnectionError
|
|
"""Cannot connect to API service.
|
|
|
|
An alias of :py:exc:`keystoneauth1.exceptions.connection.ConnectionError`
|
|
"""
|
|
|
|
ConnectionRefused = _exc.ConnectFailure
|
|
"""Connection refused while trying to connect to API service.
|
|
|
|
An alias of :py:exc:`keystoneauth1.exceptions.connection.ConnectFailure`
|
|
"""
|
|
|
|
SSLError = _exc.SSLError
|
|
"""An SSL error occurred.
|
|
|
|
An alias of :py:exc:`keystoneauth1.exceptions.connection.SSLError`
|
|
"""
|
|
|
|
AuthorizationFailure = _exc.AuthorizationFailure
|
|
"""Cannot authorize API client.
|
|
|
|
An alias of :py:exc:`keystoneauth1.exceptions.auth.AuthorizationFailure`
|
|
"""
|
|
|
|
|
|
class ValidationError(ClientException):
|
|
"""Error in validation on API client side."""
|
|
|
|
pass
|
|
|
|
|
|
class UnsupportedVersion(ClientException):
|
|
"""User is trying to use an unsupported version of the API."""
|
|
|
|
pass
|
|
|
|
|
|
class CommandError(ClientException):
|
|
"""Error in CLI tool."""
|
|
|
|
pass
|
|
|
|
|
|
class AuthPluginOptionsMissing(AuthorizationFailure):
|
|
"""Auth plugin misses some options."""
|
|
|
|
def __init__(self, opt_names):
|
|
super(AuthPluginOptionsMissing, self).__init__(
|
|
_("Authentication failed. Missing options: %s") %
|
|
", ".join(opt_names))
|
|
self.opt_names = opt_names
|
|
|
|
|
|
class AuthSystemNotFound(AuthorizationFailure):
|
|
"""User has specified an AuthSystem that is not installed."""
|
|
|
|
def __init__(self, auth_system):
|
|
super(AuthSystemNotFound, self).__init__(
|
|
_("AuthSystemNotFound: %r") % auth_system)
|
|
self.auth_system = auth_system
|
|
|
|
|
|
class NoUniqueMatch(ClientException):
|
|
"""Multiple entities found instead of one."""
|
|
|
|
pass
|
|
|
|
|
|
EndpointException = _exc.CatalogException
|
|
"""Something is rotten in Service Catalog.
|
|
|
|
An alias of :py:exc:`keystoneauth1.exceptions.catalog.CatalogException`
|
|
"""
|
|
|
|
EndpointNotFound = _exc.EndpointNotFound
|
|
"""Could not find requested endpoint in Service Catalog.
|
|
|
|
An alias of :py:exc:`keystoneauth1.exceptions.catalog.EndpointNotFound`
|
|
"""
|
|
|
|
|
|
class AmbiguousEndpoints(EndpointException):
|
|
"""Found more than one matching endpoint in Service Catalog."""
|
|
|
|
def __init__(self, endpoints=None):
|
|
super(AmbiguousEndpoints, self).__init__(
|
|
_("AmbiguousEndpoints: %r") % endpoints)
|
|
self.endpoints = endpoints
|
|
|
|
|
|
HttpError = _exc.HttpError
|
|
"""The base exception class for all HTTP exceptions.
|
|
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.HttpError`
|
|
"""
|
|
|
|
HTTPClientError = _exc.HTTPClientError
|
|
"""Client-side HTTP error.
|
|
|
|
Exception for cases in which the client seems to have erred.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.HTTPClientError`
|
|
"""
|
|
|
|
HttpServerError = _exc.HttpServerError
|
|
"""Server-side HTTP error.
|
|
|
|
Exception for cases in which the server is aware that it has
|
|
erred or is incapable of performing the request.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.HttpServerError`
|
|
"""
|
|
|
|
|
|
class HTTPRedirection(HttpError):
|
|
"""HTTP Redirection."""
|
|
|
|
message = _("HTTP Redirection")
|
|
|
|
|
|
class MultipleChoices(HTTPRedirection):
|
|
"""HTTP 300 - Multiple Choices.
|
|
|
|
Indicates multiple options for the resource that the client may follow.
|
|
"""
|
|
|
|
http_status = 300
|
|
message = _("Multiple Choices")
|
|
|
|
|
|
BadRequest = _exc.BadRequest
|
|
"""HTTP 400 - Bad Request.
|
|
|
|
The request cannot be fulfilled due to bad syntax.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.BadRequest`
|
|
"""
|
|
|
|
Unauthorized = _exc.Unauthorized
|
|
"""HTTP 401 - Unauthorized.
|
|
|
|
Similar to 403 Forbidden, but specifically for use when authentication
|
|
is required and has failed or has not yet been provided.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.Unauthorized`
|
|
"""
|
|
|
|
PaymentRequired = _exc.PaymentRequired
|
|
"""HTTP 402 - Payment Required.
|
|
|
|
Reserved for future use.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.PaymentRequired`
|
|
"""
|
|
|
|
Forbidden = _exc.Forbidden
|
|
"""HTTP 403 - Forbidden.
|
|
|
|
The request was a valid request, but the server is refusing to respond
|
|
to it.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.Forbidden`
|
|
"""
|
|
|
|
NotFound = _exc.NotFound
|
|
"""HTTP 404 - Not Found.
|
|
|
|
The requested resource could not be found but may be available again
|
|
in the future.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.NotFound`
|
|
"""
|
|
|
|
MethodNotAllowed = _exc.MethodNotAllowed
|
|
"""HTTP 405 - Method Not Allowed.
|
|
|
|
A request was made of a resource using a request method not supported
|
|
by that resource.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.MethodNotAllowed`
|
|
"""
|
|
|
|
NotAcceptable = _exc.NotAcceptable
|
|
"""HTTP 406 - Not Acceptable.
|
|
|
|
The requested resource is only capable of generating content not
|
|
acceptable according to the Accept headers sent in the request.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.NotAcceptable`
|
|
"""
|
|
|
|
ProxyAuthenticationRequired = _exc.ProxyAuthenticationRequired
|
|
"""HTTP 407 - Proxy Authentication Required.
|
|
|
|
The client must first authenticate itself with the proxy.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.ProxyAuthenticationRequired`
|
|
"""
|
|
|
|
RequestTimeout = _exc.RequestTimeout
|
|
"""HTTP 408 - Request Timeout.
|
|
|
|
The server timed out waiting for the request.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.RequestTimeout`
|
|
"""
|
|
|
|
Conflict = _exc.Conflict
|
|
"""HTTP 409 - Conflict.
|
|
|
|
Indicates that the request could not be processed because of conflict
|
|
in the request, such as an edit conflict.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.Conflict`
|
|
"""
|
|
|
|
Gone = _exc.Gone
|
|
"""HTTP 410 - Gone.
|
|
|
|
Indicates that the resource requested is no longer available and will
|
|
not be available again.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.Gone`
|
|
"""
|
|
|
|
LengthRequired = _exc.LengthRequired
|
|
"""HTTP 411 - Length Required.
|
|
|
|
The request did not specify the length of its content, which is
|
|
required by the requested resource.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.LengthRequired`
|
|
"""
|
|
|
|
PreconditionFailed = _exc.PreconditionFailed
|
|
"""HTTP 412 - Precondition Failed.
|
|
|
|
The server does not meet one of the preconditions that the requester
|
|
put on the request.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.PreconditionFailed`
|
|
"""
|
|
|
|
RequestEntityTooLarge = _exc.RequestEntityTooLarge
|
|
"""HTTP 413 - Request Entity Too Large.
|
|
|
|
The request is larger than the server is willing or able to process.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.RequestEntityTooLarge`
|
|
"""
|
|
|
|
RequestUriTooLong = _exc.RequestUriTooLong
|
|
"""HTTP 414 - Request-URI Too Long.
|
|
|
|
The URI provided was too long for the server to process.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.RequestUriTooLong`
|
|
"""
|
|
|
|
UnsupportedMediaType = _exc.UnsupportedMediaType
|
|
"""HTTP 415 - Unsupported Media Type.
|
|
|
|
The request entity has a media type which the server or resource does
|
|
not support.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.UnsupportedMediaType`
|
|
"""
|
|
|
|
RequestedRangeNotSatisfiable = _exc.RequestedRangeNotSatisfiable
|
|
"""HTTP 416 - Requested Range Not Satisfiable.
|
|
|
|
The client has asked for a portion of the file, but the server cannot
|
|
supply that portion.
|
|
An alias of
|
|
:py:exc:`keystoneauth1.exceptions.http.RequestedRangeNotSatisfiable`
|
|
"""
|
|
|
|
ExpectationFailed = _exc.ExpectationFailed
|
|
"""HTTP 417 - Expectation Failed.
|
|
|
|
The server cannot meet the requirements of the Expect request-header field.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.ExpectationFailed`
|
|
"""
|
|
|
|
UnprocessableEntity = _exc.UnprocessableEntity
|
|
"""HTTP 422 - Unprocessable Entity.
|
|
|
|
The request was well-formed but was unable to be followed due to semantic
|
|
errors.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.UnprocessableEntity`
|
|
"""
|
|
|
|
InternalServerError = _exc.InternalServerError
|
|
"""HTTP 500 - Internal Server Error.
|
|
|
|
A generic error message, given when no more specific message is suitable.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.InternalServerError`
|
|
"""
|
|
|
|
HttpNotImplemented = _exc.HttpNotImplemented
|
|
"""HTTP 501 - Not Implemented.
|
|
|
|
The server either does not recognize the request method, or it lacks
|
|
the ability to fulfill the request.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.HttpNotImplemented`
|
|
"""
|
|
|
|
BadGateway = _exc.BadGateway
|
|
"""HTTP 502 - Bad Gateway.
|
|
|
|
The server was acting as a gateway or proxy and received an invalid
|
|
response from the upstream server.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.BadGateway`
|
|
"""
|
|
|
|
ServiceUnavailable = _exc.ServiceUnavailable
|
|
"""HTTP 503 - Service Unavailable.
|
|
|
|
The server is currently unavailable.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.ServiceUnavailable`
|
|
"""
|
|
|
|
GatewayTimeout = _exc.GatewayTimeout
|
|
"""HTTP 504 - Gateway Timeout.
|
|
|
|
The server was acting as a gateway or proxy and did not receive a timely
|
|
response from the upstream server.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.GatewayTimeout`
|
|
"""
|
|
|
|
HttpVersionNotSupported = _exc.HttpVersionNotSupported
|
|
"""HTTP 505 - HttpVersion Not Supported.
|
|
|
|
The server does not support the HTTP protocol version used in the request.
|
|
An alias of :py:exc:`keystoneauth1.exceptions.http.HttpVersionNotSupported`
|
|
"""
|
|
|
|
from_response = _exc.from_response
|
|
"""Return an instance of :class:`HttpError` or subclass based on response.
|
|
|
|
An alias of :py:func:`keystoneauth1.exceptions.http.from_response`
|
|
"""
|
|
|
|
|
|
# NOTE(akurilin): This alias should be left here to support backwards
|
|
# compatibility until we are sure that usage of these exceptions in
|
|
# projects is correct.
|
|
HTTPNotImplemented = HttpNotImplemented
|
|
Timeout = RequestTimeout
|
|
HTTPError = HttpError
|
|
|
|
|
|
class CertificateConfigError(Exception):
|
|
"""Error reading the certificate."""
|
|
|
|
def __init__(self, output):
|
|
self.output = output
|
|
msg = _('Unable to load certificate.')
|
|
super(CertificateConfigError, self).__init__(msg)
|
|
|
|
|
|
class CMSError(Exception):
|
|
"""Error reading the certificate."""
|
|
|
|
def __init__(self, output):
|
|
self.output = output
|
|
msg = _('Unable to sign or verify data.')
|
|
super(CMSError, self).__init__(msg)
|
|
|
|
EmptyCatalog = _exc.EmptyCatalog
|
|
"""The service catalog is empty.
|
|
|
|
An alias of :py:exc:`keystoneauth1.exceptions.catalog.EmptyCatalog`
|
|
"""
|
|
|
|
DiscoveryFailure = _exc.DiscoveryFailure
|
|
"""Discovery of client versions failed.
|
|
|
|
An alias of :py:exc:`keystoneauth1.exceptions.discovery.DiscoveryFailure`
|
|
"""
|
|
|
|
VersionNotAvailable = _exc.VersionNotAvailable
|
|
"""Discovery failed as the version you requested is not available.
|
|
|
|
An alias of :py:exc:`keystoneauth1.exceptions.discovery.VersionNotAvailable`
|
|
"""
|
|
|
|
|
|
class MethodNotImplemented(ClientException):
|
|
"""Method not implemented by the keystoneclient API."""
|
|
|
|
MissingAuthPlugin = _exc.MissingAuthPlugin
|
|
"""An authenticated request is required but no plugin available.
|
|
|
|
An alias of :py:exc:`keystoneauth1.exceptions.auth_plugins.MissingAuthPlugin`
|
|
"""
|
|
|
|
NoMatchingPlugin = _exc.NoMatchingPlugin
|
|
"""There were no auth plugins that could be created from the parameters
|
|
provided.
|
|
|
|
An alias of :py:exc:`keystoneauth1.exceptions.auth_plugins.NoMatchingPlugin`
|
|
"""
|
|
|
|
|
|
class UnsupportedParameters(ClientException):
|
|
"""A parameter that was provided or returned is not supported.
|
|
|
|
:param List(str) names: Names of the unsupported parameters.
|
|
|
|
.. py:attribute:: names
|
|
|
|
Names of the unsupported parameters.
|
|
"""
|
|
|
|
def __init__(self, names):
|
|
self.names = names
|
|
|
|
m = _('The following parameters were given that are unsupported: %s')
|
|
super(UnsupportedParameters, self).__init__(m % ', '.join(self.names))
|
|
|
|
|
|
class InvalidResponse(ClientException):
|
|
"""The response from the server is not valid for this request."""
|
|
|
|
def __init__(self, response):
|
|
super(InvalidResponse, self).__init__()
|
|
self.response = response
|