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

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

@@ -0,0 +1,262 @@
+
+pub mod payloads;
+
+extern crate paho_mqtt as mqtt;
+use uuid::Uuid;
+use futures::{StreamExt};
+use mqtt::{Message, QOS_1, QOS_2};
+use std::collections::HashMap;
+use tokio::sync::mpsc::{self, Sender, Receiver};
+use tokio::sync::mpsc::error::SendError;
+use std::time::Duration;
+use std::sync::{Arc, Mutex};
+use serde::Serialize;
+use serde_json::{self};
+
+#[derive(Clone, Debug)]
+pub struct ReceivedMessage {
+    pub message: mqtt::Message,
+    pub subscription_id: i32,
+}
+
+#[derive(Clone)]
+pub struct MessageStreamer {
+    pub subscriptions: Arc<Mutex<HashMap<i32, Sender<ReceivedMessage>>>>,
+    pub strm: mqtt::AsyncReceiver<Option<mqtt::Message>>
+}
+
+impl MessageStreamer {
+    pub async fn receive_loop(&mut self) -> Result<(), paho_mqtt::Error> {
+        println!("Starting message receive loop...");
+        while let Some(msg_opt) = self.strm.next().await {
+            if let Some(msg) = msg_opt {
+                let mut sub_id_itr = msg.properties().iter(mqtt::PropertyCode::SubscriptionIdentifier);
+                while let Some(sub_id_prop) = sub_id_itr.next() {
+                    let opt_sub_id = sub_id_prop.get_int();
+                    if let Some(sub_id) = opt_sub_id {
+                        if let Some(tx) = self.subscriptions.lock().unwrap().get(&sub_id) {
+                            let tx2 = tx.clone();
+                            let received_msg = ReceivedMessage {
+                                message: msg.clone(),
+                                subscription_id: sub_id,
+                            };
+                            tokio::spawn(async move {
+                                if let Err(e) = tx2.send(received_msg).await {
+                                    eprintln!("Failed to send message: {}", e);
+                                }
+                            });
+                        } else {
+                            println!("No subscription found for ID: {}", sub_id);
+                        } 
+                    } else {
+                        println!("No subscription ID found in message properties.");
+                    }
+                }
+            } else {
+                println!("Received None, stream closed.");
+            }
+    
+        }
+        Ok(())
+    }
+}
+
+#[derive(Clone)]
+pub struct MessagePublisher {
+    pub channel: Sender<mqtt::Message>
+}
+
+impl MessagePublisher {
+    pub async fn publish(&mut self, msg: mqtt::Message) -> Result<(), SendError<Message>> {
+        println!("Message publisher publishing message to {}", msg.topic());
+        self.channel.send(msg).await
+    }
+
+    pub async fn publish_simple(&mut self, topic: String, payload: String) -> Result<(), SendError<Message>> {
+        let msg = mqtt::Message::new(topic, payload, QOS_1);
+        self.publish(msg).await
+    }
+
+    pub async fn publish_structure<T: Serialize>(&mut self, topic: String, data: &T) -> Result<(), SendError<Message>> {
+        let payload = serde_json::to_string(data).unwrap().into_bytes();
+        let mut pub_props = mqtt::Properties::new();
+        let _ = pub_props.push_string(mqtt::PropertyCode::ContentType, "application/json");
+        let msg = mqtt::MessageBuilder::new()
+            .topic(topic)
+            .payload(payload)
+            .properties(pub_props)
+            .qos(QOS_1)
+            .finalize();
+        self.publish(msg).await
+    }
+
+    pub async fn publish_retained_structure<T: Serialize>(&mut self, topic: String, data: &T) -> Result<(), SendError<Message>> {
+        let payload = serde_json::to_string(data).unwrap().into_bytes();
+        let mut pub_props = mqtt::Properties::new();
+        let _ = pub_props.push_string(mqtt::PropertyCode::ContentType, "application/json");
+        let msg = mqtt::MessageBuilder::new()
+            .topic(topic)
+            .payload(payload)
+            .properties(pub_props)
+            .qos(QOS_1)
+            .retained(true)
+            .finalize();
+        self.publish(msg).await
+    }
+
+    pub async fn publish_request_structure<T: Serialize>(&mut self, topic: String, data: &T, response_topic: &str, correlation_id: Uuid) -> Result<(), SendError<Message>> {
+        println!("Publishing request structure to {} with responses going to {}", topic, response_topic);
+        let uuid_vec: Vec<u8> = correlation_id.as_bytes().to_vec();
+        let mut pub_props = mqtt::Properties::new();
+        let _ = pub_props.push_binary(mqtt::PropertyCode::CorrelationData, uuid_vec);
+        let _ = pub_props.push_string(mqtt::PropertyCode::ResponseTopic, response_topic);
+        let _ = pub_props.push_string(mqtt::PropertyCode::ContentType, "application/json");
+        let payload = serde_json::to_string(data).unwrap().into_bytes();
+        let msg = mqtt::MessageBuilder::new()
+            .topic(topic)
+            .qos(QOS_2)
+            .properties(pub_props)
+            .payload(payload)
+            .finalize();
+        self.publish(msg).await
+    }
+
+    pub async fn publish_response_structure<T: Serialize>(&mut self, topic: String, data: &T, correlation_id: Option<Vec<u8>>) -> Result<(), SendError<Message>> {
+        let mut pub_props = mqtt::Properties::new();
+        if let Some(corr_id) = correlation_id {
+            let _ = pub_props.push_binary(mqtt::PropertyCode::CorrelationData, corr_id);
+        }
+        let payload = serde_json::to_string(data).unwrap().into_bytes();
+        let _ = pub_props.push_string(mqtt::PropertyCode::ContentType, "application/json");
+        let msg = mqtt::MessageBuilder::new()
+            .topic(topic)
+            .payload(payload)
+            .qos(QOS_2)
+            .properties(pub_props)
+            .finalize();
+        self.publish(msg).await
+    }
+}
+
+pub struct Connection {
+    pub client: paho_mqtt::AsyncClient,
+    pub client_id: String,
+    pub next_subscription_id: i32,
+    pub subscriptions: Arc<Mutex<HashMap<i32, Sender<ReceivedMessage>>>>,
+    pub pub_chan_rx: Receiver<mqtt::Message>,
+    pub pub_chan_tx: Sender<mqtt::Message>,
+}
+
+impl Connection {
+    pub async fn new(broker: &str) -> Result<Self, paho_mqtt::Error> {
+        println!("Creating new connection object");
+        let client_id_uuid = Uuid::new_v4();
+        let client_id = client_id_uuid.to_string();
+        let create_opts = mqtt::CreateOptionsBuilder::new()
+            .server_uri(broker)
+            .mqtt_version(mqtt::MQTT_VERSION_5)
+            .allow_disconnected_send_at_anytime(true)
+            .client_id(client_id.clone())
+            .finalize();
+        let (tx, rx) = mpsc::channel(32);
+        let client = paho_mqtt::AsyncClient::new(create_opts)?;
+        Ok(Self { 
+            client,
+            client_id,
+            next_subscription_id: 5,
+            subscriptions: Arc::new(Mutex::new(HashMap::new())),
+            pub_chan_rx: rx,
+            pub_chan_tx: tx,
+        })
+    }
+
+    {%for broker_name, broker in stinger.brokers.items()%}
+    pub async fn new_{{broker.class_name | snake_case}}() -> Result<Self, paho_mqtt::Error> {
+        Connection::new("{{broker.hostname or 'localhost'}}:{{broker.port or 1883}}").await
+    }
+    {%endfor%}
+
+    fn get_subscription_id(&mut self) -> i32 {
+        let id = self.next_subscription_id;
+        self.next_subscription_id += 1;
+        id
+    }
+
+    pub async fn get_streamer(&mut self) -> MessageStreamer {
+        let strm = self.client.get_stream(25);
+        MessageStreamer {
+            subscriptions: self.subscriptions.clone(),
+            strm,
+        }
+    }
+
+    pub fn get_publisher(&self) -> MessagePublisher {
+        let channel = self.pub_chan_tx.clone();
+        MessagePublisher {
+            channel,
+        }
+    }
+
+    pub async fn connect(&self) -> Result<paho_mqtt::ServerResponse, paho_mqtt::Error> {
+        println!("Connecting to mqtt");
+        let conn_opts = mqtt::ConnectOptionsBuilder::new_v5()
+            .keep_alive_interval(Duration::from_secs(20))
+            .clean_start(true)
+            .finalize();
+
+        self.client.connect(conn_opts).await
+    }
+
+    pub async fn disconnect(&self) -> Result<paho_mqtt::ServerResponse, paho_mqtt::Error> {
+        self.client.disconnect(None).await
+    }
+    
+    pub async fn publish(&self, msg: mqtt::Message) -> Result<(), paho_mqtt::Error> {
+        println!("Publishing message to {}", msg.topic());
+        let pub_result = self.client.publish(msg).await;
+        pub_result
+    }
+
+    async fn add_subscription_receiver(
+        &mut self,
+        subscription_id: i32,
+        tx: Sender<ReceivedMessage>,
+    ) -> Result<(), paho_mqtt::Error> {
+        let mut subscriptions = self.subscriptions.lock().unwrap();
+        subscriptions.insert(subscription_id, tx);
+        Ok(())
+    }
+
+    pub async fn subscribe(&mut self, topic: &str, tx: Sender<ReceivedMessage>) -> Result<i32, paho_mqtt::Error> {
+        println!("Subscribing to {}", topic);
+        let sub_opts = mqtt::SubscribeOptions::new(true, false, mqtt::RetainHandling::SendRetainedOnSubscribe);
+        let mut sub_props = mqtt::Properties::new();
+        let subscription_id = self.get_subscription_id();
+        let si_prop =  mqtt::Property::new(mqtt::PropertyCode::SubscriptionIdentifier, subscription_id as i32).unwrap();
+        let _ = sub_props.push(si_prop);
+        let _sub_result = self.client.subscribe_with_options(topic, paho_mqtt::QOS_1, sub_opts, sub_props).await;
+        self.add_subscription_receiver(subscription_id, tx).await?;
+        Ok(subscription_id)
+    }
+
+    pub async fn start_loop(&mut self) {
+        println!("Starting MQTT loop...");
+
+        let mut streamer = self.get_streamer().await;
+        let _stream_task = tokio::spawn(async move {
+            let _ = streamer.receive_loop().await;
+        });
+
+        loop {
+            let opt_msg = self.pub_chan_rx.recv().await;
+            if let Some(msg) = opt_msg {
+                let pub_result = self.publish(msg).await;
+                match pub_result {
+                    Ok(_r) => println!("Message was published"),
+                    Err(e) => eprintln!("Error publishing: {:?}", e),
+                }
+            }
+        }
+    }
+
+}

