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:
danny 2026-09-13 19:50:57 +02:00
parent fb318980a1
commit 0c7aae5b93
7 changed files with 918 additions and 14 deletions

View file

@ -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