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()
|
||||
Loading…
Add table
Add a link
Reference in a new issue