73042b771c
Logo Das Programmlogo steht jetzt klein neben "powered by ravokk" - dort sitzt die Kennung des Werkzeugs, nicht die des Kunden. Eine eigene Kopfzeile hat dieses Programm nicht; oben sind die Reiter. 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. Genau das ist heute passiert. 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. "Der Prozess laeuft" beweist dabei nichts - er lief ja, waehrend nichts zu sehen war. Aufgeraeumt "Rechnung Campinghof.exe" ist weg; gebaute Dateien gehoeren ins Release, nicht ins Repo. Die .spec-Dateien dagegen schon: ohne sie kann niemand die EXE nachbauen, die der Updater ausliefert. Fassung 1.7.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 ...")
|