v0.29.0

src/proxy/forward/route_cache.rs

@@ -6,6 +6,8 @@ if let Some(exchange) = request.extensions().get::<Arc<Exchange>>() {
     *exchange.route.lock().unwrap_or_else(|e| e.into_inner()) = Some(route.id.clone());
     *exchange.source.lock().unwrap_or_else(|e| e.into_inner()) = if route.response.is_some() {
         "local_response"
+    } else if route.redirect.is_some() {
+        "local_redirect"
     } else {
         match &route.source {
             crate::config::CompiledSource::WebServer(_) => "web_server",
@@ -18,6 +20,17 @@ if let Some(exchange) = request.extensions().get::<Arc<Exchange>>() {
 if let Some(spec) = &route.response {
     return local_location_response(spec, request.method());
 }
+if let Some(spec) = &route.redirect {
+    let location = match route.redirect_location(&path, request.uri()) {
+        Ok(Some(location)) => location,
+        _ => return error(StatusCode::INTERNAL_SERVER_ERROR, "RustProxy: invalid location redirect\n"),
+    };
+    let status = StatusCode::from_u16(spec.status).unwrap_or(StatusCode::FOUND);
+    let mut response = status.into_response();
+    response.headers_mut().insert(http::header::LOCATION, location);
+    response.headers_mut().insert("cache-control", HeaderValue::from_static("no-store"));
+    return response;
+}
 if route.unavailable {
     let mut response = error(
         StatusCode::SERVICE_UNAVAILABLE,
@@ -178,28 +191,38 @@ let body_empty = if cache_enabled
 } else {
     request.body().is_end_stream()
 };
-let ignore_static_cookie = cache_settings.ignore_cookie_for_path(&path);
-let original_policy = policy_reason
-    .map(crate::cache::RequestPolicy::Bypass)
-    .unwrap_or_else(|| {
-        crate::cache::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());
 let public_suffix = request
     .uri()
     .path_and_query()
     .map(|v| v.as_str())
     .unwrap_or("/")
     .to_owned();
+let force_cache = policy_reason.is_none()
+    && 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,
+            )
+        }
+    });
+
+let only_cached =
+    cache_settings.active_for(route.cache) && crate::cache::only_if_cached(request.headers());
 let origin_suffix = match route.rewritten_path(&path) {
     Ok(None) => public_suffix.clone(),
     Ok(Some(rewritten)) => {
@@ -283,14 +306,20 @@ 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 = crate::cache::request_policy(
-    request.method(),
-    request.headers(),
-    body_empty,
-    &path,
-    request.uri().query().is_some(),
-    cache_settings,
-);
+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 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)
@@ -353,7 +382,8 @@ let pending_revalidation = revalidation_reason.is_some()
 let miss_recorded = false;
     (
         backend, backend_lease, affinity_cookie, admin_control_plane, cache_settings,
-        transform_settings, scope, ignore_static_cookie, only_cached, public_suffix,
+        transform_settings, scope, ignore_static_cookie, force_cache, force_vary_cookie,
+        force_vary_authorization, only_cached, public_suffix,
         origin_suffix, uri, exchange, lease, stop, downstream, h2_downstream,
         range_selection, if_range, range_requested, effective_reason, revalidation_reason,
         cache_ticket, client_conditionals, cached_revalidation, freshness_revalidation_reason,