Completed for a grade of five
Skeleton contracts / contracts (pull_request) Canceled after 0s

This commit is contained in:
2026-10-09 11:50:01 +03:00
parent 1632fe4b16
commit dc5abb6fff
142 changed files with 8207 additions and 57 deletions
+167
View File
@@ -0,0 +1,167 @@
#!/usr/bin/env python3
"""Builds evidence/track1/summary.md from the raw results of run-all.sh."""
import csv
import glob
import json
import os
import re
import statistics
from datetime import datetime
ROOT = "evidence/track1"
def load_k6(path):
metrics = json.load(open(path))["metrics"]
duration = metrics["http_req_duration{phase:measure}"]["values"]
requests = metrics["http_reqs{phase:measure}"]["values"]["count"]
failed = metrics["http_req_failed{phase:measure}"]["values"]
return {
"requests": requests,
"failed": failed["passes"],
"p50": duration["med"],
"p95": duration["p(95)"],
"p99": duration["p(99)"],
"max": duration["max"],
}
def median_range(values, fmt="{:.0f}"):
values = [v for v in values if v is not None]
if not values:
return "—"
med = statistics.median(values)
if len(values) == 1:
return fmt.format(med)
return f"{fmt.format(med)} ({fmt.format(min(values))}–{fmt.format(max(values))})"
def stampede_rows():
runs = []
for run_dir in sorted(glob.glob(f"{ROOT}/stampede/*/*")):
run = json.load(open(f"{run_dir}/run.json"))
sessions, users, total = map(int, open(f"{run_dir}/sql-calls.csv").read().strip().split(","))
redis = dict(line.strip().split(":") for line in open(f"{run_dir}/redis-stats.txt") if ":" in line)
k6 = load_k6(f"{run_dir}/k6-summary.json")
runs.append({**run, **k6, "sessions": sessions, "users": users, "total_sql": total,
"misses": int(redis["keyspace_misses"]), "hits": int(redis["keyspace_hits"])})
with open(f"{ROOT}/stampede-runs.csv", "w", newline="") as f:
writer = csv.DictWriter(f, fieldnames=list(runs[0].keys()))
writer.writeheader()
writer.writerows(runs)
return runs
def stampede_table(runs):
lines = [
"| Сессий | Сбросов кэша | Single-flight | Запросов к `sessions` | на один сброс | на сессию за сброс | Промахов Redis | Всего SQL | RPS | p50 / p95 / p99, мс | max, мс | Ошибки |",
"| ---: | ---: | --- | ---: | ---: | ---: | ---: | ---: | ---: | --- | ---: | ---: |",
]
keys = sorted({(r["tokens"], r["flush_interval_s"], r["variant"]) for r in runs}, key=lambda k: (-k[1], -k[0], k[2]))
for tokens, flush, variant in keys:
group = [r for r in runs if (r["tokens"], r["flush_interval_s"], r["variant"]) == (tokens, flush, variant)]
flushes = group[0]["flushes"]
per_flush = [r["sessions"] / r["flushes"] for r in group] if flushes else [None]
per_session = [r["sessions"] / r["flushes"] / tokens for r in group] if flushes else [None]
lines.append(
f"| {tokens} | {flushes if flushes else 'нет'} | {'да' if variant == 'on' else 'нет'} "
f"| {median_range([r['sessions'] for r in group])} "
f"| {median_range(per_flush, '{:.1f}')} | {median_range(per_session, '{:.2f}')} "
f"| {median_range([r['misses'] for r in group])} | {median_range([r['total_sql'] for r in group])} "
f"| {median_range([r['requests'] / r['duration_s'] for r in group])} "
f"| {statistics.median(r['p50'] for r in group):.1f} / {statistics.median(r['p95'] for r in group):.1f} / "
f"{statistics.median(r['p99'] for r in group):.1f} "
f"| {median_range([r['max'] for r in group], '{:.0f}')} | {sum(r['failed'] for r in group)} |"
)
return lines
def parse_log_time(line):
stamp = line.split()[0]
return datetime.fromisoformat(stamp.replace("Z", "+00:00")).timestamp()
def restart_rows():
runs = []
for run_dir in sorted(glob.glob(f"{ROOT}/redis-restart/*/*")):
run = json.load(open(f"{run_dir}/run.json"))
k6 = load_k6(f"{run_dir}/k6-summary.json")
seconds = list(csv.DictReader(open(f"{run_dir}/per-second.csv")))
samples = list(csv.DictReader(open(f"{run_dir}/samples.csv")))
lookups = max(int(s["session_lookups_total"]) for s in samples if s["session_lookups_total"])
log = [line for line in open(f"{run_dir}/cache-availability.log")]
down = [parse_log_time(l) for l in log if "unavailable" in l and parse_log_time(l) >= run["measure_start"]]
up = [parse_log_time(l) for l in log if "available again" in l and parse_log_time(l) >= run["measure_start"]]
outage = (up[0] - down[0]) if down and up else None
restart_second = int(run["restart_begin"] - run["measure_start"])
window = [s for s in seconds if restart_second - 1 <= int(s["second"]) <= restart_second + 1 and s["p99_ms"]]
before = [s for s in seconds if int(s["second"]) < restart_second - 1 and s["p99_ms"]]
runs.append({
**run, **k6,
"session_lookups": lookups,
"cache_outage_s": outage,
"recovered_after_restart_s": (up[0] - run["restart_end"]) if up else None,
"restart_s": run["restart_end"] - run["restart_begin"],
"peak_p99_ms": max(float(s["p99_ms"]) for s in window),
"peak_max_ms": max(float(s["max_ms"]) for s in window),
"p99_before_ms": statistics.median(float(s["p99_ms"]) for s in before),
"non_200": sum(int(s["non_200"]) for s in seconds),
})
with open(f"{ROOT}/redis-restart-runs.csv", "w", newline="") as f:
writer = csv.DictWriter(f, fieldnames=list(runs[0].keys()))
writer.writeheader()
writer.writerows(runs)
return runs
def restart_table(runs):
lines = [
"| Single-flight | `docker compose restart redis`, с | Кэш недоступен по логу API, с | Запросов к `sessions` за прогон | p99 до рестарта, мс | p99 в секунду рестарта, мс | max в секунду рестарта, мс | Не 200 |",
"| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |",
]
for variant in ("off", "on"):
group = [r for r in runs if r["variant"] == variant]
if not group:
continue
lines.append(
f"| {'да' if variant == 'on' else 'нет'} | {median_range([r['restart_s'] for r in group], '{:.2f}')} "
f"| {median_range([r['cache_outage_s'] for r in group], '{:.2f}')} "
f"| {median_range([r['session_lookups'] for r in group])} "
f"| {median_range([r['p99_before_ms'] for r in group], '{:.0f}')} "
f"| {median_range([r['peak_p99_ms'] for r in group], '{:.0f}')} "
f"| {median_range([r['peak_max_ms'] for r in group], '{:.0f}')} | {sum(r['non_200'] for r in group)} |"
)
return lines
def read_after_write_table():
lines = [
"| Single-flight | Redis | Итераций | Первый запрос после входа не 200 | Запросов до ответа logout | Запросов после ответа logout | Из них 200 (нарушение) | Другие коды | Токен жив через 1 с |",
"| --- | --- | ---: | ---: | ---: | ---: | ---: | --- | ---: |",
]
for path in sorted(glob.glob(f"{ROOT}/read-after-write/*.json")):
variant, redis = re.match(r".*/(on|off)_redis-(up|down)\.json", path).groups()
d = json.load(open(path))
lines.append(
f"| {'да' if variant == 'on' else 'нет'} | {'работает' if redis == 'up' else 'остановлен'} | {d['iterations']} "
f"| {d['first_request_after_login_not_200']} | {d['requests_started_before_logout_response']} "
f"| {d['requests_started_after_logout_response']} | {d['violations_200_after_logout']} "
f"| {d['unexpected_statuses'] or 'нет'} | {d['token_alive_one_second_later']} |"
)
return lines
def main():
out = ["# Track 1 summary", "", "Generated by `python3 scripts/track1/aggregate.py`. Medians of the repeats, (min–max) in brackets.", ""]
if os.path.isdir(f"{ROOT}/stampede"):
out += ["## Cache stampede: FLUSHALL every second under 200 VUs", ""] + stampede_table(stampede_rows()) + [""]
if os.path.isdir(f"{ROOT}/redis-restart"):
out += ["## Redis restart under 200 VUs, 50 sessions", ""] + restart_table(restart_rows()) + [""]
if os.path.isdir(f"{ROOT}/read-after-write"):
out += ["## Read-after-write of login and logout, 16 concurrent readers", ""] + read_after_write_table() + [""]
open(f"{ROOT}/summary.md", "w").write("\n".join(out))
print("\n".join(out))
if __name__ == "__main__":
main()
+39
View File
@@ -0,0 +1,39 @@
#!/usr/bin/env python3
"""Reduces a k6 CSV of single requests to per-second numbers of the measure phase:
second, requests, non-200 responses, p50/p99/max latency in ms."""
import csv
import math
import sys
from collections import defaultdict
def percentile(values, q):
values = sorted(values)
return values[min(len(values) - 1, int(q * len(values)))]
def main():
path, measure_start, duration = sys.argv[1], float(sys.argv[2]), int(sys.argv[3])
durations = defaultdict(list)
failures = defaultdict(int)
statuses = {}
with open(path) as f:
for row in csv.DictReader(f):
if row["metric_name"] == "http_req_duration":
second = math.floor(float(row["timestamp"]) / 1000 - measure_start)
if 0 <= second < duration:
durations[second].append(float(row["metric_value"]))
if row.get("status") != "200":
failures[second] += 1
print("second,requests,non_200,p50_ms,p99_ms,max_ms")
for second in range(duration):
values = durations.get(second, [])
if not values:
print(f"{second},0,0,,,")
continue
print(f"{second},{len(values)},{failures[second]},{percentile(values, 0.5):.2f},"
f"{percentile(values, 0.99):.2f},{max(values):.2f}")
if __name__ == "__main__":
main()
+42
View File
@@ -0,0 +1,42 @@
#!/usr/bin/env python3
"""Registers N synthetic users, opens one session each and writes the tokens, one per line, to a file.
The file holds live credentials of synthetic users only; the caller keeps it outside the repository
(mode 600) and deletes it after the run.
"""
import base64
import json
import os
import sys
import urllib.request
import uuid
PASSWORD = "track1-stampede-password"
def request(method, url, body=None, headers=None):
data = json.dumps(body).encode() if body is not None else None
req = urllib.request.Request(url, data=data, method=method, headers=headers or {})
if data is not None:
req.add_header("Content-Type", "application/json")
with urllib.request.urlopen(req, timeout=10) as response:
return json.load(response)
def main():
base_url, count, path = sys.argv[1], int(sys.argv[2]), sys.argv[3]
tokens = []
for i in range(count):
username = f"t1_{uuid.uuid4().hex[:12]}"
request("POST", f"{base_url}/api/v1/users",
{"username": username, "display_name": f"Stampede {i}", "password": PASSWORD})
basic = base64.b64encode(f"{username}:{PASSWORD}".encode()).decode()
session = request("POST", f"{base_url}/api/v1/auth/sessions", headers={"Authorization": f"Basic {basic}"})
tokens.append(session["token"])
fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
with os.fdopen(fd, "w") as f:
f.write("\n".join(tokens) + "\n")
if __name__ == "__main__":
main()
+34
View File
@@ -0,0 +1,34 @@
#!/bin/sh
# Read-after-write of login/logout under concurrent readers, see read_after_write.py.
# VARIANT=off|on (single-flight), REDIS=up|down, ITERATIONS, READERS
set -eu
cd "$(dirname "$0")/../.."
VARIANT=${VARIANT:?set VARIANT=off or VARIANT=on}
REDIS=${REDIS:-up}
ITERATIONS=${ITERATIONS:-300}
READERS=${READERS:-16}
BASE_URL=${BASE_URL:-http://localhost:8080}
case "$VARIANT" in
off) SINGLE_FLIGHT=false ;;
on) SINGLE_FLIGHT=true ;;
*) echo "VARIANT must be off or on" >&2; exit 2 ;;
esac
OUT="evidence/track1/read-after-write"
mkdir -p "$OUT"
SESSION_CACHE_SINGLE_FLIGHT=$SINGLE_FLIGHT docker compose up -d --force-recreate --wait api >/dev/null 2>&1
if [ "$REDIS" = "down" ]; then
docker compose stop redis >/dev/null 2>&1
fi
python3 scripts/track1/read_after_write.py "$BASE_URL" "$ITERATIONS" "$READERS" > "$OUT/${VARIANT}_redis-${REDIS}.json"
if [ "$REDIS" = "down" ]; then
docker compose up -d --wait redis >/dev/null 2>&1
fi
echo "$OUT/${VARIANT}_redis-${REDIS}.json"
cat "$OUT/${VARIANT}_redis-${REDIS}.json"
+121
View File
@@ -0,0 +1,121 @@
#!/usr/bin/env python3
"""Read-after-write of sessions under concurrency.
Every iteration logs in (fresh token, cold cache), checks that the very first request with the token succeeds,
starts READERS threads that call GET /users/me in a loop and logs out after a random 0-20 ms, i.e. while the
first cache fills race with the revocation. A violation is a 200 for a request that started after the client
had received the 204 of the logout. One second later the token is checked again: a stale cached copy must not
bring it back. Prints a JSON summary; tokens are never printed.
"""
import base64
import http.client
import json
import random
import sys
import threading
import time
import urllib.parse
import uuid
PASSWORD = "track1-read-after-write"
class Client:
def __init__(self, base_url):
url = urllib.parse.urlparse(base_url)
self.connection = http.client.HTTPConnection(url.hostname, url.port, timeout=10)
def call(self, method, path, headers=None, body=None):
self.connection.request(method, path, body=body, headers=headers or {})
response = self.connection.getresponse()
data = response.read()
return response.status, data
def main():
base_url, iterations, readers = sys.argv[1], int(sys.argv[2]), int(sys.argv[3])
rng = random.Random(42)
setup = Client(base_url)
username = f"raw_{uuid.uuid4().hex[:12]}"
status, _ = setup.call("POST", "/api/v1/users", {"Content-Type": "application/json"},
json.dumps({"username": username, "display_name": "RAW", "password": PASSWORD}))
assert status == 201, status
basic = "Basic " + base64.b64encode(f"{username}:{PASSWORD}".encode()).decode()
reader_clients = [Client(base_url) for _ in range(readers)]
revoked = []
totals = {
"iterations": iterations, "readers": readers,
"first_request_after_login_not_200": 0,
"requests_started_before_logout_response": 0,
"requests_started_after_logout_response": 0,
"violations_200_after_logout": 0,
"unexpected_statuses": {},
"token_alive_one_second_later": 0,
"logout_not_204": 0,
}
for _ in range(iterations):
status, body = setup.call("POST", "/api/v1/auth/sessions", {"Authorization": basic})
assert status == 201, status
bearer = {"Authorization": "Bearer " + json.loads(body)["token"]}
# Read-after-write of the login itself: no negative caching, the token works immediately.
status, _ = setup.call("GET", "/api/v1/users/me", bearer)
if status != 200:
totals["first_request_after_login_not_200"] += 1
# The check above filled the cache; start the race from a cold key with a new session.
status, body = setup.call("POST", "/api/v1/auth/sessions", {"Authorization": basic})
assert status == 201, status
bearer = {"Authorization": "Bearer " + json.loads(body)["token"]}
stop = threading.Event()
results = []
lock = threading.Lock()
def read(client):
while not stop.is_set():
started = time.monotonic()
status, _ = client.call("GET", "/api/v1/users/me", bearer)
with lock:
results.append((started, status))
threads = [threading.Thread(target=read, args=(c,)) for c in reader_clients]
for t in threads:
t.start()
time.sleep(rng.uniform(0, 0.02))
status, _ = setup.call("DELETE", "/api/v1/auth/sessions/current", bearer)
logout_done = time.monotonic()
if status != 204:
totals["logout_not_204"] += 1
time.sleep(0.1)
stop.set()
for t in threads:
t.join()
for started, status in results:
if started > logout_done:
totals["requests_started_after_logout_response"] += 1
if status == 200:
totals["violations_200_after_logout"] += 1
elif status != 401:
key = str(status)
totals["unexpected_statuses"][key] = totals["unexpected_statuses"].get(key, 0) + 1
else:
totals["requests_started_before_logout_response"] += 1
revoked.append(bearer)
# Late check, one second after the last logout at the earliest: nothing cached resurrects a revoked token.
time.sleep(1)
for bearer in revoked:
status, _ = setup.call("GET", "/api/v1/users/me", bearer)
if status == 200:
totals["token_alive_one_second_later"] += 1
print(json.dumps(totals, indent=2))
if __name__ == "__main__":
main()
+89
View File
@@ -0,0 +1,89 @@
#!/bin/sh
# Cache restart under load: the same k6 load as stampede.sh, but instead of FLUSHALL the Redis container is
# restarted RESTART_AT_S seconds into the measure phase. Every second the script samples session lookups in
# pg_stat_statements and Redis keyspace hits/misses, k6 writes every request to a CSV that is reduced to
# per-second numbers afterwards.
# VARIANT=off|on, TOKENS, VUS, WARMUP_S, DURATION_S, RESTART_AT_S, REPEAT
set -eu
cd "$(dirname "$0")/../.."
VARIANT=${VARIANT:?set VARIANT=off or VARIANT=on}
TOKENS=${TOKENS:-50}
VUS=${VUS:-200}
WARMUP_S=${WARMUP_S:-5}
DURATION_S=${DURATION_S:-30}
RESTART_AT_S=${RESTART_AT_S:-10}
REPEAT=${REPEAT:-1}
BASE_URL=${BASE_URL:-http://localhost:8080}
case "$VARIANT" in
off) SINGLE_FLIGHT=false ;;
on) SINGLE_FLIGHT=true ;;
*) echo "VARIANT must be off or on" >&2; exit 2 ;;
esac
OUT="evidence/track1/redis-restart/$VARIANT/t${TOKENS}_r${REPEAT}"
mkdir -p "$OUT"
WORK=$(mktemp -d)
[ -z "${KEEP_WORK:-}" ] || echo "work dir: $WORK"
trap '[ -n "${KEEP_WORK:-}" ] || rm -rf "$WORK"' EXIT
redis() { docker compose exec -T -e REDISCLI_AUTH="$(cat secrets/redis_password)" redis redis-cli "$@"; }
psql_() { docker compose exec -T postgres psql -U messenger -d messenger -X -q -At "$@"; }
SESSION_CACHE_SINGLE_FLIGHT=$SINGLE_FLIGHT docker compose up -d --force-recreate --wait api >/dev/null 2>&1
test "$(docker compose exec -T api printenv SESSION_CACHE_SINGLE_FLIGHT)" = "$SINGLE_FLIGHT"
python3 scripts/track1/prepare_sessions.py "$BASE_URL" "$TOKENS" "$WORK/tokens"
psql_ -c "CREATE EXTENSION IF NOT EXISTS pg_stat_statements" >/dev/null 2>&1
K6_CSV_TIME_FORMAT=unix_milli k6 run --quiet --no-usage-report \
-e BASE_URL="$BASE_URL" -e VUS="$VUS" -e WARMUP_S="$WARMUP_S" -e DURATION_S="$DURATION_S" \
-e TOKENS_FILE="$WORK/tokens" -e SUMMARY_FILE="$OUT/k6-summary.json" \
--out csv="$WORK/requests.csv" \
scripts/track1/stampede.js > "$OUT/k6.log" 2>&1 &
K6_PID=$!
sleep "$WARMUP_S"
psql_ -c "SELECT pg_stat_statements_reset()" >/dev/null
MEASURE_START=$(python3 -c 'import time; print(time.time())')
sample() {
lookups=$(psql_ -c "SELECT coalesce(sum(calls), 0) FROM pg_stat_statements WHERE query ILIKE '%FROM sessions WHERE%'" 2>/dev/null || echo "")
stats=$(redis INFO stats 2>/dev/null | tr -d '\r' | grep -E '^keyspace_(hits|misses):' | cut -d: -f2 | tr '\n' ',' || true)
echo "$(python3 -c 'import time; print(round(time.time(), 3))'),$lookups,$stats"
}
echo "unix_time,session_lookups_total,redis_hits_total,redis_misses_total," > "$OUT/samples.csv"
MEASURE_END=$(python3 -c "print($MEASURE_START + $DURATION_S)")
(
# Paced by the clock: one docker exec pair takes a noticeable part of a second.
next=$MEASURE_START
while python3 -c "import sys, time; sys.exit(0 if time.time() < $MEASURE_END else 1)"; do
sample >> "$OUT/samples.csv"
next=$(python3 -c "print($next + 1)")
python3 -c "import time; time.sleep(max(0, $next - time.time()))"
done
) &
SAMPLER_PID=$!
sleep "$RESTART_AT_S"
RESTART_BEGIN=$(python3 -c 'import time; print(time.time())')
docker compose restart redis >/dev/null 2>&1
RESTART_END=$(python3 -c 'import time; print(time.time())')
wait "$SAMPLER_PID"
wait "$K6_PID"
docker compose logs --no-log-prefix --since 2m api 2>&1 | grep -E "Session cache is (unavailable|available again)" > "$OUT/cache-availability.log" || true
python3 scripts/track1/per_second.py "$WORK/requests.csv" "$MEASURE_START" "$DURATION_S" > "$OUT/per-second.csv"
cat > "$OUT/run.json" <<JSON
{"variant": "$VARIANT", "single_flight": $SINGLE_FLIGHT, "tokens": $TOKENS, "vus": $VUS,
"warmup_s": $WARMUP_S, "duration_s": $DURATION_S, "measure_start": $MEASURE_START,
"restart_begin": $RESTART_BEGIN, "restart_end": $RESTART_END, "repeat": $REPEAT,
"finished_at": "$(date -u +%FT%TZ)"}
JSON
echo "$OUT: restart took $(python3 -c "print(round($RESTART_END - $RESTART_BEGIN, 2))") s"
+40
View File
@@ -0,0 +1,40 @@
#!/bin/sh
# Full track 1 matrix. Repeats go round-robin over all combinations, so a slow drift of the laptop does not
# land on one variant. Takes about 25 minutes.
set -eu
cd "$(dirname "$0")/../.."
rm -rf evidence/track1
docker compose build -q api
for repeat in 1 2 3; do
for tokens in 50 10; do
for variant in off on; do
VARIANT=$variant TOKENS=$tokens REPEAT=$repeat ./scripts/track1/stampede.sh
done
done
for variant in off on; do
VARIANT=$variant REPEAT=$repeat ./scripts/track1/redis-restart.sh
done
done
# Two more cache restarts: a single failed request per restart is what the first version of this
# experiment caught, so the restart gets more repeats than the rest.
for repeat in 4 5; do
for variant in off on; do
VARIANT=$variant REPEAT=$repeat ./scripts/track1/redis-restart.sh
done
done
# Reference without any cache invalidation: how many lookups a warm cache leaves.
for variant in off on; do
VARIANT=$variant TOKENS=50 FLUSH_INTERVAL_S=0 REPEAT=1 ./scripts/track1/stampede.sh
done
for variant in off on; do
for redis in up down; do
VARIANT=$variant REDIS=$redis ./scripts/track1/read-after-write.sh > /dev/null
done
done
SESSION_CACHE_SINGLE_FLIGHT=true docker compose up -d --force-recreate --wait api >/dev/null 2>&1
python3 scripts/track1/aggregate.py
+41
View File
@@ -0,0 +1,41 @@
// Closed-loop load on GET /api/v1/users/me: every VU reuses one of TOKENS sessions, so VUS / TOKENS requests
// per session are in flight at any moment. The shell script empties Redis once a second during the measure phase.
import http from 'k6/http';
import { check } from 'k6';
import exec from 'k6/execution';
const BASE_URL = __ENV.BASE_URL || 'http://localhost:8080';
const VUS = Number(__ENV.VUS || 200);
const WARMUP_S = Number(__ENV.WARMUP_S || 5);
const DURATION_S = Number(__ENV.DURATION_S || 30);
const tokens = open(__ENV.TOKENS_FILE).split('\n').filter((line) => line.length > 0);
export const options = {
discardResponseBodies: true,
// One scenario for warm-up and measurement: the VUs keep their keep-alive connections, so the measure phase
// does not start with 200 fresh TCP connects through the Docker port forward.
scenarios: {
load: { executor: 'constant-vus', vus: VUS, duration: `${WARMUP_S + DURATION_S}s` },
},
summaryTrendStats: ['avg', 'med', 'p(95)', 'p(99)', 'max'],
thresholds: {
// Thresholds only make k6 report the measure-phase submetrics; they never fail the run.
'http_req_duration{phase:measure}': ['max>=0'],
'http_reqs{phase:measure}': ['count>=0'],
'http_req_failed{phase:measure}': ['rate>=0'],
},
};
export default function () {
const token = tokens[(__VU - 1) % tokens.length];
const phase = Date.now() - exec.scenario.startTime < WARMUP_S * 1000 ? 'warmup' : 'measure';
const response = http.get(`${BASE_URL}/api/v1/users/me`, {
headers: { Authorization: `Bearer ${token}` },
tags: { phase },
});
check(response, { 'status is 200': (r) => r.status === 200 });
}
export function handleSummary(data) {
return { [__ENV.SUMMARY_FILE]: JSON.stringify(data, null, 2) };
}
+83
View File
@@ -0,0 +1,83 @@
#!/bin/sh
# One stampede run against the Compose stack.
# VARIANT=off|on single-flight disabled / enabled (SESSION_CACHE_SINGLE_FLIGHT)
# TOKENS distinct sessions shared by the VUs
# VUS, WARMUP_S, DURATION_S, FLUSH_INTERVAL_S (0 = never flush), REPEAT
# Results go to evidence/track1/stampede/<variant>/t<TOKENS>_f<FLUSH>_r<REPEAT>/.
set -eu
cd "$(dirname "$0")/../.."
VARIANT=${VARIANT:?set VARIANT=off or VARIANT=on}
TOKENS=${TOKENS:-50}
VUS=${VUS:-200}
WARMUP_S=${WARMUP_S:-5}
DURATION_S=${DURATION_S:-30}
FLUSH_INTERVAL_S=${FLUSH_INTERVAL_S:-1}
REPEAT=${REPEAT:-1}
BASE_URL=${BASE_URL:-http://localhost:8080}
case "$VARIANT" in
off) SINGLE_FLIGHT=false ;;
on) SINGLE_FLIGHT=true ;;
*) echo "VARIANT must be off or on" >&2; exit 2 ;;
esac
OUT="evidence/track1/stampede/$VARIANT/t${TOKENS}_f${FLUSH_INTERVAL_S}_r${REPEAT}"
mkdir -p "$OUT"
TOKENS_FILE=$(mktemp)
trap 'rm -f "$TOKENS_FILE"' EXIT
redis() { docker compose exec -T -e REDISCLI_AUTH="$(cat secrets/redis_password)" redis redis-cli "$@"; }
psql_() { docker compose exec -T postgres psql -U messenger -d messenger -X -q -At "$@"; }
# Fresh API process for every run, same image, only the flag differs.
SESSION_CACHE_SINGLE_FLIGHT=$SINGLE_FLIGHT docker compose up -d --force-recreate --wait api >/dev/null 2>&1
test "$(docker compose exec -T api printenv SESSION_CACHE_SINGLE_FLIGHT)" = "$SINGLE_FLIGHT"
python3 scripts/track1/prepare_sessions.py "$BASE_URL" "$TOKENS" "$TOKENS_FILE"
psql_ -c "CREATE EXTENSION IF NOT EXISTS pg_stat_statements" >/dev/null 2>&1
k6 run --quiet --no-usage-report \
-e BASE_URL="$BASE_URL" -e VUS="$VUS" -e WARMUP_S="$WARMUP_S" -e DURATION_S="$DURATION_S" \
-e TOKENS_FILE="$TOKENS_FILE" -e SUMMARY_FILE="$OUT/k6-summary.json" \
scripts/track1/stampede.js > "$OUT/k6.log" 2>&1 &
K6_PID=$!
sleep "$WARMUP_S"
psql_ -c "SELECT pg_stat_statements_reset()" >/dev/null
redis CONFIG RESETSTAT >/dev/null
FLUSHES=0
if [ "$FLUSH_INTERVAL_S" -gt 0 ]; then
FLUSHES=$((DURATION_S / FLUSH_INTERVAL_S))
# The loop runs inside the Redis container, so the interval is not stretched by docker exec latency.
docker compose exec -T -e REDISCLI_AUTH="$(cat secrets/redis_password)" -e N="$FLUSHES" -e I="$FLUSH_INTERVAL_S" redis \
sh -c 'i=0; while [ $i -lt $N ]; do sleep $I; redis-cli FLUSHALL >/dev/null; i=$((i+1)); done'
else
sleep "$DURATION_S"
fi
wait "$K6_PID"
psql_ -F ',' -c "
SELECT coalesce(sum(calls) FILTER (WHERE query ILIKE '%FROM sessions WHERE%'), 0),
coalesce(sum(calls) FILTER (WHERE query ILIKE '%FROM users WHERE%'), 0),
coalesce(sum(calls), 0)
FROM pg_stat_statements
WHERE dbid = (SELECT oid FROM pg_database WHERE datname = 'messenger')
AND query NOT ILIKE '%pg_stat_statements%'" > "$OUT/sql-calls.csv"
psql_ -c "
SELECT calls, round(total_exec_time::numeric, 1) AS total_ms, left(regexp_replace(query, '\s+', ' ', 'g'), 120)
FROM pg_stat_statements
WHERE dbid = (SELECT oid FROM pg_database WHERE datname = 'messenger') AND query NOT ILIKE '%pg_stat_statements%'
ORDER BY calls DESC LIMIT 10" > "$OUT/top-queries.txt"
redis INFO stats | tr -d '\r' | grep -E '^keyspace_(hits|misses):' > "$OUT/redis-stats.txt"
cat > "$OUT/run.json" <<JSON
{"variant": "$VARIANT", "single_flight": $SINGLE_FLIGHT, "tokens": $TOKENS, "vus": $VUS,
"warmup_s": $WARMUP_S, "duration_s": $DURATION_S, "flush_interval_s": $FLUSH_INTERVAL_S, "flushes": $FLUSHES,
"repeat": $REPEAT, "finished_at": "$(date -u +%FT%TZ)"}
JSON
echo "$OUT: sql(sessions,users,total)=$(cat "$OUT/sql-calls.csv") $(tr '\n' ' ' < "$OUT/redis-stats.txt")"