Tower

.github/workflows/CI.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        rust: [1.60.0, stable]
+        rust: [1.70.0, stable]
     steps:
     - uses: actions/checkout@v3
     - uses: actions-rs/toolchain@v1
@@ -31,7 +31,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        rust: [1.60.0, stable, beta]
+        rust: [1.70.0, stable, beta]
         redis-version: [6]
     steps:
     - uses: actions/checkout@v3

Cargo.toml

@@ -1,12 +1,13 @@
 [workspace]
+resolver = "2"
 
 members = [
     "hitbox",
-    "hitbox-tokio",
-    "hitbox-actix",
     "hitbox-backend",
-    "hitbox-derive",
+    "hitbox-core",
     "hitbox-redis",
+    "hitbox-stretto",
     "hitbox-tower",
+    "hitbox-tarantool",
     "examples",
 ]

documentation/fsm.md

@@ -0,0 +1,64 @@
+# Main cache flow diagram
+```mermaid
+ stateDiagram-v2
+    classDef Implemented fill:lightgreen,color:black,font-weight:bold,stroke-width:2px,stroke:green
+    classDef Unimplemented fill:red,color:black,font-weight:bold,stroke-width:2px,stroke:red
+    class Initial Implemented
+    class if_cache_enabled Unimplemented
+    class CheckRequestCachePolicy Implemented
+    class match_request_cache_policy Implemented
+    class PollCache Implemented
+    class check_backend_result Implemented
+    class CheckCacheState Implemented
+    class check_cache_state Implemented
+    class Response Implemented
+    class PollUpstream Implemented
+    class UpstreamPolled Implemented
+    class CheckResponseCachePolicy Implemented
+    class UpdateCache Implemented
+    class AcquireCacheLock Unimplemented
+
+    state if_cache_enabled <<choice>>
+    [*] --> Initial
+    Initial --> if_cache_enabled
+    if_cache_enabled --> CheckRequestCachePolicy: config.enabled = true
+    if_cache_enabled --> PollUpstream: config.enabled = false
+
+    state match_request_cache_policy <<choice>>
+    CheckRequestCachePolicy --> match_request_cache_policy
+    match_request_cache_policy --> PollCache: request policy = Cacheable
+    match_request_cache_policy --> PollUpstream: request policy = NonCacheable
+
+    state check_backend_result <<choice>>
+    PollCache --> check_backend_result
+    check_backend_result --> CheckCacheState: backend_result = Some
+    check_backend_result --> PollUpstream: backend_result = None
+
+    state check_cache_state <<choice>>
+    state check_stale_config <<choice>>
+    CheckCacheState --> check_cache_state
+    check_cache_state --> check_stale_config: cache_state = Stale
+    check_cache_state --> Response: cache_state = Actual
+
+    state check_lock_config <<choice>>
+    check_stale_config --> check_lock_config: config.stale = enabled
+    check_stale_config --> Response: config.stale = disable
+
+    check_lock_config --> AcquireCacheLock: config.lock = enabled
+    check_lock_config --> PollUpstream: config.lock = disabled
+    AcquireCacheLock --> PollUpstream
+
+    PollUpstream --> UpstreamPolled
+    state check_cache_key <<choice>>
+    UpstreamPolled --> check_cache_key
+    check_cache_key --> Response: cache_key = None
+    check_cache_key --> CheckResponseCachePolicy: cache_key = Some
+
+    state match_response_cache_policy <<choice>>
+    CheckResponseCachePolicy --> match_response_cache_policy
+    match_response_cache_policy --> Response: response policy = NonCacheable
+    match_response_cache_policy --> UpdateCache: response policy = Cacheable
+
+    UpdateCache --> Response
+    Response --> [*]
+```

examples/Cargo.toml

@@ -3,31 +3,37 @@ name = "hitbox-examples"
 version = "0.0.0"
 publish = false
 edition = "2021"
+autoexamples = false
 
 [features]
 default = []
 
 [dev-dependencies]
-hitbox = { path = "../hitbox", features = ["derive", "metrics"] }
-hitbox-actix = { path = "../hitbox-actix", features = ["redis"]}
+hitbox = { path = "../hitbox", features = ["metrics"] }
+hitbox-backend = { path = "../hitbox-backend" }
+hitbox-tower = { path = "../hitbox-tower" }
+hitbox-redis = { path = "../hitbox-redis" }
+hitbox-stretto = { path = "../hitbox-stretto" }
 actix = "0.13"
+axum = "0.6"
 log = "0.4"
 actix-rt = "2"
-serde_json = "1"
-serde_qs = { version = "0.10" }
 serde = { version = "1", features = ["derive"] }
