Handle the disconnection - transition to the appropriate state

Author: etet100

src/gpilot/core/state_behavior/abstractstatebehavior.cpp

@@ -237,6 +237,14 @@ void AbstractStateBehavior::onMachineStateChanged(MachineState state)
     emit machineStateChangedSignal(state);
 }
 
+void AbstractStateBehavior::onConnectionStateChanged(ConnectionState state)
+{
+    if (state == ConnectionState::Disconnected) {
+        qDebug() << QString("[%1] Connection lost, transitioning to Disconnecting").arg(name());
+        emit transition(this, new DisconnectingBehavior());
+    }
+}
+
 AbstractStateBehavior::Result AbstractStateBehavior::onCommandResponse(QString command, CommandAttributes commandAttributes,
                                                         CmdStatus cmdStatus, QString response,
                                                         QStringList fullResponse)

src/gpilot/core/state_behavior/abstractstatebehavior.h

@@ -161,9 +161,14 @@ class AbstractStateBehavior : public QObject
         // the buffer drains regardless of who sent the last command.
         virtual void onResponseProcessed() {}
 
-        virtual void onConnectionStateChanged(ConnectionState state) {
-            Q_UNUSED(state);
-        }
+        // Default: on Disconnected, transitions to DisconnectingBehavior so the
+        // base onExit() can run its standard cleanup (stops state polling, kills
+        // timers, clears scheduled callbacks, fires asyncCompleted to wake any
+        // co_awaiting coroutine). States that manage the connection lifecycle
+        // themselves (Connecting, Reconnecting, Disconnecting) override to keep
+        // their own logic. States with extra teardown (e.g. Running) override
+        // to clean up their own bookkeeping before transitioning.
+        virtual void onConnectionStateChanged(ConnectionState state);
 
         // Registers a callback to fire when the machine reaches targetState (Unknown = any state).
         // If milliseconds > 0, fires callback(MachineState::Unknown) on timeout.

src/gpilot/core/state_behavior/initializationbehavior.cpp

@@ -31,14 +31,6 @@ void InitializationBehavior::onMachineStateChanged(MachineState state)
 //     // This could be used to transition to other behaviors based on command responses
 // }
 
-void InitializationBehavior::onConnectionStateChanged(ConnectionState state)
-{
-    if (state == ConnectionState::Disconnected) {
-        // Handle disconnection if necessary
-        emit transition(this, new AlarmBehavior()); // Example: transition to alarm on disconnect
-    }
-}
-
 AbstractStateBehavior::Result InitializationBehavior::doOnEntry(CommunicatorApi *communicator, const EntryContext &ctx)
 {
     qDebug() << "[Behavior][Initialization] Entry";

src/gpilot/core/state_behavior/initializationbehavior.h

@@ -13,7 +13,6 @@ class InitializationBehavior : public AbstractStateBehavior
         Type type() const override { return Type::Initialization; }
         void onMachineStateChanged(MachineState state) override;
         // bool onCommandResponse(QString command, QString response, QStringList fullResponse) override;
-        void onConnectionStateChanged(ConnectionState state) override;
         Result doOnEntry(CommunicatorApi *communicator, const EntryContext &ctx) override;
         Result doOnExit(AbstractStateBehavior *next) override;
 

src/gpilot/core/state_behavior/reconnectingbehavior.h

@@ -17,6 +17,10 @@ class ReconnectingBehavior : public AbstractStateBehavior
         QString description() override { return "Reconnecting"; }
         Type type() const override { return Type::Reconnecting; }
         Result doOnEntry(CommunicatorApi *communicator, const EntryContext &ctx) override;
+        // Disconnected events during reconnection are expected — the polling
+        // timer in doOnEntry drives the lifecycle. Don't fall through to the
+        // base default that would transition to DisconnectingBehavior.
+        void onConnectionStateChanged(ConnectionState state) override { Q_UNUSED(state); }
 
     protected:
         QString name() const override { return "Reconnecting"; }

src/gpilot/core/state_behavior/runningbehavior.cpp

@@ -8,6 +8,7 @@
 #include "idlebehavior.h"
 #include "pausebehavior.h"
 #include "alarmbehavior.h"
+#include "disconnectingbehavior.h"
 #include "toolchangebehavior.h"
 #include "userpromptbehavior.h"
 #include "core/communicator/communicator.h"
@@ -225,6 +226,29 @@ void RunningBehavior::onAlarm(int code)
     emit transition(this, new AlarmBehavior(code));
 }
 
