From bd9dc739136a98d5a902bd516c945589d3985868 Mon Sep 17 00:00:00 2001 From: Ralph Martin Fischer Date: Sat, 7 Nov 2026 09:34:59 +0100 Subject: [PATCH 1/7] Cmd+Q: letzte Sicherung und Ende von rigctld im closeEvent Unter macOS enden Cmd+Q und quit() in exit(), noch innerhalb von closeEvent(). Der Destruktor von AppController lief auf diesen Wegen nie: die letzte Log-Sicherung samt Kopie in den zweiten Ordner fiel aus, und rigctld/rotctld blieben als Waisen zurueck und hielten den seriellen Anschluss. Beides steht jetzt in AppController::vorDemBeenden(), aufgerufen aus closeEvent() und aus dem Destruktor. Co-Authored-By: Claude Opus 5.5 --- src/app/AppController.cpp | 5 + src/app/AppController.h | 12 ++ src/ui/MainWindow.cpp | 3 + tests/CMakeLists.txt | 1 + tests/test_cmdq_ohne_destruktor.cpp | 177 ++++++++++++++++++++++++++++ 5 files changed, 198 insertions(+) create mode 100644 tests/test_cmdq_ohne_destruktor.cpp diff --git a/src/app/AppController.cpp b/src/app/AppController.cpp index 3565e59..f28c2fa 100644 --- a/src/app/AppController.cpp +++ b/src/app/AppController.cpp @@ -279,6 +279,11 @@ void AppController::superviseRotctld(int slot, bool mayStart) } AppController::~AppController() +{ + vorDemBeenden(); +} + +void AppController::vorDemBeenden() { if (m_logBackup && m_database.isOpen()) { m_logBackup->backupNow(false); diff --git a/src/app/AppController.h b/src/app/AppController.h index 7adb078..6fb4ddb 100644 --- a/src/app/AppController.h +++ b/src/app/AppController.h @@ -71,6 +71,18 @@ class AppController : public QObject { // timer never sees the QSOs of the final minutes otherwise. ~AppController() override; + // Was beim Beenden geschehen muss: die letzte Sicherung und das Ende + // der eigenen rotctld/rigctld. Aufruf aus MainWindow::closeEvent() + // UND aus dem Destruktor, mehrfach ohne Schaden. + // + // Der Destruktor allein reicht nicht. Gemessen am 2026-11-07 (Qt 6.11, + // macOS): Cmd+Q und QCoreApplication::quit() enden über + // [NSApp terminate:] in exit(), noch innerhalb von closeEvent(). Die + // Objekte auf dem Stapel von main() werden dabei nie zerstört. Nur + // der rote Punkt erreicht den Destruktor. closeEvent() läuft auf + // allen drei Wegen. + void vorDemBeenden(); + // Opens `path`, loads settings + available ContestDefinitions, and // applies them to the network clients/GeoFilter. Returns false and // fills `errorOut` (if given) on failure. diff --git a/src/ui/MainWindow.cpp b/src/ui/MainWindow.cpp index b7181bd..1a1f1b7 100644 --- a/src/ui/MainWindow.cpp +++ b/src/ui/MainWindow.cpp @@ -2262,6 +2262,9 @@ void MainWindow::aktualisiereMitschnittAnzeige() void MainWindow::closeEvent(QCloseEvent* event) { saveWindowGeometry(); + // Hier und nicht erst im Destruktor: bei Cmd+Q läuft keiner mehr, + // siehe AppController::vorDemBeenden(). + m_appController.vorDemBeenden(); QMainWindow::closeEvent(event); } diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index f1d251e..7cc743f 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -127,6 +127,7 @@ contestprogramm_add_test(test_rotctldprocess) contestprogramm_add_test(test_client_reconnect) contestprogramm_add_test(test_rotctld_supervision) contestprogramm_add_test(test_rigctld_supervision) +contestprogramm_add_test(test_cmdq_ohne_destruktor) contestprogramm_add_test(test_netz_unter_stoerung) contestprogramm_add_test(test_readiness_check) contestprogramm_add_test(test_clock_check) diff --git a/tests/test_cmdq_ohne_destruktor.cpp b/tests/test_cmdq_ohne_destruktor.cpp new file mode 100644 index 0000000..c283fd0 --- /dev/null +++ b/tests/test_cmdq_ohne_destruktor.cpp @@ -0,0 +1,177 @@ +// SPDX-License-Identifier: GPL-3.0-or-later +// ================================================================= +// tests/test_cmdq_ohne_destruktor.cpp (Contestprogramm) +// ================================================================= +// +// Die letzte Sicherung und das Ende von rigctld standen im Destruktor +// von AppController. Bei Cmd+Q läuft der nicht. +// +// Gemessen am 2026-11-07 mit einer kleinen Qt-6.11-Sonde unter macOS: +// +// Weg closeEvent exec() zurück Destruktor atexit +// Cmd+Q ja nein nein ja +// quit() ja nein nein ja +// roter Punkt ja ja ja ja +// +// Das exit() kommt noch innerhalb von closeEvent(). Hier wird darum nur +// das Fenster geschlossen und AppController bewusst NICHT zerstört -- +// genau so viel, wie der Betrieb bei Cmd+Q erlebt. +// +// Modification history (Contestprogramm): +// 2026-11-07 — Original von Martin Fischer (OE5SOS), KI-gestützt +// über Anthropic Claude. +// ================================================================= + +#include + +#include +#include +#include +#include +#include + +#include "app/AppController.h" +#include "app/ContestSettings.h" +#include "data/LogBackup.h" +#include "data/QsoRecord.h" +#include "ui/MainWindow.h" + +#include + +using namespace Contestprogramm; + +namespace { + +QsoRecord einQso(const QString& rufzeichen) +{ + QsoRecord r; + r.callsign = rufzeichen; + r.band = QStringLiteral("144"); + r.mode = QStringLiteral("SSB"); + r.timestampUtc = QStringLiteral("2026-11-07T08:00:00Z"); + r.contestId = QStringLiteral("IARU_R1_VHF_UHF"); + return r; +} + +quint16 freierPort() +{ + QTcpServer probe; + probe.listen(QHostAddress::LocalHost, 0); + const quint16 port = probe.serverPort(); + probe.close(); + return port; +} + +std::unique_ptr baueSteuerung(QTemporaryDir& dir) +{ + auto c = std::make_unique(); + if (!c->openDatabase(dir.filePath(QStringLiteral("cmdq.sqlite")))) { return nullptr; } + ContestSettings s = c->settings(); + s.ownCallsign = QStringLiteral("OE5SOS"); + s.ownGrid = QStringLiteral("JN67UT"); + s.rigctldHost.clear(); + s.rotor1Enabled = false; + s.rotor2Enabled = false; + c->setSettings(s); + return c; +} + +} // namespace + +class TestCmdQOhneDestruktor : public QObject +{ + Q_OBJECT + +private slots: + void dasSchliessenSchreibtDieLetzteSicherung(); + void dasSchliessenBeendetRigctld(); + void zweimalSchliessenSchadetNicht(); +}; + +// ── Die QSOs der letzten Minute ───────────────────────────────────── +void TestCmdQOhneDestruktor::dasSchliessenSchreibtDieLetzteSicherung() +{ + QTemporaryDir dir; + QVERIFY(dir.isValid()); + auto c = baueSteuerung(dir); + QVERIFY(c); + MainWindow fenster(*c); + + QVERIFY(c->logBackup()); + const QString ordner = c->logBackup()->directory(); + const int vorher = LogBackup::listBackups(ordner).size(); + + QsoRecord qso = einQso(QStringLiteral("DL1ABC")); + QVERIFY(c->database().insertQso(qso)); + + fenster.close(); + + QVERIFY2(LogBackup::listBackups(ordner).size() > vorher, + "nach dem Schliessen fehlt die letzte Sicherung -- bei Cmd+Q " + "wuerde der Destruktor sie nicht mehr schreiben"); +} + +// ── rigctld hält sonst den Anschluss des Funkgeräts ───────────────── +void TestCmdQOhneDestruktor::dasSchliessenBeendetRigctld() +{ +#ifdef Q_OS_WIN + QSKIP("Der Stellvertreter-rigctld ist ein Shell-Skript; unter Windows startet QProcess es nicht."); +#else + QTemporaryDir dir; + QVERIFY(dir.isValid()); + + QFile skript(dir.filePath(QStringLiteral("rigctld"))); + QVERIFY(skript.open(QIODevice::WriteOnly | QIODevice::Text)); + skript.write("#!/bin/sh\nexec sleep 60\n"); + skript.close(); + QVERIFY(skript.setPermissions(QFile::ReadOwner | QFile::WriteOwner | QFile::ExeOwner)); + const QByteArray altePfade = qgetenv("PATH"); + qputenv("PATH", (dir.path() + QLatin1Char(':') + QString::fromLocal8Bit(altePfade)).toLocal8Bit()); + + auto c = baueSteuerung(dir); + QVERIFY(c); + MainWindow fenster(*c); + + ContestSettings s = c->settings(); + s.rigctldHost = QStringLiteral("127.0.0.1"); + s.rigctldPort = freierPort(); + s.rigctldHamlibModel = 2031; + s.rigctldDevice = QStringLiteral("/dev/cu.fake"); + s.rigctldBaud = 115200; + c->setSettings(s); + + // Voraussetzung: ohne laufenden Daemon sagte die Prüfung nichts. + QTRY_VERIFY_WITH_TIMEOUT(c->rigctldRunning(), 8000); + + fenster.close(); + + QVERIFY2(!c->rigctldRunning(), + "rigctld laeuft nach dem Schliessen weiter -- bei Cmd+Q bliebe " + "er als Waise zurueck und hielte den seriellen Anschluss"); + + qputenv("PATH", altePfade); +#endif +} + +// ── Schliessen, dann der Destruktor auf dem roten Punkt ───────────── +void TestCmdQOhneDestruktor::zweimalSchliessenSchadetNicht() +{ + QTemporaryDir dir; + QVERIFY(dir.isValid()); + auto c = baueSteuerung(dir); + QVERIFY(c); + + QsoRecord qso = einQso(QStringLiteral("DL2ABC")); + QVERIFY(c->database().insertQso(qso)); + + c->vorDemBeenden(); + const QString ordner = c->logBackup()->directory(); + const int nachDemErsten = LogBackup::listBackups(ordner).size(); + QVERIFY(nachDemErsten > 0); + + c->vorDemBeenden(); + QCOMPARE(LogBackup::listBackups(ordner).size(), nachDemErsten); +} + +QTEST_MAIN(TestCmdQOhneDestruktor) +#include "test_cmdq_ohne_destruktor.moc" From f1c8be012ed62a3f394190511eed2668806bf742 Mon Sep 17 00:00:00 2001 From: Ralph Martin Fischer Date: Sat, 7 Nov 2026 16:53:15 +0100 Subject: [PATCH 2/7] Abbau: die Aufsicht startet rigctld nicht mehr neu Beim Abbau meldete sich die CAT-Verbindung ab, und die Aufsicht griff auf das schon zerstoerte RigctldProcess zu. Die Leitungen werden jetzt zuerst gekappt. Der Pruefstand laeuft ohne die Behebung in den SIGSEGV. Co-Authored-By: Claude Opus 5.5 --- src/app/AppController.cpp | 7 +++++++ tests/test_cmdq_ohne_destruktor.cpp | 25 +++++++++++++++++++++++++ 2 files changed, 32 insertions(+) diff --git a/src/app/AppController.cpp b/src/app/AppController.cpp index f28c2fa..db9b012 100644 --- a/src/app/AppController.cpp +++ b/src/app/AppController.cpp @@ -285,6 +285,13 @@ AppController::~AppController() void AppController::vorDemBeenden() { + // Zuerst die Leitungen kappen. Wer gleich rotctld und rigctld beendet, + // verliert die Verbindung zu ihnen, und die Aufsicht wuerde sie + // sofort neu starten -- im Destruktor auf schon abgebauten Mitgliedern + // (SIGSEGV in RigctldProcess::start, gemessen 2026-11-07). + disconnect(&m_rigctldClient, nullptr, this, nullptr); + disconnect(&m_rotor1, nullptr, this, nullptr); + disconnect(&m_rotor2, nullptr, this, nullptr); if (m_logBackup && m_database.isOpen()) { m_logBackup->backupNow(false); } diff --git a/tests/test_cmdq_ohne_destruktor.cpp b/tests/test_cmdq_ohne_destruktor.cpp index c283fd0..f3216c7 100644 --- a/tests/test_cmdq_ohne_destruktor.cpp +++ b/tests/test_cmdq_ohne_destruktor.cpp @@ -86,6 +86,7 @@ private slots: void dasSchliessenSchreibtDieLetzteSicherung(); void dasSchliessenBeendetRigctld(); void zweimalSchliessenSchadetNicht(); + void derAbbauStartetKeinRigctldNeu(); }; // ── Die QSOs der letzten Minute ───────────────────────────────────── @@ -173,5 +174,29 @@ void TestCmdQOhneDestruktor::zweimalSchliessenSchadetNicht() QCOMPARE(LogBackup::listBackups(ordner).size(), nachDemErsten); } +// Beim Abbau meldete sich die CAT-Verbindung ab, und die Aufsicht startete +// rigctld auf einem schon zerstoerten Mitglied: SIGSEGV in +// RigctldProcess::start, gemessen 2026-11-07 in Longpath. +void TestCmdQOhneDestruktor::derAbbauStartetKeinRigctldNeu() +{ + QTemporaryDir dir; + QVERIFY(dir.isValid()); + QTcpServer geraet; + QVERIFY(geraet.listen(QHostAddress::LocalHost, 0)); + + auto c = baueSteuerung(dir); + QVERIFY(c); + ContestSettings s = c->settings(); + s.rigctldHost = QStringLiteral("127.0.0.1"); + s.rigctldPort = geraet.serverPort(); + s.rigctldHamlibModel = 2031; + s.rigctldDevice = QStringLiteral("/dev/cu.fake"); + s.rigctldBaud = 115200; + c->setSettings(s); + + QTRY_VERIFY_WITH_TIMEOUT(c->rigctldClient().isConnected(), 5000); + c.reset(); // darf nicht abstuerzen +} + QTEST_MAIN(TestCmdQOhneDestruktor) #include "test_cmdq_ohne_destruktor.moc" From 5d8b1a1611ce389337f0d58620503cfac171c899 Mon Sep 17 00:00:00 2001 From: Ralph Martin Fischer Date: Sat, 7 Nov 2026 17:29:03 +0100 Subject: [PATCH 3/7] Pruefstand Abbau: unter Windows ueberspringen Co-Authored-By: Claude Opus 5.5 --- tests/test_cmdq_ohne_destruktor.cpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests/test_cmdq_ohne_destruktor.cpp b/tests/test_cmdq_ohne_destruktor.cpp index f3216c7..2ecffc4 100644 --- a/tests/test_cmdq_ohne_destruktor.cpp +++ b/tests/test_cmdq_ohne_destruktor.cpp @@ -179,6 +179,9 @@ void TestCmdQOhneDestruktor::zweimalSchliessenSchadetNicht() // RigctldProcess::start, gemessen 2026-11-07 in Longpath. void TestCmdQOhneDestruktor::derAbbauStartetKeinRigctldNeu() { +#ifdef Q_OS_WIN + QSKIP("Der Windows-Laeufer verbindet hier nicht; der Weg ist derselbe."); +#endif QTemporaryDir dir; QVERIFY(dir.isValid()); QTcpServer geraet; From 03078edfb1100043cdd19cb71f44e5ea5514a65b Mon Sep 17 00:00:00 2001 From: Ralph Martin Fischer Date: Sat, 7 Nov 2026 20:20:13 +0100 Subject: [PATCH 4/7] In Longpath eingebettet startet das Logbuch keinen eigenen rigctld Kam der erste Anruf vor dem Server von Longpath, startete die Aufsicht einen eigenen rigctld. Der nahm Longpath Anschluss und Port weg, oder er starb mit Code 1, wenn Longpath den Anschluss schon hielt. Co-Authored-By: Claude Opus 5.5 --- src/app/AppController.cpp | 2 +- src/app/AppController.h | 6 ++++++ tests/test_rigctld_supervision.cpp | 33 ++++++++++++++++++++++++++++++ 3 files changed, 40 insertions(+), 1 deletion(-) diff --git a/src/app/AppController.cpp b/src/app/AppController.cpp index db9b012..5d40ea5 100644 --- a/src/app/AppController.cpp +++ b/src/app/AppController.cpp @@ -218,7 +218,7 @@ void AppController::superviseRigctld(bool mayStart) // failed dial brings a fresh one. stopRigctld(); } - if (!mayStart) { + if (!mayStart || !m_rigctldSelbstStarten) { return; } // A rigctld that just died (a serial port that is not there, a diff --git a/src/app/AppController.h b/src/app/AppController.h index 6fb4ddb..a352140 100644 --- a/src/app/AppController.h +++ b/src/app/AppController.h @@ -88,6 +88,11 @@ class AppController : public QObject { // fills `errorOut` (if given) on failure. bool openDatabase(const QString& path, QString* errorOut = nullptr); + /// In Longpath eingebettet ist Longpath der CAT-Server und haelt den + /// Anschluss. Ein eigener rigctld wuerde ihm beides wegnehmen, sobald + /// der erste Anruf noch vor dessen Server kommt. Vor openDatabase(). + void setRigctldSelbstStarten(bool darf) { m_rigctldSelbstStarten = darf; } + ContestDatabase& database() { return m_database; } // Periodic copies of the database (data/LogBackup.h); created in // openDatabase() beside the database file, null before that. @@ -309,6 +314,7 @@ class AppController : public QObject { RigctldLaunch m_rigctldLaunch; // what m_rigctld runs with; empty when not ours/not running QDateTime m_rigctldFailedAt; // last failure, for the restart cool-down bool m_rigctldStopping = false; // true while our own stopRigctld() is ending it + bool m_rigctldSelbstStarten = true; TransverterSetup m_transverter; CallsignLocatorLookup m_callsignLocatorLookup; // holds ContestDatabase& -- declared after m_database TerrainDataManager m_terrainDataManager; // declared before m_geoFilter -- setTerrainDataManager() takes its address diff --git a/tests/test_rigctld_supervision.cpp b/tests/test_rigctld_supervision.cpp index 7f01ece..8914b71 100644 --- a/tests/test_rigctld_supervision.cpp +++ b/tests/test_rigctld_supervision.cpp @@ -69,11 +69,44 @@ private slots: void launchOnlyForALoopbackHostWithADevice(); void argumentsAreTheDocumentedRigctldForm(); void startsAfterTheClientFailsAndFollowsTheSettings(); + void inLongpathStartetEsKeinenEigenen(); void theModelListComesFromTheInstalledHamlib(); void theWholeChainWorksWithARealHamlib(); void thePickerOffersEveryRadioHamlibKnows(); }; +// Eingebettet in Longpath: der abgewiesene Anruf darf nichts starten, sonst +// nimmt ein eigener rigctld Longpath den Anschluss weg. +void TestRigctldSupervision::inLongpathStartetEsKeinenEigenen() +{ +#ifdef Q_OS_WIN + QSKIP("Der Stellvertreter-rigctld ist ein Shell-Skript; unter Windows startet QProcess es nicht."); +#endif + QTemporaryDir dir; + QVERIFY(dir.isValid()); + const QString argsFile = dir.filePath(QStringLiteral("rigctld.args")); + QVERIFY(installFakeRigctld(QDir(dir.path()), argsFile)); + + AppController controller; + controller.setRigctldSelbstStarten(false); + QVERIFY(controller.openDatabase(dir.filePath(QStringLiteral("eingebettet.sqlite")))); + ContestSettings settings = controller.settings(); + settings.ownCallsign = QStringLiteral("OE5SOS"); + settings.ownGrid = QStringLiteral("JN67UT"); + settings.rotor1Enabled = false; + settings.rotor2Enabled = false; + settings.rigctldHost = QStringLiteral("127.0.0.1"); + settings.rigctldPort = freePort(); + settings.rigctldHamlibModel = 2037; + settings.rigctldDevice = QStringLiteral("/dev/cu.fake-A"); + settings.rigctldBaud = 115200; + controller.setSettings(settings); + + QTest::qWait(2500); + QVERIFY(!controller.rigctldRunning()); + QVERIFY(readArgs(argsFile).isEmpty()); +} + void TestRigctldSupervision::launchOnlyForALoopbackHostWithADevice() { ContestSettings settings; From a551d3d55fe927a4999f4af4d09d99be3d937bf0 Mon Sep 17 00:00:00 2001 From: Ralph Martin Fischer Date: Sun, 8 Nov 2026 07:51:06 +0100 Subject: [PATCH 5/7] =?UTF-8?q?Startcheck=20auch=20f=C3=BCr=20einen=20Wirt?= =?UTF-8?q?=20ohne=20Men=C3=BC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Longpath bettet das Logbuch ein und zeigt nur seine Panels; das Menü mit dem Startcheck gibt es dort nicht. zeigeStartcheck() öffnet ihn, auf Wunsch als Werkzeugfenster auf der Ebene der schwebenden Panels. Co-Authored-By: Claude Opus 5.5 --- src/ui/MainWindow.cpp | 14 ++++++++++++++ src/ui/MainWindow.h | 5 +++++ 2 files changed, 19 insertions(+) diff --git a/src/ui/MainWindow.cpp b/src/ui/MainWindow.cpp index 1a1f1b7..bbd7ec2 100644 --- a/src/ui/MainWindow.cpp +++ b/src/ui/MainWindow.cpp @@ -6255,6 +6255,20 @@ void MainWindow::openReadinessWindow() m_readinessWindow->activateWindow(); } +QWidget* MainWindow::zeigeStartcheck(bool alsWerkzeugfenster) +{ + openReadinessWindow(); + if (alsWerkzeugfenster && m_readinessWindow + && m_readinessWindow->windowType() != Qt::Tool) { + m_readinessWindow->setWindowFlags( + (m_readinessWindow->windowFlags() & ~Qt::WindowType_Mask) | Qt::Tool); + m_readinessWindow->setAttribute(Qt::WA_MacAlwaysShowToolWindow); + m_readinessWindow->show(); + m_readinessWindow->raise(); + } + return m_readinessWindow; +} + void MainWindow::openShortcutsWindow() { if (!m_shortcutsWindow) { diff --git a/src/ui/MainWindow.h b/src/ui/MainWindow.h index a6334cb..603241e 100644 --- a/src/ui/MainWindow.h +++ b/src/ui/MainWindow.h @@ -82,6 +82,11 @@ class MainWindow : public QMainWindow { explicit MainWindow(AppController& appController, QWidget* parent = nullptr); ~MainWindow() override; + // Der Startcheck fuer einen Wirt ohne dieses Menue (Longpath bettet das + // Logbuch ein und zeigt nur seine Panels). Als Werkzeugfenster steht er + // auf derselben Ebene wie die schwebenden Panels und nicht darunter. + QWidget* zeigeStartcheck(bool alsWerkzeugfenster); + // The restore itself, without the dialogs (public for the tests): // safety backup, close, replace the file, restartRequested(). // False = nothing replaced (the safety backup failed) or the copy From 26beeb74a96574f8e2398cda045c0bf198f79309 Mon Sep 17 00:00:00 2001 From: Ralph Martin Fischer Date: Sun, 8 Nov 2026 09:44:44 +0100 Subject: [PATCH 6/7] CI: macOS auf macos-15 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Seit dem 06.11. bricht GitHub jeden Lauf auf macos-14 nach null Sekunden ab, ohne einen Schritt, in jedem PR. Longpath fordert macos-15 an und läuft. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/build.yml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index f1f8097..a5c95ef 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -232,7 +232,10 @@ jobs: paket: macos-apple-silicon - arch: x86_64 paket: macos-intel - runs-on: macos-14 + # macos-14 statt 15 lief bis zum 05.11.2026; ab dem 06.11. brach GitHub + # jeden Lauf darauf nach null Sekunden ab, ohne einen Schritt. Longpath + # fordert macos-15 an und lief am selben Tag durch. + runs-on: macos-15 steps: - uses: actions/checkout@v4 with: From 608032d493a6ea53575afced4dbb0212cffc2a22 Mon Sep 17 00:00:00 2001 From: Ralph Martin Fischer Date: Wed, 11 Nov 2026 08:24:46 +0100 Subject: [PATCH 7/7] setTarget: ein neues Ziel gilt sofort RigctldClient/RotctldClient::setTarget() merkte sich nur Host und Port. Ein Anruf, der schon unterwegs war, ging beim ALTEN Ziel zu Ende, und ein verbundener Klient blieb dort bis zum naechsten Abriss. AppController::openDatabase() waehlt mit den Vorgaben 127.0.0.1:4532, bevor setSettings() das eigentliche Ziel setzt -- ohne Ereignisschleife dazwischen. Auf einem Rechner mit laufendem Longpath lauscht dort dessen CAT-Server: test_seitenband_folgt_dem_band landete dort (Hamlib-Fehler statt Antworten, Befehle beim fremden Dienst), und test_rigctld_supervision / test_cmdq_ohne_destruktor sahen nie einen gescheiterten Anruf, also nie den eigenen rigctld. Dieselbe Reihenfolge erklaert "L KEYSPD 24" im macOS-Lauf: der Klient war zuerst woanders verbunden. Jetzt: bei geaendertem Ziel auflegen und beim neuen sofort waehlen; ohne Ziel aufgelegt bleiben; dasselbe Ziel aendert nichts. test_client_reconnect: drei Faelle (Rig: Ziel waehrend des Anrufs gewechselt -- das alte bekommt kein Byte; Rig: verbunden, anderer Port -- Wechsel unter der Wiederwahl-Frist, gleiches Ziel bleibt, leeres Ziel legt auf; Rotor: wie der erste). Gegenprobe mit dem alten setTarget: alle drei rot. Lokal gruen: test_client_reconnect, test_seitenband_folgt_dem_band, test_rigctld_supervision, test_cmdq_ohne_destruktor, test_rigctldprotocol (vorher drei davon rot, solange Longpath lief). Co-Authored-By: Claude Opus 5.5 --- src/core/RigctldClient.cpp | 29 ++++++++- src/core/RotctldClient.cpp | 29 ++++++++- tests/test_client_reconnect.cpp | 107 +++++++++++++++++++++++++++++++- 3 files changed, 162 insertions(+), 3 deletions(-) diff --git a/src/core/RigctldClient.cpp b/src/core/RigctldClient.cpp index 3984f93..56dd7c1 100644 --- a/src/core/RigctldClient.cpp +++ b/src/core/RigctldClient.cpp @@ -10,6 +10,9 @@ // Longpath/NereusSDR's RotctldClient.cpp. AI-assisted // via Anthropic Claude Code, operator Ralph Martin // Fischer. +// 2026-11-11 — setTarget(): ein neues Ziel gilt sofort (auflegen, +// neu waehlen). Ralph Martin Fischer, KI-gestuetzt +// ueber Anthropic Claude. // ================================================================= #include "RigctldClient.h" @@ -109,8 +112,32 @@ RigctldClient::RigctldClient(QObject* parent) : QObject(parent) void RigctldClient::setTarget(const QString& host, quint16 port) { - m_host = host.trimmed(); + const QString neu = host.trimmed(); + if (neu == m_host && port == m_port) { return; } + m_host = neu; m_port = port; + + // Ein neues Ziel gilt sofort (2026-11-11). Bis dahin merkte sich + // setTarget() nur Host und Port: ein Anruf, der schon unterwegs war, + // ging beim ALTEN Ziel zu Ende, und ein verbundener Klient blieb dort + // bis zum naechsten Abriss. AppController::openDatabase() waehlt mit + // den Vorgaben (127.0.0.1:4532), bevor die eigenen Einstellungen + // greifen -- auf Martins Rechner lauscht dort Longpaths CAT-Server, + // und ein Pruefstand schickte ihm seine Befehle. Also: auflegen und + // beim neuen Ziel neu waehlen. Ohne Ziel bleibt es aufgelegt. + if (m_socket.state() == QAbstractSocket::UnconnectedState) { return; } + m_poll->stop(); + m_deadline->stop(); + m_queue.clear(); + m_buffer.clear(); + m_awaiting = Pending::None; + m_socket.abort(); + if (m_host.isEmpty()) { + m_retry->stop(); + setState(State::Disconnected); + return; + } + connectToRig(); } void RigctldClient::setPollIntervalMs(int ms) diff --git a/src/core/RotctldClient.cpp b/src/core/RotctldClient.cpp index 4d3b0cf..aa7ae55 100644 --- a/src/core/RotctldClient.cpp +++ b/src/core/RotctldClient.cpp @@ -10,6 +10,9 @@ // Longpath/NereusSDR's RotctldClient.cpp. AI-assisted // via Anthropic Claude Code, operator Ralph Martin // Fischer. +// 2026-11-11 — setTarget(): ein neues Ziel gilt sofort (auflegen, +// neu waehlen). Ralph Martin Fischer, KI-gestuetzt +// ueber Anthropic Claude. // ================================================================= #include "RotctldClient.h" @@ -114,8 +117,32 @@ RotctldClient::RotctldClient(QObject* parent) : QObject(parent) void RotctldClient::setTarget(const QString& host, quint16 port) { - m_host = host.trimmed(); + const QString neu = host.trimmed(); + if (neu == m_host && port == m_port) { return; } + m_host = neu; m_port = port; + + // Ein neues Ziel gilt sofort (2026-11-11). Bis dahin merkte sich + // setTarget() nur Host und Port: ein Anruf, der schon unterwegs war, + // ging beim ALTEN Ziel zu Ende, und ein verbundener Klient blieb dort + // bis zum naechsten Abriss. AppController::openDatabase() waehlt mit + // den Vorgaben (127.0.0.1:4532), bevor die eigenen Einstellungen + // greifen -- auf Martins Rechner lauscht dort Longpaths CAT-Server, + // und ein Pruefstand schickte ihm seine Befehle. Also: auflegen und + // beim neuen Ziel neu waehlen. Ohne Ziel bleibt es aufgelegt. + if (m_socket.state() == QAbstractSocket::UnconnectedState) { return; } + m_poll->stop(); + m_deadline->stop(); + m_queue.clear(); + m_buffer.clear(); + m_awaiting = Pending::None; + m_socket.abort(); + if (m_host.isEmpty()) { + m_retry->stop(); + setState(State::Disconnected); + return; + } + connectToRotor(); } void RotctldClient::setPollIntervalMs(int ms) diff --git a/tests/test_client_reconnect.cpp b/tests/test_client_reconnect.cpp index 13011a8..bfc0f66 100644 --- a/tests/test_client_reconnect.cpp +++ b/tests/test_client_reconnect.cpp @@ -59,8 +59,10 @@ class FakeDaemon : public QObject { connect(&m_server, &QTcpServer::newConnection, this, [this] { QTcpSocket* socket = m_server.nextPendingConnection(); - connect(socket, &QTcpSocket::readyRead, socket, [socket] { + ++m_anrufe; + connect(socket, &QTcpSocket::readyRead, socket, [this, socket] { const QByteArray request = socket->readAll(); + m_empfangen += request; if (request.startsWith("p")) { socket->write("123.0\n0.0\n"); } else if (request.startsWith("f")) { @@ -77,8 +79,14 @@ class FakeDaemon : public QObject return m_server.listen(QHostAddress::LocalHost, port); } + // Wie oft angerufen wurde und was ankam -- fuer die Zielwechsel-Faelle. + int anrufe() const { return m_anrufe; } + QByteArray empfangen() const { return m_empfangen; } + private: QTcpServer m_server; + int m_anrufe = 0; + QByteArray m_empfangen; }; } // namespace @@ -92,8 +100,105 @@ private slots: void rigClientFindsARigctldThatAppearsLater(); void on4kstClientDialsAgainAfterARefusedConnect(); void clusterClientDialsAgainAfterARefusedConnect(); + void rigClientDialsTheNewTargetNotTheOld(); + void rigClientLeavesAConnectedOldTarget(); + void rotorClientDialsTheNewTargetNotTheOld(); }; +// ── Zielwechsel (2026-11-11) ──────────────────────────────────────── +// +// AppController::openDatabase() waehlt mit den Vorgaben 127.0.0.1:4532, +// bevor setSettings() das eigentliche Ziel setzt -- ohne dass dazwischen +// ein Ereignis verarbeitet wird. setTarget() merkte sich das neue Ziel +// nur; der Anruf beim alten ging zu Ende, und dort bekam ein fremder +// Dienst die Abfragen und Befehle (auf Martins Rechner: Longpaths +// CAT-Server, gemessen mit test_seitenband_folgt_dem_band). Genau diese +// Reihenfolge hier: waehlen, Ziel wechseln, waehlen -- dann erst die +// Ereignisschleife. Das alte Ziel darf kein einziges Byte bekommen. +void TestClientReconnect::rigClientDialsTheNewTargetNotTheOld() +{ + FakeDaemon alt; + FakeDaemon neu; + const quint16 altPort = freePort(); + QVERIFY(alt.listen(altPort)); + const quint16 neuPort = freePort(); + QVERIFY(neu.listen(neuPort)); + + RigctldClient client; + client.setTarget(QStringLiteral("127.0.0.1"), altPort); + client.connectToRig(); + client.setTarget(QStringLiteral("127.0.0.1"), neuPort); + client.connectToRig(); // wie AppController::applyNetworkSettings + + QTRY_VERIFY_WITH_TIMEOUT(client.isConnected(), 10000); + QTRY_VERIFY_WITH_TIMEOUT(neu.empfangen().contains("f\n"), 10000); + QTest::qWait(300); + QCOMPARE(client.port(), neuPort); + QVERIFY2(alt.empfangen().isEmpty(), + qPrintable(QStringLiteral("das alte Ziel bekam: %1") + .arg(QString::fromLatin1(alt.empfangen())))); +} + +// Verbunden, und dann ein anderer Port in den Einstellungen: der Klient +// geht hinueber, sofort -- nicht erst, wenn das alte Geraet abreisst. +void TestClientReconnect::rigClientLeavesAConnectedOldTarget() +{ + FakeDaemon alt; + FakeDaemon neu; + const quint16 altPort = freePort(); + QVERIFY(alt.listen(altPort)); + const quint16 neuPort = freePort(); + QVERIFY(neu.listen(neuPort)); + + RigctldClient client; + client.setTarget(QStringLiteral("127.0.0.1"), altPort); + client.connectToRig(); + QTRY_VERIFY_WITH_TIMEOUT(client.isConnected(), 10000); + QTRY_VERIFY_WITH_TIMEOUT(alt.empfangen().contains("f\n"), 10000); + + client.setTarget(QStringLiteral("127.0.0.1"), neuPort); + client.connectToRig(); + // Unter der Wiederwahl-Frist (3 s): kein Abriss, auf den es wartet. + QTRY_VERIFY_WITH_TIMEOUT(neu.anrufe() == 1, 2500); + QTRY_VERIFY_WITH_TIMEOUT(client.isConnected(), 10000); + + // Dasselbe Ziel noch einmal: kein Auflegen, kein neuer Anruf. + client.setTarget(QStringLiteral("127.0.0.1"), neuPort); + QTest::qWait(300); + QVERIFY(client.isConnected()); + QCOMPARE(neu.anrufe(), 1); + + // Kein Ziel mehr: aufgelegt, und es wird auch nicht neu gewaehlt. + client.setTarget(QString(), 0); + QCOMPARE(client.state(), RigctldClient::State::Disconnected); + QTest::qWait(3500); + QCOMPARE(client.state(), RigctldClient::State::Disconnected); + QCOMPARE(neu.anrufe(), 1); +} + +void TestClientReconnect::rotorClientDialsTheNewTargetNotTheOld() +{ + FakeDaemon alt; + FakeDaemon neu; + const quint16 altPort = freePort(); + QVERIFY(alt.listen(altPort)); + const quint16 neuPort = freePort(); + QVERIFY(neu.listen(neuPort)); + + RotctldClient client; + client.setTarget(QStringLiteral("127.0.0.1"), altPort); + client.connectToRotor(); + client.setTarget(QStringLiteral("127.0.0.1"), neuPort); + client.connectToRotor(); + + QTRY_VERIFY_WITH_TIMEOUT(client.isConnected(), 10000); + QTRY_VERIFY_WITH_TIMEOUT(neu.empfangen().contains("p\n"), 10000); + QTest::qWait(300); + QVERIFY2(alt.empfangen().isEmpty(), + qPrintable(QStringLiteral("das alte Ziel bekam: %1") + .arg(QString::fromLatin1(alt.empfangen())))); +} + void TestClientReconnect::rotorClientFindsARotctldThatAppearsLater() { const quint16 port = freePort();