v0.34.0_1

src/proxy/forward/web_source.rs

@@ -11,6 +11,14 @@
         Err(_) => return error(StatusCode::BAD_REQUEST,
             "RustProxy: invalid Web Server rewrite path\n"),
     };
+    #[cfg(target_os = "linux")]
+    let kernel_sendfile = request.extensions()
+        .get::<crate::server::sendfile::SendfileSlots>().cloned();
+    #[cfg(target_os = "linux")]
+    let identity_request = request.version() == http::Version::HTTP_11
+        && !request.headers().contains_key("accept-encoding")
+        && !request.headers().contains_key("range")
+        && !request.headers().contains_key("if-range");
     let cache_settings = route.frontend.as_ref()
         .map(|frontend| &frontend.cache)
         .unwrap_or(&snapshot.envelope.config.cache);
@@ -19,9 +27,8 @@
     let enabled = cache_settings.active_for(route.cache)
         && frontend.is_none_or(|frontend| frontend.basic_auth.is_none() && frontend.tinyauth.is_none());
     if let Some(exchange) = request.extensions().get::<Arc<Exchange>>() {
-        *exchange.cache_effective_enabled.lock().unwrap_or_else(|e| e.into_inner()) = Some(enabled);
-        *exchange.transform_effective_enabled.lock().unwrap_or_else(|e| e.into_inner()) =
-            Some(transform_settings.is_some_and(|settings| settings.enabled));
+        exchange.set_cache_enabled(enabled);
+        exchange.set_transform_enabled(transform_settings.is_some_and(|settings| settings.enabled));
     }
     // The authority is already validated by effective_host. HTTP/2 and HTTP/3
     // requests commonly have :authority but no Host field, which otherwise
@@ -64,7 +71,8 @@
         Some(headers)
     } else { None };
     let cache_ticket = if eligible {
-        state.cache.ticket_scoped(state.cache.revision(), scope, context.scheme,
+        state.cache.ticket_scoped_for_config(snapshot.envelope.revision,
+            state.cache.revision(), scope, context.scheme,
             original_host.to_str().unwrap_or(""), &route.id, &public_suffix,
             key_headers.as_ref().unwrap_or(&request_headers))
     } else { None };
@@ -280,5 +288,32 @@
     cache_settings.annotate_reason(response.headers_mut(), outcome, 0, 0, reason);
     let transformed = response.extensions().get::<crate::transform::Applied>().is_some();
     cache_settings.annotate_transformed(response.headers_mut(), transformed);
+    // Register only AFTER the vhost response policy, cache and transformation
+    // decisions are final. Never feed synthetic transport placeholders into
+    // cache, compression or the transformation engine. The ordinary body
+    // remains the fallback on every other protocol/response and when the
+    // per-connection bridge has no capacity.
+    #[cfg(target_os = "linux")]
+    if !enabled && identity_request && request_method == Method::GET
+        && !transform_settings.is_some_and(|settings| settings.enabled)
+        && response.status() == StatusCode::OK
+        && !response.headers().contains_key("content-encoding")
+        && !response.headers().contains_key("transfer-encoding")
+        && !response.headers().contains_key("content-range")
+    {
+        if let (Some(slots), Some(candidate)) = (
+            kernel_sendfile,
+            response.extensions().get::<crate::server::sendfile::SendfileCandidate>().cloned(),
+        ) {
+            let correct_length = response.headers().get("content-length")
+                .and_then(|v| v.to_str().ok())
+                .and_then(|v| v.parse::<u64>().ok()) == Some(candidate.length);
+            if correct_length {
+                if let Some(body) = slots.create_body(candidate, service.web_metrics.clone()) {
+                    *response.body_mut() = Body::new(body);
+                }
+            }
+        }
+    }
     response
 }