feat: second lab
Skeleton contracts / contracts (pull_request) Canceled after 0s

This commit is contained in:
yurtaev.va
2026-10-23 18:39:11 +03:00
parent 65003b6119
commit 0f8dc7a6e4
18 changed files with 1151 additions and 29 deletions
+116
View File
@@ -0,0 +1,116 @@
#!/usr/bin/env python3
"""Reproducible isolated Compose experiment for track 1."""
import base64
import concurrent.futures
import json
import math
import os
import statistics
import subprocess
import time
import urllib.request
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
BASE = os.environ.get("BASE_URL", "http://localhost:8080")
def compose(*args, env=None):
return subprocess.run(["docker", "compose", "--env-file", ".env", *args], cwd=ROOT, env=env, check=True, capture_output=True, text=True).stdout
def api(method, path, token=None, data=None, extra=None):
headers = {"Accept": "application/json"}
if token:
headers["Authorization"] = "Bearer " + token
if data is not None:
headers["Content-Type"] = "application/json"
headers.update(extra or {})
raw = json.dumps(data).encode() if data is not None else None
request = urllib.request.Request(BASE + path, method=method, headers=headers, data=raw)
start = time.perf_counter()
with urllib.request.urlopen(request, timeout=10) as response:
payload = json.loads(response.read())
return payload, (time.perf_counter() - start) * 1000
def metrics():
code = "import json,urllib.request; print(urllib.request.urlopen('http://127.0.0.1:8080/internal/cache-metrics').read().decode())"
return json.loads(compose("exec", "-T", "api", "python", "-c", code))
def run_batch(path, token, count=32):
with concurrent.futures.ThreadPoolExecutor(max_workers=count) as workers:
results = list(workers.map(lambda _: api("GET", path, token), range(count)))
assert all(item[0] == results[0][0] for item in results)
times = sorted(item[1] for item in results)
return {"requests": count, "p50_ms": round(statistics.median(times), 2), "p95_ms": round(times[math.ceil(count * 0.95) - 1], 2), "p99_ms": round(times[-1], 2)}
def restart_api(cache_enabled, lock_enabled):
env = dict(os.environ, CACHE_ENABLED="1" if cache_enabled else "0",
CACHE_LOCK_ENABLED="1" if lock_enabled else "0",
CACHE_MISS_DELAY_MS="150", ENABLE_EXPERIMENT_METRICS="1")
compose("up", "-d", "--force-recreate", "--wait", "api", env=env)
def main():
username = "experiment_" + uuid.uuid4().hex[:12]
password = "synthetic-" + uuid.uuid4().hex
account, _ = api("POST", "/api/v1/users", data={"username": username, "display_name": "Experiment", "password": password})
basic = base64.b64encode((username + ":" + password).encode()).decode()
session, _ = api("POST", "/api/v1/auth/sessions", extra={"Authorization": "Basic " + basic})
token = session["token"]
chat, _ = api("POST", "/api/v1/chats", token, {"title": "Cache experiment", "member_ids": [account["id"]]})
chat_id = chat["id"]
# Synthetic seed in one transaction; the same indexed data serves both modes.
sql = ("BEGIN; INSERT INTO messages(id,chat_id,sender_id,text) "
f"SELECT gen_random_uuid(),'{chat_id}'::uuid,'{account['id']}'::uuid,'seed-'||g "
"FROM generate_series(1,10000) g; "
f"UPDATE chat_versions SET version=version+1 WHERE chat_id='{chat_id}'; COMMIT;")
compose("exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-c", sql)
explain_sql = ("EXPLAIN (ANALYZE, BUFFERS) SELECT id,chat_id,sender_id,text,created_at "
f"FROM messages WHERE chat_id='{chat_id}' ORDER BY created_at,id LIMIT 101;")
compose("exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-c", "ANALYZE messages;")
plan = compose("exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-c", explain_sql)
(ROOT / "evidence" / "history_explain.txt").write_text(explain_sql + "\n\n" + plan)
path = f"/api/v1/chats/{chat_id}/messages?limit=100"
result = {"seed_messages": 10000, "concurrency": 32, "cache_miss_delay_ms": 150, "modes": {}}
for label, cache_enabled, lock_enabled in (("cache_off", False, False), ("cache_unlocked", True, False), ("cache_locked", True, True)):
restart_api(cache_enabled, lock_enabled)
compose("exec", "-T", "redis", "redis-cli", "FLUSHDB")
before = metrics()
cold = run_batch(path, token)
middle = metrics()
warm = run_batch(path, token)
after = metrics()
result["modes"][label] = {
"cold": cold, "warm": warm,
"cold_history_sql": middle["history_sql"] - before["history_sql"],
"warm_history_sql": after["history_sql"] - middle["history_sql"],
"cold_cache_hits": middle["history_cache_hit"] - before["history_cache_hit"],
"cold_lock_waits": middle["history_lock_wait"] - before["history_lock_wait"],
}
# A write changes the database version in the same transaction as the message.
fresh, _ = api("POST", "/api/v1/chats", token, {"title": "Consistency probe", "member_ids": [account["id"]]})
fresh_path = f"/api/v1/chats/{fresh['id']}/messages?limit=100"
api("GET", fresh_path, token) # cache an empty page
new, _ = api("POST", f"/api/v1/chats/{fresh['id']}/messages", token, {"text": "read after write"})
after = api("GET", fresh_path, token)[0]
result["read_after_write"] = any(item["id"] == new["id"] for item in after["items"])
# The first page is restored from PostgreSQL after the disposable cache restarts.
compose("restart", "redis")
recovered = api("GET", fresh_path, token)[0]
result["cache_restart_recovered"] = any(item["id"] == new["id"] for item in recovered["items"])
assert result["read_after_write"] and result["cache_restart_recovered"]
output = ROOT / "evidence" / os.environ.get("EVIDENCE_OUTPUT", "cache_experiment.json")
output.write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n")
print(output)
print(json.dumps(result, ensure_ascii=False, indent=2))
if __name__ == "__main__":
main()
+49
View File
@@ -0,0 +1,49 @@
#!/usr/bin/env python3
"""Offline lint for this small Python project: syntax, whitespace, unused imports."""
import ast
from pathlib import Path
import sys
ROOT = Path(__file__).resolve().parents[1]
FILES = [ROOT / "app/main.py", ROOT / "scripts/cache_experiment.py", ROOT / "scripts/lint.py", ROOT / "tests/level4.py"]
def check(path):
source = path.read_text()
issues = []
try:
tree = ast.parse(source, filename=str(path))
except SyntaxError as error:
return [f"{path}:{error.lineno}: {error.msg}"]
used = {node.id for node in ast.walk(tree) if isinstance(node, ast.Name)}
for node in ast.walk(tree):
if isinstance(node, ast.Import):
imports = [(item.asname or item.name.split(".")[0], node.lineno) for item in node.names]
elif isinstance(node, ast.ImportFrom):
imports = [(item.asname or item.name, node.lineno) for item in node.names]
else:
continue
for name, line in imports:
if name not in used:
issues.append(f"{path}:{line}: unused import {name}")
for number, line in enumerate(source.splitlines(), 1):
if line.rstrip() != line:
issues.append(f"{path}:{number}: trailing whitespace")
if "\t" in line:
issues.append(f"{path}:{number}: tab character")
return issues
def main():
issues = [issue for path in FILES for issue in check(path)]
if issues:
print("\n".join(issues))
return 1
print(f"PASS: lint ({len(FILES)} Python files)")
return 0
if __name__ == "__main__":
sys.exit(main())
+5
View File
@@ -0,0 +1,5 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose --env-file .env stop api redis postgres
docker compose --env-file .env up -d --wait postgres redis api