rpg-westreiche/tools/pdf_sync.py
torsten 2dd6295caf Westreiche: Vault, Werkzeuge und Website
Neuinitialisierung ohne den PDF-Ballast (Regelwerke/Abenteuer/Magazine liegen
auf dem Server, siehe tools/pdf_sync.py und tools/pdf_manifest.json).
Vorherige Historie bewusst verworfen.
2026-11-20 17:20:36 +01:00

351 lines
14 KiB
Python
Executable file
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#!/usr/bin/env python3
"""
Hält die ausgelagerten Regelwerk-/Abenteuer-PDFs zwischen Vault und Webserver synchron.
Warum: Fremdmaterial (Regelwerke, Abenteuer, Magazine) bläht das Git-Repo auf rund
1 GB auf. Es liegt deshalb nicht mehr in Git, sondern auf dem eigenen Server –
**außerhalb von `public_html`**, also für Crawler und Direkt-URLs unerreichbar:
<FTP-Wurzel>/pdf_archiv/blobs/<sha256>.pdf
Der kleine, versionierte Manifest `tools/pdf_manifest.json` (Pfad → SHA-256 + Größe)
sagt einem frischen Checkout, welche Datei wohin gehört. Ablage ist
inhaltsadressiert: Duplikate und Umbenennungen kosten keinen zweiten Upload.
Weil der Blob-Name nur der Hash ist, liegt auf dem Server zusätzlich
`pdf_archiv/index.json` – dieselbe Pfad→Hash-Tabelle. Damit bleibt das Archiv
auch ohne Repo lesbar (`--pull` holt den Index, wenn das Manifest fehlt).
Befehle
-------
tools/pdf_sync.py --scan # Manifest aus den lokalen PDFs neu schreiben
tools/pdf_sync.py --push # fehlende Blobs hochladen
tools/pdf_sync.py --pull # fehlende Blobs herunterladen (frischer Checkout)
tools/pdf_sync.py --check # Abgleich lokal/Remote gegen Manifest
tools/pdf_sync.py --index # nur index.json hochladen
tools/pdf_sync.py --prune --yes # Remote-Blobs löschen, die im Manifest fehlen
Zugang: `credentials.txt` im Repo-Wurzel (FTP_URL, FTP_USER, FTP_PASSWORD), FTPS
explizit (`--ssl-reqd`, wie in `tools/deploy_web.sh`).
Aufgenommen werden alle PDFs über 1 MiB aus `RPG/` und `Druckmaterial/` – **außer**
den selbst erzeugten Handouts (Summarien, SL-Tabellen, SL-Schirm, pdf_export).
"""
from __future__ import annotations
import argparse
import hashlib
import json
import os
import subprocess
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parent.parent
CREDENTIALS = ROOT / "credentials.txt"
MANIFEST = ROOT / "tools" / "pdf_manifest.json"
SCAN_DIRS = ["RPG", "Druckmaterial"]
MIN_SIZE = 1024 * 1024 # 1 MiB: alles Kleinere bleibt in Git
SKIP_PATH_PARTS = {"pdf_export", "SL Schirm"}
SKIP_NAME_PARTS = ("Summarium", "SL-Tabellen", "SL-Schirm")
REMOTE_DIR = os.environ.get("PDF_REMOTE_DIR", "pdf_archiv/blobs")
REMOTE_INDEX = os.environ.get("PDF_REMOTE_INDEX", "pdf_archiv/index.json")
MANIFEST_VERSION = 1
# ------------------------------------------------------------------ Hilfen
def die(msg: str) -> None:
raise SystemExit(f"FEHLER: {msg}")
def credentials() -> tuple[str, str, str]:
if not CREDENTIALS.exists():
die(f"{CREDENTIALS} fehlt (FTP_URL, FTP_USER, FTP_PASSWORD)")
werte: dict[str, str] = {}
for line in CREDENTIALS.read_text(encoding="utf-8").splitlines():
line = line.strip()
if not line or line.startswith("#") or "=" not in line:
continue
k, v = line.split("=", 1)
werte[k.strip()] = v.strip().strip("'\"")
try:
return werte["FTP_URL"], werte["FTP_USER"], werte["FTP_PASSWORD"]
except KeyError as fehlt:
die(f"{fehlt} fehlt in credentials.txt")
def curl(args: list[str], userpass: str | None = None, verbose: bool = False) -> str:
"""curl mit FTPS; Zugangsdaten laufen über stdin-Config (nicht über argv)."""
cmd = ["curl", "-sS", "--ssl-reqd", "--retry", "3", "--retry-delay", "2",
"--connect-timeout", "20", "--ftp-create-dirs"]
if not verbose:
cmd.append("--no-progress-meter")
cmd += args
if userpass:
cmd += ["--config", "-"]
proc = subprocess.run(cmd, input=f'user = "{userpass}"\n', text=True,
capture_output=True)
else:
proc = subprocess.run(cmd, text=True, capture_output=True)
if proc.returncode != 0:
die(f"curl: {proc.stderr.strip() or proc.stdout.strip()}")
return proc.stdout
def sha256(path: Path) -> str:
h = hashlib.sha256()
with path.open("rb") as fh:
for block in iter(lambda: fh.read(1024 * 1024), b""):
h.update(block)
return h.hexdigest()
def is_archived_pdf(path: Path) -> bool:
if path.suffix.lower() != ".pdf" or not path.is_file():
return False
if path.stat().st_size <= MIN_SIZE:
return False
rel = path.relative_to(ROOT)
if any(part in SKIP_PATH_PARTS for part in rel.parts):
return False
if any(teil in path.name for teil in SKIP_NAME_PARTS):
return False
return True
def discover() -> list[Path]:
treffer: list[Path] = []
for wurzel in SCAN_DIRS:
basis = ROOT / wurzel
if basis.exists():
treffer += [p for p in basis.rglob("*.pdf") if is_archived_pdf(p)]
return sorted(treffer)
def load_manifest() -> dict:
if not MANIFEST.exists():
return {"version": MANIFEST_VERSION, "remote_dir": REMOTE_DIR, "files": {}}
return json.loads(MANIFEST.read_text(encoding="utf-8"))
def remote_listing(url: str, userpass: str) -> set[str]:
ziel = f"ftp://{url}/{REMOTE_DIR}/"
try:
ausgabe = curl(["--list-only", ziel], userpass)
except SystemExit:
return set() # Verzeichnis existiert noch nicht
return {z.strip() for z in ausgabe.splitlines() if z.strip() not in ("", ".", "..")}
def index_json(files: dict[str, dict]) -> str:
"""Serverfassung des Manifests – macht das Archiv ohne Repo lesbar."""
return json.dumps({"version": MANIFEST_VERSION, "remote_dir": REMOTE_DIR,
"hinweis": "Pfad -> SHA-256 + Groesse; Blobs liegen unter pdf_archiv/blobs/",
"files": dict(sorted(files.items()))},
indent=2, ensure_ascii=False) + "\n"
def upload_index(url: str, userpass: str, files: dict[str, dict]) -> None:
tmp = ROOT / "tools" / ".pdf_index.tmp"
tmp.write_text(index_json(files), encoding="utf-8")
try:
curl(["-T", str(tmp), f"ftp://{url}/{REMOTE_INDEX}"], userpass)
print(f"Index hochgeladen: {REMOTE_INDEX}")
finally:
tmp.unlink(missing_ok=True)
def fetch_index(url: str, userpass: str) -> dict:
tmp = ROOT / "tools" / ".pdf_index.tmp"
curl(["-o", str(tmp), f"ftp://{url}/{REMOTE_INDEX}"], userpass)
try:
return json.loads(tmp.read_text(encoding="utf-8"))
finally:
tmp.unlink(missing_ok=True)
def mb(n: int) -> str:
return f"{n / 1048576:.1f} MB"
# ------------------------------------------------------------------ Befehle
def cmd_scan(verbose: bool) -> None:
alt = load_manifest()["files"]
neu: dict[str, dict] = {}
for p in discover():
neu[p.relative_to(ROOT).as_posix()] = {"sha256": sha256(p), "size": p.stat().st_size}
geaendert = [k for k, v in neu.items() if alt.get(k, {}).get("sha256") not in (None, v["sha256"])]
dazu = [k for k in neu if k not in alt]
weg = [k for k in alt if k not in neu]
MANIFEST.write_text(json.dumps({"version": MANIFEST_VERSION, "remote_dir": REMOTE_DIR,
"files": dict(sorted(neu.items()))},
indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
blobs = {v["sha256"] for v in neu.values()}
gesamt = sum(v["size"] for v in neu.values())
print(f"Manifest: {len(neu)} Dateien, {len(blobs)} Blobs, {mb(gesamt)} → {MANIFEST.name}")
for titel, menge in (("neu", dazu), ("geändert", geaendert), ("entfernt", weg)):
if menge:
print(f" {titel}: {len(menge)}")
if verbose:
for k in menge:
print(f" {k}")
def cmd_push(verbose: bool, force: bool) -> None:
url, user, pw = credentials()
userpass = f"{user}:{pw}"
files = load_manifest()["files"]
if not files:
die("Manifest ist leer – zuerst --scan laufen lassen")
vorhanden = remote_listing(url, userpass)
offen = [(k, v) for k, v in files.items()
if force or f"{v['sha256']}.pdf" not in vorhanden]
blobs: dict[str, int] = {}
for k, v in offen:
blobs.setdefault(v["sha256"], v["size"])
print(f"Remote: {len(vorhanden)} Blobs · zu laden: {len(blobs)} Blobs "
f"({mb(sum(blobs.values()))}) für {len(offen)} Dateien")
for n, (digest, size) in enumerate(sorted(blobs.items()), 1):
quelle = next((ROOT / k for k, v in files.items() if v["sha256"] == digest), None)
if quelle is None or not quelle.exists():
print(f" [{n}/{len(blobs)}] übersprungen (lokal nicht vorhanden): {digest[:12]}")
continue
if verbose or n == 1 or n == len(blobs) or n % 10 == 0:
print(f" [{n}/{len(blobs)}] {quelle.name} ({mb(size)})")
curl(["-T", str(quelle), f"ftp://{url}/{REMOTE_DIR}/{digest}.pdf"], userpass)
upload_index(url, userpass, files)
print("Upload fertig.")
def cmd_pull(verbose: bool, force: bool) -> None:
url, user, pw = credentials()
userpass = f"{user}:{pw}"
files = load_manifest()["files"]
if not files:
print("Manifest lokal leer – hole pdf_archiv/index.json vom Server …")
files = fetch_index(url, userpass).get("files", {})
if files:
MANIFEST.write_text(index_json(files), encoding="utf-8")
print(f"Manifest aus Server-Index rekonstruiert ({len(files)} Dateien).")
if not files:
die("Manifest ist leer – zuerst --scan laufen lassen")
vorhanden = remote_listing(url, userpass)
fehlend, konflikt, geladen = [], [], 0
for rel, meta in files.items():
ziel = ROOT / rel
digest = meta["sha256"]
if ziel.exists():
if sha256(ziel) != digest:
konflikt.append(rel)
if not force:
continue
else:
continue
if f"{digest}.pdf" not in vorhanden:
fehlend.append(rel)
continue
ziel.parent.mkdir(parents=True, exist_ok=True)
tmp = ziel.with_suffix(ziel.suffix + ".part")
if verbose:
print(f" ↓ {rel}")
curl(["-o", str(tmp), f"ftp://{url}/{REMOTE_DIR}/{digest}.pdf"], userpass)
if sha256(tmp) != digest:
tmp.unlink(missing_ok=True)
die(f"Prüfsumme falsch nach Download: {rel}")
tmp.replace(ziel)
geladen += 1
print(f"Download fertig: {geladen} Dateien geladen, {len(konflikt)} Konflikte, "
f"{len(fehlend)} fehlen auf dem Server")
for rel in konflikt:
print(f" KONFLIKT (lokal anders, nicht überschrieben): {rel}")
for rel in fehlend:
print(f" FEHLT REMOTE: {rel}")
def cmd_check() -> None:
url, user, pw = credentials()
userpass = f"{user}:{pw}"
files = load_manifest()["files"]
vorhanden = remote_listing(url, userpass)
lokal_fehlt, lokal_anders, remote_fehlt = [], [], []
for rel, meta in files.items():
ziel = ROOT / rel
if not ziel.exists():
lokal_fehlt.append(rel)
elif sha256(ziel) != meta["sha256"]:
lokal_anders.append(rel)
if f"{meta['sha256']}.pdf" not in vorhanden:
remote_fehlt.append(rel)
ungelistet = [p.relative_to(ROOT).as_posix() for p in discover()
if p.relative_to(ROOT).as_posix() not in files]
print(f"Manifest: {len(files)} Dateien · Remote-Blobs: {len(vorhanden)}")
print(f" lokal fehlt: {len(lokal_fehlt)}")
print(f" lokal abweichend: {len(lokal_anders)}")
print(f" remote fehlt: {len(remote_fehlt)}")
print(f" nicht im Manifest: {len(ungelistet)}")
for titel, menge in (("lokal fehlt", lokal_fehlt), ("lokal abweichend", lokal_anders),
("remote fehlt", remote_fehlt),):
for rel in menge[:20]:
print(f" {titel}: {rel}")
for rel in ungelistet:
print(f" nicht im Manifest: {rel}")
def cmd_prune(yes: bool, verbose: bool) -> None:
url, user, pw = credentials()
userpass = f"{user}:{pw}"
gebraucht = {f"{v['sha256']}.pdf" for v in load_manifest()["files"].values()}
vorhanden = remote_listing(url, userpass)
ueberzaehlig = sorted(vorhanden - gebraucht)
if not ueberzaehlig:
print("Nichts zu löschen.")
return
print(f"{len(ueberzaehlig)} Blobs ohne Manifest-Eintrag:")
for name in ueberzaehlig:
print(f" {name}")
if not yes:
print("Zum Löschen mit --yes erneut aufrufen.")
return
for name in ueberzaehlig:
if verbose:
print(f" DELE {name}")
curl(["-Q", f"DELE /{REMOTE_DIR}/{name}", f"ftp://{url}/"], userpass)
print("Gelöscht.")
def main() -> None:
ap = argparse.ArgumentParser(description="PDF-Archiv zwischen Vault und Server syncen")
g = ap.add_mutually_exclusive_group()
g.add_argument("--scan", action="store_true", help="Manifest aus lokalen PDFs schreiben")
g.add_argument("--push", action="store_true", help="fehlende Blobs hochladen")
g.add_argument("--pull", action="store_true", help="fehlende Blobs herunterladen")
g.add_argument("--check", action="store_true", help="Abgleich lokal/Remote")
g.add_argument("--index", action="store_true", help="nur index.json hochladen")
g.add_argument("--prune", action="store_true", help="Remote-Blobs ohne Manifest löschen")
ap.add_argument("--force", action="store_true", help="vorhandene/gleichnamige Dateien überschreiben")
ap.add_argument("--yes", action="store_true", help="Löschen bestätigen (--prune)")
ap.add_argument("-v", "--verbose", action="store_true")
args = ap.parse_args()
if args.scan or not any([args.push, args.pull, args.check, args.prune, args.index]):
cmd_scan(args.verbose)
if args.push:
cmd_push(args.verbose, args.force)
if args.pull:
cmd_pull(args.verbose, args.force)
if args.check:
cmd_check()
if args.index:
url, user, pw = credentials()
files = load_manifest()["files"]
if not files:
die("Manifest ist leer – zuerst --scan laufen lassen")
upload_index(url, f"{user}:{pw}", files)
if args.prune:
cmd_prune(args.yes, args.verbose)
if __name__ == "__main__":
main()