mirror of
https://github.com/hanzoai/porto.git
synced 2026-11-03 18:08:27 +00:00
362 lines
16 KiB
Go
362 lines
16 KiB
Go
package httperror
|
|
|
|
import (
|
|
"net/http"
|
|
|
|
"google.golang.org/grpc/codes"
|
|
)
|
|
|
|
const (
|
|
// CodeAccountNotFound when requested account not found
|
|
CodeAccountNotFound = "account_not_found"
|
|
// CodeBadNonce is returned for bad nonce.
|
|
CodeBadNonce = "bad_nonce"
|
|
// CodeConflict is returned whith 409 CONFLICT response code.
|
|
CodeConflict = "conflict"
|
|
// CodeConnection is returned when connection failed.
|
|
CodeConnection = "connection"
|
|
// CodeContentLengthRequired is returned when request does not specify ContentLength.
|
|
CodeContentLengthRequired = "content_length_required"
|
|
// CodeFailedToReadRequestBody is returned when there's an error reading the HTTP body of the request.
|
|
CodeFailedToReadRequestBody = "request_body"
|
|
// CodeForbidden is returned when the client is not authorized to access the resource indicated.
|
|
CodeForbidden = "forbidden"
|
|
// CodeInvalidContentType is returned when request specifies invalid Content-Type.
|
|
CodeInvalidContentType = "invalid_content_type"
|
|
// CodeInvalidJSON is returned when we were unable to parse a client supplied JSON Payload.
|
|
CodeInvalidJSON = "invalid_json"
|
|
// CodeInvalidParam is returned where a URL parameter, or other type of generalized parameters value is invalid.
|
|
CodeInvalidParam = "invalid_parameter"
|
|
// CodeInvalidRequest is returned when the request validation failed.
|
|
CodeInvalidRequest = "invalid_request"
|
|
// CodeMalformed is returned when the request was malformed.
|
|
CodeMalformed = "malformed"
|
|
// CodeNotFound is returned when the requested URL doesn't exist.
|
|
CodeNotFound = "not_found"
|
|
// CodeNotReady is returned when the service is not ready to serve
|
|
CodeNotReady = "not_ready"
|
|
// CodeRateLimitExceeded is returned when the client has exceeded their request allotment.
|
|
CodeRateLimitExceeded = "rate_limit_exceeded"
|
|
// CodeRequestFailed is returned when an outbound request failed.
|
|
CodeRequestFailed = "request_failed"
|
|
// CodeRequestTooLarge is returned when the client provided payload is larger than allowed for the particular resource.
|
|
CodeRequestTooLarge = "request_too_large"
|
|
// CodeTimeout is returned when request timed out.
|
|
CodeTimeout = "timeout"
|
|
// CodeTooEarly is returned when the client makes requests too early.
|
|
CodeTooEarly = "too_early"
|
|
// CodeUnauthorized is for unauthorized access.
|
|
CodeUnauthorized = "unauthorized"
|
|
// CodeUnexpected is returned when something went wrong.
|
|
CodeUnexpected = "unexpected"
|
|
)
|
|
|
|
var httpCode = map[int]string{
|
|
http.StatusBadRequest: "bad_request",
|
|
http.StatusUnauthorized: "unauthorized",
|
|
http.StatusPaymentRequired: "payment_required",
|
|
http.StatusForbidden: "forbidden",
|
|
http.StatusNotFound: "not_found",
|
|
http.StatusMethodNotAllowed: "not_allowed",
|
|
http.StatusNotAcceptable: "not_acceptable",
|
|
http.StatusProxyAuthRequired: "auth_required",
|
|
http.StatusRequestTimeout: "request_timeout",
|
|
http.StatusConflict: "conflict",
|
|
http.StatusGone: "gone",
|
|
http.StatusLengthRequired: "length_required",
|
|
http.StatusPreconditionFailed: "precondition_failed",
|
|
http.StatusRequestEntityTooLarge: "too_large",
|
|
http.StatusRequestURITooLong: "uri_too_long",
|
|
http.StatusUnsupportedMediaType: "unsupported_media_type",
|
|
http.StatusRequestedRangeNotSatisfiable: "bad_request",
|
|
http.StatusExpectationFailed: "expectation_failed",
|
|
http.StatusTeapot: "teapot",
|
|
http.StatusMisdirectedRequest: "misdirected",
|
|
http.StatusUnprocessableEntity: "unprocessable",
|
|
http.StatusLocked: "locked",
|
|
http.StatusFailedDependency: "failed_dependency",
|
|
http.StatusTooEarly: "too_early",
|
|
http.StatusUpgradeRequired: "upgrade_required",
|
|
http.StatusPreconditionRequired: "precondition_required",
|
|
http.StatusTooManyRequests: "too_many_requests",
|
|
http.StatusRequestHeaderFieldsTooLarge: "too_large",
|
|
http.StatusUnavailableForLegalReasons: "legal_reason",
|
|
|
|
http.StatusInternalServerError: CodeUnexpected,
|
|
http.StatusNotImplemented: "not_implemented",
|
|
http.StatusBadGateway: "bad_gateway",
|
|
http.StatusServiceUnavailable: "unavailable",
|
|
http.StatusGatewayTimeout: "gateway_timeout",
|
|
http.StatusHTTPVersionNotSupported: "not_supported",
|
|
http.StatusVariantAlsoNegotiates: CodeUnexpected,
|
|
http.StatusInsufficientStorage: "insufficient_storage",
|
|
http.StatusLoopDetected: "loop_detected",
|
|
http.StatusNotExtended: "not_extended",
|
|
http.StatusNetworkAuthenticationRequired: "authentication_required",
|
|
}
|
|
|
|
// See: https://cloud.google.com/apis/design/errors
|
|
var codeStatus = map[codes.Code]int{
|
|
// OK is returned on success.
|
|
codes.OK: http.StatusOK,
|
|
|
|
// Canceled indicates the operation was canceled (typically by the caller).
|
|
//
|
|
// The gRPC framework will generate this error code when cancellation
|
|
// is requested.
|
|
codes.Canceled: http.StatusRequestTimeout,
|
|
|
|
// Unknown error. An example of where this error may be returned is
|
|
// if a Status value received from another address space belongs to
|
|
// an error-space that is not known in this address space. Also
|
|
// errors raised by APIs that do not return enough error information
|
|
// may be converted to this error.
|
|
//
|
|
// The gRPC framework will generate this error code in the above two
|
|
// mentioned cases.
|
|
codes.Unknown: http.StatusInternalServerError,
|
|
|
|
// InvalidArgument indicates client specified an invalid argument.
|
|
// Note that this differs from FailedPrecondition. It indicates arguments
|
|
// that are problematic regardless of the state of the system
|
|
// (e.g., a malformed file name).
|
|
//
|
|
// This error code will not be generated by the gRPC framework.
|
|
codes.InvalidArgument: http.StatusBadRequest,
|
|
|
|
// DeadlineExceeded means operation expired before completion.
|
|
// For operations that change the state of the system, this error may be
|
|
// returned even if the operation has completed successfully. For
|
|
// example, a successful response from a server could have been delayed
|
|
// long enough for the deadline to expire.
|
|
//
|
|
// The gRPC framework will generate this error code when the deadline is
|
|
// exceeded.
|
|
codes.DeadlineExceeded: http.StatusRequestTimeout,
|
|
|
|
// NotFound means some requested entity (e.g., file or directory) was
|
|
// not found.
|
|
//
|
|
// This error code will not be generated by the gRPC framework.
|
|
codes.NotFound: http.StatusNotFound,
|
|
|
|
// AlreadyExists means an attempt to create an entity failed because one
|
|
// already exists.
|
|
//
|
|
// This error code will not be generated by the gRPC framework.
|
|
codes.AlreadyExists: http.StatusConflict,
|
|
|
|
// PermissionDenied indicates the caller does not have permission to
|
|
// execute the specified operation. It must not be used for rejections
|
|
// caused by exhausting some resource (use ResourceExhausted
|
|
// instead for those errors). It must not be
|
|
// used if the caller cannot be identified (use Unauthenticated
|
|
// instead for those errors).
|
|
//
|
|
// This error code will not be generated by the gRPC core framework,
|
|
// but expect authentication middleware to use it.
|
|
//
|
|
// The caller is identified but not allowed: HTTP 403, not 401.
|
|
codes.PermissionDenied: http.StatusForbidden,
|
|
|
|
// ResourceExhausted indicates some resource has been exhausted, perhaps
|
|
// a per-user quota, or perhaps the entire file system is out of space.
|
|
//
|
|
// This error code will be generated by the gRPC framework in
|
|
// out-of-memory and server overload situations, or when a message is
|
|
// larger than the configured maximum size.
|
|
codes.ResourceExhausted: http.StatusTooManyRequests,
|
|
|
|
// FailedPrecondition indicates operation was rejected because the
|
|
// system is not in a state required for the operation's execution.
|
|
// For example, directory to be deleted may be non-empty, an rmdir
|
|
// operation is applied to a non-directory, etc.
|
|
//
|
|
// A litmus test that may help a service implementor in deciding
|
|
// between FailedPrecondition, Aborted, and Unavailable:
|
|
// (a) Use Unavailable if the client can retry just the failing call.
|
|
// (b) Use Aborted if the client should retry at a higher-level
|
|
// (e.g., restarting a read-modify-write sequence).
|
|
// (c) Use FailedPrecondition if the client should not retry until
|
|
// the system state has been explicitly fixed. E.g., if an "rmdir"
|
|
// fails because the directory is non-empty, FailedPrecondition
|
|
// should be returned since the client should not retry unless
|
|
// they have first fixed up the directory by deleting files from it.
|
|
// (d) Use FailedPrecondition if the client performs conditional
|
|
// REST Get/Update/Delete on a resource and the resource on the
|
|
// server does not match the condition. E.g., conflicting
|
|
// read-modify-write on the same resource.
|
|
//
|
|
// This error code will not be generated by the gRPC framework.
|
|
//
|
|
// google.rpc.Code maps this to 400 Bad Request. 409 stays with
|
|
// AlreadyExists and Aborted: the code string "conflict" maps back
|
|
// to AlreadyExists. HTTP 412 and the other precondition statuses
|
|
// map to this code in the reverse direction only.
|
|
codes.FailedPrecondition: http.StatusBadRequest,
|
|
|
|
// Aborted indicates the operation was aborted, typically due to a
|
|
// concurrency issue like sequencer check failures, transaction aborts,
|
|
// etc.
|
|
//
|
|
// See litmus test above for deciding between FailedPrecondition,
|
|
// Aborted, and Unavailable.
|
|
//
|
|
// This error code will not be generated by the gRPC framework.
|
|
codes.Aborted: http.StatusConflict,
|
|
|
|
// OutOfRange means operation was attempted past the valid range.
|
|
// E.g., seeking or reading past end of file.
|
|
//
|
|
// Unlike InvalidArgument, this error indicates a problem that may
|
|
// be fixed if the system state changes. For example, a 32-bit file
|
|
// system will generate InvalidArgument if asked to read at an
|
|
// offset that is not in the range [0,2^32-1], but it will generate
|
|
// OutOfRange if asked to read from an offset past the current
|
|
// file size.
|
|
//
|
|
// There is a fair bit of overlap between FailedPrecondition and
|
|
// OutOfRange. We recommend using OutOfRange (the more specific
|
|
// error) when it applies so that callers who are iterating through
|
|
// a space can easily look for an OutOfRange error to detect when
|
|
// they are done.
|
|
//
|
|
// This error code will not be generated by the gRPC framework.
|
|
codes.OutOfRange: http.StatusBadRequest,
|
|
|
|
// Unimplemented indicates operation is not implemented or not
|
|
// supported/enabled in this service.
|
|
//
|
|
// This error code will be generated by the gRPC framework. Most
|
|
// commonly, you will see this error code when a method implementation
|
|
// is missing on the server. It can also be generated for unknown
|
|
// compression algorithms or a disagreement as to whether an RPC should
|
|
// be streaming.
|
|
codes.Unimplemented: http.StatusNotImplemented,
|
|
|
|
// Internal errors. Means some invariants expected by underlying
|
|
// system has been broken. If you see one of these errors,
|
|
// something is very broken.
|
|
//
|
|
// This error code will be generated by the gRPC framework in several
|
|
// internal error conditions.
|
|
codes.Internal: http.StatusInternalServerError,
|
|
|
|
// Unavailable indicates the service is currently unavailable.
|
|
// This is a most likely a transient condition and may be corrected
|
|
// by retrying with a backoff. Note that it is not always safe to retry
|
|
// non-idempotent operations.
|
|
//
|
|
// See litmus test above for deciding between FailedPrecondition,
|
|
// Aborted, and Unavailable.
|
|
//
|
|
// This error code will be generated by the gRPC framework during
|
|
// abrupt shutdown of a server process or network connection.
|
|
codes.Unavailable: http.StatusServiceUnavailable,
|
|
|
|
// DataLoss indicates unrecoverable data loss or corruption.
|
|
//
|
|
// This error code will not be generated by the gRPC framework.
|
|
codes.DataLoss: http.StatusInternalServerError,
|
|
|
|
// Unauthenticated indicates the request does not have valid
|
|
// authentication credentials for the operation.
|
|
//
|
|
// The gRPC framework will generate this error code when the
|
|
// authentication metadata is invalid or a Credentials callback fails,
|
|
// but also expect authentication middleware to generate it.
|
|
codes.Unauthenticated: http.StatusUnauthorized,
|
|
}
|
|
|
|
// HTTPStatusFromRPC maps a gRPC status code to an HTTP status following the
|
|
// Google API error model; unknown codes map to 0.
|
|
func HTTPStatusFromRPC(c codes.Code) int {
|
|
return codeStatus[c]
|
|
}
|
|
|
|
var statusCode = map[string]codes.Code{
|
|
CodeAccountNotFound: codes.NotFound,
|
|
CodeBadNonce: codes.InvalidArgument,
|
|
CodeConflict: codes.AlreadyExists,
|
|
CodeConnection: codes.Unknown,
|
|
CodeContentLengthRequired: codes.InvalidArgument,
|
|
CodeFailedToReadRequestBody: codes.InvalidArgument,
|
|
CodeForbidden: codes.PermissionDenied,
|
|
CodeInvalidContentType: codes.InvalidArgument,
|
|
CodeInvalidJSON: codes.InvalidArgument,
|
|
CodeInvalidParam: codes.InvalidArgument,
|
|
CodeInvalidRequest: codes.InvalidArgument,
|
|
CodeMalformed: codes.InvalidArgument,
|
|
CodeNotFound: codes.NotFound,
|
|
CodeNotReady: codes.Unavailable,
|
|
CodeRateLimitExceeded: codes.ResourceExhausted,
|
|
CodeRequestFailed: codes.Unknown,
|
|
CodeRequestTooLarge: codes.ResourceExhausted,
|
|
CodeTimeout: codes.DeadlineExceeded,
|
|
CodeTooEarly: codes.ResourceExhausted,
|
|
CodeUnauthorized: codes.Unauthenticated,
|
|
CodeUnexpected: codes.Internal,
|
|
|
|
"bad_request": codes.InvalidArgument,
|
|
//"unauthorized": codes.Unauthenticated,
|
|
"payment_required": codes.PermissionDenied,
|
|
//"forbidden": codes.PermissionDenied,
|
|
//"not_found": codes.NotFound,
|
|
"not_allowed": codes.InvalidArgument,
|
|
"not_acceptable": codes.InvalidArgument,
|
|
"auth_required": codes.Unauthenticated,
|
|
"request_timeout": codes.Canceled,
|
|
//"conflict": codes.AlreadyExists,
|
|
"gone": codes.NotFound,
|
|
"length_required": codes.InvalidArgument,
|
|
"precondition_failed": codes.FailedPrecondition,
|
|
"too_large": codes.InvalidArgument,
|
|
"uri_too_long": codes.InvalidArgument,
|
|
"unsupported_media_type": codes.InvalidArgument,
|
|
//"bad_request": codes.InvalidArgument,
|
|
"expectation_failed": codes.InvalidArgument,
|
|
"teapot": codes.InvalidArgument,
|
|
"misdirected": codes.InvalidArgument,
|
|
"unprocessable": codes.InvalidArgument,
|
|
"locked": codes.FailedPrecondition,
|
|
"failed_dependency": codes.FailedPrecondition,
|
|
//"too_early": codes.ResourceExhausted,
|
|
"upgrade_required": codes.FailedPrecondition,
|
|
"precondition_required": codes.FailedPrecondition,
|
|
"too_many_requests": codes.ResourceExhausted,
|
|
//"too_large": codes.InvalidArgument,
|
|
"legal_reason": codes.PermissionDenied,
|
|
"not_implemented": codes.Unimplemented,
|
|
"bad_gateway": codes.Unavailable,
|
|
"unavailable": codes.Unavailable,
|
|
"gateway_timeout": codes.Unavailable,
|
|
"not_supported": codes.Unimplemented,
|
|
"insufficient_storage": codes.ResourceExhausted,
|
|
"loop_detected": codes.ResourceExhausted,
|
|
"not_extended": codes.Unimplemented,
|
|
"authentication_required": codes.Unauthenticated,
|
|
}
|
|
|
|
// FromOAuth converts an OAuth 2.0 error response (RFC 6749 "error" and
|
|
// "error_description") into an *Error whose Code is the OAuth error code and
|
|
// whose HTTP status is 400, 401, 500 or 503 depending on the code.
|
|
func FromOAuth(code, descr string) *Error {
|
|
status := http.StatusBadRequest
|
|
switch code {
|
|
case "invalid_request",
|
|
"invalid_grant",
|
|
"invalid_scope",
|
|
"unsupported_response_type",
|
|
"unsupported_grant_type":
|
|
status = http.StatusBadRequest
|
|
case "temporarily_unavailable":
|
|
status = http.StatusServiceUnavailable
|
|
case "server_error":
|
|
status = http.StatusInternalServerError
|
|
case "invalid_client", "unauthorized_client", "access_denied":
|
|
status = http.StatusUnauthorized
|
|
}
|
|
|
|
return New(status, code, "%s", descr)
|
|
}
|