forked from mtusi2026/mtusi2026lab2
119 lines
4.9 KiB
Python
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()
|