1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
pub mod accept;
pub mod access_control_request_method;
pub mod and;
pub mod any;
pub mod content_type;
pub use self::accept::AcceptHeaderRouteMatcher;
pub use self::access_control_request_method::AccessControlRequestMethodMatcher;
pub use self::and::AndRouteMatcher;
pub use self::any::AnyRouteMatcher;
pub use self::content_type::ContentTypeHeaderRouteMatcher;
mod lookup_table;
use self::lookup_table::{LookupTable, LookupTableFromTypes};
use std::panic::RefUnwindSafe;
use hyper::{Method, StatusCode};
use log::trace;
use crate::router::non_match::RouteNonMatch;
use crate::state::{request_id, FromState, State};
pub trait RouteMatcher: RefUnwindSafe + Clone {
fn is_match(&self, state: &State) -> Result<(), RouteNonMatch>;
}
pub trait IntoRouteMatcher {
type Output: RouteMatcher;
fn into_route_matcher(self) -> Self::Output;
}
impl IntoRouteMatcher for Vec<Method> {
type Output = MethodOnlyRouteMatcher;
fn into_route_matcher(self) -> Self::Output {
MethodOnlyRouteMatcher::new(self)
}
}
impl<M> IntoRouteMatcher for M
where
M: RouteMatcher + Send + Sync + 'static,
{
type Output = M;
fn into_route_matcher(self) -> Self::Output {
self
}
}
#[derive(Clone)]
pub struct MethodOnlyRouteMatcher {
methods: Vec<Method>,
}
impl MethodOnlyRouteMatcher {
pub fn new(methods: Vec<Method>) -> Self {
MethodOnlyRouteMatcher { methods }
}
}
impl RouteMatcher for MethodOnlyRouteMatcher {
fn is_match(&self, state: &State) -> Result<(), RouteNonMatch> {
let method = Method::borrow_from(state);
if self.methods.iter().any(|m| m == method) {
trace!(
"[{}] matched request method {} to permitted method",
request_id(&state),
method
);
Ok(())
} else {
trace!(
"[{}] did not match request method {}",
request_id(&state),
method
);
Err(RouteNonMatch::new(StatusCode::METHOD_NOT_ALLOWED)
.with_allow_list(self.methods.as_slice()))
}
}
}