fixup! feat(core.utils): reject path-backed ObjectCode on read too

Author: cpcloud

cuda_core/cuda/core/utils/_program_cache.py

@@ -57,6 +57,18 @@
 _IS_WINDOWS = os.name == "nt"
 
 
+def _is_cacheable_object_code(value: object) -> bool:
+    """True iff ``value`` is a bytes-backed :class:`ObjectCode`.
+
+    Used by read paths to reject deserialized entries that would fail the
+    same check writes enforce: path-backed ``ObjectCode`` (where
+    ``value.code`` is a ``str`` path) pickles only the path, so reopening
+    an older cache or a manually-seeded entry could return stale or
+    missing on-disk content. Treat such entries as misses and prune.
+    """
+    return isinstance(value, ObjectCode) and not isinstance(value.code, str)
+
+
 def _require_object_code(value: object) -> ObjectCode:
     if not isinstance(value, ObjectCode):
         raise TypeError(f"cache values must be ObjectCode instances, got {type(value).__name__}")
@@ -961,7 +973,7 @@ def _load(self, key: object, *, touch_lru: bool) -> ObjectCode | None:
             except Exception:
                 conn.execute("DELETE FROM entries WHERE key = ?", (k,))
                 return None
-            if not isinstance(value, ObjectCode):
+            if not _is_cacheable_object_code(value):
                 conn.execute("DELETE FROM entries WHERE key = ?", (k,))
                 return None
             if touch_lru:
@@ -1014,7 +1026,7 @@ def __len__(self) -> int:
                 except Exception:
                     conn.execute("DELETE FROM entries WHERE key = ?", (k,))
                     continue
-                if not isinstance(value, ObjectCode):
+                if not _is_cacheable_object_code(value):
                     conn.execute("DELETE FROM entries WHERE key = ?", (k,))
                     continue
                 count += 1
@@ -1289,7 +1301,7 @@ def __getitem__(self, key: object) -> ObjectCode:
         except Exception:
             _prune_if_stat_unchanged(path, st_before)
             raise KeyError(key) from None
-        if not isinstance(value, ObjectCode):
+        if not _is_cacheable_object_code(value):
             _prune_if_stat_unchanged(path, st_before)
             raise KeyError(key) from None
         return value
@@ -1360,7 +1372,7 @@ def __len__(self) -> int:
             except Exception:
                 _prune_if_stat_unchanged(path, st_before)
                 continue
-            if not isinstance(value, ObjectCode):
+            if not _is_cacheable_object_code(value):
                 _prune_if_stat_unchanged(path, st_before)
                 continue
             count += 1

cuda_core/tests/test_program_cache.py

@@ -1179,6 +1179,41 @@ def test_sqlite_cache_rejects_path_backed_object_code(tmp_path):
         cache[b"k"] = path_backed
 
 
+@needs_sqlite3
+def test_sqlite_cache_treats_path_backed_payload_as_miss_and_prunes(tmp_path):
+    """An older version, a corrupt/injected entry, or a direct DB write may
+    leave a pickled path-backed ObjectCode on disk. Reopen must refuse to
+    surface it (pickling stores only the path, so the bytes would be stale
+    or missing) and prune the row so subsequent access doesn't re-hit."""
+    import pickle
+    import sqlite3
+    import time as _time
+
+    from cuda.core._module import ObjectCode
+    from cuda.core.utils import SQLiteProgramCache
+
+    db = tmp_path / "cache.db"
+    with SQLiteProgramCache(db):
+        pass  # materialise schema
+    path_backed = ObjectCode.from_cubin(str(tmp_path / "nonexistent.cubin"), name="x")
+    payload = pickle.dumps(path_backed)
+    now = _time.time()
+    conn = sqlite3.connect(db)
+    try:
+        conn.execute(
+            "INSERT INTO entries(key, payload, size_bytes, created_at, accessed_at) VALUES (?, ?, ?, ?, ?)",
+            (b"k", payload, len(payload), now, now),
+        )
+        conn.commit()
+    finally:
+        conn.close()
+
+    with SQLiteProgramCache(db) as cache:
+        assert cache.get(b"k") is None
+        assert b"k" not in cache
+        assert len(cache) == 0
+
+
 @needs_sqlite3
 def test_sqlite_cache_accepts_str_keys(tmp_path):
     from cuda.core.utils import SQLiteProgramCache
@@ -1694,6 +1729,33 @@ def test_filestream_cache_rejects_path_backed_object_code(tmp_path):
         cache[b"k"] = path_backed
 
 
+def test_filestream_cache_treats_path_backed_payload_as_miss_and_prunes(tmp_path):
+    """Same guarantee as the SQLite backend: a pickled path-backed ObjectCode
+    on disk (older version, corruption, direct injection) must not surface
+    on reopen, and the file must be pruned so it doesn't keep re-hitting."""
+    import pickle
+    import time as _time
+
+    from cuda.core._module import ObjectCode
+    from cuda.core.utils import FileStreamProgramCache
+    from cuda.core.utils._program_cache import _FILESTREAM_SCHEMA_VERSION
+
+    root = tmp_path / "fc"
+    with FileStreamProgramCache(root) as cache:
+        target = cache._path_for_key(b"k")
+    path_backed = ObjectCode.from_cubin(str(tmp_path / "nonexistent.cubin"), name="x")
+    payload = pickle.dumps(path_backed)
+    record = pickle.dumps((_FILESTREAM_SCHEMA_VERSION, b"k", payload, _time.time()))
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_bytes(record)
+
+    with FileStreamProgramCache(root) as cache:
+        assert cache.get(b"k") is None
+        assert b"k" not in cache
+        assert len(cache) == 0
+    assert not target.exists()
+
+
 def test_filestream_cache_rejects_negative_size_cap(tmp_path):
     from cuda.core.utils import FileStreamProgramCache