chore: rename middleware dirs

middleware/request-extensions/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "middleware-request-extensions"
+version = "1.0.0"
+publish.workspace = true
+edition.workspace = true
+
+[dependencies]
+actix-web.workspace = true
+log.workspace = true
+env_logger.workspace = true

middleware/request-extensions/README.md

@@ -0,0 +1,17 @@
+# Middleware: Add/Retrieve Request-Local Data
+
+This example showcases a middleware that adds and retrieves request-local data. See also the [middleware guide](https://actix.rs/docs/middleware).
+
+## Usage
+
+```sh
+cd middleware/request-extensions
+cargo run
+```
+
+Look in `src/add_msg.rs` to see how it works.
+
+## Routes
+
+- [GET /on](http://localhost:8080/on) - `200 OK` with "hello from middleware" body and console log showing the request passed through the middleware
+- [GET /off](http://localhost:8080/off) - `500 Internal Server Error` with "no message found" body and console log showing the request passed through the middleware

middleware/request-extensions/src/add_msg.rs

@@ -0,0 +1,76 @@
+use std::{
+    future::{ready, Ready},
+    task::{Context, Poll},
+};
+
+use actix_web::{
+    dev::{Service, ServiceRequest, ServiceResponse, Transform},
+    Error, HttpMessage,
+};
+
+#[derive(Debug, Clone)]
+pub struct Msg(pub String);
+
+#[doc(hidden)]
+pub struct AddMsgService<S> {
+    service: S,
+    enabled: bool,
+}
+
+impl<S, B> Service<ServiceRequest> for AddMsgService<S>
+where
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = actix_web::Error>,
+{
+    type Response = ServiceResponse<B>;
+    type Error = Error;
+    type Future = S::Future;
+
+    fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.service.poll_ready(ctx)
+    }
+
+    fn call(&self, req: ServiceRequest) -> Self::Future {
+        log::info!("request is passing through the AddMsg middleware");
+
+        if self.enabled {
+            // insert data into extensions if enabled
+            req.extensions_mut()
+                .insert(Msg("Hello from Middleware!".to_owned()));
+        }
+
+        self.service.call(req)
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct AddMsg {
+    enabled: bool,
+}
+
+impl AddMsg {
+    pub fn enabled() -> Self {
+        Self { enabled: true }
+    }
+
+    pub fn disabled() -> Self {
+        Self { enabled: false }
+    }
+}
+
+impl<S, B> Transform<S, ServiceRequest> for AddMsg
+where
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = actix_web::Error>,
+{
+    type Response = ServiceResponse<B>;
+    type Error = Error;
+    type Future = Ready<Result<Self::Transform, Self::InitError>>;
+    type Transform = AddMsgService<S>;
+    type InitError = ();
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        ready(Ok(AddMsgService {
+            service,
+            enabled: self.enabled,
+        }))
+    }
+}

middleware/request-extensions/src/main.rs

@@ -0,0 +1,37 @@
+use std::io;
+
+use actix_web::{
+    middleware,
+    web::{self, ReqData},
+    App, HttpResponse, HttpServer,
+};
+
+mod add_msg;
+use self::add_msg::{AddMsg, Msg};
+
+// wrap route in our middleware factory
+async fn index(msg: Option<ReqData<Msg>>) -> HttpResponse {
+    if let Some(msg_data) = msg {
+        let Msg(message) = msg_data.into_inner();
+        HttpResponse::Ok().body(message)
+    } else {
+        HttpResponse::InternalServerError().body("No message found.")
+    }
+}
+
+#[actix_web::main]
+async fn main() -> io::Result<()> {
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
+
+    log::info!("starting HTTP server at http://localhost:8080");
+
+    HttpServer::new(|| {
+        App::new()
+            .wrap(middleware::Logger::default())
+            .service(web::resource("/on").wrap(AddMsg::enabled()).to(index))
+            .service(web::resource("/off").wrap(AddMsg::disabled()).to(index))
+    })
+    .bind(("127.0.0.1", 8080))?
+    .run()
+    .await
+}