v0.33.8

src/proxy/forward/route_cache.rs

@@ -167,7 +167,7 @@ let body_empty = if cache_enabled
         }
     }
 } else {
-    request.body().is_end_stream()
+    cache_enabled && request.body().is_end_stream()
 };
 let public_suffix = request
     .uri()
@@ -175,29 +175,18 @@ let public_suffix = request
     .map(|v| v.as_str())
     .unwrap_or("/")
     .to_owned();
-let force_cache = policy_reason.is_none()
-    && cache_settings.active_for(route.cache)
-    && route
+let cache_plan = cache_plan::CachePlan::new(policy_reason, cache_settings, &path, || {
+    cache_settings.active_for(route.cache) && route
         .frontend
         .as_ref()
-        .is_some_and(|frontend| frontend.force_cache.matches(&path, &public_suffix));
-let ignore_static_cookie = !force_cache && cache_settings.ignore_cookie_for_path(&path);
-let original_policy = policy_reason
-    .map(crate::cache::RequestPolicy::Bypass)
-    .unwrap_or_else(|| {
-        if force_cache {
-            crate::cache::forced_request_policy(request.method(), request.headers(), body_empty)
-        } else {
-            crate::cache::request_policy(
-                request.method(),
-                request.headers(),
-                body_empty,
-                &path,
-                request.uri().query().is_some(),
-                cache_settings,
-            )
-        }
-    });
+        .is_some_and(|frontend| frontend.force_cache.matches(&path, &public_suffix))
+});
+let force_cache = cache_plan.force_cache();
+let ignore_static_cookie = cache_plan.ignore_cookie();
+let original_policy = cache_plan.request_policy(
+    request.method(), request.headers(), body_empty, &path,
+    request.uri().query().is_some(), cache_settings,
+);
 
 let only_cached =
     cache_settings.active_for(route.cache) && crate::cache::only_if_cached(request.headers());
@@ -282,48 +271,31 @@ if websocket_legacy_support {
         }
     }
 }
-let range_selection = crate::cache::request_range(request.method(), request.headers());
-let if_range = request.headers().get("if-range").cloned();
-let range_requested = !matches!(range_selection, crate::cache::RangeSelection::None);
-let post_policy = if force_cache {
-    crate::cache::forced_request_policy(request.method(), request.headers(), body_empty)
-} else {
-    crate::cache::request_policy(
-        request.method(),
-        request.headers(),
-        body_empty,
-        &path,
-        request.uri().query().is_some(),
-        cache_settings,
+let effective_policy = cache_plan::combine_policy(original_policy, || {
+    cache_plan.request_policy(
+        request.method(), request.headers(), body_empty, &path,
+        request.uri().query().is_some(), cache_settings,
     )
-};
+});
 let force_vary_cookie = force_cache && request.headers().contains_key("cookie");
 let force_vary_authorization = force_cache && request.headers().contains_key("authorization");
-let effective_policy = match (original_policy, post_policy) {
-    (crate::cache::RequestPolicy::Bypass(reason), _) => {
-        crate::cache::RequestPolicy::Bypass(reason)
-    }
-    (_, crate::cache::RequestPolicy::Bypass(reason)) => {
-        crate::cache::RequestPolicy::Bypass(reason)
-    }
-    (crate::cache::RequestPolicy::Revalidate(reason), _) => {
-        crate::cache::RequestPolicy::Revalidate(reason)
-    }
-    (_, crate::cache::RequestPolicy::Revalidate(reason)) => {
-        crate::cache::RequestPolicy::Revalidate(reason)
-    }
-    _ => crate::cache::RequestPolicy::Use,
-};
 let effective_reason = effective_policy.bypass_reason();
 let revalidation_reason = effective_policy.revalidation_reason();
 let effective_cacheable = effective_reason.is_none();
+let range_selection = cache_plan::range_selection(
+    effective_cacheable, request.method(), request.headers(),
+);
+let if_range = if effective_cacheable {
+    request.headers().get("if-range").cloned()
+} else { None };
+let range_requested = !matches!(range_selection, crate::cache::RangeSelection::None);
 
 // Match Varnish-style cache identity: a load-balanced backend member must not
 // fragment the object cache. The vhost scope + canonical host + request target
 // already identify the public resource; Vary handles representation variants.
 let cache_route = route.id.as_str();
 let mut cache_key_headers = None;
-if ignore_static_cookie && request.headers().contains_key("cookie") {
+if effective_cacheable && ignore_static_cookie && request.headers().contains_key("cookie") {
     let mut headers = request.headers().clone();
     headers.remove("cookie");
     cache_key_headers = Some(headers);
@@ -344,7 +316,9 @@ let cache_ticket = if effective_cacheable {
 } else {
     None
 };
-let client_conditionals = request.headers().clone();
+let client_conditionals = if cache_ticket.is_some() {
+    request.headers().clone()
+} else { HeaderMap::new() };
 let cached_revalidation = if let Some(ticket) = cache_ticket.as_ref() {
     state.cache.revalidation_tiered(ticket).await
 } else {