fixed metadata handling with bincode

Author: 06chaynes

http-cache/src/lib.rs

@@ -436,7 +436,10 @@ pub use error::{
     HttpCacheError, HttpCacheResult, Result, StreamingError,
 };
 
-#[cfg(feature = "manager-cacache")]
+#[cfg(any(
+    feature = "manager-cacache",
+    feature = "manager-cacache-bincode"
+))]
 pub use managers::cacache::CACacheManager;
 
 #[cfg(feature = "streaming")]

http-cache/src/managers/cacache.rs

@@ -20,12 +20,84 @@ impl std::fmt::Debug for CACacheManager {
     }
 }
 
+// Modern store format (postcard) - includes metadata field
+#[cfg(feature = "postcard")]
 #[derive(Debug, Deserialize, Serialize)]
 struct Store {
     response: HttpResponse,
     policy: CachePolicy,
 }
 
+// Legacy store format (bincode) - HttpResponse without metadata field
+// The metadata field was added alongside postcard, so bincode cache
+// data will never contain it.
+#[cfg(all(feature = "bincode", not(feature = "postcard")))]
+#[derive(Debug, Deserialize, Serialize)]
+struct Store {
+    response: LegacyHttpResponse,
+    policy: CachePolicy,
+}
+
+#[cfg(all(feature = "bincode", not(feature = "postcard")))]
+use crate::{HttpHeaders, HttpVersion, Url};
+
+#[cfg(all(feature = "bincode", not(feature = "postcard")))]
+#[derive(Debug, Clone, Deserialize, Serialize)]
+struct LegacyHttpResponse {
+    body: Vec<u8>,
+    #[cfg(feature = "http-headers-compat")]
+    headers: std::collections::HashMap<String, String>,
+    #[cfg(not(feature = "http-headers-compat"))]
+    headers: std::collections::HashMap<String, Vec<String>>,
+    status: u16,
+    url: Url,
+    version: HttpVersion,
+}
+
+#[cfg(all(feature = "bincode", not(feature = "postcard")))]
+impl From<LegacyHttpResponse> for HttpResponse {
+    fn from(legacy: LegacyHttpResponse) -> Self {
+        #[cfg(feature = "http-headers-compat")]
+        let headers = HttpHeaders::Legacy(legacy.headers);
+        #[cfg(not(feature = "http-headers-compat"))]
+        let headers = HttpHeaders::Modern(legacy.headers);
+
+        HttpResponse {
+            body: legacy.body,
+            headers,
+            status: legacy.status,
+            url: legacy.url,
+            version: legacy.version,
+            metadata: None,
+        }
+    }
+}
+
+#[cfg(all(feature = "bincode", not(feature = "postcard")))]
+impl From<HttpResponse> for LegacyHttpResponse {
+    fn from(response: HttpResponse) -> Self {
+        #[cfg(feature = "http-headers-compat")]
+        let headers = match response.headers {
+            HttpHeaders::Legacy(h) => h,
+            HttpHeaders::Modern(h) => {
+                h.into_iter().map(|(k, v)| (k, v.join(", "))).collect()
+            }
+        };
+        #[cfg(not(feature = "http-headers-compat"))]
+        let headers = match response.headers {
+            HttpHeaders::Modern(h) => h,
+        };
+
+        LegacyHttpResponse {
+            body: response.body,
+            headers,
+            status: response.status,
+            url: response.url,
+            version: response.version,
+        }
+    }
+}
+
 #[allow(dead_code)]
 impl CACacheManager {
     /// Creates a new [`CACacheManager`] with the given path.
@@ -64,7 +136,15 @@ impl CacheManager for CACacheManager {
                 return Ok(None);
             }
         };
-        Ok(Some((store.response, store.policy)))
+
+        #[cfg(feature = "postcard")]
+        {
+            Ok(Some((store.response, store.policy)))
+        }
+        #[cfg(all(feature = "bincode", not(feature = "postcard")))]
+        {
+            Ok(Some((store.response.into(), store.policy)))
+        }
     }
 
     async fn put(
@@ -73,13 +153,26 @@ impl CacheManager for CACacheManager {
         response: HttpResponse,
         policy: CachePolicy,
     ) -> Result<HttpResponse> {
+        #[cfg(feature = "postcard")]
         let data = Store { response, policy };
+        #[cfg(all(feature = "bincode", not(feature = "postcard")))]
+        let data = Store { response: response.into(), policy };
+
         #[cfg(feature = "postcard")]
         let bytes = postcard::to_allocvec(&data)?;
         #[cfg(all(feature = "bincode", not(feature = "postcard")))]
         let bytes = bincode::serialize(&data)?;
+
         cacache::write(&self.path, cache_key, bytes).await?;
-        Ok(data.response)
+
+        #[cfg(feature = "postcard")]
+        {
+            Ok(data.response)
+        }
+        #[cfg(all(feature = "bincode", not(feature = "postcard")))]
+        {
+            Ok(data.response.into())
+        }
     }
 
     async fn delete(&self, cache_key: &str) -> Result<()> {

http-cache/src/managers/mod.rs

@@ -1,4 +1,4 @@
-#[cfg(feature = "manager-cacache")]
+#[cfg(any(feature = "manager-cacache", feature = "manager-cacache-bincode"))]
 pub mod cacache;
 
 #[cfg(feature = "manager-foyer")]