""" 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()