forked from mtusi2026/mtusi2026lab2
342 lines
22 KiB
Python
342 lines
22 KiB
Python
#!/usr/bin/env python3
|
||
"""Track 2, часть 2: backup → восстановление в новое хранилище → сверка.
|
||
|
||
1. В служебный чат track2-rpo пишутся K сообщений «до backup».
|
||
2. Снимается отпечаток исходной БД (счётчики, md5 таблиц, страницы чатов).
|
||
3. pg_dump -Fc из сервиса db в backups/ (каталог в .gitignore).
|
||
4. В исходную БД пишутся N сообщений «после backup» — их не должно быть
|
||
в восстановленной копии (граница потери данных логического backup).
|
||
5. Новый контейнер postgres:16-alpine с новым пустым volume, pg_restore
|
||
по секциям pre-data / data / post-data с замером каждой.
|
||
6. Сверка отпечатков, страниц, RPO-маркеров и плана запроса на копии.
|
||
7. Контейнер и volume копии удаляются (если не указан --keep).
|
||
|
||
Результат: evidence/track2_restore.md.
|
||
|
||
python3 scripts/track2_restore.py
|
||
python3 scripts/track2_restore.py --jobs 4 --keep
|
||
"""
|
||
import argparse
|
||
import secrets
|
||
import subprocess
|
||
import time
|
||
from pathlib import Path
|
||
|
||
from track2_common import (ENV, MESSAGE_COLS, PERF_USER_ID, ROOT, Pg,
|
||
dataset_lines, environment_lines, pick_chats,
|
||
write_evidence)
|
||
|
||
IMAGE = "postgres:16-alpine"
|
||
RPO_CHAT_TITLE = "track2-rpo"
|
||
PAGE = 50
|
||
|
||
src = Pg.compose()
|
||
|
||
FINGERPRINT_SQL = """
|
||
SELECT 'count.users', count(*)::text FROM users
|
||
UNION ALL SELECT 'count.chats', count(*)::text FROM chats
|
||
UNION ALL SELECT 'count.chat_members', count(*)::text FROM chat_members
|
||
UNION ALL SELECT 'count.messages', count(*)::text FROM messages
|
||
UNION ALL SELECT 'count.sessions', count(*)::text FROM sessions
|
||
UNION ALL SELECT 'schema_migrations', string_agg(version::text, ',' ORDER BY version) FROM schema_migrations
|
||
UNION ALL SELECT 'md5.users', md5(coalesce(string_agg(
|
||
id::text || '|' || username || '|' || display_name || '|' || password_hash || '|' ||
|
||
extract(epoch FROM created_at)::text, E'\\n' ORDER BY id), '')) FROM users
|
||
UNION ALL SELECT 'md5.chats', md5(coalesce(string_agg(
|
||
id::text || '|' || title || '|' || extract(epoch FROM created_at)::text,
|
||
E'\\n' ORDER BY id), '')) FROM chats
|
||
UNION ALL SELECT 'md5.chat_members', md5(coalesce(string_agg(
|
||
chat_id::text || '|' || user_id::text, E'\\n' ORDER BY chat_id, user_id), '')) FROM chat_members
|
||
UNION ALL SELECT 'md5.messages', md5(coalesce(string_agg(
|
||
id::text || '|' || chat_id::text || '|' || sender_id::text || '|' || text || '|' ||
|
||
extract(epoch FROM created_at)::text, E'\\n' ORDER BY id), '')) FROM messages
|
||
UNION ALL SELECT 'md5.sessions', md5(coalesce(string_agg(
|
||
token || '|' || user_id::text || '|' || extract(epoch FROM expires_at)::text,
|
||
E'\\n' ORDER BY token), '')) FROM sessions
|
||
UNION ALL SELECT 'md5.messages_per_chat', md5(coalesce(string_agg(
|
||
chat_id::text || ':' || n::text, ',' ORDER BY chat_id), ''))
|
||
FROM (SELECT chat_id, count(*) AS n FROM messages GROUP BY chat_id) s;
|
||
"""
|
||
|
||
|
||
def fingerprint(db):
|
||
return {k: v for k, v in db.rows(FINGERPRINT_SQL)}
|
||
|
||
|
||
def page_queries(chats):
|
||
"""Страницы теми же запросами, что у приложения: первая, keyset из середины, последняя."""
|
||
qs = {}
|
||
for label, (cid, _, n) in chats:
|
||
ts, mid = src.rows(f"""
|
||
SELECT created_at::text, id FROM messages WHERE chat_id = '{cid}'
|
||
ORDER BY created_at, id OFFSET {n // 2} LIMIT 1;
|
||
""")[0]
|
||
base = f"SELECT {MESSAGE_COLS} FROM messages WHERE chat_id = '{cid}'"
|
||
qs[f"{label}.first"] = f"{base} ORDER BY created_at ASC, id ASC LIMIT {PAGE}"
|
||
qs[f"{label}.middle"] = (f"{base} AND (created_at, id) > ('{ts}'::timestamptz, '{mid}'::uuid) "
|
||
f"ORDER BY created_at ASC, id ASC LIMIT {PAGE}")
|
||
qs[f"{label}.last"] = (f"SELECT * FROM ({base} ORDER BY created_at DESC, id DESC "
|
||
f"LIMIT {PAGE}) t ORDER BY created_at_epoch, id")
|
||
return qs
|
||
|
||
|
||
def fetch_pages(db, qs):
|
||
return {k: db.rows(q + ";") for k, q in qs.items()}
|
||
|
||
|
||
def ensure_rpo_chat():
|
||
cid = src.scalar(f"SELECT id FROM chats WHERE title = '{RPO_CHAT_TITLE}' LIMIT 1;")
|
||
if cid:
|
||
return cid
|
||
return src.scalar(f"""
|
||
WITH c AS (
|
||
INSERT INTO chats (id, title, created_at)
|
||
VALUES (gen_random_uuid(), '{RPO_CHAT_TITLE}', now()) RETURNING id
|
||
), m AS (
|
||
INSERT INTO chat_members (chat_id, user_id) SELECT id, '{PERF_USER_ID}' FROM c
|
||
)
|
||
SELECT id FROM c;
|
||
""")
|
||
|
||
|
||
def insert_marker(cid, tag, n):
|
||
src.psql(f"""
|
||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||
SELECT gen_random_uuid(), '{cid}', '{PERF_USER_ID}', '{tag}-' || g,
|
||
date_trunc('second', clock_timestamp())
|
||
FROM generate_series(1, {n}) AS g;
|
||
""")
|
||
|
||
|
||
def count_marker(db, tag):
|
||
return int(db.scalar(f"SELECT count(*) FROM messages WHERE text LIKE '{tag}-%';"))
|
||
|
||
|
||
def sh(cmd, **kw):
|
||
return subprocess.run(cmd, check=True, capture_output=True, text=True, cwd=ROOT, **kw)
|
||
|
||
|
||
def timed(fn):
|
||
t0 = time.perf_counter()
|
||
result = fn()
|
||
return result, time.perf_counter() - t0
|
||
|
||
|
||
def start_restore_storage(name, volume):
|
||
sh(["docker", "volume", "create", volume])
|
||
sh(["docker", "run", "-d", "--name", name,
|
||
"-e", f"POSTGRES_USER={ENV['POSTGRES_USER']}",
|
||
"-e", f"POSTGRES_PASSWORD={secrets.token_hex(16)}",
|
||
"-e", f"POSTGRES_DB={ENV['POSTGRES_DB']}",
|
||
"-v", f"{volume}:/var/lib/postgresql/data", IMAGE])
|
||
# Во время initdb сервер слушает только unix-socket; TCP-готовность
|
||
# означает, что поднят окончательный сервер.
|
||
for _ in range(120):
|
||
r = subprocess.run(["docker", "exec", name, "pg_isready", "-h", "127.0.0.1",
|
||
"-U", ENV["POSTGRES_USER"], "-d", ENV["POSTGRES_DB"]],
|
||
capture_output=True)
|
||
if r.returncode == 0:
|
||
return
|
||
time.sleep(0.25)
|
||
raise SystemExit("восстановительный PostgreSQL не поднялся за 30 с")
|
||
|
||
|
||
def main():
|
||
p = argparse.ArgumentParser(description=__doc__.split("\n")[0])
|
||
p.add_argument("--before", type=int, default=100, help="маркеров до backup")
|
||
p.add_argument("--after", type=int, default=37, help="маркеров после backup")
|
||
p.add_argument("--jobs", type=int, default=1, help="pg_restore -j для data/post-data")
|
||
p.add_argument("--keep", action="store_true", help="не удалять контейнер и volume копии")
|
||
args = p.parse_args()
|
||
|
||
run_id = time.strftime("%Y%m%d%H%M%S")
|
||
tag_before, tag_after = f"track2-rpo-before-{run_id}", f"track2-rpo-after-{run_id}"
|
||
name, volume = f"track2-restore-{run_id}", f"track2_restore_{run_id}"
|
||
backups = ROOT / "backups"
|
||
backups.mkdir(exist_ok=True)
|
||
dump_path = backups / f"track2_{run_id}.dump"
|
||
|
||
chats = pick_chats(src)
|
||
rpo_chat = ensure_rpo_chat()
|
||
insert_marker(rpo_chat, tag_before, args.before)
|
||
env, dataset = environment_lines(src), dataset_lines(src)
|
||
print("\n".join(env + dataset))
|
||
print(f"\n[1] записано {args.before} сообщений до backup")
|
||
|
||
qs = page_queries(chats)
|
||
fp_src = fingerprint(src)
|
||
pages_src = fetch_pages(src, qs)
|
||
db_size = int(src.scalar(f"SELECT pg_database_size('{ENV['POSTGRES_DB']}');"))
|
||
print(f"[2] отпечаток исходной БД: {fp_src['count.messages']} сообщений")
|
||
|
||
with open(dump_path, "wb") as f:
|
||
_, t_dump = timed(lambda: src.run(
|
||
["pg_dump", "-U", ENV["POSTGRES_USER"], "-d", ENV["POSTGRES_DB"], "-Fc"],
|
||
binary=True, stdout=f))
|
||
dump_size = dump_path.stat().st_size
|
||
print(f"[3] pg_dump: {t_dump:.2f} s, {dump_size / 1048576:.1f} MiB → {dump_path.relative_to(ROOT)}")
|
||
|
||
insert_marker(rpo_chat, tag_after, args.after)
|
||
print(f"[4] записано {args.after} сообщений после backup")
|
||
|
||
dst = Pg.container(name)
|
||
timings = {}
|
||
try:
|
||
_, timings["storage"] = timed(lambda: start_restore_storage(name, volume))
|
||
print(f"[5] новое хранилище {name} (volume {volume}): {timings['storage']:.2f} s")
|
||
_, timings["copy"] = timed(lambda: sh(["docker", "cp", str(dump_path), f"{name}:/tmp/db.dump"]))
|
||
for section in ("pre-data", "data", "post-data"):
|
||
cmd = ["pg_restore", "-U", ENV["POSTGRES_USER"], "-d", ENV["POSTGRES_DB"],
|
||
"--no-owner", "--exit-on-error", f"--section={section}"]
|
||
if section != "pre-data" and args.jobs > 1:
|
||
cmd += ["-j", str(args.jobs)]
|
||
_, timings[section] = timed(lambda: dst.run(cmd + ["/tmp/db.dump"]))
|
||
print(f" pg_restore --section={section}: {timings[section]:.2f} s")
|
||
dst.psql("ANALYZE;")
|
||
|
||
fp_dst, t_verify = timed(lambda: fingerprint(dst))
|
||
pages_dst = fetch_pages(dst, qs)
|
||
fp_src_now = fingerprint(src)
|
||
rpo = {
|
||
"before_dst": count_marker(dst, tag_before),
|
||
"after_dst": count_marker(dst, tag_after),
|
||
"after_src": count_marker(src, tag_after),
|
||
}
|
||
plan_dst = dst.psql(f"EXPLAIN (ANALYZE, BUFFERS) {qs['large.middle']};", tuples=False).strip()
|
||
indexes_dst = dst.scalar(
|
||
"SELECT string_agg(indexname, ', ' ORDER BY indexname) FROM pg_indexes "
|
||
"WHERE schemaname = 'public';")
|
||
version_dst = dst.scalar("SHOW server_version;")
|
||
sample = pages_src["large.middle"][:3]
|
||
finally:
|
||
if args.keep:
|
||
print(f"\nкопия оставлена: docker exec -it {name} psql -U {ENV['POSTGRES_USER']} {ENV['POSTGRES_DB']}")
|
||
else:
|
||
subprocess.run(["docker", "rm", "-f", name], capture_output=True)
|
||
subprocess.run(["docker", "volume", "rm", volume], capture_output=True)
|
||
print(f"\nконтейнер {name} и volume {volume} удалены")
|
||
|
||
# ---------- сверка ----------
|
||
checks = []
|
||
for key in sorted(fp_src):
|
||
checks.append((key, fp_src[key], fp_dst.get(key), fp_src[key] == fp_dst.get(key)))
|
||
pages_ok = {k: pages_src[k] == pages_dst[k] for k in qs}
|
||
rpo_ok = (rpo["before_dst"] == args.before and rpo["after_dst"] == 0
|
||
and rpo["after_src"] == args.after)
|
||
plan_ok = "messages_chat_keyset_idx" in plan_dst
|
||
diverged = sorted(k for k in fp_src_now if fp_src_now[k] != fp_dst.get(k))
|
||
all_ok = all(c[3] for c in checks) and all(pages_ok.values()) and rpo_ok and plan_ok
|
||
print("\nPASS: копия совпадает со снимком" if all_ok else "\nFAIL: есть расхождения")
|
||
|
||
rto = timings["storage"] + timings["copy"] + timings["pre-data"] + timings["data"] + timings["post-data"]
|
||
restore_only = timings["pre-data"] + timings["data"] + timings["post-data"]
|
||
post_share = timings["post-data"] / restore_only * 100
|
||
throughput = db_size / 1048576 / restore_only
|
||
|
||
md = ["# Track 2. Backup → восстановление в новое хранилище → сверка", "",
|
||
f"Сгенерировано `python3 scripts/track2_restore.py --before {args.before} "
|
||
f"--after {args.after} --jobs {args.jobs}`. Итог: **{'PASS' if all_ok else 'FAIL'}**.", "",
|
||
"## Окружение и данные", "", *env, *dataset,
|
||
f"- Размер БД `pg_database_size`: {db_size / 1048576:.1f} MiB; "
|
||
f"восстановлено в PostgreSQL {version_dst} (`{IMAGE}`, новый пустой volume)", "",
|
||
"## Гипотезы", "",
|
||
"- **H4.** Логический backup (`pg_dump -Fc`) восстанавливается в пустое хранилище без "
|
||
"потерь: совпадают счётчики, содержимое всех таблиц и страницы истории.",
|
||
"- **H5.** Время восстановления заметно определяется построением индексов и "
|
||
"ограничений (секция post-data), а не только загрузкой строк.",
|
||
"- **H6.** Граница потери данных (RPO) логического backup — момент его снимка: всё, что "
|
||
"подтверждено COMMIT после начала `pg_dump`, в копии отсутствует.", "",
|
||
"## Методика", "",
|
||
f"1. В служебный чат `{RPO_CHAT_TITLE}` записано {args.before} сообщений с меткой «до».",
|
||
"2. Снят отпечаток исходной БД: `count(*)` и md5 упорядоченного содержимого каждой "
|
||
"таблицы, md5 числа сообщений по чатам, страницы истории (первая, keyset из середины, "
|
||
"последняя) для чатов small/medium/large/burst — теми же запросами, что у приложения.",
|
||
"3. `pg_dump -Fc` из работающего сервиса `db` в `backups/` (не в Git).",
|
||
f"4. В исходную БД записано {args.after} сообщений с меткой «после».",
|
||
"5. `docker volume create` + `docker run postgres:16-alpine`: новое хранилище; "
|
||
"`pg_restore --section=pre-data|data|post-data` с замером каждой секции.",
|
||
"6. Сверка отпечатков, страниц, маркеров и плана запроса на копии; копия удаляется.", "",
|
||
"## Время", "",
|
||
"| Этап | Время, s |", "|---|---|",
|
||
f"| pg_dump (backup) | {t_dump:.2f} |",
|
||
f"| Запуск нового хранилища (initdb + старт) | {timings['storage']:.2f} |",
|
||
f"| Копирование дампа в контейнер | {timings['copy']:.2f} |",
|
||
f"| pg_restore pre-data (схема) | {timings['pre-data']:.2f} |",
|
||
f"| pg_restore data (COPY строк) | {timings['data']:.2f} |",
|
||
f"| pg_restore post-data (PK, FK, индексы) | {timings['post-data']:.2f} |",
|
||
f"| **RTO: от пустого хоста до готовой БД** | **{rto:.2f}** |",
|
||
f"| Сверка отпечатков (вне RTO) | {t_verify:.2f} |", "",
|
||
f"Размер дампа: {dump_size / 1048576:.1f} MiB (сжатие custom-формата, "
|
||
f"{db_size / max(dump_size, 1):.1f}× меньше БД).", "",
|
||
"## Сверка", "",
|
||
"| Проверка | Исходная (снимок) | Копия | Совпадает |", "|---|---|---|---|"]
|
||
for key, a, b, ok in checks:
|
||
short = (lambda v: v if v is None or len(v) <= 20 else v[:12] + "…")
|
||
md.append(f"| {key} | `{short(a)}` | `{short(b)}` | {'да' if ok else '**НЕТ**'} |")
|
||
for key, ok in pages_ok.items():
|
||
md.append(f"| страница {key} ({len(pages_src[key])} строк) | — | — | {'да' if ok else '**НЕТ**'} |")
|
||
md += [f"| план Q2 на копии использует messages_chat_keyset_idx | — | — | {'да' if plan_ok else '**НЕТ**'} |",
|
||
"", "Пример выбранных сообщений (large, keyset из середины), одинаковы в обеих БД:", "",
|
||
"| id | chat_id | created_at (epoch) | text |", "|---|---|---|---|"]
|
||
for row in sample:
|
||
md.append(f"| `{row[0]}` | `{row[1][:8]}…` | {row[4]} | {row[3]} |")
|
||
md += ["", "Индексы на копии: " + indexes_dst, "",
|
||
"## Граница потери данных", "",
|
||
"| Маркер | В исходной БД | В копии | Ожидание |", "|---|---|---|---|",
|
||
f"| до backup | {args.before} | {rpo['before_dst']} | все есть |",
|
||
f"| после backup | {rpo['after_src']} | {rpo['after_dst']} | нет ни одного |", "",
|
||
"После записи маркеров «после» исходная БД разошлась с копией по: "
|
||
+ (", ".join(f"`{k}`" for k in diverged) or "—") + ".", "",
|
||
"## Выводы", "",
|
||
f"**H4 — {'подтверждена' if all(c[3] for c in checks) and all(pages_ok.values()) else 'НЕ подтверждена'}.** "
|
||
f"Все {len(checks)} отпечатков (счётчики и md5 содержимого users, chats, chat_members, "
|
||
f"messages, sessions, schema_migrations, распределение по чатам) и {len(pages_ok)} страниц "
|
||
f"истории совпали. На копии восстановлены индексы, и тот же keyset-запрос идёт через "
|
||
f"`messages_chat_keyset_idx`. Таблица `schema_migrations` восстановлена, поэтому API, "
|
||
f"направленный на копию, не будет повторно применять миграции.", "",
|
||
f"**H5 — {'подтверждена' if post_share >= 25 else 'частично'}.** "
|
||
f"post-data заняла {timings['post-data']:.2f} s из {restore_only:.2f} s pg_restore "
|
||
f"({post_share:.0f}%): PK и вторичные индексы строятся заново после загрузки строк. "
|
||
f"Полный RTO {rto:.1f} s, из них {timings['storage']:.1f} s — запуск пустого PostgreSQL. "
|
||
f"Скорость восстановления ≈ {throughput:.0f} MiB/s БД; при линейной экстраполяции "
|
||
f"10× данных ≈ {restore_only * 10:.0f} s только на pg_restore (оценка: построение "
|
||
f"индексов растёт как n·log n, а при данных больше RAM появится дисковый I/O). "
|
||
f"Ускорение — `pg_restore -j N` для data/post-data или физический backup "
|
||
f"(`pg_basebackup`), который не перестраивает индексы.", "",
|
||
f"**H6 — {'подтверждена' if rpo_ok else 'НЕ подтверждена'}.** "
|
||
f"Все {args.before} сообщений до backup есть в копии, ни одного из {args.after} после — нет, "
|
||
f"хотя они подтверждены COMMIT в исходной БД. `pg_dump` читает один согласованный снимок "
|
||
f"(REPEATABLE READ) на момент старта, поэтому RPO = время с начала последнего backup. "
|
||
f"При backup раз в сутки можно потерять до суток сообщений; чтобы уменьшить RPO до секунд, "
|
||
f"нужен непрерывный архив WAL (`archive_mode` + pgBackRest/wal-g) и PITR "
|
||
f"или потоковая реплика.", "",
|
||
"**Сессии.** "
|
||
+ ("Сессии хранятся в Valkey (`SESSION_STORE=redis`) и в дамп PostgreSQL не входят. "
|
||
"Если Valkey цел, старые токены работают и с восстановленной БД: `user_id` сохранились. "
|
||
"Если потерян и Valkey, пользователи логинятся заново; при AOF `appendfsync everysec` "
|
||
"можно потерять до ~1 s новых сессий. Таблица `sessions` в PostgreSQL (резервный "
|
||
"режим `SESSION_STORE=postgres`) восстанавливается вместе с дампом."
|
||
if ENV.get("SESSION_STORE", "redis") == "redis" else
|
||
"Сессии хранятся в PostgreSQL и восстанавливаются вместе с дампом; сессии, созданные "
|
||
"после backup, теряются, а logout после backup «воскрешает» отозванный токен до его expiry."),
|
||
"",
|
||
"**COMMIT и durability.** При `synchronous_commit=on` подтверждённая транзакция уже "
|
||
"записана в WAL на диск и переживает рестарт контейнера, но не потерю volume/диска: "
|
||
"от этого защищает только копия на другом носителе. Здесь дамп лежит на том же хосте, "
|
||
"поэтому эксперимент доказывает процедуру восстановления, а не защиту от потери хоста.", "",
|
||
"## Ограничения", "",
|
||
"- Один хост, тёплый page cache; дамп и копия на том же диске.",
|
||
"- Во время backup не было внешней нагрузки; при нагрузке pg_dump длится дольше, но "
|
||
"снимок остаётся согласованным.",
|
||
"- RTO не включает переключение API на новую БД (смена секрета `database_url` и рестарт api).",
|
||
"- Сверка md5 упорядоченного содержимого требует чтения всех таблиц; на больших объёмах "
|
||
"её заменяют выборочной сверкой и счётчиками.",
|
||
"", "## План keyset-запроса на восстановленной копии", "", "```", plan_dst, "```", ""]
|
||
write_evidence("track2_restore.md", "\n".join(md))
|
||
if not all_ok:
|
||
raise SystemExit(1)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|