From 1665df92748a4256fc2a3b73d354e7275c992a7b Mon Sep 17 00:00:00 2001
From: Andrey Ermilov <andrerm@ya.ru>
Date: Sun, 27 Aug 2023 16:03:08 +0200
Subject: [PATCH 1/2] refactor(config): Add trait Configurable

---
 hitbox-tower/src/configurable.rs           | 29 +++++++++++
 hitbox-tower/src/configuration/endpoint.rs | 13 +++--
 hitbox-tower/src/layer.rs                  | 58 +++++++++++-----------
 hitbox-tower/src/lib.rs                    |  3 ++
 hitbox-tower/src/service.rs                | 33 ++++++------
 5 files changed, 87 insertions(+), 49 deletions(-)
 create mode 100644 hitbox-tower/src/configurable.rs

diff --git a/hitbox-tower/src/configurable.rs b/hitbox-tower/src/configurable.rs
new file mode 100644
index 0000000..a7b9f05
--- /dev/null
+++ b/hitbox-tower/src/configurable.rs
@@ -0,0 +1,29 @@
+use hitbox::policy::PolicyConfig;
+use hitbox::predicate::Predicate;
+use hitbox::Extractor;
+use hitbox_http::{CacheableHttpRequest, CacheableHttpResponse};
+
+type RequestPredicate<ReqBody> =
+    Box<dyn Predicate<Subject = CacheableHttpRequest<ReqBody>> + Send + Sync>;
+
+type ResponsePredicate<ResBody> =
+    Box<dyn Predicate<Subject = CacheableHttpResponse<ResBody>> + Send + Sync>;
+
+type RequestExtractor<ResBody> =
+    Box<dyn Extractor<Subject = CacheableHttpRequest<ResBody>> + Send + Sync>;
+
+pub trait Configurable {
+    fn request_predicates<ReqBody>(&self) -> RequestPredicate<ReqBody>
+    where
+        ReqBody: Send + 'static;
+
+    fn response_predicates<ResBody>(&self) -> ResponsePredicate<ResBody>
+    where
+        ResBody: Send + 'static;
+
+    fn extractors<ReqBody>(&self) -> RequestExtractor<ReqBody>
+    where
+        ReqBody: Send + 'static;
+
+    fn policy(&self) -> PolicyConfig;
+}
diff --git a/hitbox-tower/src/configuration/endpoint.rs b/hitbox-tower/src/configuration/endpoint.rs
index f7a3d59..dca5375 100644
--- a/hitbox-tower/src/configuration/endpoint.rs
+++ b/hitbox-tower/src/configuration/endpoint.rs
@@ -1,4 +1,5 @@
 use crate::configuration::{RequestExtractor, RequestPredicate, ResponsePredicate};
+use crate::Configurable;
 use hitbox::policy::PolicyConfig;
 use hitbox::predicate::Predicate;
 use hitbox::Extractor;
@@ -31,8 +32,10 @@ impl EndpointConfig {
             policy: Default::default(),
         }
     }
+}
 
-    pub(crate) fn request_predicates<ReqBody>(
+impl Configurable for EndpointConfig {
+    fn request_predicates<ReqBody>(
         &self,
     ) -> Box<dyn Predicate<Subject = CacheableHttpRequest<ReqBody>> + Send + Sync>
     where
@@ -54,7 +57,7 @@ impl EndpointConfig {
             })
     }
 
-    pub(crate) fn response_predicates<ResBody>(
+    fn response_predicates<ResBody>(
         &self,
     ) -> Box<dyn Predicate<Subject = CacheableHttpResponse<ResBody>> + Send + Sync>
     where
@@ -68,7 +71,7 @@ impl EndpointConfig {
             })
     }
 
-    pub(crate) fn extractors<ReqBody>(
+    fn extractors<ReqBody>(
         &self,
     ) -> Box<dyn Extractor<Subject = CacheableHttpRequest<ReqBody>> + Send + Sync>
     where
@@ -84,6 +87,10 @@ impl EndpointConfig {
                 RequestExtractor::Header { key } => Box::new(inner.header(key.to_string())),
             })
     }
