stinger-ipc 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

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

@@ -0,0 +1,243 @@
+
+#include <exception>
+#include <string>
+#include <functional>
+#include <boost/interprocess/sync/scoped_lock.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/format.hpp>
+#include <boost/algorithm/string.hpp>
+#include <mosquitto.h>
+#include <mqtt_protocol.h>
+#include <iostream>
+
+#include "broker.hpp"
+
+using namespace std;
+
+MqttConnection::MqttConnection(const std::string& host, int port, const std::string& clientId)
+    : _mosq(NULL), _host(host), _port(port), _clientId(clientId)
+{
+    boost::mutex::scoped_lock lock(_mutex);
+
+    if (mosquitto_lib_init() != MOSQ_ERR_SUCCESS) {
+        throw std::runtime_error("Mosquitto lib init problem");   
+    };
+    _mosq = mosquitto_new(_clientId.c_str(), false, (void*)this);
+
+    mosquitto_connect_callback_set(_mosq, [](struct mosquitto *mosq, void *user, int i)
+    {
+        MqttConnection *thisClient = static_cast<MqttConnection*>(user);
+        cout << "Connected to " << thisClient->_host << endl;
+        boost::mutex::scoped_lock lock(thisClient->_mutex);
+        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);
+            thisClient->_subscriptions.pop();
+        }
+        while(!thisClient->_msgQueue.empty())
+        {
+            MqttMessage& msg = thisClient->_msgQueue.front();
+            cout << "Sending message to " << msg._topic << endl;
+            int mid;
+            mosquitto_property *propList = NULL;
+            if (msg._optCorrelationId)
+            {
+                mosquitto_property_add_string(&propList, MQTT_PROP_CORRELATION_DATA, msg._optCorrelationId->c_str());
+            }
+            if (msg._optResponseTopic)
+            {
+                mosquitto_property_add_string(&propList, MQTT_PROP_RESPONSE_TOPIC, msg._optResponseTopic->c_str());
+            }
+            mosquitto_publish_v5(mosq, &mid, msg._topic.c_str(), msg._payload.size(), msg._payload.c_str(), msg._qos, msg._retain, propList);
+            mosquitto_property_free_all(&propList);
+            thisClient->_sendMessages[mid] = msg._pSentPromise;
+            thisClient->_msgQueue.pop();
+        }
+    });
+
+    mosquitto_message_v5_callback_set(_mosq, [](struct mosquitto *mosq, void *user, const struct mosquitto_message *mmsg, const mosquitto_property *props)
+    {
+        MqttConnection *thisClient = static_cast<MqttConnection*>(user);
+        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;
+        const mosquitto_property *prop;
+        for (prop = props; prop != NULL; prop = mosquitto_property_next(prop))
+        {
+            if (mosquitto_property_identifier(prop) == MQTT_PROP_CORRELATION_DATA)
+            {
+                void *correlation_data;
+                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);
+                }
+            }
+            else if (mosquitto_property_identifier(prop) == MQTT_PROP_RESPONSE_TOPIC)
+            {
+                char *responseTopic = NULL;
+                if (mosquitto_property_read_string(prop, MQTT_PROP_RESPONSE_TOPIC, &responseTopic, false))
+                {
+                    optResponseTopic = std::string(responseTopic);
+                    free(responseTopic);
+                }
+            }
+            else if (mosquitto_property_identifier(prop) == MQTT_PROP_USER_PROPERTY)
+            {
+                char *name = NULL;
+                char *value = NULL;
+                if (mosquitto_property_read_string_pair(prop, MQTT_PROP_USER_PROPERTY, &name, &value, false))
+                {
+                    if (strcmp(name, "ReturnValue") == 0)
+                    {
+                        int returnValueInt = boost::lexical_cast<int>(value);
+                        optResultCode = static_cast<MethodResultCode>(returnValueInt);
+                    }
+                    free(name);
+                    free(value);
+                }
+            }
+        }
+        for (auto& cb : thisClient->_messageCallbacks)
+        {
+            cout << "Calling callback" << endl;
+            cb(topic, payload, optCorrelationId, optResponseTopic, optResultCode);
+        }
+    });
+
+    mosquitto_publish_callback_set(_mosq, [](struct mosquitto *mosq, void *user, int mid)
+    {
+        MqttConnection *thisClient = static_cast<MqttConnection*>(user);
+        auto found = thisClient->_sendMessages.find(mid);
+        if (found != thisClient->_sendMessages.end())
+        {
+            found->second->set_value(true);
+            thisClient->_sendMessages.erase(found);
+        }
+    });
+
+    Connect();
+    mosquitto_loop_start(_mosq);
+}
+
+MqttConnection::~MqttConnection()
+{
+    boost::mutex::scoped_lock lock(_mutex);
+    mosquitto_loop_stop(_mosq, true);
+    mosquitto_disconnect(_mosq);
+    mosquitto_destroy(_mosq);
+    mosquitto_lib_cleanup();
+
+}
+
+void MqttConnection::Connect()
+{
+    mosquitto_int_option(_mosq, MOSQ_OPT_PROTOCOL_VERSION, MQTT_PROTOCOL_V5);
+    mosquitto_connect(_mosq, _host.c_str(), _port, 120);
+}
+
+boost::future<bool> MqttConnection::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)
+{
+    int mid;
+    mosquitto_property *propList = NULL;
+    mosquitto_property_add_string(&propList, MQTT_PROP_CONTENT_TYPE, "application/json");
+    if (optCorrelationId)
+    {
+        mosquitto_property_add_binary(&propList, MQTT_PROP_CORRELATION_DATA, (void*)optCorrelationId->c_str(), optCorrelationId->size());
+    }
+    if (optResponseTopic)
+    {
+        mosquitto_property_add_string(&propList, MQTT_PROP_RESPONSE_TOPIC, optResponseTopic->c_str());
+    }
+    if (optResultCode)
+    {
+        std::string resultCodeStr = std::to_string(static_cast<int>(*optResultCode));
+        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);
+    mosquitto_property_free_all(&propList);
+    if (rc == MOSQ_ERR_NO_CONN)
+    {
+        std::cout << "Delayed published queued to: " << topic << std::endl;
+        MqttConnection::MqttMessage msg(topic, payload, qos, retain, optCorrelationId, optResponseTopic);
+        auto future = msg.getFuture();
+        boost::mutex::scoped_lock lock(_mutex);
+        _msgQueue.push(std::move(msg));
+        return future;
+    }
+    else if (rc == MOSQ_ERR_SUCCESS)
+    {
+        std::cout << "Published to: " << topic << " | " << payload << std::endl;
+        auto pPromise = std::make_shared<boost::promise<bool>>();
+        auto future = pPromise->get_future();
+        boost::mutex::scoped_lock lock(_mutex);
+        _sendMessages[mid] = std::move(pPromise);
+        return future;
+    }
+    else
+    {
+        std::cout << "RC " << rc << std::endl;
+    }
+    throw std::runtime_error("Unhandled rc");
+}
+
+void MqttConnection::Subscribe(const std::string& topic, int qos)
+{
+    std::cout << "Subscribing to " << topic << endl;
+    int rc = mosquitto_subscribe(_mosq, NULL, topic.c_str(), qos);
+    if (rc == MOSQ_ERR_NO_CONN)
+    {
+        MqttConnection::MqttSubscription sub(topic, qos);
+        boost::mutex::scoped_lock lock(_mutex);
+        _subscriptions.push(sub);
+    }
+    else if (rc == MOSQ_ERR_SUCCESS)
+    {
+        std::cout << "Subscribed to " << topic << std::endl;
+    }
+}
+
+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)
+{
+    boost::mutex::scoped_lock lock(_mutex);
+    _messageCallbacks.push_back(cb);
+    cout << "Message callback set" << endl;
+}
+
+bool MqttConnection::TopicMatchesSubscription(const std::string& topic, const std::string& subscr) const
+{
+    bool result;
+    int rc = mosquitto_topic_matches_sub(subscr.c_str(), topic.c_str(), &result);
+    if (rc != MOSQ_ERR_SUCCESS)
+    {
+        throw std::runtime_error("Mosquitto error");
+    }
+    return result;
+}
+
+std::string MqttConnection::GetClientId() const
+{
+    return _clientId;
+}
+
+{%for broker in stinger.brokers.values()%}
+{{broker.class_name}}::{{broker.class_name}}({%if broker.hostname is none%}const std::string& host, int port, {%endif%}const std::string& clientId)
+    :  MqttConnection({%if broker.hostname is none%}host{%else%}"{{broker.hostname}}"{%endif%}, {%if broker.port is none%}port{%else%}{{broker.port}}{%endif%}, clientId)
+{
+
+}
+
+{%endfor%}

