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

stingeripc/templates/python/method_codes.py.jinja2

@@ -0,0 +1,30 @@
+
+from typing import Optional
+from enum import IntEnum
+
+class MethodResultCode(IntEnum):{%for rc_i, rc_name in stinger.method_return_codes.items()%}
+    {{rc_name | CONST_CASE}} = {{rc_i}}
+    {%-endfor%}
+
+class StingerMethodException(Exception):
+    
+    def __init__(self, result_code: MethodResultCode, message: str):
+        super().__init__(message)
+        self._result_code = result_code
+
+    @property
+    def result_code(self) -> MethodResultCode:
+        return self._result_code
+{%for rc_i, rc_name in stinger.method_return_codes.items()%}
+class {{rc_name | UpperCamelCase}}StingerMethodException(StingerMethodException):
+    def __init__(self, message: str):
+        super().__init__(MethodResultCode.{{rc_name | CONST_CASE}}, message)
+{%endfor%}
+
+def stinger_exception_factory(result_code: int, message: Optional[str]=None):
+    exc_classes = { {%for rc_i, rc_name in stinger.method_return_codes.items()%}
+        {{rc_i}}: {{rc_name | UpperCamelCase}}StingerMethodException,
+        {%endfor%}
+    }
+    exc_class = exc_classes[result_code]
+    return exc_class(message or "")

stingeripc/templates/python/pyproject.toml.jinja2

@@ -0,0 +1,9 @@
+[project]
+name = "{{stinger.name}}"
+version = "{{stinger.version}}"
+description = "{{stinger.title}}"
+requires-python = ">=3.9"
+dependencies = [
+    "pydantic>=2.11.7",
+    "paho-mqtt>=2.0.1",
+]

stingeripc/templates/python/server.py.jinja2

