stinger-ipc 0.0.5__py3-none-any.whl → 0.0.8__py3-none-any.whl

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

@@ -5,20 +5,20 @@ 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 mqttier::{MqttierClient, ReceivedMessage};
+{%if stinger.methods|length > 0 -%}
 use std::collections::HashMap;
+use json::JsonValue;
 use uuid::Uuid;
+{%endif-%}
 use serde_json;
 
+
 #[allow(unused_imports)]
-use connection::payloads::{*, MethodResultCode};
+use {{stinger.rust.common_package_name}}::{MethodResultCode, *};
 
 use std::sync::{Arc, Mutex};
-use tokio::sync::{mpsc, broadcast, oneshot};
-use tokio::join;
+use tokio::sync::{broadcast, mpsc{%if stinger.methods|length > 0 -%}, oneshot{%endif-%}};
 use tokio::task::JoinError;
 
 /// This struct is used to store all the MQTTv5 subscription ids
@@ -26,16 +26,19 @@ use tokio::task::JoinError;
 #[derive(Clone, Debug)]
 struct {{stinger.name | UpperCamelCase }}SubscriptionIds {
     {%for method_name, method in stinger.methods.items()-%}
-    {{method_name | snake_case}}_method_resp: i32,
-    {%-endfor%}
+    {{method_name | snake_case}}_method_resp: usize,
+    {%endfor%}
     {%for sig_name, sig in stinger.signals.items()-%}
-    {{sig_name | snake_case}}_signal: Option<i32>,
+    {{sig_name | snake_case}}_signal: Option<usize>,
     {%-endfor%}
+    {%for prop_name, prop in stinger.properties.items()-%}
+    {{prop_name | snake_case}}_property_value: usize,
+    {%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
+/// When {{stinger.rust.client_struct_name}} 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 {
@@ -44,61 +47,90 @@ struct {{stinger.name | UpperCamelCase }}SignalChannels {
     {%endfor%}
 }
 
+{%if stinger.properties | length > 0%}
+#[derive(Clone)]
+pub struct {{stinger.name | UpperCamelCase}}Properties {
+    {%for prop_name, prop in stinger.properties.items()-%}
+    {%-if prop.arg_list | length > 1%}
+    pub {{prop_name | snake_case}}: Arc<Mutex<Option<{{prop.rust_type}}>>>,
+    {%-else%}
+    pub {{prop_name | snake_case}}: Arc<Mutex<Option<{{prop.arg_list[0].rust_type}}>>>,
+    {%endif%}
+    {%-endfor%}
+}
+{%endif%}
+
 /// This is the struct for our API client.
-pub struct {{stinger.name | UpperCamelCase }}Client {
+#[derive(Clone)]
+pub struct {{stinger.rust.client_struct_name}} {
+    mqttier_client: MqttierClient,
     {%if stinger.methods | length > 0 %}/// Temporarily holds oneshot channels for responses to method calls.
-    pending_responses: Arc<Mutex<HashMap::<Uuid, oneshot::Sender::<JsonValue>>>>,
+    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>>,
+    msg_streamer_rx: Arc<Mutex<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.
+    #[allow(dead_code)]
     msg_streamer_tx: mpsc::Sender<ReceivedMessage>,
-
-    {%if stinger.methods | length > 0 %}/// Through this MessagePublisher object, we can publish messages to MQTT.
-    msg_publisher: MessagePublisher,
+    {%if stinger.properties|length > 0%}
+    /// Struct contains all the properties.
+    pub properties: {{stinger.name | UpperCamelCase}}Properties,
     {%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.
+    {%-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,
+    pub client_id: String,
 }
 
-impl {{stinger.name | UpperCamelCase }}Client {
+impl {{stinger.rust.client_struct_name}} {
 
-    /// 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");
+    /// Creates a new {{stinger.rust.client_struct_name}} that uses an MqttierClient.
+    pub async fn new(connection: &mut MqttierClient) -> Self {
 
-        // Create a channel for messages to get from the Connection object to this {{stinger.name | UpperCamelCase }}Client object.
+        // Create a channel for messages to get from the Connection object to this {{stinger.rust.client_struct_name}} 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);
+        let subscription_id_{{method_name | snake_case}}_method_resp = connection.subscribe(topic_{{method_name | snake_case}}_method_resp, 2, 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(|_| usize::MAX);
         {%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);
+        let topic_{{signal_name | snake_case}}_signal = "{{signal.topic}}".to_string();
+        let subscription_id_{{signal_name | snake_case}}_signal = connection.subscribe(topic_{{signal_name | snake_case}}_signal, 2, message_received_tx.clone()).await;
+        let subscription_id_{{signal_name | snake_case}}_signal = subscription_id_{{signal_name | snake_case}}_signal.unwrap_or_else(|_| usize::MAX);
         {%endfor%}
 
+        // Subscribe to all the topics needed for properties.
+        {% for prop_name, prop in stinger.properties.items() %}
+        let topic_{{prop_name | snake_case}}_property_value = "{{prop.value_topic}}".to_string();
+        let subscription_id_{{prop_name | snake_case}}_property_value = connection.subscribe(topic_{{prop_name | snake_case}}_property_value, 1, message_received_tx.clone()).await;
+        let subscription_id_{{prop_name | snake_case}}_property_value = subscription_id_{{prop_name | snake_case}}_property_value.unwrap_or_else(|_| usize::MAX);
+        {% endfor %}
+
+        {%if stinger.properties|length > 0%}
+        let property_values = {{stinger.name | UpperCamelCase}}Properties {
+        {%-for prop_name, prop in stinger.properties.items()%}
+            {%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%}
         // Create structure for subscription ids.
         let sub_ids = {{stinger.name | UpperCamelCase }}SubscriptionIds {
             {%for method_name, method in stinger.methods.items()-%}
@@ -107,6 +139,9 @@ impl {{stinger.name | UpperCamelCase }}Client {
             {%-for sig_name, sig in stinger.signals.items()-%}
             {{sig_name | snake_case}}_signal: Some(subscription_id_{{sig_name | snake_case}}_signal),
             {%endfor%}
+            {%-for prop_name, prop in stinger.properties.items()-%}
+            {{prop_name | snake_case}}_property_value: subscription_id_{{prop_name | snake_case}}_property_value,
+            {%endfor%}
         };
 
         {%if stinger.signals | length > 0 %}// Create structure for the tx side of broadcast channels for signals.
@@ -116,12 +151,15 @@ impl {{stinger.name | UpperCamelCase }}Client {
             {%endfor%}
         };{%endif%}
 
-        // Create {{stinger.name | UpperCamelCase }}Client structure.
-        let inst = {{stinger.name | UpperCamelCase }}Client {
+        // Create {{stinger.rust.client_struct_name}} structure.
+        let inst = {{stinger.rust.client_struct_name}} {
+            mqttier_client: connection.clone(),
             {%if stinger.methods | length > 0 %}pending_responses: Arc::new(Mutex::new(HashMap::new())),{%endif%}
-            msg_streamer_rx: Some(message_received_rx),
+            msg_streamer_rx: Arc::new(Mutex::new(Some(message_received_rx))),
             msg_streamer_tx: message_received_tx,
-            {%if stinger.methods | length > 0 %}msg_publisher: publisher,{%endif%}
+            {%if stinger.properties|length > 0 %}
+            properties: property_values,
+            {%endif%}
             subscription_ids: sub_ids,
             {%if stinger.signals | length > 0 %}signal_channels: signal_channels,{%endif%}
             client_id: connection.client_id.to_string(),
@@ -143,23 +181,24 @@ impl {{stinger.name | UpperCamelCase }}Client {
     /// 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> {
+    pub async fn {{method_name|snake_case}}(&mut self{%if method.arg_list | length > 0 %}, {%endif%}{%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 correlation_data = correlation_id.as_bytes().to_vec();
         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 {
+        let data = {{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();
+        let response_topic: String = format!("{{method.response_topic('{}')}}", self.client_id);
+        let _ = self.mqttier_client.publish_request("{{method.topic}}".to_string(), &data, response_topic, correlation_data).await;
+        let {%if method.return_value_type is false %}_{%endif%}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())
@@ -201,43 +240,61 @@ impl {{stinger.name | UpperCamelCase }}Client {
                     let oss: oneshot::Sender<JsonValue> = sender;
                     match oss.send(payload_object) {
                         Ok(_) => (),
-                        Err(_) => ()
+                        Err(_) => (),
                     }
-                },
-                None => ()
+                }
+                None => (),
             }
         }
     }
     {%endfor%}
 
     /// Starts the tasks that process messages received.
-    pub async fn receive_loop(&mut self) -> Result<(), JoinError> {
+    pub async fn run_loop(&self) -> Result<(), JoinError> {
+        // Make sure the MqttierClient is connected and running.
+        let _ = self.mqttier_client.run_loop().await;
+
         {%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 mut message_receiver = {
+            let mut guard = self.msg_streamer_rx.lock().expect("Mutex was poisoned");
+            guard.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 {
+        {%-if stinger.properties|length > 0%}
+        let props = self.properties.clone();
+        {%endif%}
+        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());
+                {% if stinger.methods|length > 0 %}
+                let opt_corr_data: Option<Vec<u8>> = msg.correlation_data.clone();
+                let opt_corr_id: Option<Uuid> = opt_corr_data.and_then(|b| Uuid::from_slice(b.as_slice()).ok());
+
+                let payload = String::from_utf8_lossy(&msg.payload).to_string();
                 {%-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);
+                    {{stinger.rust.client_struct_name}}::handle_{{method_name|snake_case}}_response(resp_map.clone(), payload, opt_corr_id);
                 }
                 {%-endfor%}
+                {%endif%}
                 {%-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 pl: {{signal_name | UpperCamelCase}}SignalPayload =  serde_json::from_slice(&msg.payload).expect("Failed to deserialize");
                     let _send_result = chan.send(pl);
                 }
                 {%endfor%}
+                {%-for prop_name, prop in stinger.properties.items()%}
+                {%if not loop.first%}else {%endif%}if msg.subscription_id == sub_ids.{{prop_name | snake_case}}_property_value {
+                    let pl: {{prop.rust_type}} =  serde_json::from_slice(&msg.payload).expect("Failed to deserialize");
+                    let mut guard = props.{{prop_name | snake_case}}.lock().expect("Mutex was poisoned");
+                    *guard = Some(pl);
+                }
+                {%endfor%}
             }   
         });
 

stingeripc/templates/rust/{connection → payloads}/Cargo.toml.jinja2

@@ -1,11 +1,11 @@
 [package]
-name = "connection"
-version = "0.1.0"
+name = "{{stinger.rust.common_package_name}}"
+version = "{{stinger.version}}"
 edition = "2024"
 
 [dependencies]
 futures = "0.3.31"
-paho-mqtt = "0.13.3"
+mqttier = { git = "https://github.com/stinger-ipc/mqttier.git" }
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.142"
 tokio = { version = "1", features = ["full"] }
@@ -18,4 +18,8 @@ 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
-]
+]
+
+[[example]]
+name = "{{stinger.name | snake_case}}_connection_demo"
+path = "examples/pub_and_recv.rs"

stingeripc/templates/rust/{connection → payloads}/examples/pub_and_recv.rs.jinja2

@@ -1,5 +1,5 @@
 
-use connection::Connection;
+use mqttier::MqttierClient;
 use tokio::time::{sleep, Duration};
 use tokio::join;
 use tokio::sync::mpsc;
@@ -7,26 +7,26 @@ 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");
+    println!("Starting pub and recv example");
+    let client = MqttierClient::new("localhost", 1883, None).unwrap();
     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();
+    client.subscribe("example/recv_topic".to_string(), 1, recv_chan_tx.clone()).await.expect("Failed to subscribe to topic");
 
-    let loop_task = tokio::spawn(async move {
-        connection.start_loop().await;
-    });
+    println!("Starting MQTT client loop");
+    client.run_loop().await.unwrap();
 
+    let client2 = client.clone();
     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 message = format!("Periodic message {}", i);
+            client2.publish_string("example/pub_topic".to_string(), message, 1, false, None).await.expect("Failed to publish periodic message");
         }
     });
 
-    let _receive_task = tokio::spawn(async move {
+    let receive_task = tokio::spawn(async move {
         loop {
             match recv_chan_rx.recv().await {
                 Some(message) => {
@@ -40,5 +40,5 @@ async fn main() {
         }
     });
     
-    let _result = join!(loop_task);
+    let _result = join!(receive_task);
 }

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

@@ -0,0 +1,4 @@
+pub mod payloads;
+
+// Re-export all public types from payloads
+pub use payloads::{*};

stingeripc/templates/rust/{connection → payloads}/src/payloads.rs.jinja2

@@ -8,7 +8,7 @@ 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};
+use num_traits::FromPrimitive;
 {%endif%}
 use serde::{Serialize, Deserialize};
 
@@ -74,6 +74,7 @@ pub enum MethodResultCode { {%-for rc_i, rc_name in stinger.method_return_codes.
 
 #[allow(dead_code, non_snake_case)]
 #[derive(Clone, Debug, Serialize, Deserialize)]
+/// Request Object for `{{method_name}}`
 pub struct {{method_name | UpperCamelCase}}RequestObject {
     {%-for arg in method.arg_list%}
     {%-if arg.arg_type.name.lower() == 'primitive'%}
@@ -83,9 +84,11 @@ pub struct {{method_name | UpperCamelCase}}RequestObject {
     {%endif-%}
     {%endfor%}
 }
-{%if method.return_value_type == 'struct'%}
+
+{%if method.return_value_type == 'struct' %}
 #[allow(dead_code)]
 #[derive(Debug, Clone, Serialize, Deserialize)]
+/// Return Object for `{{method_name}}`
 pub struct {{method.return_value_name | UpperCamelCase}} {
 {%-for arg in method.return_value %}
     pub {{arg.name}}: {{arg.rust_local_type}},
@@ -96,6 +99,11 @@ pub struct {{method.return_value_name | UpperCamelCase}} {
 pub struct {{method.return_value_name | UpperCamelCase}} {
     pub {{method.return_value_property_name}}: {{method.return_value.rust_local_type}},
 }
+{%else%}
+#[derive(Debug, Clone, Serialize)]
+/// Empty (no parameters) return structure for the `{{method_name}}` method.
+pub struct {{method.return_value_name | UpperCamelCase}} {
+}
 {%endif-%}
 {%-endfor%}
 {%for sig_name, sig in stinger.signals.items()%}

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

@@ -1,13 +1,13 @@
 [package]
-name = "{{stinger.name | snake_case}}_server"
+name = "{{stinger.rust.server_package_name}}"
 version = "{{stinger.version}}"
 edition = "2024"
 
 [dependencies]
-connection = { path = "../connection" }
+{{stinger.rust.common_package_name}} = { path = "../payloads" }
 futures = "0.3"
 json = "0.12.4"
-paho-mqtt = "0.13.3"
+mqttier = { git = "https://github.com/stinger-ipc/mqttier.git" }
 num-derive = "0.4.2"
 num-traits = "0.2.19"
 tokio = { version = "1", features = ["full"] }
@@ -15,5 +15,5 @@ serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.142"
 
 [[example]]
-name = "{{stinger.name | snake_case}}_server_example"
+name = "{{stinger.name | snake_case}}_server_demo"
 path = "examples/server.rs"

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

@@ -5,11 +5,12 @@ 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 mqttier::MqttierClient;
+use {{stinger.rust.server_package_name}}::{{stinger.rust.server_struct_name}};
 use tokio::time::{sleep, Duration};
-use tokio::join;
-use connection::payloads::{MethodResultCode, *};
+
+#[allow(unused_imports)]
+use {{stinger.rust.common_package_name}}::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> {
@@ -34,13 +35,9 @@ fn {{method_name|snake_case}}_handler({%for arg in method.arg_list%}_{{arg.name|
 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 connection = MqttierClient::new("localhost", 1883, None).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 %}
@@ -76,8 +73,7 @@ async fn main() {
         server.set_{{prop_name | snake_case}}(new_value).await;
         {%endif%}
         {%endfor%}{# property initialization -#}
-        server.receive_loop().await;
-        join!(loop_task);
+        let _server_loop_task = server.receive_loop().await;
     });
     // Ctrl-C to stop
 }