+void RunningBehavior::onConnectionStateChanged(ConnectionState state)
+{
+    if (state != ConnectionState::Disconnected) {
+        return;
+    }
+
+    qDebug() << "[Behavior][Running] Connection lost, aborting program";
+
+    Core::instance().timer().stopExecution();
+
+    // Mark every still-unacknowledged program command as aborted so the program
+    // table reflects what actually happened — those commands will never get a
+    // response now that the controller is gone.
+    for (auto &cmd : m_communicator->commandBuffer()->commands()) {
+        if (cmd.tableIndex >= 0) {
+            m_program.setCommandAborted(cmd.tableIndex);
+        }
+    }
+    m_communicator->clearCommandsAndQueue();
+
+    emit transition(this, new DisconnectingBehavior());
+}
+
 void RunningBehavior::doOnMachineState(MachineState state)
 {
     // Fallback for the missed-Run race: a very short program (e.g. M5 + M30)

src/gpilot/core/state_behavior/runningbehavior.h

@@ -43,6 +43,7 @@ class RunningBehavior : public AbstractStateBehavior
         Result onCommandResponse(QString command, CommandAttributes commandAttributes, CmdStatus cmdStatus, QString response, QStringList fullResponse) override;
         void onResponseProcessed() override;
         void onAlarm(int code) override;
+        void onConnectionStateChanged(ConnectionState state) override;
         Result doOnEntry(CommunicatorApi *communicator, const EntryContext &ctx) override;
         // Running-specific methods
         void handleFeedOverride(int percentage);

src/gpilot/io/connection/virtualconnection.cpp

@@ -180,12 +180,16 @@ void VirtualConnection::startProcess()
              << "type:" << simulatorType();
 
     m_process = new QProcess(this);
+    connect(m_process, &QProcess::finished, this, &VirtualConnection::onProcessFinished);
+    connect(m_process, &QProcess::errorOccurred, this, &VirtualConnection::onProcessErrorOccurred);
+
     m_process->start(exePath, {m_server->serverName(), simulatorType()});
 
     if (!m_process->waitForStarted(3000)) {
         qWarning() << qPrintable(QString("[IO][%1]").arg(m_deviceName))
                    << "Failed to start simulator process:" << m_process->errorString();
-        delete m_process;
+        m_process->disconnect(this);
+        m_process->deleteLater();
         m_process = nullptr;
         setState(ConnectionState::Disconnected);
     }
@@ -197,14 +201,44 @@ void VirtualConnection::killProcess()
         return;
     }
 
-    qDebug() << qPrintable(QString("[IO][%1]").arg(m_deviceName)) << "Killing simulator process...";
+    // Disconnect signals first to avoid re-entering cleanup() via onProcessFinished().
+    m_process->disconnect(this);
+
+    if (m_process->state() != QProcess::NotRunning) {
+        qDebug() << qPrintable(QString("[IO][%1]").arg(m_deviceName)) << "Killing simulator process...";
+        m_process->kill();
+        if (!m_process->waitForFinished(2000)) {
+            qWarning() << qPrintable(QString("[IO][%1]").arg(m_deviceName))
+                       << "Simulator process did not terminate within timeout.";
+        }
+    } else {
+        qDebug() << qPrintable(QString("[IO][%1]").arg(m_deviceName)) << "Simulator process already stopped.";
+    }
 
-    m_process->kill();
-    m_process->waitForFinished(2000);
-    delete m_process;
+    m_process->deleteLater();
     m_process = nullptr;
 }
 
+void VirtualConnection::onProcessFinished(int exitCode, QProcess::ExitStatus status)
+{
+    qDebug() << qPrintable(QString("[IO][%1]").arg(m_deviceName))
+             << "Simulator process finished. exitCode:" << exitCode
+             << "status:" << (status == QProcess::NormalExit ? "NormalExit" : "CrashExit");
+
+    cleanup();
+}
+
+void VirtualConnection::onProcessErrorOccurred(QProcess::ProcessError error)
+{
+    qWarning() << qPrintable(QString("[IO][%1]").arg(m_deviceName))
+               << "Simulator process error:" << error
+               << (m_process ? m_process->errorString() : QString());
+
+    if (error == QProcess::Crashed || error == QProcess::FailedToStart) {
+        cleanup();
+    }
+}
+
 #endif // VIRTUAL_SIMULATOR_PROCESS
 
 // Data transfer

src/gpilot/io/connection/virtualconnection.h

@@ -93,6 +93,10 @@ private slots:
     void onDisconnected();
     void onControlDisconnected();
     void onReadyRead();
+#ifdef VIRTUAL_SIMULATOR_PROCESS
+    void onProcessFinished(int exitCode, QProcess::ExitStatus status);
+    void onProcessErrorOccurred(QProcess::ProcessError error);
+#endif
 };
 
 #endif // VIRTUALCONNECTION_H