Abgleich der Akten mit dem Server (ohne Oberflaeche)
- konto.py: Aufrufe der Schnittstelle, Anmeldung; das Token liegt per DPAPI an das Windows-Konto gebunden in konto.json - abgleich.py: gleicht lokale Akten und Server ab. server.json neben jeder Akte haelt den Stand des letzten Abgleichs (Pruefwert des Inhalts statt Zeitstempel, der nur sekundengenau ist). Konflikte sichern die Serverfassung als konflikt-<Zeit>.json; auf dem Server geloeschte Akten wandern lokal in den Papierkorb - hintergrund.py: Netzwerkarbeit im Thread, Ergebnis im tkinter-Hauptthread - akte_modell.speichern(zeit_setzen=False) fuer uebernommene Serverdaten - Server liefert portraet_kennung, damit ein zweiter Rechner neue Bilder erkennt - Tests: werkzeuge/abgleich_test.py mit zwei simulierten Rechnern (34 Faelle); der Testserver nutzt php-cgi statt "php -S", das unter Windows nach vielen Verbindungen haengen bleibt Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
parent
fb318980a1
commit
0c7aae5b93
7 changed files with 918 additions and 14 deletions
243
werkzeuge/abgleich_test.py
Normal file
243
werkzeuge/abgleich_test.py
Normal file
|
|
@ -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()
|
||||
|
|
@ -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
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue