From e2dba11e9149f130086eae4c0acc0284f4c2e041 Mon Sep 17 00:00:00 2001 From: torsten Date: Thu, 12 Nov 2026 23:46:13 +0100 Subject: [PATCH] fix: Beim Beenden alle Worker-Threads einsammeln MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Der exportierte Build stürzte mit SIGSEGV ab, wenn er direkt nach dem Start beendet wurde (--quit-after 5, Fenster schließen): Der automatische Update-Check lief noch im Hintergrund-Thread, _exit_tree sammelte ihn aber nicht ein. Ohne Netzwerk trat der Fehler nicht auf. - _exit_tree setzt jetzt CloudHttp.request_cancel() und wartet auf Update-, OAuth-, Sync- und Hub-Thread. - CloudHttp bricht seine Warteschleifen bei cancel_requested sofort ab, statt bis zum Timeout weiterzulaufen. - Der Update-Check läuft headless nicht mehr (dort sinnlos). check_export.sh bleibt bei --quit-after 5 und prüft damit weiter, dass der Export sauber beendet. Ursache und Nachweis: docs/findings-2026-11-12-headless-crash.md --- docs/findings-2026-11-12-headless-crash.md | 49 +++++++++++++++++++ rinkplanner/src/core/sync/cloud_http.gd | 24 +++++++++ .../whiteboard/ctrl/whiteboard_controller.gd | 26 ++++++---- rinkplanner/tests/run_sync_tests.gd | 22 +++++++++ tools/check_export.sh | 3 ++ 5 files changed, 115 insertions(+), 9 deletions(-) create mode 100644 docs/findings-2026-11-12-headless-crash.md diff --git a/docs/findings-2026-11-12-headless-crash.md b/docs/findings-2026-11-12-headless-crash.md new file mode 100644 index 0000000..980f2c5 --- /dev/null +++ b/docs/findings-2026-11-12-headless-crash.md @@ -0,0 +1,49 @@ +# Headless-Crash beim Beenden des Exports + +Stand: 2026-11-12. Betrifft `./tools/check_export.sh` und jedes vorzeitige +Beenden der App (Fenster schließen direkt nach dem Start). + +## Symptom + +Der exportierte Linux-Build beendet sich mit `SIGSEGV` (Status 139), sobald +er mit `--headless --quit-after 5` gestartet wird. Der Editor-Build und die +Tests laufen headless fehlerfrei; mit Display (Vulkan) startet derselbe +Export normal. + +Der Crash trat schon vor der Übersetzungsarbeit auf (geprüft mit einem +Worktree auf `9819311`), ist also kein Regress daraus. + +## Ursache + +Nicht die Texturen, sondern der **automatische Update-Check**: + +- Im exportierten Build startet `_ready()` über `_start_update_check(false)` + einen `Thread`, der per `CloudHttp` den Versions-Endpunkt abruft. +- `--quit-after 5` beendet die App nach wenigen Frames, während der Thread + noch in der HTTPS-Anfrage hängt. +- Der bisherige `_exit_tree()` sammelte nur OAuth-, Sync- und Hub-Threads ein, + **nicht** den Update-Thread. Die Engine fuhr den Prozess herunter, während + der Thread noch lief und Speicher benutzte → `SIGSEGV` im Worker-Thread. + +Nachweis: Mit `unshare -rn` (ohne Netzwerk) endet derselbe Build mit +`--quit-after 5` sauber; mit Netzwerk stürzt er ab. Die Schwelle lag auf +diesem Rechner zwischen 20 und 25 Frames (ab dann war der Thread fertig). + +## Fix + +- `_exit_tree()` (Whiteboard-Controller) setzt jetzt zusätzlich + `CloudHttp.request_cancel()` und sammelt **alle** Threads ein + (Update, OAuth, Sync, Hub). +- `CloudHttp` prüft in allen Warteschleifen ein statisches + `cancel_requested` und bricht sofort mit „Abgebrochen.“ ab, statt bis zum + Timeout (20–300 s) weiterzulaufen. +- Der Update-Check läuft headless gar nicht mehr + (`DisplayServer.get_name() == "headless"`), dort ist er sinnlos. + +`check_export.sh` bleibt bei `--quit-after 5` und deckt damit weiterhin ab, +dass beim Beenden alle Threads eingesammelt werden. + +## Test + +`tests/run_sync_tests.gd` prüft, dass eine abgebrochene Anfrage sofort +zurückkehrt und den Fehler „Abgebrochen.“ meldet. diff --git a/rinkplanner/src/core/sync/cloud_http.gd b/rinkplanner/src/core/sync/cloud_http.gd index 9f4ea70..8de156d 100644 --- a/rinkplanner/src/core/sync/cloud_http.gd +++ b/rinkplanner/src/core/sync/cloud_http.gd @@ -14,6 +14,19 @@ const USER_AGENT := "Rinkplanner (Godot)" var last_error: String = "" +## Wird beim Beenden gesetzt. Die Worker-Threads brechen ihre Blockier-Schleifen +## dann ab, damit der Prozess sie sauber einsammeln kann (sonst stürzt Godot +## beim Schließen während einer laufenden Anfrage ab). +static var cancel_requested: bool = false + + +static func request_cancel() -> void: + cancel_requested = true + + +static func reset_cancel() -> void: + cancel_requested = false + func request( method: int, @@ -59,6 +72,10 @@ func request( return {} while client.get_status() == HTTPClient.STATUS_REQUESTING: + if cancel_requested: + client.close() + last_error = "Abgebrochen." + return {} if Time.get_ticks_msec() > deadline: client.close() last_error = "Zeitüberschreitung beim Warten auf die Antwort" @@ -76,6 +93,10 @@ func request( var response_headers := client.get_response_headers_as_dictionary() var payload := PackedByteArray() while client.get_status() == HTTPClient.STATUS_BODY: + if cancel_requested: + client.close() + last_error = "Abgebrochen." + return {} if Time.get_ticks_msec() > deadline: client.close() last_error = "Zeitüberschreitung beim Lesen der Antwort" @@ -123,6 +144,9 @@ func request( func _wait_connected(client: HTTPClient, deadline: int) -> bool: while true: + if cancel_requested: + last_error = "Abgebrochen." + return false match client.get_status(): HTTPClient.STATUS_RESOLVING, HTTPClient.STATUS_CONNECTING: if Time.get_ticks_msec() > deadline: diff --git a/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd b/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd index a5532b5..ff513c5 100644 --- a/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd +++ b/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd @@ -431,6 +431,7 @@ func _apply_sport_theme() -> void: func _ready() -> void: + CloudHttp.reset_cancel() AppSettings.apply_locale(AppSettings.load_locale()) _apply_sport_theme() _maximize_window_on_desktop.call_deferred() @@ -7136,18 +7137,23 @@ func _refresh_synced_music(result: Dictionary) -> void: _start_music() +## Beim Schließen laufende Worker-Threads einsammeln. Ohne das räumt die +## Engine beim Beenden Speicher weg, den die Threads noch benutzen – der +## Prozess stürzt dann mit SIGSEGV ab (z. B. beim automatischen Update-Check +## direkt nach dem Start). func _exit_tree() -> void: if _oauth_job != null: _oauth_job.cancelled = true - if _oauth_thread != null: - _oauth_thread.wait_to_finish() - _oauth_thread = null - if _sync_thread != null: - _sync_thread.wait_to_finish() - _sync_thread = null - if _hub_thread != null: - _hub_thread.wait_to_finish() - _hub_thread = null + # Blockierende HTTP-Schleifen in den Jobs brechen damit ab, statt bis zum + # Timeout weiterzulaufen. + CloudHttp.request_cancel() + for thread: Thread in [_update_thread, _oauth_thread, _sync_thread, _hub_thread]: + if thread != null and thread.is_alive(): + thread.wait_to_finish() + _update_thread = null + _oauth_thread = null + _sync_thread = null + _hub_thread = null func _open_export_dialog() -> void: @@ -8127,6 +8133,8 @@ func _start_update_check(manual: bool) -> void: ## Only exported desktop builds check automatically; the editor and the ## headless tests must not touch the network on start. func _update_check_allowed() -> bool: + if DisplayServer.get_name() == "headless": + return false if not OS.has_feature("template") or OS.has_feature("web"): return false return UpdateInfo.platform_key() in ["macos", "windows", "linux"] diff --git a/rinkplanner/tests/run_sync_tests.gd b/rinkplanner/tests/run_sync_tests.gd index f06c2f2..e93ac3a 100644 --- a/rinkplanner/tests/run_sync_tests.gd +++ b/rinkplanner/tests/run_sync_tests.gd @@ -65,6 +65,7 @@ func _run() -> void: _test_delete_files() _test_rename_files() _test_cloud_helpers() + _test_http_cancel() _test_app_config() _test_state_roundtrip() await _test_controller_wiring() @@ -608,6 +609,27 @@ func _test_cloud_helpers() -> void: ) +## Ein Abbruch (z. B. beim Beenden) beendet die Warteschleife sofort, statt +## bis zum Timeout zu laufen. +func _test_http_cancel() -> void: + CloudHttp.request_cancel() + var http := CloudHttp.new() + var started := Time.get_ticks_msec() + var response := http.request( + HTTPClient.METHOD_GET, + "https://127.0.0.1:9/", + PackedStringArray(), + PackedByteArray(), + 5000 + ) + var elapsed := Time.get_ticks_msec() - started + _check(response.is_empty(), "abgebrochene Anfrage liefert keine Antwort") + _check(http.last_error == "Abgebrochen.", "Abbruch wird als Fehler gemeldet") + _check(elapsed < 1000, "Abbruch beendet die Anfrage sofort (%d ms)" % elapsed) + CloudHttp.reset_cancel() + _check(not CloudHttp.cancel_requested, "Abbruch lässt sich zurücksetzen") + + func _test_app_config() -> void: var path := "user://test_sync_apps.cfg" var config := ConfigFile.new() diff --git a/tools/check_export.sh b/tools/check_export.sh index 1e57df6..782cb1b 100755 --- a/tools/check_export.sh +++ b/tools/check_export.sh @@ -33,6 +33,9 @@ build_preset "Linux" release "$BINARY" echo "Starte den Export headless …" mkdir -p "$TMP_DIR/userdata" set +e +# Der frühe Abbruch ist Absicht: Er deckt ab, dass beim Beenden alle +# Worker-Threads eingesammelt werden. Ohne das beendet sich der Export mit +# SIGSEGV (siehe _exit_tree im Whiteboard-Controller). XDG_DATA_HOME="$TMP_DIR/userdata" "$BINARY" --headless --quit-after 5 >"$LOG" 2>&1 STATUS=$? set -e