@@ -2,16 +2,18 @@ extern crate conduit;
2
2
3
3
use std:: error:: Error ;
4
4
5
- use conduit:: { Request , Response , Handler } ;
5
+ use conduit:: { Handler , Request , Response } ;
6
6
7
7
pub trait Middleware : Send + Sync + ' static {
8
- fn before ( & self , _: & mut dyn Request ) -> Result < ( ) , Box < dyn Error + Send > > {
8
+ fn before ( & self , _: & mut dyn Request ) -> Result < ( ) , Box < dyn Error + Send > > {
9
9
Ok ( ( ) )
10
10
}
11
11
12
- fn after ( & self , _: & mut dyn Request , res : Result < Response , Box < dyn Error +Send > > )
13
- -> Result < Response , Box < dyn Error +Send > >
14
- {
12
+ fn after (
13
+ & self ,
14
+ _: & mut dyn Request ,
15
+ res : Result < Response , Box < dyn Error + Send > > ,
16
+ ) -> Result < Response , Box < dyn Error + Send > > {
15
17
res
16
18
}
17
19
}
@@ -22,19 +24,20 @@ pub trait AroundMiddleware: Handler {
22
24
23
25
pub struct MiddlewareBuilder {
24
26
middlewares : Vec < Box < dyn Middleware > > ,
25
- handler : Option < Box < dyn Handler > >
27
+ handler : Option < Box < dyn Handler > > ,
26
28
}
27
29
28
30
impl MiddlewareBuilder {
29
31
pub fn new < H : Handler > ( handler : H ) -> MiddlewareBuilder {
30
32
MiddlewareBuilder {
31
- middlewares : vec ! ( ) ,
32
- handler : Some ( Box :: new ( handler) as Box < dyn Handler > )
33
+ middlewares : vec ! [ ] ,
34
+ handler : Some ( Box :: new ( handler) as Box < dyn Handler > ) ,
33
35
}
34
36
}
35
37
36
38
pub fn add < M : Middleware > ( & mut self , middleware : M ) {
37
- self . middlewares . push ( Box :: new ( middleware) as Box < dyn Middleware > ) ;
39
+ self . middlewares
40
+ . push ( Box :: new ( middleware) as Box < dyn Middleware > ) ;
38
41
}
39
42
40
43
pub fn around < M : AroundMiddleware > ( & mut self , mut middleware : M ) {
@@ -45,7 +48,7 @@ impl MiddlewareBuilder {
45
48
}
46
49
47
50
impl Handler for MiddlewareBuilder {
48
- fn call ( & self , req : & mut dyn Request ) -> Result < Response , Box < dyn Error + Send > > {
51
+ fn call ( & self , req : & mut dyn Request ) -> Result < Response , Box < dyn Error + Send > > {
49
52
let mut error = None ;
50
53
51
54
for ( i, middleware) in self . middlewares . iter ( ) . enumerate ( ) {
@@ -62,7 +65,7 @@ impl Handler for MiddlewareBuilder {
62
65
Some ( ( err, i) ) => {
63
66
let middlewares = & self . middlewares [ ..i] ;
64
67
run_afters ( middlewares, req, Err ( err) )
65
- } ,
68
+ }
66
69
None => {
67
70
let res = { self . handler . as_ref ( ) . unwrap ( ) . call ( req) } ;
68
71
let middlewares = & self . middlewares ;
@@ -73,60 +76,87 @@ impl Handler for MiddlewareBuilder {
73
76
}
74
77
}
75
78
76
- fn run_afters ( middleware : & [ Box < dyn Middleware > ] ,
77
- req : & mut dyn Request ,
78
- res : Result < Response , Box < dyn Error +Send > > )
79
- -> Result < Response , Box < dyn Error +Send > >
80
- {
81
- middleware. iter ( ) . rev ( ) . fold ( res, |res, m| m. after ( req, res) )
79
+ fn run_afters (
80
+ middleware : & [ Box < dyn Middleware > ] ,
81
+ req : & mut dyn Request ,
82
+ res : Result < Response , Box < dyn Error + Send > > ,
83
+ ) -> Result < Response , Box < dyn Error + Send > > {
84
+ middleware
85
+ . iter ( )
86
+ . rev ( )
87
+ . fold ( res, |res, m| m. after ( req, res) )
82
88
}
83
89
84
90
#[ cfg( test) ]
85
91
mod tests {
86
92
extern crate semver;
87
93
88
- use { MiddlewareBuilder , Middleware , AroundMiddleware } ;
94
+ use { AroundMiddleware , Middleware , MiddlewareBuilder } ;
89
95
90
96
use std:: any:: Any ;
91
97
use std:: collections:: HashMap ;
92
98
use std:: error:: Error ;
93
- use std:: io:: { self , Cursor } ;
94
99
use std:: io:: prelude:: * ;
100
+ use std:: io:: { self , Cursor } ;
95
101
use std:: net:: SocketAddr ;
96
102
97
103
use conduit;
98
- use conduit:: { Request , Response , Host , Headers , Method , Scheme , Extensions } ;
104
+ use conduit:: { Extensions , Headers , Host , Method , Request , Response , Scheme } ;
99
105
use conduit:: { Handler , TypeMap } ;
100
106
101
107
struct RequestSentinel {
102
108
path : String ,
103
109
extensions : TypeMap ,
104
- method : Method
110
+ method : Method ,
105
111
}
106
112
107
113
impl RequestSentinel {
108
114
fn new ( method : Method , path : & ' static str ) -> RequestSentinel {
109
115
RequestSentinel {
110
116
path : path. to_string ( ) ,
111
117
extensions : TypeMap :: new ( ) ,
112
- method : method
118
+ method : method,
113
119
}
114
120
}
115
121
}
116
122
117
123
impl conduit:: Request for RequestSentinel {
118
- fn http_version ( & self ) -> semver:: Version { unimplemented ! ( ) }
119
- fn conduit_version ( & self ) -> semver:: Version { unimplemented ! ( ) }
120
- fn method ( & self ) -> Method { self . method . clone ( ) }
121
- fn scheme ( & self ) -> Scheme { unimplemented ! ( ) }
122
- fn host < ' a > ( & ' a self ) -> Host < ' a > { unimplemented ! ( ) }
123
- fn virtual_root < ' a > ( & ' a self ) -> Option < & ' a str > { unimplemented ! ( ) }
124
- fn path < ' a > ( & ' a self ) -> & ' a str { & self . path }
125
- fn query_string < ' a > ( & ' a self ) -> Option < & ' a str > { unimplemented ! ( ) }
126
- fn remote_addr ( & self ) -> SocketAddr { unimplemented ! ( ) }
127
- fn content_length ( & self ) -> Option < u64 > { unimplemented ! ( ) }
128
- fn headers < ' a > ( & ' a self ) -> & ' a dyn Headers { unimplemented ! ( ) }
129
- fn body < ' a > ( & ' a mut self ) -> & ' a mut dyn Read { unimplemented ! ( ) }
124
+ fn http_version ( & self ) -> semver:: Version {
125
+ unimplemented ! ( )
126
+ }
127
+ fn conduit_version ( & self ) -> semver:: Version {
128
+ unimplemented ! ( )
129
+ }
130
+ fn method ( & self ) -> Method {
131
+ self . method . clone ( )
132
+ }
133
+ fn scheme ( & self ) -> Scheme {
134
+ unimplemented ! ( )
135
+ }
136
+ fn host < ' a > ( & ' a self ) -> Host < ' a > {
137
+ unimplemented ! ( )
138
+ }
139
+ fn virtual_root < ' a > ( & ' a self ) -> Option < & ' a str > {
140
+ unimplemented ! ( )
141
+ }
142
+ fn path < ' a > ( & ' a self ) -> & ' a str {
143
+ & self . path
144
+ }
145
+ fn query_string < ' a > ( & ' a self ) -> Option < & ' a str > {
146
+ unimplemented ! ( )
147
+ }
148
+ fn remote_addr ( & self ) -> SocketAddr {
149
+ unimplemented ! ( )
150
+ }
151
+ fn content_length ( & self ) -> Option < u64 > {
152
+ unimplemented ! ( )
153
+ }
154
+ fn headers < ' a > ( & ' a self ) -> & ' a dyn Headers {
155
+ unimplemented ! ( )
156
+ }
157
+ fn body < ' a > ( & ' a mut self ) -> & ' a mut dyn Read {
158
+ unimplemented ! ( )
159
+ }
130
160
fn extensions < ' a > ( & ' a self ) -> & ' a Extensions {
131
161
& self . extensions
132
162
}
@@ -138,7 +168,7 @@ mod tests {
138
168
struct MyMiddleware ;
139
169
140
170
impl Middleware for MyMiddleware {
141
- fn before < ' a > ( & self , req : & ' a mut dyn Request ) -> Result < ( ) , Box < dyn Error + Send > > {
171
+ fn before < ' a > ( & self , req : & ' a mut dyn Request ) -> Result < ( ) , Box < dyn Error + Send > > {
142
172
req. mut_extensions ( ) . insert ( "hello" . to_string ( ) ) ;
143
173
Ok ( ( ) )
144
174
}
@@ -147,15 +177,17 @@ mod tests {
147
177
struct ErrorRecovery ;
148
178
149
179
impl Middleware for ErrorRecovery {
150
- fn after ( & self , _: & mut dyn Request , res : Result < Response , Box < dyn Error +Send > > )
151
- -> Result < Response , Box < dyn Error +Send > >
152
- {
180
+ fn after (
181
+ & self ,
182
+ _: & mut dyn Request ,
183
+ res : Result < Response , Box < dyn Error + Send > > ,
184
+ ) -> Result < Response , Box < dyn Error + Send > > {
153
185
res. or_else ( |e| {
154
186
let e = e. to_string ( ) ;
155
187
Ok ( Response {
156
188
status : ( 500 , "Internal Server Error" ) ,
157
189
headers : HashMap :: new ( ) ,
158
- body : Box :: new ( Cursor :: new ( e. into_bytes ( ) ) )
190
+ body : Box :: new ( Cursor :: new ( e. into_bytes ( ) ) ) ,
159
191
} )
160
192
} )
161
193
}
@@ -164,27 +196,29 @@ mod tests {
164
196
struct ProducesError ;
165
197
166
198
impl Middleware for ProducesError {
167
- fn before ( & self , _: & mut dyn Request ) -> Result < ( ) , Box < dyn Error + Send > > {
199
+ fn before ( & self , _: & mut dyn Request ) -> Result < ( ) , Box < dyn Error + Send > > {
168
200
Err ( Box :: new ( io:: Error :: new ( io:: ErrorKind :: Other , "" ) ) )
169
201
}
170
202
}
171
203
172
204
struct NotReached ;
173
205
174
206
impl Middleware for NotReached {
175
- fn after ( & self , _: & mut dyn Request , _: Result < Response , Box < dyn Error +Send > > )
176
- -> Result < Response , Box < dyn Error +Send > >
177
- {
207
+ fn after (
208
+ & self ,
209
+ _: & mut dyn Request ,
210
+ _: Result < Response , Box < dyn Error + Send > > ,
211
+ ) -> Result < Response , Box < dyn Error + Send > > {
178
212
Ok ( Response {
179
213
status : ( 200 , "OK" ) ,
180
214
headers : HashMap :: new ( ) ,
181
- body : Box :: new ( Cursor :: new ( vec ! ( ) ) )
215
+ body : Box :: new ( Cursor :: new ( vec ! [ ] ) ) ,
182
216
} )
183
217
}
184
218
}
185
219
186
220
struct MyAroundMiddleware {
187
- handler : Option < Box < dyn Handler > >
221
+ handler : Option < Box < dyn Handler > > ,
188
222
}
189
223
190
224
impl MyAroundMiddleware {
@@ -202,7 +236,7 @@ mod tests {
202
236
}
203
237
204
238
impl Handler for MyAroundMiddleware {
205
- fn call ( & self , req : & mut dyn Request ) -> Result < Response , Box < dyn Error + Send > > {
239
+ fn call ( & self , req : & mut dyn Request ) -> Result < Response , Box < dyn Error + Send > > {
206
240
req. mut_extensions ( ) . insert ( "hello" . to_string ( ) ) ;
207
241
self . handler . as_ref ( ) . unwrap ( ) . call ( req)
208
242
}
@@ -216,7 +250,7 @@ mod tests {
216
250
Response {
217
251
status : ( 200 , "OK" ) ,
218
252
headers : HashMap :: new ( ) ,
219
- body : Box :: new ( Cursor :: new ( string. into_bytes ( ) ) )
253
+ body : Box :: new ( Cursor :: new ( string. into_bytes ( ) ) ) ,
220
254
}
221
255
}
222
256
0 commit comments