914 lines
38 KiB
Go
914 lines
38 KiB
Go
// Copyright 2025-present Gustavo "Guz" L. de Mello
|
|
// Copyright 2025-present The Lored.dev Contributors
|
|
//
|
|
// 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.
|
|
|
|
package exception
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
)
|
|
|
|
// BadRequest creates a new [Exception] with the "400 Bad Request" status code,
|
|
// a human readable message and the provided error describing what in the request
|
|
// was wrong. The severity of this Exception by default is [WARN].
|
|
//
|
|
// // "The HTTP 400 Bad Request client error response status code indicates that the
|
|
// // server would not process the request due to something the server considered to
|
|
// // be a client error. The reason for a 400 response is typically due to malformed
|
|
// // request syntax, invalid request message framing, or deceptive request routing.
|
|
// //
|
|
// // Clients that receive a 400 response should expect that repeating the request
|
|
// // without modification will fail with the same error."
|
|
// //
|
|
// // - Quoted from "400 Bad Request" by Mozilla Contributors, licensed under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/400
|
|
func BadRequest(err error, opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusBadRequest),
|
|
WithCode("Bad Request"),
|
|
WithMessage("The request sent is malformed, see the provided error for more information."),
|
|
WithError(err),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// Unathorized creates a new [Exception] with the "401 Unathorized" status code,
|
|
// a human readable message and error. The severity of this Exception by default
|
|
// is [WARN]. A "WWW-Authenticate" header should be sent with this exception,
|
|
// provided via the "authenticate" parameter.
|
|
//
|
|
// // "The HTTP 401 Unauthorized client error response status code indicates that a
|
|
// // request was not successful because it lacks valid authentication credentials
|
|
// // for the requested resource. This status code is sent with an HTTP WWW-Authenticate
|
|
// // response header that contains information on the authentication scheme the
|
|
// // server expects the client to include to make the request successfully.
|
|
// //
|
|
// // A 401 Unauthorized is similar to the 403 Forbidden response, except that a 403
|
|
// // is returned when a request contains valid credentials, but the client does not
|
|
// // have permissions to perform a certain action."
|
|
// //
|
|
// // - Quoted from "401 Unathorized" by Mozilla Contributors, licensed under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/401
|
|
func Unathorized(authenticate string, opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusUnauthorized),
|
|
WithCode("Unathorized"),
|
|
WithMessage("Not authorized/authenticated to be able to do this request."),
|
|
WithError(errors.New("user agent is not authenticated to do the request")),
|
|
WithSeverity(WARN),
|
|
|
|
WithHeader("WWW-Authenticate", authenticate),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// PaymentRequired creates a new [Exception] with the "402 Payment Required" status code,
|
|
// a human readable message and error. The severity of this Exception by default
|
|
// is [WARN].
|
|
//
|
|
// // "The HTTP 402 Payment Required client error response status code is a nonstandard
|
|
// // response status code reserved for future use.
|
|
// //
|
|
// // This status code was created to enable digital cash or (micro) payment systems
|
|
// // and would indicate that requested content is not available until the client makes
|
|
// // a payment. No standard use convention exists and different systems use it in
|
|
// // different contexts.
|
|
// //
|
|
// // [...]
|
|
// //
|
|
// // This status code is reserved but not defined. Actual implementations vary in
|
|
// // the format and contents of the response. No browser supports a 402, and an error
|
|
// // will be displayed as a generic 4xx status code."
|
|
// //
|
|
// // - Quoted from "402 Payment Required" by Mozilla Contributors, licensed under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/402
|
|
func PaymentRequired(opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusPaymentRequired),
|
|
WithCode("Payment Required"),
|
|
WithMessage("Payment is required to be able to see this page."),
|
|
WithError(errors.New("user agent needs to have payed to see this content")),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// Forbidden creates a new [Exception] with the "403 Forbidden" status code,
|
|
// a human readable message and error. The severity of this Exception by default
|
|
// is [WARN].
|
|
//
|
|
// // "The HTTP 403 Forbidden client error response status code indicates that the
|
|
// // server understood the request but refused to process it. This status is similar
|
|
// // to 401, except that for 403 Forbidden responses, authenticating or
|
|
// // re-authenticating makes no difference. The request failure is tied to application
|
|
// // logic, such as insufficient permissions to a resource or action.
|
|
// //
|
|
// // Clients that receive a 403 response should expect that repeating the request
|
|
// // without modification will fail with the same error. Server owners may decide
|
|
// // to send a 404 response instead of a 403 if acknowledging the existence of a
|
|
// // resource to clients with insufficient privileges is not desired."
|
|
// //
|
|
// // - Quoted from "403 Forbidden" by Mozilla Contributors, licensed under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/403
|
|
func Forbidden(opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusForbidden),
|
|
WithCode("Forbidden"),
|
|
WithMessage("You do not have the rights to do this request."),
|
|
WithError(errors.New("user agent does not have the rights to do the request")),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// NotFound creates a new [Exception] with the "404 Not Found" status code,
|
|
// a human readable message and error. The severity of this Exception by default
|
|
// is [WARN].
|
|
//
|
|
// // "The HTTP 404 Not Found client error response status code indicates that the
|
|
// // server cannot find the requested resource. Links that lead to a 404 page are
|
|
// // often called broken or dead links and can be subject to link rot.
|
|
// //
|
|
// // A 404 status code only indicates that the resource is missing without indicating
|
|
// // if this is temporary or permanent. If a resource is permanently removed, servers
|
|
// // should send the 410 Gone status instead.
|
|
// //
|
|
// // 404 errors on a website can lead to a poor user experience for your visitors,
|
|
// // so the number of broken links (internal and external) should be minimized to
|
|
// // prevent frustration for readers. Common causes of 404 responses are mistyped
|
|
// // URLs or pages that are moved or deleted without redirection. For more
|
|
// // information, see the Redirections in HTTP guide."
|
|
// //
|
|
// // - Quoted from "404 Not Found" by Mozilla Contributors, licensed under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/404
|
|
func NotFound(opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusNotFound),
|
|
WithCode("Not Found"),
|
|
WithMessage("This content does not exists."),
|
|
WithError(errors.New("user agent requested content that does not exists")),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// MethodNotAllowed creates a new [Exception] with the "405 Method Not Allowed" status code,
|
|
// a human readable message and error, and a "Allow" header with the methods provided via the
|
|
// "allowed" parameter. The severity of this Exception by default is [WARN].
|
|
//
|
|
// // "The HTTP 405 Method Not Allowed client error response status code indicates
|
|
// // that the server knows the request method, but the target resource doesn't support
|
|
// // this method. The server must generate an Allow header in a 405 response with a
|
|
// // list of methods that the target resource currently supports.
|
|
// //
|
|
// // Improper server-side permissions set on files or directories may cause a 405
|
|
// // response when the request would otherwise be expected to succeed."
|
|
// //
|
|
// // - Quoted from "405 Method Not Allowed" by Mozilla Contributors, licensed under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/405
|
|
func MethodNotAllowed(allowed []string, opts ...Option) Exception {
|
|
a := strings.Join(allowed, ", ")
|
|
o := []Option{
|
|
WithStatus(http.StatusMethodNotAllowed),
|
|
WithCode("Method Not Allowed"),
|
|
WithMessage("The method is not allowed for this endpoints."),
|
|
WithError(fmt.Errorf("user agent tried to use method which is not a allowed method (allowed: %s)", a)),
|
|
WithSeverity(WARN),
|
|
|
|
WithHeader("Allow", a),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// NotAcceptable creates a new [Exception] with the "406 Not Acceptable" status code,
|
|
// a human readable message and error, and a list of accepted mime types provided via
|
|
// the "accepted" parameter. The severity of this Exception by default is [WARN].
|
|
//
|
|
// // "The HTTP 406 Not Acceptable client error response status code indicates that the
|
|
// // server could not produce a response matching the list of acceptable values defined
|
|
// // in the request's proactive content negotiation headers and that the server was
|
|
// // unwilling to supply a default representation.
|
|
// //
|
|
// // [...]
|
|
// //
|
|
// // A server may return responses that differ from the request's accept headers.
|
|
// // In such cases, a 200 response with a default resource that doesn't match the client's
|
|
// // list of acceptable content negotiation values may be preferable to sending a 406 response.
|
|
// //
|
|
// // If a server returns a 406, the body of the message should contain the list of
|
|
// // available representations for the resource, allowing the user to choose, although
|
|
// // no standard way for this is defined."
|
|
// //
|
|
// // - Quoted from "406 Not Acceptable" by Mozilla Contributors, licensed under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/406
|
|
func NotAcceptable(accepted []string, opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusNotAcceptable),
|
|
WithCode("Not Acceptable"),
|
|
WithMessage("Unable to find any content that conforms to the request."),
|
|
WithError(errors.New("no content conforms to the requested criteria of the user agent")),
|
|
WithData("accepted", accepted),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// ProxyAuthenticationRequired creates a new [Exception] with the "407 Proxy Authentication Required"
|
|
// status code, a human readable message and error. The severity of this Exception by default is [WARN].
|
|
// A "Proxy-Authenticate" header should be sent with this exception, provided via the
|
|
// "authenticate" parameter.
|
|
//
|
|
// // "The HTTP 407 Proxy Authentication Required client error response status code indicates that
|
|
// // the request did not succeed because it lacks valid authentication credentials for the proxy
|
|
// // server that sits between the client and the server with access to the requested resource.
|
|
// //
|
|
// // This response is sent with a Proxy-Authenticate header that contains information on how to
|
|
// // correctly authenticate requests. The client may repeat the request with a new or replaced
|
|
// // Proxy-Authorization header field."
|
|
// //
|
|
// // - Quoted from "407 Proxy Authentication Required" by Mozilla Contributors, licensed under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/407
|
|
func ProxyAuthenticationRequired(authenticate string, opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusProxyAuthRequired),
|
|
WithCode("Proxy Authentication Required"),
|
|
WithMessage("Authorization/authentication via proxy is needed to access this content."),
|
|
WithError(errors.New("user agent is missing proxy authorization/authentication")),
|
|
WithSeverity(WARN),
|
|
|
|
WithHeader("Proxy-Authenticate", authenticate),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// RequestTimeout creates a new [Exception] with the "408 Request Timeout" status code, a human
|
|
// readable message and error, with a "Connection: close" header alongside. The severity of this
|
|
// Exception by default is [WARN].
|
|
//
|
|
// // "The HTTP 408 Request Timeout client error response status code indicates that the server
|
|
// // would like to shut down this unused connection. A 408 is sent on an idle connection by some
|
|
// // servers, even without any previous request by the client.
|
|
// //
|
|
// // A server should send the Connection: close header field in the response, since 408 implies
|
|
// // that the server has decided to close the connection rather than continue waiting.
|
|
// //
|
|
// // This response is used much more since some browsers, like Chrome and Firefox, use HTTP
|
|
// // pre-connection mechanisms to speed up surfing."
|
|
// //
|
|
// // - Quoted from "408 Request Timeout" by Mozilla Contributors, licensed under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/408
|
|
func RequestTimeout(opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusRequestTimeout),
|
|
WithCode("Request Timeout"),
|
|
WithMessage("This request was shut down."),
|
|
WithError(errors.New("request timed out")),
|
|
WithSeverity(WARN),
|
|
|
|
WithHeader("Connection", "close"),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// Conflict creates a new [Exception] with the "409 Conflict" status code, a human
|
|
// readable message and error. The severity of this Exception by default is [WARN].
|
|
//
|
|
// // "The HTTP 409 Conflict client error response status code indicates a request
|
|
// // conflict with the current state of the target resource.
|
|
// //
|
|
// // In WebDAV remote web authoring, 409 conflict responses are errors sent to the
|
|
// // client so that a user might be able to resolve a conflict and resubmit the
|
|
// // request. [...] Additionally, you may get a 409 response when uploading a file
|
|
// // that is older than the existing one on the server, resulting in a version
|
|
// // control conflict.
|
|
// //
|
|
// // In other systems, 409 responses may be used for implementation-specific purposes,
|
|
// // such as to indicate that the server has received multiple requests to update
|
|
// // the same resource."
|
|
// //
|
|
// // - Quoted from "409 Conflict" by Mozilla Contributors, licensed under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/409
|
|
func Conflict(opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusConflict),
|
|
WithCode("Conflict"),
|
|
WithMessage("Request conflicts with the current state of the server."),
|
|
WithError(errors.New("user agent sent a request which conflicts with the current state")),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// Gone creates a new [Exception] with the "410 Gone" status code, a human
|
|
// readable message and error. The severity of this Exception by default is [WARN].
|
|
//
|
|
// // "The HTTP 410 Gone client error response status code indicates that the target
|
|
// // resource is no longer available at the origin server and that this condition
|
|
// // is likely to be permanent. A 410 response is cacheable by default.
|
|
// //
|
|
// // Clients should not repeat requests for resources that return a 410 response,
|
|
// // and website owners should remove or replace links that return this code.
|
|
// // If server owners don't know whether this condition is temporary or permanent, Exception
|
|
// // a 404 status code should be used instead."
|
|
// //
|
|
// // - Quoted from "410 Gone" by Mozilla Contributors, licensed under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/410
|
|
func Gone(opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusGone),
|
|
WithCode("Gone"),
|
|
WithMessage("The requested content has been permanently deleted."),
|
|
WithError(errors.New("user agent has requested content that has been permanently deleted")),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// LengthRequired creates a new [Exception] with the "411 Length Required" status
|
|
// code, a human readable message and error. The severity of this Exception by
|
|
// default is [WARN].
|
|
//
|
|
// // "The HTTP 411 Length Required client error response status code indicates that
|
|
// // the server refused to accept the request without a defined Content-Length header."
|
|
// //
|
|
// // - Quoted from "411 Length Required" by Mozilla Contributors, licensed under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/411
|
|
func LengthRequired(opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusLengthRequired),
|
|
WithCode("Length Required"),
|
|
WithMessage(`The request does not contain a "Content-Length" header, which is required.`),
|
|
WithError(errors.New(`user agent has requested without required "Content-Length" header`)),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// PreconditionFailed creates a new [Exception] with the "412 Precondition Failed"
|
|
// status code, a human readable message and error. The severity of this Exception
|
|
// by default is [WARN].
|
|
//
|
|
// // "The HTTP 412 Precondition Failed client error response status code indicates
|
|
// // that access to the target resource was denied. This happens with conditional
|
|
// // requests on methods other than GET or HEAD when the condition defined by the
|
|
// // If-Unmodified-Since or If-Match headers is not fulfilled. In that case, the
|
|
// // request (usually an upload or a modification of a resource) cannot be made
|
|
// // and this error response is sent back."
|
|
// //
|
|
// // - Quoted from "412 Precondition Failed" by Mozilla Contributors, licensed
|
|
// // under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/412
|
|
func PreconditionFailed(err error, opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusPreconditionFailed),
|
|
WithCode("Precondition Failed"),
|
|
WithMessage("The request does passes required preconditions."),
|
|
WithError(err),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// ContentTooLarge creates a new [Exception] with the "413 Content Too Large"
|
|
// status code, a human readable message and error. The severity of this
|
|
// Exception by default is [WARN].
|
|
//
|
|
// // "The HTTP 413 Content Too Large client error response status code indicates
|
|
// // that the request entity was larger than limits defined by server. The server
|
|
// // might close the connection or return a Retry-After header field."
|
|
// //
|
|
// // - Quoted from "413 Content Too Large" by Mozilla Contributors, licensed
|
|
// // under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/413
|
|
func ContentTooLarge(opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusRequestEntityTooLarge),
|
|
WithCode("Content Too Large"),
|
|
WithMessage("The request body is larger than expected."),
|
|
WithError(errors.New("user agent sent request body that is larger than expected")),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// URITooLong creates a new [Exception] with the "414 URI Too Long"
|
|
// status code, a human readable message and error. The severity of this
|
|
// Exception by default is [WARN].
|
|
//
|
|
// // "The HTTP 414 URI Too Long client error response status code indicates
|
|
// // that a URI requested by the client was longer than the server is willing
|
|
// // to interpret.
|
|
// //
|
|
// // There are a few rare conditions when this error might occur:
|
|
// //
|
|
// // - a client has improperly converted a POST request to a GET request with
|
|
// // long query information,
|
|
// //
|
|
// // - a client has descended into a loop of redirection (for example, a
|
|
// // redirected URI prefix that points to a suffix of itself), or
|
|
// //
|
|
// // - the server is under attack by a client attempting to exploit potential
|
|
// // security holes."
|
|
// //
|
|
// // - Quoted from "414 URI Too Long" by Mozilla Contributors, licensed under
|
|
// // CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/414
|
|
func URITooLong(opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusRequestURITooLong),
|
|
WithCode("URI Too Long"),
|
|
WithMessage("The request has a URI longer than expected."),
|
|
WithError(errors.New("user agent sent request with URI longer than expected")),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// UnsupportedMediaType creates a new [Exception] with the "415 Unsupported Media Type"
|
|
// status code, a human readable message and error. The severity of this Exception by
|
|
// default is [WARN].
|
|
//
|
|
// // "The HTTP 415 Unsupported Media Type client error response status code indicates
|
|
// // that the server refused to accept the request because the message content format
|
|
// // is not supported.
|
|
// //
|
|
// // The format problem might be due to the request's indicated Content-Type or
|
|
// // Content-Encoding, or as a result of processing the request message content. Some
|
|
// // servers may be strict about the expected Content-Type of requests. For example,
|
|
// // sending UTF8 instead of UTF-8 to specify the UTF-8 charset may cause the server
|
|
// // to consider the media type invalid."
|
|
// //
|
|
// // - Quoted from "415 Unsupported Media Type" by Mozilla Contributors, licensed
|
|
// // under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/415
|
|
func UnsupportedMediaType(opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusUnsupportedMediaType),
|
|
WithCode("Unsupported Media Type"),
|
|
WithMessage("The request unsupported media type."),
|
|
WithError(errors.New("user agent sent request with unsupported media type")),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// RangeNotSatisfiable creates a new [Exception] with the "416 Range Not Satisfiable"
|
|
// status code, a human readable message and error. The severity of this Exception by
|
|
// default is [WARN]. A "Content-Range" header is sent with the provided number of
|
|
// bytes via the "contentRange" parameter.
|
|
//
|
|
// // "The HTTP 416 Range Not Satisfiable client error response status code indicates
|
|
// // that a server could not serve the requested ranges. The most likely reason for
|
|
// // this response is that the document doesn't contain such ranges, or that the
|
|
// // Range header value, though syntactically correct, doesn't make sense.
|
|
// //
|
|
// // The 416 response message should contain a Content-Range indicating an unsatisfied
|
|
// // range (that is a '*') followed by a '/' and the current length of the resource,
|
|
// // e.g., Content-Range: bytes */12777
|
|
// //
|
|
// // When encountering this error, browsers typically either abort the operation
|
|
// // (for example, a download will be considered non-resumable) or request the whole
|
|
// // document again without ranges."
|
|
// //
|
|
// // - Quoted from "416 Range Not Satisfiable" by Mozilla Contributors, licensed
|
|
// // under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/416
|
|
func RangeNotSatisfiable(contentRange int, opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusUnsupportedMediaType),
|
|
WithCode("Range Not Satisfiable"),
|
|
WithMessage(`Request's "Range" header cannot be satified.`),
|
|
WithError(errors.New(`user agent sent request with unsitisfiable "Range" header`)),
|
|
WithSeverity(WARN),
|
|
|
|
WithHeader("Content-Range", fmt.Sprintf("bytes */%d", contentRange)),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// ExpectationFailed creates a new [Exception] with the "417 Expectation Failed"
|
|
// status code, a human readable message and error. The severity of this Exception
|
|
// by default is [WARN].
|
|
//
|
|
// // "The HTTP 417 Expectation Failed client error response status code indicates
|
|
// // that the expectation given in the request's Expect header could not be met.
|
|
// // After receiving a 417 response, a client should repeat the request without an
|
|
// // Expect request header, including the file in the request body without waiting
|
|
// // for a 100 response. See the Expect header documentation for more details."
|
|
// //
|
|
// // - Quoted from "417 Expectation Failed" by Mozilla Contributors, licensed under
|
|
// // CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/417
|
|
func ExpectationFailed(opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusExpectationFailed),
|
|
WithCode("Exception Failed"),
|
|
WithMessage(`Request's "Expect" header cannot be met.`),
|
|
WithError(errors.New(`user agent sent request with unmetable "Expect" header`)),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// ImATeapot creates a new [Exception] with the "418 I'm a teapot" status code,
|
|
// a human readable message and error. The severity of this Exception by default
|
|
// is [WARN].
|
|
//
|
|
// // "The HTTP 418 I'm a teapot status response code indicates that the server
|
|
// // refuses to brew coffee because it is, permanently, a teapot. A combined
|
|
// // coffee/tea pot that is temporarily out of coffee should instead return 503.
|
|
// // This error is a reference to Hyper Text Coffee Pot Control Protocol defined
|
|
// // in April Fools' jokes in 1998 and 2014.
|
|
// //
|
|
// // Some websites use this response for requests they do not wish to handle,
|
|
// // such as automated queries."
|
|
// //
|
|
// // - Quoted from "418 I'm a teapot" by Mozilla Contributors, licensed under
|
|
// // CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/418
|
|
func ImATeapot(opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusTeapot),
|
|
WithCode("I'm a teapot"),
|
|
WithMessage("The request to brew coffee with a teapot is impossible."),
|
|
WithError(errors.New("user agent tried to brew coffee with a teapot, an impossible request")),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// MisdirectedRequest creates a new [Exception] with the "421 Misdirected Request"
|
|
// status code, a human readable message and error. The severity of this Exception
|
|
// by default is [WARN].
|
|
//
|
|
// // "The HTTP 421 Misdirected Request client error response status code indicates
|
|
// // that the request was directed to a server that is not able to produce a response.
|
|
// // This can be sent by a server that is not configured to produce responses for the
|
|
// // combination of scheme and authority that are included in the request URI.
|
|
// //
|
|
// // Clients may retry the request over a different connection."
|
|
// //
|
|
// // - Quoted from "421 Misdirected Request" by Mozilla Contributors, licensed under
|
|
// // CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/421
|
|
func MisdirectedRequest(opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusMisdirectedRequest),
|
|
WithCode("Misdirected Request"),
|
|
WithMessage("The request was directed to a location unable to produce a response."),
|
|
WithError(errors.New("user agent requested on a location that is unable to produce a response.")),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// UnprocessableContent creates a new [Exception] with the "422 Unprocessable Content"
|
|
// status code, a human readable message and error. The severity of this Exception
|
|
// by default is [WARN].
|
|
//
|
|
// // "The HTTP 422 Unprocessable Content client error response status code indicates
|
|
// // that the server understood the content type of the request content, and the syntax
|
|
// // of the request content was correct, but it was unable to process the contained
|
|
// // instructions.
|
|
// //
|
|
// // Clients that receive a 422 response should expect that repeating the request
|
|
// // without modification will fail with the same error."
|
|
// //
|
|
// // - Quoted from "422 Unprocessable Content" by Mozilla Contributors, licensed
|
|
// // under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/422
|
|
func UnprocessableContent(opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusUnprocessableEntity),
|
|
WithCode("Unprocessable Content"),
|
|
WithMessage("Unable to follow request due to semantic errors."),
|
|
WithError(errors.New("user agent sent request containing semantic errors.")),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// Locked creates a new [Exception] with the "423 Locked" status code, a human
|
|
// readable message and error. The severity of this Exception by default is [WARN].
|
|
//
|
|
// // "The HTTP 423 Locked client error response status code indicates that a
|
|
// // resource is locked, meaning it can't be accessed. Its response body should
|
|
// // contain information in WebDAV's XML format.
|
|
// //
|
|
// // NOTE: The ability to lock a resource to prevent conflicts is specific to
|
|
// // some WebDAV servers. Browsers accessing web pages will never encounter
|
|
// // this status code; in the erroneous cases it happens, they will handle
|
|
// // it as a generic 400 status code."
|
|
// //
|
|
// // - Quoted from "423 Locked" by Mozilla Contributors, licensed under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/423
|
|
func Locked(opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusUnprocessableEntity),
|
|
WithCode("Locked"),
|
|
WithMessage("This resource is locked."),
|
|
WithError(errors.New("user agent requested a locked resource")),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// FailedDependency creates a new [Exception] with the "424 Failed Dependency"
|
|
// status code, a human readable message and error. The severity of this
|
|
// Exception by default is [WARN].
|
|
//
|
|
// // "The HTTP 424 Failed Dependency client error response status code
|
|
// // indicates that the method could not be performed on the resource
|
|
// // because the requested action depended on another action, and that
|
|
// // action failed.
|
|
// //
|
|
// // Regular web servers typically do not return this status code, but
|
|
// // some protocols like WebDAV can return it. For example, in WebDAV,
|
|
// // if a PROPPATCH request was issued, and one command fails then
|
|
// // automatically every other command will also fail with
|
|
// // 424 Failed Dependency."
|
|
// //
|
|
// // - Quoted from "424 Failed Dependency" by Mozilla Contributors,
|
|
// // licensed under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/424
|
|
func FailedDependency(opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusFailedDependency),
|
|
WithCode("Failed Dependency"),
|
|
WithMessage("Cannot respond due to failure of a previous request."),
|
|
WithError(errors.New("request cannot be due to failure of a previous request")),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// TooEarly creates a new [Exception] with the "425 Too Early" status code,
|
|
// a human readable message and error. The severity of this Exception by
|
|
// default is [WARN].
|
|
//
|
|
// // "LIMITED AVAILABILITY
|
|
// //
|
|
// // The HTTP 425 Too Early client error response status code indicates
|
|
// // that the server was unwilling to risk processing a request that might
|
|
// // be replayed to avoid potential replay attacks.
|
|
// //
|
|
// // If a client has interacted with a server recently, early data
|
|
// // (also known as zero round-trip time (0-RTT) data) allows the client
|
|
// // to send data to a server in the first round trip of a connection,
|
|
// // without waiting for the TLS handshake to complete. A client that
|
|
// // sends a request in early data does not need to include the
|
|
// // Early-Data header."
|
|
// //
|
|
// // - Quoted from "425 Too Early" by Mozilla Contributors, licensed under
|
|
// // CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/425
|
|
func TooEarly(opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusTooEarly),
|
|
WithCode("Too Early"),
|
|
WithMessage("Unwilling to process the request to avoid replay attacks."),
|
|
WithError(errors.New("request was rejected to avoid replay attacks")),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// UpgradeRequired creates a new [Exception] with the "426 Upgrade Required"
|
|
// status code, a human readable message and error. The severity of this
|
|
// Exception by default is [WARN]. A "Upgrade" header is sent with the value
|
|
// provided by the "upgrade" parameter.
|
|
//
|
|
// // "The HTTP 426 Upgrade Required client error response status code
|
|
// // indicates that the server refused to perform the request using the
|
|
// // current protocol but might be willing to do so after the client
|
|
// // upgrades to a different protocol.
|
|
// //
|
|
// // The server sends an Upgrade header with this response to indicate
|
|
// // the required protocol(s)."
|
|
// //
|
|
// // - Quoted from "426 Upgrade Required" by Mozilla Contributors,
|
|
// // licensed under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/426
|
|
func UpgradeRequired(upgrade string, opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusUpgradeRequired),
|
|
WithCode("Upgrade Required"),
|
|
WithMessage("An upgrade to the protocol is required to do this request."),
|
|
WithError(fmt.Errorf("user agent needs to upgrade to protocol %q", upgrade)),
|
|
WithHeader("Upgrade", upgrade),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// PreconditionRequired creates a new [Exception] with the "428 Precondition Required"
|
|
// status code, a human readable message and error. The severity of this Exception
|
|
// by default is [WARN].
|
|
//
|
|
// // "The HTTP 428 Precondition Required client error response status code indicates
|
|
// // that the server requires the request to be conditional.
|
|
// //
|
|
// // Typically, a 428 response means that a required precondition header such as
|
|
// // If-Match is missing. When a precondition header does not match the server-side
|
|
// // state, the response should be 412 Precondition Failed."
|
|
// //
|
|
// // - Quoted from "428 Precondition Required" by Mozilla Contributors,
|
|
// // licensed under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/426
|
|
func PreconditionRequired(opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusPreconditionRequired),
|
|
WithCode("Precondition Required"),
|
|
WithMessage("The request needs to be conditional."),
|
|
WithError(errors.New("user agent sent request that is not conditional")),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// TooManyRequests creates a new [Exception] with the "429 Too Many Requests"
|
|
// status code, a human readable message and error. The severity of this
|
|
// Exception by default is [WARN].
|
|
//
|
|
// To provide a "Retry-After" header, use the [WithHeader] option function.
|
|
//
|
|
// // "The HTTP 429 Too Many Requests client error response status code
|
|
// // indicates the client has sent too many requests in a given amount
|
|
// // of time. This mechanism of asking the client to slow down the rate
|
|
// // of requests is commonly called "rate limiting".
|
|
// //
|
|
// // A Retry-After header may be included to this response to indicate
|
|
// // how long a client should wait before making the request again."
|
|
// //
|
|
// // - Quoted from "429 Too Many Requests" by Mozilla Contributors,
|
|
// // licensed under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/429
|
|
func TooManyRequests(opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusTooManyRequests),
|
|
WithCode("Too Many Requests"),
|
|
WithMessage("Too many requests were sent in the span of a short time."),
|
|
WithError(errors.New("user agent sent too many requests")),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// RequestHeaderFieldsTooLarge creates a new [Exception] with the
|
|
// "431 Request Header Fields Too Large" status code, a human readable
|
|
// message and error. The severity of this Exception by default is [WARN].
|
|
//
|
|
// // "The HTTP 431 Request Header Fields Too Large client error response
|
|
// // status code indicates that the server refuses to process the request
|
|
// // because the request's HTTP headers are too long. The request may
|
|
// // be resubmitted after reducing the size of the request headers.
|
|
// //
|
|
// // 431 can be used when the total size of request headers is too large
|
|
// // or when a single header field is too large. To help clients running
|
|
// // into this error, indicate which of the two is the problem in the
|
|
// // response body and, ideally, say which headers are too large. This
|
|
// // lets people attempt to fix the problem, such as by clearing cookies.
|
|
// //
|
|
// // Servers will often produce this status if:
|
|
// // - The Referer URL is too long
|
|
// // - There are too many Cookies in the request"
|
|
// //
|
|
// // - Quoted from "431 Request Header Fields Too Large" by Mozilla Contributors,
|
|
// // licensed under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/431
|
|
func RequestHeaderFieldsTooLarge(opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusRequestHeaderFieldsTooLarge),
|
|
WithCode("Request Header Fields Too Large"),
|
|
WithMessage("Headers fields are larger than expected."),
|
|
WithError(errors.New("user agent sent header fields larger than expected")),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|
|
|
|
// UnavailableForLegalReasons creates a new [Exception] with the
|
|
// "451 Unavailable For Legal Reasons" status code, a human readable
|
|
// message and error. The severity of this Exception by default is [WARN].
|
|
//
|
|
// // "The HTTP 451 Unavailable For Legal Reasons client error response
|
|
// // status code indicates that the user requested a resource that is
|
|
// // not available due to legal reasons, such as a web page for which
|
|
// // a legal action has been issued."
|
|
// //
|
|
// // - Quoted from "451 Unavailable For Legal Reasons" by Mozilla Contributors,
|
|
// // licensed under CC-BY-SA 2.5.
|
|
// //
|
|
// // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/451
|
|
func UnavailableForLegalReasons(opts ...Option) Exception {
|
|
o := []Option{
|
|
WithStatus(http.StatusUnavailableForLegalReasons),
|
|
WithCode("Unavailable For Legal Reasons"),
|
|
WithMessage("Content cannot be legally be provided."),
|
|
WithError(errors.New("user agent requested content that cannot be legally provided")),
|
|
WithSeverity(WARN),
|
|
}
|
|
o = append(o, opts...)
|
|
|
|
return newException(o...)
|
|
}
|