stingeripc/templates/cpp/src/client.cpp.jinja2

@@ -0,0 +1,202 @@
+
+#include <vector>
+#include <iostream>
+#include <boost/format.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/functional/hash.hpp>
+#include <boost/uuid/uuid_io.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+#include <rapidjson/stringbuffer.h>
+#include <rapidjson/writer.h>
+#include <rapidjson/error/en.h>
+#include <rapidjson/document.h>
+
+#include "client.hpp"
+#include "enums.hpp"
+#include "ibrokerconnection.hpp"
+
+
+constexpr const char {{stinger.name | UpperCamelCase}}Client::NAME[];
+constexpr const char {{stinger.name | UpperCamelCase}}Client::INTERFACE_VERSION[];
+
+{{stinger.name | UpperCamelCase}}Client::{{stinger.name | UpperCamelCase}}Client(std::shared_ptr<IBrokerConnection> broker) : _broker(broker)
+{
+    _broker->AddMessageCallback([this](const std::string& topic, const std::string& payload, const boost::optional<std::string> optCorrelationId, const boost::optional<std::string> unusedRespTopic, const boost::optional<MethodResultCode> optResultCode)
+    {
+        _receiveMessage(topic, payload, optCorrelationId, optResultCode);
+    });
+
+    {%-for sig_name, sig in stinger.signals.items() %}
+    _broker->Subscribe("{{sig.topic}}", 1);
+    {%endfor%}
+    {%-for method_name, method in stinger.methods.items() %}
+    { // Restrict scope
+        std::stringstream responseTopicStringStream;
+        responseTopicStringStream << boost::format("{{method.response_topic('%1%')}}") % _broker->GetClientId();
+        _broker->Subscribe(responseTopicStringStream.str(), 2);
+    }
+    {%-endfor%}
+}
+
+void {{stinger.name | UpperCamelCase}}Client::_receiveMessage(
+        const std::string& topic, 
+        const std::string& payload, 
+        const boost::optional<std::string> optCorrelationId, 
+        const boost::optional<MethodResultCode> optResultCode)
+{
+    {%-for sig_name, sig in stinger.signals.items() %}
+    if (_broker->TopicMatchesSubscription(topic, "{{sig.topic}}"))
+    {
+        //Log("Handling {{sig_name}} signal");
+        rapidjson::Document doc;
+        try {
+            if (_{{sig_name | camelCase}}Callback)
+            {
+                rapidjson::ParseResult ok = doc.Parse(payload.c_str());
+                if (!ok)
+                {
+                    //Log("Could not JSON parse {{sig_name}} signal payload.");
+                    throw std::runtime_error(rapidjson::GetParseError_En(ok.Code()));
+                }
+
+                if (!doc.IsObject()) {
+                    throw std::runtime_error("Received payload is not an object");
+                }
+
+                {%for arg in sig.arg_list%}
+                {{arg.cpp_temp_type}} temp{{arg.name}};
+                { // Scoping
+                    rapidjson::Value::ConstMemberIterator itr = doc.FindMember("{{arg.name}}");
+                    if (itr != doc.MemberEnd() && itr->value.Is{{arg.cpp_rapidjson_type}}()) {
+                        {%if arg.arg_type.name.lower() == 'primitive'%}
+                        temp{{arg.name}} = itr->value.Get{{arg.cpp_rapidjson_type}}();
+                        {%elif arg.arg_type.name.lower() == 'enum'%}
+                        temp{{arg.name}} = static_cast<{{arg.cpp_data_type}}>(itr->value.Get{{arg.cpp_rapidjson_type}}());
+                        {%endif%}
+                    } else {
+                    {%-if arg.optional%}
+                        temp{{arg.name}} = boost::none;
+                    {%else%}
+                        throw std::runtime_error("Received payload doesn't have required value/type");
+                    {%endif%}
+                    }
+                }
+                {%endfor%}
+
+                _{{sig_name | camelCase}}Callback({%for arg in sig.arg_list%}temp{{arg.name}}{%if not loop.last%}, {%endif%}{%endfor%});
+            }
+        }
+        catch (const boost::bad_lexical_cast&)
+        {
+            // We couldn't find an integer out of the string in the topic name,
+            // so we are dropping the message completely. 
+            // TODO: Log this failure
+        }
+    }
+    {%-endfor%}
+    {%-for method_name, method in stinger.methods.items() %}
+    {%if not loop.first%}else {%endif%}if (_broker->TopicMatchesSubscription(topic, "{{method.response_topic('+')}}") && optCorrelationId)
+    {
+        std::cout << "Matched topic for {{method_name}} response" << std::endl;
+        _handle{{method_name|UpperCamelCase}}Response(topic, payload, *optCorrelationId);
+    }
+    {%-endfor%}
+}
+
+
+{%-for sig_name, sig in stinger.signals.items() %}
+void {{stinger.name | UpperCamelCase}}Client::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)
+{
+    _{{sig_name | camelCase}}Callback = cb;
+}
+{%-endfor%}
+
+{%for method_name, method in stinger.methods.items()%}
+boost::future<{{method.return_value_cpp_class}}> {{stinger.name | UpperCamelCase}}Client::{{method_name | camelCase}}({%for arg in method.arg_list%}{{arg.cpp_type}} {{arg.name}}{%if not loop.last%}, {%endif%}{%endfor%})
+{
+    auto correlationId = boost::uuids::random_generator()();
+    const std::string correlationIdStr = boost::lexical_cast<std::string>(correlationId);
+    _pending{{method_name|UpperCamelCase}}MethodCalls[correlationId] = boost::promise<{{method.return_value_cpp_class}}>();
+
+    rapidjson::Document doc;
+    doc.SetObject();
+
+    {%macro addToDoc(arg)%}
+    {%-if arg.arg_type.name.lower() == 'primitive'%}
+    {%-if arg.optional %}if ({{arg.name}}) {%endif-%}
+    {%-if arg.type.name.lower() == 'string'%}
+    { // restrict scope
+        rapidjson::Value tempStringValue;
+        tempStringValue.SetString({{arg.name}}{%-if arg.optional %}->{%else%}.{%endif-%}c_str(), {{arg.name}}.size(), doc.GetAllocator());
+        doc.AddMember("{{arg.name}}", tempStringValue, doc.GetAllocator());
+    }
+    {%-else%}
+    doc.AddMember("{{arg.name}}", {%-if arg.optional %}*{%endif-%}{{arg.name}}, doc.GetAllocator());
+    {%-endif%}
+    {%elif arg.arg_type.name.lower() == 'enum'%}
+    doc.AddMember("{{arg.name}}", static_cast<int>({{arg.name}}), doc.GetAllocator());
+    {%-endif-%}
+    {%endmacro%}
+    {%for arg in method.arg_list%}
+    {{addToDoc(arg)}}
+    {%endfor%}
+    rapidjson::StringBuffer buf;
+    rapidjson::Writer<rapidjson::StringBuffer> writer(buf);
+    doc.Accept(writer);
+    std::stringstream responseTopicStringStream;
+    responseTopicStringStream << boost::format("{{method.response_topic('%1%')}}") % _broker->GetClientId();
+    _broker->Publish("{{method.topic}}", buf.GetString(), 2, false, correlationIdStr, responseTopicStringStream.str(), MethodResultCode::SUCCESS);
+
+    return _pending{{method_name|UpperCamelCase}}MethodCalls[correlationId].get_future();
+}
+
+void {{stinger.name | UpperCamelCase}}Client::_handle{{method_name|UpperCamelCase}}Response(
+        const std::string& topic, 
+        const std::string& payload, 
+        const std::string &correlationId) 
+{
+    std::cout << "In response handler for " << topic << " with correlationId=" << correlationId << std::endl;
+    rapidjson::Document doc;
+    rapidjson::ParseResult ok = doc.Parse(payload.c_str());
+    if (!ok)
+    {
+        //Log("Could not JSON parse {{method_name}} signal payload.");
+        throw std::runtime_error(rapidjson::GetParseError_En(ok.Code()));
+    }
+
+    if (!doc.IsObject()) {
+        throw std::runtime_error("Received payload is not an object");
+    }
+
+    boost::uuids::uuid correlationIdUuid = boost::lexical_cast<boost::uuids::uuid>(correlationId);
+    auto promiseItr = _pending{{method_name|UpperCamelCase}}MethodCalls.find(correlationIdUuid);
+    if (promiseItr != _pending{{method_name|UpperCamelCase}}MethodCalls.end())
+    {
+        {%macro unpack_rv(arg)-%}
+        rapidjson::Value::ConstMemberIterator {{arg.name}}Itr = doc.FindMember("{{arg.name}}");
+        {%if arg.arg_type.name.lower() == 'primitive'-%}
+        {{arg.cpp_type}} {{arg.name}} = {{arg.name}}Itr->value.Get{{arg.cpp_rapidjson_type}}();
+        {%elif arg.arg_type.name.lower() == 'enum'-%}
+        {{arg.cpp_type}} {{arg.name}} = static_cast<{{arg.cpp_type}}>({{arg.name}}Itr->value.GetInt());
+        {%endif-%}
+        {%endmacro-%}
+        {%if method.return_value_type == 'struct'-%}
+        {%for item in method.return_value%}
+        {{unpack_rv(item)}}
+        {%-endfor%}
+        {{method.return_value_cpp_class}} returnValue { //initializer list
+        {%for item in method.return_value%}
+            {{item.name}}{%if not loop.last%},{%endif%}
+        {%-endfor%}
+        };
+        promiseItr->second.set_value(returnValue);
+        {%-else%}
+        {{-unpack_rv(method.return_value)}}
+        promiseItr->second.set_value({{method.return_value_property_name}});
+        {%-endif%}
+    }
+
+    std::cout << "End of response handler for " << topic << std::endl;
+}
+{%endfor%}

