Enhancements to the pub sub client reconnect unsubscribe publish with time out

.vscode/settings.json

@@ -0,0 +1,73 @@
+{
+    "files.associations": {
+        "array": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "*.tcc": "cpp",
+        "cctype": "cpp",
+        "chrono": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "compare": "cpp",
+        "concepts": "cpp",
+        "condition_variable": "cpp",
+        "csignal": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "list": "cpp",
+        "map": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "functional": "cpp",
+        "initializer_list": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "memory": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "numbers": "cpp",
+        "ostream": "cpp",
+        "ratio": "cpp",
+        "semaphore": "cpp",
+        "stdexcept": "cpp",
+        "stop_token": "cpp",
+        "streambuf": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "thread": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "typeinfo": "cpp",
+        "utility": "cpp",
+        "any": "cpp",
+        "codecvt": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "forward_list": "cpp",
+        "set": "cpp",
+        "unordered_set": "cpp",
+        "algorithm": "cpp",
+        "iterator": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "random": "cpp",
+        "fstream": "cpp",
+        "iomanip": "cpp",
+        "shared_mutex": "cpp",
+        "sstream": "cpp",
+        "cinttypes": "cpp",
+        "variant": "cpp",
+        "future": "cpp"
+    }
+}

sdk/include/sdk/AsyncResult.h

@@ -59,6 +59,15 @@ struct VoidResult {};
 
 enum class CallState { ONGOING, CANCELING, COMPLETED, FAILED };
 
