withcache 0.4.0__tar.gz → 0.4.1__tar.gz

{withcache-0.4.0 → withcache-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: withcache
-Version: 0.4.0
+Version: 0.4.1
 Summary: Operator-curated, URL-keyed artifact cache for a small lab (CUDA/ROCm/DOCA/firmware)
 Project-URL: Homepage, https://github.com/safl/withcache
 Author-email: "Simon A. F. Lund" <safl@safl.dk>

{withcache-0.4.0 → withcache-0.4.1}/shim/build.zig.zon

@@ -2,7 +2,7 @@
     .name = .withcache_shim,
     // Zig requires a literal here; keep it in lockstep with the project's
     // single source (src/withcache/__init__.py) via `make bump` / `make version-check`.
-    .version = "0.4.0",
+    .version = "0.4.1",
     .fingerprint = 0xd7d96c5ed212ccaa,
     .minimum_zig_version = "0.16.0",
     .paths = .{

{withcache-0.4.0 → withcache-0.4.1}/src/withcache/__init__.py

@@ -12,6 +12,6 @@ All modules are stdlib-only and self-contained.
 
 from .client import blob_url, cache_base, is_cached, serve_url
 
-__version__ = "0.4.0"
+__version__ = "0.4.1"
 
 __all__ = ["__version__", "blob_url", "cache_base", "is_cached", "serve_url"]

{withcache-0.4.0 → withcache-0.4.1}/src/withcache/server.py

@@ -325,6 +325,17 @@ class Store:
                         size += len(chunk)
                         if progress:
                             progress(size, total)
+            # urllib's read loop exits on clean EOF AND on transport-
+            # aborted close; HTTPResponse only raises IncompleteRead
+            # in some configurations. When the origin declared
+            # Content-Length, treat that as the contract and refuse
+            # to promote a short blob. A silent partial-promotion
+            # would serve malformed bytes to every future consumer
+            # with no way for them to invalidate the entry.
+            if total is not None and size != total:
+                raise TruncatedDownload(
+                    f"upstream truncated for {url}: declared {total} bytes, got {size}"
+                )
             os.replace(tmp, self.blob_path(key))
         except BaseException:
             if os.path.exists(tmp):
@@ -369,6 +380,14 @@ class CacheFull(Exception):
     """Raised when --max-bytes is reached; the fill is refused, not evicted."""
 
 
+class TruncatedDownload(Exception):
+    """Raised when the upstream stream ended before the declared
+    Content-Length. The temp file is removed and no blob row is
+    written, so the same URL re-enqueues cleanly on the next request
+    instead of permanently serving a malformed file.
+    """
+
+
 @dataclass
 class Job:
     id: int

{withcache-0.4.0 → withcache-0.4.1}/tests/test_withcache.py

@@ -7,6 +7,7 @@ without an install.
 import http.server
 import os
 import shutil
+import socket
 import socketserver
 import sys
 import tempfile
@@ -167,6 +168,78 @@ class TestStoreFromOrigin(unittest.TestCase):
             store.store_from_origin(f"http://127.0.0.1:{self.port}/b.bin")
 
 
+class _TruncatingOrigin(http.server.BaseHTTPRequestHandler):
+    """Declare a full Content-Length, then send half the payload and
+    close the socket. Mirrors the real-world failure mode where the
+    upstream drops the connection mid-stream (lab-box fedora-44-desktop
+    flash that surfaced this bug)."""
+
+    PAYLOAD = b"abcdefghij" * 100  # 1000 bytes; will write half then close
+
+    def do_GET(self):
+        self.send_response(200)
+        self.send_header("Content-Type", "application/octet-stream")
+        self.send_header("Content-Length", str(len(self.PAYLOAD)))
+        self.end_headers()
+        half = len(self.PAYLOAD) // 2
+        self.wfile.write(self.PAYLOAD[:half])
+        # close the underlying socket so urllib observes EOF before
+        # Content-Length bytes arrive
+        self.wfile.flush()
+        try:
+            self.connection.shutdown(socket.SHUT_RDWR)
+        except OSError:
+            pass
+
+    def log_message(self, format, *args):
+        pass
+
+
+class TestTruncatedDownloadRejected(unittest.TestCase):
+    """Regression for the lab-spotted bug where a transport-aborted
+    upstream stream silently became a permanent cached blob: future
+    HEADs returned 200 with the partial bytes, every consumer got a
+    malformed file, and the only escape was hand-deleting the blob.
+    Content-Length mismatches now fail loudly and leave no entry."""
+
+    def setUp(self):
+        self.httpd = socketserver.TCPServer(("127.0.0.1", 0), _TruncatingOrigin)
+        self.port = self.httpd.server_address[1]
+        self.t = threading.Thread(target=self.httpd.serve_forever, daemon=True)
+        self.t.start()
+        self.store = server.Store(tempfile.mkdtemp(), keep_query=False)
+
+    def tearDown(self):
+        self.httpd.shutdown()
+        self.httpd.server_close()
+
+    def test_truncated_upstream_raises_and_leaves_no_blob(self):
+        url = f"http://127.0.0.1:{self.port}/truncated.bin"
+        with self.assertRaises(server.TruncatedDownload) as cm:
+            self.store.store_from_origin(url)
+        # the message must name both totals so the operator can see
+        # how short the upstream came
+        msg = str(cm.exception)
+        self.assertIn("1000", msg)  # declared
+        self.assertIn("500", msg)  # got
+        # no row was written; no blob file lingers on disk
+        self.assertIsNone(self.store.get_blob(url))
+        blobs = list(self.store.blob_path("").rsplit("/", 1)[0:1])
+        if os.path.isdir(blobs[0]):
+            self.assertEqual(os.listdir(blobs[0]), [])
+
+    def test_repeat_request_after_truncation_can_retry_cleanly(self):
+        url = f"http://127.0.0.1:{self.port}/truncated.bin"
+        with self.assertRaises(server.TruncatedDownload):
+            self.store.store_from_origin(url)
+        # second attempt against the same URL would have hit the
+        # poisoned cache before the fix; now it must repeat the
+        # failure mode (no sticky blob blocking the retry) so a
+        # later origin recovery can re-fill the entry cleanly.
+        with self.assertRaises(server.TruncatedDownload):
+            self.store.store_from_origin(url)
+
+
 # --------------------------------------------------------------------------
 # _shim: URL detection, rewrite, real-tool resolution, env, path-encoding
 # --------------------------------------------------------------------------