stingeripc/templates/rust/connection/src/payloads.rs.jinja2

@@ -0,0 +1,131 @@
+/*
+DO NOT MODIFY THIS FILE {# unless you see this comment #}.  It is automatically generated and changes will be over-written
+on the next generation.
+
+It contains enumerations used by the {{stinger.name}} interface.
+*/
+
+{%if stinger.enums | length > 0%}
+use std::fmt;
+use num_derive::{FromPrimitive, ToPrimitive};
+use num_traits::{FromPrimitive, ToPrimitive};
+{%endif%}
+use serde::{Serialize, Deserialize};
+
+{%for ie_name, ie in stinger.enums.items() %}
+#[repr(u32)]
+#[derive(Debug, FromPrimitive, ToPrimitive, Clone, Serialize, Deserialize)]
+#[serde(into = "u32", try_from = "u32")]
+pub enum {{ie_name | UpperCamelCase }} {
+    {%-for value in ie.values %}
+    {{value | UpperCamelCase}} = {{loop.index}}{%if not loop.last%},{%endif%}
+    {%-endfor%}
+}
+
+#[allow(dead_code)]
+impl {{ie_name | UpperCamelCase }} {
+    pub fn from_u32(value: u32) -> Option<Self> {
+        FromPrimitive::from_u32(value)
+    }
+}
+
+impl From<{{ie_name | UpperCamelCase }}> for u32 {
+    fn from(s: {{ie_name | UpperCamelCase }}) -> u32 {
+        s as u32
+    }
+}
+
+impl From<u32> for {{ie_name | UpperCamelCase }} {
+    fn from(s: u32) -> {{ie_name | UpperCamelCase }} {
+        {{ie_name | UpperCamelCase }}::from_u32(s).unwrap()
+    }
+}
+
+impl fmt::Display for {{ie_name | UpperCamelCase }} {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+       write!(f, "{:?}", self)
+    }
+}
+{%endfor%}
+
+{%for struct_name, struct in stinger.structs.items() %}
+#[allow(dead_code, non_snake_case)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct {{struct_name | UpperCamelCase}} {
+    {%-for arg in struct.members%}
+    {%-if arg.arg_type.name.lower() == 'primitive'%}
+    pub {{arg.name}}: {{arg.rust_type}},
+    {%-elif arg.arg_type.name.lower() == 'enum'%}
+    pub {{arg.name}}: {{arg.rust_local_type}},
+    {%endif-%}
+    {%endfor%}
+}
+{%-endfor%}
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub enum MethodResultCode { {%-for rc_i, rc_name in stinger.method_return_codes.items()%}
+    {{rc_name | UpperCamelCase}} = {{rc_i}},
+    {%-endfor%}
+}
+
+{%for method_name, method in stinger.methods.items()%}
+// Structures for `{{method_name}}` method
+
+#[allow(dead_code, non_snake_case)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct {{method_name | UpperCamelCase}}RequestObject {
+    {%-for arg in method.arg_list%}
+    {%-if arg.arg_type.name.lower() == 'primitive'%}
+    pub {{arg.name}}: {{arg.rust_type}},
+    {%-elif arg.arg_type.name.lower() == 'enum'-%}
+    pub {{arg.name}}: u32,
+    {%endif-%}
+    {%endfor%}
+}
+{%if method.return_value_type == 'struct'%}
+#[allow(dead_code)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct {{method.return_value_name | UpperCamelCase}} {
+{%-for arg in method.return_value %}
+    pub {{arg.name}}: {{arg.rust_local_type}},
+{%-endfor%}
+}
+{%elif method.return_value_type == 'primitive'%}
+#[derive(Debug, Clone, Serialize)]
+pub struct {{method.return_value_name | UpperCamelCase}} {
+    pub {{method.return_value_property_name}}: {{method.return_value.rust_local_type}},
+}
+{%endif-%}
+{%-endfor%}
+{%for sig_name, sig in stinger.signals.items()%}
+// Structures for `{{sig_name}}` signal
+#[allow(dead_code, non_snake_case)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct {{sig_name | UpperCamelCase}}SignalPayload {
+    {%-for arg in sig.arg_list%}
+    {%-if arg.arg_type.name.lower() == 'primitive'%}
+    pub {{arg.name}}: {{arg.rust_type}},
+    {%elif arg.arg_type.name.lower() == 'enum'-%}
+    pub {{arg.name}}: {{arg.rust_local_type}},
+    {%endif-%}
+    {%endfor%}
+}
+{%endfor%}
+
+{%for prop_name, prop in stinger.properties.items()%}
+// `{{prop_name}}` property structure.
+#[allow(dead_code, non_snake_case)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct {{prop_name | UpperCamelCase}}Property {
+    {%for arg in prop.arg_list%}
+    {%-if arg.arg_type.name.lower() == 'primitive' -%}
+    pub {{arg.name}}: {{arg.rust_type}},
+    {%elif arg.arg_type.name.lower() == 'enum'-%}
+    pub {{arg.name}}: {{arg.rust_local_type}},
+    {%elif arg.arg_type.name.lower() == 'struct'-%}
+    pub {{arg.name}}: {{arg.rust_local_type}},
+    {%endif-%}
+    {%endfor%}
+}
+{%endfor%}

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

