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

stingeripc/connection.py

@@ -1,7 +1,8 @@
 from abc import ABC, abstractmethod
 
+
 class AbstractConnection(ABC):
 
     @abstractmethod
-    def publish(self, topic: str, payload: str, qos: int, retain:bool=False):
+    def publish(self, topic: str, payload: str, qos: int, retain: bool = False):
         pass

stingeripc/exceptions.py

@@ -1,3 +1,2 @@
-
 class InvalidStingerStructure(Exception):
-    pass
+    pass

stingeripc/interface.py

@@ -5,17 +5,19 @@ import yamlloader
 from .components import StingerSpec, InvalidStingerStructure
 from .topic import InterfaceTopicCreator
 
-VERSION_SUPPORTED = "0.0.6"
+VERSION_SUPPORTED = "0.0.7"
 
 
 class StingerInterface(StingerSpec):
 
     def __init__(self, stinger: Dict[str, Any], topic_prefix: Optional[str] = None):
         itc = self._create_topic_creator(stinger)
-        super().__init__(itc, stinger['interface'])
+        super().__init__(itc, stinger["interface"])
 
     @staticmethod
-    def _create_topic_creator(stinger_spec: Dict[str, Any], topic_prefix: Optional[str] = None) -> InterfaceTopicCreator:
+    def _create_topic_creator(
+        stinger_spec: Dict[str, Any], topic_prefix: Optional[str] = None
+    ) -> InterfaceTopicCreator:
         if (
             "stingeripc" not in stinger_spec
             or "version" not in stinger_spec["stingeripc"]
@@ -28,7 +30,9 @@ class StingerInterface(StingerSpec):
             raise InvalidStingerStructure(
                 "Could not find interface name in Stinger Spec"
             )
-        itc = InterfaceTopicCreator(stinger_spec["interface"]["name"], root=topic_prefix)
+        itc = InterfaceTopicCreator(
+            stinger_spec["interface"]["name"], root=topic_prefix
+        )
         return itc
 
     @classmethod

stingeripc/lang_symb.py

@@ -0,0 +1,68 @@
+
+from jacobsjinjatoo import stringmanip
+
+class PythonSymbols:
+    def __init__(self):
+        ...
+
+    @property
+    def type_definition_module(self) -> str:
+        return "stinger_types"
+
+class PythonInterfaceSymbols(PythonSymbols):
+
+    def __init__(self, interface):
+        super().__init__()
+        self._iface = interface
+
+    @property
+    def client_class_name(self) -> str:
+        """ Name of the python class for the interface client."""
+        return f"{stringmanip.upper_camel_case(self._iface.name)}Client"
+
+    @property
+    def server_class_name(self) -> str:
+        """ Name of the python class for the interface server."""
+        return f"{stringmanip.upper_camel_case(self._iface.name)}Server"
+
+
+class PythonStructSymbols(PythonSymbols):
+
+    def __init__(self, iface_struct):
+        super().__init__()
+        self._iface_struct = iface_struct
+
+
+class PythonMethodSymbols(PythonSymbols):
+
+    def __init__(self, method):
+        super().__init__()
+        self._method = method
+    
+    @property
+    def return_value_annotation(self) -> str:
+        return self._method.return_value_python_type
+    
+    @property
+    def return_value_local_class(self) -> str:
+        return f"{stringmanip.upper_camel_case(self._method.name)}ReturnValue"
+
+    @property
+    def return_value_class(self):
+        return f"{self.type_definition_module}.{self.return_value_local_class}"
+
+class RustInterfaceSymbols(PythonSymbols):
+
+    def __init__(self, interface):
+        super().__init__()
+        self._iface = interface
+
+    @property
+    def client_struct_name(self) -> str:
+        """ Name of the rust struct for the interface client."""
+        return f"{stringmanip.upper_camel_case(self._iface.name)}Client"
+
+    @property
+    def server_struct_name(self) -> str:
+        """ Name of the struct for the interface server."""
+        return f"{stringmanip.upper_camel_case(self._iface.name)}Server"

stingeripc/templates/cpp/CMakeLists.txt.jinja2

@@ -0,0 +1,26 @@
+cmake_minimum_required(VERSION 3.16)
+
+project ({{stinger.name}})
+set(CMAKE_CXX_STANDARD 11) 
+
+include_directories(include)
+ 
+set(SOURCE_FILES {%for src_file in source_files|sort%}{{src_file}} {%endfor%})
+
+add_library(lib-{{stinger.name}} ${SOURCE_FILES})
+
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+
+add_executable(client-demo examples/client_main.cpp)
+target_link_libraries(client-demo PUBLIC lib-{{stinger.name}})
+target_link_libraries(client-demo PUBLIC mosquitto)
+target_link_libraries(client-demo PUBLIC boost_thread)
+target_link_libraries(client-demo PUBLIC boost_chrono)
+target_link_libraries(client-demo PRIVATE Threads::Threads)
+
+add_executable(server-demo examples/server_main.cpp)
+target_link_libraries(server-demo PUBLIC lib-{{stinger.name}})
+target_link_libraries(server-demo PUBLIC mosquitto)
+target_link_libraries(server-demo PUBLIC boost_thread)
+target_link_libraries(server-demo PRIVATE Threads::Threads)

stingeripc/templates/cpp/examples/client_main.cpp.jinja2

@@ -0,0 +1,47 @@
+
+#include <iostream>
+#include <boost/chrono/chrono.hpp>
+#include "broker.hpp"
+#include "client.hpp"
+
+int main(int argc, char** argv) {
+
+    {%set broker = stinger.get_example_broker()%}
+    auto conn = std::make_shared<{{broker.class_name}}>({%if broker.hostname is none%}"localhost", 1883, {%endif%}"{{stinger.name | UpperCamelCase}}Client-demo");
+    {{stinger.name | UpperCamelCase}}Client client(conn);
+
+    {%-for sig_name, sig in stinger.signals.items() %}
+    client.register{{sig_name | UpperCamelCase}}Callback([]({%for arg in sig.arg_list%}{{arg.cpp_type}} {{arg.name}}{%if not loop.last%}, {%endif%}{%endfor%}) {
+        std::cout << {%for arg in sig.arg_list%}"{{arg.name}}=" << {%-if arg.optional%} "None"{%else%}{%if arg.arg_type.name.lower() == 'enum'%}{{arg.enum.name | camelCase }}Strings[static_cast<int>({{arg.name}})]{%else%}{{arg.name}}{%endif%}{%endif%} << {%if not loop.last %}" | " << {%endif%}{%endfor%} std::endl;
+    });
+    {%-endfor%}
+
+    {%-for method_name, method in stinger.methods.items() %}
+    std::cout << "Calling {{method_name}}" << std::endl;
+    auto {{method_name|camelCase}}ResultFuture = client.{{method_name | camelCase}}({%for arg in method.arg_list%}{{arg.get_random_example_value('c++')}}{%if not loop.last%}, {%endif%}{%endfor%});
+    auto {{method_name|camelCase}}Status = {{method_name|camelCase}}ResultFuture.wait_for(boost::chrono::seconds(5));
+    if ({{method_name|camelCase}}Status == boost::future_status::timeout)
+    {
+        std::cout << "TIMEOUT after 5 seconds waiting for {{method_name}} response." << std::endl;
+    }
+    else
+    {
+        {%if method.return_value_type == 'primitive'-%}
+        std::cout << "Result: {{method.return_value.name | UpperCamelCase}}=" << {{method_name|camelCase}}ResultFuture.get() << std::endl;
+        {%elif method.return_value_type == 'enum'-%}
+        std::cout << "Result: {{method.return_value.name | UpperCamelCase}}=" << {{method.return_value.enum.name | camelCase }}Strings[{{method_name|camelCase}}ResultFuture.get()] << std::endl;
+        {%elif method.return_value_type == 'struct'-%}
+        {{method.return_value_cpp_class}} returnValue = {{method_name|camelCase}}ResultFuture.get();
+        std::cout << "Results:"{%for m in method.return_value%} << " {{m.name}}=" << {%if m.arg_type.name.lower() == 'enum'%}{{m.enum.name | camelCase }}Strings[static_cast<int>(returnValue.{{m.name}})]{%else%}returnValue.{{m.name}}{%endif%} {%endfor%} << std::endl;
+        {%endif%}
+    }
+    {%-endfor%}
+
+    std::cout << "Connected and waiting.  Use Ctrl-C to exit." << std::endl;
+
+    while (true) {
+        sleep(10);
+    }
+
+    return 0;
+}

stingeripc/templates/cpp/examples/server_main.cpp.jinja2

@@ -0,0 +1,35 @@
+
+#include <iostream>
+
+#include "broker.hpp"
+#include "server.hpp"
+#include "enums.hpp"
+
+int main(int argc, char** argv) {
+
+    {%set broker = stinger.get_example_broker()%}
+    auto conn = std::make_shared<{{broker.class_name}}>({%if broker.hostname is none%}"localhost", 1883, {%endif%}"{{stinger.name | UpperCamelCase}}Serve-demo");
+    {{stinger.name | UpperCamelCase}}Server server(conn);
+
+    {%-for sig_name, sig in stinger.signals.items() %}
+    auto {{sig_name}}Future = server.emit{{sig_name | UpperCamelCase}}Signal({%for arg in sig.arg_list%}{{arg.get_random_example_value(lang="c++")}}{%if not loop.last%}, {%endif%}{%endfor%});
+    {%-endfor%}
+    {%-for sig_name in stinger.signals.keys() %}
+    {{sig_name}}Future.wait();
+    {%-endfor%}
+
+    {%-for method_name, method in stinger.methods.items() %}
+    server.register{{method_name | UpperCamelCase}}Handler([]({%for arg in method.arg_list%}{{arg.cpp_type}} unused{{loop.index}}{%if not loop.last%}, {%endif%}{%endfor%}) -> {{method.return_value_cpp_class}}
+    {
+        std::cout << "Received call for {{method_name}}\n";
+        {%if method.return_value_type == 'struct'%}
+        return {{method.return_value_name | UpperCamelCase}}{ {{method.get_return_value_random_example_value('c++')}} };
+        {%else%}
+        return {{method.get_return_value_random_example_value('c++')}};
+        {%-endif%}
+    });
+    {%endfor%}
+    std::cout << "Press Enter to exit\n"; 
+    std::cin.ignore();
+    return 0;
+}

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

@@ -0,0 +1,132 @@
+
+#pragma once
+
+#include <mosquitto.h>
+#include <queue>
+#include <string>
+#include <map>
+#include <utility>
+#include <boost/interprocess/sync/scoped_lock.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/core/noncopyable.hpp>
+
+#define BOOST_THREAD_PROVIDES_FUTURE
+#include <boost/thread/future.hpp>
+
+#include "ibrokerconnection.hpp"
+
+/*! This class presents a connection to a MQTT broker.
+ */
+class MqttConnection : public IBrokerConnection
+{
+public:
+
+    /*! Constructor for a MqttConnection.
+     * \param hostname IP address or hostname of the MQTT broker server.
+     * \param port Port where the MQTT broker is running (often 1883).
+     */
+    MqttConnection(const std::string& host, int port, const std::string& clientId);
+
+    virtual ~MqttConnection();
+
+    /*! Publish a message to the MQTT broker.
+     * \param topic the topic of the message.
+     * \param payload is the payload body of the message.
+     * \param qos the MQTT quality of service value between 0 and 2 inclusive.
+     * \param retain an indicator that the MQTT broker should retain the message.
+     * \param optCorrelationId Optional correlation ID string that will be used to associate responses to requests.
+     * \param optResponseTopic Optional MQTT topic used for publishing responses to requests.
+     * \param optReturnValue Optional (predetermined) value for the result of a method call.
+     * \return A future which is resolved to true when the message has been published to the MQTT broker.
+     */
+    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);
+
+    /*! Subscribe to a topic.
+     * \param topic the subscription topic.
+     * \param qos an MQTT quality of service value between 0 and 2 inclusive.
+     */
+    virtual void Subscribe(const std::string& topic, int qos);
+
+    /*! Add a function that is called on the receipt of a message.
+     * Many callbacks can be added, and each will be called in the order in which the callbacks were added.
+     * \param cb the callback function.
+     */
+    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);
+
+    /*! Determines if a topic string matches a subscription topic.
+     * \param topic a topic to match against a subscription.
+     * \param subscr the subscription topic string to match against.
+     * \return true if it is a match.
+     */
+    virtual bool TopicMatchesSubscription(const std::string& topic, const std::string& subscr) const;
+
+    virtual std::string GetClientId() const;
+protected:
+    /*! Establishes the connection to the broker.
+     */
+    virtual void Connect();
+
+private:
+    class MqttMessage : private boost::noncopyable
+    {
+    public:
+        MqttMessage(const std::string& topic, const std::string& payload, int qos, bool retain, boost::optional<std::string> optCorrelationId, boost::optional<std::string> optResponseTopic) : _topic(topic), _payload(payload), _qos(qos), _retain(retain), _optCorrelationId(optCorrelationId), _optResponseTopic(optResponseTopic) {}
+        MqttMessage(const MqttMessage& other) : _topic(other._topic), _payload(other._payload), _qos(other._qos), _retain(other._retain), _pSentPromise(other._pSentPromise) {}
+        virtual ~MqttMessage() = default;
+        boost::future<bool> getFuture() { return _pSentPromise->get_future(); };
+        std::string _topic;
+        std::string _payload;
+        int _qos;
+        bool _retain;
+        std::shared_ptr<boost::promise<bool>> _pSentPromise;
+        boost::optional<std::string> _optCorrelationId;
+        boost::optional<std::string> _optResponseTopic;
+    };
+
+    struct MqttSubscription
+    {
+        MqttSubscription(const std::string& topic, int qos) : _topic(topic), _qos(qos) {}
+        ~MqttSubscription() = default;
+        std::string _topic;
+        int _qos;
+        int subscription_id;
+    };
+
+    mosquitto *_mosq;
+    std::string _host;
+    int _port;
+    std::string _clientId;
+    std::queue<MqttSubscription> _subscriptions;
+    boost::mutex _mutex;
+    std::vector<std::function<void(const std::string&, const std::string&, const boost::optional<std::string>, const boost::optional<std::string>, const boost::optional<MethodResultCode>)>> _messageCallbacks;
+    std::queue<MqttMessage> _msgQueue;
+    std::map<int, std::shared_ptr<boost::promise<bool>>> _sendMessages;
+};
+
+{%for broker in stinger.brokers.values()%}
+/*! This class presents a connection to a MQTT broker.
+ */
+class {{broker.class_name}} : public MqttConnection
+{
+public:
+
+    /*! Constructor for a {{broker.class_name}}.
+    {%-if broker.hostname is none%}
+     * \param hostname IP address or hostname of the MQTT broker server.
+    {%-endif%}
+    {%-if broker.port is none%}
+     * \param port Port where the MQTT broker is running (often 1883).
+    {%-endif%}
+     */
+    {{broker.class_name}}({%if broker.hostname is none%}const std::string& host, int port, {%endif%}const std::string& clientId);
+
+    virtual ~{{broker.class_name}}() = default;
+};
+{%endfor%}

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

