Middleware for caching succesful GET responses with Redis automatically

cache/redis-cache-middleware/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+authors = ["Jatutep Bunupuradah <[email protected]>"]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+actix-web = "*"
+actix-rt = "*"
+env_logger = "*"
+actix-web-lab = "*"
+redis = { version = "*", features = ["tls-native-tls"] }

cache/redis-cache-middleware/README.md

@@ -0,0 +1,34 @@
+# Redis Cache Middleware
+
+This project demonstrates how to implement Redis cache middleware to handle cache responses synchronously.
+The application should be able to function properly even if Redis is not running; however, the caching process will be disabled in such cases.
+
+
+## Setting up
+Configure the environment variable `REDIS_HOST`, or if not set, the default host `redis://localhost:4379` will be used. TLS is supported using the `rediss://` protocol.
+Run the server using `cargo run`.
+
+## Endpoints
+
+### `GET /fibonacci/{number}`
+
+To test the demo, send a GET request to `/fibonacci/{number}`, where {number} is a positive integer of type u64.
+
+## Request Directives
+
+- `Cache-Control: no-cache` will return the most up-to-date response while still caching it. This will always yield a `miss` cache status.
+- `Cache-Control: no-store` will prevent caching, ensuring you always receive the latest response.
+
+## Verify Redis Contents
+
+When making the first GET request to `/fibonacci/47`, it may take around 8 seconds to respond.
+If Redis is running and the connection is established, subsequent requests should return the cached result immediately, a `hit` cache status will be returned, but with content type `application/json`.
+
+## Known issues
+
+- Connecting to a remote Redis server might introduce significant overhead and could lead to prolonged connection times or even failure to reach the remote server.
+
+## Further implementations
+
+- Implement asynchronous insertion of cache responses.
+- Explore using an in-memory datastore within the application process to reduce reliance on Redis.

cache/redis-cache-middleware/src/main.rs

