Files
axum/src/extract/rejection.rs
T

364 lines
10 KiB
Rust
Raw Normal View History

2021-06-07 16:28:40 +02:00
//! Rejection response types.
use http::StatusCode;
2021-06-13 11:01:40 +02:00
use tower::BoxError;
2021-06-06 11:37:08 +02:00
use super::IntoResponse;
use crate::body::Body;
macro_rules! define_rejection {
(
#[status = $status:ident]
#[body = $body:expr]
2021-06-07 16:28:40 +02:00
$(#[$m:meta])*
pub struct $name:ident;
2021-06-06 11:37:08 +02:00
) => {
2021-06-07 16:28:40 +02:00
$(#[$m])*
2021-06-06 11:37:08 +02:00
#[derive(Debug)]
#[non_exhaustive]
pub struct $name;
2021-06-06 11:37:08 +02:00
2021-06-06 22:41:52 +02:00
impl IntoResponse for $name {
2021-06-06 11:37:08 +02:00
fn into_response(self) -> http::Response<Body> {
let mut res = http::Response::new(Body::from($body));
*res.status_mut() = http::StatusCode::$status;
res
}
}
};
(
#[status = $status:ident]
#[body = $body:expr]
2021-06-07 16:28:40 +02:00
$(#[$m:meta])*
2021-06-06 11:37:08 +02:00
pub struct $name:ident (BoxError);
) => {
2021-06-07 16:28:40 +02:00
$(#[$m])*
2021-06-06 11:37:08 +02:00
#[derive(Debug)]
pub struct $name(pub(super) tower::BoxError);
impl $name {
pub(super) fn from_err<E>(err: E) -> Self
where
E: Into<tower::BoxError>,
{
Self(err.into())
}
}
2021-06-06 22:41:52 +02:00
impl IntoResponse for $name {
2021-06-06 11:37:08 +02:00
fn into_response(self) -> http::Response<Body> {
let mut res =
http::Response::new(Body::from(format!(concat!($body, ": {}"), self.0)));
*res.status_mut() = http::StatusCode::$status;
res
}
}
};
}
define_rejection! {
#[status = BAD_REQUEST]
#[body = "Query string was invalid or missing"]
2021-06-07 16:28:40 +02:00
/// Rejection type for [`Query`](super::Query).
pub struct QueryStringMissing;
2021-06-06 11:37:08 +02:00
}
define_rejection! {
#[status = BAD_REQUEST]
#[body = "Failed to parse the response body as JSON"]
2021-06-07 16:28:40 +02:00
/// Rejection type for [`Json`](super::Json).
2021-06-06 11:37:08 +02:00
pub struct InvalidJsonBody(BoxError);
}
define_rejection! {
#[status = BAD_REQUEST]
#[body = "Expected request with `Content-Type: application/json`"]
2021-06-07 16:28:40 +02:00
/// Rejection type for [`Json`](super::Json) used if the `Content-Type`
/// header is missing.
pub struct MissingJsonContentType;
2021-06-06 11:37:08 +02:00
}
define_rejection! {
#[status = INTERNAL_SERVER_ERROR]
#[body = "Missing request extension"]
2021-06-07 16:28:40 +02:00
/// Rejection type for [`Extension`](super::Extension) if an expected
/// request extension was not found.
pub struct MissingExtension;
2021-06-06 11:37:08 +02:00
}
define_rejection! {
#[status = BAD_REQUEST]
#[body = "Failed to buffer the request body"]
2021-06-07 16:28:40 +02:00
/// Rejection type for extractors that buffer the request body. Used if the
/// request body cannot be buffered due to an error.
2021-06-06 11:37:08 +02:00
pub struct FailedToBufferBody(BoxError);
}
define_rejection! {
#[status = BAD_REQUEST]
#[body = "Response body didn't contain valid UTF-8"]
2021-06-07 16:28:40 +02:00
/// Rejection type used when buffering the request into a [`String`] if the
/// body doesn't contain valid UTF-8.
2021-06-06 11:37:08 +02:00
pub struct InvalidUtf8(BoxError);
}
define_rejection! {
#[status = PAYLOAD_TOO_LARGE]
#[body = "Request payload is too large"]
2021-06-09 08:14:20 +02:00
/// Rejection type for [`ContentLengthLimit`](super::ContentLengthLimit) if
/// the request body is too large.
pub struct PayloadTooLarge;
2021-06-06 11:37:08 +02:00
}
define_rejection! {
#[status = LENGTH_REQUIRED]
#[body = "Content length header is required"]
2021-06-09 08:14:20 +02:00
/// Rejection type for [`ContentLengthLimit`](super::ContentLengthLimit) if
/// the request is missing the `Content-Length` header or it is invalid.
pub struct LengthRequired;
2021-06-06 11:37:08 +02:00
}
define_rejection! {
#[status = INTERNAL_SERVER_ERROR]
2021-06-13 11:22:02 +02:00
#[body = "No url params found for matched route. This is a bug in awebframework. Please open an issue"]
2021-06-07 16:28:40 +02:00
/// Rejection type for [`UrlParamsMap`](super::UrlParamsMap) and
/// [`UrlParams`](super::UrlParams) if you try and extract the URL params
/// more than once.
pub struct MissingRouteParams;
2021-06-06 11:37:08 +02:00
}
define_rejection! {
#[status = INTERNAL_SERVER_ERROR]
#[body = "Cannot have two request body extractors for a single handler"]
2021-06-07 16:28:40 +02:00
/// Rejection type used if you try and extract the request body more than
/// once.
2021-06-09 09:03:09 +02:00
pub struct BodyAlreadyExtracted;
}
define_rejection! {
#[status = INTERNAL_SERVER_ERROR]
2021-06-19 12:50:33 +02:00
#[body = "Cannot have two `Request<_>` extractors for a single handler"]
2021-06-09 09:03:09 +02:00
/// Rejection type used if you try and extract the request more than once.
pub struct RequestAlreadyExtracted;
2021-06-06 11:37:08 +02:00
}
2021-06-06 22:41:52 +02:00
2021-06-13 11:01:40 +02:00
define_rejection! {
#[status = BAD_REQUEST]
#[body = "Form requests must have `Content-Type: x-www-form-urlencoded`"]
/// Rejection type used if you try and extract the request more than once.
pub struct InvalidFormContentType;
}
2021-06-07 16:28:40 +02:00
/// Rejection type for [`UrlParams`](super::UrlParams) if the capture route
/// param didn't have the expected type.
2021-06-06 22:41:52 +02:00
#[derive(Debug)]
pub struct InvalidUrlParam {
type_name: &'static str,
}
impl InvalidUrlParam {
pub(super) fn new<T>() -> Self {
InvalidUrlParam {
type_name: std::any::type_name::<T>(),
}
}
}
impl IntoResponse for InvalidUrlParam {
fn into_response(self) -> http::Response<Body> {
let mut res = http::Response::new(Body::from(format!(
"Invalid URL param. Expected something of type `{}`",
self.type_name
)));
*res.status_mut() = http::StatusCode::BAD_REQUEST;
res
}
}
2021-06-13 11:01:40 +02:00
/// Rejection type for extractors that deserialize query strings if the input
/// couldn't be deserialized into the target type.
#[derive(Debug)]
pub struct FailedToDeserializeQueryString {
error: BoxError,
type_name: &'static str,
}
impl FailedToDeserializeQueryString {
pub(super) fn new<T, E>(error: E) -> Self
where
E: Into<BoxError>,
{
FailedToDeserializeQueryString {
error: error.into(),
type_name: std::any::type_name::<T>(),
}
}
}
impl IntoResponse for FailedToDeserializeQueryString {
fn into_response(self) -> http::Response<Body> {
let mut res = http::Response::new(Body::from(format!(
"Failed to deserialize query string. Expected something of type `{}`. Error: {}",
self.type_name, self.error,
)));
*res.status_mut() = http::StatusCode::BAD_REQUEST;
res
}
}
2021-06-13 12:06:59 +02:00
macro_rules! composite_rejection {
(
$(#[$m:meta])*
pub enum $name:ident {
$($variant:ident),+
$(,)?
}
) => {
$(#[$m])*
#[derive(Debug)]
#[non_exhaustive]
pub enum $name {
$(
#[allow(missing_docs)]
$variant($variant)
),+
}
impl IntoResponse for $name {
fn into_response(self) -> http::Response<Body> {
match self {
$(
Self::$variant(inner) => inner.into_response(),
)+
}
}
}
$(
impl From<$variant> for $name {
fn from(inner: $variant) -> Self {
Self::$variant(inner)
}
}
)+
};
}
composite_rejection! {
/// Rejection used for [`Query`](super::Query).
///
/// Contains one variant for each way the [`Query`](super::Query) extractor
/// can fail.
pub enum QueryRejection {
QueryStringMissing,
FailedToDeserializeQueryString,
}
}
composite_rejection! {
/// Rejection used for [`Form`](super::Form).
///
/// Contains one variant for each way the [`Form`](super::Form) extractor
/// can fail.
pub enum FormRejection {
InvalidFormContentType,
QueryStringMissing,
FailedToDeserializeQueryString,
FailedToBufferBody,
BodyAlreadyExtracted,
}
}
composite_rejection! {
/// Rejection used for [`Json`](super::Json).
///
/// Contains one variant for each way the [`Json`](super::Json) extractor
/// can fail.
pub enum JsonRejection {
InvalidJsonBody,
MissingJsonContentType,
BodyAlreadyExtracted,
}
}
composite_rejection! {
/// Rejection used for [`UrlParams`](super::UrlParams).
///
/// Contains one variant for each way the [`UrlParams`](super::UrlParams) extractor
/// can fail.
pub enum UrlParamsRejection {
InvalidUrlParam,
MissingRouteParams,
}
}
composite_rejection! {
/// Rejection used for [`Bytes`](bytes::Bytes).
///
/// Contains one variant for each way the [`Bytes`](bytes::Bytes) extractor
/// can fail.
pub enum BytesRejection {
BodyAlreadyExtracted,
FailedToBufferBody,
}
}
composite_rejection! {
/// Rejection used for [`String`].
///
/// Contains one variant for each way the [`String`] extractor can fail.
pub enum StringRejection {
BodyAlreadyExtracted,
FailedToBufferBody,
InvalidUtf8,
}
}
/// Rejection used for [`ContentLengthLimit`](super::ContentLengthLimit).
///
/// Contains one variant for each way the
/// [`ContentLengthLimit`](super::ContentLengthLimit) extractor can fail.
#[derive(Debug)]
#[non_exhaustive]
pub enum ContentLengthLimitRejection<T> {
#[allow(missing_docs)]
PayloadTooLarge(PayloadTooLarge),
#[allow(missing_docs)]
LengthRequired(LengthRequired),
#[allow(missing_docs)]
Inner(T),
}
impl<T> IntoResponse for ContentLengthLimitRejection<T>
where
T: IntoResponse,
{
fn into_response(self) -> http::Response<Body> {
match self {
Self::PayloadTooLarge(inner) => inner.into_response(),
Self::LengthRequired(inner) => inner.into_response(),
Self::Inner(inner) => inner.into_response(),
}
}
}
/// Rejection used for [`TypedHeader`](super::TypedHeader).
#[cfg(feature = "headers")]
#[cfg_attr(docsrs, doc(cfg(feature = "headers")))]
#[derive(Debug)]
pub struct TypedHeaderRejection {
pub(super) name: &'static http::header::HeaderName,
pub(super) err: headers::Error,
}
#[cfg(feature = "headers")]
#[cfg_attr(docsrs, doc(cfg(feature = "headers")))]
impl IntoResponse for TypedHeaderRejection {
fn into_response(self) -> http::Response<Body> {
let mut res = format!("{} ({})", self.err, self.name).into_response();
*res.status_mut() = StatusCode::BAD_REQUEST;
res
}
}