Replace redis errors with a generic cache error

Author: MaeIsBad

src/auth0/cache/inmemory.rs

@@ -2,25 +2,26 @@ use dashmap::DashMap;
 
 use crate::auth0::cache;
 use crate::auth0::cache::Cache;
-use crate::auth0::errors::Auth0Error;
 use crate::auth0::token::Token;
 
+use super::CacheError;
+
 #[derive(Default, Clone, Debug)]
 pub struct InMemoryCache {
     key_value: DashMap<String, Token>,
 }
 
 #[async_trait::async_trait]
 impl Cache for InMemoryCache {
-    async fn get_token(&self, client_id: &str, aud: &str) -> Result<Option<Token>, Auth0Error> {
+    async fn get_token(&self, client_id: &str, aud: &str) -> Result<Option<Token>, CacheError> {
         let token = self
             .key_value
             .get(&cache::token_key(client_id, aud))
             .map(|v| v.to_owned());
         Ok(token)
     }
 
-    async fn put_token(&self, client_id: &str, aud: &str, token: &Token) -> Result<(), Auth0Error> {
+    async fn put_token(&self, client_id: &str, aud: &str, token: &Token) -> Result<(), CacheError> {
         let key: String = cache::token_key(client_id, aud);
         let _ = self.key_value.insert(key, token.clone());
         Ok(())

src/auth0/cache/mod.rs

@@ -1,7 +1,7 @@
 pub use inmemory::InMemoryCache;
 pub use redis_impl::RedisCache;
+use std::error::Error;
 
-use crate::auth0::errors::Auth0Error;
 use crate::auth0::Token;
 
 mod crypto;
@@ -13,11 +13,15 @@ const TOKEN_PREFIX: &str = "auth0rs_tokens";
 // The version of the token for backwards incompatible changes
 const TOKEN_VERSION: &str = "2";
 
+#[derive(thiserror::Error, Debug)]
+#[error(transparent)]
+pub struct CacheError(pub Box<dyn Error>);
+
 #[async_trait::async_trait]
 pub trait Cache: Send + Sync + std::fmt::Debug {
-    async fn get_token(&self, client_id: &str, aud: &str) -> Result<Option<Token>, Auth0Error>;
+    async fn get_token(&self, client_id: &str, aud: &str) -> Result<Option<Token>, CacheError>;
 
-    async fn put_token(&self, client_id: &str, aud: &str, token: &Token) -> Result<(), Auth0Error>;
+    async fn put_token(&self, client_id: &str, aud: &str, token: &Token) -> Result<(), CacheError>;
 }
 
 pub(in crate::auth0::cache) fn token_key(caller: &str, audience: &str) -> String {

src/auth0/cache/redis_impl.rs

@@ -1,9 +1,25 @@
 use redis::AsyncCommands;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 
+use super::CacheError;
 use crate::auth0::cache::{self, crypto, Cache};
 use crate::auth0::token::Token;
-use crate::auth0::Auth0Error;
+
+#[derive(Debug, thiserror::Error)]
+pub enum RedisCacheError {
+    #[error(transparent)]
+    Serde(#[from] serde_json::Error),
+    #[error("redis error: {0}")]
+    Redis(#[from] redis::RedisError),
+    #[error("couldn't decrypt stored token: {0}")]
+    Crypto(#[from] chacha20poly1305::Error),
+}
+
+impl From<RedisCacheError> for super::CacheError {
+    fn from(val: RedisCacheError) -> Self {
+        CacheError(Box::new(val))
+    }
+}
 
 #[derive(Clone, Debug)]
 pub struct RedisCache {
@@ -13,7 +29,7 @@ pub struct RedisCache {
 
 impl RedisCache {
     /// Redis connection string(eg. `"redis://{host}:{port}?{ParamKey1}={ParamKey2}"`)
-    pub async fn new(redis_connection_url: String, token_encryption_key: String) -> Result<Self, Auth0Error> {
+    pub async fn new(redis_connection_url: String, token_encryption_key: String) -> Result<Self, RedisCacheError> {
         let client: redis::Client = redis::Client::open(redis_connection_url)?;
         // Ensure connection is fine. Should fail otherwise
         let _ = client.get_multiplexed_async_connection().await?;
@@ -24,7 +40,7 @@ impl RedisCache {
         })
     }
 
-    async fn get<T>(&self, key: &str) -> Result<Option<T>, Auth0Error>
+    async fn get<T>(&self, key: &str) -> Result<Option<T>, RedisCacheError>
     where
         for<'de> T: Deserialize<'de>,
     {
@@ -35,24 +51,30 @@ impl RedisCache {
             .await?
             .map(|value| crypto::decrypt(self.encryption_key.as_str(), value.as_slice()))
             .transpose()
+            .map_err(|_| todo!())
+    }
+
+    async fn put<T: Serialize>(&self, key: &str, lifetime_in_seconds: u64, v: T) -> Result<(), RedisCacheError> {
+        let mut connection = self.client.get_multiplexed_async_connection().await?;
+
+        let encrypted_value: Vec<u8> = crypto::encrypt(&v, self.encryption_key.as_str()).unwrap();
+        let _: () = connection.set_ex(key, encrypted_value, lifetime_in_seconds).await?;
+        Ok(())
     }
 }
 
 #[async_trait::async_trait]
 impl Cache for RedisCache {
-    async fn get_token(&self, client_id: &str, audience: &str) -> Result<Option<Token>, Auth0Error> {
+    async fn get_token(&self, client_id: &str, audience: &str) -> Result<Option<Token>, CacheError> {
         let key: &str = &cache::token_key(client_id, audience);
-        self.get(key).await
+        self.get(key).await.map_err(Into::into)
     }
 
-    async fn put_token(&self, client_id: &str, audience: &str, value_ref: &Token) -> Result<(), Auth0Error> {
+    async fn put_token(&self, client_id: &str, audience: &str, value_ref: &Token) -> Result<(), CacheError> {
         let key: &str = &cache::token_key(client_id, audience);
-
-        let mut connection = self.client.get_multiplexed_async_connection().await?;
-        let encrypted_value: Vec<u8> = crypto::encrypt(value_ref, self.encryption_key.as_str())?;
-        let expiration = value_ref.lifetime_in_seconds();
-        let _: () = connection.set_ex(key, encrypted_value, expiration).await?;
-        Ok(())
+        self.put(key, value_ref.lifetime_in_seconds(), value_ref)
+            .await
+            .map_err(Into::into)
     }
 }
 

src/auth0/errors.rs

@@ -1,5 +1,7 @@
 use thiserror::Error;
 
+use super::cache;
+
 #[derive(Debug, Error)]
 pub enum Auth0Error {
     #[error(transparent)]
@@ -12,8 +14,8 @@ pub enum Auth0Error {
     JwtFetchDeserializationError(String, reqwest::Error),
     #[error("failed to fetch jwt from {0}. Status code: {0}; error: {1}")]
     JwksHttpError(String, reqwest::Error),
-    #[error("redis error: {0}")]
-    RedisError(#[from] redis::RedisError),
+    #[error("cache error: {0}")]
+    CacheError(#[from] cache::CacheError),
     #[error(transparent)]
     CryptoError(#[from] chacha20poly1305::Error),
 }

src/auth0/mod.rs

@@ -10,7 +10,7 @@ mod refresh;
 mod token;
 mod util;
 
-use cache::Cache;
+use cache::{Cache, CacheError};
 pub use client::Auth0Client;
 pub use config::{CacheType, Config};
 pub use errors::Auth0Error;
@@ -29,7 +29,11 @@ impl Auth0 {
         } else {
             let redis_conn = config.cache_type().redis_connection_url().to_string();
             let encryption_key = config.token_encryption_key().to_string();
-            Box::new(cache::RedisCache::new(redis_conn, encryption_key).await?)
+            Box::new(
+                cache::RedisCache::new(redis_conn, encryption_key)
+                    .await
+                    .map_err(Into::<CacheError>::into)?,
+            )
         };
 
         let client = client::Auth0Client::from_config(&config, client);