293 lines
6.5 KiB
Python
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) |