@@ -0,0 +1,53 @@
+
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <memory>
+#include <exception>
+#include <mutex>
+#include <rapidjson/document.h>
+#include <boost/uuid/uuid.hpp>
+
+#include "ibrokerconnection.hpp"
+#include "enums.hpp"
+#include "return_types.hpp"
+
+class {{stinger.name | UpperCamelCase}}Client {
+
+public:
+    // This is the name of the API.
+    static constexpr const char NAME[] = "{{stinger.name}}";
+    // This is the version of the API contract.
+    static constexpr const char INTERFACE_VERSION[] = "{{stinger.version}}";
+
+    // Constructor taking a connection object.
+    {{stinger.name | UpperCamelCase}}Client(std::shared_ptr<IBrokerConnection> broker);
+
+    virtual ~{{stinger.name | UpperCamelCase}}Client() = default;
+
+    {%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%}
+
+    {%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: 
+    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%}
+    {%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;
+    {%endfor%}
+    {%-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);
+    {%-endfor%}
+};

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

@@ -0,0 +1,17 @@
+/*
+DO NOT MODIFY THIS FILE.  It is automatically generated and changes will be over-written
+on the next generation.
+
+It contains enumerations used by the {{stinger.name}} interface.
+*/
+
+#pragma once
+
+{%for ie_name, ie in stinger.enums.items() %}
+enum class {{ie_name | UpperCamelCase }} {
+    {%-for value in ie.values %}
+    {{value | CONST_CASE}} = {{loop.index}}{%if not loop.last%},{%endif%}
+    {%-endfor%}
+};
+static const char *{{ie_name | camelCase }}Strings[] = {"{{ie_name | UpperCamelCase }}", {%for value in ie.values %}"{{value}}"{%if not loop.last%}, {%endif%}{%endfor%} };
+{%endfor%}

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

@@ -0,0 +1,42 @@
+
+#pragma once
+
+#include <functional>
+#include <string>
+
+#define BOOST_THREAD_PROVIDES_FUTURE
+#include <boost/thread/future.hpp>
+#include <boost/optional.hpp> // Include the Boost.Optional header
+
+enum class MethodResultCode
+{
+    {%-for rc_i, rc_name in stinger.method_return_codes.items()%}
+    {{rc_name | CONST_CASE}} = {{rc_i}}{%if not loop.last%},{%endif%}
+    {%-endfor%}
+};
+
+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;
+    
+    /*! Subscribe to a topic.
+     * Implementation should queue up subscriptions when not connected.
+     */
+    virtual void 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;
+
+    /*! Utility for matching topics.
+     * This probably should be a wrapper around `mosquitto_topic_matches_sub` or similar
+     */
+    virtual bool TopicMatchesSubscription(const std::string& topic, const std::string& subscr) const = 0;
+
+    virtual std::string GetClientId() const = 0;
+}; 

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