stingeripc/templates/cpp/src/server.cpp.jinja2

@@ -0,0 +1,170 @@
+
+#include <vector>
+#include <iostream>
+#include <boost/format.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/functional/hash.hpp>
+#include <rapidjson/stringbuffer.h>
+#include <rapidjson/writer.h>
+#include <rapidjson/error/en.h>
+#include <rapidjson/document.h>
+
+#include "server.hpp"
+#include "enums.hpp"
+#include "ibrokerconnection.hpp"
+
+
+constexpr const char {{stinger.name | UpperCamelCase}}Server::NAME[];
+constexpr const char {{stinger.name | UpperCamelCase}}Server::INTERFACE_VERSION[];
+
+{{stinger.name | UpperCamelCase}}Server::{{stinger.name | UpperCamelCase}}Server(std::shared_ptr<IBrokerConnection> broker) : _broker(broker) {
+    _broker->AddMessageCallback([this](const std::string& topic, const std::string& payload, const boost::optional<std::string> optCorrelationId, const boost::optional<std::string> optResponseTopic, const boost::optional<MethodResultCode> unusedRc)
+    {
+        _receiveMessage(topic, payload, optCorrelationId, optResponseTopic);
+    });
+    {%for method in stinger.methods.values()%}
+    _broker->Subscribe("{{method.topic}}", 2);
+    {%endfor%}
+}
+
+void {{stinger.name | UpperCamelCase}}Server::_receiveMessage(
+        const std::string& topic, 
+        const std::string& payload, 
+        const boost::optional<std::string> optCorrelationId, 
+        const boost::optional<std::string> optResponseTopic)
+{
+    {%for method_name, method in stinger.methods.items()%}
+    if (_broker->TopicMatchesSubscription(topic, "{{method.topic}}"))
+    {
+        std::cout << "Message matched topic {{method.topic}}\n";
+        rapidjson::Document doc;
+        try {
+            if (_{{method_name | camelCase}}Handler)
+            {
+                rapidjson::ParseResult ok = doc.Parse(payload.c_str());
+                if (!ok)
+                {
+                    //Log("Could not JSON parse {{sig_name}} signal payload.");
+                    throw std::runtime_error(rapidjson::GetParseError_En(ok.Code()));
+                }
+
+                if (!doc.IsObject()) {
+                    throw std::runtime_error("Received payload is not an object");
+                }
+
+                _call{{method_name | UpperCamelCase}}Handler(topic, doc, optCorrelationId, optResponseTopic);
+            }
+        }
+        catch (const boost::bad_lexical_cast&)
+        {
+            // We couldn't find an integer out of the string in the topic name,
+            // so we are dropping the message completely. 
+            // TODO: Log this failure
+        }
+    }
+    {%endfor%}
+}
+
+{%for sig_name, sig in stinger.signals.items()%}
+boost::future<bool> {{stinger.name | UpperCamelCase}}Server::emit{{sig_name | UpperCamelCase}}Signal({%for arg in sig.arg_list%}{{arg.cpp_type}} {{arg.name}}{%if not loop.last%}, {%endif%}{%endfor%})
+{
+    rapidjson::Document doc;
+    doc.SetObject();
+    {%macro addToDoc(arg)%}
+    {%-if arg.optional%}if ({{arg.name}}){%endif%}
+    {%-if arg.arg_type.name.lower() == 'primitive'%}
+    {%-if arg.type.name.lower() == 'string'%}
+    { // restrict scope
+        rapidjson::Value tempStringValue;
+        tempStringValue.SetString({{arg.name}}{%-if arg.optional%}->{%else%}.{%endif%}c_str(), {{arg.name}}.size(), doc.GetAllocator());
+        doc.AddMember("{{arg.name}}", tempStringValue, doc.GetAllocator());
+    }
+    {%-else%}
+    doc.AddMember("{{arg.name}}", {%-if arg.optional%}*{%endif%}{{arg.name}}, doc.GetAllocator());
+    {%-endif%}
+    {%-elif arg.arg_type.name.lower() == 'enum'%}
+    doc.AddMember("{{arg.name}}", static_cast<int>({%-if arg.optional%}*{%endif%}{{arg.name}}), doc.GetAllocator());
+    {%-endif-%}
+    {%-endmacro%}
+    {%-for arg in sig.arg_list%}
+    {{addToDoc(arg)}}
+    {%endfor%}
+    rapidjson::StringBuffer buf;
+    rapidjson::Writer<rapidjson::StringBuffer> writer(buf);
+    doc.Accept(writer);
+    return _broker->Publish("{{sig.topic}}", buf.GetString(), 1, false, boost::none, boost::none, boost::none);
+}
+{%endfor%}
+
+{%for method_name, method in stinger.methods.items()%}
+void {{stinger.name | UpperCamelCase}}Server::register{{method_name | UpperCamelCase}}Handler(std::function<{{method.return_value_cpp_class}}({%for arg in method.arg_list%}{{arg.cpp_type}}{%if not loop.last%}, {%endif%}{%endfor%})> func)
+{
+    std::cout << "Registered method to handle {{method.topic}}\n";
+    _{{method_name | camelCase}}Handler = func;
+}
+{%endfor%}
+
+{%for method_name, method in stinger.methods.items()%}
+void {{stinger.name | UpperCamelCase}}Server::_call{{method_name | UpperCamelCase}}Handler(
+        const std::string& topic, 
+        const rapidjson::Document& doc, 
+        const boost::optional<std::string> optCorrelationId,
+        const boost::optional<std::string> optResponseTopic) const
+{
+    std::cout << "Handling call to {{method_name}}\n";
+    if (_{{method_name | camelCase}}Handler) {
+        {%for arg in method.arg_list%}
+        {{arg.cpp_temp_type}} temp{{arg.name|UpperCamelCase}};
+        { // Scoping
+            rapidjson::Value::ConstMemberIterator itr = doc.FindMember("{{arg.name}}");
+            if (itr != doc.MemberEnd() && itr->value.Is{{arg.cpp_rapidjson_type}}()) {
+                {%if arg.arg_type.name.lower() == 'primitive'%}
+                temp{{arg.name|UpperCamelCase}} = itr->value.Get{{arg.cpp_rapidjson_type}}();
+                {%elif arg.arg_type.name.lower() == 'enum'%}
+                temp{{arg.name|UpperCamelCase}} = static_cast<{{arg.cpp_type}}>(itr->value.Get{{arg.cpp_rapidjson_type}}());
+                {%endif%}
+            } else {
+                throw std::runtime_error("Received payload doesn't have required value/type");
+            }
+        }
+        {%endfor%}
+
+        {{method.return_value_cpp_class}} ret = _{{method_name | camelCase}}Handler({%for arg in method.arg_list%}temp{{arg.name|UpperCamelCase}}{%if not loop.last%}, {%endif%}{%endfor%});
+
+        if (optResponseTopic)
+        {
+            rapidjson::Document responseJson;
+            responseJson.SetObject();
+            {%macro add_arg_to_json(arg, value) %}
+            // add the {{arg.name}} (a/n {{arg.arg_type.name}}) to the json
+            rapidjson::Value returnValue{{arg.name|UpperCamelCase}};
+            {%-if arg.arg_type.name.lower() == 'primitive' %}
+            {%-if arg.type.name.lower() == 'string' %}
+            returnValue{{arg.name|UpperCamelCase}}.SetString({{value}}.c_str(), {{value}}.size(), responseJson.GetAllocator());
+            {%-else%}
+            returnValue{{arg.name|UpperCamelCase}}.Set{{method.return_value.cpp_rapidjson_type | UpperCamelCase}}({{value}});
+            {%-endif%} {# value type string/primitive #}
+            {%-elif arg.arg_type.name.lower() == 'enum'%}
+            returnValue{{arg.name|UpperCamelCase}}.SetInt(static_cast<int>({{value}}));
+            {%-endif%} {# value or enum#}
+            responseJson.AddMember("{{arg.name}}", returnValue{{arg.name|UpperCamelCase}}, responseJson.GetAllocator());
+            {%endmacro%}
+
+            {%-if method.return_value_type == 'struct'%}
+            // Return type is a struct of values that need added to json
+            {%for member in method.return_value-%}
+            {{add_arg_to_json(member, "ret."+member.name)}}
+            {%endfor%}
+            {%-else%}
+            {{add_arg_to_json(method.return_value, "ret")}}
+            {%-endif%}
+
+            rapidjson::StringBuffer buf;
+            rapidjson::Writer<rapidjson::StringBuffer> writer(buf);
+            responseJson.Accept(writer);
+            _broker->Publish(*optResponseTopic, buf.GetString(), 2, false, optCorrelationId, boost::none, MethodResultCode::SUCCESS);
+        }
+    }
+}
+{%endfor%}