@@ -0,0 +1,214 @@
+"""
+DO NOT MODIFY THIS FILE. {# Unless you see this comment, in which case you are modifying the template. #} It is automatically generated and changes will be over-written
+on the next generation.
+
+This is the Server for the {{stinger.name}} interface.
+"""
+
+import json
+import logging
+
+logging.basicConfig(level=logging.DEBUG)
+
+from typing import Callable, Dict, Any, Optional, List
+from connection import BrokerConnection
+from method_codes import *
+import {{stinger.get_enum_module_name()}} as {{stinger.get_enum_module_alias()}}
+{%macro method_type_annotation(method) %}Callable[[{%if method.arg_list | length > 0%}{%for arg in method.arg_list%}{{arg.python_type}}{%if not loop.last%}, {%endif%}{%endfor%}{%else%}None{%endif%}], {{method.return_value_python_type}}]{%endmacro%}
+
+class {{stinger.python.server_class_name}}:
+
+    def __init__(self, connection: BrokerConnection):
+        self._logger = logging.getLogger('{{stinger.python.server_class_name}}')
+        self._logger.setLevel(logging.DEBUG)
+        self._logger.debug("Initializing {{stinger.python.server_class_name}}")
+        self._conn = connection
+        self._conn.set_message_callback(self._receive_message)
+        self._conn.set_last_will(topic="{{stinger.interface_info.0}}", payload=None, qos=1, retain=True)
+        {%for prop_name, prop_spec in stinger.properties.items()-%}
+        self._property_{{prop_name}} = None
+        self._conn.subscribe("{{prop_spec.update_topic}}")
+        self.changed_value_callback_for_{{pprop_name}} = None
+        self._publish_interface_info()
+        {%endfor-%}
+        {%-for method in stinger.methods.values()%}
+        self._conn.subscribe("{{method.topic}}")
+        {%endfor-%}
+        {%for method_name, method in stinger.methods.items()-%}
+        self._{{method_name|snake_case}}_method_handler: Optional[{{method_type_annotation(method)}}] = None
+        {%endfor%}
+    
+    def _receive_message(self, topic: str, payload: str, properties: Dict[str, Any]):
+        """ This is the callback that is called whenever any message is received on a subscribed topic.
+        """
+        self._logger.debug("Received message to %s", topic)
+        {%if stinger.methods | length > 0 -%}
+        {%for method_name, method in stinger.methods.items()-%}
+        {%if not loop.first%}el{%endif%}if self._conn.is_topic_sub(topic, "{{method.topic}}"):
+            try:
+                payload_obj = json.loads(payload)
+            except json.decoder.JSONDecodeError:
+                self._logger.warning("Invalid JSON payload received at topic '%s'", topic)
+            else:
+                self._process_{{method_name | snake_case}}_call(topic, payload_obj, properties)
+        {%endfor%}
+        {%-else%}pass{%-endif%}
+
+    def _publish_interface_info(self):
+        self._conn.publish("{{stinger.interface_info.0}}", '''{{stinger.interface_info.1 | tojson}}''', qos=1, retain=True)
+
+    {%for sig_name, sig in stinger.signals.items()-%}
+    def emit_{{sig_name}}(self, {%for arg in sig.arg_list%}{{arg.name}}: {{arg.python_type}}{%if not loop.last%}, {%endif%}{%endfor%}):
+        """ Server application code should call this method to emit the '{{sig_name}}' signal.
+        """
+        {%-for arg in sig.arg_list%}
+        if not isinstance({{arg.name}}, {{arg.python_class}}){%if arg.optional%} and {{arg.name}} is not None{%endif%}:
+            raise ValueError(f"The '{{arg.name}}' value must be {{arg.python_type}}.")
+        {%-endfor%}
+        
+        payload = { {%-for arg in sig.arg_list%}
+            {%if arg.arg_type.name.lower() == 'primitive'%}"{{arg.name}}": {{arg.python_type}}({{arg.name}}){%if arg.optional%} if {{arg.name}} is not None else None{%endif%},{%endif-%}
+            {%if arg.arg_type.name.lower() == 'enum'%}"{{arg.name}}": {{arg.python_class}}({{arg.name}}).value{%if arg.optional%} if {{arg.name}} is not None else None{%endif%},{%endif%}{%endfor%}
+        }
+        self._conn.publish("{{sig.topic}}", json.dumps(payload), qos=1, retain=False)
+
+    {%endfor%}
+
+    {%for method_name, method in stinger.methods.items()%}
+    def handle_{{method_name | snake_case}}(self, handler: {{method_type_annotation(method)}}):
+        """ This is a decorator to decorate a method that will handle the '{{method_name}}' method calls.
+        """
+        if self._{{method_name|snake_case}}_method_handler is None and handler is not None:
+            self._{{method_name|snake_case}}_method_handler = handler
+        else:
+            raise Exception("Method handler already set")
+
+    def _process_{{method_name | snake_case}}_call(self, topic: str, payload: Dict[str, Any], properties: Dict[str, Any]):
+        """ This processes a call to the '{{method_name}}' method.  It deserializes the payload to find the method arguments,
+        then calls the method handler with those arguments.  It then builds and serializes a response and publishes it to the response topic.
+        """
+        correlation_id = properties.get('CorrelationData') # type: Optional[bytes]
+        response_topic = properties.get('ResponseTopic') # type: Optional[str]
+        self._logger.info("Correlation Data %s", correlation_id)
+        if self._{{method_name|snake_case}}_method_handler is not None:
+            method_args = [] # type: List[Any]
+            {%for arg in method.arg_list -%}
+            if "{{arg.name}}" in payload:
+                if not isinstance(payload["{{arg.name}}"], {{arg.python_class}}){%if arg.optional%} or {{arg.name}} is None{%endif%}:
+                    self._logger.warning("The '{{arg.name}}' property in the payload to '%s' wasn't the correct type.  It should have been {{arg.python_type}}.", topic)
+                    # TODO: return an error via MQTT
+                    return
+                else:
+                    method_args.append(payload["{{arg.name}}"])
+            else:
+                {%if arg.optional%}
+                method_args.append(None)
+                {%else%}
+                self._logger.warning("The '{{arg.name}}' property in the payload to '%s' wasn't present", topic)
+                # TODO: return an error via MQTT
+                return
+                {%endif%}
+            {%endfor%}
+            
+            if response_topic is not None:
+                return_json = ""
+                debug_msg = None # type: Optional[str]
+                try:
+                    return_struct = self._{{method_name|snake_case}}_method_handler(*method_args)
+                    self._logger.debug("Return value is %s", return_struct)
+                    {%if method.return_value is false%}
+                        return_json = "{}"
+                    {%else%}
+                    if return_struct is not None:
+                        {%-if method.return_value_type == "primitive" %}
+                        return_json = json.dumps({
+                            "{{method.return_value_property_name}}": return_struct
+                        })
+                        {%-elif method.return_value_type == "enum" %}
+                        return_json = json.dumps({
+                            "{{method.return_value_property_name}}": return_struct.value
+                        })
+                        {%-elif method.return_value_type == "struct" %}
+                        return_json = json.dumps({
+                            "{{method.return_value_property_name}}": return_struct.model_dump_json()
+                        })
+                        {%else%}                        
+                        return_json = return_struct.model_dump_json()
+                        {%endif%}
+                    {%-endif%}
+                except Exception as e:
+                    self._logger.exception("Exception while handling {{method_name}}", exc_info=e)
+                    return_code = MethodResultCode.SERVER_ERROR
+                    debug_msg = str(e)
+                else:
+                    return_code = MethodResultCode.SUCCESS
+                    debug_msg = None
+
+                self._conn.publish(response_topic, return_json, qos=1, retain=False, 
+                    correlation_id=correlation_id, return_value=return_code, debug_info=debug_msg)
+    {%endfor%}
+
+
+class {{stinger.python.server_class_name}}Builder:
+    """
+    This is a builder for the {{stinger.python.server_class_name}}.  It is used to create a server with the desired parameters.
+    """
+
+    def __init__(self, connection: BrokerConnection):
+        self._conn = connection
+        {%for method_name, method in stinger.methods.items()%}
+        self._{{method_name|snake_case}}_method_handler: Optional[{{method_type_annotation(method)}}] = None
+        {%-endfor%}
+    {%for method_name, method in stinger.methods.items()%}
+    def handle_{{method_name | snake_case}}(self, handler: {{method_type_annotation(method)}}):
+        if self._{{method_name|snake_case}}_method_handler is None and handler is not None:
+            self._{{method_name|snake_case}}_method_handler = handler
+        else:
+            raise Exception("Method handler already set")
+    {%endfor%}
+    def build(self) -> {{stinger.python.server_class_name}}:
+        new_server = {{stinger.python.server_class_name}}(self._conn)
+        {%for method_name, method in stinger.methods.items()%}
+        if self._{{method_name|snake_case}}_method_handler is not None:
+            new_server.handle_{{method_name|snake_case}}(self._{{method_name|snake_case}}_method_handler)
+        {%-endfor%}
+        return new_server
+
+if __name__ == '__main__':
+    """
+    This shows an example on how to run the code.  Ideally, your app should do something similar, but use the methods in
+    a more meaningful way.
+    """
+    from time import sleep
+    import signal
+    {%set broker = stinger.get_example_broker()%}
+    from connection import {{broker.class_name}}
+
+    conn = {{broker.class_name}}({%if broker.hostname is none%}'localhost', 1883{%endif%})
+    server = {{stinger.python.server_class_name}}(conn)
+
+    {%for method_name, method in stinger.methods.items()%}
+    @server.handle_{{method_name | snake_case}} 
+    def {{method_name | snake_case}}({%for arg in method.arg_list%}{{arg.name}}: {{arg.python_type}}{%if not loop.last%}, {%endif%}{%endfor%}) -> {{method.return_value_python_type}}:
+        """ This is an example handler for the '{{method_name}}' method.  """
+        print(f"Running {{method_name | snake_case}}'({%for arg in method.arg_list %}{ {{-arg.name-}} }{%if not loop.last%}, {%endif%}{%endfor%})'")
+        return {{method.get_return_value_random_example_value('python')}}
+    {%endfor%}
+
+    print("Ctrl-C will stop the program.")
+
+    while True:
+        try:
+            {%for sig_name, sig in stinger.signals.items()-%}
+            server.emit_{{sig_name}}({%for arg in sig.arg_list%}{{arg.get_random_example_value()}}{%if not loop.last%}, {%endif%}{%endfor%})
+            {%endfor%}
+            sleep(4)
+            {%for sig_name, sig in stinger.signals.items()-%}
+            server.emit_{{sig_name}}({%for arg in sig.arg_list%}{{arg.name}}={{arg.get_random_example_value()}}{%if not loop.last%}, {%endif%}{%endfor%})
+            {%endfor%}
+            sleep(6)
+        except KeyboardInterrupt:
+            break
+
+
+    signal.pause()