+
+    fn policy(&self) -> PolicyConfig {
+        self.policy.clone()
+    }
 }
 
 impl Default for EndpointConfig {
diff --git a/hitbox-tower/src/layer.rs b/hitbox-tower/src/layer.rs
index 65d39ba..05f1fcb 100644
--- a/hitbox-tower/src/layer.rs
+++ b/hitbox-tower/src/layer.rs
@@ -15,26 +15,26 @@ use crate::service::CacheService;
 #[derive(Clone)]
 pub struct Cache<B> {
     pub backend: Arc<B>,
-    pub endpoint_config: Arc<EndpointConfig>,
+    pub configuration: Arc<EndpointConfig>,
 }
 
 impl<B> Cache<B> {
     pub fn new(backend: B) -> Cache<B> {
         Cache {
             backend: Arc::new(backend),
-            endpoint_config: Arc::new(Default::default()),
+            configuration: Arc::new(Default::default()),
         }
     }
 }
 
 impl<S, B> Layer<S> for Cache<B> {
-    type Service = CacheService<S, B>;
+    type Service = CacheService<S, B, EndpointConfig>;
 
     fn layer(&self, upstream: S) -> Self::Service {
         CacheService::new(
             upstream,
             Arc::clone(&self.backend),
-            Arc::clone(&self.endpoint_config),
+            Arc::clone(&self.configuration),
         )
     }
 }
@@ -47,7 +47,7 @@ impl Cache<StrettoBackend> {
 
 pub struct CacheBuilder<B> {
     backend: Option<B>,
-    endpoint_config: EndpointConfig,
+    configuration: EndpointConfig,
 }
 
 impl<B> CacheBuilder<B>
@@ -57,73 +57,73 @@ where
     pub fn backend<NB: CacheBackend>(self, backend: NB) -> CacheBuilder<NB> {
         CacheBuilder {
             backend: Some(backend),
-            endpoint_config: self.endpoint_config,
+            configuration: self.configuration,
         }
     }
 
     pub fn enable(self, policy: EnabledCacheConfig) -> Self {
-        let endpoint_config = EndpointConfig {
-            request_predicates: self.endpoint_config.request_predicates,
-            response_predicates: self.endpoint_config.response_predicates,
-            extractors: self.endpoint_config.extractors,
+        let configuration = EndpointConfig {
+            request_predicates: self.configuration.request_predicates,
+            response_predicates: self.configuration.response_predicates,
+            extractors: self.configuration.extractors,
             policy: PolicyConfig::Enabled(policy),
         };
         CacheBuilder {
             backend: self.backend,
-            endpoint_config,
+            configuration,
         }
     }
 
     pub fn disable(self) -> Self {
         CacheBuilder {
             backend: self.backend,
-            endpoint_config: self.endpoint_config,
+            configuration: self.configuration,
         }
     }
 
     pub fn request(self, predicates: RequestPredicateBuilder) -> Self {
-        let endpoint_config = EndpointConfig {
+        let configuration = EndpointConfig {
             request_predicates: predicates.build(),
-            response_predicates: self.endpoint_config.response_predicates,
-            extractors: self.endpoint_config.extractors,
-            policy: self.endpoint_config.policy,
+            response_predicates: self.configuration.response_predicates,
+            extractors: self.configuration.extractors,
+            policy: self.configuration.policy,
         };
         CacheBuilder {
             backend: self.backend,
-            endpoint_config,
+            configuration,
         }
     }
 
     pub fn response(self, predicates: ResponsePredicateBuilder) -> Self {
-        let endpoint_config = EndpointConfig {
-            request_predicates: self.endpoint_config.request_predicates,
+        let configuration = EndpointConfig {
+            request_predicates: self.configuration.request_predicates,
             response_predicates: predicates.build(),
-            extractors: self.endpoint_config.extractors,
-            policy: self.endpoint_config.policy,
+            extractors: self.configuration.extractors,
+            policy: self.configuration.policy,
         };
         CacheBuilder {
             backend: self.backend,
-            endpoint_config,
+            configuration,
         }
     }
 
     pub fn cache_key(self, extractors: ExtractorBuilder) -> Self {
-        let endpoint_config = EndpointConfig {
-            request_predicates: self.endpoint_config.request_predicates,
-            response_predicates: self.endpoint_config.response_predicates,
+        let configuration = EndpointConfig {
+            request_predicates: self.configuration.request_predicates,
+            response_predicates: self.configuration.response_predicates,
             extractors: extractors.build(),
-            policy: self.endpoint_config.policy,
+            policy: self.configuration.policy,
         };
         CacheBuilder {
             backend: self.backend,
-            endpoint_config,
+            configuration,
         }
     }
 
     pub fn build(self) -> Cache<B> {
         Cache {
             backend: Arc::new(self.backend.expect("Please add some cache backend")),
-            endpoint_config: Arc::new(self.endpoint_config),
+            configuration: Arc::new(self.configuration),
         }
     }
 }
@@ -132,7 +132,7 @@ impl<B> Default for CacheBuilder<B> {
     fn default() -> Self {
         Self {
             backend: None,
-            endpoint_config: Default::default(),
+            configuration: Default::default(),
         }
     }
 }
diff --git a/hitbox-tower/src/lib.rs b/hitbox-tower/src/lib.rs
index cd6503e..4ff2110 100644
--- a/hitbox-tower/src/lib.rs
+++ b/hitbox-tower/src/lib.rs
@@ -1,7 +1,10 @@
+pub mod configurable;
 pub mod configuration;
 pub mod future;
 pub mod layer;
 pub mod service;
 
+pub use crate::configuration::EndpointConfig;
 pub use ::http::{Method, StatusCode};
+pub use configurable::Configurable;
 pub use layer::Cache;
diff --git a/hitbox-tower/src/service.rs b/hitbox-tower/src/service.rs
index d93620b..c58e958 100644
--- a/hitbox-tower/src/service.rs
+++ b/hitbox-tower/src/service.rs
@@ -1,4 +1,4 @@
-use crate::configuration::EndpointConfig;
+use crate::Configurable;
 use std::{fmt::Debug, sync::Arc};
 
 use hitbox::{backend::CacheBackend, fsm::CacheFuture};
@@ -9,23 +9,23 @@ use tower::Service;
 
 use crate::future::Transformer;
 
-pub struct CacheService<S, B> {
+pub struct CacheService<S, B, C> {
     upstream: S,
     backend: Arc<B>,
-    endpoint_config: Arc<EndpointConfig>,
+    configuration: Arc<C>,
 }
 
-impl<S, B> CacheService<S, B> {
-    pub fn new(upstream: S, backend: Arc<B>, endpoint_config: Arc<EndpointConfig>) -> Self {
+impl<S, B, C> CacheService<S, B, C> {
+    pub fn new(upstream: S, backend: Arc<B>, configuration: Arc<C>) -> Self {
         CacheService {
             upstream,
             backend,
-            endpoint_config,
+            configuration,
         }
     }
 }
 
-impl<S, B> Clone for CacheService<S, B>
+impl<S, B, C> Clone for CacheService<S, B, C>
 where
     S: Clone,
     B: Clone,
@@ -33,17 +33,18 @@ where
     fn clone(&self) -> Self {
         Self {
             upstream: self.upstream.clone(),
-            backend: Arc::clone(&self.backend),
-            endpoint_config: Arc::clone(&self.endpoint_config),
+            backend: self.backend.clone(),
+            configuration: self.configuration.clone(),
         }
     }
 }
 
-impl<S, B, ReqBody, ResBody> Service<Request<ReqBody>> for CacheService<S, B>
+impl<S, B, C, ReqBody, ResBody> Service<Request<ReqBody>> for CacheService<S, B, C>
 where
     S: Service<Request<ReqBody>, Response = Response<ResBody>> + Clone + Send + 'static,
     B: CacheBackend + Clone + Send + Sync + 'static,
     S::Future: Send,
+    C: Configurable,
 
     // debug bounds
     ReqBody: Debug + HttpBody + Send + 'static,
@@ -69,18 +70,16 @@ where
     }
 
     fn call(&mut self, req: Request<ReqBody>) -> Self::Future {
-        //dbg!(&req);
-
         let transformer = Transformer::new(self.upstream.clone());
-        let config = &self.endpoint_config;
+        let configuration = &self.configuration;
         CacheFuture::new(
             self.backend.clone(),
             CacheableHttpRequest::from_request(req),
             transformer,
-            Arc::new(config.request_predicates()),
-            Arc::new(config.response_predicates()),
-            Arc::new(config.extractors()),
-            Arc::new(config.policy.clone()), //TODO: remove clone
+            Arc::new(configuration.request_predicates()),
+            Arc::new(configuration.response_predicates()),
+            Arc::new(configuration.extractors()),
+            Arc::new(configuration.policy()),
         )
     }
 }

From 07d84821303ccd0c44e2170b00d3a82637bdaf79 Mon Sep 17 00:00:00 2001
From: Andrey Ermilov <andrerm@ya.ru>
Date: Sun, 27 Aug 2023 17:56:29 +0200
Subject: [PATCH 2/2] refactor(config): layer uses generic Configurable

---
 examples/examples/axum.rs                     |  29 +++--
 hitbox-tower/src/configuration/builder.rs     |  88 ++++++++++++++
 hitbox-tower/src/configuration/endpoint.rs    |  47 +++++++-
 .../src/configuration/extractors/request.rs   |   2 +-
 hitbox-tower/src/configuration/mod.rs         |   1 +
 .../src/configuration/predicates/request.rs   |   2 +-
 .../src/configuration/predicates/response.rs  |   2 +-
 hitbox-tower/src/layer.rs                     | 107 +++++-------------
 hitbox-tower/src/service.rs                   |   5 +-
 hitbox/src/policy.rs                          |   5 +-
 10 files changed, 194 insertions(+), 94 deletions(-)
 create mode 100644 hitbox-tower/src/configuration/builder.rs

diff --git a/examples/examples/axum.rs b/examples/examples/axum.rs
index f9602f5..8db2503 100644
--- a/examples/examples/axum.rs
+++ b/examples/examples/axum.rs
@@ -6,7 +6,7 @@ use hitbox_tower::{
 };
 
 use hitbox_redis::RedisBackend;
-use hitbox_tower::Cache;
+use hitbox_tower::{Cache, EndpointConfig};
 
 async fn handler_result(Path(_name): Path<String>) -> Result<String, String> {
     //dbg!("axum::handler_result");
@@ -41,9 +41,12 @@ async fn main() {
         .finish();
     tracing::subscriber::set_global_default(subscriber).unwrap();
 
-    let backend = RedisBackend::new().unwrap();
-    let json_cache = Cache::builder()
-        .backend(backend)
+    let redis_backend = RedisBackend::new().unwrap();
+    let inmemory_backend = hitbox_stretto::StrettoBackend::builder(10)
+        .finalize()
+        .unwrap();
+
+    let json_config = EndpointConfig::builder()
         .request(
             request::method(Method::GET)
                 .query("cache", "true")
@@ -53,14 +56,22 @@ async fn main() {
         .response(response::status_code(StatusCode::OK))
         .cache_key(extractor::method().query("cache").path("/{path}*"))
         .build();
-    let backend = hitbox_stretto::StrettoBackend::builder(10)
-        .finalize()
-        .unwrap();
-    let health_check = Cache::builder()
-        .backend(backend) // FIX: it should work withod backend
+
+    let health_config = EndpointConfig::builder()
         .request(request::path("/health").method(Method::GET))
         .disable()
         .build();
+
+    let json_cache = Cache::builder()
+        .backend(redis_backend)
+        .config(json_config)
+        .build();
+
+    let health_check = Cache::builder()
+        .backend(inmemory_backend) // FIX: it should work withod backend
+        .config(health_config)
+        .build();
+
     let app = Router::new()
         .route("/greet/:name/", get(handler_result))
         .route("/", get(handler))
diff --git a/hitbox-tower/src/configuration/builder.rs b/hitbox-tower/src/configuration/builder.rs
new file mode 100644
index 0000000..ef7b887
--- /dev/null
+++ b/hitbox-tower/src/configuration/builder.rs
@@ -0,0 +1,88 @@
+use crate::configuration::{
+    ExtractorBuilder, RequestExtractor, RequestPredicate, RequestPredicateBuilder,
+    ResponsePredicate, ResponsePredicateBuilder,
+};
+use crate::EndpointConfig;
+use hitbox::policy::PolicyConfig;
+
+#[derive(Debug)]
+pub struct EndpointConfigBuilder {
+    pub request_predicates: Vec<RequestPredicate>,
+    pub response_predicates: Vec<ResponsePredicate>,
+    pub extractors: Vec<RequestExtractor>,
+    pub policy: PolicyConfig,
+}
+
+impl EndpointConfigBuilder {
+    pub fn new() -> Self {
+        Self {
+            request_predicates: Vec::new(),
+            response_predicates: Vec::new(),
+            extractors: Vec::new(),
+            policy: Default::default(),
+        }
+    }
+
+    pub fn disable(self) -> Self {
+        Self {
+            request_predicates: self.request_predicates,
+            response_predicates: self.response_predicates,
+            extractors: self.extractors,
+            policy: PolicyConfig::Disabled,
+        }
+    }
+
+    pub fn request(self, predicates: RequestPredicateBuilder) -> Self {
+        Self {
+            request_predicates: predicates.build(),
+            response_predicates: self.response_predicates,
+            extractors: self.extractors,
+            policy: self.policy,
+        }
+    }
+
+    pub fn response(self, predicates: ResponsePredicateBuilder) -> Self {
+        Self {
+            request_predicates: self.request_predicates,
+            response_predicates: predicates.build(),
+            extractors: self.extractors,
+            policy: self.policy,
+        }
+    }
+
+    pub fn cache_key(self, extractors: ExtractorBuilder) -> Self {
+        Self {
+            request_predicates: self.request_predicates,
+            response_predicates: self.response_predicates,
+            extractors: extractors.build(),
+            policy: self.policy,
+        }
+    }
+
+    pub fn build(self) -> EndpointConfig {
+        EndpointConfig {
+            request_predicates: self.request_predicates,
+            response_predicates: self.response_predicates,
+            extractors: self.extractors,
+            policy: self.policy,
+        }
+    }
+}
+
+impl Default for EndpointConfigBuilder {
+    fn default() -> Self {
+        Self {
+            request_predicates: Vec::new(),
+            response_predicates: vec![ResponsePredicate::StatusCode {
+                code: http::StatusCode::OK,
+            }],
+            extractors: vec![
+                RequestExtractor::Path {
+                    path: String::from("{path}*"),
+                },
+                RequestExtractor::Method,
+            ],
+            policy: Default::default(),
+        }
+    }
+}
diff --git a/hitbox-tower/src/configuration/endpoint.rs b/hitbox-tower/src/configuration/endpoint.rs
index dca5375..7f6a3ec 100644
--- a/hitbox-tower/src/configuration/endpoint.rs
+++ b/hitbox-tower/src/configuration/endpoint.rs
@@ -1,4 +1,6 @@
-use crate::configuration::{RequestExtractor, RequestPredicate, ResponsePredicate};
+use crate::configuration::{
+    builder::EndpointConfigBuilder, RequestExtractor, RequestPredicate, ResponsePredicate,
+};
 use crate::Configurable;
 use hitbox::policy::PolicyConfig;
 use hitbox::predicate::Predicate;
@@ -14,8 +16,9 @@ use hitbox_http::predicates::{
 };
 use hitbox_http::{CacheableHttpRequest, CacheableHttpResponse};
 use serde::{Deserialize, Serialize};
+use std::sync::Arc;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct EndpointConfig {
     pub request_predicates: Vec<RequestPredicate>,
     pub response_predicates: Vec<ResponsePredicate>,
@@ -32,6 +35,10 @@ impl EndpointConfig {
             policy: Default::default(),
         }
     }
+
+    pub fn builder() -> EndpointConfigBuilder {
+        EndpointConfigBuilder::new()
+    }
 }
 
 impl Configurable for EndpointConfig {
@@ -93,6 +100,42 @@ impl Configurable for EndpointConfig {
     }
 }
 
+impl<C> Configurable for Arc<C>
+where
+    C: Configurable,
+{
+    fn request_predicates<ReqBody>(
+        &self,
+    ) -> Box<dyn Predicate<Subject = CacheableHttpRequest<ReqBody>> + Send + Sync>
+    where
+        ReqBody: Send + 'static,
+    {
+        self.as_ref().request_predicates()
+    }
+
+    fn response_predicates<ResBody>(
+        &self,
+    ) -> Box<dyn Predicate<Subject = CacheableHttpResponse<ResBody>> + Send + Sync>
+    where
+        ResBody: Send + 'static,
+    {
+        self.as_ref().response_predicates()
+    }
+
+    fn extractors<ReqBody>(
+        &self,
+    ) -> Box<dyn Extractor<Subject = CacheableHttpRequest<ReqBody>> + Send + Sync>
+    where
+        ReqBody: Send + 'static,
+    {
+        self.as_ref().extractors()
+    }
+
+    fn policy(&self) -> PolicyConfig {
+        self.as_ref().policy()
+    }
+}
+
 impl Default for EndpointConfig {
     fn default() -> Self {
         Self {
diff --git a/hitbox-tower/src/configuration/extractors/request.rs b/hitbox-tower/src/configuration/extractors/request.rs
index 11fc3ec..0a02971 100644
--- a/hitbox-tower/src/configuration/extractors/request.rs
+++ b/hitbox-tower/src/configuration/extractors/request.rs
@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum RequestExtractor {
     Path { path: String },
     Method,
diff --git a/hitbox-tower/src/configuration/mod.rs b/hitbox-tower/src/configuration/mod.rs
index ea25e19..d7ac6c0 100644
--- a/hitbox-tower/src/configuration/mod.rs
+++ b/hitbox-tower/src/configuration/mod.rs
@@ -1,3 +1,4 @@
+pub mod builder;
 mod endpoint;
 mod extractors;
 mod predicates;
diff --git a/hitbox-tower/src/configuration/predicates/request.rs b/hitbox-tower/src/configuration/predicates/request.rs
index 368dfa0..fe749fb 100644
--- a/hitbox-tower/src/configuration/predicates/request.rs
+++ b/hitbox-tower/src/configuration/predicates/request.rs
@@ -1,7 +1,7 @@
 use crate::configuration::serializers::method;
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum RequestPredicate {
     Path {
         path: String,
diff --git a/hitbox-tower/src/configuration/predicates/response.rs b/hitbox-tower/src/configuration/predicates/response.rs
index 4637cd1..e75f0e4 100644
--- a/hitbox-tower/src/configuration/predicates/response.rs
+++ b/hitbox-tower/src/configuration/predicates/response.rs
@@ -1,7 +1,7 @@
 use crate::configuration::serializers::status_code;
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum ResponsePredicate {
     #[serde(with = "status_code")]
     StatusCode { code: http::StatusCode },
diff --git a/hitbox-tower/src/layer.rs b/hitbox-tower/src/layer.rs
index 05f1fcb..2ad27fb 100644
--- a/hitbox-tower/src/layer.rs
+++ b/hitbox-tower/src/layer.rs
@@ -1,134 +1,87 @@
-use crate::configuration::{
-    EndpointConfig, ExtractorBuilder, RequestPredicateBuilder, ResponsePredicateBuilder,
-};
+use crate::configuration::EndpointConfig;
 use std::sync::Arc;
 
-use hitbox::{
-    backend::CacheBackend,
-    policy::{EnabledCacheConfig, PolicyConfig},
-};
+use hitbox::backend::CacheBackend;
 use hitbox_stretto::StrettoBackend;
 use tower::Layer;
 
 use crate::service::CacheService;
 
 #[derive(Clone)]
-pub struct Cache<B> {
+pub struct Cache<B, C> {
     pub backend: Arc<B>,
-    pub configuration: Arc<EndpointConfig>,
+    pub configuration: C,
 }
 
-impl<B> Cache<B> {
-    pub fn new(backend: B) -> Cache<B> {
+impl<B, C> Cache<B, C>
+where
+    C: Default,
+{
+    pub fn new(backend: B) -> Cache<B, C> {
         Cache {
             backend: Arc::new(backend),
-            configuration: Arc::new(Default::default()),
+            configuration: Default::default(),
         }
     }
 }
 
-impl<S, B> Layer<S> for Cache<B> {
-    type Service = CacheService<S, B, EndpointConfig>;
+impl<S, B, C> Layer<S> for Cache<B, C>
+where
+    C: Clone,
+{
+    type Service = CacheService<S, B, C>;
 
     fn layer(&self, upstream: S) -> Self::Service {
         CacheService::new(
             upstream,
             Arc::clone(&self.backend),
-            Arc::clone(&self.configuration),
+            self.configuration.clone(),
         )
     }
 }
 
-impl Cache<StrettoBackend> {
-    pub fn builder() -> CacheBuilder<StrettoBackend> {
+impl Cache<StrettoBackend, EndpointConfig> {
+    pub fn builder() -> CacheBuilder<StrettoBackend, EndpointConfig> {
         CacheBuilder::default()
     }
 }
 
-pub struct CacheBuilder<B> {
+pub struct CacheBuilder<B, C> {
     backend: Option<B>,
-    configuration: EndpointConfig,
+    configuration: C,
 }
 
-impl<B> CacheBuilder<B>
+impl<B, C> CacheBuilder<B, C>
 where
     B: CacheBackend,
+    C: Default,
 {
-    pub fn backend<NB: CacheBackend>(self, backend: NB) -> CacheBuilder<NB> {
+    pub fn backend<NB: CacheBackend>(self, backend: NB) -> CacheBuilder<NB, C> {
         CacheBuilder {
             backend: Some(backend),
             configuration: self.configuration,
         }
     }
 
-    pub fn enable(self, policy: EnabledCacheConfig) -> Self {
-        let configuration = EndpointConfig {
-            request_predicates: self.configuration.request_predicates,
-            response_predicates: self.configuration.response_predicates,
-            extractors: self.configuration.extractors,
-            policy: PolicyConfig::Enabled(policy),
-        };
-        CacheBuilder {
-            backend: self.backend,
-            configuration,
-        }
-    }
-
-    pub fn disable(self) -> Self {
-        CacheBuilder {
-            backend: self.backend,
-            configuration: self.configuration,
-        }
-    }
-
-    pub fn request(self, predicates: RequestPredicateBuilder) -> Self {
-        let configuration = EndpointConfig {
-            request_predicates: predicates.build(),
-            response_predicates: self.configuration.response_predicates,
-            extractors: self.configuration.extractors,
-            policy: self.configuration.policy,
-        };
-        CacheBuilder {
-            backend: self.backend,
-            configuration,
-        }
-    }
-
-    pub fn response(self, predicates: ResponsePredicateBuilder) -> Self {
-        let configuration = EndpointConfig {
-            request_predicates: self.configuration.request_predicates,
-            response_predicates: predicates.build(),
-            extractors: self.configuration.extractors,
-            policy: self.configuration.policy,
-        };
-        CacheBuilder {
-            backend: self.backend,
-            configuration,
-        }
-    }
-
-    pub fn cache_key(self, extractors: ExtractorBuilder) -> Self {
-        let configuration = EndpointConfig {
-            request_predicates: self.configuration.request_predicates,
-            response_predicates: self.configuration.response_predicates,
-            extractors: extractors.build(),
-            policy: self.configuration.policy,
-        };
+    pub fn config<NC>(self, configuration: NC) -> CacheBuilder<B, NC> {
         CacheBuilder {
             backend: self.backend,
             configuration,
         }
     }
 
-    pub fn build(self) -> Cache<B> {
+    pub fn build(self) -> Cache<B, C> {
         Cache {
             backend: Arc::new(self.backend.expect("Please add some cache backend")),
-            configuration: Arc::new(self.configuration),
+            configuration: self.configuration,
         }
     }
 }
 
-impl<B> Default for CacheBuilder<B> {
+impl<B, C> Default for CacheBuilder<B, C>
+where
+    C: Default,
+{
     fn default() -> Self {
         Self {
             backend: None,
diff --git a/hitbox-tower/src/service.rs b/hitbox-tower/src/service.rs
index c58e958..f88866e 100644
--- a/hitbox-tower/src/service.rs
+++ b/hitbox-tower/src/service.rs
@@ -12,11 +12,11 @@ use crate::future::Transformer;
 pub struct CacheService<S, B, C> {
     upstream: S,
     backend: Arc<B>,
-    configuration: Arc<C>,
+    configuration: C,
 }
 
 impl<S, B, C> CacheService<S, B, C> {
-    pub fn new(upstream: S, backend: Arc<B>, configuration: Arc<C>) -> Self {
+    pub fn new(upstream: S, backend: Arc<B>, configuration: C) -> Self {
         CacheService {
             upstream,
             backend,
@@ -29,6 +29,7 @@ impl<S, B, C> Clone for CacheService<S, B, C>
 where
     S: Clone,
     B: Clone,
+    C: Clone,
 {
     fn clone(&self) -> Self {
         Self {
diff --git a/hitbox/src/policy.rs b/hitbox/src/policy.rs
index 449ae61..1c5ff2c 100644
--- a/hitbox/src/policy.rs
+++ b/hitbox/src/policy.rs
@@ -14,6 +14,9 @@ pub enum PolicyConfig {
 
 impl Default for PolicyConfig {
     fn default() -> Self {
-        Self::Enabled(Default::default())
+        Self::Enabled(EnabledCacheConfig {
+            ttl: Some(5),
+            stale_cache: None,
+        })
     }
 }