restructure folders

middleware/middleware/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "middleware-example"
+version = "1.0.0"
+edition = "2021"
+
+[dependencies]
+actix-web = "4.0.0-rc.1"
+env_logger = "0.9"
+futures = "0.3.7"
+pin-project = "1"

middleware/middleware/README.md

@@ -0,0 +1,32 @@
+# middleware examples
+
+This example showcases a bunch of different uses of middlewares. See also the [Middleware guide](https://actix.rs/docs/middleware/).
+
+## Usage
+
+```bash
+cd basics/middleware
+cargo run
+# Started http server: 127.0.0.1:8080
+```
+
+Look in `src/main.rs` and comment the different middlewares in/out to see how they function.
+
+## Middlewares
+
+### redirect::CheckLogin
+
+A middleware implementing a request guard which sketches a rough approximation of what a login could look like.
+
+### read_request_body::Logging
+
+A middleware demonstrating how to read out the incoming request body.
+
+### read_response_body::Logging
+
+A middleware demonstrating how to read out the outgoing response body.
+
+### simple::SayHi
+
+A minimal middleware demonstrating the sequence of operations in an actix middleware.
+There is a second version of the same middleware using `wrap_fn` which shows how easily a middleware can be implemented in actix.

middleware/middleware/src/main.rs

@@ -0,0 +1,42 @@
+use actix_web::{dev::Service, web, App, HttpServer};
+use futures::FutureExt as _;
+
+#[allow(dead_code)]
+mod read_request_body;
+#[allow(dead_code)]
+mod read_response_body;
+#[allow(dead_code)]
+mod redirect;
+#[allow(dead_code)]
+mod simple;
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    std::env::set_var("RUST_LOG", "actix_web=debug");
+    env_logger::init();
+
+    HttpServer::new(|| {
+        App::new()
+            .wrap(redirect::CheckLogin)
+            .wrap(read_request_body::Logging)
+            .wrap(read_response_body::Logging)
+            .wrap(simple::SayHi)
+            .wrap_fn(|req, srv| {
+                println!("Hi from start. You requested: {}", req.path());
+
+                srv.call(req).map(|res| {
+                    println!("Hi from response");
+                    res
+                })
+            })
+            .service(web::resource("/login").to(|| async {
+                "You are on /login. Go to src/redirect.rs to change this behavior."
+            }))
+            .service(web::resource("/").to(|| async {
+                "Hello, middleware! Check the console where the server is run."
+            }))
+    })
+    .bind(("127.0.0.1", 8080))?
+    .run()
+    .await
+}

middleware/middleware/src/read_request_body.rs

@@ -0,0 +1,67 @@
+use std::{
+    future::{ready, Ready},
+    rc::Rc,
+};
+
+use actix_web::dev::{self, Service, Transform};
+use actix_web::web::BytesMut;
+use actix_web::{dev::ServiceRequest, dev::ServiceResponse, Error, HttpMessage};
+use futures::future::LocalBoxFuture;
+use futures::stream::StreamExt;
+
+pub struct Logging;
+
+impl<S: 'static, B> Transform<S, ServiceRequest> for Logging
+where
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S::Future: 'static,
+    B: 'static,
+{
+    type Response = ServiceResponse<B>;
+    type Error = Error;
+    type InitError = ();
+    type Transform = LoggingMiddleware<S>;
+    type Future = Ready<Result<Self::Transform, Self::InitError>>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        ready(Ok(LoggingMiddleware {
+            service: Rc::new(service),
+        }))
+    }
+}
+
+pub struct LoggingMiddleware<S> {
+    // This is special: We need this to avoid lifetime issues.
+    service: Rc<S>,
+}
+
+impl<S, B> Service<ServiceRequest> for LoggingMiddleware<S>
+where
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static,
+    S::Future: 'static,
+    B: 'static,
+{
+    type Response = ServiceResponse<B>;
+    type Error = Error;
+    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
+
+    dev::forward_ready!(service);
+
+    fn call(&self, mut req: ServiceRequest) -> Self::Future {
+        let svc = self.service.clone();
+
+        Box::pin(async move {
+            let mut body = BytesMut::new();
+            let mut stream = req.take_payload();
+            while let Some(chunk) = stream.next().await {
+                body.extend_from_slice(&chunk?);
+            }
+
+            println!("request body: {:?}", body);
+            let res = svc.call(req).await?;
+
+            println!("response: {:?}", res.headers());
+            Ok(res)
+        })
+    }
+}

middleware/middleware/src/read_response_body.rs

