class PaymentRequired(HTTPClientError):
"""HTTP 402 - Payment Required.
Reserved for future use.
"""
status_code = 402
message = _("Payment Required")
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")
def get_parser(self, prog_name):
parser = super(ListInstanceCPUMappings, self).get_parser(prog_name)
parser.add_argument('--long',
action='store_true',
default=False,
help=_("List additional fields in output"))
return parser
def take_action(self, parsed_args):
kongmingclient = self.app.client_manager.resource_pin
result = 0
for one_mapping in parsed_args.instance_uuid:
try:
data = utils.find_resource(
kongmingclient.instance_cpu_mappings, one_mapping)
kongmingclient.instance_cpu_mappings.delete(data.instance_uuid)
except Exception as e:
result += 1
LOG.error(
"Failed to delete cpu mapping with instance UUID "
"'%(uuid)s': %(e)s", {
'uuid': one_mapping,
'e': e
})
if result > 0:
total = len(parsed_args.instance_uuid)
msg = (_("%(result)s of %(total)s mapping failed "
"to delete.") % {
'result': result,
'total': total
})
raise exceptions.CommandError(msg)
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 RequestTimeout(HTTPClientError):
"""HTTP 408 - Request Timeout.
The server timed out waiting for the request.
"""
status_code = 408
message = _("Request Timeout")
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 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 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 ServiceUnavailable(HttpServerError):
"""HTTP 503 - Service Unavailable.
The server is currently unavailable.
"""
status_code = 503
message = _("Service Unavailable")
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 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 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 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 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 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")
def get_parser(self, prog_name):
parser = super(ShowHost, self).get_parser(prog_name)
parser.add_argument(
'host_name',
metavar='<host_name>',
help=_("Host to display (Host_name)")
)
return parser
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")
def get_parser(self, prog_name):
parser = super(CreateInstanceCPUMappings, self).get_parser(prog_name)
parser.add_argument(
"instance_uuid",
metavar="<instance_uuid>",
help=_("The instance uuid you want to create mapping for."))
parser.add_argument(
"cpu_mappings",
metavar="<cpu_mappings>",
help=_("The mappings you want to assign for the given instance."))
parser.add_argument(
"--wait-until-active",
metavar='<wait_until_active|True>',
default=False,
help=_("Whether to perform this action now or do it "
"automatically once the instance turn into ACTIVE status."))
return parser
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")
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 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 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 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 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")
def get_parser(self, prog_name):
parser = super(DeleteInstanceCPUMappings, self).get_parser(prog_name)
parser.add_argument(
'instance_uuid',
metavar='<instance_uuid>',
nargs='+',
help=_("instance_cpu_mapping(s) to delete (instance UUID)"))
return parser
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 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")
