1212- Compact Middleware and Handler System inspired by [ The Iron Framework] ( https://github.com/iron/iron ) .
1313- Simple [ Hyper Service] ( https://docs.rs/hyper/latest/hyper/service/trait.Service.html ) with convenient __ Remote Address__ access.
1414- Convenient ` Error ` and ` Result ` types powered by [ anyhow] ( https://github.com/dtolnay/anyhow ) .
15+ - ` Async ` support via [ async-trait] ( https://github.com/dtolnay/async-trait ) .
16+ - Macros to facilitate HTTP response errors or error casting.
1517
1618## Example
1719
1820[ examples/server.rs] ( examples/server.rs )
1921
2022``` rust
21- #![deny(warnings)]
22- 2323use hyper :: {header, Server , StatusCode };
24- use std :: {net :: SocketAddr , path :: PathBuf };
2524use hyper_middleware :: {
26- async_trait, AfterMiddleware , BeforeMiddleware , Body , Chain , Error , Handler , Request , Response ,
27- Result , Service ,
25+ async_trait, AfterMiddleware , BeforeMiddleware , Body , Error , Handler , Middlewares , Request ,
26+ Response , Result , Service ,
2827};
28+ use std :: {net :: SocketAddr , path :: PathBuf };
2929
3030struct Config {
3131 pub root : PathBuf ,
@@ -39,17 +39,18 @@ struct Application {
3939impl Handler for Application {
4040 async fn handle (& self , req : & mut Request ) -> Result <Response > {
4141 // Access the Hyper incoming Request
42- println! (" Handler - URI Path: {}" , req . uri (). path ());
42+ println! (" Application::handle() - URI Path: {}" , req . uri (). path ());
4343
4444 // Access the custom app options
45- println! (" Config Root: {}" , self . opts. root. display ());
46- 47- // Access the Remote Address
4845 println! (
49- " Remote Addr : {}" ,
50- req . extensions () . get :: < SocketAddr >() . unwrap ()
46+ " Application::handle() - Config Root : {}" ,
47+ self . opts . root . display ()
5148 );
5249
50+ // Access the Remote Address
51+ let remote_addr = req . extensions (). get :: <SocketAddr >(). unwrap ();
52+ println! (" Application::handle() - Remote Addr: {}" , remote_addr );
53+ 5354 // Create a Hyper Response and send it back to the middlewares chain
5455 Ok (Response :: new (Body :: from (" ¡Hola!" )))
5556 }
@@ -60,10 +61,10 @@ struct FirstMiddleware {}
6061#[async_trait]
6162impl BeforeMiddleware for FirstMiddleware {
6263 async fn before (& self , req : & mut Request ) -> Result {
63- println! (" First Middleware called! " );
64+ println! (" FirstMiddleware::before() " );
6465
6566 // Access the Hyper incoming Request
66- println! (" First - URI Path: {}" , req . uri (). path ());
67+ println! (" FirstMiddleware::before() - URI Path: {}" , req . uri (). path ());
6768
6869 Ok (())
6970 }
@@ -78,7 +79,7 @@ struct SecondMiddleware {}
7879#[async_trait]
7980impl AfterMiddleware for SecondMiddleware {
8081 async fn after (& self , _ : & mut Request , mut res : Response ) -> Result <Response > {
81- println! (" Second Middleware called! " );
82+ println! (" SecondMiddleware::after() " );
8283
8384 // Mutate the Hyper Response at convenience
8485 // and send it back to other middlewares on the chain
@@ -105,17 +106,15 @@ async fn main() -> Result {
105106 root : std :: env :: current_dir (). unwrap (),
106107 };
107108
108- // 1. Create a custom middleware chain
109- let mut handler = Chain :: new (Application { opts });
109+ // 1. Create a custom middleware chain and plug in some custom middlewares
110+ let mut middlewares = Middlewares :: new (Application { opts });
111+ middlewares . link_before (FirstMiddleware {});
112+ middlewares . link_after (SecondMiddleware {});
110113
111- // 2. Plug in some custom middlewares
112- handler . link_before (FirstMiddleware {});
113- handler . link_after (SecondMiddleware {});
114+ // 2. Create a Hyper service and set the current handler with its middlewares
115+ let service = Service :: new (middlewares );
114116
115- // 3. Create a Hyper service and set the current handler with its middlewares
116- let service = Service :: new (handler );
117- 118- // 4. Finally just run server using the service already created
117+ // 3. Finally just run server using the service already created
119118 let addr = ([127 , 0 , 0 , 1 ], 8787 ). into ();
120119 let server = Server :: bind (& addr ). serve (service );
121120
@@ -129,7 +128,7 @@ async fn main() -> Result {
129128
130129To run the example just type:
131130
132- ```
131+ ``` sh
133132cargo run --example server
134133```
135134
0 commit comments