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
285
abgleich.py
Normal file
285
abgleich.py
Normal file
|
|
@ -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-<Zeit>.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()
|
||||
|
|
@ -120,8 +120,15 @@ 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."""
|
||||
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)
|
||||
|
|
|
|||
46
hintergrund.py
Normal file
46
hintergrund.py
Normal file
|
|
@ -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
|
||||
230
konto.py
Normal file
230
konto.py
Normal file
|
|
@ -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
|
||||
|
|
@ -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'],
|
||||
];
|
||||
|
|
|
|||
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