,
80 | }
81 |
82 | fn walk_dir(base_path: P) -> io::Result>
83 | where
84 | P: AsRef,
85 | {
86 | fn walk_nested(base_path: &Path, path: &Path) -> io::Result> {
87 | let dir = fs::read_dir(path)?;
88 | let mut static_files = Vec::new();
89 | for entry in dir {
90 | let entry = entry?;
91 | let file_type = entry.file_type()?;
92 | if file_type.is_dir() {
93 | static_files.extend(walk_nested(base_path, &entry.path())?.into_iter());
94 | } else {
95 | let entry_path = entry.path();
96 | let entry_path = entry_path
97 | .strip_prefix(base_path)
98 | .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
99 | let mime = mime_guess::from_path(entry_path)
100 | .first()
101 | .unwrap_or(mime::TEXT_PLAIN);
102 |
103 | let content = fs::read(entry.path())?;
104 |
105 | static_files.push(StaticFile {
106 | mime,
107 | path: entry_path
108 | .to_str()
109 | .ok_or_else(|| {
110 | io::Error::new(
111 | io::ErrorKind::Other,
112 | "unable to convert path to UTF-8 string",
113 | )
114 | })?
115 | .to_string(),
116 | content,
117 | });
118 | }
119 | }
120 |
121 | Ok(static_files)
122 | }
123 |
124 | walk_nested(base_path.as_ref(), base_path.as_ref())
125 | }
126 |
--------------------------------------------------------------------------------
/submillisecond_macros/src/router/item_route.rs:
--------------------------------------------------------------------------------
1 | use proc_macro2::TokenStream;
2 | use quote::{ToTokens, TokenStreamExt};
3 | use syn::parse::{Parse, ParseStream};
4 | use syn::spanned::Spanned;
5 | use syn::{braced, token, Expr, LitStr, Path, Token};
6 |
7 | use super::item_with_middleware::ItemWithMiddleware;
8 | use super::method::Method;
9 | use super::with;
10 | use crate::hquote;
11 | use crate::router::Router;
12 |
13 | /// `"/abc" => sub_router`
14 | /// `GET "/abc" => handler`
15 | /// `GET "/abc" if guard => handler`
16 | /// `GET "/abc" use middleware => handler`
17 | /// `GET "/abc" if guard use middleware => handler`
18 | #[derive(Clone, Debug)]
19 | pub struct ItemRoute {
20 | pub method: Option,
21 | pub path: LitStr,
22 | pub guard: Option,
23 | pub middleware: Option,
24 | pub fat_arrow_token: Token![=>],
25 | pub handler: ItemHandler,
26 | }
27 |
28 | impl Parse for ItemRoute {
29 | fn parse(input: ParseStream) -> syn::Result {
30 | let item_route = ItemRoute {
31 | method: if Method::peek(input) {
32 | Some(input.parse()?)
33 | } else {
34 | None
35 | },
36 | path: input.parse()?,
37 | guard: if input.peek(Token![if]) {
38 | Some(input.parse()?)
39 | } else {
40 | None
41 | },
42 | middleware: if input.peek(with) {
43 | Some(input.parse()?)
44 | } else {
45 | None
46 | },
47 | fat_arrow_token: input.parse()?,
48 | handler: input.parse()?,
49 | };
50 |
51 | if let Some(method) = item_route.method {
52 | if matches!(item_route.handler, ItemHandler::SubRouter(_)) {
53 | return Err(syn::Error::new(
54 | method.span(),
55 | "method prefix cannot be used with sub routers",
56 | ));
57 | }
58 | }
59 |
60 | let path = item_route.path.value();
61 | if let Some(pos) = path.find('*') {
62 | if pos < path.len() - 1 {
63 | return Err(syn::Error::new(
64 | item_route.path.span(),
65 | "wildcards must be placed at the end of the path",
66 | ));
67 | }
68 |
69 | if item_route.method.is_none() {
70 | return Err(syn::Error::new(
71 | item_route.path.span(),
72 | "wildcards cannot be used with sub routers - try adding a HTTP method",
73 | ));
74 | }
75 | }
76 |
77 | Ok(item_route)
78 | }
79 | }
80 |
81 | #[derive(Clone, Debug)]
82 | pub struct ItemGuard {
83 | pub if_token: Token![if],
84 | pub guard: Box,
85 | }
86 |
87 | impl Parse for ItemGuard {
88 | fn parse(input: ParseStream) -> syn::Result {
89 | Ok(ItemGuard {
90 | if_token: input.parse()?,
91 | guard: Box::new(input.call(Expr::parse_without_eager_brace)?),
92 | })
93 | }
94 | }
95 |
96 | impl ToTokens for ItemGuard {
97 | fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
98 | tokens.append_all(expand_guard_struct(&self.guard));
99 | }
100 | }
101 |
102 | fn expand_guard_struct(guard: &syn::Expr) -> TokenStream {
103 | match guard {
104 | Expr::Binary(expr_binary) => {
105 | let left = expand_guard_struct(&expr_binary.left);
106 | let op = &expr_binary.op;
107 | let right = expand_guard_struct(&expr_binary.right);
108 |
109 | hquote! { #left #op #right }
110 | }
111 | Expr::Paren(expr_paren) => {
112 | let expr = expand_guard_struct(&expr_paren.expr);
113 | hquote! { (#expr) }
114 | }
115 | expr => hquote! { ::submillisecond::Guard::check(&#expr, &req) },
116 | }
117 | }
118 |
119 | #[derive(Clone, Debug)]
120 | pub enum ItemHandler {
121 | Expr(Box),
122 | SubRouter(Router),
123 | }
124 |
125 | impl Parse for ItemHandler {
126 | fn parse(input: ParseStream) -> syn::Result {
127 | if input.peek(token::Brace) {
128 | let content;
129 | braced!(content in input);
130 | return Ok(ItemHandler::SubRouter(content.parse()?));
131 | }
132 |
133 | let fork = input.fork();
134 | let _: Path = fork.parse()?;
135 | Ok(ItemHandler::Expr(input.parse()?))
136 | }
137 | }
138 |
--------------------------------------------------------------------------------
/src/reader.rs:
--------------------------------------------------------------------------------
1 | //! Uri reader using a cursor.
2 | //!
3 | //! The [`router!`](crate::router) macro uses this internally for routing.
4 |
5 | /// A uri string and cursor reader.
6 | #[derive(Clone, Debug, Default)]
7 | pub struct UriReader {
8 | /// Request uri.
9 | pub uri: String,
10 | /// Request uri cursor.
11 | pub cursor: usize,
12 | }
13 |
14 | impl UriReader {
15 | /// Creates a new [`UriReader`] with the cursor set to `0`.
16 | pub fn new(uri: String) -> UriReader {
17 | UriReader { uri, cursor: 0 }
18 | }
19 |
20 | /// Returns the next `len` characters from the uri, without modifying the
21 | /// cursor position.
22 | pub fn peek(&self, len: usize) -> &str {
23 | let read_attempt = self.cursor + len;
24 | if self.uri.len() >= read_attempt {
25 | return &self.uri[self.cursor..read_attempt];
26 | }
27 | ""
28 | }
29 |
30 | /// Returns a bool indicating whether the reader has reached the end,
31 | /// disregarding any trailing slash.
32 | pub fn is_dangling_slash(&self) -> bool {
33 | self.uri.len() == self.cursor || &self.uri[self.cursor..self.cursor + 1] == "/"
34 | }
35 |
36 | /// Returns a bool indicating whether the reader has reached the end,
37 | /// disregarding any trailing slash.
38 | pub fn is_dangling_terminal_slash(&self) -> bool {
39 | self.uri.len() == self.cursor
40 | || (&self.uri[self.cursor..self.cursor + 1] == "/" && self.uri.len() - self.cursor == 1)
41 | }
42 |
43 | /// Move the cursor forward based on `len`.
44 | pub fn read(&mut self, len: usize) {
45 | self.cursor += len;
46 | }
47 |
48 | /// Attempt to read `s` from the current cursor position, modifying the
49 | /// cursor if a match was found.
50 | ///
51 | /// `true` is returned if `s` matched the uri and the cursor was updated.
52 | pub fn read_matching(&mut self, s: &str) -> bool {
53 | let read_to = self.cursor + s.len();
54 | if read_to > self.uri.len() {
55 | return false;
56 | }
57 |
58 | if &self.uri[self.cursor..read_to] == s {
59 | self.cursor = read_to;
60 | return true;
61 | }
62 |
63 | false
64 | }
65 |
66 | /// Reads a single `/` character, modifying the cursor and returning whether
67 | /// there was a match.
68 | pub fn ensure_next_slash(&mut self) -> bool {
69 | self.read_matching("/")
70 | }
71 |
72 | /// Reset the cursor to the start of the uri.
73 | pub fn reset(&mut self) {
74 | self.cursor = 0;
75 | }
76 |
77 | /// Check if the cursor has reached the end of the uri, optionally allowing
78 | /// for a trailing slash.
79 | pub fn is_empty(&self, allow_trailing_slash: bool) -> bool {
80 | if allow_trailing_slash {
81 | self.uri.len() <= self.cursor || &self.uri[self.cursor..] == "/"
82 | } else {
83 | self.uri.len() <= self.cursor
84 | }
85 | }
86 |
87 | /// Read a param until the next `/` or end of uri.
88 | pub fn read_param(&mut self) -> Option<&str> {
89 | let initial_cursor = self.cursor;
90 | while !self.is_empty(false) {
91 | if self.peek(1) != "/" {
92 | self.read(1);
93 | } else {
94 | break;
95 | }
96 | }
97 | // if nothing was found, return none
98 | if initial_cursor == self.cursor {
99 | return None;
100 | }
101 | // read the param
102 | Some(&self.uri[initial_cursor..self.cursor])
103 | }
104 |
105 | /// Check if the uri ends with `suffix`.
106 | pub fn ends_with(&self, suffix: &str) -> bool {
107 | if self.cursor >= self.uri.len() {
108 | return false;
109 | }
110 | let end = &self.uri[self.cursor..];
111 | end == suffix
112 | }
113 |
114 | /// Returns the remainder of the uri from the current cursor position.
115 | pub fn read_to_end(&self) -> &str {
116 | &self.uri[self.cursor..]
117 | }
118 | }
119 |
120 | #[cfg(test)]
121 | mod tests {
122 | use super::UriReader;
123 |
124 | #[test]
125 | fn peek_empty_string() {
126 | let reader = UriReader::new("".to_string());
127 | assert_eq!(reader.peek(5), "");
128 | }
129 |
130 | #[test]
131 | fn peek_path() {
132 | let mut reader = UriReader::new("/alive".to_string());
133 | assert_eq!(reader.peek(3), "/al");
134 | reader.read(3);
135 | assert_eq!(reader.peek(3), "ive");
136 | reader.read(3);
137 | assert_eq!(reader.peek(3), "");
138 | reader.read(3);
139 | }
140 | }
141 |
--------------------------------------------------------------------------------
/src/macros.rs:
--------------------------------------------------------------------------------
1 | macro_rules! define_rejection {
2 | (
3 | #[status = $status:ident]
4 | #[body = $body:expr]
5 | $(#[$m:meta])*
6 | pub struct $name:ident;
7 | ) => {
8 | $(#[$m])*
9 | #[derive(Debug)]
10 | #[non_exhaustive]
11 | pub struct $name;
12 |
13 | impl $crate::response::IntoResponse for $name {
14 | fn into_response(self) -> $crate::Response {
15 | (http::StatusCode::$status, $body).into_response()
16 | }
17 | }
18 |
19 | impl std::fmt::Display for $name {
20 | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21 | write!(f, "{}", $body)
22 | }
23 | }
24 |
25 | impl std::error::Error for $name {}
26 |
27 | impl Default for $name {
28 | fn default() -> Self {
29 | Self
30 | }
31 | }
32 | };
33 |
34 | (
35 | #[status = $status:ident]
36 | #[body = $body:expr]
37 | $(#[$m:meta])*
38 | pub struct $name:ident (Error);
39 | ) => {
40 | $(#[$m])*
41 | #[derive(Debug)]
42 | pub struct $name(pub(crate) crate::Error);
43 |
44 | impl $name {
45 | pub(crate) fn from_err(err: E) -> Self
46 | where
47 | E: Into,
48 | {
49 | Self(crate::Error::new(err))
50 | }
51 | }
52 |
53 | impl crate::response::IntoResponse for $name {
54 | fn into_response(self) -> $crate::Response {
55 | (
56 | http::StatusCode::$status,
57 | format!(concat!($body, ": {}"), self.0),
58 | ).into_response()
59 | }
60 | }
61 |
62 | impl std::fmt::Display for $name {
63 | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
64 | write!(f, "{}", $body)
65 | }
66 | }
67 |
68 | impl std::error::Error for $name {
69 | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
70 | Some(&self.0)
71 | }
72 | }
73 | };
74 | }
75 |
76 | macro_rules! composite_rejection {
77 | (
78 | $(#[$m:meta])*
79 | pub enum $name:ident {
80 | $($variant:ident),+
81 | $(,)?
82 | }
83 | ) => {
84 | $(#[$m])*
85 | #[derive(Debug)]
86 | #[non_exhaustive]
87 | pub enum $name {
88 | $(
89 | #[allow(missing_docs)]
90 | $variant($variant)
91 | ),+
92 | }
93 |
94 | impl $crate::response::IntoResponse for $name {
95 | fn into_response(self) -> $crate::Response {
96 | match self {
97 | $(
98 | Self::$variant(inner) => inner.into_response(),
99 | )+
100 | }
101 | }
102 | }
103 |
104 | $(
105 | impl From<$variant> for $name {
106 | fn from(inner: $variant) -> Self {
107 | Self::$variant(inner)
108 | }
109 | }
110 | )+
111 |
112 | impl std::fmt::Display for $name {
113 | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
114 | match self {
115 | $(
116 | Self::$variant(inner) => write!(f, "{}", inner),
117 | )+
118 | }
119 | }
120 | }
121 |
122 | impl std::error::Error for $name {
123 | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
124 | match self {
125 | $(
126 | Self::$variant(inner) => Some(inner),
127 | )+
128 | }
129 | }
130 | }
131 | };
132 | }
133 |
134 | macro_rules! all_the_tuples {
135 | ($name:ident) => {
136 | $name!(T1);
137 | $name!(T1, T2);
138 | $name!(T1, T2, T3);
139 | $name!(T1, T2, T3, T4);
140 | $name!(T1, T2, T3, T4, T5);
141 | $name!(T1, T2, T3, T4, T5, T6);
142 | $name!(T1, T2, T3, T4, T5, T6, T7);
143 | $name!(T1, T2, T3, T4, T5, T6, T7, T8);
144 | $name!(T1, T2, T3, T4, T5, T6, T7, T8, T9);
145 | $name!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10);
146 | $name!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11);
147 | $name!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12);
148 | $name!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13);
149 | $name!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14);
150 | $name!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15);
151 | $name!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16);
152 | };
153 | ($name:ident, numbered) => {
154 | $name!(1, T1);
155 | $name!(2, T1, T2);
156 | $name!(3, T1, T2, T3);
157 | $name!(4, T1, T2, T3, T4);
158 | $name!(5, T1, T2, T3, T4, T5);
159 | $name!(6, T1, T2, T3, T4, T5, T6);
160 | $name!(7, T1, T2, T3, T4, T5, T6, T7);
161 | $name!(8, T1, T2, T3, T4, T5, T6, T7, T8);
162 | $name!(9, T1, T2, T3, T4, T5, T6, T7, T8, T9);
163 | $name!(10, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10);
164 | $name!(11, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11);
165 | $name!(12, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12);
166 | $name!(13, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13);
167 | $name!(14, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14);
168 | $name!(15, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15);
169 | $name!(16, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16);
170 | };
171 | }
172 |
--------------------------------------------------------------------------------
/src/handler.rs:
--------------------------------------------------------------------------------
1 | use lunatic::function::reference::Fn as FnPtr;
2 | use lunatic::function::FuncRef;
3 | use serde::de::DeserializeOwned;
4 | use serde::Serialize;
5 |
6 | use crate::extract::{FromOwnedRequest, FromRequest};
7 | use crate::response::IntoResponse;
8 | use crate::{RequestContext, Response};
9 |
10 | /// Implemented for process-safe [`Handlers`](Handler).
11 | ///
12 | /// Submillisecond handles every request in a separate lunatic process, and
13 | /// lunatic's processes are sandboxed. This means that no memory is shared
14 | /// between the request handler and the rest of the app. This introduces an
15 | /// additional limitation on what can be a [`Handler`].
16 | ///
17 | /// Two kinds of types are safe to be used as handlers:
18 | /// - Static functions
19 | /// - Serializable and clonable objects
20 | ///
21 | /// ### Static functions
22 | ///
23 | /// This type is obvious. Non-capturing functions are generated during compile
24 | /// time and are shared between all processes, so they can be easily used as
25 | /// handlers. In fact, the [`router!`](crate::router) macro will in the end just
26 | /// generate a function that will be used as a handler and invoke other handlers
27 | /// depending on the request values.
28 | ///
29 | /// ### Serializable and clonable objects
30 | ///
31 | /// Everything else needs to be passed somehow to the memory of the handler
32 | /// process. This means that we need to clone the value for every incoming
33 | /// request, serialize it and send it to the process handling the request.
34 | pub trait ProcessSafeHandler {
35 | /// A handler is only safe if it can be cloned and safely sent between
36 | /// processes.
37 | type SafeHandler: Handler + Clone + Serialize + DeserializeOwned;
38 |
39 | /// Turn type into a safe handler.
40 | fn safe_handler(self) -> Self::SafeHandler;
41 | }
42 |
43 | /// Marker type for functions that satisfy [`ProcessSafeHandler`].
44 | pub struct Function;
45 | /// Marker type for objects that satisfy [`ProcessSafeHandler`].
46 | pub struct Object;
47 |
48 | impl ProcessSafeHandler for T
49 | where
50 | T: FnPtr + Copy,
51 | FuncRef: Handler,
52 | {
53 | type SafeHandler = FuncRef;
54 |
55 | fn safe_handler(self) -> Self::SafeHandler {
56 | FuncRef::new(self)
57 | }
58 | }
59 |
60 | impl ProcessSafeHandler for T
61 | where
62 | T: Clone + Handler + Serialize + DeserializeOwned,
63 | {
64 | type SafeHandler = T;
65 |
66 | fn safe_handler(self) -> Self::SafeHandler {
67 | self
68 | }
69 | }
70 |
71 | impl Handler for FuncRef
72 | where
73 | T: FnPtr + Copy + Handler,
74 | {
75 | fn handle(&self, req: RequestContext) -> Response {
76 | self.get().handle(req)
77 | }
78 | }
79 |
80 | /// A handler is implemented for any function which takes any number of
81 | /// [extractors](crate::extract), and returns any type that implements
82 | /// [`IntoResponse`].
83 | ///
84 | /// To avoid unnecessary clones, the [`RequestContext`], [`http::Request`],
85 | /// [`String`], [`Vec`], [`Params`](crate::params::Params) extractors (and
86 | /// any other types which implement [`FromOwnedRequest`] directly) should be
87 | /// placed as the first argument, and cannot be used together in a single
88 | /// handler.
89 | ///
90 | /// A maximum of 16 extractor arguments may be added for a single handler.
91 | ///
92 | /// # Handler examples
93 | ///
94 | /// ```
95 | /// fn index() -> &'static str {
96 | /// "Hello, submillisecond"
97 | /// }
98 | ///
99 | /// use submillisecond::extract::Path;
100 | /// use submillisecond::http::status::FOUND;
101 | ///
102 | /// fn headers(Path(id): Path) -> (StatusCode, String) {
103 | /// (FOUND, id)
104 | /// }
105 | /// ```
106 | ///
107 | /// # Middleware example
108 | ///
109 | /// ```
110 | /// use submillisecond::RequestContent;
111 | /// use submillisecond::response::Response;
112 | ///
113 | /// fn logging_layer(req: RequestContext) -> Response {
114 | /// println!("Incoming request start");
115 | /// let res = req.next_handler();
116 | /// println!("Incoming request end");
117 | /// res
118 | /// }
119 | /// ```
120 | pub trait Handler {
121 | /// Handles the request, returning a response.
122 | fn handle(&self, req: RequestContext) -> Response;
123 |
124 | /// Initializes handler, useful for spawning processes on startup.
125 | fn init(&self) {}
126 | }
127 |
128 | impl Handler<(), R> for F
129 | where
130 | F: Fn() -> R,
131 | R: IntoResponse,
132 | {
133 | fn handle(&self, _req: RequestContext) -> Response {
134 | self().into_response()
135 | }
136 | }
137 |
138 | macro_rules! impl_handler {
139 | ( $arg1: ident $(, $( $args: ident ),*)? ) => {
140 | #[allow(unused_parens)]
141 | impl Handler<($arg1$(, $( $args, )*)?), R> for F
142 | where
143 | F: Fn($arg1$(, $( $args, )*)?) -> R,
144 | $arg1: FromOwnedRequest,
145 | $( $( $args: FromRequest, )* )?
146 | R: IntoResponse,
147 | {
148 |
149 | #[allow(unused_mut, unused_variables)]
150 | fn handle(&self, mut req: RequestContext) -> Response {
151 | paste::paste! {
152 | $($(
153 | let [< $args:lower >] = match <$args as FromRequest>::from_request(&mut req) {
154 | Ok(e) => e,
155 | Err(err) => return err.into_response(),
156 | };
157 | )*)?
158 | let e1 = match <$arg1 as FromOwnedRequest>::from_owned_request(req) {
159 | Ok(e) => e,
160 | Err(err) => return err.into_response(),
161 | };
162 | self(e1 $(, $( [< $args:lower >] ),*)?).into_response()
163 | }
164 | }
165 | }
166 | };
167 | }
168 |
169 | all_the_tuples!(impl_handler);
170 |
--------------------------------------------------------------------------------
/src/response/into_response_parts.rs:
--------------------------------------------------------------------------------
1 | use std::convert::{Infallible, TryInto};
2 | use std::fmt;
3 |
4 | use http::header::{HeaderMap, HeaderName, HeaderValue};
5 | use http::{Extensions, StatusCode};
6 |
7 | use super::{IntoResponse, Response};
8 |
9 | /// Trait for adding headers and extensions to a response.
10 | pub trait IntoResponseParts {
11 | /// The type returned in the event of an error.
12 | ///
13 | /// This can be used to fallibly convert types into headers or extensions.
14 | type Error: IntoResponse;
15 |
16 | /// Set parts of the response
17 | fn into_response_parts(self, res: ResponseParts) -> Result;
18 | }
19 |
20 | impl IntoResponseParts for Option
21 | where
22 | T: IntoResponseParts,
23 | {
24 | type Error = T::Error;
25 |
26 | fn into_response_parts(self, res: ResponseParts) -> Result {
27 | if let Some(inner) = self {
28 | inner.into_response_parts(res)
29 | } else {
30 | Ok(res)
31 | }
32 | }
33 | }
34 |
35 | /// Parts of a response.
36 | ///
37 | /// Used with [`IntoResponseParts`].
38 | #[derive(Debug)]
39 | pub struct ResponseParts {
40 | pub(crate) res: Response,
41 | }
42 |
43 | impl ResponseParts {
44 | /// Gets a reference to the response headers.
45 | pub fn headers(&self) -> &HeaderMap {
46 | self.res.headers()
47 | }
48 |
49 | /// Gets a mutable reference to the response headers.
50 | pub fn headers_mut(&mut self) -> &mut HeaderMap {
51 | self.res.headers_mut()
52 | }
53 |
54 | /// Gets a reference to the response extensions.
55 | pub fn extensions(&self) -> &Extensions {
56 | self.res.extensions()
57 | }
58 |
59 | /// Gets a mutable reference to the response extensions.
60 | pub fn extensions_mut(&mut self) -> &mut Extensions {
61 | self.res.extensions_mut()
62 | }
63 | }
64 |
65 | impl IntoResponseParts for HeaderMap {
66 | type Error = Infallible;
67 |
68 | fn into_response_parts(self, mut res: ResponseParts) -> Result {
69 | res.headers_mut().extend(self);
70 | Ok(res)
71 | }
72 | }
73 |
74 | impl IntoResponseParts for [(K, V); N]
75 | where
76 | K: TryInto,
77 | K::Error: fmt::Display,
78 | V: TryInto,
79 | V::Error: fmt::Display,
80 | {
81 | type Error = TryIntoHeaderError;
82 |
83 | fn into_response_parts(self, mut res: ResponseParts) -> Result {
84 | for (key, value) in self {
85 | let key = key.try_into().map_err(TryIntoHeaderError::key)?;
86 | let value = value.try_into().map_err(TryIntoHeaderError::value)?;
87 | res.headers_mut().insert(key, value);
88 | }
89 |
90 | Ok(res)
91 | }
92 | }
93 |
94 | /// Error returned if converting a value to a header fails.
95 | #[derive(Debug)]
96 | pub struct TryIntoHeaderError {
97 | kind: TryIntoHeaderErrorKind,
98 | }
99 |
100 | impl TryIntoHeaderError {
101 | pub(super) fn key(err: K) -> Self {
102 | Self {
103 | kind: TryIntoHeaderErrorKind::Key(err),
104 | }
105 | }
106 |
107 | pub(super) fn value(err: V) -> Self {
108 | Self {
109 | kind: TryIntoHeaderErrorKind::Value(err),
110 | }
111 | }
112 | }
113 |
114 | #[derive(Debug)]
115 | enum TryIntoHeaderErrorKind {
116 | Key(K),
117 | Value(V),
118 | }
119 |
120 | impl IntoResponse for TryIntoHeaderError
121 | where
122 | K: fmt::Display,
123 | V: fmt::Display,
124 | {
125 | fn into_response(self) -> Response {
126 | match self.kind {
127 | TryIntoHeaderErrorKind::Key(inner) => {
128 | (StatusCode::INTERNAL_SERVER_ERROR, inner.to_string()).into_response()
129 | }
130 | TryIntoHeaderErrorKind::Value(inner) => {
131 | (StatusCode::INTERNAL_SERVER_ERROR, inner.to_string()).into_response()
132 | }
133 | }
134 | }
135 | }
136 |
137 | impl fmt::Display for TryIntoHeaderError {
138 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
139 | match self.kind {
140 | TryIntoHeaderErrorKind::Key(_) => write!(f, "failed to convert key to a header name"),
141 | TryIntoHeaderErrorKind::Value(_) => {
142 | write!(f, "failed to convert value to a header value")
143 | }
144 | }
145 | }
146 | }
147 |
148 | impl std::error::Error for TryIntoHeaderError
149 | where
150 | K: std::error::Error + 'static,
151 | V: std::error::Error + 'static,
152 | {
153 | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
154 | match &self.kind {
155 | TryIntoHeaderErrorKind::Key(inner) => Some(inner),
156 | TryIntoHeaderErrorKind::Value(inner) => Some(inner),
157 | }
158 | }
159 | }
160 |
161 | macro_rules! impl_into_response_parts {
162 | ( $($ty:ident),* $(,)? ) => {
163 | #[allow(non_snake_case)]
164 | impl<$($ty,)*> IntoResponseParts for ($($ty,)*)
165 | where
166 | $( $ty: IntoResponseParts, )*
167 | {
168 | type Error = Response;
169 |
170 | fn into_response_parts(self, res: ResponseParts) -> Result {
171 | let ($($ty,)*) = self;
172 |
173 | $(
174 | let res = match $ty.into_response_parts(res) {
175 | Ok(res) => res,
176 | Err(err) => {
177 | return Err(err.into_response());
178 | }
179 | };
180 | )*
181 |
182 | Ok(res)
183 | }
184 | }
185 | }
186 | }
187 |
188 | all_the_tuples!(impl_into_response_parts);
189 |
190 | impl IntoResponseParts for Extensions {
191 | type Error = Infallible;
192 |
193 | fn into_response_parts(self, mut res: ResponseParts) -> Result {
194 | res.extensions_mut().extend(self);
195 | Ok(res)
196 | }
197 | }
198 |
--------------------------------------------------------------------------------
/src/session.rs:
--------------------------------------------------------------------------------
1 | //! Session data stored in encrypted user cookie.
2 | //!
3 | //! Sessions can be shared across handlers as long as the same type in the
4 | //! generic is used. Using different session types across handlers is valid,
5 | //! and the data will be stored in separate cookies named
6 | //! `session-{type_id_hash}`.
7 | //!
8 | //! The [`init_session`] should be called before starting the web server to
9 | //! initialize a key.
10 | //!
11 | //! The [`cookies::cookies_layer`](super::cookies::cookies_layer) layer must
12 | //! also be used for session data to work.
13 | //!
14 | //! # Example
15 | //!
16 | //! ```
17 | //! use submillisecond::cookies::{cookies_layer, Key};
18 | //! use submillisecond::session::{init_session, Session};
19 | //! use submillisecond::{router, Application};
20 | //!
21 | //! fn counter(mut session: Session) -> String {
22 | //! if *session < 10 {
23 | //! *session += 1;
24 | //! }
25 | //! session.to_string()
26 | //! }
27 | //!
28 | //! fn main() -> std::io::Result<()> {
29 | //! session::init_session(Key::generate());
30 | //!
31 | //! Application::new(router! {
32 | //! with cookies_layer;
33 | //!
34 | //! GET "/counter" => counter
35 | //! })
36 | //! .serve("0.0.0.0:3000")
37 | //! }
38 | //! ```
39 |
40 | use std::any::TypeId;
41 | use std::collections::hash_map::DefaultHasher;
42 | use std::hash::{Hash, Hasher};
43 | use std::ops::{Deref, DerefMut};
44 |
45 | use cookie::{Cookie, Key};
46 | use lunatic::ap::{AbstractProcess, Config, ProcessRef, RequestHandler, State};
47 | use lunatic::serializer::Bincode;
48 | use lunatic::ProcessName;
49 | use serde::de::DeserializeOwned;
50 | use serde::{Deserialize, Serialize};
51 |
52 | use crate::cookies::COOKIES;
53 | use crate::extract::FromRequest;
54 |
55 | #[derive(ProcessName)]
56 | struct SessionProcessID;
57 |
58 | /// Initialize the session key.
59 | pub fn init_session(key: Key) {
60 | SessionProcess::start_as(&SessionProcessID, KeyWrapper(key)).unwrap();
61 | }
62 |
63 | /// Session extractor, used to store data encrypted in a browser cookie.
64 | ///
65 | /// If the session does not exist from the request, a default session will be
66 | /// used with [`Default::default`].
67 | pub struct Session
68 | where
69 | D: Default + Serialize + DeserializeOwned + 'static,
70 | {
71 | changed: bool,
72 | data: D,
73 | key: Key,
74 | }
75 |
76 | impl Deref for Session
77 | where
78 | D: Default + Serialize + DeserializeOwned,
79 | {
80 | type Target = D;
81 |
82 | fn deref(&self) -> &Self::Target {
83 | &self.data
84 | }
85 | }
86 |
87 | impl DerefMut for Session
88 | where
89 | D: Default + Serialize + DeserializeOwned,
90 | {
91 | fn deref_mut(&mut self) -> &mut Self::Target {
92 | self.changed = true;
93 | &mut self.data
94 | }
95 | }
96 |
97 | impl Drop for Session
98 | where
99 | D: Default + Serialize + DeserializeOwned + 'static,
100 | {
101 | fn drop(&mut self) {
102 | if self.changed {
103 | if let Ok(value) = serde_json::to_string(&self.data) {
104 | COOKIES.with_borrow_mut(|mut cookies| {
105 | let mut private_jar = cookies.private_mut(&self.key);
106 | let cookie_name = cookie_name::();
107 | private_jar.add(Cookie::new(cookie_name, value));
108 | });
109 | }
110 | }
111 | }
112 | }
113 |
114 | impl FromRequest for Session
115 | where
116 | D: Default + Serialize + DeserializeOwned + 'static,
117 | {
118 | type Rejection = SessionProcessNotRunning;
119 |
120 | fn from_request(_req: &mut crate::RequestContext) -> Result {
121 | let session_process = ProcessRef::::lookup(&SessionProcessID)
122 | .ok_or(SessionProcessNotRunning)?;
123 | let KeyWrapper(key) = session_process.request(GetSessionNameKey);
124 | let cookie_name = cookie_name::();
125 | let (changed, data) = COOKIES.with_borrow(|cookies| {
126 | let private_jar = cookies.private(&key);
127 | let session_cookie = private_jar.get(&cookie_name);
128 | let changed = session_cookie.is_none();
129 | let data = session_cookie
130 | .and_then(|session_cookie| serde_json::from_str(session_cookie.value()).ok())
131 | .unwrap_or_default();
132 | (changed, data)
133 | });
134 | Ok(Session { changed, data, key })
135 | }
136 | }
137 |
138 | define_rejection! {
139 | #[status = INTERNAL_SERVER_ERROR]
140 | #[body = "Session key not configured. Did you forget to call `session::init_session`?"]
141 | /// Rejection type used when the session process has not been started via [`session::init_session`].
142 | pub struct SessionProcessNotRunning;
143 | }
144 |
145 | struct SessionProcess(KeyWrapper);
146 | impl AbstractProcess for SessionProcess {
147 | type Arg = KeyWrapper;
148 | type State = Self;
149 | type Serializer = Bincode;
150 | type Handlers = ();
151 | type StartupError = ();
152 |
153 | fn init(_: Config, key: KeyWrapper) -> Result {
154 | Ok(Self(key))
155 | }
156 | }
157 |
158 | #[derive(serde::Serialize, serde::Deserialize)]
159 | struct GetSessionNameKey;
160 | impl RequestHandler for SessionProcess {
161 | type Response = KeyWrapper;
162 |
163 | fn handle(state: State, _: GetSessionNameKey) -> Self::Response {
164 | state.0.clone()
165 | }
166 | }
167 |
168 | #[derive(Clone)]
169 | struct KeyWrapper(Key);
170 |
171 | impl Serialize for KeyWrapper {
172 | fn serialize(&self, serializer: S) -> Result
173 | where
174 | S: serde::Serializer,
175 | {
176 | serializer.serialize_bytes(self.0.master())
177 | }
178 | }
179 |
180 | impl<'de> Deserialize<'de> for KeyWrapper {
181 | fn deserialize(deserializer: D) -> Result
182 | where
183 | D: serde::Deserializer<'de>,
184 | {
185 | let key = >::deserialize(deserializer)?;
186 | Ok(KeyWrapper(Key::from(&key)))
187 | }
188 | }
189 |
190 | fn cookie_name() -> String {
191 | let type_id = TypeId::of::();
192 | let mut hasher = DefaultHasher::new();
193 | type_id.hash(&mut hasher);
194 | let hash = hasher.finish();
195 | format!("session-{hash:x}")
196 | }
197 |
--------------------------------------------------------------------------------
/src/extract/host.rs:
--------------------------------------------------------------------------------
1 | use http::header::{HeaderMap, FORWARDED};
2 |
3 | use super::rejection::{FailedToResolveHost, HostRejection};
4 | use super::FromRequest;
5 |
6 | const X_FORWARDED_HOST_HEADER_KEY: &str = "X-Forwarded-Host";
7 |
8 | /// Extractor that resolves the hostname of the request.
9 | ///
10 | /// Hostname is resolved through the following, in order:
11 | /// - `Forwarded` header
12 | /// - `X-Forwarded-Host` header
13 | /// - `Host` header
14 | /// - request target / URI
15 | ///
16 | /// Note that user agents can set `X-Forwarded-Host` and `Host` headers to
17 | /// arbitrary values so make sure to validate them to avoid security issues.
18 | #[derive(Debug, Clone)]
19 | pub struct Host(pub String);
20 |
21 | impl FromRequest for Host {
22 | type Rejection = HostRejection;
23 |
24 | fn from_request(req: &mut crate::RequestContext) -> Result {
25 | let headers = req.headers();
26 |
27 | if let Some(host) = parse_forwarded(headers) {
28 | return Ok(Host(host.to_owned()));
29 | }
30 |
31 | if let Some(host) = headers
32 | .get(X_FORWARDED_HOST_HEADER_KEY)
33 | .and_then(|host| host.to_str().ok())
34 | {
35 | return Ok(Host(host.to_owned()));
36 | }
37 |
38 | if let Some(host) = headers
39 | .get(http::header::HOST)
40 | .and_then(|host| host.to_str().ok())
41 | {
42 | return Ok(Host(host.to_owned()));
43 | }
44 |
45 | if let Some(host) = req.uri().host() {
46 | return Ok(Host(host.to_owned()));
47 | }
48 |
49 | Err(HostRejection::FailedToResolveHost(FailedToResolveHost))
50 | }
51 | }
52 |
53 | #[allow(warnings)]
54 | fn parse_forwarded(headers: &HeaderMap) -> Option<&str> {
55 | // if there are multiple `Forwarded` `HeaderMap::get` will return the first one
56 | let forwarded_values = headers.get(FORWARDED)?.to_str().ok()?;
57 |
58 | // get the first set of values
59 | let first_value = forwarded_values.split(',').nth(0)?;
60 |
61 | // find the value of the `host` field
62 | first_value.split(';').find_map(|pair| {
63 | let (key, value) = pair.split_once('=')?;
64 | key.trim()
65 | .eq_ignore_ascii_case("host")
66 | .then(|| value.trim().trim_matches('"'))
67 | })
68 | }
69 |
70 | #[cfg(test)]
71 | mod tests {
72 | use http::header::HeaderName;
73 | use lunatic::net::TcpStream;
74 |
75 | use super::*;
76 | use crate::{Body, RequestContext};
77 |
78 | #[lunatic::test]
79 | fn host_header() {
80 | let original_host = "some-domain:123";
81 |
82 | let mut req = RequestContext::new(
83 | http::Request::builder()
84 | .method("GET")
85 | .header(http::header::HOST, original_host)
86 | .body(Body::from_slice(&[]))
87 | .unwrap(),
88 | TcpStream::connect("127.0.0.1:22").unwrap(),
89 | );
90 |
91 | let Host(host) = Host::from_request(&mut req).unwrap();
92 |
93 | assert_eq!(host, original_host);
94 | }
95 |
96 | #[lunatic::test]
97 | fn x_forwarded_host_header() {
98 | let original_host = "some-domain:456";
99 |
100 | let mut req = RequestContext::new(
101 | http::Request::builder()
102 | .method("GET")
103 | .header(X_FORWARDED_HOST_HEADER_KEY, original_host)
104 | .body(Body::from_slice(&[]))
105 | .unwrap(),
106 | TcpStream::connect("127.0.0.1:22").unwrap(),
107 | );
108 |
109 | let Host(host) = Host::from_request(&mut req).unwrap();
110 |
111 | assert_eq!(host, original_host);
112 | }
113 |
114 | #[lunatic::test]
115 | fn x_forwarded_host_precedence_over_host_header() {
116 | let x_forwarded_host_header = "some-domain:456";
117 | let host_header = "some-domain:123";
118 |
119 | let mut req = RequestContext::new(
120 | http::Request::builder()
121 | .method("GET")
122 | .header(X_FORWARDED_HOST_HEADER_KEY, x_forwarded_host_header)
123 | .header(http::header::HOST, host_header)
124 | .body(Body::from_slice(&[]))
125 | .unwrap(),
126 | TcpStream::connect("127.0.0.1:22").unwrap(),
127 | );
128 |
129 | let Host(host) = Host::from_request(&mut req).unwrap();
130 |
131 | assert_eq!(host, x_forwarded_host_header);
132 | }
133 |
134 | #[lunatic::test]
135 | fn uri_host() {
136 | let mut req = RequestContext::new(
137 | http::Request::builder()
138 | .method("GET")
139 | .uri("127.0.0.1")
140 | .body(Body::from_slice(&[]))
141 | .unwrap(),
142 | TcpStream::connect("127.0.0.1:22").unwrap(),
143 | );
144 |
145 | let Host(host) = Host::from_request(&mut req).unwrap();
146 |
147 | assert!(host.contains("127.0.0.1"));
148 | }
149 |
150 | #[lunatic::test]
151 | fn forwarded_parsing() {
152 | // the basic case
153 | let headers = header_map(&[(FORWARDED, "host=192.0.2.60;proto=http;by=203.0.113.43")]);
154 | let value = parse_forwarded(&headers).unwrap();
155 | assert_eq!(value, "192.0.2.60");
156 |
157 | // is case insensitive
158 | let headers = header_map(&[(FORWARDED, "host=192.0.2.60;proto=http;by=203.0.113.43")]);
159 | let value = parse_forwarded(&headers).unwrap();
160 | assert_eq!(value, "192.0.2.60");
161 |
162 | // ipv6
163 | let headers = header_map(&[(FORWARDED, "host=\"[2001:db8:cafe::17]:4711\"")]);
164 | let value = parse_forwarded(&headers).unwrap();
165 | assert_eq!(value, "[2001:db8:cafe::17]:4711");
166 |
167 | // multiple values in one header
168 | let headers = header_map(&[(FORWARDED, "host=192.0.2.60, host=127.0.0.1")]);
169 | let value = parse_forwarded(&headers).unwrap();
170 | assert_eq!(value, "192.0.2.60");
171 |
172 | // multiple header values
173 | let headers = header_map(&[
174 | (FORWARDED, "host=192.0.2.60"),
175 | (FORWARDED, "host=127.0.0.1"),
176 | ]);
177 | let value = parse_forwarded(&headers).unwrap();
178 | assert_eq!(value, "192.0.2.60");
179 | }
180 |
181 | fn header_map(values: &[(HeaderName, &str)]) -> HeaderMap {
182 | let mut headers = HeaderMap::new();
183 | for (key, value) in values {
184 | headers.append(key, value.parse().unwrap());
185 | }
186 | headers
187 | }
188 | }
189 |
--------------------------------------------------------------------------------
/src/params.rs:
--------------------------------------------------------------------------------
1 | //! Params are data from the request url.
2 | //!
3 | //! The [`router!`](crate::router) macro collects params into the
4 | //! [`crate::RequestContext`]
5 |
6 | use std::{iter, mem, slice};
7 |
8 | /// A single URL parameter, consisting of a key and a value.
9 | #[derive(Debug, PartialEq, Eq, Ord, PartialOrd, Default, Clone)]
10 | pub struct Param {
11 | /// Param key as defined in the url.
12 | pub key: &'static str,
13 | /// Param value.
14 | pub value: String,
15 | }
16 |
17 | /// A list of parameters returned by a route match.
18 | ///
19 | /// # Extractor example
20 | ///
21 | /// ```
22 | /// use submillisecond::router;
23 | /// use submillisecond::params::Params;
24 | ///
25 | /// fn params(params: Params) -> String {
26 | /// let name = params.get("name").unwrap_or("user");
27 | /// format!("Welcome, {name}")
28 | /// }
29 | ///
30 | /// router! {
31 | /// GET "/:name" => params
32 | /// }
33 | /// ```
34 | #[derive(Debug, PartialEq, Eq, Ord, PartialOrd, Clone)]
35 | pub struct Params {
36 | kind: ParamsKind,
37 | }
38 |
39 | // Most routes have 1-3 dynamic parameters, so we can avoid a heap allocation in
40 | // common cases.
41 | const SMALL: usize = 3;
42 |
43 | #[derive(Debug, PartialEq, Eq, Ord, PartialOrd, Clone)]
44 | enum ParamsKind {
45 | None,
46 | Small([Param; SMALL], usize),
47 | Large(Vec),
48 | }
49 |
50 | impl Default for Params {
51 | fn default() -> Self {
52 | Self::new()
53 | }
54 | }
55 |
56 | impl Params {
57 | /// Creates an empty instance of [`Params`].
58 | pub fn new() -> Self {
59 | let kind = ParamsKind::None;
60 | Self { kind }
61 | }
62 |
63 | /// Returns the number of parameters.
64 | pub fn len(&self) -> usize {
65 | match &self.kind {
66 | ParamsKind::None => 0,
67 | ParamsKind::Small(_, len) => *len,
68 | ParamsKind::Large(vec) => vec.len(),
69 | }
70 | }
71 |
72 | /// Returns the value of the first parameter registered under the given key.
73 | pub fn get(&self, key: &str) -> Option<&str> {
74 | match &self.kind {
75 | ParamsKind::None => None,
76 | ParamsKind::Small(arr, len) => arr
77 | .iter()
78 | .take(*len)
79 | .find(|param| param.key == key)
80 | .map(|value| value.value.as_str()),
81 | ParamsKind::Large(vec) => vec
82 | .iter()
83 | .find(|param| param.key == key)
84 | .map(|value| value.value.as_str()),
85 | }
86 | }
87 |
88 | /// Returns an iterator over the parameters in the list.
89 | pub fn iter(&self) -> ParamsIter<'_> {
90 | ParamsIter::new(self)
91 | }
92 |
93 | /// Returns `true` if there are no parameters in the list.
94 | pub fn is_empty(&self) -> bool {
95 | match &self.kind {
96 | ParamsKind::None => true,
97 | ParamsKind::Small(_, len) => *len == 0,
98 | ParamsKind::Large(vec) => vec.is_empty(),
99 | }
100 | }
101 |
102 | /// Inserts a key value parameter pair into the list.
103 | pub fn push(&mut self, key: &'static str, value: String) {
104 | #[cold]
105 | fn drain_to_vec(len: usize, elem: T, arr: &mut [T; SMALL]) -> Vec {
106 | let mut vec = Vec::with_capacity(len + 1);
107 | vec.extend(arr.iter_mut().map(mem::take));
108 | vec.push(elem);
109 | vec
110 | }
111 |
112 | let param = Param { key, value };
113 | match &mut self.kind {
114 | ParamsKind::None => {
115 | self.kind = ParamsKind::Small([param, Param::default(), Param::default()], 1);
116 | }
117 | ParamsKind::Small(arr, len) => {
118 | if *len == SMALL {
119 | self.kind = ParamsKind::Large(drain_to_vec(*len, param, arr));
120 | return;
121 | }
122 | arr[*len] = param;
123 | *len += 1;
124 | }
125 | ParamsKind::Large(vec) => vec.push(param),
126 | }
127 | }
128 | }
129 |
130 | /// An iterator over the keys and values of a route's [parameters](Params).
131 | pub struct ParamsIter<'ps> {
132 | kind: ParamsIterKind<'ps>,
133 | }
134 |
135 | impl<'ps> ParamsIter<'ps> {
136 | fn new(params: &'ps Params) -> Self {
137 | let kind = match ¶ms.kind {
138 | ParamsKind::None => ParamsIterKind::None,
139 | ParamsKind::Small(arr, len) => ParamsIterKind::Small(arr.iter().take(*len)),
140 | ParamsKind::Large(vec) => ParamsIterKind::Large(vec.iter()),
141 | };
142 | Self { kind }
143 | }
144 | }
145 |
146 | enum ParamsIterKind<'ps> {
147 | None,
148 | Small(iter::Take>),
149 | Large(slice::Iter<'ps, Param>),
150 | }
151 |
152 | impl<'ps> Iterator for ParamsIter<'ps> {
153 | type Item = (&'ps str, &'ps str);
154 |
155 | fn next(&mut self) -> Option {
156 | match self.kind {
157 | ParamsIterKind::None => None,
158 | ParamsIterKind::Small(ref mut iter) => iter.next().map(|p| (p.key, p.value.as_str())),
159 | ParamsIterKind::Large(ref mut iter) => iter.next().map(|p| (p.key, p.value.as_str())),
160 | }
161 | }
162 | }
163 |
164 | #[cfg(test)]
165 | mod tests {
166 | use super::*;
167 |
168 | #[test]
169 | fn no_alloc() {
170 | assert_eq!(Params::new().kind, ParamsKind::None);
171 | }
172 |
173 | #[test]
174 | fn heap_alloc() {
175 | let vec = vec![
176 | ("hello", "hello"),
177 | ("world", "world"),
178 | ("foo", "foo"),
179 | ("bar", "bar"),
180 | ("baz", "baz"),
181 | ];
182 |
183 | let mut params = Params::new();
184 | for (key, value) in vec.clone() {
185 | params.push(key, value.to_string());
186 | assert_eq!(params.get(key), Some(value));
187 | }
188 |
189 | match params.kind {
190 | ParamsKind::Large(..) => {}
191 | _ => panic!(),
192 | }
193 |
194 | assert!(params.iter().eq(vec.clone()));
195 | }
196 |
197 | #[test]
198 | fn stack_alloc() {
199 | let vec = vec![("hello", "hello"), ("world", "world"), ("baz", "baz")];
200 |
201 | let mut params = Params::new();
202 | for (key, value) in vec.clone() {
203 | params.push(key, value.to_string());
204 | assert_eq!(params.get(key), Some(value));
205 | }
206 |
207 | match params.kind {
208 | ParamsKind::Small(..) => {}
209 | _ => panic!(),
210 | }
211 |
212 | assert!(params.iter().eq(vec.clone()));
213 | }
214 |
215 | #[test]
216 | fn ignore_array_default() {
217 | let params = Params::new();
218 | assert!(params.get("").is_none());
219 | }
220 | }
221 |
--------------------------------------------------------------------------------
/tests/parsing_http_1_1.rs:
--------------------------------------------------------------------------------
1 | use std::io::{Read, Write};
2 | use std::str::from_utf8;
3 | use std::time::Duration;
4 |
5 | use lunatic::net::TcpStream;
6 | use lunatic::{sleep, test, Mailbox, Process};
7 | use submillisecond::{router, Application, Body};
8 |
9 | fn hell_world_server(port: u16, _: Mailbox<()>) {
10 | fn hello_world_handler() -> &'static str {
11 | "Hello world!"
12 | }
13 |
14 | Application::new(router! {
15 | GET "/" => hello_world_handler
16 | })
17 | .serve(format!("localhost:{port}"))
18 | .unwrap();
19 | }
20 |
21 | #[test]
22 | fn empty_line_prefix_is_valid() {
23 | Process::spawn_link(8900, hell_world_server);
24 | // Give enough time to for server to start
25 | sleep(Duration::from_millis(10));
26 | let mut stream = TcpStream::connect("localhost:8900").unwrap();
27 | let request = "\r\n\nGET / HTTP/1.1\r\n\r\n".as_bytes();
28 | stream.write_all(request).unwrap();
29 | let mut response = [0u8; 256];
30 | let n = stream.read(&mut response).unwrap();
31 | let response_str = from_utf8(&response[..n]).unwrap();
32 | assert_eq!(
33 | response_str,
34 | "HTTP/1.1 200 OK\r\n\
35 | content-type: text/plain; charset=utf-8\r\n\
36 | content-length: 12\r\n\
37 | \r\n\
38 | Hello world!"
39 | );
40 | }
41 |
42 | #[test]
43 | #[ignore]
44 | fn pipeline_requests() {
45 | Process::spawn_link(8901, hell_world_server);
46 | // Give enough time to for server to start
47 | sleep(Duration::from_millis(10));
48 | let mut stream = TcpStream::connect("localhost:8901").unwrap();
49 | let request = "GET / HTTP/1.1\r\n\r\nGET / HTTP/1.1\r\n\r\n".as_bytes();
50 | stream.write_all(request).unwrap();
51 | let mut response = [0u8; 256];
52 | // First response
53 | let n = stream.read(&mut response[..100]).unwrap();
54 | let response_str = from_utf8(&response[..n]).unwrap();
55 | assert_eq!(
56 | response_str,
57 | "HTTP/1.1 200 OK\r\n\
58 | content-type: text/plain; charset=utf-8\r\n\
59 | content-length: 12\r\n\
60 | \r\n\
61 | Hello world!"
62 | );
63 | // Second response
64 | let n = stream.read(&mut response).unwrap();
65 | let response_str = from_utf8(&response[..n]).unwrap();
66 | assert_eq!(
67 | response_str,
68 | "HTTP/1.1 200 OK\r\n\
69 | content-type: text/plain; charset=utf-8\r\n\
70 | content-length: 12\r\n\
71 | \r\n\
72 | Hello world!"
73 | );
74 | }
75 |
76 | #[test]
77 | fn pipeline_requests_in_2_parts() {
78 | Process::spawn_link(8902, hell_world_server);
79 | // Give enough time to for server to start
80 | sleep(Duration::from_millis(10));
81 | let mut stream = TcpStream::connect("localhost:8902").unwrap();
82 | let request = "\
83 | GET / HTTP/1.1\r\n\
84 | Content-length: 5\r\n\
85 | \r\n\
86 | Hello\
87 | GET /"
88 | .as_bytes();
89 | stream.write_all(request).unwrap();
90 | let mut response = [0u8; 256];
91 | // First response
92 | let n = stream.read(&mut response).unwrap();
93 | let response_str = from_utf8(&response[..n]).unwrap();
94 | assert_eq!(
95 | response_str,
96 | "HTTP/1.1 200 OK\r\n\
97 | content-type: text/plain; charset=utf-8\r\n\
98 | content-length: 12\r\n\
99 | \r\n\
100 | Hello world!"
101 | );
102 | // Second response
103 | let request_rest = " HTTP/1.1\r\n\r\n".as_bytes();
104 | stream.write_all(request_rest).unwrap();
105 |
106 | let n = stream.read(&mut response).unwrap();
107 | let response_str = from_utf8(&response[..n]).unwrap();
108 | assert_eq!(
109 | response_str,
110 | "HTTP/1.1 200 OK\r\n\
111 | content-type: text/plain; charset=utf-8\r\n\
112 | content-length: 12\r\n\
113 | \r\n\
114 | Hello world!"
115 | );
116 | }
117 |
118 | #[test]
119 | fn invalid_method() {
120 | Process::spawn_link(8903, hell_world_server);
121 | // Give enough time to for server to start
122 | sleep(Duration::from_millis(10));
123 | let mut stream = TcpStream::connect("localhost:8903").unwrap();
124 | let request = "INVALID / HTTP/1.1\r\n\r\n".as_bytes();
125 | stream.write_all(request).unwrap();
126 | let mut response = [0u8; 256];
127 | let n = stream.read(&mut response).unwrap();
128 | let response_str = from_utf8(&response[..n]).unwrap();
129 | assert_eq!(
130 | response_str,
131 | "HTTP/1.1 404 Not Found\r\n\
132 | content-type: text/html; charset=UTF-8\r\n\
133 | content-length: 23\r\n\
134 | \r\n\
135 | 404: Not found
"
136 | );
137 | }
138 |
139 | fn panic_server(port: u16, _: Mailbox<()>) {
140 | fn panic_handler() {
141 | panic!()
142 | }
143 |
144 | Application::new(router! {
145 | GET "/" => panic_handler
146 | })
147 | .serve(format!("localhost:{port}"))
148 | .unwrap();
149 | }
150 |
151 | #[test]
152 | fn handler_panics() {
153 | Process::spawn_link(8904, panic_server);
154 | // Give enough time to for server to start
155 | sleep(Duration::from_millis(10));
156 | let mut stream = TcpStream::connect("localhost:8904").unwrap();
157 | let request = "GET / HTTP/1.1\r\n\r\n".as_bytes();
158 | stream.write_all(request).unwrap();
159 | let mut response = [0u8; 256];
160 | let n = stream.read(&mut response).unwrap();
161 | let response_str = from_utf8(&response[..n]).unwrap();
162 | assert_eq!(
163 | response_str,
164 | "HTTP/1.1 500 Internal Server Error\r\n\
165 | content-type: text/plain; charset=utf-8\r\n\
166 | content-length: 21\r\n\
167 | \r\n\
168 | Internal Server Error"
169 | );
170 | }
171 |
172 | fn post_echo_server(port: u16, _: Mailbox<()>) {
173 | fn hello_world_handler(data: Body) -> Vec {
174 | data.as_slice().into()
175 | }
176 |
177 | Application::new(router! {
178 | POST "/" => hello_world_handler
179 | })
180 | .serve(format!("localhost:{port}"))
181 | .unwrap();
182 | }
183 |
184 | #[test]
185 | fn post_request_keep_alive() {
186 | Process::spawn_link(8905, post_echo_server);
187 | // Give enough time to for server to start
188 | sleep(Duration::from_millis(10));
189 | let mut stream = TcpStream::connect("localhost:8905").unwrap();
190 | let request = "\
191 | POST / HTTP/1.1\r\n\
192 | Content-length: 5\r\n\
193 | \r\n\
194 | Hello"
195 | .as_bytes();
196 | stream.write_all(request).unwrap();
197 | let mut response = [0u8; 256];
198 | let n = stream.read(&mut response).unwrap();
199 | let response_str = from_utf8(&response[..n]).unwrap();
200 | assert_eq!(
201 | response_str,
202 | "HTTP/1.1 200 OK\r\n\
203 | content-type: application/octet-stream\r\n\
204 | content-length: 5\r\n\
205 | \r\n\
206 | Hello"
207 | );
208 | }
209 |
--------------------------------------------------------------------------------
/submillisecond_macros/src/router/trie.rs:
--------------------------------------------------------------------------------
1 | use std::fmt::Debug;
2 | use std::mem;
3 |
4 | #[derive(Debug)]
5 | pub struct Trie {
6 | node: TrieNode,
7 | }
8 |
9 | impl Default for Trie {
10 | fn default() -> Self {
11 | Trie {
12 | node: TrieNode::Empty,
13 | }
14 | }
15 | }
16 |
17 | impl Trie
18 | where
19 | V: Clone,
20 | {
21 | pub fn children(&self) -> Children {
22 | Children::new(TrieNode::Node {
23 | value: None,
24 | prefix: String::new(),
25 | children: vec![self.node.clone()],
26 | })
27 | }
28 |
29 | pub fn insert(&mut self, key: String, new_value: V) {
30 | self.node.insert(key, new_value)
31 | }
32 | }
33 |
34 | #[derive(Debug, Clone)]
35 | pub enum TrieNode {
36 | Node {
37 | value: Option,
38 | prefix: String,
39 | children: Vec>,
40 | },
41 | Empty,
42 | }
43 |
44 | impl TrieNode
45 | where
46 | V: Clone,
47 | {
48 | pub fn create_terminal(prefix: String, value: V) -> Self {
49 | TrieNode::Node {
50 | value: Some(value),
51 | prefix,
52 | children: vec![],
53 | }
54 | }
55 |
56 | pub fn insert(&mut self, key: String, new_value: V) {
57 | let key_len = key.len();
58 | match self {
59 | TrieNode::Node {
60 | ref mut prefix,
61 | ref mut children,
62 | ref mut value,
63 | } => {
64 | let mut last_match = key_len;
65 | for (idx, b) in key.chars().enumerate() {
66 | // if node prefix ended, try to delegate to a child
67 | if idx >= prefix.len() {
68 | return Self::delegate_to_child(
69 | key[idx..].to_string(),
70 | new_value,
71 | children,
72 | );
73 | }
74 | // if matches current node, delegate to a child
75 | if b == prefix.chars().nth(idx).unwrap() {
76 | continue;
77 | } else {
78 | // they are not the same, need to split at longest common prefix
79 | last_match = idx;
80 | break;
81 | }
82 | }
83 | // inserting the same key
84 | if last_match == prefix.len() {
85 | return;
86 | }
87 | // in this case, key_len will ALWAYS be shorter than prefix.len()
88 | // prefix has left-over data, need to split the prefix
89 | let (new_prefix, suffix) = prefix.split_at(last_match);
90 | // create new node that carries data from current node
91 | let new_child = TrieNode::Node {
92 | value: mem::take(value),
93 | prefix: suffix.to_string(),
94 | children: mem::take(children),
95 | };
96 | // insert new node with new suffix if
97 | if last_match < key_len {
98 | // create new self
99 | *self = TrieNode::Node {
100 | value: None,
101 | prefix: new_prefix.to_string(),
102 | children: vec![
103 | new_child,
104 | TrieNode::Node {
105 | value: Some(new_value),
106 | prefix: key.as_str()[last_match..].to_string(),
107 | children: vec![],
108 | },
109 | ],
110 | };
111 | } else {
112 | // create new self
113 | *self = TrieNode::Node {
114 | value: Some(new_value),
115 | prefix: new_prefix.to_string(),
116 | children: vec![new_child],
117 | };
118 | }
119 | }
120 | TrieNode::Empty => {
121 | *self = TrieNode::create_terminal(key, new_value);
122 | }
123 | }
124 | }
125 |
126 | fn delegate_to_child(key: String, new_value: V, children: &mut Vec>) {
127 | let next = key.chars().next();
128 | // if we find any existing match for the next one we pass it on
129 | let child = children.iter_mut().find(|c| {
130 | if let TrieNode::Node { prefix, .. } = c {
131 | // if first character matches we found the right child
132 | return prefix.chars().next() == next;
133 | }
134 | false
135 | });
136 | if let Some(child) = child {
137 | child.insert(key, new_value);
138 | } else {
139 | // create a new terminal child
140 | children.push(TrieNode::create_terminal(key, new_value));
141 | }
142 | }
143 |
144 | pub fn children(&self) -> Children {
145 | Children::new(self.clone())
146 | }
147 | }
148 |
149 | #[derive(Clone, Debug)]
150 | pub struct Node {
151 | pub prefix: String,
152 | pub value: Option,
153 | pub trie_node: TrieNode,
154 | }
155 |
156 | impl Node
157 | where
158 | V: Clone,
159 | {
160 | pub fn children(&self) -> Children {
161 | self.trie_node.children()
162 | }
163 |
164 | pub fn is_leaf(&self) -> bool {
165 | if let TrieNode::Node { ref children, .. } = self.trie_node {
166 | return children.is_empty();
167 | }
168 | true
169 | }
170 | }
171 |
172 | #[derive(Clone, Debug)]
173 | pub struct Children
174 | where
175 | V: Clone,
176 | {
177 | trie: TrieNode,
178 | idx_child: usize,
179 | }
180 |
181 | impl Children
182 | where
183 | V: Clone,
184 | {
185 | pub fn new(trie: TrieNode) -> Self {
186 | Children { trie, idx_child: 0 }
187 | }
188 | }
189 |
190 | impl Iterator for Children
191 | where
192 | V: Clone,
193 | {
194 | type Item = Node;
195 |
196 | fn next(&mut self) -> Option {
197 | match self.trie {
198 | TrieNode::Node { ref children, .. } if self.idx_child < children.len() => {
199 | let current_child = &children[self.idx_child];
200 | self.idx_child += 1;
201 | if let TrieNode::Node { value, prefix, .. } = current_child {
202 | Some(Node {
203 | prefix: prefix.clone(),
204 | value: value.clone(),
205 | trie_node: current_child.clone(),
206 | })
207 | } else {
208 | None
209 | }
210 | }
211 | _ => None,
212 | }
213 | }
214 | }
215 |
216 | #[cfg(test)]
217 | mod tests {
218 | use super::*;
219 |
220 | #[test]
221 | fn trie_basic() {
222 | let mut trie = Trie::default();
223 | trie.insert("/".to_string(), "/");
224 | trie.insert("/vec".to_string(), "/");
225 | trie.insert("/json".to_string(), "/");
226 |
227 | let prefixes: Vec<_> = trie.children().map(|c| c.prefix).collect();
228 | assert_eq!(prefixes, vec!["/"])
229 | }
230 | }
231 |
--------------------------------------------------------------------------------
/submillisecond_macros/src/lib.rs:
--------------------------------------------------------------------------------
1 | mod named_param;
2 | mod router;
3 | mod static_router;
4 |
5 | use proc_macro::TokenStream;
6 | use router::Router;
7 | use static_router::StaticRouter;
8 | use syn::{parse_macro_input, DeriveInput};
9 |
10 | /// The `NamedParam` derive macro can be used to implement `FromRequest` for a
11 | /// struct.
12 | ///
13 | /// If using with unnamed struct, then the `#[param(name = "...")]` attribute
14 | /// should be used.
15 | ///
16 | /// If using with a struct with named fields, then each field name should match
17 | /// the ones defined in the router.
18 | ///
19 | /// # Struct with fields example
20 | ///
21 | /// ```ignore
22 | /// #[derive(NamedParam)]
23 | /// struct Params {
24 | /// name: String,
25 | /// age: i32,
26 | /// }
27 | ///
28 | /// fn user_name_age(Params { name, age }: Params) -> String {
29 | /// format!("Hello {name}, you are {age} years old")
30 | /// }
31 | ///
32 | /// router! {
33 | /// GET "/user/:name/:age" => user_name_age
34 | /// }
35 | /// ```
36 | ///
37 | /// # Unnamed struct example
38 | ///
39 | /// ```ignore
40 | /// #[derive(NamedParam)]
41 | /// #[param(name = "age")]
42 | /// struct AgeParam(i32);
43 | ///
44 | /// fn age_param(AgeParam(age): AgeParam) -> String {
45 | /// format!("You are {age} years old")
46 | /// }
47 | ///
48 | /// router! {
49 | /// GET "/user/:age" => age_param
50 | /// }
51 | /// ```
52 | #[proc_macro_derive(NamedParam, attributes(param))]
53 | pub fn named_param(input: TokenStream) -> TokenStream {
54 | let input = parse_macro_input!(input as DeriveInput);
55 | match named_param::NamedParam::try_from(input) {
56 | Ok(named_param) => named_param.expand().into(),
57 | Err(err) => err.into_compile_error().into(),
58 | }
59 | }
60 |
61 | /// Macro for defining a router in [submillisecond](https://github.com/lunatic-solutions/submillisecond).
62 | ///
63 | /// The syntax in this macro is aimed to be as simple and intuitive as possible.
64 | ///
65 | /// # Handlers
66 | ///
67 | /// Handlers are routes with a HTTP method, path and handler.
68 | ///
69 | /// A basic example would be:
70 | ///
71 | /// ```ignore
72 | /// router! {
73 | /// GET "/home" => home_handler
74 | /// }
75 | /// ```
76 | ///
77 | /// In this example, `home_handler` is a function we defined which implements
78 | /// `Handler`.
79 | ///
80 | /// Multiple routes can be defined with handlers:
81 | ///
82 | /// ```ignore
83 | /// router! {
84 | /// GET "/" => index_handler
85 | /// GET "/about" => about_handler
86 | /// POST "/avatar" => avatar_handler
87 | /// }
88 | /// ```
89 | ///
90 | /// ## Methods
91 | ///
92 | /// The supported methods are:
93 | ///
94 | /// - GET
95 | /// - POST
96 | /// - PUT
97 | /// - DELETE
98 | /// - HEAD
99 | /// - OPTIONS
100 | /// - PATCH
101 | ///
102 | /// # Sub-routers
103 | ///
104 | /// Routers can be nested to create more complex routing.
105 | ///
106 | /// Sub-routers are a similar syntax as handlers, except that they do not have a
107 | /// method prefix, and have curly braces after the `=>`.
108 | ///
109 | /// ```ignore
110 | /// router! {
111 | /// "/admin" => {
112 | /// GET "/dashboard" => admin_dashboard
113 | /// POST "/auth" => admin_auth
114 | /// }
115 | /// }
116 | /// ```
117 | ///
118 | /// The syntax in-between `{` and `}` is the same as the `router` macro itself.
119 | ///
120 | /// # Layers/middleware
121 | ///
122 | /// Handlers which call [`submillisecond::RequestContext::next_handler`](https://docs.rs/submillisecond/latest/submillisecond/struct.RequestContext.html#method.next_handler) are
123 | /// considered to be middleware.
124 | ///
125 | /// Middleware can be used in the router macro using the `with` keyword.
126 | ///
127 | /// ```ignore
128 | /// router! {
129 | /// with global_logger;
130 | /// }
131 | /// ```
132 | ///
133 | /// Multiple middleware can be used with the array syntax.
134 | ///
135 | /// ```ignore
136 | /// router! {
137 | /// with [layer_one, layer_two];
138 | /// }
139 | /// ```
140 | ///
141 | /// In the examples above, the middleware is used on the whole router.
142 | /// Instead, we can also use middleware on a per-route basis.
143 | ///
144 | /// ```ignore
145 | /// router! {
146 | /// GET "/" with logger_layer => index_handler
147 | /// }
148 | /// ```
149 | ///
150 | /// When using guards, middleware should be placed after the if statement.
151 | ///
152 | /// ```ignore
153 | /// router! {
154 | /// GET "/admin" if IsAdmin with logger_layer => admin_handler
155 | /// }
156 | /// ```
157 | ///
158 | /// # Guards
159 | ///
160 | /// Guards can be used to protect routes.
161 | ///
162 | /// The syntax is similar to a regular `if` statement, and is placed after the
163 | /// path of a route.
164 | ///
165 | /// ```ignore
166 | /// router! {
167 | /// GET "/admin" if IsAdmin => admin_handler
168 | /// }
169 | /// ```
170 | ///
171 | /// # Syntax
172 | ///
173 | /// ##### RouterDefinition
174 | ///
175 | /// > `{`
176 | /// >
177 | /// > [_RouterMiddleware_]﹖ `;`
178 | /// >
179 | /// > [_RouterItem_]*
180 | /// >
181 | /// > [_RouterCatchAll_]﹖
182 | /// >
183 | /// > `}`
184 | ///
185 | /// ##### RouterItem
186 | ///
187 | /// > [_RouterMethod_]﹖ [STRING_LITERAL] [_RouterIfStmt_]﹖
188 | /// > [_RouterMiddleware_] `=>` [_RouterItemValue_]
189 | ///
190 | /// ##### RouterItemValue
191 | ///
192 | /// > [IDENTIFIER] | [_RouterDefinition_]
193 | ///
194 | /// ##### RouterMethod
195 | ///
196 | /// > `GET` | `POST` | `PUT` | `DELETE` | `HEAD` | `OPTIONS` | `PATCH`
197 | ///
198 | /// ##### RouterMiddleware
199 | ///
200 | /// > `with` [_RouterMiddlewareItem_]
201 | ///
202 | /// ##### RouterMiddlewareItem
203 | ///
204 | /// > [IDENTIFIER] | `[` [IDENTIFIER] `]`
205 | ///
206 | /// ##### RouterIfStmt
207 | ///
208 | /// > `if` [Expression]
209 | ///
210 | /// ##### RouterCatchAll
211 | ///
212 | /// > `_` `=>` [_RouterItemValue_]
213 | ///
214 | /// [_RouterDefinition_]: #routerdefinition
215 | /// [_RouterMiddleware_]: #routermiddleware
216 | /// [_RouterMiddlewareItem_]: #routermiddlewareitem
217 | /// [_RouterItem_]: #routeritem
218 | /// [_RouterItemValue_]: #routeritemvalue
219 | /// [_RouterMethod_]: #routermethod
220 | /// [_RouterIfStmt_]: #routerifstmt
221 | /// [_RouterCatchAll_]: #routercatchall
222 | ///
223 | /// [IDENTIFIER]: https://doc.rust-lang.org/reference/identifiers.html
224 | /// [STRING_LITERAL]: https://doc.rust-lang.org/reference/tokens.html#string-literals
225 | /// [Expression]: https://doc.rust-lang.org/reference/expressions.html
226 | #[proc_macro]
227 | pub fn router(input: TokenStream) -> TokenStream {
228 | let input = parse_macro_input!(input as Router);
229 | input.expand().into()
230 | }
231 |
232 | /// The static router can be used to serve static files within a folder.
233 | ///
234 | /// Two arguments can be passed to the router, with the first one being
235 | /// optional:
236 | /// - The path to your static directory (relative to your Cargo.toml).
237 | /// - A custom 404 handler (optional).
238 | ///
239 | /// # Basic example
240 | ///
241 | /// ```ignore
242 | /// static_router!("./static")
243 | /// ```
244 | ///
245 | /// # Example with custom 404 handler
246 | ///
247 | /// ```ignore
248 | /// static_router!("./static", handle_404)
249 | /// ```
250 | #[proc_macro]
251 | pub fn static_router(input: TokenStream) -> TokenStream {
252 | let input = parse_macro_input!(input as StaticRouter);
253 | input.expand().into()
254 | }
255 |
256 | macro_rules! hquote {( $($tt:tt)* ) => (
257 | ::quote::quote_spanned! { ::proc_macro2::Span::mixed_site()=>
258 | $($tt)*
259 | }
260 | )}
261 | pub(crate) use hquote;
262 |
--------------------------------------------------------------------------------
/src/extract/rejection.rs:
--------------------------------------------------------------------------------
1 | //! Rejection response types.
2 |
3 | use super::path::FailedToDeserializePathParams;
4 | use crate::response::IntoResponse;
5 | use crate::Response;
6 | #[cfg(feature = "query")]
7 | use crate::{BoxError, Error};
8 |
9 | define_rejection! {
10 | #[status = INTERNAL_SERVER_ERROR]
11 | #[body = "No paths parameters found for matched route. Are you also extracting `Request<_>`?"]
12 | /// Rejection type used if axum's internal representation of path parameters
13 | /// is missing. This is commonly caused by extracting `Request<_>`. `Path`
14 | /// must be extracted first.
15 | pub struct MissingPathParams;
16 | }
17 |
18 | composite_rejection! {
19 | /// Rejection used for [`Path`](super::Path).
20 | ///
21 | /// Contains one variant for each way the [`Path`](super::Path) extractor
22 | /// can fail.
23 | pub enum PathRejection {
24 | FailedToDeserializePathParams,
25 | MissingPathParams,
26 | }
27 | }
28 |
29 | /// Rejection type for extractors that deserialize query strings if the input
30 | /// couldn't be deserialized into the target type.
31 | #[cfg(feature = "query")]
32 | #[derive(Debug)]
33 | pub struct FailedToDeserializeQueryString {
34 | error: Error,
35 | type_name: &'static str,
36 | }
37 |
38 | #[cfg(feature = "query")]
39 | impl FailedToDeserializeQueryString {
40 | #[doc(hidden)]
41 | pub fn __private_new(error: E) -> Self
42 | where
43 | E: Into