@@ -0,0 +1,14 @@
+
+#pragma once
+#include <string>
+#include "enums.hpp"
+
+{%for method_name, method in stinger.methods.items()%}
+{%-if method.return_value_type == 'struct'%}
+struct {{method.return_value_name | UpperCamelCase}} {
+{%-for rv in method.return_value %}
+    {{rv.cpp_temp_type}} {{rv.name}};
+{%-endfor%}
+};
+{%endif%}
+{%-endfor%}

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

@@ -0,0 +1,44 @@
+
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+#include <memory>
+#include <exception>
+#include <mutex>
+#include <boost/optional.hpp>
+#include <rapidjson/document.h>
+
+#include "ibrokerconnection.hpp"
+#include "enums.hpp"
+#include "return_types.hpp"
+
+class {{stinger.name | UpperCamelCase}}Server {
+
+public:
+    static constexpr const char NAME[] = "{{stinger.name}}";
+    static constexpr const char INTERFACE_VERSION[] = "{{stinger.version}}";
+
+    {{stinger.name | UpperCamelCase}}Server(std::shared_ptr<IBrokerConnection> broker);
+
+    virtual ~{{stinger.name | UpperCamelCase}}Server() = default;
+
+    {%for sig_name, sig in stinger.signals.items()%}
+    boost::future<bool> emit{{sig_name | UpperCamelCase}}Signal({%for arg in sig.arg_list%}{{arg.cpp_type}}{%if not loop.last%}, {%endif%}{%endfor%});
+    {%endfor%}
+
+    {%for method_name, method in stinger.methods.items()%}
+    void 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);
+    {%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);
+
+    {%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;
+    std::function<{{method.return_value_cpp_class}}({%for arg in method.arg_list%}{{arg.cpp_type}}{%if not loop.last%}, {%endif%}{%endfor%})> _{{method_name | camelCase}}Handler;
+    {%endfor%}
+
+};

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

@@ -0,0 +1,13 @@
+
+#pragma once
+#include <string>
+#include <boost/optional.hpp>
+#include "enums.hpp"
+
+{%for istruct_name, istruct in stinger.structs.items() %}
+struct {{istruct_name | UpperCamelCase }} {
+    {%-for value in istruct.members %}
+    {{value.cpp_temp_type}} {{value.name}};
+    {%-endfor%}
+};
+{%endfor%}