0.34.13_cleaup_code

src/cache/policy/request.rs

@@ -44,9 +44,7 @@ fn directives(headers: &HeaderMap) -> Option<HashMap<String, Option<String>>> {
     }
     Some(result)
 }
-/// Keep all client cache restrictions except the hard-reload directives that
-/// Varnish normally disregards for a fresh shared object. Never mutate the
-/// actual request (it is still forwarded to the origin and used for Vary).
+
 fn compatible_freshness_headers<'a>(
     headers: &'a HeaderMap,
     compatible: bool,
@@ -54,29 +52,31 @@ fn compatible_freshness_headers<'a>(
     if !compatible || (!headers.contains_key("cache-control") && !headers.contains_key("pragma")) {
         return std::borrow::Cow::Borrowed(headers);
     }
-    // An invalid cache-control header cannot be made valid by filtering it.
-    // Also avoid cloning the full map for ordinary requests with no reload
-    // directives, including min-fresh, max-stale and only-if-cached.
+
     let Some(control) = directives(headers) else {
         return std::borrow::Cow::Borrowed(headers);
     };
     let remove_reload = control.contains_key("no-cache")
-        || control.get("max-age").and_then(|value| value.as_deref())
-            .and_then(|value| value.parse::<u64>().ok()) == Some(0);
+        || control
+            .get("max-age")
+            .and_then(|value| value.as_deref())
+            .and_then(|value| value.parse::<u64>().ok())
+            == Some(0);
     if !remove_reload && !pragma_no_cache(headers) {
         return std::borrow::Cow::Borrowed(headers);
     }
     let mut freshness = headers.clone();
+
     let mut changed = false;
+
     if pragma_no_cache(headers) {
-        // Pragma only affects freshness through its `no-cache` token in this
-        // implementation. Preserve other tokens, if any.
         freshness.remove("pragma");
         for header in headers.get_all("pragma") {
             let Ok(text) = header.to_str() else {
                 return std::borrow::Cow::Borrowed(headers);
             };
-            let retained = text.split(',')
+            let retained = text
+                .split(',')
                 .map(str::trim)
                 .filter(|token| !token.eq_ignore_ascii_case("no-cache"))
                 .collect::<Vec<_>>();
@@ -95,15 +95,21 @@ fn compatible_freshness_headers<'a>(
             let Ok(text) = header.to_str() else {
                 return std::borrow::Cow::Borrowed(headers);
             };
-            let retained = text.split(',').map(str::trim).filter(|token| {
-                let (name, value) = token.split_once('=').unwrap_or((token, ""));
-                let name = name.trim();
-                let skip = name.eq_ignore_ascii_case("no-cache")
-                    || (name.eq_ignore_ascii_case("max-age")
-                        && value.trim().trim_matches('"').parse::<u64>() == Ok(0));
-                if skip { changed = true; }
-                !skip
-            }).collect::<Vec<_>>();
+            let retained = text
+                .split(',')
+                .map(str::trim)
+                .filter(|token| {
+                    let (name, value) = token.split_once('=').unwrap_or((token, ""));
+                    let name = name.trim();
+                    let skip = name.eq_ignore_ascii_case("no-cache")
+                        || (name.eq_ignore_ascii_case("max-age")
+                            && value.trim().trim_matches('"').parse::<u64>() == Ok(0));
+                    if skip {
+                        changed = true;
+                    }
+                    !skip
+                })
+                .collect::<Vec<_>>();
             if !retained.is_empty() {
                 let Ok(value) = HeaderValue::from_str(&retained.join(", ")) else {
                     return std::borrow::Cow::Borrowed(headers);
@@ -118,8 +124,11 @@ fn compatible_freshness_headers<'a>(
             }
         }
     }
-    if changed { std::borrow::Cow::Owned(freshness) }
-    else { std::borrow::Cow::Borrowed(headers) }
+    if changed {
+        std::borrow::Cow::Owned(freshness)
+    } else {
+        std::borrow::Cow::Borrowed(headers)
+    }
 }
 
 pub fn request_freshness_headers<'a>(
@@ -243,8 +252,7 @@ pub fn request_policy(
             return RequestPolicy::Bypass(reason);
         }
     }
