v0.27.3

src/cache/model/cache.rs

@@ -246,7 +246,6 @@ struct ColdFile {
 
 #[derive(Clone)]
 struct ColdEntry {
-    key: Key,
     base_key: Key,
     vary: Vec<String>,
     revision: u64,
@@ -258,11 +257,10 @@ struct ColdEntry {
     target: String,
     tags: Vec<String>,
     created_at: SystemTime,
-    headers: HeaderMap,
     body_path: PathBuf,
     meta_path: PathBuf,
     body_bytes: usize,
-    body_sha256: String,
+    body_sha256: Key,
     disk_bytes: u64,
     stored_at: SystemTime,
     last_access: SystemTime,
@@ -273,8 +271,7 @@ struct ColdEntry {
     stale_if_error: u64,
     must_revalidate: bool,
     proxy_revalidate: bool,
-    origin_etag: Option<HeaderValue>,
-    origin_last_modified: Option<HeaderValue>,
+    has_validator: bool,
     hits: u64,
     transformed: bool,
     sequence: u64,

src/cache/model/cold_metadata.rs

@@ -0,0 +1,69 @@
+struct ColdMetadata {
+    headers: HeaderMap,
+    origin_etag: Option<HeaderValue>,
+    origin_last_modified: Option<HeaderValue>,
+}
+
+async fn read_cold_metadata(storage_key: &Key, entry: &ColdEntry) -> Option<ColdMetadata> {
+    let bytes = tokio::fs::read(&entry.meta_path).await.ok()?;
+    let file: ColdFile = serde_json::from_slice(&bytes).ok()?;
+    let key = parse_key_hex(&file.key)?;
+    let base_key = parse_key_hex(&file.base_key)?;
+    let body_sha256 = parse_key_hex(&file.body_sha256)?;
+    let mut vary = file.vary.clone();
+    vary.sort();
+    vary.dedup();
+    let authority = if file.authority.is_empty() {
+        file.domain.as_str()
+    } else {
+        file.authority.as_str()
+    };
+    let target = if file.target.is_empty() {
+        file.path.as_str()
+    } else {
+        file.target.as_str()
+    };
+    if file.format != COLD_FORMAT_VERSION
+        || key != *storage_key
+        || base_key != entry.base_key
+        || vary != entry.vary
+        || file.revision != entry.revision
+        || file.scope != entry.scope
+        || file.scheme != entry.scheme
+        || authority != entry.authority
+        || file.domain != entry.domain
+        || file.path != entry.path
+        || target != entry.target
+        || file.tags != entry.tags
+        || file.body_bytes != entry.body_bytes
+        || body_sha256 != entry.body_sha256
+        || file.ttl != entry.ttl
+        || file.stale_while_revalidate != entry.stale_while_revalidate
+        || file.stale_if_error != entry.stale_if_error
+        || file.must_revalidate != entry.must_revalidate
+        || file.proxy_revalidate != entry.proxy_revalidate
+        || file.transformed != entry.transformed
+        || file.skip_compression != entry.skip_compression
+        || file.requires_revalidation != entry.requires_revalidation
+        || entry.body_path.file_name().and_then(|name| name.to_str()) != Some(file.body_file.as_str())
+    {
+        return None;
+    }
+    let headers = pairs_to_headers(&file.headers)?;
+    let origin_etag = file
+        .origin_etag
+        .as_deref()
+        .and_then(|value| HeaderValue::from_str(value).ok());
+    let origin_last_modified = file
+        .origin_last_modified
+        .as_deref()
+        .and_then(|value| HeaderValue::from_str(value).ok());
+    if entry.has_validator != (origin_etag.is_some() || origin_last_modified.is_some()) {
+        return None;
+    }
+    Some(ColdMetadata {
+        headers,
+        origin_etag,
+        origin_last_modified,
+    })
+}

src/cache/model/maintenance.rs

@@ -404,18 +404,15 @@ fn incompatible_cold_variants(store: &ColdStore, base_key: &Key, vary: &[String]
         .collect()
 }
 
-fn body_sha256(body: &[u8]) -> String {
+fn body_sha256_bytes(body: &[u8]) -> Key {
     let digest = Sha256::digest(body);
-    let mut out = String::with_capacity(64);
-    for byte in digest {
-        use std::fmt::Write as _;
-        let _ = write!(&mut out, "{byte:02x}");
-    }
+    let mut out = [0u8; 32];
+    out.copy_from_slice(&digest);
     out
 }
 
 fn cold_body_matches(entry: &ColdEntry, body: &[u8]) -> bool {
-    body.len() == entry.body_bytes && body_sha256(body).as_str() == entry.body_sha256.as_str()
+    body.len() == entry.body_bytes && body_sha256_bytes(body) == entry.body_sha256
 }
 
 fn key_hex(key: &Key) -> String {