class RequestTimeout(HTTPClientError): """HTTP 408 - Request Timeout. The server timed out waiting for the request. """ status_code = 408 message = _("Request Timeout")
class InternalServerError(HttpServerError): """HTTP 500 - Internal Server Error. A generic error message, given when no more specific message is suitable. """ status_code = 500 message = _("Internal Server Error")
class ExpectationFailed(HTTPClientError): """HTTP 417 - Expectation Failed. The server cannot meet the requirements of the Expect request-header field. """ status_code = 417 message = _("Expectation Failed")
class ServiceUnavailable(HttpServerError): """HTTP 503 - Service Unavailable. The server is currently unavailable. """ status_code = 503 message = _("Service Unavailable")
class RequestUriTooLong(HTTPClientError): """HTTP 414 - Request-URI Too Long. The URI provided was too long for the server to process. """ status_code = 414 message = _("Request-URI Too Long")
class HttpServerError(HttpError): """Server-side HTTP error. Exception for cases in which the server is aware that it has erred or is incapable of performing the request. """ message = _("HTTP Server Error")
class HttpVersionNotSupported(HttpServerError): """HTTP 505 - HttpVersion Not Supported. The server does not support the HTTP protocol version used in the request. """ status_code = 505 message = _("HTTP Version Not Supported")
class BadRequest(HTTPClientError): """HTTP 400 - Bad Request. The request cannot be fulfilled due to bad syntax. """ status_code = 400 message = _("Bad Request")
class PaymentRequired(HTTPClientError): """HTTP 402 - Payment Required. Reserved for future use. """ status_code = 402 message = _("Payment Required")
class ProxyAuthenticationRequired(HTTPClientError): """HTTP 407 - Proxy Authentication Required. The client must first authenticate itself with the proxy. """ status_code = 407 message = _("Proxy Authentication Required")
class UnsupportedMediaType(HTTPClientError): """HTTP 415 - Unsupported Media Type. The request entity has a media type which the server or resource does not support. """ status_code = 415 message = _("Unsupported Media Type")
def strip_endpoint(self, location): if location is None: message = _("Location not returned with redirect") raise exc.EndpointException(message=message) if location.lower().startswith(self.endpoint): return location[len(self.endpoint):] else: return location
class LengthRequired(HTTPClientError): """HTTP 411 - Length Required. The request did not specify the length of its content, which is required by the requested resource. """ status_code = 411 message = _("Length Required")
class UnprocessableEntity(HTTPClientError): """HTTP 422 - Unprocessable Entity. The request was well-formed but was unable to be followed due to semantic errors. """ status_code = 422 message = _("Unprocessable Entity")
class NotAcceptable(HTTPClientError): """HTTP 406 - Not Acceptable. The requested resource is only capable of generating content not acceptable according to the Accept headers sent in the request. """ status_code = 406 message = _("Not Acceptable")
class MethodNotAllowed(HTTPClientError): """HTTP 405 - Method Not Allowed. A request was made of a resource using a request method not supported by that resource. """ status_code = 405 message = _("Method Not Allowed")
class NotFound(HTTPClientError): """HTTP 404 - Not Found. The requested resource could not be found but may be available again in the future. """ status_code = 404 message = _("Not Found")
class Forbidden(HTTPClientError): """HTTP 403 - Forbidden. The request was a valid request, but the server is refusing to respond to it. """ status_code = 403 message = _("Forbidden")
class RequestedRangeNotSatisfiable(HTTPClientError): """HTTP 416 - Requested Range Not Satisfiable. The client has asked for a portion of the file, but the server cannot supply that portion. """ status_code = 416 message = _("Requested Range Not Satisfiable")
class HttpNotImplemented(HttpServerError): """HTTP 501 - Not Implemented. The server either does not recognize the request method, or it lacks the ability to fulfill the request. """ status_code = 501 message = _("Not Implemented")
class Unauthorized(HTTPClientError): """HTTP 401 - Unauthorized. Similar to 403 Forbidden, but specifically for use when authentication is required and has failed or has not yet been provided. """ status_code = 401 message = _("Unauthorized")
class Conflict(HTTPClientError): """HTTP 409 - Conflict. Indicates that the request could not be processed because of conflict in the request, such as an edit conflict. """ status_code = 409 message = _("Conflict")
class MultipleChoices(HTTPRedirection): """HTTP 300 - Multiple Choices. Indicates multiple options for the resource that the client may follow. """ status_code = 300 message = _("Multiple Choices")
class BadGateway(HttpServerError): """HTTP 502 - Bad Gateway. The server was acting as a gateway or proxy and received an invalid response from the upstream server. """ status_code = 502 message = _("Bad Gateway")
class Gone(HTTPClientError): """HTTP 410 - Gone. Indicates that the resource requested is no longer available and will not be available again. """ status_code = 410 message = _("Gone")
class GatewayTimeout(HttpServerError): """HTTP 504 - Gateway Timeout. The server was acting as a gateway or proxy and did not receive a timely response from the upstream server. """ status_code = 504 message = _("Gateway Timeout")
class PreconditionFailed(HTTPClientError): """HTTP 412 - Precondition Failed. The server does not meet one of the preconditions that the requester put on the request. """ status_code = 412 message = _("Precondition Failed")
def build_option_parser(parser): """Hook to add global options""" parser.add_argument('--os-event-api-version', metavar='<event-api-version>', default=utils.env('OS_EVENT_API_VERSION', default=DEFAULT_EVENT_API_VERSION), help=(_('Event API version, default=%s ' '(Env: OS_EVENT_API_VERSION)') % DEFAULT_EVENT_API_VERSION)) return parser
class RequestEntityTooLarge(HTTPClientError): """HTTP 413 - Request Entity Too Large. The request is larger than the server is willing or able to process. """ status_code = 413 message = _("Request Entity Too Large") def __init__(self, *args, **kwargs): try: self.retry_after = int(kwargs.pop('retry_after')) except (KeyError, ValueError): self.retry_after = 0 super(RequestEntityTooLarge, self).__init__(*args, **kwargs)
class HttpError(ClientException): """The base exception class for all HTTP exceptions.""" status_code = 0 message = _("HTTP Error") def __init__(self, message=None, details=None, response=None, request_id=None, url=None, method=None, status_code=None): self.status_code = status_code or self.status_code self.message = message or self.message self.details = details self.request_id = request_id self.response = response self.url = url self.method = method formatted_string = "%s (HTTP %s)" % (self.message, self.status_code) if request_id: formatted_string += " (Request-ID: %s)" % request_id super(HttpError, self).__init__(formatted_string)