squad-manager/update_helfer.py
danny a200987237 Updater: geschuetzte Programmordner, Installer nur pro Benutzer
Lag das Programm unter C:\Program Files (Installer-Wahl "fuer alle
Benutzer"), scheiterte das Kopieren beim Update still und die alte
Fassung startete neu. Neu:

- update_helfer.py ersetzt die Batchdatei. Wartet per Prozess-ID auf das
  Programmende, prueft den Ordner per Schreibprobe und kopiert bei Bedarf
  in einem zweiten Prozess mit Adminrechten. Fehler werden gemeldet und
  protokolliert, mit Link zum Installer.
- Das Programm kuendigt die Windows-Abfrage vor dem Download an.
- Der Helfer aus dem neuen Paket hat Vorrang.
- Installer ohne die Wahl "fuer alle Benutzer"; eine alte Installation
  fuer alle Benutzer wird vorher entfernt.
- version.json fuehrt die Installer-Adresse.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-10 19:15:13 +02:00

209 lines
7.9 KiB
Python

"""
Spielt ein heruntergeladenes Update ein und startet das Programm neu.
Laeuft als eigener Prozess aus dem temporaeren Ordner des Updates, weil
das Programm seine Dateien nicht ersetzen soll, solange es selbst laeuft.
Verwendet nur die Standardbibliothek: Die Pakete der virtuellen Umgebung
liegen hier nicht im Suchpfad, und der Programmordner wird gerade
ueberschrieben.
Liegt das Programm in einem geschuetzten Ordner wie C:\\Program Files,
wird nur das Kopieren mit Administratorrechten wiederholt. Das Programm
selbst startet danach wieder mit normalen Rechten - mit Adminrechten
gestartet, laese es sonst unter Umstaenden die Einstellungen eines
anderen Benutzerkontos.
Aufruf: pythonw update_helfer.py <quelle> <ziel> <pid> [<installer-url>]
pythonw update_helfer.py --kopieren <quelle> <ziel>
"""
import ctypes
import ctypes.wintypes as wintypes
import os
import shutil
import subprocess
import sys
import time
import traceback
import webbrowser
from pathlib import Path
LOG_PATH = Path(os.getenv("APPDATA", ".")) / "SquadManager" / "error.log"
INSTALLER_SEITE = "https://sva.tyrveil.com"
ABGELEHNT = 1223 # ERROR_CANCELLED: Windows-Abfrage abgelehnt
KOPIEREN_GESCHEITERT = 2
kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
shell32 = ctypes.WinDLL("shell32", use_last_error=True)
user32 = ctypes.WinDLL("user32", use_last_error=True)
kernel32.OpenProcess.argtypes = (wintypes.DWORD, wintypes.BOOL, wintypes.DWORD)
kernel32.OpenProcess.restype = wintypes.HANDLE
kernel32.WaitForSingleObject.argtypes = (wintypes.HANDLE, wintypes.DWORD)
kernel32.WaitForSingleObject.restype = wintypes.DWORD
kernel32.GetExitCodeProcess.argtypes = (wintypes.HANDLE, ctypes.POINTER(wintypes.DWORD))
kernel32.GetExitCodeProcess.restype = wintypes.BOOL
kernel32.CloseHandle.argtypes = (wintypes.HANDLE,)
kernel32.CloseHandle.restype = wintypes.BOOL
user32.MessageBoxW.argtypes = (wintypes.HWND, wintypes.LPCWSTR, wintypes.LPCWSTR, wintypes.UINT)
user32.MessageBoxW.restype = ctypes.c_int
class SHELLEXECUTEINFOW(ctypes.Structure):
_fields_ = [("cbSize", wintypes.DWORD), ("fMask", wintypes.ULONG),
("hwnd", wintypes.HWND), ("lpVerb", wintypes.LPCWSTR),
("lpFile", wintypes.LPCWSTR), ("lpParameters", wintypes.LPCWSTR),
("lpDirectory", wintypes.LPCWSTR), ("nShow", ctypes.c_int),
("hInstApp", wintypes.HINSTANCE), ("lpIDList", ctypes.c_void_p),
("lpClass", wintypes.LPCWSTR), ("hkeyClass", wintypes.HKEY),
("dwHotKey", wintypes.DWORD), ("hIconOrMonitor", wintypes.HANDLE),
("hProcess", wintypes.HANDLE)]
shell32.ShellExecuteExW.argtypes = (ctypes.POINTER(SHELLEXECUTEINFOW),)
shell32.ShellExecuteExW.restype = wintypes.BOOL
def protokollieren(text):
try:
LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
with open(LOG_PATH, "a", encoding="utf-8") as datei:
datei.write(f"\n--- {time.strftime('%Y-%m-%d %H:%M:%S')} update_helfer ---\n{text}\n")
except Exception:
pass
def beschreibbar(ordner):
"""Probiert es aus. os.access kennt die Zugriffsrechte von Windows nicht."""
probe = Path(ordner) / f".schreibprobe_{os.getpid()}"
try:
with open(probe, "w") as datei:
datei.write("x")
probe.unlink()
return True
except OSError:
return False
def warten_auf_ende(pid, sekunden=20):
"""Wartet, bis das Programm beendet ist, statt eine feste Zeit zu raten."""
SYNCHRONIZE = 0x00100000
handle = kernel32.OpenProcess(SYNCHRONIZE, False, pid)
if not handle:
return # laeuft schon nicht mehr
try:
kernel32.WaitForSingleObject(handle, int(sekunden * 1000))
finally:
kernel32.CloseHandle(handle)
def kopieren(quelle, ziel):
quelle, ziel = Path(quelle), Path(ziel)
for datei in sorted(quelle.rglob("*")):
pfad = ziel / datei.relative_to(quelle)
if datei.is_dir():
pfad.mkdir(parents=True, exist_ok=True)
continue
pfad.parent.mkdir(parents=True, exist_ok=True)
# Ein Virenscanner haelt frisch geschriebene Dateien oft kurz fest
for versuch in range(6):
try:
shutil.copy2(datei, pfad)
break
except PermissionError:
if versuch == 5:
raise
time.sleep(0.5)
def mit_adminrechten_kopieren(quelle, ziel, verb="runas"):
"""
Startet diesen Helfer ein zweites Mal, nur zum Kopieren, mit Adminrechten.
Gibt den Rueckgabewert des zweiten Prozesses zurueck, ABGELEHNT wenn
die Windows-Abfrage verneint wurde.
"""
parameter = subprocess.list2cmdline(
[str(Path(__file__).resolve()), "--kopieren", str(quelle), str(ziel)])
info = SHELLEXECUTEINFOW()
info.cbSize = ctypes.sizeof(info)
info.fMask = 0x00000040 # SEE_MASK_NOCLOSEPROCESS
info.lpVerb = verb
info.lpFile = sys.executable
info.lpParameters = parameter
info.nShow = 0
if not shell32.ShellExecuteExW(ctypes.byref(info)):
return ctypes.get_last_error() or KOPIEREN_GESCHEITERT
try:
kernel32.WaitForSingleObject(info.hProcess, 5 * 60 * 1000)
code = wintypes.DWORD()
kernel32.GetExitCodeProcess(info.hProcess, ctypes.byref(code))
return code.value
finally:
kernel32.CloseHandle(info.hProcess)
def einspielen(quelle, ziel):
"""Gibt None zurueck, wenn alles kopiert ist, sonst eine Fehlerbeschreibung."""
try:
if beschreibbar(ziel):
kopieren(quelle, ziel)
return None
code = mit_adminrechten_kopieren(quelle, ziel)
except Exception:
protokollieren(traceback.format_exc())
return "Die neuen Dateien konnten nicht in den Programmordner kopiert werden."
if code == 0:
return None
if code == ABGELEHNT:
return ("Die Abfrage nach Administratorrechten wurde abgelehnt. Ohne sie "
"darf in den Programmordner nicht geschrieben werden.")
return f"Das Kopieren mit Administratorrechten ist gescheitert (Code {code})."
def melden(fehler, ziel, installer_url):
text = (f"Das Update konnte nicht eingespielt werden.\n\n{fehler}\n\n"
f"Programmordner:\n{ziel}\n\n"
"Squad Manager startet jetzt in der bisherigen Version. Abhilfe "
"schafft der aktuelle Installer: Er installiert in deinen "
"Benutzerordner, dort klappen kuenftige Updates ohne Rueckfrage.\n\n"
"Installer jetzt herunterladen?")
MB_YESNO, MB_ICONWARNING, MB_TOPMOST, IDYES = 0x4, 0x30, 0x40000, 6
antwort = user32.MessageBoxW(None, text, "Squad Manager - Update",
MB_YESNO | MB_ICONWARNING | MB_TOPMOST)
if antwort == IDYES:
webbrowser.open(installer_url or INSTALLER_SEITE)
def neu_starten(ziel):
start = Path(ziel) / "start.pyw"
if start.is_file():
subprocess.Popen([sys.executable, str(start)], cwd=str(ziel),
creationflags=0x08000000) # kein Konsolenfenster
def main(argumente):
if argumente[:1] == ["--kopieren"]:
try:
kopieren(argumente[1], argumente[2])
return 0
except Exception:
protokollieren(traceback.format_exc())
return KOPIEREN_GESCHEITERT
quelle, ziel, pid = Path(argumente[0]), Path(argumente[1]), int(argumente[2])
installer_url = argumente[3] if len(argumente) > 3 else ""
warten_auf_ende(pid)
fehler = einspielen(quelle, ziel)
if fehler:
protokollieren(f"{fehler}\nQuelle: {quelle}\nZiel: {ziel}")
melden(fehler, ziel, installer_url)
neu_starten(ziel)
# Der Arbeitsordner enthaelt auch diese Datei. Python hat sie beim
# Start vollstaendig gelesen, sie darf also mit weg.
shutil.rmtree(quelle.parent, ignore_errors=True)
return 1 if fehler else 0
if __name__ == "__main__":
sys.exit(main(sys.argv[1:]))