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>
209 lines
7.9 KiB
Python
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:]))
|