-    // Compatibility only relaxes browser hard-reload freshness requests.
-    // Retain no-store, only-if-cached, min-fresh and max-stale semantics.
+
     let Some(control) = directives(headers) else {
         return RequestPolicy::Bypass("request_cache_control_invalid");
     };

src/cache/policy/response.rs

@@ -127,24 +127,23 @@ pub fn plan(
         Some(v) => httpdate::parse_http_date(v.to_str().ok()?).ok()?,
         None => now,
     };
-    let declared_ttl =
-        if override_public_no_cache {
-            Some(settings.default_ttl_seconds)
-        } else if let Some(value) = control.get("s-maxage").or_else(|| control.get("max-age")) {
-            Some(value.as_ref()?.parse::<u64>().ok()?)
-        } else if let Some(expires) = headers.get("expires") {
-            Some(
-                httpdate::parse_http_date(expires.to_str().ok()?)
-                    .ok()?
-                    .duration_since(date)
-                    .ok()?
-                    .as_secs(),
-            )
-        } else if control.contains_key("public") {
-            Some(settings.default_ttl_seconds)
-        } else {
-            None
-        };
+    let declared_ttl = if override_public_no_cache {
+        Some(settings.default_ttl_seconds)
+    } else if let Some(value) = control.get("s-maxage").or_else(|| control.get("max-age")) {
+        Some(value.as_ref()?.parse::<u64>().ok()?)
+    } else if let Some(expires) = headers.get("expires") {
+        Some(
+            httpdate::parse_http_date(expires.to_str().ok()?)
+                .ok()?
+                .duration_since(date)
+                .ok()?
+                .as_secs(),
+        )
+    } else if control.contains_key("public") {
+        Some(settings.default_ttl_seconds)
+    } else {
+        None
+    };
     let age = match headers.get("age") {
         Some(v) => v.to_str().ok()?.parse::<u64>().ok()?,
         None => 0,

src/cache/policy/scope_tests.rs

@@ -58,14 +58,29 @@ mod scope_tests {
     fn stale_snapshot_cannot_issue_cache_ticket_after_config_commit() {
         let cache = Cache::new(1);
         cache.set_control_revision(7);
-        let ticket = |revision| cache.ticket_scoped_for_config(
-            revision, 1, "vhost-a", "http", "same.test", "main", "/resource", &HeaderMap::new()
-        );
+        let ticket = |revision| {
+            cache.ticket_scoped_for_config(
+                revision,
+                1,
+                "vhost-a",
+                "http",
+                "same.test",
+                "main",
+                "/resource",
+                &HeaderMap::new(),
+            )
+        };
         assert!(ticket(7).is_some(), "the current snapshot can cache");
         cache.set_control_revision(8);
         assert_eq!(cache.revision(), 1);
-        assert!(ticket(7).is_none(), "late request from the previous snapshot must bypass");
-        assert!(ticket(8).is_some(), "the new snapshot can reuse the same cache identity");
+        assert!(
+            ticket(7).is_none(),
+            "late request from the previous snapshot must bypass"
+        );
+        assert!(
+            ticket(8).is_some(),
+            "the new snapshot can reuse the same cache identity"
+        );
     }
 
     #[test]
@@ -82,18 +97,30 @@ mod scope_tests {
         assert!(effective.enabled && effective.expose_status);
         let mut globally_disabled = global.clone();
         globally_disabled.enabled = false;
-        assert!(!Overrides { enabled: Some(true), ..Overrides::default() }
+        assert!(
+            !Overrides {
+                enabled: Some(true),
+                ..Overrides::default()
+            }
             .resolve(&globally_disabled)
             .unwrap()
-            .enabled);
-        assert!(!Overrides { enabled: Some(false), ..Overrides::default() }
+            .enabled
+        );
+        assert!(
+            !Overrides {
+                enabled: Some(false),
+                ..Overrides::default()
+            }
             .resolve(&global)
             .unwrap()
-            .enabled);
-        assert!(!Overrides::default()
-            .resolve(&globally_disabled)
-            .unwrap()
-            .enabled);
+            .enabled
+        );
+        assert!(
+            !Overrides::default()
+                .resolve(&globally_disabled)
+                .unwrap()
+                .enabled
+        );
         assert_eq!(effective.max_bytes, global.max_bytes);
         assert_eq!(effective.max_ttl_seconds, 30);
         assert!(Overrides {