-chrono = { version = "0.4", features = ["serde"] }
-thiserror = "1"
-prometheus = { version = "0.13" }
-env_logger = "0.9"
-actix_derive = "0.6"
-actix-web = "4.0"
-tracing = "0.1"
-tracing-subscriber = "0.3"
-metrics-exporter-prometheus = "0.11"
-
+env_logger = "0.10"
+serde_json = "1"
 hyper = { version = "0.14", features = ["full"] }
 tokio = { version = "1", features = ["full"] }
 tower = { version = "0.4", features = ["full"] }
-tower-http = { version = "0.3", features = ["full"] }
+tower-http = { version = "0.4", features = ["full"] }
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+tracing = { version = "0.1" }
 http = "0.2"
+lazy_static = "1"
+
+[[example]]
+name = "axum"
+path = "examples/axum.rs"
+
+[[example]]
+name = "tower"
+path = "examples/tower.rs"

examples/examples/async_backend.rs

@@ -96,6 +96,4 @@ async fn main() -> Result<(), CacheError> {
     Ok(())
 }*/
 
-fn main() {
-
-}
+fn main() {}

examples/examples/axum.rs

@@ -0,0 +1,87 @@
+use axum::{extract::Path, routing::get, Json, Router};
+use hitbox_tower::{
+    configuration::extractor,
+    configuration::predicate::{request, response},
+    Method, StatusCode,
+};
+
+use hitbox_redis::RedisBackend;
+use hitbox_tower::{Cache, EndpointConfig};
+
+async fn handler_result(Path(_name): Path<String>) -> Result<String, StatusCode> {
+    //dbg!("axum::handler_result");
+    // Ok(format!("Hello, {name}"))
+    Err(StatusCode::INTERNAL_SERVER_ERROR)
+}
+
+async fn handler() -> String {
+    //dbg!("axum::handler");
+    "root".to_string()
+}
+
+#[derive(serde::Serialize)]
+struct Greet {
+    name: String,
+    answer: u32,
+}
+
+async fn handler_json() -> Json<Greet> {
+    //dbg!("axum::handler");
+    Json(Greet {
+        name: "root".to_owned(),
+        answer: 42,
+    })
+}
+
+#[tokio::main]
+async fn main() {
+    let subscriber = tracing_subscriber::fmt()
+        .pretty()
+        .with_env_filter("debug,hitbox=trace")
+        .finish();
+    tracing::subscriber::set_global_default(subscriber).unwrap();
+
+    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")
+                .query("x-cache", "true")
+                .path("/{path}*"),
+        )
+        .response(response::status_code(StatusCode::OK))
+        .cache_key(extractor::method().query("cache").path("/{path}*"))
+        .build();
+
+    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))
+        .route("/json/", get(handler_json))
+        .route("/health", get(handler).layer(health_check))
+        .layer(json_cache);
+
+    // run it with hyper on localhost:3000
+    axum::Server::bind(&"0.0.0.0:3000".parse().unwrap())
+        .serve(app.into_make_service())
+        .await
+        .unwrap();
+}

examples/examples/cacheable_response.rs

@@ -59,6 +59,4 @@ async fn main() -> Result<(), CacheError> {
     Ok(())
 }*/
 
-fn main() {
-
-}
+fn main() {}

examples/examples/sync_backend.rs

@@ -102,6 +102,4 @@ async fn main() -> Result<(), CacheError> {
     Ok(())
 }*/
 
-fn main() {
-
-}
+fn main() {}

examples/examples/tower.rs

@@ -1,17 +1,31 @@
-use std::{convert::Infallible, net::SocketAddr};
+use hitbox_redis::RedisBackend;
+use hitbox_stretto::StrettoBackend;
+use hitbox_tower::Cache;
 use hyper::{Body, Server};
+use std::net::SocketAddr;
 
+use http::{Method, Request, Response};
 use tower::make::Shared;
-use http::{Request, Response};
 
-async fn handle(_: Request<Body>) -> Result<Response<Body>, Infallible> {
-    Ok(Response::new("Hello, World!".into()))
+async fn handle(_: Request<Body>) -> http::Result<Response<Body>> {
+    // Ok(Response::new("Hello, World!".into()))
+    Err(http::Error::from(Method::from_bytes(&[0x01]).unwrap_err()))
 }
 
 #[tokio::main]
 async fn main() {
+    let subscriber = tracing_subscriber::fmt()
+        .pretty()
+        .with_env_filter("debug,hitbox=trace")
+        .finish();
+    tracing::subscriber::set_global_default(subscriber).unwrap();
+
+    let inmemory = StrettoBackend::builder(10_000_000).finalize().unwrap();
+    let redis = RedisBackend::builder().build().unwrap();
+
     let service = tower::ServiceBuilder::new()
-        .layer(tower_http::trace::TraceLayer::new_for_http())
+        // .layer(Cache::builder().backend(inmemory).build())
+        .layer(Cache::builder().backend(redis).build())
         .service_fn(handle);
 
     let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
@@ -20,4 +34,3 @@ async fn main() {
         .await
         .expect("server error");
 }
-