redis: update backend trait

examples/examples/axum.rs

@@ -10,16 +10,16 @@ use hitbox_backend::{
     serializer::{JsonSerializer, Serializer},
     BackendError, BackendResult, CacheBackend, CacheableResponse, CachedValue, DeleteStatus,
 };
-use hitbox_redis::RedisBackend;
+//use hitbox_redis::RedisBackend;
 use hitbox_tower::Cache;
 use http::StatusCode;
 use lazy_static::lazy_static;
 use stretto::AsyncCache;
 use tower::ServiceBuilder;
 
-lazy_static! {
-    static ref BACKEND: Arc<RedisBackend> = Arc::new(RedisBackend::new().unwrap());
-}
+//lazy_static! {
+//    static ref BACKEND: Arc<RedisBackend> = Arc::new(RedisBackend::new().unwrap());
+//}
 
 #[derive(Clone)]
 struct InMemoryBackend {
@@ -105,8 +105,13 @@ async fn main() {
         .filter_level(log::LevelFilter::Debug)
         .init();
 
-    let backend = RedisBackend::new().unwrap();
+    //let backend = RedisBackend::new().unwrap();
     let inmemory = InMemoryBackend::new();
+    let redis = hitbox_redis::fred::Builder::standalone()
+        .with_serializer::<axum::body::Bytes>()
+        .build()
+        .unwrap();
+
     // build our application with a single route
     let app = Router::new()
         .route("/greet/:name/", get(handler_result))
@@ -117,8 +122,8 @@ async fn main() {
         )
         .layer(
             ServiceBuilder::new()
-                .layer(Cache::builder().backend(inmemory).build())
-                .layer(Cache::builder().backend(backend).build()),
+                //.layer(Cache::builder().backend(inmemory).build())
+                .layer(Cache::new(redis)),
         );
 
     // run it with hyper on localhost:3000

hitbox-redis/src/fred/backend.rs

@@ -8,6 +8,7 @@ use std::marker::PhantomData;
 use fred::clients::RedisClient;
 use fred::interfaces::{ClientLike, KeysInterface};
 use fred::types::{Expiration, FromRedis, RedisKey, RedisValue};
+use serde::Serialize;
 
 use async_trait::async_trait;
 use hitbox_backend::{
@@ -79,16 +80,16 @@ where
     async fn set<T>(
         &self,
         key: String,
-        value: CachedValue<T::Cached>,
+        value: &CachedValue<T::Cached>,
         ttl: Option<u32>,
     ) -> BackendResult<()>
     where
         T: CacheableResponse + Send,
-        <T as CacheableResponse>::Cached: serde::Serialize + Send,
+        <T as CacheableResponse>::Cached: Serialize + Send + Sync,
     {
         tracing::debug!("RedisBackend::set::{}", &key);
         let key = RedisKey::from(key);
-        let ser_value = S::serialize(&value).map_err(BackendError::from)?;
+        let ser_value = S::serialize(value).map_err(BackendError::from)?;
         self.execute(|client| async move {
             let expire = ttl.map(|ttl| Expiration::EX(ttl as i64));
             client