forked from mtusi2026/mtusi2026lab2
реализация второй лабы
This commit is contained in:
@@ -0,0 +1,12 @@
|
||||
# Трек 2 на оценку 5
|
||||
|
||||
Запуск из корня: `./scripts/research.sh`. Нужны Docker Compose, Python 3 и интернет для первой сборки. Скрипт собирает API-образ и использует отдельный Compose project с новыми volumes. Текущий стенд не участвует.
|
||||
|
||||
- run.py управляет контейнерами, pg_dump, pg_restore, файлами evidence и cleanup.
|
||||
- benchmark.py выполняет SQL и сверку внутри API-образа. Перед заполнением требует пустую БД. Исследовательский флаг устанавливает только драйвер.
|
||||
|
||||
Датасет: 100000 сообщений в 4 чатах (70000/20000/9000/1000). Сравниваются индекс chat_id и индекс (chat_id,created_at,id), по 3 повтора с одинаковыми ограничениями и записями. На каждый чат — страницы около 10/50/90%, один прогрев и пять измерений, 51 строка. Измеряется INSERT SELECT с COMMIT, WAL и размер индекса. EXPLAIN и основные цифры сохраняются в evidence.
|
||||
|
||||
После dump создаётся ещё одно сообщение. Backup восстанавливается в другой контейнер и свежий volume. Сравниваются все счётчики, 12 полных записей и SHA-256 всех сообщений. Последующая запись ожидаемо отсутствует в восстановленном снимке.
|
||||
|
||||
Файлы research.json, query-plans.json и research.txt обновляются автоматически. Dump остаётся в игнорируемом backups/. Временные исследовательские volumes удаляются после проверки. Методика, фактические результаты и ограничения описаны в REPORT.md.
|
||||
@@ -0,0 +1,168 @@
|
||||
"""SQL-эксперимент запускается только в отдельном research Compose project."""
|
||||
from datetime import datetime, timedelta, timezone
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import secrets
|
||||
import statistics
|
||||
import sys
|
||||
import time
|
||||
from uuid import UUID
|
||||
|
||||
import psycopg
|
||||
from psycopg.conninfo import make_conninfo
|
||||
from psycopg.rows import dict_row
|
||||
|
||||
from src import db, migrate, passwords
|
||||
from src.config import secret
|
||||
|
||||
|
||||
SIZES = [70000, 20000, 9000, 1000]
|
||||
START = datetime(2026, 1, 1, tzinfo=timezone.utc)
|
||||
QUERY = """SELECT * FROM messages WHERE chat_id=%s AND (created_at, id)>(%s, %s)
|
||||
ORDER BY created_at, id LIMIT %s"""
|
||||
|
||||
|
||||
def identifier(value):
|
||||
return UUID(hashlib.md5(value.encode(), usedforsecurity=False).hexdigest())
|
||||
|
||||
|
||||
def connect(restored=False):
|
||||
url = secret("DATABASE_URL")
|
||||
if restored:
|
||||
url = make_conninfo(url, host="postgres-restore")
|
||||
return psycopg.connect(url, autocommit=True, row_factory=dict_row,
|
||||
options="-c timezone=UTC -c statement_timeout=120000")
|
||||
|
||||
|
||||
def snapshot(conn):
|
||||
counts = {}
|
||||
for table in ("users", "chats", "chat_members", "messages", "schema_migrations"):
|
||||
# Имена таблиц — фиксированный список выше, не входные данные клиента.
|
||||
counts[table] = conn.execute("SELECT count(*) AS n FROM " + table).fetchone()["n"]
|
||||
digest = hashlib.sha256()
|
||||
for row in conn.execute("SELECT * FROM messages ORDER BY id"):
|
||||
digest.update((json.dumps(row, default=str, sort_keys=True, ensure_ascii=False) + "\n").encode())
|
||||
samples = []
|
||||
offset = 0
|
||||
for size in SIZES:
|
||||
for number in (offset + 1, offset + size // 2, offset + size):
|
||||
row = conn.execute("SELECT * FROM messages WHERE id=%s", (identifier(f"message:{number}"),)).fetchone()
|
||||
samples.append(json.loads(json.dumps(row, default=str, sort_keys=True, ensure_ascii=False)))
|
||||
offset += size
|
||||
return {"counts": counts, "messages_sha256": digest.hexdigest(), "samples": samples}
|
||||
|
||||
|
||||
def benchmark():
|
||||
db.pool.open(wait=True, timeout=15)
|
||||
try:
|
||||
migrate.apply()
|
||||
finally:
|
||||
db.pool.close()
|
||||
results, plans = [], []
|
||||
with connect() as conn:
|
||||
assert conn.execute("SELECT count(*) AS n FROM users").fetchone()["n"] == 0, "Research requires an empty database"
|
||||
encoded = passwords.hash_password(secrets.token_urlsafe(24))
|
||||
for n in range(1, 11):
|
||||
conn.execute("INSERT INTO users(id,username,display_name,password_hash) VALUES(%s,%s,%s,%s)",
|
||||
(identifier(f"user:{n}"), f"research_{n}", "Synthetic research user", encoded))
|
||||
for n in range(4):
|
||||
chat = identifier(f"chat:{n}")
|
||||
conn.execute("INSERT INTO chats(id,title) VALUES(%s,%s)", (chat, f"Research chat {n}"))
|
||||
for user in (1, 2):
|
||||
conn.execute("INSERT INTO chat_members(chat_id,user_id) VALUES(%s,%s)", (chat, identifier(f"user:{user}")))
|
||||
variants = [("chat_only", "chat_id"), ("history", "chat_id, created_at, id")]
|
||||
for repeat in range(3):
|
||||
order = variants if repeat % 2 == 0 else variants[::-1]
|
||||
for variant, columns in order:
|
||||
conn.execute("TRUNCATE messages")
|
||||
conn.execute("DROP INDEX IF EXISTS messages_history_idx")
|
||||
conn.execute("DROP INDEX IF EXISTS messages_chat_idx")
|
||||
index = "messages_history_idx" if variant == "history" else "messages_chat_idx"
|
||||
conn.execute("CREATE INDEX " + index + " ON messages (" + columns + ")")
|
||||
lsn = conn.execute("SELECT pg_current_wal_insert_lsn() AS lsn").fetchone()["lsn"]
|
||||
started = time.perf_counter()
|
||||
conn.execute("""INSERT INTO messages(id,chat_id,sender_id,text,created_at)
|
||||
SELECT md5('message:'||n)::uuid,
|
||||
md5('chat:'||(CASE WHEN n<=70000 THEN 0 WHEN n<=90000 THEN 1 WHEN n<=99000 THEN 2 ELSE 3 END))::uuid,
|
||||
md5('user:'||(1+n%2))::uuid,
|
||||
'Synthetic message '||n||' '||repeat('x',80),
|
||||
timestamptz '2026-01-01 00:00:00+00' + n*interval '1 microsecond'
|
||||
FROM generate_series(1,100000) AS n""")
|
||||
insert_ms = (time.perf_counter() - started) * 1000
|
||||
wal = conn.execute("SELECT pg_wal_lsn_diff(pg_current_wal_insert_lsn(), %s) AS bytes", (lsn,)).fetchone()["bytes"]
|
||||
conn.execute("VACUUM (ANALYZE) messages")
|
||||
index_bytes = conn.execute("SELECT pg_relation_size(%s::regclass) AS bytes", (index,)).fetchone()["bytes"]
|
||||
result = {"variant": variant, "repeat": repeat + 1, "insert_100000_ms": insert_ms,
|
||||
"wal_bytes": int(wal), "index_bytes": index_bytes, "queries": []}
|
||||
offset = 0
|
||||
for chat, size in enumerate(SIZES):
|
||||
for fraction in (0.1, 0.5, 0.9):
|
||||
number = offset + int(size * fraction)
|
||||
params = (identifier(f"chat:{chat}"), START + timedelta(microseconds=number), identifier(f"message:{number}"), 51)
|
||||
conn.execute(QUERY, params).fetchall() # один прогрев именно этой страницы
|
||||
times = []
|
||||
for _ in range(5):
|
||||
started = time.perf_counter()
|
||||
rows = conn.execute(QUERY, params).fetchall()
|
||||
times.append((time.perf_counter() - started) * 1000)
|
||||
assert len(rows) == 51
|
||||
plan = conn.execute("EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) " + QUERY, params).fetchone()["QUERY PLAN"][0]
|
||||
result["queries"].append({"chat_size": size, "position": fraction, "latency_ms": times,
|
||||
"explain_execution_ms": plan["Execution Time"]})
|
||||
if repeat == 0:
|
||||
plans.append({"variant": variant, "chat_size": size, "position": fraction, "plan": plan})
|
||||
offset += size
|
||||
results.append(result)
|
||||
# Последняя итерация заканчивается production-индексом history.
|
||||
assert conn.execute("SELECT to_regclass('messages_history_idx') AS name").fetchone()["name"]
|
||||
baseline = snapshot(conn)
|
||||
assert baseline["counts"]["messages"] == 100000
|
||||
summary = {}
|
||||
for variant, _ in variants:
|
||||
trials = [row for row in results if row["variant"] == variant]
|
||||
latencies = sorted(t for row in trials for q in row["queries"] for t in q["latency_ms"])
|
||||
summary[variant] = {
|
||||
"insert_100000_median_ms": statistics.median(row["insert_100000_ms"] for row in trials),
|
||||
"index_bytes": trials[-1]["index_bytes"],
|
||||
"wal_bytes_median": statistics.median(row["wal_bytes"] for row in trials),
|
||||
"queries": len(latencies), "errors": 0, "concurrency": 1,
|
||||
"p50_ms": statistics.median(latencies),
|
||||
"p95_ms": latencies[int(0.95 * (len(latencies) - 1))],
|
||||
"p99_ms": latencies[int(0.99 * (len(latencies) - 1))],
|
||||
"successful_sql_rps": len(latencies) / (sum(latencies) / 1000),
|
||||
}
|
||||
return {"postgres": conn.execute("SELECT version() AS version").fetchone()["version"],
|
||||
"messages": 100000, "chat_sizes": SIZES, "repeats": 3, "warmup_per_case": 1,
|
||||
"measurements_per_case": 5, "page_size": 51, "query": QUERY,
|
||||
"summary": summary, "trials": results, "plans": plans, "snapshot": baseline}
|
||||
|
||||
|
||||
def after_backup():
|
||||
with connect() as conn:
|
||||
message_id = identifier("after-backup")
|
||||
conn.execute("INSERT INTO messages(id,chat_id,sender_id,text) VALUES(%s,%s,%s,%s)",
|
||||
(message_id, identifier("chat:0"), identifier("user:1"), "Committed AFTER backup"))
|
||||
return {"id": str(message_id), "source_messages": conn.execute("SELECT count(*) AS n FROM messages").fetchone()["n"]}
|
||||
|
||||
|
||||
def verify():
|
||||
expected = json.load(sys.stdin)
|
||||
with connect(restored=True) as restored, connect() as source:
|
||||
actual = snapshot(restored)
|
||||
assert actual == expected, "Restored data differs from the snapshot"
|
||||
marker = (identifier("after-backup"),)
|
||||
assert restored.execute("SELECT 1 FROM messages WHERE id=%s", marker).fetchone() is None
|
||||
assert source.execute("SELECT 1 FROM messages WHERE id=%s", marker).fetchone() is not None
|
||||
return {"counts": actual["counts"], "messages_sha256": actual["messages_sha256"],
|
||||
"samples_verified": len(actual["samples"]), "all_messages_match": True,
|
||||
"after_backup_message_missing_in_restore": True,
|
||||
"source_messages": source.execute("SELECT count(*) AS n FROM messages").fetchone()["n"]}
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
if os.environ.get("LAB2_RESEARCH") != "1":
|
||||
raise SystemExit("Use ./scripts/research.sh: an isolated research database is required")
|
||||
operation = sys.argv[1] if len(sys.argv) > 1 else "benchmark"
|
||||
result = {"benchmark": benchmark, "after-backup": after_backup, "verify": verify}[operation]()
|
||||
print(json.dumps(result, ensure_ascii=False, default=str))
|
||||
@@ -0,0 +1,99 @@
|
||||
"""Создаёт изолированный стенд, измеряет SQL, делает dump и restore; пишет реальные результаты."""
|
||||
from datetime import datetime, timezone
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import platform
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
from uuid import uuid4
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
project = "lab2-research-" + uuid4().hex[:10]
|
||||
env = dict(os.environ, COMPOSE_PROJECT_NAME=project)
|
||||
command = ["docker", "compose", "--profile", "research"]
|
||||
|
||||
|
||||
def compose(*args, stdin=None, stdout=subprocess.PIPE):
|
||||
return subprocess.run([*command, *args], cwd=ROOT, env=env, input=stdin,
|
||||
stdout=stdout, stderr=subprocess.PIPE, check=True, timeout=600)
|
||||
|
||||
|
||||
def run_module(operation, stdin=None):
|
||||
result = compose("run", "--rm", "--no-deps", "-T", "-e", "LAB2_RESEARCH=1", "api", "python", "-m", "research.benchmark", operation, stdin=stdin)
|
||||
return json.loads(result.stdout)
|
||||
|
||||
|
||||
def wait_database(service):
|
||||
for _ in range(60):
|
||||
cid = compose("ps", "-q", service).stdout.decode().strip()
|
||||
state = subprocess.run(["docker", "inspect", "--format", "{{.State.Health.Status}}", cid], capture_output=True, text=True, check=True)
|
||||
if state.stdout.strip() == "healthy":
|
||||
return
|
||||
time.sleep(1)
|
||||
raise RuntimeError(service + " did not become healthy")
|
||||
|
||||
|
||||
def main():
|
||||
evidence = ROOT / "evidence"
|
||||
evidence.mkdir(exist_ok=True)
|
||||
backups = ROOT / "backups"
|
||||
backups.mkdir(exist_ok=True)
|
||||
dump = backups / (project + ".dump")
|
||||
metadata = {"utc": datetime.now(timezone.utc).isoformat(), "project": project,
|
||||
"command": "./scripts/research.sh", "host": platform.system() + " " + platform.machine(),
|
||||
"commit": subprocess.run(["git", "rev-parse", "--short", "HEAD"], cwd=ROOT, capture_output=True, text=True).stdout.strip() + " + working tree",
|
||||
"postgres_limits": {"cpus": 1, "memory_mib": 512}, "api_runner_limits": {"cpus": 1, "memory_mib": 256}}
|
||||
started = time.perf_counter()
|
||||
try:
|
||||
print("Research project:", project, flush=True)
|
||||
compose("up", "-d", "postgres", "postgres-restore")
|
||||
wait_database("postgres")
|
||||
wait_database("postgres-restore")
|
||||
print("Measuring two indexes on the same 100000 messages, three repeats...", flush=True)
|
||||
result = run_module("benchmark")
|
||||
plans = result.pop("plans")
|
||||
(evidence / "query-plans.json").write_text(json.dumps(plans, ensure_ascii=False, indent=2))
|
||||
source_id = compose("ps", "-q", "postgres").stdout.decode().strip()
|
||||
restore_id = compose("ps", "-q", "postgres-restore").stdout.decode().strip()
|
||||
assert source_id != restore_id
|
||||
for label, cid in (("source", source_id), ("restored", restore_id)):
|
||||
inspected = json.loads(subprocess.run(["docker", "inspect", cid], capture_output=True, check=True).stdout)[0]
|
||||
metadata[label] = {"container": cid, "image": inspected["Image"],
|
||||
"volumes": [m["Name"] for m in inspected["Mounts"] if m["Type"] == "volume"]}
|
||||
assert metadata["source"]["volumes"] != metadata["restored"]["volumes"]
|
||||
metadata["docker"] = subprocess.run(["docker", "info", "--format", "{{.ServerVersion}} {{.Architecture}} CPUs={{.NCPU}} RAM={{.MemTotal}}"], capture_output=True, text=True, check=True).stdout.strip()
|
||||
metadata["stats_after_queries"] = subprocess.run(["docker", "stats", "--no-stream", "--format", "{{json .}}", source_id], capture_output=True, text=True, check=True).stdout.strip()
|
||||
backup_started = time.perf_counter()
|
||||
with dump.open("wb") as output:
|
||||
compose("exec", "-T", "postgres", "pg_dump", "-U", "messenger", "-d", "messenger", "--format=custom", stdout=output)
|
||||
backup_seconds = time.perf_counter() - backup_started
|
||||
marker = run_module("after-backup")
|
||||
restore_started = time.perf_counter()
|
||||
# Dump подаётся через stdin, без вывода данных или credentials в журнал.
|
||||
with dump.open("rb") as input_file:
|
||||
subprocess.run([*command, "exec", "-T", "postgres-restore", "pg_restore", "-U", "messenger", "-d", "messenger",
|
||||
"--exit-on-error", "--single-transaction", "--no-owner"], cwd=ROOT, env=env, stdin=input_file,
|
||||
stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, check=True, timeout=300)
|
||||
restore_seconds = time.perf_counter() - restore_started
|
||||
verification_started = time.perf_counter()
|
||||
verification = run_module("verify", stdin=json.dumps(result["snapshot"]).encode())
|
||||
result.update(metadata)
|
||||
result["backup"] = {"file": "backups/" + dump.name, "bytes": dump.stat().st_size, "seconds": backup_seconds}
|
||||
result["restore"] = {"seconds": restore_seconds, "verification_seconds": time.perf_counter() - verification_started,
|
||||
"verification": verification, "post_backup_insert": marker}
|
||||
result["total_seconds"] = time.perf_counter() - started
|
||||
(evidence / "research.json").write_text(json.dumps(result, ensure_ascii=False, indent=2))
|
||||
print(json.dumps(result["summary"], ensure_ascii=False, indent=2), flush=True)
|
||||
print(f"PASS: backup {backup_seconds:.2f}s; restore {restore_seconds:.2f}s; 100000 messages, all hashes and 12 samples match", flush=True)
|
||||
print("PASS: restored into a different container and fresh volume; one post-backup commit is absent as expected", flush=True)
|
||||
print("Results: evidence/research.json, evidence/query-plans.json; dump stays outside Git in backups/", flush=True)
|
||||
finally:
|
||||
compose("down", "--volumes", "--timeout", "10")
|
||||
print("Removed only temporary research project:", project, flush=True)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user