Merge pull request #15 from EleisonC/Add-redis

Implement Redis

auth-service/Cargo.toml

@@ -23,6 +23,7 @@ url = "2"
 rand = "0.8.5"
 sqlx = { version = "0.7", features = [ "runtime-tokio-rustls", "postgres", "migrate"] }
 argon2 = { version = "0.5.3", features = ["std"] }
+redis = { version = "0.25.2", features = ["tokio-comp"] }
 
 [dev-dependencies]
 fake = "=2.3.0"

auth-service/Dockerfile

@@ -25,4 +25,5 @@ FROM debian:buster-slim AS runtime
 WORKDIR /app
 COPY --from=builder /app/target/release/auth-service /usr/local/bin
 COPY --from=builder /app/assets /app/assets
+ENV REDIS_HOST_NAME=redis
 ENTRYPOINT ["/usr/local/bin/auth-service"]

auth-service/src/lib.rs

@@ -6,6 +6,7 @@ use axum::{
     http::{Method, StatusCode},
     Json
 };
+use redis::{Client, RedisResult};
 use sqlx::{postgres::PgPoolOptions, PgPool};
 use tower_http::{services::ServeDir, cors::CorsLayer};
 use app_state::AppState;
@@ -97,3 +98,8 @@ impl Application {
 pub async fn get_postgres_pool(url: &str) -> Result<PgPool, sqlx::Error> {
     PgPoolOptions::new().max_connections(5).connect(url).await
 }
+
+pub fn get_redis_client(redis_hostname: String) -> RedisResult<Client> {
+    let redis_url = format!("redis://{}/", redis_hostname);
+    redis::Client::open(redis_url)
+}

auth-service/src/main.rs

@@ -2,15 +2,16 @@ use std::sync::Arc;
 use sqlx::PgPool;
 use tokio::sync::RwLock;
 
-use auth_service::{app_state::AppState, get_postgres_pool, services, utils::constants::{prod, DATABASE_URL}, Application};
+use auth_service::{app_state::AppState, get_postgres_pool, get_redis_client, services, utils::constants::{prod, DATABASE_URL, REDIS_HOST_NAME}, Application};
 
 #[tokio::main]
 async fn main() {
     let pg_pool = configure_postgresql().await;
+    let redis_client = Arc::new(RwLock::new(configure_redis()));
 
     let user_store = Arc::new(RwLock::new(services::PostgresUserStore::new(pg_pool)));
-    let banned_token_store = Arc::new(RwLock::new(services::HashsetBannedTokenStore::default()));
-    let two_fa_code_store = Arc::new(RwLock::new(services::HashmapTwoFACodeStore::default()));
+    let banned_token_store = Arc::new(RwLock::new(services::RedisBannedTokenStore::new(redis_client.clone())));
+    let two_fa_code_store = Arc::new(RwLock::new(services::RedisTwoFACodeStore::new(redis_client)));
     let email_client = Arc::new(RwLock::new(services::MockEmailClient::default()));
 
     let app_state = AppState::new(
@@ -33,3 +34,10 @@ async fn configure_postgresql() -> PgPool {
         .expect("Failed to run migrations");
     pg_pool
 }
+
+fn configure_redis() -> redis::Connection {
+    get_redis_client(REDIS_HOST_NAME.to_owned())
+        .expect("Failed to get Redis client")
+        .get_connection()
+        .expect("Failed to get Redis client")
+}

auth-service/src/services/data_stores/mod.rs

@@ -3,10 +3,14 @@ pub mod hashset_banned_token;
 pub mod hashmap_two_fa_code_store;
 pub mod mock_email_client;
 pub mod postgres_user_store;
+pub mod redis_banned_token_store;
+pub mod redis_two_fa_code_store;
 
 
 pub use hashmap_user_store::*;
 pub use hashset_banned_token::*;
 pub use hashmap_two_fa_code_store::*;
 pub use mock_email_client::*;
-pub use postgres_user_store::*;
+pub use postgres_user_store::*;
+pub use redis_banned_token_store::*;
+pub use redis_two_fa_code_store::*;

auth-service/src/services/data_stores/redis_banned_token_store.rs

@@ -0,0 +1,55 @@
+use std::sync::Arc;
+
+use redis::{Commands, Connection};
+use tokio::sync::RwLock;
+
+use crate::{
+    domain::data_stores::{
+        BannedTokenStore, BannedTokenStoreError},
+        utils::auth::TOKEN_TTL_SECONDS,
+};
+
+pub struct RedisBannedTokenStore {
+    conn: Arc<RwLock<Connection>>
+}
+
+impl RedisBannedTokenStore {
+    pub fn new(conn: Arc<RwLock<Connection>>) -> Self {
+        Self{ conn }
+    }
+}
+
+#[async_trait::async_trait]
+impl BannedTokenStore for RedisBannedTokenStore {
+    async fn store_banned_token(&mut self, token: String) -> Result<(), BannedTokenStoreError> {
+        let redis_token_key = get_key(&token);
+        let mut store_conn = self.conn.write().await;
+
+        let ttl = TOKEN_TTL_SECONDS as u64;
+        let result = store_conn.set_ex::<String, bool, ()>(redis_token_key, true, ttl);
+
+        match result {
+            Ok(_) => Ok(()),
+            Err(_) => Err(BannedTokenStoreError::UnexpectedError)
+        }
+    }
+
+    async fn check_banned_token(&self, token: String) -> Result<String, BannedTokenStoreError> {
+        let redis_token_key = get_key(&token);
+        let mut store_conn = self.conn.write().await;
+
+        let result = store_conn.exists(redis_token_key);
+
+        match result {
+            Ok(true) => Ok(format!("Token {} is banned", token)),
+            Ok(false) => Err(BannedTokenStoreError::TokenNotFound),
+            Err(_) => Err(BannedTokenStoreError::UnexpectedError)
+        }
+    }
+}
+
+const BANNED_TOKEN_KEY_PREFIX: &str = "banned_token:";
+
+fn get_key(token: &str) -> String {
+    return format!("{}{}", BANNED_TOKEN_KEY_PREFIX, token);
+}

auth-service/src/services/data_stores/redis_two_fa_code_store.rs

@@ -0,0 +1,81 @@
+use std::sync::Arc;
+
+use redis::{Commands, Connection};
+use serde::{Deserialize, Serialize};
+use tokio::sync::RwLock;
+
+use crate::domain::{
+    data_stores::{ TwoFACodeStore, TwoFACodeStoreError}, 
+    Email, LoginAttemptId, TwoFACode,
+};
+
+pub struct RedisTwoFACodeStore {
+    conn: Arc<RwLock<Connection>>
+}
+
+impl RedisTwoFACodeStore {
+    pub fn new(conn: Arc<RwLock<Connection>>) -> Self {
+        Self{ conn }
+    }
+}
+
+#[async_trait::async_trait]
+impl TwoFACodeStore for RedisTwoFACodeStore {
+    async fn add_code(&mut self, 
+        email: Email,
+        login_attempt_id: LoginAttemptId,
+        code: TwoFACode
+    ) -> Result<(), TwoFACodeStoreError> {
+        let mut conn = self.conn.write().await;
+        let key = get_key(&email);
+
+        let two_fa_tuple = TwoFATuple(login_attempt_id.as_ref().to_owned(), code.as_ref().to_owned());
+
+        let serialized_data = serde_json::to_string(&two_fa_tuple).map_err(|_| TwoFACodeStoreError::UnexpectedError)?;
+
+        let _:() = conn
+            .set_ex(&key, serialized_data, TEN_MINUTES_IN_SECONDS)
+            .map_err(|_| TwoFACodeStoreError::UnexpectedError)?;
+
+        Ok(())
+    }
+
+    async fn remove_code(&mut self, email: &Email) -> Result<(), TwoFACodeStoreError> {
+        let mut conn = self.conn.write().await;
+        let key = get_key(email);
+
+        let _:() = conn
+           .del(&key)
+           .map_err(|_| TwoFACodeStoreError::UnexpectedError)?;
+
+        Ok(())
+    }
+
+    async fn get_code(
+        &self,
+        email: &Email,
+    ) -> Result<(LoginAttemptId, TwoFACode), TwoFACodeStoreError> {
+        let mut conn = self.conn.write().await;
+        let key = get_key(email);
+
+        match conn.get::<_, String>(&key) {
+            Ok(data) => {
+                let two_fa_tuple: TwoFATuple = serde_json::from_str(&data)
+                    .map_err(|_| TwoFACodeStoreError::UnexpectedError)?;
+
+                Ok((LoginAttemptId::parse(two_fa_tuple.0).unwrap(), TwoFACode::parse(two_fa_tuple.1).unwrap()))
+            },
+            Err(_) => Err(TwoFACodeStoreError::LoginAttemptIdNotFound)
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+struct TwoFATuple(pub String, pub String);
+
+const TEN_MINUTES_IN_SECONDS: u64 = 600;
+const TWO_FA_CODE_PREFIX: &str = "two_fa_code:";
+
+fn get_key(email: &Email) -> String {
+    format!("{}{}", TWO_FA_CODE_PREFIX, email.as_ref())
+}

auth-service/src/utils/constants.rs

@@ -5,6 +5,7 @@ use std::env as std_env;
 lazy_static! {
     pub static ref JWT_SECRET: String = set_token();
     pub static ref DATABASE_URL: String = set_database_url();
+    pub static ref REDIS_HOST_NAME: String = set_redis_host();
 }
 
 fn set_token() -> String {
@@ -31,12 +32,19 @@ fn set_database_url() -> String {
     database_url
 }
 
+fn set_redis_host() -> String {
+    dotenv().ok();
+    std_env::var(env::REDIS_HOST_NAME_ENV_VAR)
+    .unwrap_or(DEFAULT_REDIS_HOSTNAME.to_owned())
+}
 pub mod env {
     pub const JWT_SECRET_ENV_VAR: &str = "JWT_SECRET";
     pub const DATABASE_URL_ENV_VAR: &str = "DATABASE_URL";
+    pub const REDIS_HOST_NAME_ENV_VAR: &str = "REDIS_HOST_NAME";
 }
 
 pub const JWT_COOKIE_NAME: &str = "jwt";
+pub const DEFAULT_REDIS_HOSTNAME: &str = "127.0.0.1";
 
 pub mod prod {
     pub const APP_ADDRESS: &str = "0.0.0.0:3000";

auth-service/tests/api/helpers.rs

@@ -1,4 +1,4 @@
-use auth_service::{app_state::AppState, get_postgres_pool, services::{self, HashmapTwoFACodeStore}, utils::constants::{test, DATABASE_URL}, Application};
+use auth_service::{app_state::AppState, get_postgres_pool, get_redis_client, services::{self, RedisTwoFACodeStore}, utils::constants::{test, DATABASE_URL, DEFAULT_REDIS_HOSTNAME}, Application};
 use sqlx::{postgres::{PgConnectOptions, PgPoolOptions}, Connection, Executor, PgConnection, PgPool};
 use uuid::Uuid;
 use std::{str::FromStr, sync::Arc};
@@ -11,18 +11,19 @@ pub struct TestApp {
     pub http_client: reqwest::Client,
     pub db_name: String,
     pub cookie_jar: Arc<Jar>,
-    pub two_fa_code_store: Arc<RwLock<HashmapTwoFACodeStore>>,
+    pub two_fa_code_store: Arc<RwLock<RedisTwoFACodeStore>>,
     clean_up_called: bool
 }
 
 impl  TestApp {
     pub async fn new() -> Self {
         let db_name = Uuid::new_v4().to_string();
         let pg_pool = configure_postgresql(&db_name).await;
+        let redis_client = Arc::new(RwLock::new(configure_redis()));
 
         let test_user_store = Arc::new(RwLock::new(services::PostgresUserStore::new(pg_pool)));
-        let test_banned_token_store = Arc::new(RwLock::new(services::HashsetBannedTokenStore::default()));
-        let two_fa_code_store = Arc::new(RwLock::new(services::HashmapTwoFACodeStore::default()));
+        let test_banned_token_store = Arc::new(RwLock::new(services::RedisBannedTokenStore::new(redis_client.clone())));
+        let two_fa_code_store = Arc::new(RwLock::new(services::RedisTwoFACodeStore::new(redis_client)));
         let email_client = Arc::new(RwLock::new(services::MockEmailClient::default()));
 
         let test_app_state = AppState::new(test_user_store, test_banned_token_store, two_fa_code_store.clone(), email_client);
@@ -205,3 +206,12 @@ async fn delete_database(db_name: &str) {
             .await
             .expect("Failed to drop the database.");
 }
+
+fn configure_redis() -> redis::Connection {
+    let redis_hostname = DEFAULT_REDIS_HOSTNAME.to_owned();
+
+    get_redis_client(redis_hostname)
+        .expect("Failed to get Redis client")
+        .get_connection()
+        .expect("Failed to get Redis connection")
+}

compose.yml

@@ -1,9 +1,9 @@
 version: "3.9"
 services:
   app-service:
-    # TODO: change "letsgetrusty" to your Docker Hub username
     image: redwallet212/app-service # specify name of image on Docker Hub
     restart: "always" # automatically restart container when server crashes
+    container_name: app-service
     environment: # set up environment variables
       AUTH_SERVICE_IP: ${AUTH_SERVICE_IP} 
     ports:
@@ -12,7 +12,6 @@ services:
       auth-service:
         condition: service_started
   auth-service:
-    # TODO: change "letsgetrusty" to your Docker Hub username
     image: redwallet212/auth-service
     restart: always # automatically restart container when server crashes
     container_name: auth-service
@@ -23,6 +22,7 @@ services:
       - "3000:3000" # expose port 3000 so that applications outside the container can connect to it 
     depends_on:
       - db
+      - redis
   db:
     image: postgres:15.2-alpine
     restart: always
@@ -33,6 +33,12 @@ services:
       - "5432:5432"
     volumes:
       - db_data:/var/lib/postgresql/data
+  redis:
+    image: redis:7.0-alpine
+    restart: always
+    container_name: redis
+    ports:
+      - "6379:6379" 
 
 volumes:
   db_data: