v0.27.0

src/proxy/forward/route_cache.rs

@@ -18,6 +18,16 @@ if let Some(exchange) = request.extensions().get::<Arc<Exchange>>() {
 if let Some(spec) = &route.response {
     return local_location_response(spec, request.method());
 }
+if route.unavailable {
+    let mut response = error(
+        StatusCode::SERVICE_UNAVAILABLE,
+        "RustProxy: published Docker service is currently unavailable\n",
+    );
+    response
+        .headers_mut()
+        .insert("retry-after", HeaderValue::from_static("1"));
+    return response;
+}
 if let crate::config::CompiledSource::WebServer(service) = &route.source {
     if handshake.is_some() {
         return error(

src/proxy/forward/success_prepare.rs

@@ -130,7 +130,7 @@ let origin_reason = (cache_ticket.is_some() && origin_plan.is_none()).then(|| {
     }
 });
 let origin_no_transform = crate::transform::no_transform(response.headers());
-let skip_compression = crate::compression::private_or_no_transform(response.headers());
+let skip_compression = crate::compression::no_transform(response.headers());
 let origin_validators = crate::transform::OriginValidators {
     etag: response.headers().get("etag").cloned(),
     last_modified: response.headers().get("last-modified").cloned(),

src/proxy/types.rs

@@ -333,7 +333,7 @@ async fn refresh_cache_once(
         return false;
     };
     let origin_no_transform = crate::transform::no_transform(origin.headers());
-    let skip_compression = crate::compression::private_or_no_transform(origin.headers());
+    let skip_compression = crate::compression::no_transform(origin.headers());
     let origin_validators = crate::transform::OriginValidators {
         etag: origin.headers().get("etag").cloned(),
         last_modified: origin.headers().get("last-modified").cloned(),

src/proxy/upstream_helpers.rs

@@ -284,29 +284,17 @@ async fn observe(State(state): State<Arc<App>>, mut request: Request, next: Next
         {
             response.headers_mut().remove("alt-svc");
         }
-        // Cookie-bearing requests are normally excluded from compression to avoid
-        // compressing potentially private dynamic content. The cache can explicitly
-        // ignore cookies for configured static extensions, though; once that request
-        // is a shared-cache HIT, cache policy has already proven the stored response
-        // contains no Set-Cookie/private/no-store metadata. Local Web Server static
-        // responses are equally independent of request cookies. Allow compression in
-        // those two bounded cases so cached/static browser assets still negotiate
-        // Content-Encoding.
-        if original_headers.contains_key("cookie")
-            && (exchange.cache_status.load(Ordering::Relaxed) == 1
-                || response.extensions().get::<StaticSourceResponse>().is_some())
-        {
-            response
-                .extensions_mut()
-                .insert(crate::compression::AllowCookie);
+        let global_compression = &snapshot.envelope.config.compression;
+        let mut compression = global_compression.clone();
+        if let Some(frontend) = frontend_context.as_ref() {
+            compression = frontend.compression.resolve(global_compression, &compression);
         }
-        response = crate::compression::encode(
-            response,
-            &original_headers,
-            &method,
-            &snapshot.envelope.config.compression,
-        )
-        .await;
+        if let Some(route) = route_context.as_ref() {
+            if let crate::config::CompiledSource::WebServer(service) = &route.source {
+                compression = service.compression.resolve(global_compression, &compression);
+            }
+        }
+        response = crate::compression::encode(response, &original_headers, &method, &compression).await;
         if let Some(encoding) = response
             .extensions()
             .get::<crate::compression::AppliedEncoding>()