stingeripc/templates/rust/Cargo.toml.jinja2

@@ -0,0 +1,4 @@
+[workspace]
+members = ["server", "client", "connection"]
+
+resolver = "2"

stingeripc/templates/rust/client/Cargo.toml.jinja2

@@ -0,0 +1,25 @@
+[package]
+name = "{{stinger.name | snake_case}}_client"
+version = "{{stinger.version}}"
+edition = "2024"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+connection = { path = "../connection" }
+futures = "0.3"
+json = "0.12.4"
+paho-mqtt = "0.13.3"
+num-derive = "0.4.2"
+num-traits = "0.2.19"
+tokio = { version = "1", features = ["full"] }
+serde = { version = "1.0.219", features = ["derive"] }
+serde_json = "1.0.142"
+
+[dependencies.uuid]
+version = "1.2.1"
+features = [
+    "v4",                # Lets you generate random UUIDs
+    "fast-rng",          # Use a faster (but still sufficiently random) RNG
+    "macro-diagnostics", # Enable better diagnostics for compile-time UUIDs
+]

stingeripc/templates/rust/client/examples/client.rs.jinja2

@@ -0,0 +1,53 @@
+use futures::{executor::block_on};
+use {{stinger.name | snake_case}}_client::{{stinger.rust.client_struct_name}};
+use connection::Connection;
+use tokio::time::{sleep, Duration};
+use tokio::join;
+
+#[tokio::main]
+async fn main() {
+    block_on(async {
+        {%set broker = stinger.get_example_broker()%}
+        let mut connection = Connection::new_{{broker.class_name|snake_case}}().await.expect("Failed to create connection");
+        let mut client = {{stinger.rust.client_struct_name}}::new(&mut connection).await;
+
+        tokio::spawn(async move {
+            println!("Making call to start connection loop");
+            let _conn_loop = connection.start_loop().await;
+        });
+
+        {%for sig_name, sig in stinger.signals.items()%}
+        let mut sig_rx = client.get_{{sig_name|snake_case}}_receiver();
+        println!("Got signal receiver for {{sig_name}}");
+
+        sleep(Duration::from_secs(5)).await;
+
+        let sig_rx_task = tokio::spawn(async move {
+            println!("Looping for signals");
+            loop {
+                match sig_rx.recv().await {
+                    Ok(payload) => {
+                        println!("Received {{sig_name}} signal with payload: {:?}", payload);
+                    },
+                    Err(e) => {
+                        eprintln!("Error receiving {{sig_name}} signal: {:?}", e);
+                        break;
+                    }
+                }
+            }
+        });
+        {%endfor%}
+
+        println!("Starting client receive loop");
+        let _client_loop = client.receive_loop().await;
+
+        {%for method_name, method in stinger.methods.items()%}
+        println!("Calling {{method_name}} with example values...");
+        let result = client.{{method_name | snake_case}}({%for arg in method.arg_list%}{{arg.get_random_example_value(lang='rust')}}{%if not loop.last%}, {%endif%}{%endfor%}).await.expect("Failed to call {{method_name}}");
+        println!("{{method_name}} response: {:?}", result);
+        {%endfor%}
+
+        join!(sig_rx_task);
+    });
+    // Ctrl-C to stop
+}

