stinger-ipc 0.0.10__py3-none-any.whl → 0.0.26__py3-none-any.whl

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

@@ -5,14 +5,22 @@ on the next generation.
 This is the Server for the {{stinger.name}} interface.
 */
 
+
+
 use mqttier::{MqttierClient{%if stinger.methods|length > 0 or stinger.properties|length > 0 %}, ReceivedMessage{%endif%}};
 
 #[allow(unused_imports)]
 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 std::sync::{Arc, Mutex};
+{%endif%}
 {%if stinger.methods|length > 0 or stinger.properties|length > 0 %}
 use serde_json;
-use std::sync::{Arc, Mutex};
-use tokio::sync::mpsc;
+use tokio::sync::{mpsc{%if stinger.properties|length > 0 %}, watch{%endif%}};
 {%endif%}
 use tokio::task::JoinError;
 
@@ -28,14 +36,7 @@ struct {{stinger.name | UpperCamelCase }}ServerSubscriptionIds {
     {{prop_name | snake_case}}_property_update: usize,
     {%endif%}{%endfor%}
 }
-{%if stinger.methods|length > 0 %}
-#[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%}
-}{%endif%}{# method handlers struct #}
+
 {%if stinger.properties | length > 0%}
 #[derive(Clone)]
 struct {{stinger.name | UpperCamelCase}}Properties {
@@ -43,8 +44,10 @@ struct {{stinger.name | UpperCamelCase}}Properties {
     {{prop_name | snake_case}}_topic: Arc<String>,
     {%-if prop.arg_list | length > 1%}
     {{prop_name | snake_case}}: Arc<Mutex<Option<{{prop.rust_type}}>>>,
+    {{prop_name | snake_case}}_tx_channel: watch::Sender<Option<{{prop.rust_type}}>>,
     {%-else%}
     {{prop_name | snake_case}}: Arc<Mutex<Option<{{prop.arg_list[0].rust_type}}>>>,
+    {{prop_name | snake_case}}_tx_channel: watch::Sender<Option<{{prop.arg_list[0].rust_type}}>>,
     {%endif%}
     {%-endfor%}
 }
@@ -64,8 +67,9 @@ pub struct {{stinger.rust.server_struct_name}} {
     msg_streamer_tx: mpsc::Sender<ReceivedMessage>,
     {%endif%}
     {%if stinger.methods|length > 0 %}
-    /// Struct contains all the handlers for the various methods.
-    method_handlers: {{stinger.name | UpperCamelCase }}ServerMethodHandlers,{%endif%}
+    /// Struct contains all the method handlers.
+    method_handlers: Arc<Mutex<Box<dyn {{stinger.name | UpperCamelCase }}MethodHandlers>>>,
+    {%endif%}
     {%if stinger.properties|length > 0%}
     /// Struct contains all the properties.
     properties: {{stinger.name | UpperCamelCase}}Properties,
@@ -81,7 +85,7 @@ pub struct {{stinger.rust.server_struct_name}} {
 }
 
 impl {{stinger.rust.server_struct_name}} {
-    pub async fn new(connection: &mut MqttierClient) -> Self {
+    pub async fn new(connection: &mut MqttierClient{%if stinger.methods|length > 0%}, method_handlers: Arc<Mutex<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.
@@ -97,14 +101,6 @@ impl {{stinger.rust.server_struct_name}} {
         let subscription_id_{{prop_name | snake_case}}_property_update = subscription_id_{{prop_name | snake_case}}_property_update.unwrap_or_else(|_| usize::MAX);
         {%else-%}
         {%endif%}{%endfor%}
-        {%if stinger.methods | length > 0 %}
-        // 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%}
-        };
-        {%endif%}{# method handlers #}
         
         // Create structure for subscription ids.
         let sub_ids = {{stinger.name | UpperCamelCase }}ServerSubscriptionIds {
@@ -121,11 +117,10 @@ impl {{stinger.rust.server_struct_name}} {
         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%}
+            {{prop_name | snake_case}}_tx_channel: watch::channel(None).0,
+
         {%-endfor%}
         };
         {%endif%}
@@ -148,44 +143,45 @@ impl {{stinger.rust.server_struct_name}} {
     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 = {{sig_name|UpperCamelCase}}SignalPayload {
             {%for arg in sig.arg_list%}
-            {{arg.name}}: {{arg.name|snake_case}},
+        {{arg.name}}: {{arg.name|snake_case}},
             {%endfor%}
         };
         let _ = self.mqttier_client.publish_structure("{{sig.topic}}".to_string(), &data).await;
     }
     {%endfor%}
 
-    {%for method_name, method in stinger.methods.items()-%}
-    /// Sets the function to be called when a request for the {{method_name}} method is received.
-    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()-%}
     /// Handles a request message for the {{method_name}} method.
-    async fn handle_{{method_name|snake_case}}_request(publisher: MqttierClient, handlers: &mut {{stinger.name | UpperCamelCase }}ServerMethodHandlers, msg: ReceivedMessage) {
+    async fn handle_{{method_name|snake_case}}_request(publisher: MqttierClient, handlers: Arc<Mutex<Box<dyn {{stinger.name | UpperCamelCase }}MethodHandlers>>>, msg: ReceivedMessage) {
         let opt_corr_data = msg.correlation_data;
         let opt_resp_topic = msg.response_topic;
-        {%if method.return_value_type != false -%}
+        {%if method.arg_list | length > 0 -%}
         let payload_vec = msg.payload;
         let payload = serde_json::from_slice::<{{method_name | UpperCamelCase}}RequestObject>(&payload_vec).unwrap();
-        {%endif%}
+        {%endif%}{# has arg_list #} 
         // 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()
+        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%})
         };
 
-        {%-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 {
             let corr_data = opt_corr_data.unwrap_or_default();
-            publisher.publish_response(resp_topic, &rv, corr_data).await.expect("Failed to publish response structure");
+            match rv {
+                Ok({%if method.return_value_type is false %}_{%else%}retval{%endif%}) => {
+                    {%-if method.return_value_type == "primitive" %}
+                    let retval = {{method_name | UpperCamelCase}}ReturnValue {
+                        {{method.return_value_property_name}}: retval,
+                    };
+                    {%elif method.return_value_type is false %}
+                    let retval = {{method_name | UpperCamelCase}}ReturnValue {};
+                    {%endif%}
+                    publisher.publish_response(resp_topic, &retval, corr_data).await.expect("Failed to publish response structure");
+                }
+                Err(err) => {
+                    eprintln!("Error occurred while handling {}: {:?}", stringify!({{method_name}}), err);
+                }
+            }
         } else {
             eprintln!("No response topic found in message properties.");
         }
@@ -206,7 +202,7 @@ impl {{stinger.rust.server_struct_name}} {
         {%endif%}
     }
     {%if not prop.read_only %}
-    async fn update_{{prop_name}}_value(publisher: MqttierClient, topic: Arc<String>, data: Arc<Mutex<Option<{{prop.rust_type}}>>>, msg: ReceivedMessage)
+    async fn update_{{prop_name}}_value(publisher: MqttierClient, topic: Arc<String>, data: Arc<Mutex<Option<{{prop.rust_type}}>>>, watch_sender: watch::Sender<Option<{{prop.rust_type}}>>, msg: ReceivedMessage)
     {
         let payload_str = String::from_utf8_lossy(&msg.payload).to_string();
         let new_data: {{prop_name | UpperCamelCase}}Property = serde_json::from_str(&payload_str).unwrap();
@@ -223,10 +219,17 @@ impl {{stinger.rust.server_struct_name}} {
         {%-else%}
         let data2 = new_data;
         {%endif%}
+        let data_to_send_to_watchers = data2.clone();
+        let _ = watch_sender.send(Some(data_to_send_to_watchers));
         let _ = tokio::spawn(async move {
             {{stinger.rust.server_struct_name}}::publish_{{prop_name}}_value(publisher2, topic2, data2).await;
         });
     }
+
+    pub async fn watch_{{prop_name}}(&self) -> watch::Receiver<Option<{{prop.rust_type}}>> {
+        self.properties.{{prop_name}}_tx_channel.subscribe()
+    }
+
     {%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}}");
@@ -236,6 +239,9 @@ impl {{stinger.rust.server_struct_name}} {
             *locked_data = Some(data.clone());
         }
 
+        let data_to_send_to_watchers = data.clone();
+        let _ = self.properties.{{prop_name}}_tx_channel.send(Some(data_to_send_to_watchers));
+
         let publisher2 = self.mqttier_client.clone();
         let topic2 = self.properties.{{prop_name}}_topic.as_ref().clone();
         let _ = tokio::spawn(async move {
@@ -249,7 +255,7 @@ impl {{stinger.rust.server_struct_name}} {
     /// 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> {
+    pub async fn run_loop(&mut self) -> Result<(), JoinError> {
         // Make sure the MqttierClient is connected and running.
         let _ = self.mqttier_client.run_loop().await;
 
@@ -260,7 +266,8 @@ impl {{stinger.rust.server_struct_name}} {
         };
 
         {%if stinger.methods|length > 0 -%}
-        let mut method_handlers = self.method_handlers.clone();
+        let method_handlers = self.method_handlers.clone();
+        self.method_handlers.lock().unwrap().initialize(self.clone()).expect("Failed to initialize method handlers");
         {%endif-%}
 
         let sub_ids = self.subscription_ids.clone();
@@ -277,12 +284,12 @@ impl {{stinger.rust.server_struct_name}} {
             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.rust.server_struct_name}}::handle_{{method_name|snake_case}}_request(publisher.clone(), &mut method_handlers, msg).await;
+                    {{stinger.rust.server_struct_name}}::handle_{{method_name|snake_case}}_request(publisher.clone(), method_handlers.clone(), msg).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.rust.server_struct_name}}::update_{{prop_name | snake_case}}_value(publisher.clone(), properties.{{prop_name | snake_case}}_topic.clone(), properties.{{prop_name | snake_case}}.clone(), msg).await;
+                    {{stinger.rust.server_struct_name}}::update_{{prop_name | snake_case}}_value(publisher.clone(), properties.{{prop_name | snake_case}}_topic.clone(), properties.{{prop_name | snake_case}}.clone(), properties.{{prop_name | snake_case}}_tx_channel.clone(), msg).await;
                 }
                 {%-endif%}{%endfor%}{# properties #}
             }
@@ -296,3 +303,17 @@ impl {{stinger.rust.server_struct_name}} {
     }
 
 }
+{%if stinger.methods|length > 0 %}
+pub trait {{stinger.name | UpperCamelCase }}MethodHandlers: Send + Sync {
+
+    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>;
+    
+    {%endfor%}
+
+    fn as_any(&self) -> &dyn Any;
+}
+{%endif%}{# methods #}

stingeripc/tools/cli.py

@@ -1,17 +1,21 @@
 
 import os
+import sys
+from wsgiref.validate import validator
 from rich import print
 from pathlib import Path
 import typer
 from typing_extensions import Annotated
 from jacobsjinjatoo import templator as jj2
-
+from jacobsjsonschema.draft7 import Validator
+import yaml
+import yamlloader
 from stingeripc.interface import StingerInterface
 
 from . import markdown_generator
 from . import python_generator
 from . import rust_generator
-
+from . import cpp_generator
 
 app = typer.Typer(help="stinger-ipc generator CLI")
 
@@ -24,13 +28,13 @@ def generate(
 ):
     """Generate code for a Stinger interface.
 
-    LANGUAGE must be one of: rust, python, markdown
+    LANGUAGE must be one of: rust, python, markdown, cpp, web
     INPUT_FILE is the .stinger.yaml file
     OUTPUT_DIR is the directory that will receive generated files
     """
     lang = language.lower()
-    if lang not in ("rust", "python", "markdown", "web"):
-        raise typer.BadParameter("language must be one of: rust, python, markdown, web")
+    if lang not in ("rust", "python", "markdown", "cpp", "web"):
+        raise typer.BadParameter("language must be one of: rust, python, markdown, cpp, web")
 
     if lang == "python":
         # python_generator.main expects Path arguments via typer
@@ -55,12 +59,34 @@ def generate(
         ]:
             ct.render_template(f"{output_file}.jinja2", output_file, stinger=stinger)
         wt.render_template("index.html.jinja2", "index.html", stinger=stinger)
-    else:  # rust
+    elif lang == "cpp":
+        cpp_generator.main(input_file, output_dir)
+    elif lang == "rust":
         rust_generator.main(input_file, output_dir)
-    
+    else:
+        raise RuntimeError("Unreachable code reached")
 
     print(f"Generation for '{lang}' completed.")
 
+@app.command()
+def validate(input_file: Annotated[Path, typer.Argument(..., exists=True, file_okay=True, dir_okay=False, readable=True)]):
+    """Validate a Stinger interface YAML file.
+
+    INPUT_FILE is the .stinger.yaml file
+    """
+    schema_file = Path(__file__).parent.parent / "schema" / "schema.yaml"
+    schema_obj = yaml.load(schema_file.open("r"), Loader=yamlloader.ordereddict.Loader)
+    validator = Validator(schema_obj, lazy_error_reporting=False)
+
+    input_obj = yaml.load(input_file.open("r"), Loader=yamlloader.ordereddict.Loader)
+    if result := validator.validate(input_obj):
+        print("Validated: ", result)
+    else:
+        for error in validator.get_errors():
+            print(error)
+        sys.exit(1)
+    sys.exit(0)
+
 @app.command()
 def hello():
     print("Hello world")

stingeripc/tools/cpp_generator.py

@@ -0,0 +1,90 @@
+from jacobsjinjatoo import templator as jj2
+import os
+import yaml
+import typer
+from typing_extensions import Annotated
+from pathlib import Path
+from rich import print
+
+from stingeripc import StingerInterface
+
+
+def main(
+    inname: Annotated[Path, typer.Argument(exists=True, file_okay=True, dir_okay=False, readable=True)],
+    outdir: Annotated[Path, typer.Argument(file_okay=False, dir_okay=True, writable=True, readable=True)],
+):
+    """Generate C++ output for a Stinger interface."""
+
+    with inname.open(mode="r") as f:
+        stinger = StingerInterface.from_yaml(f)
+
+    params = {
+        "stinger": stinger,
+        "source_files": [],
+        "header_files": [],
+    }
+
+    if outdir.is_file():
+        raise RuntimeError("Output directory is a file!")
+
+    if not outdir.is_dir():
+        outdir.mkdir(parents=True)
+
+    source_code_dir = outdir / "src"
+    source_code_dir.mkdir(parents=True, exist_ok=True)
+
+    headers_code_dir = outdir / "include"
+    headers_code_dir.mkdir(parents=True, exist_ok=True)
+
+    examples_code_dir = outdir / "examples"
+    examples_code_dir.mkdir(parents=True, exist_ok=True)
+
+    this_file = Path(__file__)
+    # The templates live under the package `stingeripc/templates/cpp` next to `tools`.
+    # compute that from the tools directory: tools -> parent (stingeripc) -> templates/cpp
+    template_dir = (this_file.parent / ".." / "templates" / "cpp").resolve()
+
+    if not template_dir.is_dir():
+        raise RuntimeError(f"C++ template directory not found: {template_dir}")
+
+    output_dir = outdir.resolve()
+    t = jj2.CodeTemplator(output_dir=output_dir)
+    t.add_template_dir(template_dir)
+
+    headers_template_dir = template_dir / "include"
+    for fname in os.listdir(headers_template_dir):
+        header_code_path = Path("include") / fname
+        if fname.endswith(".jinja2"):
+            print(f"GENERATING HEADER: {fname}")
+            header_dest_path = str(header_code_path)[:-len(".jinja2")]
+            params["header_files"].append(header_dest_path)
+            t.render_template(header_code_path, header_dest_path, **params)
+
+    src_template_dir = template_dir / "src"
+    for fname in os.listdir(src_template_dir):
+        source_code_path = Path("src") / fname
+        if fname.endswith(".jinja2"):
+            print(f"GENERATING SOURCE: {fname}")
+            source_dest_path = str(source_code_path)[:-len(".jinja2")]
+            params["source_files"].append(source_dest_path)
+            t.render_template(source_code_path, source_dest_path, **params)
+
+    example_template_dir = template_dir / "examples"
+    for fname in os.listdir(example_template_dir):
+        example_code_path = Path("examples") / fname
+        if fname.endswith(".jinja2"):
+            print(f"GENERATING EXAMPLE: {fname}")
+            example_dest_path = str(example_code_path)[:-len(".jinja2")]
+            t.render_template(example_code_path, example_dest_path, **params)
+
+    print(f"GENERATING CmakeLists")
+    t.render_template("CMakeLists.txt.jinja2", "CMakeLists.txt", **params)
+
+
+def run():
+    typer.run(main)
+
+
+if __name__ == "__main__":
+    run()
+

stingeripc/tools/rust_generator.py

@@ -35,7 +35,7 @@ def main(
     t = jj2.CodeTemplator(output_dir=outdir)
     t.add_template_dir(template_dir)
 
-    def recursive_render_templates(local_dir: str):
+    def recursive_render_templates(local_dir: str|Path):
         local_dir = Path(local_dir)
         cur_template_dir = template_dir / local_dir
         for entry in os.listdir(cur_template_dir):