middleware example

middleware/README.md

@@ -0,0 +1,11 @@
+## Middleware example
+
+```bash
+cd form
+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.
+

middleware/src/main.rs

@@ -3,6 +3,9 @@ extern crate actix_web;
 
 use actix_web::{server, App};
 
+#[allow(dead_code)]
+mod redirect;
+#[allow(dead_code)]
 mod simple;
 
 fn main() {
@@ -11,8 +14,14 @@ fn main() {
     let _addr = server::new(|| {
         App::new()
             .middleware(simple::SayHi)
-            .resource("/index.html", |r| r.f(|_| "Hello, middleware!"))
+            // .middleware(redirect::CheckLogin)
-    }).bind("0.0.0.0:8080")
+            .resource("/login", |r| {
+                r.f(|_| "You are on /login. Go to src/redirect.rs to change this behavior.")
+            })
+            .resource("/", |r| {
+                r.f(|_| "Hello, middleware! Check the console where the server is run.")
+            })
+    }).bind("127.0.0.1:8080")
         .unwrap()
         .start();
 

middleware/src/redirect.rs

@@ -0,0 +1,28 @@
+extern crate actix_web;
+
+use actix_web::middleware::{Middleware, Started};
+use actix_web::{http, HttpRequest, HttpResponse, Result};
+
+pub struct CheckLogin;
+
+impl<S> Middleware<S> for CheckLogin {
+    // We only need to hook into the `start` for this middleware.
+    fn start(&self, req: &mut HttpRequest<S>) -> Result<Started> {
+        let is_logged_in = false; // Change this to see the change in outcome in the browser
+
+        if is_logged_in {
+            return Ok(Started::Done);
+        }
+
+        // Don't forward to /login if we are already on /login
+        if req.path() == "/login" {
+            return Ok(Started::Done);
+        }
+
+        Ok(Started::Response(
+            HttpResponse::Found()
+                .header(http::header::LOCATION, "/login")
+                .finish(),
+        ))
+    }
+}

middleware/src/simple.rs

@@ -1,13 +1,29 @@
 extern crate actix_web;
 
-use actix_web::middleware::{Middleware, Started};
+use actix_web::middleware::{Finished, Middleware, Response, Started};
-use actix_web::{HttpRequest, Result};
+use actix_web::{HttpRequest, HttpResponse, Result};
 
+// Middleware can get called at three stages during the request/response handling. Below is a
+// struct that implements all three of them.
 pub struct SayHi;
 
 impl<S> Middleware<S> for SayHi {
-    fn start(&self, _req: &mut HttpRequest<S>) -> Result<Started> {
+    fn start(&self, req: &mut HttpRequest<S>) -> Result<Started> {
-        println!("Hi");
+        println!("Hi from start. You requested: {}", req.path());
         Ok(Started::Done)
     }
+
+    fn response(
+        &self,
+        _req: &mut HttpRequest<S>,
+        resp: HttpResponse,
+    ) -> Result<Response> {
+        println!("Hi from response");
+        Ok(Response::Done(resp))
+    }
+
+    fn finish(&self, _req: &mut HttpRequest<S>, _resp: &HttpResponse) -> Finished {
+        println!("Hi from finish");
+        Finished::Done
+    }
 }