stinger-ipc 0.0.25__tar.gz → 0.0.27__tar.gz

{stinger_ipc-0.0.25/stinger_ipc.egg-info → stinger_ipc-0.0.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stinger-ipc
-Version: 0.0.25
+Version: 0.0.27
 Summary: Tools to create code to do IPC over MQTT
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{stinger_ipc-0.0.25 → stinger_ipc-0.0.27}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stinger-ipc"
-version = "0.0.25"
+version = "0.0.27"
 description = "Tools to create code to do IPC over MQTT"
 readme = "README.md"
 requires-python = ">=3.12"

{stinger_ipc-0.0.25 → stinger_ipc-0.0.27/stinger_ipc.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stinger-ipc
-Version: 0.0.25
+Version: 0.0.27
 Summary: Tools to create code to do IPC over MQTT
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{stinger_ipc-0.0.25 → stinger_ipc-0.0.27}/stingeripc/templates/cpp/src/client.cpp.jinja2

@@ -45,7 +45,7 @@ constexpr const char {{stinger.cpp.client_class_name}}::INTERFACE_VERSION[];
     {%-endfor%}
 
     {%-for prop_name, prop in stinger.properties.items() %}
-    _{{prop_name | lowerCamelCase}}PropertySubscriptionId = _broker->Subscribe("{{prop.update_topic}}", 1);
+    _{{prop_name | lowerCamelCase}}PropertySubscriptionId = _broker->Subscribe("{{prop.value_topic}}", 1);
     {%-endfor%}
 }
 
@@ -116,7 +116,7 @@ void {{stinger.cpp.client_class_name}}::_receiveMessage(
     {%-endfor%}{# for methods #}
 
     {%-for prop_name, prop in stinger.properties.items() %}
-    {%if not loop.first%}else {%endif%}if ((mqttProps.subscriptionId && (*mqttProps.subscriptionId == _{{prop_name | lowerCamelCase}}PropertySubscriptionId)) || topic == "{{prop.update_topic}}")
+    {%if not loop.first%}else {%endif%}if ((mqttProps.subscriptionId && (*mqttProps.subscriptionId == _{{prop_name | lowerCamelCase}}PropertySubscriptionId)) || topic == "{{prop.value_topic}}")
     {
         _receive{{prop_name | UpperCamelCase}}PropertyUpdate(topic, payload, mqttProps.propertyVersion);
     }
@@ -164,6 +164,7 @@ void {{stinger.cpp.client_class_name}}::_handle{{method_name|UpperCamelCase}}Res
         const std::string &correlationId) 
 {
     std::cout << "In response handler for " << topic << " with correlationId=" << correlationId << std::endl;
+    {%if method.return_value_type is not false%}
     rapidjson::Document doc;
     rapidjson::ParseResult ok = doc.Parse(payload.c_str());
     if (!ok)
@@ -171,11 +172,10 @@ void {{stinger.cpp.client_class_name}}::_handle{{method_name|UpperCamelCase}}Res
         //Log("Could not JSON parse {{method_name}} signal payload.");
         throw std::runtime_error(rapidjson::GetParseError_En(ok.Code()));
     }
-
     if (!doc.IsObject()) {
         throw std::runtime_error("Received payload is not an object");
     }
-
+    {%endif%}
     boost::uuids::uuid correlationIdUuid = boost::lexical_cast<boost::uuids::uuid>(correlationId);
     auto promiseItr = _pending{{method_name|UpperCamelCase}}MethodCalls.find(correlationIdUuid);
     if (promiseItr != _pending{{method_name|UpperCamelCase}}MethodCalls.end())

{stinger_ipc-0.0.25 → stinger_ipc-0.0.27}/stingeripc/templates/python/server.py.jinja2

@@ -7,15 +7,31 @@ This is the Server for the {{stinger.name}} interface.
 
 import json
 import logging
-
+import threading
+from dataclasses import dataclass, field
 logging.basicConfig(level=logging.DEBUG)
 
-from typing import Callable, Dict, Any, Optional, List
+from typing import Callable, Dict, Any, Optional, List, Generic, TypeVar
 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%}
 
+T = TypeVar('T')
+
+@dataclass
+class PropertyControls(Generic[T]):
+    value: T | None = None
+    mutex = threading.Lock()
+    version: int = -1
+    subscription_id: int | None = None
+    callbacks: List[Callable[[T], None]] = field(default_factory=list)
+
+@dataclass
+class MethodControls:
+    subscription_id: int | None = None
+    callback: Optional[Callable] = None
+
 class {{stinger.python.server_class_name}}:
 
     def __init__(self, connection: BrokerConnection):
@@ -25,18 +41,15 @@ class {{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()
+        {%for prop_name, prop in stinger.properties.items()%}
+        self._property_{{prop_name|snake_case}}: PropertyControls[{%if prop.arg_list | length == 1%}{{prop.arg_list[0].python_class}}{%else%}{{prop.python_class}}{%endif%}, {%for arg in prop.arg_list %}{{arg.python_type}}{%if not loop.last%}, {%endif%}{%endfor%}] = PropertyControls()
+        self._property_{{prop_name|snake_case}}.subscription_id = self._conn.subscribe("{{prop.update_topic}}")
         {%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
+        {%-for method_name, method in stinger.methods.items()%}
+        self._method_{{method_name|snake_case}} = MethodControls()
+        self._method_{{method_name|snake_case}}.subscription_id = self._conn.subscribe("{{method.topic}}")
         {%endfor%}
+        self._publish_interface_info()
     
     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.
@@ -44,7 +57,7 @@ class {{stinger.python.server_class_name}}:
         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}}"):
+        {%if not loop.first%}el{%endif%}if (properties.get('SubscriptionId', -1) == self._method_{{method_name|snake_case}}.subscription_id) or self._conn.is_topic_sub(topic, "{{method.topic}}"):
             try:
                 payload_obj = json.loads(payload)
             except json.decoder.JSONDecodeError:
@@ -52,7 +65,25 @@ class {{stinger.python.server_class_name}}:
             else:
                 self._process_{{method_name | snake_case}}_call(topic, payload_obj, properties)
         {%endfor%}
-        {%-else%}pass{%-endif%}
+        {%-endif%}
+        {%for prop_name, prop in stinger.properties.items()%}
+        {%if not loop.first%}el{%endif%}if (properties.get('SubscriptionId', -1) == self._property_{{prop_name|snake_case}}.subscription_id) or self._conn.is_topic_sub(topic, "{{prop.update_topic}}"):
+            {%if prop.arg_list | length > 1 -%}
+            prop_value = {{prop.python_class}}.model_validate_json(payload)
+            {%else-%}
+            payload_obj = json.loads(payload)
+            prop_value = {{prop.arg_list[0].python_class}}(payload_obj["{{prop.arg_list[0].name}}"])
+            {%endif-%}
+            with self._property_{{prop_name|snake_case}}.mutex:
+                self._property_{{prop_name|snake_case}}.value = prop_value
+                self._property_{{prop_name|snake_case}}.version += 1
+            for callback in self._property_{{prop_name|snake_case}}.callbacks:
+                {%-if prop.arg_list | length > 1%}
+                    callback({%for arg in prop.arg_list %}prop_value.{{arg.name|snake_case}}{%if not loop.last%}, {%endif%}{%endfor%})
+                {%-else%}
+                callback(prop_value)
+                {%-endif%}
+        {%endfor%}
 
     def _publish_interface_info(self):
         self._conn.publish("{{stinger.interface_info.0}}", '''{{stinger.interface_info.1 | tojson}}''', qos=1, retain=True)
@@ -78,8 +109,8 @@ class {{stinger.python.server_class_name}}:
     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
+        if self._method_{{method_name|snake_case}}.callback is None and handler is not None:
+            self._method_{{method_name|snake_case}}.callback = handler
         else:
             raise Exception("Method handler already set")
 
@@ -90,7 +121,7 @@ class {{stinger.python.server_class_name}}:
         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:
+        if self._method_{{method_name|snake_case}}.callback is not None:
             method_args = [] # type: List[Any]
             {%for arg in method.arg_list -%}
             if "{{arg.name}}" in payload:
@@ -114,7 +145,7 @@ class {{stinger.python.server_class_name}}:
                 return_json = ""
                 debug_msg = None # type: Optional[str]
                 try:
-                    return_struct = self._{{method_name|snake_case}}_method_handler(*method_args)
+                    return_struct = self._method_{{method_name|snake_case}}.callback(*method_args)
                     self._logger.debug("Return value is %s", return_struct)
                     {%if method.return_value is false%}
                         return_json = "{}"
@@ -147,7 +178,65 @@ class {{stinger.python.server_class_name}}:
                 self._conn.publish(response_topic, return_json, qos=1, retain=False, 
                     correlation_id=correlation_id, return_value=return_code, debug_info=debug_msg)
     {%endfor%}
+    {%for prop_name, prop in stinger.properties.items()%}
+    @property
+    def {{prop_name | snake_case}}(self) -> {{prop.python_class}}|None:
+        """ This property returns the last received value for the '{{prop_name}}' property.
+        """
+        with self._property_{{prop_name|snake_case}}_mutex:
+            return self._property_{{prop_name|snake_case}}
 
+    @{{prop_name | snake_case}}.setter
+    def {{prop_name | snake_case}}(self, {%if prop.arg_list | length > 1%}value{%else%}{{prop.arg_list[0].name|snake_case}}{%endif%}: {{prop.python_class}}):
+        """ This property sets (publishes) a new value for the '{{prop_name}}' property.
+        """
+        if not isinstance({%if prop.arg_list | length > 1%}value{%else%}{{prop.arg_list[0].name|snake_case}}{%endif%}, {{prop.python_class}}):
+            raise ValueError(f"The value must be {{prop.python_class}}.")
+
+        {%if prop.arg_list | length > 1%}
+        payload = value.model_dump_json()
+        {%else%}
+        payload = json.dumps({ "{{prop.arg_list[0].name}}": {{prop.arg_list[0].name|snake_case}} })
+        {%endif%}
+
+        if {%if prop.arg_list | length > 1%}value{%else%}{{prop.arg_list[0].name|snake_case}}{%endif%} != self._property_{{prop_name|snake_case}}.value:
+            with self._property_{{prop_name|snake_case}}.mutex:
+                self._property_{{prop_name|snake_case}}.value = {%if prop.arg_list | length > 1%}value{%else%}{{prop.arg_list[0].name|snake_case}}{%endif%}
+                self._property_{{prop_name|snake_case}}.version += 1
+            self._conn.publish("{{prop.value_topic}}", payload, qos=1, retain=True)
+            for callback in self._property_{{prop_name|snake_case}}.callbacks:
+                {%-if prop.arg_list | length > 1%}
+                    callback({%for arg in prop.arg_list %}value.{{arg.name|snake_case}}{%if not loop.last%}, {%endif%}{%endfor%})
+                {%-else%}
+                callback({{prop.arg_list[0].name|snake_case}})
+                {%-endif%}
+
+    def set_{{prop_name | snake_case}}(self, {%for arg in prop.arg_list %}{{arg.name|snake_case}}: {{arg.python_type}}{%if not loop.last%}, {%endif%}{%endfor%}):
+        """ This method sets (publishes) a new value for the '{{prop_name}}' property.
+        """
+        {%-for arg in prop.arg_list%}
+        if not isinstance({{arg.name|snake_case}}, {{arg.python_class}}){%if arg.optional%} and {{arg.name|snake_case}} is not None{%endif%}:
+            raise ValueError(f"The '{{arg.name|snake_case}}' value must be {{arg.python_type}}.")
+        {%-endfor%}
+
+        {%if prop.arg_list | length > 1%}
+        obj = stinger_types.{{prop.python_local_type}}({%for arg in prop.arg_list%}
+            {{arg.name}}={{arg.name|snake_case}},
+            {%endfor%}
+        )
+        {%else%}
+        obj = {{prop.arg_list[0].name | snake_case}}
+        {%endif%}
+
+        # Use the property.setter to do that actual work.
+        self.{{prop_name|snake_case}} = obj
+
+    def on_{{prop_name | snake_case}}_updates(self, handler: Callable[[{%for arg in prop.arg_list %}{{arg.python_type}}{%if not loop.last%}, {%endif%}{%endfor%}], None]):
+        """ This method registers a callback to be called whenever a new '{{prop_name}}' property update is received.
+        """
+        if handler is not None:
+            self._property_{{prop_name|snake_case}}.callbacks.append(handler)
+    {%endfor%}
 
 class {{stinger.python.server_class_name}}Builder:
     """
@@ -159,6 +248,9 @@ class {{stinger.python.server_class_name}}Builder:
         {%for method_name, method in stinger.methods.items()%}
         self._{{method_name|snake_case}}_method_handler: Optional[{{method_type_annotation(method)}}] = None
         {%-endfor%}
+        {%for prop_name, property in stinger.properties.items()%}
+        self._{{prop_name|snake_case}}_property_callbacks: List[Callable[[{%for arg in property.arg_list %}{{arg.python_type}}{%if not loop.last%}, {%endif%}{%endfor%}], 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:
@@ -166,12 +258,22 @@ class {{stinger.python.server_class_name}}Builder:
         else:
             raise Exception("Method handler already set")
     {%endfor%}
+    {%for prop_name, prop in stinger.properties.items()%}
+    def on_{{prop_name | snake_case}}_updates(self, handler: Callable[[{%for arg in prop.arg_list %}{{arg.python_type}}{%if not loop.last%}, {%endif%}{%endfor%}], None]):
+        """ This method registers a callback to be called whenever a new '{{prop_name}}' property update is received.
+        """
+        self._{{prop_name|snake_case}}_property_callbacks.append(handler)
+    {%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%}
+        {%for prop_name, prop in stinger.properties.items()%}
+        for callback in self._{{prop_name|snake_case}}_property_callbacks:
+            new_server.on_{{prop_name|snake_case}}_updates(callback)
+        {%endfor%}
         return new_server
 
 if __name__ == '__main__':
@@ -187,6 +289,18 @@ if __name__ == '__main__':
     conn = {{broker.class_name}}({%if broker.hostname is none%}'localhost', 1883{%endif%})
     server = {{stinger.python.server_class_name}}(conn)
 
+    {%for prop_name, prop in stinger.properties.items()-%}
+    {%if prop.arg_list | length > 1%}
+    server.{{prop_name | snake_case}} = {{prop.python_class}}(
+        {%for arg in prop.arg_list%}
+        {{arg.name}}={{arg.get_random_example_value()}},
+        {%endfor%}
+    )
+    {%else%}
+    server.{{prop_name | snake_case}} = {{prop.arg_list[0].get_random_example_value()}}
+    {%endif%}
+    {%endfor%}
+
     {%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}}:
@@ -195,6 +309,12 @@ if __name__ == '__main__':
         return {{method.get_return_value_random_example_value('python')}}
     {%endfor%}
 
+    {%for prop_name, prop in stinger.properties.items()%}
+    @server.on_{{prop_name | snake_case}}_updates
+    def on_{{prop_name | snake_case}}_update({%for arg in prop.arg_list %}{{arg.name}}: {{arg.python_type}}{%if not loop.last%}, {%endif%}{%endfor%}):
+        print(f"Received update for '{{prop_name}}' property: {%for arg in prop.arg_list %}{ {{arg.name}}= }{%if not loop.last%}, {%endif%}{%endfor%}")
+    {%endfor%}
+
     print("Ctrl-C will stop the program.")
 
     while True:

{stinger_ipc-0.0.25 → stinger_ipc-0.0.27}/stingeripc/templates/rust/server/Cargo.toml.jinja2

@@ -15,6 +15,7 @@ serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.142"
 log = "0.4"
 env_logger = "0.10"
+async-trait = "0.1"
 
 [[example]]
 name = "{{stinger.name | snake_case}}_server_demo"

{stinger_ipc-0.0.25 → stinger_ipc-0.0.27}/stingeripc/templates/rust/server/examples/server.rs.jinja2

@@ -10,9 +10,10 @@ use mqttier::MqttierClient;
 use {{stinger.rust.server_package_name}}::{ {{stinger.rust.server_struct_name}}{%if stinger.methods|length>0%}, {{stinger.name | UpperCamelCase }}MethodHandlers{%endif%} };
 use tokio::time::{sleep, Duration};
 {%if stinger.methods|length > 0%}
-//use {{stinger.rust.server_package_name}}::handler::{{stinger.name | UpperCamelCase }}MethodHandlers;
-//use {{stinger.rust.server_package_name}}::init::Initializable;
-use std::sync::{Arc, Mutex};{%endif%}
+use std::sync::Arc;
+use tokio::sync::Mutex;
+use async_trait::async_trait;
+{%endif%}
 #[allow(unused_imports)]
 use {{stinger.rust.common_package_name}}::payloads::{MethodResultCode, *};
 
@@ -29,15 +30,16 @@ impl {{stinger.name | UpperCamelCase }}MethodImpl {
     }
 }
 
+#[async_trait]
 impl {{stinger.name | UpperCamelCase }}MethodHandlers for {{stinger.name | UpperCamelCase }}MethodImpl {
 
-    fn initialize(&mut self, server: {{stinger.rust.server_struct_name}}) -> Result<(), MethodResultCode> {
+    async fn initialize(&mut self, server: {{stinger.rust.server_struct_name}}) -> Result<(), MethodResultCode> {
         self.server = Some(server.clone());
         Ok(())
     }
 
     {%for method_name, method in stinger.methods.items()%}
-    fn handle_{{method_name|snake_case}}(&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> {
+    async fn handle_{{method_name|snake_case}}(&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> {
         println!("Handling {{method_name}}");
         {%-if method.return_value_type == 'struct'%}
         let rv = {{method.return_value_rust_type}} {
@@ -58,12 +60,8 @@ impl {{stinger.name | UpperCamelCase }}MethodHandlers for {{stinger.name | Upper
         self
     }
 }
-
-
 {%endif%}
 
-
-
 #[tokio::main]
 async fn main() {
     env_logger::Builder::from_default_env()

{stinger_ipc-0.0.25 → stinger_ipc-0.0.27}/stingeripc/templates/rust/server/src/lib.rs.jinja2

@@ -13,9 +13,8 @@ use mqttier::{MqttierClient{%if stinger.methods|length > 0 or stinger.properties
 use {{stinger.rust.common_package_name}}::payloads::{*, MethodResultCode};
 use std::any::Any;
 {%if stinger.methods|length > 0 %}
-//pub mod handler;
-//pub mod init;
-//pub use handler::{{stinger.name | UpperCamelCase }}MethodHandlers;
+use async_trait::async_trait;
+use tokio::sync::Mutex as AsyncMutex;
 use std::sync::{Arc, Mutex};
 {%endif%}
 {%if stinger.methods|length > 0 or stinger.properties|length > 0 %}
@@ -68,7 +67,7 @@ pub struct {{stinger.rust.server_struct_name}} {
     {%endif%}
     {%if stinger.methods|length > 0 %}
     /// Struct contains all the method handlers.
-    method_handlers: Arc<Mutex<Box<dyn {{stinger.name | UpperCamelCase }}MethodHandlers>>>,
+    method_handlers: Arc<AsyncMutex<Box<dyn {{stinger.name | UpperCamelCase }}MethodHandlers>>>,
     {%endif%}
     {%if stinger.properties|length > 0%}
     /// Struct contains all the properties.
@@ -85,7 +84,7 @@ pub struct {{stinger.rust.server_struct_name}} {
 }
 
 impl {{stinger.rust.server_struct_name}} {
-    pub async fn new(connection: &mut MqttierClient{%if stinger.methods|length > 0%}, method_handlers: Arc<Mutex<Box<dyn {{stinger.name | UpperCamelCase }}MethodHandlers>>> {%endif%}) -> Self {
+    pub async fn new(connection: &mut MqttierClient{%if stinger.methods|length > 0%}, method_handlers: Arc<AsyncMutex<Box<dyn {{stinger.name | UpperCamelCase }}MethodHandlers>>> {%endif%}) -> Self {
         {%if stinger.methods|length > 0 or stinger.properties|length > 0 %}
         // Create a channel for messages to get from the MqttierClient object to this {{stinger.rust.server_struct_name}} object.
         // The Connection object uses a clone of the tx side of the channel.
@@ -152,7 +151,7 @@ impl {{stinger.rust.server_struct_name}} {
 
     {%for method_name, method in stinger.methods.items()-%}
     /// Handles a request message for the {{method_name}} method.
-    async fn handle_{{method_name|snake_case}}_request(publisher: MqttierClient, handlers: Arc<Mutex<Box<dyn {{stinger.name | UpperCamelCase }}MethodHandlers>>>, msg: ReceivedMessage) {
+    async fn handle_{{method_name|snake_case}}_request(publisher: MqttierClient, handlers: Arc<AsyncMutex<Box<dyn {{stinger.name | UpperCamelCase }}MethodHandlers>>>, msg: ReceivedMessage) {
         let opt_corr_data = msg.correlation_data;
         let opt_resp_topic = msg.response_topic;
         {%if method.arg_list | length > 0 -%}
@@ -161,8 +160,8 @@ impl {{stinger.rust.server_struct_name}} {
         {%endif%}{# has arg_list #} 
         // call the method handler
         let rv: Result<{{method.return_value_rust_type}}, MethodResultCode> = {
-            let handler_guard = handlers.lock().unwrap();
-            (*handler_guard).handle_{{method_name|snake_case}}({%for arg in method.arg_list%}payload.{{arg.name}}{%if not loop.last%}, {%endif%}{%endfor%})
+            let handler_guard = handlers.lock().await;
+            handler_guard.handle_{{method_name|snake_case}}({%for arg in method.arg_list%}payload.{{arg.name}}{%if not loop.last%}, {%endif%}{%endfor%}).await
         };
 
         if let Some(resp_topic) = opt_resp_topic {
@@ -267,7 +266,7 @@ impl {{stinger.rust.server_struct_name}} {
 
         {%if stinger.methods|length > 0 -%}
         let method_handlers = self.method_handlers.clone();
-        self.method_handlers.lock().unwrap().initialize(self.clone()).expect("Failed to initialize method handlers");
+        self.method_handlers.lock().await.initialize(self.clone()).await;
         {%endif-%}
 
         let sub_ids = self.subscription_ids.clone();
@@ -304,13 +303,14 @@ impl {{stinger.rust.server_struct_name}} {
 
 }
 {%if stinger.methods|length > 0 %}
+#[async_trait]
 pub trait {{stinger.name | UpperCamelCase }}MethodHandlers: Send + Sync {
 
-    fn initialize(&mut self, server: {{stinger.rust.server_struct_name}}) -> Result<(), MethodResultCode>;
+    async fn initialize(&mut self, server: {{stinger.rust.server_struct_name}}) -> Result<(), MethodResultCode>;
 
     {%for method_name, method in stinger.methods.items()-%}
     /// Pointer to a function to handle the {{method_name}} method request.
-    fn handle_{{method_name|snake_case}}(&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>;
+    async fn handle_{{method_name|snake_case}}(&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>;
     
     {%endfor%}