feat: returning optional on mq error, handling signals on IC

SEAME-pt · Feb 5, 2025 · b3aaccc · b3aaccc
1 parent 6292bbf
commit b3aaccc
Show file tree

Hide file tree

Showing 9 changed files with 33 additions and 34 deletions.
diff --git a/instrument-cluster/main.cpp b/instrument-cluster/main.cpp
@@ -1,8 +1,14 @@
 #include <QtGui/QGuiApplication>
 #include <QtQml/QQmlApplicationEngine>
+#include <csignal>
 
 #include "src/DataManager.hpp"
 
+void sigHandler(int s) {
+    std::signal(s, SIG_DFL);
+    qApp->quit();
+}
+
 auto main(int argc, char *argv[]) -> int {
     QGuiApplication app(argc, argv);
 
@@ -22,5 +28,10 @@ auto main(int argc, char *argv[]) -> int {
     // Registering C++ objects as QML types
     qmlRegisterType<DataManager>("DataManager", 1, 0, "DataManager");
     engine.load(QUrl(QStringLiteral("qrc:/instrument-cluster/Main.qml")));
+
+    std::signal(SIGINT, sigHandler);
+    std::signal(SIGTERM, sigHandler);
+    std::signal(SIGSEGV, sigHandler);
+    std::signal(SIGABRT, sigHandler);
     return QGuiApplication::exec();
 }
diff --git a/instrument-cluster/mq/ZMQSubscriber.cpp b/instrument-cluster/mq/ZMQSubscriber.cpp
@@ -21,25 +21,10 @@ ZmqSubscriber::~ZmqSubscriber() {
     qDebug() << "ZmqSubscriber::finished";
 }
 
-int interrupted{0};
-
-void signalHandler(int _) {
-    (void)_;  // ignore unused variable
-    interrupted = 1;
-}
-
-void catchSignals() {
-    std::signal(SIGINT, signalHandler);
-    std::signal(SIGTERM, signalHandler);
-    std::signal(SIGSEGV, signalHandler);
-    std::signal(SIGABRT, signalHandler);
-}
-
 void ZmqSubscriber::checkForMessages() {
     qDebug() << "ZmqSubscriber::checkForMessages";
-    std::vector<uint8_t> message;
+    std::optional<std::vector<uint8_t>> message;
 
-    catchSignals();
     while (true) {
         try {
             message = subscriber->receive();
@@ -48,15 +33,10 @@ void ZmqSubscriber::checkForMessages() {
             break;
         }
 
-        if (interrupted) {
-            qDebug() << "interrupt received, killing program...";
-            break;
-        }
-
-        if (message.empty()) {
+        if (!message.has_value()) {
             continue;
         }
-        decodeMessage(message);
+        decodeMessage(message.value());
     }
     qDebug() << "stopped receiving messages";
 }

diff --git a/mq/src/IMQSocket.hpp b/mq/src/IMQSocket.hpp
@@ -2,6 +2,7 @@
 #define MQ_SOCKET_HPP
 
 #include <cstdint>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -23,7 +24,7 @@ class IMQSocket {
     virtual auto connect(const std::string& endpoint) -> bool = 0;
     virtual auto bind(const std::string& endpoint) -> bool = 0;
     virtual auto send(const std::vector<uint8_t>& data) -> bool = 0;
-    virtual auto receive() -> std::vector<uint8_t> = 0;
+    virtual auto receive() -> std::optional<std::vector<uint8_t>> = 0;
     virtual void close() = 0;
 };
 }  // namespace MQ

diff --git a/mq/src/ZeroMQSocket.cpp b/mq/src/ZeroMQSocket.cpp
@@ -41,7 +41,7 @@ auto ZeroMQSocket::send(const std::vector<uint8_t>& data) -> bool {
     return false;
 }
 
-auto ZeroMQSocket::receive() -> std::vector<uint8_t> {
+auto ZeroMQSocket::receive() -> std::optional<std::vector<uint8_t>> {
     zmq::message_t msg;
     if (!m_socket.recv(msg, zmq::recv_flags::none)) {
         return {};

diff --git a/mq/src/ZeroMQSocket.hpp b/mq/src/ZeroMQSocket.hpp
@@ -1,3 +1,6 @@
+#ifndef ZERO_MQ_SOCKET_HPP
+#define ZERO_MQ_SOCKET_HPP
+
 #include "IMQSocket.hpp"
 #include "zmq.hpp"
 
@@ -14,7 +17,9 @@ class ZeroMQSocket : public IMQSocket {
     auto connect(const std::string& endpoint) -> bool override;
     auto bind(const std::string& endpoint) -> bool override;
     auto send(const std::vector<uint8_t>& data) -> bool override;
-    auto receive() -> std::vector<uint8_t> override;
+    auto receive() -> std::optional<std::vector<uint8_t>> override;
     void close() override;
 };
 }  // namespace MQ
+
+#endif
diff --git a/mq/src/ZeroMQWorker.cpp b/mq/src/ZeroMQWorker.cpp
@@ -19,5 +19,5 @@ auto ZeroMQWorker::publish(const std::vector<uint8_t>& data) -> bool {
     return m_socket->send(data);
 }
 
-auto ZeroMQWorker::receive() -> std::vector<uint8_t> { return m_socket->receive(); }
+auto ZeroMQWorker::receive() -> std::optional<std::vector<uint8_t>> { return m_socket->receive(); }
 }  // namespace MQ
diff --git a/mq/src/ZeroMQWorker.hpp b/mq/src/ZeroMQWorker.hpp
@@ -24,7 +24,7 @@ class ZeroMQWorker {
     ZeroMQWorker(const ZeroMQWorker&) = delete;
     auto operator=(const ZeroMQWorker&) -> ZeroMQWorker& = delete;
     void subscribe(const std::string& topic);
-    auto receive() -> std::vector<uint8_t>;
+    auto receive() -> std::optional<std::vector<uint8_t>>;
     auto publish(const std::vector<uint8_t>& data) -> bool;
 
    private:

diff --git a/mq/test/ZeroMQSocketTest.cpp b/mq/test/ZeroMQSocketTest.cpp
@@ -17,8 +17,10 @@ TEST(ZeroMQSocketTest, SendAndReceive) {
     std::vector<uint8_t> data{1, 2, 3};
     ASSERT_TRUE(sender.send(data));
 
-    std::vector<uint8_t> received_message = receiver.receive();
-    ASSERT_EQ(data, received_message);
+    std::optional<std::vector<uint8_t>> received_message = receiver.receive();
+    ASSERT_TRUE(received_message.has_value());
+
+    ASSERT_EQ(data, received_message.value());
 
     sender.close();
     receiver.close();

diff --git a/mq/test/ZeroMQWorkerTest.cpp b/mq/test/ZeroMQWorkerTest.cpp
@@ -15,7 +15,7 @@ class MockMQSocket : public MQ::IMQSocket {  // Create a Mock Class
     // NOLINTNEXTLINE(modernize-use-trailing-return-type)
     MOCK_METHOD(bool, send, (const std::vector<uint8_t> &), (override));
     // NOLINTNEXTLINE(modernize-use-trailing-return-type)
-    MOCK_METHOD(std::vector<uint8_t>, receive, (), (override));
+    MOCK_METHOD(std::optional<std::vector<uint8_t>>, receive, (), (override));
     MOCK_METHOD(void, close, (), (override));
 };
 
@@ -37,10 +37,9 @@ TEST(ZeroMQTest, PublisherSendTestSuccessReturnsTrue) { testSendPublisher(true);
 
 TEST(ZeroMQTest, PublisherSendTestFailReturnFalse) { testSendPublisher(false); }
 
-void testSendSubscriber(std::vector<uint8_t> result) {
+void testSendSubscriber(std::optional<std::vector<uint8_t>> result) {
     auto mock = std::make_unique<MockMQSocket>();
 
-    std::vector<uint8_t> expected_result{1, 2, 3};
     // mocking methods
     EXPECT_CALL(*mock, bind(testing::_)).Times(1).WillOnce(Return(true));
     EXPECT_CALL(*mock, close()).Times(1);
@@ -52,7 +51,8 @@ void testSendSubscriber(std::vector<uint8_t> result) {
 }
 
 TEST(ZeroMQTest, SubscriberReceiveTestSuccessReturnsVector) {
-    std::vector<uint8_t> expected_result{1, 2, 3};
+    std::optional<std::vector<uint8_t>> expected_result =
+        std::make_optional<std::vector<uint8_t>>({1, 2, 3});
     testSendSubscriber(expected_result);
 }