96aa51ac22
Logo Das Programmlogo (Wolke mit Paragraphenzeichen) steht jetzt rechts in der Kopfleiste - damit sich die beiden Werkzeuge auf einen Blick unterscheiden. bauen.py Der Weg von der Quelle zur Setup-Datei war eine Folge von Befehlen, die jemand von Hand eintippen musste. Wer einen Schritt vergisst, liefert eine Setup-Datei mit einer alten EXE aus - und sieht es ihr nicht an. Jetzt ist es ein Befehl, die Nummer kommt aus version.py, und am Ende stehen die SHA256-Summen fuer den Release-Text. pruef_start_exe.py Prueft, was kein anderer Pruefstand prueft: ob die GEBAUTE EXE ein sichtbares Fenster zeigt. Alle uebrigen fahren das Programm aus der Quelle, dort trat der Fehler nie auf. pruef_einzelinstanz.py wieder gruen Der Erprobungshinweis haette in jedem der drei Starts ein echtes Fenster geoeffnet - in einem eigenen Prozess laesst sich kein Dialog abfangen, es klickt niemand. Geprueft wird dort die SPERRE, nicht der Hinweis (der hat einen eigenen Pruefstand). Die Kenntnisnahme wird deshalb vorher eingetragen, und zwar mit genau dem Code, den auch der Klick auf "Ja" ausfuehrt. Das trifft nur die Kopie im Temp-Ordner: im echten Journal entsteht keine Zustimmung, die niemand gegeben hat. Aufgeraeumt Beherbergungssteuer.exe und die gleichnamige .spec sind raus - das Programm heisst jetzt anders. Gebaute Dateien gehoeren ins Release, nicht ins Repo; die .spec-Dateien dagegen schon. Fassung 1.8.0. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01V4t48uxDok5rJXhC9bX1Ax
399 lines
15 KiB
Python
399 lines
15 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""Der Updater - er ist der Starter.
|
|
|
|
SEIN BILD (06.09.2026)
|
|
----------------------
|
|
"der updater schaut beim starten erst: ist auf dem git link eine neue
|
|
version mit exe? wenn ja, erst laden, ersetzen und dann starten."
|
|
"einmal pruefen auf vollstaendigkeit."
|
|
"updater startet kurz als im ram und das main programm ist aus, sonst
|
|
kannst es nicht ersetzen."
|
|
|
|
WARUM DAS DER RICHTIGE AUFBAU IST
|
|
---------------------------------
|
|
Windows laesst eine laufende EXE nicht ueberschreiben. Ein Programm, das sich
|
|
selbst aktualisiert, muss deshalb Umwege gehen (Kopie im Temp, warten, bis der
|
|
eigene Prozess weg ist, tauschen). All das entfaellt, wenn der Updater das ist,
|
|
was der Nutzer startet: Er laeuft VOR dem Programm - die EXE ist gar nicht in
|
|
Benutzung, wenn sie ersetzt wird.
|
|
|
|
DIE NUMMER STEHT IM DATEINAMEN (seine Idee, 06.09.2026)
|
|
-------------------------------------------------------
|
|
"wir werden den namen mit nummer fuehren - wenn er merkt, eh warte mal, die
|
|
heisst anders, dann neu machen"
|
|
|
|
Die installierte Datei heisst `Rechnungstool-1.6.0.exe`. Daraus folgt dreierlei:
|
|
|
|
* Es wird nie etwas UEBERSCHRIEBEN - eine neue Fassung ist eine neue Datei.
|
|
Das Sperrproblem von Windows gibt es damit nicht einmal theoretisch.
|
|
* Die alte Fassung bleibt liegen und ist die Rueckfallebene, ohne dass
|
|
jemand eine Sicherung anlegen muesste.
|
|
* Der Updater sieht AM NAMEN, was installiert ist. Er muss keiner Angabe
|
|
glauben, die auseinanderlaufen koennte.
|
|
|
|
DIE REGEL, AN DER SOLCHE UPDATER SCHEITERN
|
|
------------------------------------------
|
|
Sie schreiben einen halb geladenen Download in die Installation, und das
|
|
Programm startet nie wieder. Deshalb hier: in einen Zwischenordner laden,
|
|
GROESSE UND PRUEFSUMME gegen die Angaben des Releases halten, und erst dann in
|
|
den Installationsordner legen.
|
|
|
|
AUFBAU
|
|
------
|
|
Dieser Teil ist eine BIBLIOTHEK ohne Fenster und ohne Netzzwang: jede
|
|
Entscheidung ist eine eigene Funktion, die sich einzeln pruefen laesst
|
|
(pruef_updater.py). Das Startprogramm steht unten unter __main__.
|
|
|
|
Diese Datei liegt in BEIDEN Programmen gleich. Wer sie aendert, kopiert sie
|
|
hinueber.
|
|
"""
|
|
|
|
import hashlib
|
|
import json
|
|
import os
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import urllib.request
|
|
|
|
API = "https://git.pcore.de/api/v1/repos"
|
|
|
|
# Wie die Buchfuehrung des Updaters heisst. Sie liegt neben der EXE und wird
|
|
# von IHM gefuehrt - nicht vom Programm. So kann nichts auseinanderlaufen:
|
|
# was hier steht, hat der Updater selbst installiert.
|
|
BUCH = "installiert.json"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Versionen vergleichen
|
|
# ---------------------------------------------------------------------------
|
|
def zerlegen(fassung):
|
|
"""'v1.6.0' oder '1.6.0' -> (1, 6, 0). Unlesbares wird zu (0,).
|
|
|
|
Absichtlich nachsichtig: eine Nummer, die niemand versteht, darf kein
|
|
Update ausloesen - sie zaehlt als die aelteste denkbare.
|
|
"""
|
|
if not fassung:
|
|
return (0,)
|
|
teile = re.findall(r"\d+", str(fassung))
|
|
return tuple(int(t) for t in teile) if teile else (0,)
|
|
|
|
|
|
def ist_neuer(dort, hier):
|
|
"""Ist `dort` neuer als `hier`? Gleichstand ist NICHT neuer."""
|
|
return zerlegen(dort) > zerlegen(hier)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Das passende Release finden
|
|
# ---------------------------------------------------------------------------
|
|
def passendes_release(releases, exe_name):
|
|
"""Das neueste Release, das eine Datei `exe_name` anhaengt.
|
|
|
|
Vorabversionen zaehlen MIT - alle Fassungen dieser Programme sind als
|
|
Vorabversion gekennzeichnet, weil sie erprobt werden. Wer hier
|
|
`/releases/latest` benutzt, bekommt nichts: Forgejo laesst Vorabversionen
|
|
dort aus. Genau das ist beim Bauen aufgefallen.
|
|
|
|
Entwuerfe (draft) zaehlen NICHT - die sind nicht veroeffentlicht.
|
|
"""
|
|
beste = None
|
|
for r in releases or []:
|
|
if r.get("draft"):
|
|
continue
|
|
anhang = next((a for a in r.get("assets") or []
|
|
if a.get("name") == exe_name), None)
|
|
if not anhang:
|
|
continue
|
|
if beste is None or ist_neuer(r.get("tag_name"), beste[0].get("tag_name")):
|
|
beste = (r, anhang)
|
|
return beste
|
|
|
|
|
|
def summe_aus_release(release, exe_name):
|
|
"""Die erwartete Pruefsumme aus dem Anhang `<exe>.sha256`, oder ''.
|
|
|
|
Das Release haengt neben der EXE eine kleine Textdatei mit der Pruefsumme
|
|
an. Fehlt sie, wird nur die Groesse geprueft - dann sagt das der Updater
|
|
aber auch, statt so zu tun, als haette er geprueft.
|
|
"""
|
|
name = exe_name + ".sha256"
|
|
for a in release.get("assets") or []:
|
|
if a.get("name") == name:
|
|
return a.get("browser_download_url") or ""
|
|
return ""
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Laden und pruefen
|
|
# ---------------------------------------------------------------------------
|
|
def beschreibbar(ordner):
|
|
"""Darf in diesen Ordner geschrieben werden? Wird ausprobiert, nicht geraten.
|
|
|
|
Ein nicht beschreibbarer Ordner sieht von aussen genauso aus wie ein
|
|
beschreibbarer - erst der Versuch zeigt es.
|
|
"""
|
|
probe = os.path.join(ordner, ".schreibprobe")
|
|
try:
|
|
with open(probe, "w", encoding="ascii") as f:
|
|
f.write("x")
|
|
os.remove(probe)
|
|
return True
|
|
except OSError:
|
|
return False
|
|
|
|
|
|
def sha256(pfad):
|
|
h = hashlib.sha256()
|
|
with open(pfad, "rb") as f:
|
|
for brocken in iter(lambda: f.read(1 << 20), b""):
|
|
h.update(brocken)
|
|
return h.hexdigest()
|
|
|
|
|
|
def holen(url, ziel, melden=None):
|
|
"""Datei laden. Gibt die Anzahl geladener Bytes zurueck."""
|
|
with urllib.request.urlopen(url, timeout=60) as antwort, open(ziel, "wb") as raus:
|
|
gesamt = int(antwort.headers.get("Content-Length") or 0)
|
|
geladen = 0
|
|
while True:
|
|
brocken = antwort.read(1 << 20)
|
|
if not brocken:
|
|
break
|
|
raus.write(brocken)
|
|
geladen += len(brocken)
|
|
if melden and gesamt:
|
|
melden(geladen, gesamt)
|
|
return geladen
|
|
|
|
|
|
def vollstaendig(pfad, erwartete_groesse, erwartete_summe=""):
|
|
"""Ist die geladene Datei vollstaendig und unverfaelscht?
|
|
|
|
Rueckgabe: (True, "") oder (False, Grund). Ein halb geladener Download darf
|
|
die Installation NIE erreichen - lieber gar kein Update als ein kaputtes.
|
|
"""
|
|
if not os.path.exists(pfad):
|
|
return False, "Die geladene Datei ist nicht da."
|
|
ist = os.path.getsize(pfad)
|
|
if erwartete_groesse and ist != erwartete_groesse:
|
|
return False, (f"Groesse stimmt nicht: {ist} Bytes geladen, "
|
|
f"{erwartete_groesse} erwartet.")
|
|
if erwartete_summe:
|
|
hat = sha256(pfad)
|
|
if hat.lower() != erwartete_summe.strip().lower():
|
|
return False, "Pruefsumme stimmt nicht."
|
|
return True, ""
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Die Nummer steht im Dateinamen
|
|
# ---------------------------------------------------------------------------
|
|
def basis_und_endung(exe_name):
|
|
"""'Rechnungstool.exe' -> ('Rechnungstool', '.exe')."""
|
|
stamm, endung = os.path.splitext(exe_name)
|
|
stamm = re.sub(r"-\d+(?:\.\d+)*$", "", stamm) # eine Nummer wieder abschneiden
|
|
return stamm, endung or ".exe"
|
|
|
|
|
|
def dateiname(exe_name, fassung):
|
|
"""'Rechnungstool.exe' + 'v1.6.0' -> 'Rechnungstool-1.6.0.exe'."""
|
|
stamm, endung = basis_und_endung(exe_name)
|
|
return f"{stamm}-{str(fassung).lstrip('v')}{endung}"
|
|
|
|
|
|
def installierte(ordner, exe_name):
|
|
"""Was liegt im Ordner? Liste (Fassung, Pfad), neueste zuerst.
|
|
|
|
Gelesen wird der DATEINAME - keine Angabe, der man glauben muesste. Eine
|
|
Datei ohne Nummer (aus der Zeit vor dieser Fassung) zaehlt als aelteste.
|
|
"""
|
|
stamm, endung = basis_und_endung(exe_name)
|
|
muster = re.compile(re.escape(stamm) + r"(?:-(\d+(?:\.\d+)*))?" +
|
|
re.escape(endung) + r"$", re.I)
|
|
gefunden = []
|
|
try:
|
|
namen = os.listdir(ordner)
|
|
except OSError:
|
|
return []
|
|
for name in namen:
|
|
treffer = muster.match(name)
|
|
if treffer:
|
|
gefunden.append((treffer.group(1) or "0", os.path.join(ordner, name)))
|
|
gefunden.sort(key=lambda x: zerlegen(x[0]), reverse=True)
|
|
return gefunden
|
|
|
|
|
|
def neueste_installierte(ordner, exe_name):
|
|
"""(Fassung, Pfad) der neuesten vorhandenen Datei - oder ('0', '')."""
|
|
liste = installierte(ordner, exe_name)
|
|
return liste[0] if liste else ("0", "")
|
|
|
|
|
|
def aufraeumen(ordner, exe_name, behalten=2):
|
|
"""Alte Fassungen wegraeumen, die neuesten `behalten` bleiben liegen.
|
|
|
|
Nicht aus Ordnungsliebe: die vorletzte Fassung IST die Rueckfallebene.
|
|
Deshalb wird nie unter zwei geraeumt.
|
|
"""
|
|
liste = installierte(ordner, exe_name)
|
|
weg = []
|
|
for _fassung, pfad in liste[max(2, behalten):]:
|
|
try:
|
|
os.remove(pfad)
|
|
weg.append(os.path.basename(pfad))
|
|
except OSError:
|
|
pass
|
|
return weg
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Buchfuehrung
|
|
# ---------------------------------------------------------------------------
|
|
def buch_lesen(ordner):
|
|
pfad = os.path.join(ordner, BUCH)
|
|
try:
|
|
with open(pfad, encoding="utf-8") as f:
|
|
return json.load(f)
|
|
except (OSError, ValueError):
|
|
return {}
|
|
|
|
|
|
def buch_schreiben(ordner, daten):
|
|
pfad = os.path.join(ordner, BUCH)
|
|
try:
|
|
with open(pfad, "w", encoding="utf-8") as f:
|
|
json.dump(daten, f, ensure_ascii=False, indent=2)
|
|
return True
|
|
except OSError:
|
|
return False
|
|
|
|
|
|
def releases_holen(repository):
|
|
url = f"{API}/{repository}/releases?limit=20"
|
|
with urllib.request.urlopen(url, timeout=30) as antwort:
|
|
return json.loads(antwort.read().decode("utf-8"))
|
|
|
|
|
|
def text_holen(url):
|
|
with urllib.request.urlopen(url, timeout=30) as antwort:
|
|
return antwort.read().decode("utf-8", "replace").split()[0]
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Der Ablauf
|
|
# ---------------------------------------------------------------------------
|
|
def durchlauf(ordner, repository, exe_name, sagen=print, holen_=None):
|
|
"""Ein Durchlauf. Gibt den Pfad der Datei zurueck, die gestartet werden soll.
|
|
|
|
Nichts wird ueberschrieben: eine neue Fassung wird als eigene Datei
|
|
`<Name>-<Nummer>.exe` abgelegt. Die vorige bleibt liegen - sie ist die
|
|
Rueckfallebene, ohne dass jemand eine Sicherung anlegen muesste.
|
|
|
|
`holen_` laesst sich fuer den Pruefstand ersetzen, damit er ohne Netz
|
|
auskommt.
|
|
"""
|
|
holen_ = holen_ or releases_holen
|
|
hier, hier_pfad = neueste_installierte(ordner, exe_name)
|
|
buch = buch_lesen(ordner)
|
|
# Buch und Dateiname zusammen: wer eine Datei umbenennt, verursacht
|
|
# hoechstens einen ueberfluessigen Download, keinen Schaden.
|
|
if ist_neuer(buch.get("version") or "0", hier):
|
|
hier = buch.get("version")
|
|
|
|
try:
|
|
releases = holen_(repository)
|
|
except Exception as e: # noqa: BLE001 - ohne Netz wird einfach gestartet
|
|
sagen(f"Kein Update moeglich ({e}). Es wird die vorhandene Fassung gestartet.")
|
|
return hier_pfad
|
|
|
|
treffer = passendes_release(releases, exe_name)
|
|
if not treffer:
|
|
sagen("Im Repository liegt keine passende Datei. Vorhandene Fassung wird gestartet.")
|
|
return hier_pfad
|
|
release, anhang = treffer
|
|
dort = release.get("tag_name") or ""
|
|
|
|
if not ist_neuer(dort, hier):
|
|
sagen(f"Aktuell ({hier}). Kein Update noetig.")
|
|
return hier_pfad
|
|
|
|
ziel = os.path.join(ordner, dateiname(exe_name, dort))
|
|
if os.path.exists(ziel):
|
|
sagen(f"{os.path.basename(ziel)} liegt schon da. Es wird gestartet.")
|
|
return ziel
|
|
|
|
# Kann in den Installationsordner ueberhaupt geschrieben werden? Liegt die
|
|
# Installation in einem geschuetzten Ordner (etwa "Programme"), schlaegt das
|
|
# Ablegen fehl. Dann wird NICHT geladen - und vor allem: das Programm
|
|
# startet trotzdem. Ein fehlgeschlagenes Update darf nie dazu fuehren, dass
|
|
# gar nichts mehr geht.
|
|
if not beschreibbar(ordner):
|
|
sagen(f"In {ordner} darf nicht geschrieben werden - kein Update moeglich.")
|
|
sagen("Es wird die vorhandene Fassung gestartet.")
|
|
return hier_pfad
|
|
|
|
sagen(f"Neue Fassung {dort} gefunden (vorhanden: {hier}). Wird geladen ...")
|
|
zwischen = tempfile.mkdtemp(prefix="update_")
|
|
geladen = os.path.join(zwischen, exe_name)
|
|
try:
|
|
holen(anhang["browser_download_url"], geladen)
|
|
|
|
erwartete_summe = ""
|
|
url_summe = summe_aus_release(release, exe_name)
|
|
if url_summe:
|
|
try:
|
|
erwartete_summe = text_holen(url_summe)
|
|
except Exception: # noqa: BLE001
|
|
sagen("Pruefsumme nicht ladbar - es wird nur die Groesse geprueft.")
|
|
else:
|
|
sagen("Dieses Release hat keine Pruefsumme - es wird nur die Groesse geprueft.")
|
|
|
|
gut, grund = vollstaendig(geladen, anhang.get("size") or 0, erwartete_summe)
|
|
if not gut:
|
|
sagen(f"Das Update wurde VERWORFEN: {grund}")
|
|
sagen("Es wird die vorhandene Fassung gestartet.")
|
|
return hier_pfad
|
|
|
|
# Erst jetzt in den Installationsordner - vorher lag nichts Halbes dort.
|
|
try:
|
|
shutil.move(geladen, ziel)
|
|
except OSError as e: # noqa: BLE001
|
|
sagen(f"Die neue Fassung konnte nicht abgelegt werden ({e}).")
|
|
sagen("Es wird die vorhandene Fassung gestartet.")
|
|
return hier_pfad
|
|
buch_schreiben(ordner, {"version": dort.lstrip("v"),
|
|
"datei": os.path.basename(ziel),
|
|
"sha256": erwartete_summe,
|
|
"vorher": os.path.basename(hier_pfad) if hier_pfad else ""})
|
|
weg = aufraeumen(ordner, exe_name)
|
|
if weg:
|
|
sagen("Alte Fassungen entfernt: " + ", ".join(weg))
|
|
sagen(f"Aktualisiert auf {dort}.")
|
|
return ziel
|
|
finally:
|
|
shutil.rmtree(zwischen, ignore_errors=True)
|
|
|
|
|
|
def starten(pfad):
|
|
"""Das Programm starten und den Updater beenden."""
|
|
subprocess.Popen([pfad], close_fds=True)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
import version
|
|
|
|
ordner = os.path.dirname(os.path.abspath(
|
|
sys.executable if getattr(sys, "frozen", False) else __file__))
|
|
|
|
print(f"Updater - {version.REPOSITORY}")
|
|
zu_starten = durchlauf(ordner, version.REPOSITORY, version.EXE_NAME)
|
|
|
|
if zu_starten and os.path.exists(zu_starten):
|
|
print("Starte", os.path.basename(zu_starten))
|
|
starten(zu_starten)
|
|
else:
|
|
print(f"FEHLER: keine startbare Fassung von {version.EXE_NAME} in {ordner}")
|
|
input("Enter zum Schliessen ...")
|