@@ -0,0 +1,120 @@
+use std::future::Future;
+use std::future::{ready, Ready};
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use actix_web::body::{BodySize, MessageBody};
+use actix_web::dev::{self, Service, Transform};
+use actix_web::web::{Bytes, BytesMut};
+use actix_web::{dev::ServiceRequest, dev::ServiceResponse, Error};
+
+pub struct Logging;
+
+impl<S: 'static, B> Transform<S, ServiceRequest> for Logging
+where
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    B: MessageBody + 'static,
+{
+    type Response = ServiceResponse<BodyLogger<B>>;
+    type Error = Error;
+    type InitError = ();
+    type Transform = LoggingMiddleware<S>;
+    type Future = Ready<Result<Self::Transform, Self::InitError>>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        ready(Ok(LoggingMiddleware { service }))
+    }
+}
+
+pub struct LoggingMiddleware<S> {
+    service: S,
+}
+
+impl<S, B> Service<ServiceRequest> for LoggingMiddleware<S>
+where
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    B: MessageBody,
+{
+    type Response = ServiceResponse<BodyLogger<B>>;
+    type Error = Error;
+    type Future = WrapperStream<S, B>;
+
+    dev::forward_ready!(service);
+
+    fn call(&self, req: ServiceRequest) -> Self::Future {
+        WrapperStream {
+            fut: self.service.call(req),
+            _t: PhantomData,
+        }
+    }
+}
+
+#[pin_project::pin_project]
+pub struct WrapperStream<S, B>
+where
+    B: MessageBody,
+    S: Service<ServiceRequest>,
+{
+    #[pin]
+    fut: S::Future,
+    _t: PhantomData<(B,)>,
+}
+
+impl<S, B> Future for WrapperStream<S, B>
+where
+    B: MessageBody,
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+{
+    type Output = Result<ServiceResponse<BodyLogger<B>>, Error>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let res = futures::ready!(self.project().fut.poll(cx));
+
+        Poll::Ready(res.map(|res| {
+            res.map_body(move |_, body| BodyLogger {
+                body,
+                body_accum: BytesMut::new(),
+            })
+        }))
+    }
+}
+
+#[pin_project::pin_project(PinnedDrop)]
+pub struct BodyLogger<B> {
+    #[pin]
+    body: B,
+    body_accum: BytesMut,
+}
+
+#[pin_project::pinned_drop]
+impl<B> PinnedDrop for BodyLogger<B> {
+    fn drop(self: Pin<&mut Self>) {
+        println!("response body: {:?}", self.body_accum);
+    }
+}
+
+impl<B: MessageBody> MessageBody for BodyLogger<B> {
+    type Error = B::Error;
+
+    fn size(&self) -> BodySize {
+        self.body.size()
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+        let this = self.project();
+
+        match this.body.poll_next(cx) {
+            Poll::Ready(Some(Ok(chunk))) => {
+                this.body_accum.extend_from_slice(&chunk);
+                Poll::Ready(Some(Ok(chunk)))
+            }
+            Poll::Ready(Some(Err(e))) => Poll::Ready(Some(Err(e))),
+            Poll::Ready(None) => Poll::Ready(None),
+            Poll::Pending => Poll::Pending,
+        }
+    }
+}

middleware/middleware/src/redirect.rs

@@ -0,0 +1,63 @@
+use std::future::{ready, Ready};
+
+use actix_web::body::EitherBody;
+use actix_web::dev::{self, ServiceRequest, ServiceResponse};
+use actix_web::dev::{Service, Transform};
+use actix_web::{http, Error, HttpResponse};
+use futures::future::LocalBoxFuture;
+
+pub struct CheckLogin;
+
+impl<S, B> Transform<S, ServiceRequest> for CheckLogin
+where
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S::Future: 'static,
+{
+    type Response = ServiceResponse<EitherBody<B>>;
+    type Error = Error;
+    type InitError = ();
+    type Transform = CheckLoginMiddleware<S>;
+    type Future = Ready<Result<Self::Transform, Self::InitError>>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        ready(Ok(CheckLoginMiddleware { service }))
+    }
+}
+pub struct CheckLoginMiddleware<S> {
+    service: S,
+}
+
+impl<S, B> Service<ServiceRequest> for CheckLoginMiddleware<S>
+where
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S::Future: 'static,
+{
+    type Response = ServiceResponse<EitherBody<B>>;
+    type Error = Error;
+    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
+
+    dev::forward_ready!(service);
+
+    fn call(&self, req: ServiceRequest) -> Self::Future {
+        // We only need to hook into the `start` for this middleware.
+        let is_logged_in = false; // Change this to see the change in outcome in the browser
+        let (request, payload) = req.into_parts();
+        let svc_response = self
+            .service
+            .call(ServiceRequest::from_parts(request.clone(), payload));
+
+        Box::pin(async move {
+            // Don't forward to /login if we are already on /login
+            if is_logged_in || request.path() == "/login" {
+                svc_response.await.map(ServiceResponse::map_into_left_body)
+            } else {
+                let response = HttpResponse::Found()
+                    .insert_header((http::header::LOCATION, "/login"))
+                    .finish()
+                    .map_into_right_body();
+
+                Ok(ServiceResponse::new(request, response))
+            }
+        })
+    }
+}

middleware/middleware/src/simple.rs

@@ -0,0 +1,63 @@
+use std::future::{ready, Ready};
+
+use actix_web::{
+    dev::{self, Service, ServiceRequest, ServiceResponse, Transform},
+    Error,
+};
+use futures::future::LocalBoxFuture;
+
+// There are two steps in middleware processing.
+// 1. Middleware initialization, middleware factory gets called with
+//    next service in chain as parameter.
+// 2. Middleware's call method gets called with normal request.
+pub struct SayHi;
+
+// Middleware factory is `Transform` trait from actix-service crate
+// `S` - type of the next service
+// `B` - type of response's body
+impl<S, B> Transform<S, ServiceRequest> for SayHi
+where
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S::Future: 'static,
+    B: 'static,
+{
+    type Response = ServiceResponse<B>;
+    type Error = Error;
+    type InitError = ();
+    type Transform = SayHiMiddleware<S>;
+    type Future = Ready<Result<Self::Transform, Self::InitError>>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        ready(Ok(SayHiMiddleware { service }))
+    }
+}
+
+pub struct SayHiMiddleware<S> {
+    service: S,
+}
+
+impl<S, B> Service<ServiceRequest> for SayHiMiddleware<S>
+where
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S::Future: 'static,
+    B: 'static,
+{
+    type Response = ServiceResponse<B>;
+    type Error = Error;
+    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
+
+    dev::forward_ready!(service);
+
+    fn call(&self, req: ServiceRequest) -> Self::Future {
+        println!("Hi from start. You requested: {}", req.path());
+
+        let fut = self.service.call(req);
+
+        Box::pin(async move {
+            let res = fut.await?;
+
+            println!("Hi from response");
+            Ok(res)
+        })
+    }
+}