diff --git a/abgleich.py b/abgleich.py new file mode 100644 index 0000000..cb228f9 --- /dev/null +++ b/abgleich.py @@ -0,0 +1,285 @@ +""" +Abgleich der lokalen Akten mit dem Server. + +Die lokalen Akten bleiben Arbeitskopie und Zwischenspeicher: Das Programm +startet und speichert auch ohne Internet. Wer angemeldet ist, bekommt sie +auf den Server gespiegelt - und auf einem zweiten Rechner wieder herunter. + +Neben jeder Akte liegt server.json mit dem Stand des letzten Abgleichs: +Server-ID, Version, Pruefwert des Inhalts und Kennung des Portraets. Ein +Pruefwert statt der Aenderungszeit: Die ist nur sekundengenau, eine +Aenderung in derselben Sekunde wie der Abgleich ginge sonst verloren. +Daran laesst sich ablesen, wo sich seitdem etwas geaendert hat: + + nur lokal -> hochladen + nur Server -> herunterladen + beides -> Konflikt: die Serverfassung wird als + konflikt-.json neben die Akte gelegt, dann gilt + die lokale Fassung + auf dem Server geloescht (etwa von der Verwaltung) + -> lokal in den Papierkorb, nicht endgueltig weg + +Ohne tkinter; laeuft im Hintergrund-Thread. Aendert der Abgleich lokale +Dateien, meldet er die betroffenen Akten zurueck - die Oberflaeche laedt +sie dann neu. +""" + +import base64 +import datetime +import hashlib +import json +import os +import threading + +import akte_modell as modell +import konto + +META = "server.json" +LOESCHLISTE = "_abgleich_loeschen.json" +INHALT = ("personalien", "dienst", "beschreibung", "auszeichnungen", "einsaetze", "vermerke") + +# Nie zwei Abgleiche gleichzeitig - etwa Zeitgeber und Knopf +_laeuft = threading.Lock() + + +def _schreiben(pfad, daten): + pfad.parent.mkdir(parents=True, exist_ok=True) + zwischen = pfad.with_name(pfad.name + ".tmp") + zwischen.write_text(json.dumps(daten, ensure_ascii=False, indent=2), encoding="utf-8") + os.replace(zwischen, pfad) + + +def meta_laden(akte_id, nutzer_id=None): + """Stand des letzten Abgleichs; None, wenn nie oder fuer ein anderes Konto abgeglichen.""" + try: + meta = json.loads((modell.ordner_von(akte_id) / META).read_text(encoding="utf-8")) + except (OSError, ValueError, modell.AktenFehler): + return None + if not isinstance(meta, dict) or (nutzer_id is not None and meta.get("nutzer_id") != nutzer_id): + return None + return meta + + +def _meta_speichern(akte_id, meta): + _schreiben(modell.ordner_von(akte_id) / META, meta) + + +def _portraet_hash(akte_id): + pfad = modell.portraet_pfad(akte_id) + return hashlib.sha256(pfad.read_bytes()).hexdigest() if pfad else "" + + +def _loeschliste_pfad(): + return modell.AKTEN_ORDNER / LOESCHLISTE + + +def _loeschliste(): + try: + daten = json.loads(_loeschliste_pfad().read_text(encoding="utf-8")) + return [e for e in daten if isinstance(e, dict) and "lokale_id" in e] + except (OSError, ValueError): + return [] + + +def loeschen_vormerken(akte_id): + """ + Vor dem Verschieben in den Papierkorb aufrufen: War die Akte schon auf + dem Server, wird sie dort beim naechsten Abgleich geloescht. + """ + meta = meta_laden(akte_id) + if not meta: + return + liste = [e for e in _loeschliste() if e["lokale_id"] != akte_id] + liste.append({"lokale_id": akte_id, "nutzer_id": meta.get("nutzer_id")}) + _schreiben(_loeschliste_pfad(), liste) + + +def ausstehend(): + """Grob: gibt es lokale Aenderungen, die noch nicht auf dem Server sind?""" + stand = konto.sitzung() + if not stand: + return False + nutzer_id = stand["nutzer"].get("id") + if any(e.get("nutzer_id") == nutzer_id for e in _loeschliste()): + return True + for akte in modell.alle_akten(): + meta = meta_laden(akte["id"], nutzer_id) + if meta is None or meta.get("inhalt") != inhalt_hash(akte) \ + or meta.get("portraet_hash", "") != _portraet_hash(akte["id"]): + return True + return False + + +def inhalt_hash(akte): + """Pruefwert ueber die Felder, die der Nutzer bearbeitet.""" + inhalt = {feld: (akte or {}).get(feld) for feld in INHALT} + text = json.dumps(inhalt, ensure_ascii=False, sort_keys=True) + return hashlib.sha256(text.encode("utf-8")).hexdigest() + + +def _gleicher_inhalt(akte, daten): + return inhalt_hash(akte) == inhalt_hash(daten) + + +class _Lauf: + def __init__(self, nutzer_id): + self.nutzer_id = nutzer_id + self.ergebnis = {"hochgeladen": 0, "heruntergeladen": 0, "entfernt": 0, + "konflikte": 0, "geaendert": set()} + + # -- Akten -------------------------------------------------------------- + + def hochladen(self, akte, basis_version, erzwingen=False): + try: + charakter = konto.aufrufen("charakter_speichern", lokale_id=akte["id"], daten=akte, + basis_version=basis_version, erzwingen=erzwingen)["charakter"] + except konto.ServerFehler as fehler: + if fehler.code != "konflikt" or erzwingen: + raise + # Zwischen Liste und Hochladen hat ein anderer Rechner gespeichert + self.sichern(akte["id"], fehler.extra.get("charakter", {}).get("daten")) + return self.hochladen(akte, None, erzwingen=True) + self.ergebnis["hochgeladen"] += 1 + if charakter["aktennummer"] and charakter["aktennummer"] != akte.get("aktennummer"): + # Die Nummer vergibt der Server, damit sie ueber alle Spieler eindeutig ist + akte["aktennummer"] = charakter["aktennummer"] + modell.speichern(akte, zeit_setzen=False) + self.ergebnis["geaendert"].add(akte["id"]) + return charakter + + def herunterladen(self, charakter): + akte = modell.migrieren(dict(charakter["daten"] or {})) + akte["id"] = charakter["lokale_id"] + akte["aktennummer"] = charakter["aktennummer"] or akte.get("aktennummer", "") + akte["geaendert"] = akte.get("geaendert") or modell.zeitstempel() + akte["erstellt"] = akte.get("erstellt") or akte["geaendert"] + modell.speichern(akte, zeit_setzen=False) + self.ergebnis["heruntergeladen"] += 1 + self.ergebnis["geaendert"].add(akte["id"]) + return akte + + def sichern(self, akte_id, daten): + """Serverfassung neben die Akte legen, bevor die lokale sie ueberschreibt.""" + if not daten: + return + zeit = datetime.datetime.now().strftime("%Y%m%d-%H%M%S") + _schreiben(modell.ordner_von(akte_id) / f"konflikt-{zeit}.json", daten) + self.ergebnis["konflikte"] += 1 + + # -- Portraets ------------------------------------------------------------ + + def portraet(self, akte_id, charakter, meta): + lokal = _portraet_hash(akte_id) + kennung = charakter.get("portraet_kennung") + if lokal != meta.get("portraet_hash", ""): + if lokal: + bild = base64.b64encode(modell.portraet_pfad(akte_id).read_bytes()).decode("ascii") + kennung = konto.aufrufen("portraet_hochladen", lokale_id=akte_id, + bild=bild)["charakter"].get("portraet_kennung") + elif charakter.get("portraet"): + konto.aufrufen("portraet_entfernen", lokale_id=akte_id) + kennung = None + elif kennung != meta.get("portraet_kennung"): + daten = konto.bild(charakter["id"]) if kennung else None + if daten: + ordner = modell.ordner_von(akte_id) + zwischen = ordner / (modell.PORTRAET + ".tmp") + zwischen.write_bytes(daten) + os.replace(zwischen, ordner / modell.PORTRAET) + else: + modell.portraet_entfernen(akte_id) + lokal = _portraet_hash(akte_id) + self.ergebnis["geaendert"].add(akte_id) + meta["portraet_hash"] = lokal + meta["portraet_kennung"] = kennung + + def meta_nach(self, akte, charakter, alt=None): + meta = dict(alt or {"portraet_hash": "", "portraet_kennung": None}) + meta.update({"nutzer_id": self.nutzer_id, "server_id": charakter["id"], + "version": charakter["version"], "inhalt": inhalt_hash(akte)}) + return meta + + # -- Ablauf --------------------------------------------------------------- + + def loeschungen(self): + rest = [] + fehler_ = None + for eintrag in _loeschliste(): + if eintrag.get("nutzer_id") != self.nutzer_id or fehler_ is not None: + rest.append(eintrag) + continue + try: + konto.aufrufen("charakter_loeschen", lokale_id=eintrag["lokale_id"]) + except konto.ServerFehler as fehler: + if fehler.code != "charakter_nicht_gefunden": + rest.append(eintrag) + fehler_ = fehler + if rest: + _schreiben(_loeschliste_pfad(), rest) + else: + _loeschliste_pfad().unlink(missing_ok=True) + if fehler_ is not None: + raise fehler_ + return {e["lokale_id"] for e in rest} + + def ausfuehren(self): + noch_zu_loeschen = self.loeschungen() + server = {c["lokale_id"]: c for c in konto.aufrufen("charaktere_eigene")["charaktere"]} + + for akte in modell.alle_akten(): + akte_id = akte["id"] + meta = meta_laden(akte_id, self.nutzer_id) + charakter = server.pop(akte_id, None) + + if charakter is None: + if meta is not None: + modell.in_papierkorb(akte_id) + self.ergebnis["entfernt"] += 1 + self.ergebnis["geaendert"].add(akte_id) + continue + charakter = self.hochladen(akte, None) + elif meta is None: + # Auf dem Server vorhanden, von hier aus aber nie abgeglichen + if not _gleicher_inhalt(akte, charakter["daten"]): + self.sichern(akte_id, charakter["daten"]) + charakter = self.hochladen(akte, charakter["version"], erzwingen=True) + else: + lokal_neu = inhalt_hash(akte) != meta.get("inhalt") + server_neu = charakter["version"] != meta.get("version") + if lokal_neu and server_neu: + self.sichern(akte_id, charakter["daten"]) + charakter = self.hochladen(akte, charakter["version"], erzwingen=True) + elif lokal_neu: + charakter = self.hochladen(akte, charakter["version"]) + elif server_neu: + akte = self.herunterladen(charakter) + + meta = self.meta_nach(akte, charakter, meta) + self.portraet(akte_id, charakter, meta) + _meta_speichern(akte_id, meta) + + for akte_id, charakter in server.items(): + if akte_id in noch_zu_loeschen: + continue + akte = self.herunterladen(charakter) + meta = self.meta_nach(akte, charakter) + self.portraet(akte_id, charakter, meta) + _meta_speichern(akte_id, meta) + return self.ergebnis + + +def abgleichen(): + """ + Ein vollstaendiger Abgleich. Gibt ein Ergebnis mit Zaehlern und der Menge + "geaendert" (lokal veraenderte Akten) zurueck, wirft ServerFehler. + Laeuft schon ein Abgleich, wird nichts getan und None zurueckgegeben. + """ + stand = konto.sitzung() + if not stand: + raise konto.ServerFehler("nicht_angemeldet", "Bitte melde dich an.") + if not _laeuft.acquire(blocking=False): + return None + try: + return _Lauf(stand["nutzer"]["id"]).ausfuehren() + finally: + _laeuft.release() diff --git a/akte_modell.py b/akte_modell.py index 3fac5f2..33c3992 100644 --- a/akte_modell.py +++ b/akte_modell.py @@ -120,9 +120,16 @@ def naechste_aktennummer(jahr=None): return f"SM-{jahr}-{hoechste + 1:04d}" -def speichern(akte): - """Schreibt die Akte atomar und haelt die vorige Fassung als .bak.""" - akte["geaendert"] = zeitstempel() +def speichern(akte, zeit_setzen=True): + """ + Schreibt die Akte atomar und haelt die vorige Fassung als .bak. + + zeit_setzen=False nutzt der Abgleich, wenn er Daten vom Server + uebernimmt: Die Aenderungszeit bleibt dann die des Servers, sonst + saehe die Akte beim naechsten Abgleich wie lokal geaendert aus. + """ + if zeit_setzen or not akte.get("geaendert"): + akte["geaendert"] = zeitstempel() ordner = ordner_von(akte["id"]) ordner.mkdir(parents=True, exist_ok=True) ziel = ordner / DATEI diff --git a/hintergrund.py b/hintergrund.py new file mode 100644 index 0000000..53e26ed --- /dev/null +++ b/hintergrund.py @@ -0,0 +1,46 @@ +""" +Arbeit im Hintergrund, Ergebnis im Hauptthread von tkinter. + +Netzwerkaufrufe duerfen die Oberflaeche nicht einfrieren, und tkinter +darf nur aus dem Hauptthread angefasst werden. Die Arbeit laeuft deshalb +in einem Thread, das Ergebnis landet in einer Warteschlange, die der +Hauptthread regelmaessig leert und an die Rueckrufe verteilt. +""" + +import queue +import threading +import tkinter as tk + + +class Hintergrund: + def __init__(self, widget, takt_ms=60): + self.widget = widget + self.takt_ms = takt_ms + self._warteschlange = queue.Queue() + self._pollen() + + def starten(self, arbeit, fertig=None, fehler=None): + """arbeit() im Thread; danach fertig(ergebnis) oder fehler(ausnahme) im Hauptthread.""" + def lauf(): + try: + ergebnis = arbeit() + except Exception as ausnahme: # noqa: BLE001 - wird im Hauptthread gemeldet + self._warteschlange.put((fehler, ausnahme, True)) + else: + self._warteschlange.put((fertig, ergebnis, False)) + threading.Thread(target=lauf, daemon=True).start() + + def _pollen(self): + try: + while True: + rueckruf, wert, ist_fehler = self._warteschlange.get_nowait() + if rueckruf is not None: + rueckruf(wert) + elif ist_fehler: + self.widget.report_callback_exception(type(wert), wert, wert.__traceback__) + except queue.Empty: + pass + try: + self.widget.after(self.takt_ms, self._pollen) + except tk.TclError: + pass # Fenster geschlossen diff --git a/konto.py b/konto.py new file mode 100644 index 0000000..95a19aa --- /dev/null +++ b/konto.py @@ -0,0 +1,230 @@ +""" +Verbindung zum Server sva.tyrveil.com: Konto, Akten und Squads. + +Ohne tkinter. Alle Aufrufe blockieren und gehoeren in einen +Hintergrund-Thread (siehe hintergrund.py). + +Das Sitzungstoken liegt in %APPDATA%\\SquadManager\\konto.json, mit der +Windows-Datenschutz-API (DPAPI) an das Windows-Konto gebunden: Eine auf +einen anderen Rechner kopierte Datei ist dort wertlos. +""" + +import base64 +import ctypes +import ctypes.wintypes as wintypes +import json +import os +import socket +import threading +import urllib.error +import urllib.parse +import urllib.request +from pathlib import Path + +# Fuer Tests laesst sich ein lokaler Server einsetzen, nur ueber http://127.0.0.1 +SERVER = os.environ.get("SM_SERVER", "https://sva.tyrveil.com").rstrip("/") +KONTO_DATEI = Path(os.getenv("APPDATA", ".")) / "SquadManager" / "konto.json" +ZEITLIMIT = 25 + + +class ServerFehler(Exception): + """Fehler vom oder auf dem Weg zum Server, mit Code und lesbarer Meldung.""" + + def __init__(self, code, meldung, http=0, extra=None): + super().__init__(meldung) + self.code = code + self.meldung = meldung + self.http = http + self.extra = extra or {} + + +def _adresse_pruefen(): + teile = urllib.parse.urlsplit(SERVER) + if teile.scheme == "https": + return + if teile.scheme == "http" and teile.hostname in ("127.0.0.1", "localhost"): + return + raise ServerFehler("unsicher", "Der Server muss über HTTPS erreichbar sein.") + + +# -- Token geschuetzt ablegen ------------------------------------------------ + +class _BLOB(ctypes.Structure): + _fields_ = [("cbData", wintypes.DWORD), ("pbData", ctypes.POINTER(ctypes.c_char))] + + +def _dpapi(daten, schuetzen): + crypt32 = ctypes.WinDLL("crypt32", use_last_error=True) + kernel32 = ctypes.WinDLL("kernel32", use_last_error=True) + funktion = crypt32.CryptProtectData if schuetzen else crypt32.CryptUnprotectData + funktion.argtypes = (ctypes.POINTER(_BLOB), ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, + ctypes.c_void_p, wintypes.DWORD, ctypes.POINTER(_BLOB)) + funktion.restype = wintypes.BOOL + kernel32.LocalFree.argtypes = (ctypes.c_void_p,) + puffer = ctypes.create_string_buffer(daten, len(daten)) + ein = _BLOB(len(daten), ctypes.cast(puffer, ctypes.POINTER(ctypes.c_char))) + aus = _BLOB() + CRYPTPROTECT_UI_FORBIDDEN = 0x01 + if not funktion(ctypes.byref(ein), None, None, None, None, CRYPTPROTECT_UI_FORBIDDEN, ctypes.byref(aus)): + raise OSError(ctypes.get_last_error(), "DPAPI") + try: + return ctypes.string_at(aus.pbData, aus.cbData) + finally: + kernel32.LocalFree(ctypes.cast(aus.pbData, ctypes.c_void_p)) + + +_sperre = threading.Lock() +_sitzung = None +_geladen = False + + +def sitzung(): + """Die gespeicherte Anmeldung {"token", "nutzer"} oder None.""" + global _sitzung, _geladen + with _sperre: + if not _geladen: + _geladen = True + try: + roh = json.loads(KONTO_DATEI.read_text(encoding="utf-8")) + # Eine Anmeldung gilt nur fuer den Server, bei dem sie entstand + if roh.get("server") == SERVER: + token = _dpapi(base64.b64decode(roh["token"]), False).decode("ascii") + _sitzung = {"token": token, "nutzer": roh.get("nutzer") or {}} + except (OSError, ValueError, KeyError, TypeError): + _sitzung = None + return dict(_sitzung) if _sitzung else None + + +def _merken(token, nutzer): + global _sitzung, _geladen + KONTO_DATEI.parent.mkdir(parents=True, exist_ok=True) + zwischen = KONTO_DATEI.with_suffix(".tmp") + zwischen.write_text(json.dumps({ + "server": SERVER, + "token": base64.b64encode(_dpapi(token.encode("ascii"), True)).decode("ascii"), + "nutzer": nutzer, + }, ensure_ascii=False, indent=2), encoding="utf-8") + os.replace(zwischen, KONTO_DATEI) + with _sperre: + _sitzung, _geladen = {"token": token, "nutzer": nutzer}, True + + +def _vergessen(): + global _sitzung, _geladen + with _sperre: + _sitzung, _geladen = None, True + try: + KONTO_DATEI.unlink() + except OSError: + pass + + +# -- Aufrufe ------------------------------------------------------------------- + +def anfrage(aktion, token=None, **felder): + """Ruft eine Aktion der Schnittstelle auf. Gibt die Antwort zurueck oder wirft ServerFehler.""" + _adresse_pruefen() + kopf = {"Content-Type": "application/json", "User-Agent": "SquadManager"} + if token: + kopf["X-SM-Token"] = token + koerper = json.dumps({"aktion": aktion, **felder}, ensure_ascii=False).encode("utf-8") + anfrage_ = urllib.request.Request(SERVER + "/api/", data=koerper, headers=kopf, method="POST") + http = 200 + try: + with urllib.request.urlopen(anfrage_, timeout=ZEITLIMIT) as antwort: + text = antwort.read() + except urllib.error.HTTPError as fehler: + http, text = fehler.code, fehler.read() + except (urllib.error.URLError, OSError) as fehler: + raise ServerFehler("offline", "Keine Verbindung zum Server. Besteht eine Internetverbindung?") from fehler + try: + daten = json.loads(text.decode("utf-8")) + except ValueError: + raise ServerFehler("serverfehler", f"Der Server antwortet nicht wie erwartet (HTTP {http}).", http) from None + if not isinstance(daten, dict) or daten.get("ok") is not True: + daten = daten if isinstance(daten, dict) else {} + code = daten.get("fehler", "serverfehler") + if code == "nicht_angemeldet" and token: + _vergessen() + raise ServerFehler(code, daten.get("meldung", "Unbekannter Fehler vom Server."), http, daten) + return daten + + +def aufrufen(aktion, **felder): + """Wie anfrage(), mit dem Token der gespeicherten Anmeldung.""" + stand = sitzung() + if not stand: + raise ServerFehler("nicht_angemeldet", "Bitte melde dich an.") + return anfrage(aktion, token=stand["token"], **felder) + + +def angemeldet(): + return sitzung() is not None + + +def nutzer(): + stand = sitzung() + return stand["nutzer"] if stand else None + + +def registrieren(benutzername, email, passwort): + return anfrage("registrieren", benutzername=benutzername, email=email, passwort=passwort) + + +def anmelden(login, passwort): + antwort = anfrage("anmelden", login=login, passwort=passwort, geraet=socket.gethostname()[:100]) + _merken(antwort["token"], antwort["nutzer"]) + return antwort["nutzer"] + + +def abmelden(): + stand = sitzung() + try: + if stand: + anfrage("abmelden", token=stand["token"]) + except ServerFehler: + pass + finally: + _vergessen() + + +def pruefen(): + """Fragt, ob die gespeicherte Anmeldung noch gilt. Aktualisiert die Nutzerdaten.""" + stand = sitzung() + if not stand: + return None + antwort = anfrage("ich", token=stand["token"]) + if antwort["nutzer"] != stand["nutzer"]: + _merken(stand["token"], antwort["nutzer"]) + return antwort["nutzer"] + + +def bestaetigung_erneut(email): + return anfrage("bestaetigung_erneut", email=email) + + +def passwort_vergessen(email): + return anfrage("passwort_vergessen", email=email) + + +def bild(charakter_id): + """Portraet eines Charakters als PNG-Bytes oder None.""" + _adresse_pruefen() + stand = sitzung() + if not stand: + raise ServerFehler("nicht_angemeldet", "Bitte melde dich an.") + anfrage_ = urllib.request.Request(f"{SERVER}/api/bild.php?id={int(charakter_id)}", + headers={"X-SM-Token": stand["token"], "User-Agent": "SquadManager"}) + try: + with urllib.request.urlopen(anfrage_, timeout=ZEITLIMIT) as antwort: + return antwort.read(16 * 1024 * 1024) + except urllib.error.HTTPError as fehler: + if fehler.code == 404: + return None + raise ServerFehler("serverfehler", f"Porträt nicht abrufbar (HTTP {fehler.code}).", fehler.code) from None + except (urllib.error.URLError, OSError) as fehler: + raise ServerFehler("offline", "Keine Verbindung zum Server.") from fehler + + +def webseite(pfad): + return SERVER + pfad diff --git a/server/sva-privat/app/charaktere.php b/server/sva-privat/app/charaktere.php index 2f21c44..0bb696f 100644 --- a/server/sva-privat/app/charaktere.php +++ b/server/sva-privat/app/charaktere.php @@ -51,6 +51,15 @@ final class Charaktere ]; } + /** + * Wechselt mit jedem neuen Portraet (der Dateiname ist zufaellig). Daran + * erkennt ein zweiter Rechner, dass er das Bild neu laden muss. + */ + private static function kennung(array $zeile): ?string + { + return $zeile['portraet'] === null ? null : basename((string) $zeile['portraet'], '.png'); + } + /** Vollstaendige Sicht auf einen eigenen Charakter. */ public static function eigeneZeile(array $zeile): array { @@ -61,6 +70,7 @@ final class Charaktere 'version' => (int) $zeile['version'], 'geaendert_am' => $zeile['geaendert_am'], 'portraet' => $zeile['portraet'] !== null, + 'portraet_kennung' => self::kennung($zeile), 'squad' => self::squadKurz($zeile), 'daten' => json_decode($zeile['daten'], true) ?: new stdClass(), ]; @@ -83,6 +93,7 @@ final class Charaktere 'spieler' => $zeile['spieler'], 'eigener' => (int) $zeile['nutzer_id'] === (int) $betrachter['id'], 'portraet' => $zeile['portraet'] !== null, + 'portraet_kennung' => self::kennung($zeile), 'squad' => self::squadKurz($zeile), 'geaendert_am' => $zeile['geaendert_am'], ]; diff --git a/werkzeuge/abgleich_test.py b/werkzeuge/abgleich_test.py new file mode 100644 index 0000000..5b8a546 --- /dev/null +++ b/werkzeuge/abgleich_test.py @@ -0,0 +1,243 @@ +""" +Test des Akten-Abgleichs mit zwei simulierten Rechnern. + +Startet den lokalen Testserver aus server_test.py. Jeder "Rechner" ist ein +eigener Python-Prozess mit eigenem %APPDATA% - so wie zwei echte PCs mit +demselben Konto. Beruehrt weder echte Akten noch den echten Server. + +Aufruf: .venv\\Scripts\\python.exe werkzeuge\\abgleich_test.py +""" + +import json +import os +import re +import subprocess +import sys +import tempfile +import urllib.parse +from pathlib import Path + +WURZEL = Path(__file__).resolve().parent.parent +sys.path.insert(0, str(Path(__file__).resolve().parent)) + + +# -- Ein Rechner: wird als eigener Prozess mit "pc" aufgerufen ---------------- + +def rechner_befehl(aktion, parameter): + sys.path.insert(0, str(WURZEL)) + import hashlib + + from PIL import Image + + import abgleich + import akte_modell as modell + import konto + + def portraet_setzen(akte_id, farbe): + pfad = Path(tempfile.gettempdir()) / f"sm_test_{akte_id}.jpg" + Image.new("RGB", (400, 500), tuple(farbe)).save(pfad, "JPEG") + modell.portraet_setzen(akte_id, pfad) + pfad.unlink() + + if aktion == "anmelden": + return konto.anmelden(parameter["login"], parameter["passwort"]) + if aktion == "akte_anlegen": + akte = modell.neu_anlegen() + akte["personalien"]["callsign"] = parameter["callsign"] + akte["dienst"].update({"fraktion": "Bundeswehr", "teilstreitkraft": "Heer", "rang": "Feldwebel"}) + modell.speichern(akte) + if parameter.get("farbe"): + portraet_setzen(akte["id"], parameter["farbe"]) + return akte["id"] + if aktion == "rang": + akte = modell.laden(parameter["id"]) + akte["dienst"]["rang"] = parameter["rang"] + modell.speichern(akte) + return True + if aktion == "portraet": + portraet_setzen(parameter["id"], parameter["farbe"]) + return True + if aktion == "papierkorb": + abgleich.loeschen_vormerken(parameter["id"]) + modell.in_papierkorb(parameter["id"]) + return True + if aktion == "abgleichen": + ergebnis = abgleich.abgleichen() + return {**ergebnis, "geaendert": sorted(ergebnis["geaendert"])} + if aktion == "ausstehend": + return abgleich.ausstehend() + if aktion == "akten": + liste = [] + for akte in modell.alle_akten(): + pfad = modell.portraet_pfad(akte["id"]) + ordner = modell.ordner_von(akte["id"]) + liste.append({ + "id": akte["id"], "aktennummer": akte["aktennummer"], + "callsign": akte["personalien"]["callsign"], "rang": akte["dienst"]["rang"], + "portraet": hashlib.sha256(pfad.read_bytes()).hexdigest() if pfad else "", + "konflikte": len(list(ordner.glob("konflikt-*.json"))), + "meta": abgleich.meta_laden(akte["id"]), + }) + return liste + if aktion == "konto_datei": + return konto.KONTO_DATEI.read_text(encoding="utf-8") + raise ValueError(aktion) + + +class Rechner: + server = None + + def __init__(self, name, basis): + self.name = name + self.appdata = tempfile.mkdtemp(prefix=f"sm_pc_{name}_") + self.basis = basis + + def __call__(self, aktion, **parameter): + umgebung = dict(os.environ, APPDATA=self.appdata, SM_SERVER=self.basis, PYTHONIOENCODING="utf-8") + lauf = subprocess.run([sys.executable, __file__, "pc", aktion, json.dumps(parameter)], + capture_output=True, text=True, encoding="utf-8", env=umgebung, timeout=120) + zeilen = [z for z in lauf.stdout.splitlines() if z.startswith("ERGEBNIS ")] + if not zeilen: + raise RuntimeError(f"{self.name}.{aktion} gescheitert:\n{lauf.stdout}\n{lauf.stderr}") + antwort = json.loads(zeilen[-1][len("ERGEBNIS "):]) + if "fehler" in antwort: + print(f" ({self.name}.{aktion}: {antwort['fehler']} - {antwort.get('meldung')})") + if antwort["fehler"] == "offline" and Rechner.server is not None and "127.0.0.1:9" not in self.basis: + print(f" (Testserver läuft noch: {Rechner.server.laeuft()})") + import time + print(f" (Zeit jetzt {time.strftime('%H:%M:%S')}, letzte Zeilen des PHP-Servers:)\n" + + Rechner.server.php_protokoll(40)) + return antwort + return antwort["wert"] + + +# -- Ablauf ------------------------------------------------------------------- + +def main(): + import server_test as st + from server_test import pruefe + + server = st.Server() + try: + ablauf(server, pruefe) + finally: + log = server.daten / "fehler.log" + inhalt = log.read_text(encoding="utf-8") if log.exists() else "" + pruefe("fehler.log des Servers leer", not inhalt.strip(), inhalt[-600:]) + server.beenden() + print(f"\nERGEBNIS: {st.ergebnisse['ok']} bestanden, {st.ergebnisse['fehl']} fehlgeschlagen") + sys.exit(1 if st.ergebnisse["fehl"] else 0) + + +def ablauf(server, pruefe): + import server_test as st + + print("Vorbereitung") + code, html, _ = server.roh("/einrichten.php", {"schluessel": st.SCHLUESSEL}) + pruefe("Testserver eingerichtet", "Tabellen vorhanden" in html.decode(), html[-300:]) + code, antwort = server.api("registrieren", benutzername="danny", email="danny@example.org", + passwort="dannypasswort1") + pruefe("Konto registriert", antwort.get("ok"), antwort) + link = server.link_aus_mail("danny@example.org") + teile = urllib.parse.urlparse(link) + code, html, _ = server.roh(teile.path + "?" + teile.query) + pruefe("E-Mail bestätigt", "bestätigt" in html.decode()) + + Rechner.server = server + a = Rechner("A", server.basis) + b = Rechner("B", server.basis) + + print("Erstes Hochladen (Rechner A)") + nordlicht = a("akte_anlegen", callsign="Nordlicht", farbe=[60, 80, 50]) + frost = a("akte_anlegen", callsign="Frost") + pruefe("ohne Anmeldung nichts ausstehend", a("ausstehend") is False) + pruefe("Anmeldung", a("anmelden", login="danny", passwort="dannypasswort1").get("benutzername") == "danny") + datei = a("konto_datei") + pruefe("Token nicht im Klartext gespeichert", not re.search(r"[0-9a-f]{64}", datei), datei[:120]) + pruefe("vor dem Abgleich ausstehend", a("ausstehend") is True) + erg = a("abgleichen") + pruefe("zwei Akten hochgeladen", erg["hochgeladen"] == 2, erg) + akten_a = {x["callsign"]: x for x in a("akten")} + pruefe("Server-Nummern übernommen, Meta geschrieben", + all(x["meta"] and x["meta"]["server_id"] and re.fullmatch(r"SM-\d{4}-\d{4}", x["aktennummer"]) + for x in akten_a.values()), akten_a) + pruefe("Porträt-Kennung gemerkt", akten_a["Nordlicht"]["meta"]["portraet_kennung"], akten_a["Nordlicht"]["meta"]) + pruefe("danach nichts ausstehend", a("ausstehend") is False) + erg = a("abgleichen") + pruefe("zweiter Abgleich tut nichts", erg["hochgeladen"] == 0 and erg["heruntergeladen"] == 0, erg) + + print("Zweiter Rechner (B)") + b("anmelden", login="danny@example.org", passwort="dannypasswort1") + erg = b("abgleichen") + pruefe("zwei Akten heruntergeladen", erg["heruntergeladen"] == 2 and len(erg["geaendert"]) == 2, erg) + akten_b = {x["callsign"]: x for x in b("akten")} + pruefe("gleiche IDs und Nummern wie auf A", + {k: (v["id"], v["aktennummer"]) for k, v in akten_b.items()} + == {k: (v["id"], v["aktennummer"]) for k, v in akten_a.items()}, akten_b) + pruefe("Porträt mit heruntergeladen", akten_b["Nordlicht"]["portraet"] != "" and akten_b["Frost"]["portraet"] == "") + erg = b("abgleichen") + pruefe("B: zweiter Abgleich tut nichts", + erg["hochgeladen"] == 0 and erg["heruntergeladen"] == 0 and not erg["geaendert"], erg) + + print("Änderung wandert von B nach A") + b("rang", id=nordlicht, rang="Hauptfeldwebel") + erg = b("abgleichen") + pruefe("B hochgeladen", erg.get("hochgeladen") == 1, erg) + erg = a("abgleichen") + pruefe("A heruntergeladen", erg["heruntergeladen"] == 1 and nordlicht in erg["geaendert"], erg) + pruefe("A hat den neuen Rang", {x["id"]: x["rang"] for x in a("akten")}[nordlicht] == "Hauptfeldwebel") + + print("Konflikt: beide ändern dieselbe Akte") + a("rang", id=frost, rang="Stabsfeldwebel") + b("rang", id=frost, rang="Oberstabsfeldwebel") + erg = a("abgleichen") + pruefe("A lädt zuerst hoch", erg.get("hochgeladen") == 1, erg) + erg = b("abgleichen") + pruefe("B erkennt Konflikt", erg["konflikte"] == 1 and erg["hochgeladen"] == 1, erg) + frost_b = {x["id"]: x for x in b("akten")}[frost] + pruefe("B behält eigene Fassung, Serverfassung gesichert", + frost_b["rang"] == "Oberstabsfeldwebel" and frost_b["konflikte"] == 1, frost_b) + a("abgleichen") + pruefe("A übernimmt Bs Fassung", {x["id"]: x["rang"] for x in a("akten")}[frost] == "Oberstabsfeldwebel") + + print("Porträt geändert") + b("portraet", id=frost, farbe=[150, 40, 40]) + pruefe("B lädt Porträt hoch", b("abgleichen") is not None) + erg = a("abgleichen") + pruefe("A lädt neues Porträt", frost in erg.get("geaendert", []) and {x["id"]: x["portraet"] for x in a("akten")}[frost], erg) + erg = a("abgleichen") + pruefe("A: Porträt nicht erneut hochgeladen", erg["hochgeladen"] == 0 and not erg["geaendert"], erg) + erg = b("abgleichen") + pruefe("B: nichts mehr zu tun", erg["hochgeladen"] == 0 and erg["heruntergeladen"] == 0 and not erg["geaendert"], erg) + + print("Löschen") + a("papierkorb", id=nordlicht) + pruefe("A: Löschung ausstehend", a("ausstehend") is True) + a("abgleichen") + pruefe("A: danach nichts ausstehend", a("ausstehend") is False) + code, antwort = server.api("anmelden", login="danny", passwort="dannypasswort1") + code, antwort = server.api("charaktere_eigene", token=antwort["token"]) + pruefe("auf dem Server gelöscht", [c["lokale_id"] for c in antwort["charaktere"]] == [frost], antwort) + erg = b("abgleichen") + pruefe("B verschiebt sie in den Papierkorb", erg["entfernt"] == 1, erg) + pruefe("B hat nur noch Frost", [x["id"] for x in b("akten")] == [frost]) + + print("Ohne Server") + offline = Rechner("C", "http://127.0.0.1:9") + antwort = offline("anmelden", login="danny", passwort="dannypasswort1") + pruefe("keine Verbindung: verständlicher Fehler", antwort.get("fehler") == "offline", antwort) + + +if __name__ == "__main__": + if len(sys.argv) >= 2 and sys.argv[1] == "pc": + sys.path.insert(0, str(WURZEL)) + import konto + try: + wert = rechner_befehl(sys.argv[2], json.loads(sys.argv[3])) + print("ERGEBNIS " + json.dumps({"wert": wert}, ensure_ascii=False, default=str)) + except konto.ServerFehler as fehler: + ursache = f" [{type(fehler.__cause__).__name__}: {fehler.__cause__}]" if fehler.__cause__ else "" + print("ERGEBNIS " + json.dumps({"fehler": fehler.code, "meldung": fehler.meldung + ursache}, + ensure_ascii=False)) + else: + main() diff --git a/werkzeuge/server_test.py b/werkzeuge/server_test.py index 2a9747a..4918a71 100644 --- a/werkzeuge/server_test.py +++ b/werkzeuge/server_test.py @@ -13,8 +13,10 @@ Braucht: php (8.1+) mit pdo_sqlite, gd, mbstring im Suchpfad. import base64 import http.cookiejar +import http.server import io import json +import os import quopri import re import shutil @@ -22,6 +24,7 @@ import socket import subprocess import sys import tempfile +import threading import time import urllib.error import urllib.parse @@ -45,6 +48,76 @@ def pruefe(name, bedingung, info=""): print(f" FEHL {name}" + (f" [{info}]" if info else "")) +class _CgiServer(http.server.ThreadingHTTPServer): + daemon_threads = True + + +class _CgiAnfrage(http.server.BaseHTTPRequestHandler): + """Liefert statische Dateien selbst und reicht .php an php-cgi weiter.""" + + def log_message(self, format, *args): + with open(self.server.protokoll, "a", encoding="utf-8") as datei: + datei.write(time.strftime("[%H:%M:%S] ") + (format % args) + "\n") + + def do_GET(self): + self._behandeln() + + def do_POST(self): + self._behandeln() + + def _antwort(self, status, kopf, inhalt): + self.send_response(status) + for name, wert in kopf: + self.send_header(name, wert) + self.send_header("Content-Length", str(len(inhalt))) + self.send_header("Connection", "close") + self.end_headers() + self.wfile.write(inhalt) + + def _behandeln(self): + wurzel = self.server.dokumentenstamm + pfad, _, abfrage = self.path.partition("?") + ziel = (wurzel / urllib.parse.unquote(pfad).lstrip("/")).resolve() + if wurzel not in ziel.parents and ziel != wurzel: + return self._antwort(403, [], b"") + if ziel.is_dir(): + ziel = ziel / "index.php" + if not ziel.is_file(): + return self._antwort(404, [("Content-Type", "text/plain")], b"File not found.") + laenge = int(self.headers.get("Content-Length") or 0) + koerper = self.rfile.read(laenge) if laenge else b"" + if ziel.suffix != ".php": + art = {".png": "image/png", ".html": "text/html", ".json": "application/json"}.get(ziel.suffix, "application/octet-stream") + return self._antwort(200, [("Content-Type", art)], ziel.read_bytes()) + + umgebung = {k: v for k, v in os.environ.items() if k.upper() in ("SYSTEMROOT", "PATH", "TEMP", "TMP", "WINDIR")} + umgebung.update({ + "REDIRECT_STATUS": "200", "GATEWAY_INTERFACE": "CGI/1.1", "SERVER_PROTOCOL": "HTTP/1.1", + "SCRIPT_FILENAME": str(ziel), "SCRIPT_NAME": "/" + ziel.relative_to(wurzel).as_posix(), + "REQUEST_METHOD": self.command, "QUERY_STRING": abfrage, "REQUEST_URI": self.path, + "CONTENT_LENGTH": str(laenge), "CONTENT_TYPE": self.headers.get("Content-Type", ""), + "SERVER_NAME": "127.0.0.1", "SERVER_PORT": str(self.server.server_port), + "REMOTE_ADDR": self.client_address[0], "DOCUMENT_ROOT": str(wurzel), + }) + for name, wert in self.headers.items(): + if name.lower() not in ("content-length", "content-type"): + umgebung["HTTP_" + name.upper().replace("-", "_")] = wert + lauf = subprocess.run([self.server.php_cgi], input=koerper, capture_output=True, env=umgebung, timeout=60) + if lauf.stderr: + self.log_message("php-cgi: %s", lauf.stderr.decode("utf-8", "replace")[:500]) + kopftext, _, inhalt = lauf.stdout.partition(b"\r\n\r\n") + status, kopf = 200, [] + for zeile in kopftext.decode("latin-1").split("\r\n"): + name, _, wert = zeile.partition(":") + if name.lower() == "status": + status = int(wert.strip().split()[0]) + elif name: + kopf.append((name, wert.strip())) + if status == 200 and any(n.lower() == "location" for n, _ in kopf): + status = 302 + self._antwort(status, kopf, inhalt) + + def freier_port(): with socket.socket() as s: s.bind(("127.0.0.1", 0)) @@ -74,19 +147,28 @@ return [ 'fehler_anzeigen' => false, ]; """, encoding="utf-8") - self.prozess = subprocess.Popen( - ["php", "-S", f"127.0.0.1:{self.port}", "-t", str(self.ordner / "sva.tyrveil.com")], - stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) - for _ in range(50): - try: - socket.create_connection(("127.0.0.1", self.port), timeout=0.2).close() - break - except OSError: - time.sleep(0.1) + # Nicht "php -S": Der Entwicklungsserver nimmt unter Windows nach + # einigen hundert schnellen Verbindungen keine mehr an. Stattdessen + # startet ein Python-Server fuer jede Anfrage ein eigenes php-cgi - + # naeher an Plesk, wo PHP ebenfalls in eigenen Prozessen laeuft. + self.protokoll = self.ordner / "php-server.log" + self.webserver = _CgiServer(("127.0.0.1", self.port), _CgiAnfrage) + self.webserver.dokumentenstamm = (self.ordner / "sva.tyrveil.com").resolve() + self.webserver.protokoll = self.protokoll + self.webserver.php_cgi = str(Path(shutil.which("php")).with_name("php-cgi.exe")) + threading.Thread(target=self.webserver.serve_forever, daemon=True).start() + + def laeuft(self): + return self.webserver is not None + + def php_protokoll(self, zeilen=15): + text = self.protokoll.read_text(encoding="utf-8", errors="replace") if self.protokoll.exists() else "" + return "\n".join(text.splitlines()[-zeilen:]) def beenden(self): - self.prozess.terminate() - self.prozess.wait(timeout=10) + self.webserver.shutdown() + self.webserver.server_close() + self.webserver = None shutil.rmtree(self.ordner, ignore_errors=True) @property