forked from mtusi2026/mtusi2026lab4
227 lines
8.3 KiB
Python
227 lines
8.3 KiB
Python
"""Operator tools. Not part of the public HTTP API."""
|
|
|
|
import argparse
|
|
import asyncio
|
|
import hashlib
|
|
import json
|
|
import sys
|
|
import urllib.error
|
|
import urllib.request
|
|
import uuid
|
|
|
|
from app.config import load_settings
|
|
from app.db import close, connect, migrate, pool
|
|
from app.reconcile import reconcile
|
|
from app import s3client
|
|
|
|
|
|
async def _prepare(settings):
|
|
await connect(settings)
|
|
await migrate(settings)
|
|
|
|
|
|
async def _inject(settings, chat_id: str, owner_id: str) -> dict:
|
|
if settings.app_env != "lab":
|
|
raise SystemExit("inject is allowed only when APP_ENV=lab")
|
|
chat_uuid = uuid.UUID(chat_id)
|
|
owner_uuid = uuid.UUID(owner_id)
|
|
member = await pool().fetchval(
|
|
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
|
|
chat_uuid,
|
|
owner_uuid,
|
|
)
|
|
if member is None:
|
|
raise SystemExit("owner is not a member of the chat")
|
|
|
|
def staged(note: str) -> tuple[str, str, bytes]:
|
|
attachment_id = str(uuid.uuid4())
|
|
key = f"o/{attachment_id}"
|
|
payload = f"fault-{note}-{attachment_id}".encode("utf-8")
|
|
return attachment_id, key, payload
|
|
|
|
fresh_id, fresh_key, fresh_body = staged("fresh-orphan")
|
|
old_id, old_key, old_body = staged("old-orphan")
|
|
stale_id, stale_key, stale_body = staged("stale-missing")
|
|
used_id, used_key, used_body = staged("in-use-missing")
|
|
|
|
for key, body in (
|
|
(fresh_key, fresh_body),
|
|
(old_key, old_body),
|
|
(stale_key, stale_body),
|
|
(used_key, used_body),
|
|
):
|
|
s3client.put_bytes(settings, key, body)
|
|
|
|
async with pool().acquire() as conn:
|
|
async with conn.transaction():
|
|
for attachment_id, key, body, note in (
|
|
(fresh_id, fresh_key, fresh_body, "fresh-orphan"),
|
|
(old_id, old_key, old_body, "old-orphan"),
|
|
):
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO object_ledger (
|
|
object_key, attachment_id, chat_id, state, note, size_bytes, created_at, updated_at
|
|
)
|
|
VALUES ($1, $2, $3, 'staging', $4, $5, clock_timestamp(), clock_timestamp())
|
|
""",
|
|
key,
|
|
uuid.UUID(attachment_id),
|
|
chat_uuid,
|
|
note,
|
|
len(body),
|
|
)
|
|
await conn.execute(
|
|
"""
|
|
UPDATE object_ledger
|
|
SET created_at = clock_timestamp() - interval '2 hours',
|
|
updated_at = clock_timestamp() - interval '2 hours'
|
|
WHERE object_key = $1
|
|
""",
|
|
old_key,
|
|
)
|
|
for attachment_id, key, body, filename in (
|
|
(stale_id, stale_key, stale_body, "fault-stale-missing"),
|
|
(used_id, used_key, used_body, "fault-in-use-missing"),
|
|
):
|
|
digest = hashlib.sha256(body).hexdigest()
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO attachments (
|
|
id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
|
|
status, object_key, error_code, created_at, updated_at
|
|
)
|
|
VALUES (
|
|
$1, $2, $3, $4, 'image/png', $5, $6, 'ready', $7, NULL,
|
|
clock_timestamp() - interval '2 hours',
|
|
clock_timestamp() - interval '2 hours'
|
|
)
|
|
""",
|
|
uuid.UUID(attachment_id),
|
|
chat_uuid,
|
|
owner_uuid,
|
|
filename,
|
|
len(body),
|
|
digest,
|
|
key,
|
|
)
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO object_ledger (
|
|
object_key, attachment_id, chat_id, state, note, size_bytes, created_at, updated_at
|
|
)
|
|
VALUES (
|
|
$1, $2, $3, 'committed', $4, $5,
|
|
clock_timestamp() - interval '2 hours',
|
|
clock_timestamp() - interval '2 hours'
|
|
)
|
|
""",
|
|
key,
|
|
uuid.UUID(attachment_id),
|
|
chat_uuid,
|
|
filename,
|
|
len(body),
|
|
)
|
|
message_id = uuid.uuid4()
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
|
VALUES ($1, $2, $3, $4, clock_timestamp() - interval '2 hours')
|
|
""",
|
|
message_id,
|
|
chat_uuid,
|
|
owner_uuid,
|
|
"fault-in-use",
|
|
)
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO message_attachments (message_id, attachment_id, position)
|
|
VALUES ($1, $2, 0)
|
|
""",
|
|
message_id,
|
|
uuid.UUID(used_id),
|
|
)
|
|
|
|
s3client.delete_object(settings, stale_key)
|
|
s3client.delete_object(settings, used_key)
|
|
return {
|
|
"fresh_orphan": {"attachment_id": fresh_id, "object_key": fresh_key, "note": "fresh-orphan"},
|
|
"old_orphan": {"attachment_id": old_id, "object_key": old_key, "note": "old-orphan"},
|
|
"stale_missing": {"attachment_id": stale_id, "object_key": stale_key, "note": "fault-stale-missing"},
|
|
"in_use_missing": {"attachment_id": used_id, "object_key": used_key, "note": "fault-in-use-missing"},
|
|
}
|
|
|
|
|
|
async def _probe(settings, attachment_id: str | None, object_key: str | None) -> dict:
|
|
result = {}
|
|
if attachment_id:
|
|
row = await pool().fetchval("SELECT 1 FROM attachments WHERE id = $1::uuid", uuid.UUID(attachment_id))
|
|
result["metadata"] = row is not None
|
|
if object_key:
|
|
result["object"] = s3client.object_exists(settings, object_key)
|
|
return result
|
|
|
|
|
|
def _anonymous_status(url: str) -> int:
|
|
request = urllib.request.Request(url, method="GET")
|
|
try:
|
|
with urllib.request.urlopen(request, timeout=5) as response:
|
|
return response.status
|
|
except urllib.error.HTTPError as exc:
|
|
return exc.code
|
|
|
|
|
|
async def _check_private(settings) -> dict:
|
|
endpoint = settings.s3_endpoint.rstrip("/")
|
|
object_status = _anonymous_status(f"{endpoint}/{settings.s3_bucket}/o/private-probe-missing")
|
|
list_status = _anonymous_status(f"{endpoint}/{settings.s3_bucket}?list-type=2")
|
|
return {
|
|
"anonymous_object_status": object_status,
|
|
"anonymous_list_status": list_status,
|
|
"private": object_status == 403 and list_status == 403,
|
|
}
|
|
|
|
|
|
async def _run(args) -> dict:
|
|
settings = load_settings()
|
|
await _prepare(settings)
|
|
try:
|
|
if args.cmd == "reconcile":
|
|
if args.apply and args.dry_run:
|
|
raise SystemExit("choose either --apply or --dry-run")
|
|
return await reconcile(settings, apply=bool(args.apply))
|
|
if args.cmd == "inject":
|
|
return await _inject(settings, args.chat_id, args.owner_id)
|
|
if args.cmd == "probe":
|
|
return await _probe(settings, args.attachment_id, args.object_key)
|
|
if args.cmd == "check-private":
|
|
return await _check_private(settings)
|
|
raise SystemExit("unknown command")
|
|
finally:
|
|
await close()
|
|
|
|
|
|
def main() -> None:
|
|
parser = argparse.ArgumentParser(description="Lab operator tools")
|
|
sub = parser.add_subparsers(dest="cmd", required=True)
|
|
reconcile_parser = sub.add_parser("reconcile")
|
|
reconcile_parser.add_argument("--apply", action="store_true")
|
|
reconcile_parser.add_argument("--dry-run", action="store_true")
|
|
inject_parser = sub.add_parser("inject")
|
|
inject_parser.add_argument("--chat-id", required=True)
|
|
inject_parser.add_argument("--owner-id", required=True)
|
|
probe_parser = sub.add_parser("probe")
|
|
probe_parser.add_argument("--attachment-id")
|
|
probe_parser.add_argument("--object-key")
|
|
sub.add_parser("check-private")
|
|
args = parser.parse_args()
|
|
if args.cmd == "reconcile" and not args.apply and not args.dry_run:
|
|
args.dry_run = True
|
|
report = asyncio.run(_run(args))
|
|
json.dump(report, sys.stdout, ensure_ascii=False)
|
|
sys.stdout.write("\n")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|