Files
mtusi2026lab2/scripts/research_cache.py
T

119 lines
4.9 KiB
Python

"""Isolated before/after session-cache experiment; never used by the API.
Run against a local test database and Valkey. Creates and removes its own users.
The baseline reproduces the former two-read algorithm accepting cached identity.
"""
import json
import statistics
import sys
import threading
import time
import uuid
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from unittest.mock import patch
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from app import Store
def main():
store = Store()
store.pool.open(wait=True)
store.init()
cache = store.cache_client()
users, tokens = [], []
try:
for _ in range(2):
users.append(store.insert_user("research_" + uuid.uuid4().hex[:16], "Research", "research-password"))
result = store.create_session(users[0]["id"], users[0]["username"])
token = result["token"]
tokens.append(token)
with store.connect() as conn:
canonical = store.fetch_session_by_token(token, conn)
forged = dict(canonical, user_id=users[1]["id"], user=users[1])
def baseline():
# Former algorithm: DB validity does not authenticate cached fields.
with store.connect() as conn:
db_session = store.fetch_session_by_token(token, conn)
if not store.is_session_valid(db_session):
return None
payload = cache.get(f"session:{token}")
if payload:
cached = json.loads(payload)
if store.is_session_valid(cached):
again = store.fetch_session_by_token(token, conn)
if store.is_session_valid(again):
return cached
store.cache_session(db_session)
return db_session
outputs = {}
for name, read in (("before", baseline), ("after", lambda: store.get_session_by_token(token))):
store.cache_session(canonical)
count = 0
original = store.fetch_session_by_token
def counted(*args, **kwargs):
nonlocal count
count += 1
return original(*args, **kwargs)
latencies = []
with patch.object(store, "fetch_session_by_token", side_effect=counted):
for _ in range(100):
start = time.perf_counter()
assert read()["user_id"] == users[0]["id"]
latencies.append((time.perf_counter() - start) * 1000)
# Force a cache writer between the DB read and cache read.
db_read, writer_done = threading.Event(), threading.Event()
first = True
def interleaved(*args, **kwargs):
nonlocal first
session = original(*args, **kwargs)
if first:
first = False
db_read.set()
if not writer_done.wait(5):
raise AssertionError("cache writer timed out")
return session
def writer():
if not db_read.wait(5):
raise AssertionError("DB reader timed out")
try:
cache.setex(f"session:{token}", 60, json.dumps(forged))
finally:
writer_done.set()
with ThreadPoolExecutor(max_workers=1) as executor:
future = executor.submit(writer)
with patch.object(store, "fetch_session_by_token", side_effect=interleaved):
observed = read()
future.result()
outputs[name] = {
"requests": 100, "session_selects": count,
"mean_ms": round(statistics.mean(latencies), 3),
"p95_ms": round(sorted(latencies)[94], 3),
"concurrent_wrong_identity": observed["user_id"] != users[0]["id"],
}
# A cache restart/flush is a miss; delete only our key on shared fixtures.
cache.delete(f"session:{token}")
assert store.get_session_by_token(token)["user_id"] == users[0]["id"]
assert cache.exists(f"session:{token}")
assert outputs["before"]["concurrent_wrong_identity"]
assert not outputs["after"]["concurrent_wrong_identity"]
assert outputs["after"]["session_selects"] == 100
print(json.dumps({"results": outputs, "cache_miss_recovered": True,
"limitations": "Local sequential Store benchmark, warm DB; deterministic interleaving; baseline is former algorithm, not a deployed insecure API. No host-failure or HTTP throughput claim."}, indent=2))
finally:
for token in tokens:
store.delete_cached_session(token)
with store.connect() as conn:
for user in users:
conn.execute("DELETE FROM users WHERE id = %s", (user["id"],))
store.pool.close()
if __name__ == "__main__":
main()