+/**
+ * @brief Status of a publish operation
+ */
+enum PublishStatus {
+    Success, // Message was published successfully
+    Timeout, // Publish operation timed out
+    Failure  // Publish operation failed (e.g., exception thrown)
+};
+
 /**
  * @brief Single result of an asynchronous operation which provides
  *        an item of type TResultType.

sdk/include/sdk/IPubSubClient.h

@@ -56,8 +56,8 @@ class IPubSubClient {
      *
      * @param brokerUri address of the MQTT broker to connect to
      * @param clientId used to identify the client at the MQTT broker
-     * @param username username to get access to the MQTT broker
-     * @param password password to get access to the MQTT broker
+     * @param username to get access to the MQTT broker
+     * @param password to get access to the MQTT broker
      * @return std::shared_ptr<IPubSubClient> reference to the created MQTT client
      */
     static std::shared_ptr<IPubSubClient> createInstance(const std::string& brokerUri,
@@ -104,6 +104,13 @@ class IPubSubClient {
      */
     virtual void connect() = 0;
 
+    /**
+     * @brief Reconnect the client to the broker.
+     * @param timeout_ms maximum time to wait for the reconnection attempt to complete, in
+     * milliseconds.
+     */
+    virtual void reconnect(int timeout_ms) = 0;
+
     /**
      * @brief Disconnect the client from the broker.
      *
@@ -126,6 +133,20 @@ class IPubSubClient {
      */
     virtual void publishOnTopic(const std::string& topic, const std::string& data) = 0;
 
+    /**
+     * @brief Publishes a message to the specified MQTT topic with a timeout in milliseconds for the
+     * publish to complete. Returns a status indicating whether the publish was successful, timed
+     * out, or failed.
+     *
+     * @param topic the MQTT topic to publish the message to
+     * @param data the payload to send as the message
+     * @param timeout_ms maximum time to wait for the publish to complete, in milliseconds
+     * @return PublishStatus indicating the result of the publish operation: Success, Timeout,
+     * Failure
+     */
+    virtual PublishStatus publishOnTopic(const std::string& topic, const std::string& data,
+                                         int timeout_ms) = 0;
+
     /**
      * @brief Subscribe to a topic.
      *
@@ -134,6 +155,13 @@ class IPubSubClient {
      */
     virtual AsyncSubscriptionPtr_t<std::string> subscribeTopic(const std::string& topic) = 0;
 
+    /**
+     * @brief Unsubscribe from a topic.
+     *
+     * @param topic   The topic to unsubscribe from.
+     */
+    virtual void unsubscribeTopic(const std::string& topic) = 0;
+
     IPubSubClient(const IPubSubClient&)            = delete;
     IPubSubClient(IPubSubClient&&)                 = delete;
     IPubSubClient& operator=(const IPubSubClient&) = delete;

sdk/include/sdk/VehicleApp.h

@@ -88,6 +88,13 @@ class VehicleApp {
      */
     AsyncSubscriptionPtr_t<std::string> subscribeToTopic(const std::string& topic);
 
+    /**
+     * @brief Unsubscribe from a topic.
+     *
+     * @param topic   The topic to unsubscribe from.
+     */
+    void unsubscribeTopic(const std::string& topic);
+
     /**
      * @brief Publish a PubSub message to the given topic.
      *
@@ -96,6 +103,32 @@ class VehicleApp {
      */
     void publishToTopic(const std::string& topic, const std::string& data);
 
+    /**
+     * @brief Publishes a message to the specified MQTT topic with a timeout (in
+     * milliseconds) for the operation to complete. Returns a status indicating
+     * whether the publish was successful, timed out, or failed.
+     *
+     * @param topic the MQTT topic to publish the message to
+     * @param data the payload to send as the message
+     * @param timeout_ms maximum time (in milliseconds) to wait for the publish to
+     * complete. Values ≤ 0 are treated as an instant timeout. Timeout value is
+     * capped at a maximum of 30000 ms.
+     * @return PublishStatus indicating the result of the publish operation:
+     * Success, Timeout, or Failure
+     */
+    virtual PublishStatus publishOnTopic(const std::string& topic, const std::string& data,
+                                         int timeout_ms);
+
+    /**
+     * @brief Attempts to reconnect to the MQTT broker within a specified timeout
+     * period.
+     *
+     * @param timeout_ms The maximum time to wait for reconnection, in
+     * milliseconds. Values ≤ 0 are treated as an error. Timeout value
+     * is capped at a maximum of 30000 ms.
+     */
+    virtual void reconnect(int timeout_ms);
+
     /**
      * @brief Get values for all provided data points from the data broker.
      *

sdk/src/sdk/VehicleApp.cpp

@@ -82,6 +82,10 @@ AsyncSubscriptionPtr_t<std::string> VehicleApp::subscribeToTopic(const std::stri
     return {};
 }
 
+void VehicleApp::unsubscribeTopic(const std::string& topic) {
+    return m_pubSubClient->unsubscribeTopic(topic);
+}
+
 AsyncResultPtr_t<DataPointReply>
 VehicleApp::getDataPoints(const std::vector<std::reference_wrapper<DataPoint>>& dataPoints) {
     std::vector<std::string> dataPointPaths;
@@ -113,6 +117,13 @@ void VehicleApp::publishToTopic(const std::string& topic, const std::string& dat
     }
 }
 
+PublishStatus VehicleApp::publishOnTopic(const std::string& topic, const std::string& data,
+                                         int timeout_ms) {
+    return m_pubSubClient->publishOnTopic(topic, data, timeout_ms);
+}
+
+void VehicleApp::reconnect(int timeout_ms) { m_pubSubClient->reconnect(timeout_ms); }
+
 std::shared_ptr<IVehicleDataBrokerClient> VehicleApp::getVehicleDataBrokerClient() {
     return m_vdbClient;
 }

sdk/src/sdk/pubsub/MqttPubSubClient.cpp

@@ -22,6 +22,7 @@
 #include "sdk/middleware/Middleware.h"
 
 #include <mqtt/async_client.h>
+#include <future>
 #include <mqtt/connect_options.h>
 #include <unordered_map>
 
@@ -60,14 +61,13 @@ class MqttPubSubClient : public IPubSubClient, private mqtt::callback {
                      const std::string& privateKeyPath)
         : m_client{brokerUri, clientId} {
         m_client.set_callback(*this);
-        auto sslopts = mqtt::ssl_options_builder()
-                           .trust_store(trustStorePath)
-                           .key_store(keyStorePath)
-                           .private_key(privateKeyPath)
-                           .error_handler([](const std::string& msg) {
-                               logger().error("SSL Error: {}", msg);
-                           })
-                           .finalize();
+        auto sslopts =
+            mqtt::ssl_options_builder()
+                .trust_store(trustStorePath)
+                .key_store(keyStorePath)
+                .private_key(privateKeyPath)
+                .error_handler([](const std::string& msg) { logger().error("SSL Error: {}", msg); })
+                .finalize();
         m_connectOptions = mqtt::connect_options_builder().ssl(std::move(sslopts)).finalize();
     }
 
@@ -85,6 +85,34 @@ class MqttPubSubClient : public IPubSubClient, private mqtt::callback {
 
         m_client.connect(m_connectOptions)->wait();
     }
+
+    void reconnect(int timeout_ms) override {
+        constexpr int MAX_TIMEOUT_MS = 30000;
+        logger().info("Attempting to reconnect to MQTT broker");
+        if (timeout_ms <= 0) {
+            logger().error("Invalid timeout value: {} ms. Must be positive.",
+                           timeout_ms);
+            return;
+          }
+
+        if (timeout_ms > MAX_TIMEOUT_MS) {
+          logger().warn("Timeout capped to {} ms (requested: {} ms)",
+                        MAX_TIMEOUT_MS, timeout_ms);
+          timeout_ms = MAX_TIMEOUT_MS;
+        }
+
+        try {
+            auto token = m_client.reconnect();
+            if (!token->wait_for(std::chrono::milliseconds(timeout_ms))) {
+                logger().error("MQTT reconnect timed out after {} ms", timeout_ms);
+            } else {
+                logger().info("Successfully reconnected to MQTT broker.");
+            }
+        } catch (const mqtt::exception& ex) {
+            logger().error("MQTT reconnect failed: {}", ex.what());
+        }
+    }
+
     void               disconnect() override { m_client.disconnect()->wait(); }
     [[nodiscard]] bool isConnected() const override { return m_client.is_connected(); }
 
@@ -93,6 +121,48 @@ class MqttPubSubClient : public IPubSubClient, private mqtt::callback {
         m_client.publish(topic, data)->wait();
     }
 
+    PublishStatus publishOnTopic(const std::string& topic, const std::string& data,
+                                 int timeout_ms) override {
+        constexpr int MAX_TIMEOUT_MS = 30000;
+         // Validate timeout range
+        if (timeout_ms <= 0) {
+          logger().warn("Invalid timeout value ({} ms); must be > 0", timeout_ms);
+          return PublishStatus::Timeout;
+        }
+
+        if (timeout_ms > MAX_TIMEOUT_MS) {
+          logger().warn("Timeout capped to {} ms (requested: {} ms)",
+                        MAX_TIMEOUT_MS, timeout_ms);
+          timeout_ms = MAX_TIMEOUT_MS;
+        }
+        try {
+            logger().debug(R"(Publish on topic "{}": "{}")", topic, data);
+
+            auto future = std::async(std::launch::async, [this, &topic, &data]() {
+                auto tok = m_client.publish(topic, data);
+                if (!tok) {
+                    throw mqtt::exception(MQTTASYNC_FAILURE);
+                }
+                tok->wait();
+                return PublishStatus::Success;
+            });
+
+            if (future.wait_for(std::chrono::milliseconds(timeout_ms)) ==
+                std::future_status::ready) {
+                return future.get(); // Success
+            } else {
+                logger().warn("Publish timed out after {} ms", timeout_ms);
+                return PublishStatus::Timeout;
+            }
+        } catch (const mqtt::exception& ex) {
+            logger().error("MQTT publish failed: {}", ex.what());
+            return PublishStatus::Failure;
+        } catch (const std::exception& ex) {
+            logger().error("Unexpected exception during publish: {}", ex.what());
+            return PublishStatus::Failure;
+        }
+    }
+
     AsyncSubscriptionPtr_t<std::string> subscribeTopic(const std::string& topic) override {
         logger().debug("Subscribing to {}", topic);
         auto subscription = std::make_shared<AsyncSubscription<std::string>>();
@@ -101,6 +171,13 @@ class MqttPubSubClient : public IPubSubClient, private mqtt::callback {
         return subscription;
     }
 
+    void unsubscribeTopic(const std::string& topic) override {
+        logger().debug("Unsubscribing from {}", topic);
+        m_client.unsubscribe(topic)->wait();
+        auto range = m_subscriberMap.equal_range(topic);
+        m_subscriberMap.erase(range.first, range.second);
+    }
+
 private:
     void message_arrived(mqtt::const_message_ptr msg) override {
         const std::string& topic   = msg->get_topic();

sdk/tests/mocks/MockIPubSubClient.h

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) 2022-2025 Contributors to the Eclipse Foundation
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License, Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef MOCK_IPUBSUBCLIENT_H
+#define MOCK_IPUBSUBCLIENT_H
+
+#include "sdk/IPubSubClient.h"
+#include <gmock/gmock.h>
+
+namespace velocitas {
+
+class MockIPubSubClient : public IPubSubClient {
+public:
+    MOCK_METHOD(void, connect, (), (override));
+    MOCK_METHOD(void, disconnect, (), (override));
+    MOCK_METHOD(void, reconnect, (int timeout_ms), (override));
+    MOCK_METHOD(bool, isConnected, (), (const, override));
+
+    MOCK_METHOD(void, publishOnTopic, (const std::string& topic, const std::string& data),
+                (override));
+
+    MOCK_METHOD(PublishStatus, publishOnTopic,
+                (const std::string& topic, const std::string& data, int timeout_ms), (override));
+
+    MOCK_METHOD(AsyncSubscriptionPtr_t<std::string>, subscribeTopic, (const std::string& topic),
+                (override));
+
+    MOCK_METHOD(void, unsubscribeTopic, (const std::string& topic), (override));
+};
+
+} // namespace velocitas
+
+#endif // MOCK_IPUBSUBCLIENT_H