stinger-ipc 0.0.10__py3-none-any.whl → 0.0.25__py3-none-any.whl

stingeripc/templates/cpp/include/client.hpp.jinja2

@@ -4,7 +4,7 @@ on the next generation.
 
 It contains enumerations used by the {{stinger.name}} interface.
 */
-
+{% import 'partials/args.jinja2' as ar %}
 
 #pragma once
 
@@ -16,10 +16,13 @@ It contains enumerations used by the {{stinger.name}} interface.
 #include <mutex>
 #include <rapidjson/document.h>
 #include <boost/uuid/uuid.hpp>
-
+#include <boost/optional.hpp>
 #include "ibrokerconnection.hpp"
 #include "{{stinger.cpp.enum_header_file}}"
 #include "return_types.hpp"
+
+{%macro prop_value_type(prop) -%}{%if prop.arg_list|length > 1%}struct {%endif%}{{prop.name | UpperCamelCase}}Property{%endmacro%}
+
 {%if stinger.properties | length > 0 %}#include "{{stinger.cpp.property_struct_header_file}}"{%endif%}
 
 class {{stinger.cpp.client_class_name}} {
@@ -34,28 +37,94 @@ public:
     {{stinger.cpp.client_class_name}}(std::shared_ptr<IBrokerConnection> broker);
 
     virtual ~{{stinger.cpp.client_class_name}}() = default;
-
+    {%if stinger.signals|length > 0 -%}
+    // ------------------ SIGNALS --------------------
     {%for sig_name, sig in stinger.signals.items()%}
     // Register a callback for the `{{sig_name}}` signal.
     // The provided method will be called whenever a `{{sig_name}}` is received.
     void register{{sig_name | UpperCamelCase}}Callback(const std::function<void({%for arg in sig.arg_list%}{{arg.cpp_type}}{%if not loop.last%}, {%endif%}{%endfor%})>& cb);
     {%endfor%}
-
+    {%endif%}
+    {%if stinger.methods|length > 0 -%}
+    // ------------------- METHODS --------------------
     {%for method_name, method in stinger.methods.items()%}
     // Calls the `{{method_name}}` method.
     // Returns a future.  When that future resolves, it will have the returned value.
     boost::future<{{method.return_value_cpp_class}}> {{method_name | camelCase}}({%for arg in method.arg_list%}{{arg.cpp_type}} {{arg.name}}{%if not loop.last%}, {%endif%}{%endfor%});
     {%endfor%}
-private: 
+    {%endif%}
+    {%if stinger.properties|length > 0 -%}
+    // ---------------- PROPERTIES ------------------
+    {%for prop_name, prop in stinger.properties.items()%}
+    // ---{{prop_name}} Property---
+
+    // Gets the latest value of the `{{prop_name}}` property, if one has been received.
+    // If no value has been received yet, an empty optional is returned.
+    boost::optional<{{prop_value_type(prop)}}> get{{prop_name | UpperCamelCase}}Property() const;
+
+    // Add a callback that will be called whenever the `{{prop_name}}` property is updated.
+    // The provided method will be called whenever a new value for the `{{prop_name}}` property is received.
+    void register{{prop_name | UpperCamelCase}}PropertyCallback(const std::function<void({{ar.declarationParams(prop.arg_list)}})>& cb);
+    {% if not prop.read_only %}
+    boost::future<bool> update{{prop_name | UpperCamelCase}}Property({{ar.declarationParams(prop.arg_list)}}) const;
+    {%endif%}
+    {%endfor%}
+    {%endif%}
+private:
+    // Pointer to the broker connection.
     std::shared_ptr<IBrokerConnection> _broker;
-    void _receiveMessage(const std::string& topic, const std::string& payload, const boost::optional<std::string> optCorrelationId, const boost::optional<MethodResultCode> optResultCode);
-    {%-for method_name, method in stinger.methods.items()%}
-    std::map<boost::uuids::uuid, boost::promise<{{method.return_value_cpp_class}}>> _pending{{method_name|UpperCamelCase}}MethodCalls;
-    {%-endfor%}
+
+    // Internal method for receiving messages from the broker.
+    void _receiveMessage(
+            const std::string& topic, 
+            const std::string& payload, 
+            const MqttProperties& mqttProps);
+    {%if stinger.signals|length > 0 %}
+    // ------------------ SIGNALS --------------------
     {%for sig_name, sig in stinger.signals.items()%}
-    std::function<void({%for arg in sig.arg_list%}{{arg.cpp_type}}{%if not loop.last%}, {%endif%}{%endfor%})> _{{sig_name | camelCase}}Callback;
+    // List of callbacks to be called whenever the `{{sig_name}}` signal is received.
+    std::vector<std::function<void({%for arg in sig.arg_list%}{{arg.cpp_type}}{%if not loop.last%}, {%endif%}{%endfor%})>> _{{sig_name | lowerCamelCase}}SignalCallbacks;
+    std::mutex _{{sig_name | lowerCamelCase}}SignalCallbacksMutex;
+
+    // MQTT Subscription ID for `{{sig_name}}` signal receptions.
+    int _{{sig_name | lowerCamelCase}}SignalSubscriptionId;
     {%endfor%}
+    {%endif%}
+    {%if stinger.methods|length > 0 -%}
+    // ------------------- METHODS --------------------
+
     {%-for method_name, method in stinger.methods.items()%}
-    void _handle{{method_name|UpperCamelCase}}Response(const std::string& topic, const std::string& payload, const std::string& optCorrelationId);
+    // Holds promises for pending `{{method_name}}` method calls.
+    std::map<boost::uuids::uuid, boost::promise<{{method.return_value_cpp_class}}>> _pending{{method_name|UpperCamelCase}}MethodCalls;
+
+    // This is called internally to process responses to `{{method_name}}` method calls.
+    void _handle{{method_name|UpperCamelCase}}Response(const std::string& topic, const std::string& payload, const std::string& correlationId);
     {%-endfor%}
+    {%endif%}
+    {%if stinger.properties|length > 0 -%}
+    // ---------------- PROPERTIES ------------------
+    {%for prop_name, prop in stinger.properties.items()%}
+
+    // ---{{prop_name}} Property---
+
+    // Last received value{%if prop.arg_list|length > 1%}s{%endif%} for the `{{prop_name}}` property.
+    boost::optional<{{prop_value_type(prop)}}> _{{prop_name | lowerCamelCase}}Property;
+
+    // This is the property version of the last received `{{prop_name}}` property update.
+    int _last{{prop_name | UpperCamelCase}}PropertyVersion = -1;
+
+    // Mutex for protecting access to the `{{prop_name}}` property and its version.
+    mutable std::mutex _{{prop_name | lowerCamelCase}}PropertyMutex;
+   
+    // MQTT Subscription ID for `{{prop_name}}` property updates.
+    int _{{prop_name | lowerCamelCase}}PropertySubscriptionId;
+
+    // Method for parsing a JSON payload that updates the `{{prop_name}}` property.
+    void _receive{{prop_name | UpperCamelCase}}PropertyUpdate(const std::string& topic, const std::string& payload, boost::optional<int> optPropertyVersion);
+
+    // Callbacks registered for changes to the `{{prop_name}}` property.
+    std::vector<std::function<void({{ar.declarationParams(prop.arg_list)}})>> _{{prop_name | lowerCamelCase}}PropertyCallbacks;
+    std::mutex _{{prop_name | lowerCamelCase}}PropertyCallbacksMutex;
+    {%endfor%}
+    {%endif%}
 };

