adding jwt middlewares, and improving overall middlewares structure and server

src/server.rs

@@ -1,8 +1,12 @@
-use crate::{builder::ServerBuilder, config::ServerConfig, responder::Responder};
+use crate::{
+    builder::ServerBuilder,
+    config::ServerConfig,
+    middleware::{Middleware, MiddlewareResult},
+};
 use http1::Builder;
 use http_body_util::Full;
 use hyper::{body::Incoming, server::conn::http1, service::service_fn, Request, Response};
-use hyper_util::rt::{TokioIo, TokioTimer};
+use hyper_util::rt::TokioIo;
 use log::error;
 use std::{convert::Infallible, future::Future, net::SocketAddr, sync::Arc};
 use tokio::{net::TcpListener, spawn};
@@ -10,12 +14,14 @@ use tokio_util::bytes::Bytes;
 
 pub struct Server {
     pub config: Arc<ServerConfig>,
+    pub middlewares: Arc<Vec<Box<dyn Middleware>>>,
 }
 
 impl Server {
     pub fn builder() -> ServerBuilder {
         ServerBuilder {
             config: ServerConfig::default(),
+            middlewares: vec![],
         }
     }
 
@@ -27,56 +33,51 @@ impl Server {
         let addr: SocketAddr = format!("{}:{}", self.config.ip, self.config.port)
             .parse()
             .expect("Invalid IP or port");
-        let listener = TcpListener::bind(addr).await.unwrap();
 
+        let listener = TcpListener::bind(addr)
+            .await
+            .expect("Failed to bind to address");
         let handler = Arc::new(handler);
+
+        let shared_middlewares = self.middlewares;
         loop {
             let (tcp, client_addr) = match listener.accept().await {
                 Ok(conn) => conn,
-                Err(error) => {
-                    error!(
-                        error = error.to_string().as_str();
-                        "Failed to accept connection"
-                    );
+                Err(e) => {
+                    error!("Accept error: {}", e);
                     continue;
                 }
             };
+
             let io = TokioIo::new(tcp);
 
-            let config = Arc::clone(&self.config);
-            let handler = Arc::clone(&handler);
+            let mws = Arc::clone(&shared_middlewares);
+            let h = Arc::clone(&handler);
+            let client_ip = client_addr.ip();
+
             spawn(async move {
-                if let Err(error) = Builder::new()
-                    .timer(TokioTimer::new())
-                    .serve_connection(
-                        io,
-                        service_fn(move |req| {
-                            let config = Arc::clone(&config);
-                            let handler = Arc::clone(&handler);
+                let conn = Builder::new().serve_connection(
+                    io,
+                    service_fn(move |mut req| {
+                        let mws = Arc::clone(&mws);
+                        let h = Arc::clone(&h);
 
-                            async move {
-                                if !config.is_ip_authorized(&client_addr.ip())
-                                    || !config.is_req_authorized(&req)
-                                {
-                                    if config.log_unauthorized {
-                                        error!(tag = "ban",
-                                            ip = client_addr.ip().to_string().as_str();
-                                            "Unauthorized"
-                                        );
-                                    }
+                        async move {
+                            req.extensions_mut().insert(client_ip);
 
-                                    Responder::unathorized()
-                                } else {
-                                    handler(req).await
+                            for mw in mws.iter() {
+                                match mw.run(req).await {
+                                    MiddlewareResult::Continue(next_req) => req = next_req,
+                                    MiddlewareResult::Respond(res) => return Ok(res),
                                 }
                             }
-                        }),
-                    )
-                    .await
-                {
-                    error!(error = error.to_string().as_str();
-                        "Serving connection"
-                    );
+                            h(req).await
+                        }
+                    }),
+                );
+
+                if let Err(err) = conn.await {
+                    error!("Error serving connection: {:?}", err);
                 }
             });
         }