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

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

@@ -0,0 +1,272 @@
+/*
+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 Server for the {{stinger.name}} interface.
+*/
+
+extern crate paho_mqtt as mqtt;
+use connection::{MessagePublisher, Connection, ReceivedMessage};
+
+#[allow(unused_imports)]
+use connection::payloads::{*, MethodResultCode};
+
+use std::sync::{Arc, Mutex};
+use tokio::sync::{mpsc};
+use tokio::join;
+use tokio::task::JoinError;
+use serde::{Serialize, Deserialize};
+use serde_json;
+
+/// 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 }}ServerSubscriptionIds {
+    {%for method_name, method in stinger.methods.items()-%}
+    {{method_name | snake_case}}_method_req: i32,
+    {%endfor%}
+    {%for prop_name, prop in stinger.properties.items()-%}{%if not prop.read_only %}
+    {{prop_name | snake_case}}_property_update: i32,
+    {%endif%}{%endfor%}
+}
+
+#[derive(Clone)]
+struct {{stinger.name | UpperCamelCase }}ServerMethodHandlers {
+    {%for method_name, method in stinger.methods.items()-%}
+    /// Pointer to a function to handle the {{method_name}} method request.
+    method_handler_for_{{method_name|snake_case}}: Arc<Mutex<Box<dyn Fn({%for arg in method.arg_list%}{{arg.rust_type}}{%if not loop.last%}, {%endif%}{%endfor%})->Result<{{method.return_value_rust_type}}, MethodResultCode> + Send>>>,
+    {%endfor%}
+}
+
+#[derive(Clone)]
+struct {{stinger.name | UpperCamelCase}}Properties {
+    {%for prop_name, prop in stinger.properties.items()-%}
+    {{prop_name | snake_case}}_topic: Arc<String>,
+    {%-if prop.arg_list | length > 1%}
+    {{prop_name | snake_case}}: Arc<Mutex<Option<{{prop.rust_type}}>>>,
+    {%-else%}
+    {{prop_name | snake_case}}: Arc<Mutex<Option<{{prop.arg_list[0].rust_type}}>>>,
+    {%endif%}
+    {%-endfor%}
+}
+
+pub struct {{stinger.name | UpperCamelCase}}Server {
+    /// 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>,
+
+    /// Through this MessagePublisher object, we can publish messages to MQTT.
+    msg_publisher: MessagePublisher,
+
+    /// Struct contains all the handlers for the various methods.
+    method_handlers: {{stinger.name | UpperCamelCase }}ServerMethodHandlers,
+    {%if stinger.properties|length > 0%}
+    /// Struct contains all the properties.
+    properties: {{stinger.name | UpperCamelCase}}Properties,
+    {%endif%}
+    /// Subscription IDs for all the subscriptions this makes.
+    subscription_ids: {{stinger.name | UpperCamelCase }}ServerSubscriptionIds,
+
+    /// Copy of MQTT Client ID
+    client_id: String,
+}
+
+impl {{stinger.name | UpperCamelCase}}Server {
+    pub async fn new(connection: &mut Connection) -> Self {
+        let _ = connection.connect().await.expect("Could not connect to MQTT broker");
+
+        //let interface_info = String::from(r#"{{stinger.interface_info.1 | tojson}}"#);
+        //connection.publish("{{stinger.interface_info.0}}".to_string(), interface_info, 1).await;
+
+        // 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);
+
+        let publisher = connection.get_publisher();
+
+        // Create method handler struct
+        {%for method_name, method in stinger.methods.items()-%}
+        let subscription_id_{{method_name | snake_case}}_method_req = connection.subscribe("{{method.topic}}", message_received_tx.clone()).await;
+        let subscription_id_{{method_name | snake_case}}_method_req = subscription_id_{{method_name | snake_case}}_method_req.unwrap_or_else(|_| -1);
+        {%endfor%}
+
+        {%for prop_name, prop in stinger.properties.items()-%}{%if not prop.read_only %}
+        let subscription_id_{{prop_name | snake_case}}_property_update = connection.subscribe("{{prop.update_topic}}", message_received_tx.clone()).await;
+        let subscription_id_{{prop_name | snake_case}}_property_update = subscription_id_{{prop_name | snake_case}}_property_update.unwrap_or_else(|_| -1);
+        {%endif%}{%endfor%}
+
+        // Create structure for method handlers.
+        let method_handlers = {{stinger.name | UpperCamelCase }}ServerMethodHandlers {
+            {%-for method_name, method in stinger.methods.items()-%}
+            method_handler_for_{{method_name|snake_case}}: Arc::new(Mutex::new(Box::new( |{%for arg in method.arg_list-%}_{{loop.index}}{%if not loop.last%}, {%endif%}{%endfor%}| { Err(MethodResultCode::ServerError) } ))),
+            {%endfor%}
+        };
+
+        // Create structure for subscription ids.
+        let sub_ids = {{stinger.name | UpperCamelCase }}ServerSubscriptionIds {
+            {%for method_name, method in stinger.methods.items()-%}
+            {{method_name | snake_case}}_method_req: subscription_id_{{method_name | snake_case}}_method_req,
+            {%endfor%}
+            {%for prop_name, prop in stinger.properties.items()-%}{%if not prop.read_only %}
+            {{prop_name | snake_case}}_property_update: subscription_id_{{prop_name | snake_case}}_property_update,
+            {%endif%}{%endfor%}
+        };
+
+        {%if stinger.properties|length > 0%}
+        let property_values = {{stinger.name | UpperCamelCase}}Properties {
+        {%-for prop_name, prop in stinger.properties.items()%}
+            {{prop_name | snake_case}}_topic: Arc::new(String::from("{{prop.value_topic}}")),
+            {%if prop.arg_list | length > 1 -%}
+            {{prop_name | snake_case}}: Arc::new(Mutex::new(None)),
+            {%else%}
+            {{prop_name | snake_case}}: Arc::new(Mutex::new(None)),
+            {%-endif%}
+        {%-endfor%}
+        };
+        {%endif%}
+
+        {{stinger.name | UpperCamelCase}}Server {
+
+            msg_streamer_rx: Some(message_received_rx),
+            msg_streamer_tx: message_received_tx,
+            msg_publisher: publisher,
+            method_handlers: method_handlers,{%if stinger.properties|length > 0%}
+            properties: property_values,{%endif%}
+            subscription_ids: sub_ids,
+            client_id: connection.client_id.to_string(),
+        }
+    }
+
+    {%for sig_name, sig in stinger.signals.items()-%}
+    pub async fn emit_{{sig_name|snake_case}}(&mut self, {%for arg in sig.arg_list%}{{arg.name|snake_case}}: {{arg.rust_type}}{%if not loop.last%}, {%endif%}{%endfor%}) {
+        let data = connection::payloads::{{sig_name|UpperCamelCase}}SignalPayload {
+            {%for arg in sig.arg_list%}
+            {{arg.name}}: {{arg.name|snake_case}},
+            {%endfor%}
+        };
+        self.msg_publisher.publish_structure("{{sig.topic}}".to_string(), &data).await;
+    }
+    {%endfor%}
+
+    {%for method_name, method in stinger.methods.items()-%}
+    pub fn set_method_handler_for_{{method_name|snake_case}}(&mut self, cb: impl Fn({%for arg in method.arg_list%}{{arg.rust_type}}{%if not loop.last%}, {%endif%}{%endfor%})->Result<{{method.return_value_rust_type}}, MethodResultCode> + 'static + Send) {
+        self.method_handlers.method_handler_for_{{method_name|snake_case}} = Arc::new(Mutex::new(Box::new(cb)));
+    }
+    {%endfor%}
+
+
+    {%for method_name, method in stinger.methods.items()-%}
+    async fn handle_{{method_name|snake_case}}_request(publisher: &mut MessagePublisher, handlers: &mut {{stinger.name | UpperCamelCase }}ServerMethodHandlers, msg: mqtt::Message) {
+        let props = msg.properties();
+        let opt_corr_id_bin: Option<Vec<u8>> = props.get_binary(mqtt::PropertyCode::CorrelationData);
+        let opt_resp_topic = props.get_string(mqtt::PropertyCode::ResponseTopic);
+        let payload_str = msg.payload_str();
+        let payload = serde_json::from_str::<{{method_name | UpperCamelCase}}RequestObject>(&payload_str).unwrap();
+
+        // call the method handler
+        let rv: {{method.return_value_rust_type}} = {
+            let func_guard = handlers.method_handler_for_{{method_name|snake_case}}.lock().unwrap();
+            (*func_guard)({%for arg in method.arg_list%}payload.{{arg.name}}{%if not loop.last%}, {%endif%}{%endfor%}).unwrap()
+        };
+        {%-if method.return_value_type == "primitive" -%}
+        let rv = {{method_name | UpperCamelCase}}ReturnValue {
+            {{method.return_value_property_name}}: rv,
+        };
+        {%endif%}
+        if let Some(resp_topic) = opt_resp_topic {
+            publisher.publish_response_structure(resp_topic, &rv, opt_corr_id_bin).await.expect("Failed to publish response structure");
+        } else {
+            eprintln!("No response topic found in message properties.");
+        }
+    }
+    {%endfor%}
+
+    {%-for prop_name, prop in stinger.properties.items()%}
+    async fn publish_{{prop_name}}_value(mut publisher: MessagePublisher, topic: String, data: {{prop.rust_type}})
+    {
+        {%-if prop.arg_list | length == 1%}
+        let new_data = {{prop_name | UpperCamelCase}}Property {
+            {{prop.arg_list[0].name}}: data,
+        };
+        let _pub_result = publisher.publish_retained_structure(topic, &new_data).await;
+        {%else%}
+        let _pub_result = publisher.publish_retained_structure(topic, &data).await;
+        {%endif%}
+    }
+    {%if not prop.read_only %}
+    async fn update_{{prop_name}}_value(publisher: &mut MessagePublisher, topic: Arc<String>, data: Arc<Mutex<Option<{{prop.rust_type}}>>>, msg: mqtt::Message)
+    {
+        let payload_str = msg.payload_str();
+        let new_data: {{prop_name | UpperCamelCase}}Property = serde_json::from_str(&payload_str).unwrap();
+        let mut locked_data = data.lock().unwrap();
+        {%-if prop.arg_list | length == 1%}
+        *locked_data = Some(new_data.{{prop.arg_list[0].name}});
+        {%-else%}
+        *locked_data = Some(new_data.clone());
+        {%endif%}
+        let publisher2 = publisher.clone();
+        let topic2: String = topic.as_ref().clone();
+        {%-if prop.arg_list | length == 1%}
+        let data2 = new_data.{{prop.arg_list[0].name}};
+        {%-else%}
+        let data2 = new_data;
+        {%endif%}
+        let _ = tokio::spawn(async move {
+            {{stinger.name | UpperCamelCase}}Server::publish_{{prop_name}}_value(publisher2, topic2, data2).await;
+        });
+    }
+    {%endif%}{# not read only property #}
+    pub async fn set_{{prop_name}}(&mut self, data: {{prop.rust_type}}) {
+        println!("Setting {{prop_name}} of type {{prop.rust_type}}");
+        let prop = self.properties.{{prop_name}}.clone();
+        {
+            let mut locked_data = prop.lock().unwrap();
+            *locked_data = Some(data.clone());
+        }
+
+        let publisher2 = self.msg_publisher.clone();
+        let topic2 = self.properties.{{prop_name}}_topic.as_ref().clone();
+        let _ = tokio::spawn(async move {
+            println!("Will publish property {{prop_name}} of type {{prop.rust_type}} to {}", topic2);
+            {{stinger.name | UpperCamelCase}}Server::publish_{{prop_name}}_value(publisher2, topic2, data).await;
+        });
+    }
+    {%endfor%}
+
+    /// Starts the tasks that process messages received.
+    /// In the task, it loops over messages received from the rx side of the message_receiver channel.
+    /// Based on the subscription id of the received message, it will call a function to handle the
+    /// received message.
+    pub async fn receive_loop(&mut self) -> Result<(), JoinError> {
+
+        // 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 mut method_handlers = self.method_handlers.clone();
+        let sub_ids = self.subscription_ids.clone();
+        let mut publisher = self.msg_publisher.clone();
+        {%-if stinger.properties | length > 0 %}
+        let properties = self.properties.clone();
+        {%endif%}
+        let _loop_task = tokio::spawn(async move {
+            while let Some(msg) = message_receiver.recv().await {
+                {%-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_req {
+                    {{stinger.name | UpperCamelCase}}Server::handle_{{method_name|snake_case}}_request(&mut publisher, &mut method_handlers, msg.message).await;
+                }
+                {%-endfor%}{# methods #}
+                {%-for prop_name, prop in stinger.properties.items()%}{%if not prop.read_only %}
+                {%if not loop.first or (stinger.methods | length > 0) %}else {%endif%}if msg.subscription_id == sub_ids.{{prop_name | snake_case}}_property_update {
+                    {{stinger.name | UpperCamelCase}}Server::update_{{prop_name | snake_case}}_value(&mut publisher, properties.{{prop_name | snake_case}}_topic.clone(), properties.{{prop_name | snake_case}}.clone(), msg.message).await;
+                }
+                {%-endif%}{%endfor%}{# properties #}
+            }   
+        });
+
+        println!("Started client receive task");
+        Ok(())
+    }
+}

stingeripc/topic.py

@@ -1,5 +1,5 @@
 from typing import Optional
-
+from jacobsjinjatoo import stringmanip
 
 class TopicCreatorBase:
     def __init__(self, root: Optional[str] = None):
@@ -20,35 +20,38 @@ class SignalTopicCreator(TopicCreatorBase):
         super().__init__(root)
 
     def signal_topic(self, signal_name: str) -> str:
-        return self.slash("signal", signal_name)
+        return self.slash("signal", stringmanip.lower_camel_case(signal_name))
+
 
 class MethodTopicCreator(TopicCreatorBase):
     def __init__(self, root: str):
         super().__init__(root)
 
     def method_topic(self, method_name: str) -> str:
-        return self.slash("method", method_name)
+        return self.slash("method", stringmanip.lower_camel_case(method_name))
 
     def method_response_topic(self, method_name: str, client_id: str) -> str:
         method_topic = self.method_topic(method_name)
         return f"client/{client_id}/{method_topic}/response"
 
+
 class PropertyTopicCreator(TopicCreatorBase):
     def __init__(self, root: str):
         super().__init__(root)
 
     def property_value_topic(self, property_name: str) -> str:
-        return self.slash("property", property_name)
-    
+        return self.slash("property", stringmanip.lower_camel_case(property_name), "value")
+
     def property_update_topic(self, property_name: str) -> str:
-        return self.slash("property", property_name, "set_value");
+        return self.slash("property", stringmanip.lower_camel_case(property_name), "setValue")
+
 
 class InterfaceTopicCreator(TopicCreatorBase):
     """Helper class for creating MQTT topics for various stinger elements."""
 
     def __init__(self, interface_name: str, root: Optional[str] = None):
         super().__init__(root)
-        self._interface_name = interface_name
+        self._interface_name = stringmanip.lower_camel_case(interface_name)
 
     @property
     def _topic_prefix(self) -> str:
@@ -64,4 +67,4 @@ class InterfaceTopicCreator(TopicCreatorBase):
         return MethodTopicCreator(self._topic_prefix)
 
     def property_topic_creator(self) -> PropertyTopicCreator:
-        return PropertyTopicCreator(self._topic_prefix)
+        return PropertyTopicCreator(self._topic_prefix)

stinger_ipc-0.0.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-stinger_ipc-0.0.1.dist-info/licenses/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
-stingeripc/__init__.py,sha256=PTr5WfMfB-GL4vp3-XMU8IwGv3Q5RXQ24H7JuEo3hdk,133
-stingeripc/args.py,sha256=gpGJjtxz3a6TUCkH2mldllWgO1-PJBrmg8TlJT8bacM,3952
-stingeripc/asyncapi.py,sha256=ebXTlodDBKD0jrUd5b8A0ob7kK3hI98KO6fPDbbFcU8,19229
-stingeripc/components.py,sha256=ubiZyUySB3MDd122haXIa5diMh-pEKECA6az8ju1y_o,34143
-stingeripc/connection.py,sha256=B6_Iij1Tue-dv_uDaQKtFVT4yLMUs1PGOj7_ioHwbkI,180
-stingeripc/exceptions.py,sha256=ucD3HsV10bIFSm2p5vlx__bYDk9eNBhokw5fcv8tsu4,51
-stingeripc/interface.py,sha256=Q3WtE2hNSQaPt5WEpn51cNDffjMFD6j2_0x2MbLXVS0,1522
-stingeripc/topic.py,sha256=p6xMm1LL-9Cf86Sdf1jDhMf-5gN2HyKMHPcsrosQ-_M,2209
-stinger_ipc-0.0.1.dist-info/METADATA,sha256=MIqGf_1TrzxD88VcNU7_mlxvhT2D8QrYam7GcwU9zZ8,5993
-stinger_ipc-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-stinger_ipc-0.0.1.dist-info/top_level.txt,sha256=mSNwAf83_1qiTP_vu7XEPBrZu-fDusT1FFyQZzCrRcU,11
-stinger_ipc-0.0.1.dist-info/RECORD,,