stingeripc/templates/cpp/include/ibrokerconnection.hpp.jinja2

@@ -22,23 +22,43 @@ enum class MethodResultCode
     {%-endfor%}
 };
 
+struct MqttProperties
+{
+    MqttProperties()
+        : correlationId(boost::none),
+            responseTopic(boost::none),
+            resultCode(boost::none),
+            subscriptionId(boost::none),
+            propertyVersion(boost::none)
+    {}
+    boost::optional<std::string> correlationId;
+    boost::optional<std::string> responseTopic;
+    boost::optional<MethodResultCode> resultCode;
+    boost::optional<int> subscriptionId;
+    boost::optional<int> propertyVersion;
+};
+
 class IBrokerConnection
 {
 public:
     /*! Publish to a topic.
      * Implementations should queue up messages when not connected.
      */
-    virtual boost::future<bool> Publish(const std::string& topic, const std::string& payload, unsigned qos, bool retain, boost::optional<std::string> optCorrelationId, boost::optional<std::string> optResponseTopic, boost::optional<MethodResultCode> optResultCode) = 0;
-    
+    virtual boost::future<bool> Publish(const std::string& topic, const std::string& payload, unsigned qos, bool retain, const MqttProperties& mqttProps) = 0;
+
     /*! Subscribe to a topic.
      * Implementation should queue up subscriptions when not connected.
      */
-    virtual void Subscribe(const std::string& topic, int qos) = 0;
+    virtual int Subscribe(const std::string& topic, int qos) = 0;
 
     /*! Provide a callback to be called on an incoming message.
      * Implementation should accept this at any time, even when not connected.
      */
-    virtual void AddMessageCallback(const std::function<void(const std::string&, const std::string&, const boost::optional<std::string>, const boost::optional<std::string>, const boost::optional<MethodResultCode>)>& cb) = 0;
+    virtual void AddMessageCallback(const std::function<void
+            (const std::string&, 
+            const std::string&, 
+            const MqttProperties&
+        )>& cb) = 0;
 
     /*! Utility for matching topics.
      * This probably should be a wrapper around `mosquitto_topic_matches_sub` or similar

stingeripc/templates/cpp/include/property_structs.hpp.jinja2

@@ -5,6 +5,44 @@ on the next generation.
 It contains enumerations used by the {{stinger.name}} interface.
 */
 
-{%for prop_name, prop in stinger.properties.items() %}
-// {{prop}}
+
+#pragma once
+#include <string>
+#include <rapidjson/document.h>
+#include "{{stinger.cpp.enum_header_file}}"
+#include "structs.hpp"
+
+{%for prop_name, prop in stinger.properties.items()%}
+{%- if prop.arg_list| length > 1 %}
+{%-if prop.documentation %}/**
+{{prop.documentation |commentblock(' * ')}}
+ */{%endif%}
+struct {{prop.name | UpperCamelCase}}Property {
+    static {{prop.name | UpperCamelCase}}Property FromRapidJsonObject(const rapidjson::Value& jsonObj);
+    rapidjson::Value ToRapidJsonObject(rapidjson::Document::AllocatorType& allocator) const;
+{%-for arg in prop.arg_list %}
+    {%if arg.arg_type.name.lower() == "struct"-%}
+    {{arg.cpp_type}} {{arg.name}};{%if arg.description %}  ///< {{arg.description}}{%endif%}
+    {%-else-%}
+    {{arg.cpp_temp_type}} {{arg.name }};{%if arg.description %}  ///< {{arg.description}}{%endif%}
+    {%-endif-%}
+{%endfor-%}
+{# end for arg #}
+};
+{%elif prop.arg_list| length == 1 %}
+{% set arg = prop.arg_list[0] %}
+{%if prop.documentation %}/**
+ * The `{{prop.name}}` property contains a single field:
+{%-if arg.arg_type.name.lower() == "struct"%}
+ *   {{arg.cpp_type}} {{arg.name}};{%if arg.description %}  ///< {{arg.description}}{%endif%}
+{%-else%}
+ *   {{arg.cpp_temp_type}} {{arg.name }};{%if arg.description %}  ///< {{arg.description}}{%endif%}
+{%-endif%}
+ *
+ * Because there is only one field, no outer-structure is needed. 
+ *
+{{prop.documentation |commentblock(' * ')}}
+ */{%endif%}
+typedef {%if arg.arg_type.name.lower() == "struct"%}{{arg.cpp_type}}{%else%}{{arg.cpp_temp_type}}{%endif%} {{prop.name | UpperCamelCase}}Property;
+{%endif%}
 {%endfor%}

stingeripc/templates/cpp/include/server.hpp.jinja2

@@ -41,7 +41,11 @@ public:
     {%endfor%}
 private: 
     std::shared_ptr<IBrokerConnection> _broker;
-    void _receiveMessage(const std::string& topic, const std::string& payload, const boost::optional<std::string> optCorrelationId, const boost::optional<std::string> optResponseTopic);
+    void _receiveMessage(
+            const std::string& topic, 
+            const std::string& payload, 
+            const MqttProperties& mqttProps
+    );
 
     {%for method_name, method in stinger.methods.items()%}
     void _call{{method_name | UpperCamelCase}}Handler(const std::string& topic, const rapidjson::Document& doc, boost::optional<std::string> clientId, boost::optional<std::string> correlationId) const;

stingeripc/templates/cpp/include/structs.hpp.jinja2

@@ -8,10 +8,12 @@ It contains enumerations used by the {{stinger.name}} interface.
 #pragma once
 #include <string>
 #include <boost/optional.hpp>
+#include <rapidjson/document.h>
 #include "{{stinger.cpp.enum_header_file}}"
 
 {%for istruct_name, istruct in stinger.structs.items() %}
 struct {{istruct_name | UpperCamelCase }} {
+    static {{istruct_name | UpperCamelCase }} FromRapidJsonObject(const rapidjson::Value& jsonObj);
     {%-for value in istruct.members %}
     {{value.cpp_temp_type}} {{value.name}};
     {%-endfor%}

stingeripc/templates/cpp/partials/args.jinja2

@@ -0,0 +1,11 @@
+{%macro methodParams(arglist)%}
+    {%- for arg in arglist -%}
+        {{ arg.cpp_type }} {{ arg.name }}{% if not loop.last %}, {% endif %}
+    {%- endfor -%}
+{%-endmacro%}
+
+{%macro declarationParams(arglist)%}
+    {%- for arg in arglist -%}
+        {{ arg.cpp_type }}{% if not loop.last %}, {% endif %}
+    {%- endfor -%}
+{%-endmacro%}

stingeripc/templates/cpp/partials/deserialize.jinja2

@@ -0,0 +1,42 @@
+{%macro deserialize_value(target, arg)%}
+{%-if arg.arg_type.name.lower() == 'primitive'%}
+{{target}} = itr->value.Get{{arg.cpp_rapidjson_type}}();
+{%-elif arg.arg_type.name.lower() == 'enum'%}
+{{target}} = static_cast<{{arg.cpp_data_type}}>(itr->value.Get{{arg.cpp_rapidjson_type}}());
+{%-elif arg.arg_type.name.lower() == 'struct'%}
+{{target}} = {{arg.cpp_type}}::FromRapidJsonObject(itr->value);
+{%endif%}
+{%endmacro%}
+
+
+{%-macro deserialize(target, arglist, json_obj)%}
+{%-if arglist|length == 1%}
+{%-set arg = arglist[0]%}
+rapidjson::Value::ConstMemberIterator itr = {{json_obj}}.FindMember("{{arg.name}}");
+if (itr != {{json_obj}}.MemberEnd() && itr->value.Is{{arg.cpp_rapidjson_type}}()) {
+    {{deserialize_value(target, arg)}}
+} else {
+{%-if arg.optional%}
+    {{target}} = boost::none;
+{%-else%}
+    throw std::runtime_error("Received payload doesn't have required value/type");
+{%-endif%}
+}
+{%-elif arglist|length > 1%}
+{%-for arg in arglist%}
+{%-set arg_target %}{{target}}.{{arg.name}}{%endset%}
+{ // Scoping
+    rapidjson::Value::ConstMemberIterator itr = {{json_obj}}.FindMember("{{arg.name}}");
+    if (itr != {{json_obj}}.MemberEnd() && itr->value.Is{{arg.cpp_rapidjson_type}}()) {
+        {{deserialize_value(arg_target, arg) | indent(8)}}
+    } else {
+    {%-if arg.optional%}
+        {{arg_target}} = boost::none;
+    {%-else%}
+        throw std::runtime_error("Received payload doesn't have required value/type");
+    {%endif%}
+    }
+}
+{%-endfor%}
+{%-endif%}
+{%-endmacro%}

stingeripc/templates/cpp/partials/serialize.jinja2

@@ -0,0 +1,18 @@
+
+
+{%-macro addToValue(value, arg, allocator)%}
+{%-if arg.arg_type.name.lower() == 'primitive'%}
+{%-if arg.optional %}if ({{arg.name}}) {%endif-%}
+{%-if arg.type.name.lower() == 'string'%}
+{ {%if not arg.optional %}// restrict scope{%endif%}
+    rapidjson::Value tempStringValue;
+    tempStringValue.SetString({{arg.name}}{%-if arg.optional %}->{%else%}.{%endif-%}c_str(), {{arg.name}}{%-if arg.optional %}->{%else%}.{%endif%}size(), {{allocator}});
+    {{value}}.AddMember("{{arg.name}}", tempStringValue, {{allocator}});
+}
+{%-else%}
+{{value}}.AddMember("{{arg.name}}", {%if arg.optional %}*{%endif-%}{{arg.name}}, {{allocator}});
+{%-endif%}
+{%elif arg.arg_type.name.lower() == 'enum'%}
+{{value}}.AddMember("{{arg.name}}", static_cast<int>({%if arg.optional %}*{%endif-%}{{arg.name}}), {{allocator}});
+{%-endif-%}
+{%endmacro%}

stingeripc/templates/cpp/src/broker.cpp.jinja2

@@ -32,8 +32,11 @@ MqttConnection::MqttConnection(const std::string& host, int port, const std::str
         while(!thisClient->_subscriptions.empty())
         {
             auto sub = thisClient->_subscriptions.front();
-            cout << "Subscribing to " << sub._topic << endl;
-            mosquitto_subscribe(mosq, NULL, sub._topic.c_str(), sub._qos);
+            cout << "Subscribing to " << sub.topic << endl;
+            mosquitto_property *propList = NULL;
+            mosquitto_property_add_int16(&propList, MQTT_PROP_SUBSCRIPTION_IDENTIFIER, sub.subscriptionId);
+            int rc = mosquitto_subscribe_v5(mosq, NULL, sub.topic.c_str(), sub.qos, 0, propList);
+            mosquitto_property_free_all(&propList);
             thisClient->_subscriptions.pop();
         }
         while(!thisClient->_msgQueue.empty())
@@ -42,6 +45,7 @@ MqttConnection::MqttConnection(const std::string& host, int port, const std::str
             cout << "Sending message to " << msg._topic << endl;
             int mid;
             mosquitto_property *propList = NULL;
+            mosquitto_property_add_string(&propList, MQTT_PROP_CONTENT_TYPE, "application/json");
             if (msg._optCorrelationId)
             {
                 mosquitto_property_add_string(&propList, MQTT_PROP_CORRELATION_DATA, msg._optCorrelationId->c_str());
@@ -63,9 +67,7 @@ MqttConnection::MqttConnection(const std::string& host, int port, const std::str
         cout << "Fowarding message (" << mmsg->topic << ") to " << thisClient->_messageCallbacks.size() << " callbacks" << endl;
         std::string topic(mmsg->topic);
         std::string payload(static_cast<char*>(mmsg->payload), mmsg->payloadlen);
-        boost::optional<std::string> optCorrelationId;
-        boost::optional<std::string> optResponseTopic;
-        boost::optional<MethodResultCode> optResultCode;
+        MqttProperties mqttProps;
         const mosquitto_property *prop;
         for (prop = props; prop != NULL; prop = mosquitto_property_next(prop))
         {
@@ -75,7 +77,8 @@ MqttConnection::MqttConnection(const std::string& host, int port, const std::str
                 uint16_t correlation_data_len;
                 if (mosquitto_property_read_binary(prop, MQTT_PROP_CORRELATION_DATA, &correlation_data, &correlation_data_len, false))
                 {
-                    optCorrelationId = std::string(static_cast<char*>(correlation_data), correlation_data_len);
+                    mqttProps.correlationId = std::string(static_cast<char*>(correlation_data), correlation_data_len);
+                    free(correlation_data);
                 }
             }
             else if (mosquitto_property_identifier(prop) == MQTT_PROP_RESPONSE_TOPIC)
@@ -83,7 +86,7 @@ MqttConnection::MqttConnection(const std::string& host, int port, const std::str
                 char *responseTopic = NULL;
                 if (mosquitto_property_read_string(prop, MQTT_PROP_RESPONSE_TOPIC, &responseTopic, false))
                 {
-                    optResponseTopic = std::string(responseTopic);
+                    mqttProps.responseTopic = std::string(responseTopic);
                     free(responseTopic);
                 }
             }
@@ -96,17 +99,30 @@ MqttConnection::MqttConnection(const std::string& host, int port, const std::str
                     if (strcmp(name, "ReturnValue") == 0)
                     {
                         int returnValueInt = boost::lexical_cast<int>(value);
-                        optResultCode = static_cast<MethodResultCode>(returnValueInt);
+                        mqttProps.resultCode = static_cast<MethodResultCode>(returnValueInt);
+                    }
+                    else if (strcmp(name, "PropertyVersion") == 0)
+                    {
+                        int propertyVersionInt = boost::lexical_cast<int>(value);
+                        mqttProps.propertyVersion = propertyVersionInt;
                     }
                     free(name);
                     free(value);
                 }
             }
+            else if (mosquitto_property_identifier(prop) == MQTT_PROP_SUBSCRIPTION_IDENTIFIER)
+            {
+                uint32_t subscriptionId;
+                if (mosquitto_property_read_int32(prop, MQTT_PROP_SUBSCRIPTION_IDENTIFIER, &subscriptionId, false))
+                {
+                    mqttProps.subscriptionId = static_cast<int>(subscriptionId);
+                }
+            }
         }
         for (auto& cb : thisClient->_messageCallbacks)
         {
             cout << "Calling callback" << endl;
-            cb(topic, payload, optCorrelationId, optResponseTopic, optResultCode);
+            cb(topic, payload, mqttProps);
         }
     });
 
@@ -146,24 +162,22 @@ boost::future<bool> MqttConnection::Publish(
         const std::string& payload, 
         unsigned qos, 
         bool retain, 
-        boost::optional<std::string> optCorrelationId, 
-        boost::optional<std::string> optResponseTopic,
-        boost::optional<MethodResultCode> optResultCode)
+        const MqttProperties& mqttProps)
 {
     int mid;
     mosquitto_property *propList = NULL;
     mosquitto_property_add_string(&propList, MQTT_PROP_CONTENT_TYPE, "application/json");
-    if (optCorrelationId)
+    if (mqttProps.correlationId)
     {
-        mosquitto_property_add_binary(&propList, MQTT_PROP_CORRELATION_DATA, (void*)optCorrelationId->c_str(), optCorrelationId->size());
+        mosquitto_property_add_binary(&propList, MQTT_PROP_CORRELATION_DATA, (void*)mqttProps.correlationId->c_str(), mqttProps.correlationId->size());
     }
-    if (optResponseTopic)
+    if (mqttProps.responseTopic)
     {
-        mosquitto_property_add_string(&propList, MQTT_PROP_RESPONSE_TOPIC, optResponseTopic->c_str());
+        mosquitto_property_add_string(&propList, MQTT_PROP_RESPONSE_TOPIC, mqttProps.responseTopic->c_str());
     }
-    if (optResultCode)
+    if (mqttProps.resultCode)
     {
-        std::string resultCodeStr = std::to_string(static_cast<int>(*optResultCode));
+        std::string resultCodeStr = std::to_string(static_cast<int>(*mqttProps.resultCode));
         mosquitto_property_add_string_pair(&propList, MQTT_PROP_USER_PROPERTY, "ReturnValue", resultCodeStr.c_str());
     }
     int rc = mosquitto_publish_v5(_mosq, &mid, topic.c_str(), payload.size(), payload.c_str(), qos, retain, propList);
@@ -171,7 +185,7 @@ boost::future<bool> MqttConnection::Publish(
     if (rc == MOSQ_ERR_NO_CONN)
     {
         std::cout << "Delayed published queued to: " << topic << std::endl;
-        MqttConnection::MqttMessage msg(topic, payload, qos, retain, optCorrelationId, optResponseTopic);
+        MqttConnection::MqttMessage msg(topic, payload, qos, retain, mqttProps.correlationId, mqttProps.responseTopic);
         auto future = msg.getFuture();
         boost::mutex::scoped_lock lock(_mutex);
         _msgQueue.push(std::move(msg));
@@ -193,13 +207,16 @@ boost::future<bool> MqttConnection::Publish(
     throw std::runtime_error("Unhandled rc");
 }
 
-void MqttConnection::Subscribe(const std::string& topic, int qos)
+int MqttConnection::Subscribe(const std::string& topic, int qos)
 {
-    std::cout << "Subscribing to " << topic << endl;
-    int rc = mosquitto_subscribe(_mosq, NULL, topic.c_str(), qos);
+    int subscriptionId = _nextSubscriptionId++;
+    mosquitto_property *propList = NULL;
+    mosquitto_property_add_int16(&propList, MQTT_PROP_SUBSCRIPTION_IDENTIFIER, subscriptionId);
+    int rc = mosquitto_subscribe_v5(_mosq, NULL, topic.c_str(), qos, 0, propList);
+    mosquitto_property_free_all(&propList);
     if (rc == MOSQ_ERR_NO_CONN)
     {
-        MqttConnection::MqttSubscription sub(topic, qos);
+        MqttConnection::MqttSubscription sub(topic, qos, subscriptionId);
         boost::mutex::scoped_lock lock(_mutex);
         _subscriptions.push(sub);
     }
@@ -207,10 +224,15 @@ void MqttConnection::Subscribe(const std::string& topic, int qos)
     {
         std::cout << "Subscribed to " << topic << std::endl;
     }
+    return subscriptionId;
 }
 
 void MqttConnection::AddMessageCallback(
-        const std::function<void(const std::string&, const std::string&, const boost::optional<std::string>, const boost::optional<std::string>, const boost::optional<MethodResultCode>)>& cb)
+        const std::function<void(
+                const std::string&, 
+                const std::string&, 
+                const MqttProperties&
+        )>& cb)
 {
     boost::mutex::scoped_lock lock(_mutex);
     _messageCallbacks.push_back(cb);