@@ -0,0 +1,189 @@
+use actix_web::{
+ body::{self, MessageBody},
+ dev::{ServiceRequest, ServiceResponse},
+ http::{
+ header::{CacheDirective, HeaderValue, CACHE_CONTROL, CACHE_STATUS, CONTENT_TYPE},
+ Method, StatusCode,
+ },
+ middleware, web, App, Error, HttpResponse, HttpServer, Responder,
+};
+use actix_web_lab::middleware::{from_fn, Next};
+use redis::{Client as RedisClient, Commands, RedisError};
+use std::env;
+
+fn fib_recursive(n: u64) -> u64 {
+ if n <= 1 {
+ return n;
+ }
+ let a = n - 1;
+ let b = n - 2;
+ println!("{a} + {b}");
+ fib_recursive(a) + fib_recursive(b)
+}
+
+/* fn fib_iterative(n: u64) -> u64 {
+ let mut a = 0;
+ let mut b = 1;
+ let mut c;
+
+ if n == 0 {
+ return a;
+ }
+
+ for i in 2..=n {
+ print!("{i} ");
+ c = a + b;
+ a = b;
+ b = c;
+ }
+ b
+} */
+
+async fn an_expensive_function(n: web::Path<u64>) -> impl Responder {
+ let result = fib_recursive(n.to_owned());
+ HttpResponse::Ok().body(result.to_string())
+}
+
+#[actix_rt::main]
+async fn main() -> std::result::Result<(), std::io::Error> {
+ env_logger::init();
+
+ let redis_client =
+ redis::Client::open(env::var("REDIS_HOST").unwrap_or("redis://localhost:6379".to_owned()))
+ .unwrap();
+
+ let listen_port: String = env::var("LISTEN_PORT").unwrap_or(8080.to_string());
+ let listen_address: String = ["0.0.0.0", &listen_port].join(":");
+
+ println!("Server is listening at {}...", listen_address);
+ HttpServer::new(move || {
+ App::new()
+ .wrap(from_fn(cache_middleware))
+ .app_data(redis_client.to_owned())
+ .service(web::resource("/fibonacci/{n}").route(web::get().to(an_expensive_function)))
+ .wrap(middleware::Logger::default())
+ })
+ .bind(listen_address)?
+ .run()
+ .await?;
+
+ Ok(())
+}
+
+async fn cache_middleware(
+ req: ServiceRequest,
+ next: Next<impl MessageBody>,
+) -> Result<ServiceResponse<impl MessageBody>, Error> {
+ // Defining cache key based on requst path and query string
+ let key = format!("{}?{}", req.path(), req.query_string());
+ println!("cache key: {key:?}");
+
+ // Get "Cache-Control" request header and get cache directive
+ let headers = req.headers().to_owned();
+ let cache_directive = match headers.get(CACHE_CONTROL) {
+ Some(cache_control_header) => cache_control_header.to_str().unwrap_or(""),
+ None => "",
+ };
+
+ // If cache directive is not "no-cache" and not "no-store"
+ if cache_directive != CacheDirective::NoCache.to_string()
+ && cache_directive != CacheDirective::NoStore.to_string()
+ {
+ // Initialize Redis Client from App Data
+ let redis_client = req.app_data::<RedisClient>();
+ // This should always be Some, so let's unwrap
+ let mut redis_conn = redis_client.unwrap().get_connection();
+ let redis_ok = redis_conn.is_ok();
+
+ // If Redis connection succeeded and request method is GET
+ if redis_ok && req.method() == Method::GET {
+ // Unwrap the connection
+ let redis_conn = redis_conn.as_mut().unwrap();
+
+ // Try to get the cached response by defined key
+ let cached_response: Result<Vec<u8>, RedisError> = redis_conn.get(key.to_owned());
+ if let Err(e) = cached_response {
+ // If cache cannot be deserialized
+ println!("cache get error: {}", e);
+ } else if cached_response.as_ref().unwrap().is_empty() {
+ // If cache body is empty
+ println!("cache not found");
+ } else {
+ // If cache is found
+ println!("cache found");
+
+ // Prepare response body
+ let res = HttpResponse::new(StatusCode::OK).set_body(cached_response.unwrap());
+ let mut res = ServiceResponse::new(req.request().to_owned(), res);
+
+ // Define content-type and headers here
+ res.headers_mut()
+ .append(CONTENT_TYPE, HeaderValue::from_static("application/json"));
+ res.headers_mut()
+ .append(CACHE_CONTROL, HeaderValue::from_static("max-age=86400"));
+ res.headers_mut()
+ .append(CACHE_STATUS, HeaderValue::from_static("hit"));
+
+ return Ok(res);
+ }
+ }
+ }
+
+ // If Redis connection fails or cache could not be found
+ // Call the next service
+ let res = next.call(req).await?;
+
+ // deconstruct response into parts
+ let (req, res) = res.into_parts();
+ let (res, body) = res.into_parts();
+
+ // Convert body to Bytes
+ let body = body::to_bytes(body).await.ok().unwrap();
+ // Use bytes directly for caching instead of converting to a String
+ let res_body_enc = body.to_vec();
+
+ // Prepare response body
+ let res = res.set_body(res_body_enc.to_owned());
+ let mut res = ServiceResponse::new(req.to_owned(), res);
+
+ // If a GET request succeeded and cache directive is not "no-store"
+ if req.method() == Method::GET
+ && StatusCode::is_success(&res.status())
+ && cache_directive != CacheDirective::NoStore.to_string()
+ {
+ // Define response headers here
+ res.headers_mut()
+ .append(CACHE_CONTROL, HeaderValue::from_static("max-age=86400"));
+ res.headers_mut()
+ .append(CACHE_STATUS, HeaderValue::from_static("miss"));
+
+ // Initialize Redis Client from App Data
+ let redis_client = req.app_data::<RedisClient>();
+ // This should always be Some, so let's unwrap
+ let redis_conn = redis_client.unwrap().get_connection();
+ let redis_ok = redis_conn.is_ok();
+
+ // If Redis connection succeeded
+ if redis_ok {
+ // Try to insert the response body into Redis
+ let mut redis_conn = redis_conn.unwrap();
+ let insert = redis::Cmd::set(key, res_body_enc);
+ let insert = insert.query::<String>(&mut redis_conn);
+
+ if let Err(e) = insert {
+ // If cache insertion failed
+ println!("cache insert error: {}", e);
+ } else {
+ // This should print "cache insert success: OK"
+ println!("cache insert success: {}", insert.unwrap());
+ }
+ } else if let Err(e) = redis_conn {
+ // If Redis connection failed
+ println!("RedisError: {}", e);
+ }
+ } else {
+ // If the request method is not "GET" or the operation failed or cache directive is "no-store"
+ println!("not inserting cache");
+ }
+ Ok(res)
+}