@@ -0,0 +1,19 @@
+[package]
+name = "{{stinger.name | snake_case}}_server"
+version = "{{stinger.version}}"
+edition = "2024"
+
+[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"
+
+[[example]]
+name = "{{stinger.name | snake_case}}_server_example"
+path = "examples/server.rs"

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

@@ -0,0 +1,83 @@
+/*
+DO NOT MODIFY THIS FILE {# unless you see this comment #}.  It is automatically generated and changes will be over-written
+on the next generation.
+
+It contains enumerations used by the {{stinger.name}} interface.
+*/
+use futures::{executor::block_on};
+use {{stinger.name | snake_case}}_server::{{stinger.rust.server_struct_name}};
+use connection::Connection;
+use tokio::time::{sleep, Duration};
+use tokio::join;
+use connection::payloads::{MethodResultCode, *};
+
+{%for method_name, method in stinger.methods.items()%}
+fn {{method_name|snake_case}}_handler({%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> {
+    println!("Handling {{method_name}}");
+    {%-if method.return_value_type == 'struct'%}
+    let rv = {{method.return_value_rust_type}} {
+        {%for arg in method.return_value-%}
+        {{arg.name}}: {{arg.get_random_example_value(lang="rust")}},
+        {%endfor%}
+    };
+    Ok(rv)
+    {%elif method.return_value_type is not false %}
+    Ok({{method.return_value.get_random_example_value(lang="rust")}})
+    {%else%}
+    Ok(())
+    {%-endif%}
+}
+{%endfor%}
+
+
+#[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.unwrap();
+        let mut server = {{stinger.rust.server_struct_name}}::new(&mut connection).await;
+
+        let loop_task = tokio::spawn(async move {
+            println!("Making call to start connection loop");
+            let _conn_loop = connection.start_loop().await;
+        });
+        {%for prop_name, prop in stinger.properties.items()%}
+        println!("Setting initial value for property '{{prop_name}}'");
+        {%-if prop.arg_list | length == 1 %}
+        server.set_{{prop_name | snake_case}}({{prop.arg_list[0].get_random_example_value(lang="rust")}}).await;
+        {%-else%}{# many args in property #}
+        let new_value = {{prop.rust_type}} {
+            {%-for arg in prop.arg_list %}
+                {{arg.name}}: {{arg.get_random_example_value(lang="rust")}},
+            {%-endfor%}
+        };
+        server.set_{{prop_name | snake_case}}(new_value).await;
+        {%endif%}
+        {%endfor%}{# property initialization -#}
+        {%-for method_name, method in stinger.methods.items()%}
+        server.set_method_handler_for_{{method_name|snake_case}}({{method_name|snake_case}}_handler);
+        {%endfor%}
+        {%for sig_name, sig in stinger.signals.items()%}
+        sleep(Duration::from_secs(1)).await;
+        println!("Emitting signal '{{sig_name}}'");
+        server.emit_{{sig_name|snake_case}}({%for arg in sig.arg_list%}{{arg.get_random_example_value(lang="rust")}}{%if not loop.last%}, {%endif%}{%endfor%}).await;
+        {%endfor%}
+        {%for prop_name, prop in stinger.properties.items()%}
+        sleep(Duration::from_secs(1)).await;
+        println!("Changing property '{{prop_name}}'");
+        {%-if prop.arg_list | length == 1 %}
+        server.set_{{prop_name | snake_case}}({{prop.arg_list[0].get_random_example_value(lang="rust", seed=3)}}).await;
+        {%-else%}{# many args in property #}
+        let new_value = {{prop.rust_type}} {
+            {%-for arg in prop.arg_list %}
+                {{arg.name}}: {{arg.get_random_example_value(lang="rust", seed=4)}},
+            {%-endfor%}
+        };
+        server.set_{{prop_name | snake_case}}(new_value).await;
+        {%endif%}
+        {%endfor%}{# property initialization -#}
+        server.receive_loop().await;
+        join!(loop_task);
+    });
+    // Ctrl-C to stop
+}