Tomas/connection raii initial

src/CMakeLists.txt

@@ -61,6 +61,8 @@ set(
   PACKETSENDER_SRCS
   about.cpp
   brucethepoodle.cpp
+  connection.cpp
+  connectionmanager.cpp
   irisandmarigold.cpp
   cloudui.cpp
   main.cpp
@@ -87,6 +89,7 @@ set(
   association.cpp
   dtlsserver.cpp
   dtlsthread.cpp
+  persistentLoopConnection.cpp
 )
 
 set(
@@ -156,6 +159,17 @@ if(APPLE)
   )
 endif()
 
+# ==================== UNIT TESTS (QtTest) ====================
+option(PACKETSENDER_BUILD_TESTS "Build unit tests (QtTest)" OFF)
+
+if(PACKETSENDER_BUILD_TESTS)
+  find_package(Qt6 REQUIRED COMPONENTS Test)
+
+  enable_testing()
+
+  add_subdirectory(tests/unit)
+endif()
+
 # -------------------
 # Packaging
 # -------------------

src/connection.cpp

@@ -0,0 +1,197 @@
+//
+// Created by Tomas Gallucci on 3/5/26.
+//
+
+#include "tcpthread.h"
+#include "packet.h"
+#include "connection.h"
+
+void Connection::setupThreadConnections()
+{
+    connect(m_thread.get(), &TCPThread::packetReceived, this, &Connection::onThreadPacketReceived);
+    connect(m_thread.get(), &TCPThread::connectStatus, this, &Connection::onThreadConnectStatus);
+    connect(m_thread.get(), &TCPThread::error, this, &Connection::onThreadError);
+    // Future-proof: if you later add more signals to TCPThread, add connects here
+}
+
+// Target constructor
+Connection::Connection(std::unique_ptr<TCPThread> thread,
+                       bool isIncoming,
+                       bool isSecure,
+                       bool isPersistent,
+                       qintptr socketDescriptor,
+                       QObject *parent)
+    : QObject(parent),
+      m_isIncoming(isIncoming),
+      m_isSecure(isSecure),
+      m_isPersistent(isPersistent),
+      m_socketDescriptor(socketDescriptor)
+{
+    if (!thread) {
+        throw std::invalid_argument("Thread must be provided");
+    }
+
+    m_thread = std::move(thread);
+    m_thread->setParent(this);
+
+    assignUniqueId();
+    setupThreadConnections();
+    start();
+}
+
+/* Client/outgoing constructor (delegates) */
+Connection::Connection(const QString &host,
+                    quint16 port,
+                    const Packet &initialPacket,
+                    QObject *parent,
+                    std::unique_ptr<TCPThread> thread)
+    : Connection(thread ? std::move(thread)
+                        : std::make_unique<TCPThread>(host, port, initialPacket, nullptr),
+                 false, false, true, -1, parent)
+{
+}
+
+// Server/incoming constructor (delegates, preserves member assignments)
+Connection::Connection(int socketDescriptor, bool isSecure, bool isPersistent, QObject *parent, std::unique_ptr<TCPThread> thread)
+    : Connection(thread ? std::move(thread)
+                        : std::make_unique<TCPThread>(socketDescriptor, isSecure, isPersistent, nullptr),
+                 true, isSecure, isPersistent, socketDescriptor, parent)
+{
+}
+
+Connection::~Connection()
+{
+    // NEW: RAII cleanup – close and wait for thread
+    if (m_thread && m_thread->isRunning()) {
+        qWarning() << "~Connection(): thread still running for" << m_id
+                   << "— forcing quick shutdown (user did not call close())";
+
+        shutdownThreadSafely(1000);  // shorter timeout in destructor
+    }
+    // unique_ptr will delete it automatically here
+}
+
+void Connection::close()
+{
+    if (!m_thread || !m_threadStarted) {
+        qDebug() << "close() called but thread not started or already closed";
+        return;
+    }
+
+    if (m_isClosing) {
+        qDebug() << "close() already in progress for" << m_id;
+        return;
+    }
+
+    m_isClosing = true;
+
+    qDebug() << "Connection::close() for" << m_id;
+
+    shutdownThreadSafely(2000);           // normal graceful timeout
+
+
+    m_threadStarted = false;
+    m_isClosing = false;
+    emit disconnected();
+
+    qDebug() << "close() completed for" << m_id;
+}
+
+void Connection::shutdownThreadSafely(int timeoutMs)
+{
+    if (!m_thread || !m_threadStarted) {
+        qDebug() << "shutdownThreadSafely: no active thread for" << m_id;
+        return;
+    }
+
+    qDebug() << "shutdownThreadSafely: requesting thread stop for" << m_id
+             << "(timeout:" << timeoutMs << "ms)";
+
+    m_thread->closeConnection();          // sets closeRequest + interruption
+    m_thread->requestInterruption();
+
+    bool exitedCleanly = m_thread->wait(timeoutMs);
+
+    if (!exitedCleanly) {
+        qWarning() << "shutdownThreadSafely: thread did not exit within" << timeoutMs << "ms";
+        m_thread->forceShutdown();        // abort socket to unblock waits
+
+        // One last short chance
+        if (!m_thread->wait(1000)) {
+            qWarning() << "shutdownThreadSafely: force failed — terminating thread";
+            m_thread->terminate();        // absolute last resort
+        }
+    }
+
+    qDebug() << "shutdownThreadSafely: completed for" << m_id
+             << "(exited cleanly:" << exitedCleanly << ")";
+}
+
+QString Connection::id() const
+{
+    return m_id;
+}
+
+// public API
+void Connection::send(const Packet &packet)
+{
+    if (m_thread) {
+        m_thread->sendPersistant(packet);
+    }
+}
+
+void Connection::start()
+{
+    if (!m_thread) {
+        qWarning() << "No thread to start";
+        return;
+    }
+
+    if (m_thread->isRunning()) {
+        qDebug() << "Thread already running for" << m_id;
+        qDebug() << "setting m_threadStarted to true inside if is running";
+        m_threadStarted = true;
+        return;
+    }
+
+    if (!m_thread->isValid()) {
+        qWarning() << "Cannot start - thread invalid for" << m_id;
+        // Optional: log why (you already have good logging in isValid())
+        emit errorOccurred("Cannot start connection - initialization failed");
+        return;
+    }
+
+    qDebug() << "Starting TCPThread for connection" << m_id;
+    m_thread->start();
+    m_threadStarted = true;  // only set if start() was called successfully
+}
+
+// simple state queries
+bool Connection::isConnected() const
+{
+    // TODO: you may want to track state internally or ask thread
+    return m_thread && m_thread->isRunning();
+}
+
+bool Connection::isSecure() const
+{
+    return m_thread ? m_thread->isSecure : false;
+}
+
+// NEW: internal forwarders
+void Connection::onThreadPacketReceived(const Packet &p)
+{
+    emit dataReceived(p);
+}
+
+void Connection::onThreadConnectStatus(const QString &msg)
+{
+    emit stateChanged(msg);
+}
+
+void Connection::onThreadError(QSslSocket::SocketError error)
+{
+    QString errStr = QString("Socket error: %1").arg(error);
+    emit errorOccurred(errStr);
+    emit disconnected();
+}

src/connection.h

@@ -0,0 +1,105 @@
+//
+// Created by Tomas Gallucci on 3/5/26.
+//
+
+#ifndef CONNECTION_H
+#define CONNECTION_H
+
+
+#pragma once
+
+#include <QObject>
+#include <QString>
+#include <QUuid>
+#include <QSslSocket>
+
+#include <memory>  // for std::unique_ptr
+
+#include "packet.h"
+#include "tcpthread.h"
+
+// forward declarations
+class Packet;
+
+/**
+ * @brief RAII-style wrapper for a persistent connection.
+ *        Initially minimal; will later own a TCPThread or similar.
+ */
+class Connection : public QObject
+{
+    Q_OBJECT
+
+public:
+    // target constructor
+    explicit Connection(std::unique_ptr<TCPThread> thread,
+                        bool isIncoming = false,
+                        bool isSecure = false,
+                        bool isPersistent = true,
+                        qintptr socketDescriptor = -1,
+                        QObject *parent = nullptr);
+    explicit Connection(const QString &host,
+                        quint16 port,
+                        const Packet &initialPacket = Packet(),
+                        QObject *parent = nullptr,
+                        std::unique_ptr<TCPThread> thread = nullptr);
+    // Server/incoming constructor
+    explicit Connection(int socketDescriptor,
+                        bool isSecure = false,
+                        bool isPersistent = true,
+                        QObject *parent = nullptr,
+                        std::unique_ptr<TCPThread> thread = nullptr);
+    ~Connection() override;
+
+    [[nodiscard]] QString id() const;
+    [[nodiscard]] bool isConnected() const;
+    [[nodiscard]] bool isSecure() const;
+    [[nodiscard]] bool isIncoming() const { return m_isIncoming; }
+    [[nodiscard]] bool isPersistent() const { return m_isPersistent; }  // rename if you prefer isPersistentConnection()
+    [[nodiscard]] qintptr socketDescriptor() const { return m_socketDescriptor; }
+
+    void send(const Packet &packet);
+    void start();
+    void close();
+
+signals:
+    // NEW: forward important signals from TCPThread
+    void dataReceived(const Packet &packet);
+    void stateChanged(const QString &stateMessage);  // or use enum later
+    void errorOccurred(const QString &errorString);
+    void disconnected();
+
+private slots:
+    void onThreadPacketReceived(const Packet &p);
+    void onThreadConnectStatus(const QString &msg);
+    void onThreadError(QSslSocket::SocketError error);
+
+private:
+    void setupThreadConnections();
+    void shutdownThreadSafely(int timeoutMs = 2000);
+    bool m_isClosing = false;
+
+
+
+    QString m_id;
+    // QString m_host;       // uncomment later if needed for reconnect
+    // quint16 m_port = 0;
+    std::unique_ptr<TCPThread> m_thread;  // RAII ownership of the thread
+    bool m_threadStarted = false;
+    bool m_isIncoming = false;
+    bool m_isSecure = false;
+    bool m_isPersistent = false;
+    qintptr m_socketDescriptor = -1;
+
+    static constexpr int threadShutdownWaitMs = 10000;
+
+protected:
+    [[nodiscard]] TCPThread* getThread() const { return m_thread.get(); }
+    [[nodiscard]] bool getThreadStarted() const { return m_threadStarted; }
+
+    int m_threadWaitTimeoutMs = 10000;
+
+    void assignUniqueId() {m_id = QUuid::createUuid().toString(QUuid::WithoutBraces);}
+};
+
+
+#endif //CONNECTION_H