stingeripc/templates/rust/client/src/lib.rs.jinja2

@@ -0,0 +1,247 @@
+/*
+DO NOT MODIFY THIS FILE{# <-- Ignore this because you are editing the template file. #}.  It is automatically generated and changes will be over-written
+on the next generation.
+
+This is the Client for the {{stinger.name}} interface.
+*/
+
+extern crate paho_mqtt as mqtt;
+use connection::{MessagePublisher, Connection, ReceivedMessage};
+
+use json::{JsonValue};
+use std::collections::HashMap;
+use uuid::Uuid;
+use serde_json;
+
+#[allow(unused_imports)]
+use connection::payloads::{*, MethodResultCode};
+
+use std::sync::{Arc, Mutex};
+use tokio::sync::{mpsc, broadcast, oneshot};
+use tokio::join;
+use tokio::task::JoinError;
+
+/// This struct is used to store all the MQTTv5 subscription ids
+/// for the subscriptions the client will make.
+#[derive(Clone, Debug)]
+struct {{stinger.name | UpperCamelCase }}SubscriptionIds {
+    {%for method_name, method in stinger.methods.items()-%}
+    {{method_name | snake_case}}_method_resp: i32,
+    {%-endfor%}
+    {%for sig_name, sig in stinger.signals.items()-%}
+    {{sig_name | snake_case}}_signal: Option<i32>,
+    {%-endfor%}
+}
+
+/// This struct holds the tx side of a broadcast channels used when receiving signals.
+/// The rx side of the broadcast channels can be created from the tx side later.
+/// When {{stinger.name | UpperCamelCase }}Client gets a message and determines that it
+/// is a signal, it will send the signal payload via the tx channel that is in this struct.
+#[derive(Clone)]
+struct {{stinger.name | UpperCamelCase }}SignalChannels {
+    {%for sig_name, sig in stinger.signals.items()-%}
+    {{sig_name|snake_case}}_sender: broadcast::Sender<{%if sig.arg_list | length == 0 %}{{sig.arg_list[0]}}{% else %}{{sig_name | UpperCamelCase}}SignalPayload{% endif %}>,
+    {%endfor%}
+}
+
+/// This is the struct for our API client.
+pub struct {{stinger.name | UpperCamelCase }}Client {
+    {%if stinger.methods | length > 0 %}/// Temporarily holds oneshot channels for responses to method calls.
+    pending_responses: Arc<Mutex<HashMap::<Uuid, oneshot::Sender::<JsonValue>>>>,
+    {%endif%}
+
+    /// Temporarily holds the receiver for the MPSC channel.  The Receiver will be moved
+    /// to a process loop when it is needed.  MQTT messages will be received with this.
+    msg_streamer_rx: Option<mpsc::Receiver<ReceivedMessage>>,
+
+    /// The Sender side of MQTT messages that are received from the broker.  This tx
+    /// side is cloned for each subscription made.
+    msg_streamer_tx: mpsc::Sender<ReceivedMessage>,
+
+    {%if stinger.methods | length > 0 %}/// Through this MessagePublisher object, we can publish messages to MQTT.
+    msg_publisher: MessagePublisher,
+    {%endif%}
+    /// Contains all the MQTTv5 subscription ids.
+    subscription_ids: {{stinger.name | UpperCamelCase }}SubscriptionIds,
+
+    {%if stinger.signals | length > 0 %}/// Holds the channels used for sending signals to the application.
+    signal_channels: {{stinger.name | UpperCamelCase }}SignalChannels,
+    {%endif%}
+    /// Copy of MQTT Client ID
+    client_id: String,
+}
+
+impl {{stinger.name | UpperCamelCase }}Client {
+
+    /// Creates a new {{stinger.name | UpperCamelCase }}Client that uses elements from the provided Connection object.
+    pub async fn new(connection: &mut Connection) -> Self {
+        let _ = connection.connect().await.expect("Could not connect to MQTT broker");
+
+        // Create a channel for messages to get from the Connection object to this {{stinger.name | UpperCamelCase }}Client object.
+        // The Connection object uses a clone of the tx side of the channel.
+        let (message_received_tx, message_received_rx) = mpsc::channel(64);
+
+        {%if stinger.methods | length > 0 %}// Create the publisher object.
+        let publisher = connection.get_publisher();
+
+        // Subscribe to all the topics needed for method responses.
+        {%endif-%}
+        {%for method_name, method in stinger.methods.items()-%}
+        let topic_{{method_name | snake_case}}_method_resp = format!("{{method.response_topic('{}')}}", connection.client_id);
+        let subscription_id_{{method_name | snake_case}}_method_resp = connection.subscribe(&topic_{{method_name | snake_case}}_method_resp, message_received_tx.clone()).await;
+        let subscription_id_{{method_name | snake_case}}_method_resp = subscription_id_{{method_name | snake_case}}_method_resp.unwrap_or_else(|_| -1);
+        {%endfor%}
+
+        // Subscribe to all the topics needed for signals.
+        {%for signal_name, signal in stinger.signals.items()-%}
+        let topic_{{signal_name | snake_case}}_signal = "{{signal.topic}}";
+        let subscription_id_{{signal_name | snake_case}}_signal = connection.subscribe(&topic_{{signal_name | snake_case}}_signal, message_received_tx.clone()).await;
+        let subscription_id_{{signal_name | snake_case}}_signal = subscription_id_{{signal_name | snake_case}}_signal.unwrap_or_else(|_| -1);
+        {%endfor%}
+
+        // Create structure for subscription ids.
+        let sub_ids = {{stinger.name | UpperCamelCase }}SubscriptionIds {
+            {%for method_name, method in stinger.methods.items()-%}
+            {{method_name | snake_case}}_method_resp: subscription_id_{{method_name | snake_case}}_method_resp,
+            {%endfor%}
+            {%-for sig_name, sig in stinger.signals.items()-%}
+            {{sig_name | snake_case}}_signal: Some(subscription_id_{{sig_name | snake_case}}_signal),
+            {%endfor%}
+        };
+
+        {%if stinger.signals | length > 0 %}// Create structure for the tx side of broadcast channels for signals.
+        let signal_channels = {{stinger.name | UpperCamelCase }}SignalChannels {
+            {%for sig_name, sig in stinger.signals.items()-%}
+            {{sig_name|snake_case}}_sender: broadcast::channel(64).0,
+            {%endfor%}
+        };{%endif%}
+
+        // Create {{stinger.name | UpperCamelCase }}Client structure.
+        let inst = {{stinger.name | UpperCamelCase }}Client {
+            {%if stinger.methods | length > 0 %}pending_responses: Arc::new(Mutex::new(HashMap::new())),{%endif%}
+            msg_streamer_rx: Some(message_received_rx),
+            msg_streamer_tx: message_received_tx,
+            {%if stinger.methods | length > 0 %}msg_publisher: publisher,{%endif%}
+            subscription_ids: sub_ids,
+            {%if stinger.signals | length > 0 %}signal_channels: signal_channels,{%endif%}
+            client_id: connection.client_id.to_string(),
+        };
+        inst
+    }
+
+    {%for sig_name, sig in stinger.signals.items()-%}
+    /// Get the RX receiver side of the broadcast channel for the {{sig_name}} signal.
+    /// The signal payload, `{{sig_name | UpperCamelCase}}SignalPayload`, will be put onto the channel whenever it is received.
+    pub fn get_{{sig_name|snake_case}}_receiver(&self) -> broadcast::Receiver<{{sig_name | UpperCamelCase}}SignalPayload> {
+        self.signal_channels.{{sig_name | snake_case}}_sender.subscribe()
+    }
+    {%endfor%}
+
+    {%for method_name, method in stinger.methods.items()-%}
+    /// The `{{method_name}}` method.
+    /// Method arguments are packed into a {{method_name | UpperCamelCase}}RequestObject structure
+    /// and published to the `{{method.topic}}` MQTT topic.
+    ///
+    /// This method awaits on the response to the call before returning.
+    pub async fn {{method_name|snake_case}}(&mut self, {%for arg in method.arg_list%}{{arg.name|snake_case}}: {{arg.rust_type}}{%if not loop.last%}, {%endif%}{%endfor%})->Result<{{method.return_value_rust_type}}, MethodResultCode> {
+        let correlation_id = Uuid::new_v4();
+        let (sender, receiver) = oneshot::channel();
+        {
+            let mut hashmap = self.pending_responses.lock().expect("Mutex was poisoned");
+            hashmap.insert(correlation_id.clone(), sender);
+        }
+
+        let data = connection::payloads::{{method_name | UpperCamelCase}}RequestObject {
+            {%-for arg in method.arg_list%}
+            {{arg.name}}: {{arg.name|snake_case}},
+            {%-endfor%}
+        };
+
+        let response_topic = format!("{{method.response_topic('{}')}}", self.client_id);
+        let _ = self.msg_publisher.publish_request_structure("{{method.topic}}".to_string(), &data, response_topic.as_str(), correlation_id).await;
+        let resp_obj = receiver.await.unwrap();
+        
+        {%-if method.return_value_type == 'primitive' %}
+        Ok(resp_obj["{{method.return_value_property_name}}"].as_{{method.return_value_rust_type}}().unwrap())
+        {%-elif method.return_value_type == 'enum'%}
+        Ok({{arg.rust_type}}::from_u32(payload_object["{{arg.name}}"].as_u32().unwrap())
+        {%-elif method.return_value_type == 'struct'%}
+        Ok({{method.return_value_rust_type}} {
+        {%-for member in method.return_value -%}
+            {%if member.arg_type.name.lower() == 'primitive'%}
+            {%if member.rust_type == 'String'%}
+            {{member.name|snake_case}}: resp_obj["{{member.name}}"].as_str().unwrap().to_string(),
+            {%-else%}
+            {{member.name|snake_case}}: resp_obj["{{member.name}}"].as_{{member.rust_type}}().unwrap(),
+            {%-endif-%}
+            {%elif member.arg_type.name.lower() == 'enum'%}
+            {{member.name|snake_case}}: {{member.rust_type}}::from_u32(resp_obj["{{member.name}}"].as_u32().unwrap()).unwrap(),
+            {%endif%}
+        {%endfor-%} })
+        {%elif method.return_value_type is false%}
+        Ok(())
+        {%else%}
+        TEMPLATE ERROR CASE NOT HANDLED
+        {%-endif %}
+    }
+
+    /// Handler for responses to `{{method_name}}` method calls.
+    /// It finds oneshot channel created for the method call, and sends the response to that channel.
+    fn handle_{{method_name|snake_case}}_response(pending_responses: Arc<Mutex<HashMap::<Uuid, oneshot::Sender::<JsonValue>>>>, payload: String, opt_correlation_id: Option<Uuid>) {
+        
+        let payload_object = json::parse(&payload).unwrap();
+        if opt_correlation_id.is_some() {
+            let sender_opt = opt_correlation_id
+                .and_then(|uuid| {
+                    let mut hashmap = pending_responses.lock().expect("Mutex was poisoned");
+                    hashmap.remove(&uuid)
+                });
+            match sender_opt {
+                Some(sender) => {
+                    let oss: oneshot::Sender<JsonValue> = sender;
+                    match oss.send(payload_object) {
+                        Ok(_) => (),
+                        Err(_) => ()
+                    }
+                },
+                None => ()
+            }
+        }
+    }
+    {%endfor%}
+
+    /// Starts the tasks that process messages received.
+    pub async fn receive_loop(&mut self) -> Result<(), JoinError> {
+        {%if stinger.methods | length > 0%}// Clone the Arc pointer to the map.  This will be moved into the loop_task.
+        let resp_map: Arc<Mutex<HashMap::<Uuid, oneshot::Sender::<JsonValue>>>> = self.pending_responses.clone();
+        {%endif%}
+        // Take ownership of the RX channel that receives MQTT messages.  This will be moved into the loop_task.
+        let mut message_receiver = self.msg_streamer_rx.take().expect("msg_streamer_rx should be Some");
+
+        let sig_chans = self.signal_channels.clone();
+        let sub_ids = self.subscription_ids.clone();
+
+        let loop_task = tokio::spawn(async move {
+            while let Some(msg) = message_receiver.recv().await {
+                let msg_props = msg.message.properties();
+                let opt_corr_id_bin: Option<Vec<u8>> = msg_props.get_binary(mqtt::PropertyCode::CorrelationData);
+                let corr_id: Option<Uuid> = opt_corr_id_bin.and_then(|b| Uuid::from_slice(&b).ok());
+                {%-for method_name, method in stinger.methods.items()%}
+                {%if not loop.first%}else {%endif%}if msg.subscription_id == sub_ids.{{method_name | snake_case}}_method_resp {
+                    {{stinger.name | UpperCamelCase }}Client::handle_{{method_name|snake_case}}_response(resp_map.clone(), msg.message.payload_str().to_string(), corr_id);
+                }
+                {%-endfor%}
+                {%-for signal_name, signal in stinger.signals.items()%}
+                {%if not loop.first%}else {%endif%}if msg.subscription_id == sub_ids.{{signal_name | snake_case}}_signal.unwrap_or_default() {
+                    let chan = sig_chans.{{signal_name | snake_case}}_sender.clone();
+                    let pl: connection::payloads::{{signal_name | UpperCamelCase}}SignalPayload =  serde_json::from_str(&msg.message.payload_str()).expect("Failed to deserialize");
+                    let _send_result = chan.send(pl);
+                }
+                {%endfor%}
+            }   
+        });
+
+        println!("Started client receive task");
+        Ok(())
+    }
+}

stingeripc/templates/rust/connection/Cargo.toml.jinja2

@@ -0,0 +1,21 @@
+[package]
+name = "connection"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+futures = "0.3.31"
+paho-mqtt = "0.13.3"
+serde = { version = "1.0.219", features = ["derive"] }
+serde_json = "1.0.142"
+tokio = { version = "1", features = ["full"] }
+num-derive = "0.4.2"
+num-traits = "0.2.19"
+
+[dependencies.uuid]
+version = "1.17.0"
+features = [
+    "v4",                # Lets you generate random UUIDs
+    "fast-rng",          # Use a faster (but still sufficiently random) RNG
+    "macro-diagnostics", # Enable better diagnostics for compile-time UUIDs
+]

stingeripc/templates/rust/connection/examples/pub_and_recv.rs.jinja2

@@ -0,0 +1,44 @@
+
+use connection::Connection;
+use tokio::time::{sleep, Duration};
+use tokio::join;
+use tokio::sync::mpsc;
+
+#[tokio::main]
+async fn main() {
+    {%set broker = stinger.get_example_broker()%}
+    let mut connection = Connection::new_{{broker.class_name|snake_case}}().await.expect("Failed to create connection");
+    let (recv_chan_tx, mut recv_chan_rx) = mpsc::channel(32);
+    connection.connect().await.expect("Failed to connect to broker");
+    connection.subscribe("example/recv_topic", recv_chan_tx.clone()).await.expect("Failed to subscribe to topic");
+    let mut publisher = connection.get_publisher();
+
+    let loop_task = tokio::spawn(async move {
+        connection.start_loop().await;
+    });
+
+    let _pub_task = tokio::spawn(async move {
+        let mut i = 0;
+        loop {
+            i = i + 1;
+            sleep(Duration::from_secs(1)).await; // Simulate periodic publishing
+            publisher.publish_simple("example/pub_topic".to_string(), format!("Periodic message {}",i).to_string()).await.expect("Failed to publish periodic message");
+        }
+    });
+
+    let _receive_task = tokio::spawn(async move {
+        loop {
+            match recv_chan_rx.recv().await {
+                Some(message) => {
+                    println!("Received message: {:?}", message);
+                },
+                None => {
+                    eprintln!("Receiver channel closed");
+                    break;
+                }
+            }
+        }
+    });
+    
+    let _result = join!(loop_task);
+}