Files
mtusi2026lab4/scripts/reconcile.py
T
2026-11-08 18:17:48 +03:00

293 lines
6.5 KiB
Python

import argparse
import json
from pathlib import Path
import subprocess
import sys
from urllib.parse import unquote, urlsplit
import uuid
ROOT = Path(__file__).resolve().parents[1]
def output(args):
result = subprocess.run(
args,
cwd=ROOT,
text=True,
capture_output=True,
timeout=30,
)
if result.returncode:
raise RuntimeError(
"Docker command failed; "
"check Docker and running services"
)
return result.stdout.strip()
def service(name):
ids = output([
"docker", "compose", "ps", "-q", name,
]).splitlines()
if not ids:
raise RuntimeError(
"Service is not running: " + name
)
return json.loads(output([
"docker", "inspect", ids[0],
]))[0]
def environment(container):
return dict(
item.split("=", 1)
for item in container["Config"]["Env"]
if "=" in item
)
def main():
parser = argparse.ArgumentParser(
description="Reconcile PostgreSQL attachment metadata and S3"
)
modes = parser.add_mutually_exclusive_group()
modes.add_argument("--apply", action="store_true")
modes.add_argument("--dry-run", action="store_true")
parser.add_argument(
"--chat-id",
type=lambda value: str(uuid.UUID(value)),
default=None,
)
parser.add_argument(
"--grace-seconds",
type=int,
default=3600,
)
parser.add_argument(
"--max-seconds",
type=int,
default=600,
)
parser.add_argument(
"--backup-dir",
default="backups/attachments",
)
parser.add_argument(
"--output",
default="results/reconcile.json",
)
args = parser.parse_args()
if args.grace_seconds < 60 or args.max_seconds < 1:
parser.error(
"grace-seconds >= 60; max-seconds >= 1"
)
api = service("api")
postgres = service("postgres")
minio = service("minio")
env = environment(api)
pg = environment(postgres)
common = (
set(api["NetworkSettings"]["Networks"])
& set(postgres["NetworkSettings"]["Networks"])
& set(minio["NetworkSettings"]["Networks"])
)
if len(common) != 1:
raise RuntimeError(
"Expected exactly one common Docker network "
"for API, PostgreSQL and MinIO"
)
network = next(iter(common))
database_url = (
env.get("SPRING_DATASOURCE_URL")
or env.get("DB_URL")
or env.get("DATABASE_URL")
or ""
)
if database_url:
address = urlsplit(
database_url.removeprefix("jdbc:")
)
if address.scheme not in ("postgresql", "postgres"):
raise RuntimeError(
"Unsupported database URL scheme"
)
db_host = address.hostname
db_port = address.port or 5432
db_name = unquote(address.path.lstrip("/"))
url_user = (
unquote(address.username)
if address.username else None
)
url_password = (
unquote(address.password)
if address.password else None
)
else:
db_host = env.get("DB_HOST") or "postgres"
db_port = int(env.get("DB_PORT") or "5432")
db_name = (
env.get("DB_NAME")
or pg.get("POSTGRES_DB")
or pg.get("POSTGRES_USER")
or "postgres"
)
url_user = None
url_password = None
db_user = (
env.get("SPRING_DATASOURCE_USERNAME")
or env.get("DB_USERNAME")
or env.get("DB_USER")
or url_user
or pg.get("POSTGRES_USER")
)
db_password = (
env.get("SPRING_DATASOURCE_PASSWORD")
or env.get("DB_PASSWORD")
or url_password
or pg.get("POSTGRES_PASSWORD")
)
if not db_host or not db_name:
raise RuntimeError(
"Cannot determine PostgreSQL host or database"
)
if not db_user or not db_password:
raise RuntimeError(
"Database credentials are not available "
"in container environment"
)
required = [
"S3_ENDPOINT",
"S3_ACCESS_KEY",
"S3_SECRET_KEY",
"S3_BUCKET",
]
if any(not env.get(key) for key in required):
raise RuntimeError(
"Missing S3 settings in API container environment"
)
config = {
"apply": args.apply,
"chat_id": args.chat_id,
"grace_seconds": args.grace_seconds,
"max_seconds": args.max_seconds,
"bucket": env["S3_BUCKET"],
"db": {
"host": db_host,
"port": db_port,
"dbname": db_name,
"user": db_user,
"password": db_password,
},
"s3": {
"endpoint_url": env["S3_ENDPOINT"],
"aws_access_key_id": env["S3_ACCESS_KEY"],
"aws_secret_access_key": env["S3_SECRET_KEY"],
"region_name": "us-east-1",
},
}
backups = (ROOT / args.backup_dir).resolve()
backups.mkdir(parents=True, exist_ok=True)
command = [
"docker", "run",
"--rm",
"-i",
"--network", network,
"--read-only",
"--tmpfs", "/tmp:rw,noexec,nosuid,size=16m",
"--memory", "256m",
"--cpus", "1",
"--cap-drop", "ALL",
"--security-opt", "no-new-privileges",
"--mount",
(
f"type=bind,source={backups},"
"target=/backups,readonly"
),
"mtusi4-reconciler:local",
]
result = subprocess.run(
command,
cwd=ROOT,
input=json.dumps(config),
text=True,
capture_output=True,
)
try:
report = json.loads(result.stdout)
except json.JSONDecodeError:
raise RuntimeError(
"Worker did not return JSON; "
"check image build and backup directory permissions"
) from None
target = ROOT / args.output
target.parent.mkdir(parents=True, exist_ok=True)
rendered = json.dumps(
report,
ensure_ascii=False,
indent=2,
)
target.write_text(
rendered + "\n",
encoding="utf-8",
)
print(rendered)
print("Report saved:", target, file=sys.stderr)
return result.returncode
if __name__ == "__main__":
try:
raise SystemExit(main())
except (
RuntimeError,
ValueError,
OSError,
subprocess.TimeoutExpired,
) as error:
print("FAIL:", str(error), file=sys.stderr)
raise SystemExit(1)