Added ROS2-like Rust Examples

examples/python/add_two_ints_client.py → examples/python/src/add_two_ints_client.py

@@ -28,7 +28,7 @@ class AddTwoInts_Request(IdlStruct, typename="AddTwoInts_Request"):
 
 # Equivalent to AddTwoInts.Response class, but serializable by pycdr2
 @dataclass
-class AddTwoInts_Response(IdlStruct, typename="AddTwoInts_Request"):
+class AddTwoInts_Response(IdlStruct, typename="AddTwoInts_Response"):
     sum: pycdr2.types.int64
 
 def main():

examples/python/fibonnacci_action_client.py → examples/python/src/fibonnacci_action_client.py

@@ -60,7 +60,7 @@ class Fibonacci_Feedback(IdlStruct, typename="Fibonacci_Feedback"):
 def feedback_callback(sample: zenoh.Sample):
     # Deserialize the message
     feedback = Fibonacci_Feedback.deserialize(sample.payload)
-    print('Received feedback: {0}'.format(feedback.partial_sequence))
+    print('Next number in sequence received: {0}'.format(feedback.partial_sequence))
 
 
 def main():
@@ -84,6 +84,7 @@ def main():
     goal_id = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
     req = Fibonacci_SendGoal_Request(goal_id, order=10)
     # Send the query with the serialized request
+    print('Sending goal')
     replies = session.get('fibonacci/_action/send_goal', zenoh.Queue(), value=req.serialize())
     # Zenoh could get several replies for a request (e.g. from several "Service Servers" using the same name)
     for reply in replies.receiver:
@@ -93,7 +94,7 @@ def main():
             print('Goal rejected :(')
             return
 
-    print('Goal accepted :)')
+    print('Goal accepted by server, waiting for result')
 
     req = Fibonacci_GetResult_Request(goal_id)
     # Send the query with the serialized request

examples/rust/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "rust_examples"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[workspace]
+[dependencies]
+async-std = { version = "1.12.0" }
+futures = { version = "0.3.28" }
+zenoh = { version = "0.10.0-rc" }
+clap = { version = "3.2.23" }
+env_logger = { version = "0.10.0" }
+serde = {version = "1" }
+serde_derive = {version = "1"}
+cdr = {version = "0.2.4"}
+log = { version = "0.4.21"}

examples/rust/README.md

@@ -0,0 +1 @@
+TODO

examples/rust/src/bin/add_two_ints_client.rs

@@ -0,0 +1,75 @@
+//
+// Copyright (c) 2023 ZettaScale Technology
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
+// which is available at https://www.apache.org/licenses/LICENSE-2.0.
+//
+// SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
+//
+// Contributors:
+//   ZettaScale Zenoh Team, <zenoh@zettascale.tech>
+//
+use cdr::{CdrLe, Infinite};
+use clap::{App, Arg};
+use serde::{Deserialize, Serialize};
+use zenoh::config::Config;
+use zenoh::prelude::r#async::*;
+
+#[derive(Serialize, PartialEq, Debug)]
+struct AddTwoIntsRequest {
+    a: i64,
+    b: i64,
+}
+
+#[derive(Deserialize, PartialEq, Debug)]
+struct AddTwoIntsResponse {
+    sum: i64,
+}
+
+#[async_std::main]
+async fn main() {
+    env_logger::init();
+
+    let config = parse_args();
+
+    let session = zenoh::open(config).res().await.unwrap();
+
+    let req = AddTwoIntsRequest { a: 2, b: 3 };
+    let buf = cdr::serialize::<_, _, CdrLe>(&req, Infinite).unwrap();
+    let replies = session
+        .get("add_two_ints")
+        .with_value(buf)
+        .res()
+        .await
+        .unwrap();
+
+    while let Ok(reply) = replies.recv_async().await {
+        match cdr::deserialize_from::<_, AddTwoIntsResponse, _>(
+            reply.sample.unwrap().payload.reader(),
+            cdr::size::Infinite,
+        ) {
+            Ok(res) => {
+                println!("Result of add_two_ints: {}", res.sum);
+            }
+            Err(e) => log::warn!("Error decoding message: {}", e),
+        }
+    }
+}
+
+fn parse_args() -> Config {
+    let args = App::new("zenoh sub example")
+        .arg(Arg::from_usage(
+            "-c, --config=[FILE]      'A configuration file.'",
+        ))
+        .get_matches();
+
+    let config = if let Some(conf_file) = args.value_of("config") {
+        Config::from_file(conf_file).unwrap()
+    } else {
+        Config::default()
+    };
+
+    config
+}

examples/rust/src/bin/fibonnacci_action_client.rs

@@ -0,0 +1,150 @@
+//
+// Copyright (c) 2023 ZettaScale Technology
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
+// which is available at https://www.apache.org/licenses/LICENSE-2.0.
+//
+// SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
+//
+// Contributors:
+//   ZettaScale Zenoh Team, <zenoh@zettascale.tech>
+//
+use cdr::{CdrLe, Infinite};
+use clap::{App, Arg};
+use serde::{Deserialize, Serialize};
+use zenoh::config::Config;
+use zenoh::prelude::r#async::*;
+
+#[derive(Deserialize, PartialEq, Debug)]
+struct Time {
+    sec: u32,
+    nsec: u32,
+}
+
+#[derive(Serialize, PartialEq, Debug)]
+struct FibonacciSendGoalRequest {
+    goal_id: [u8; 16],
+    order: i32,
+}
+
+#[derive(Deserialize, PartialEq, Debug)]
+struct FibonacciSendGoalResponse {
+    accepted: bool,
+    stamp: Time,
+}
+
+#[derive(Serialize, PartialEq, Debug)]
+struct FibonacciGetResultRequest {
+    goal_id: [u8; 16],
+}
+
+#[derive(Deserialize, PartialEq, Debug)]
+struct FibonacciGetResultResponse {
+    status: i8,
+    sequence: Vec<i32>,
+}
+
+#[derive(Deserialize, PartialEq, Debug)]
+struct FibonacciFeedback {
+    goal_id: [u8; 16],
+    partial_sequence: Vec<i32>,
+}
+
+#[async_std::main]
+async fn main() {
+    env_logger::init();
+
+    let config = parse_args();
+
+    let session = zenoh::open(config).res().await.unwrap();
+
+    let _subscriber = session
+        .declare_subscriber("fibonacci/_action/feedback")
+        .callback(|sample| {
+            match cdr::deserialize_from::<_, FibonacciFeedback, _>(
+                sample.value.payload.reader(),
+                cdr::size::Infinite,
+            ) {
+                Ok(msg) => {
+                    println!(
+                        "Next number in sequence received: {:?}",
+                        msg.partial_sequence
+                    );
+                }
+                Err(e) => log::warn!("Error decoding message: {}", e),
+            };
+        })
+        .res()
+        .await
+        .unwrap();
+
+    let goal_id: [u8; 16] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
+    let req = FibonacciSendGoalRequest {
+        goal_id: goal_id,
+        order: 10,
+    };
+
+    let buf = cdr::serialize::<_, _, CdrLe>(&req, Infinite).unwrap();
+    println!("Sending goal");
+    let replies = session
+        .get("fibonacci/_action/send_goal")
+        .with_value(buf)
+        .res()
+        .await
+        .unwrap();
+
+    while let Ok(reply) = replies.recv_async().await {
+        match cdr::deserialize_from::<_, FibonacciSendGoalResponse, _>(
+            reply.sample.unwrap().payload.reader(),
+            cdr::size::Infinite,
+        ) {
+            Ok(res) => {
+                if res.accepted {
+                    println!("Goal accepted by server, waiting for result");
+                } else {
+                    println!("Goal rejected :(");
+                    return;
+                }
+            }
+            Err(e) => log::warn!("Error decoding message: {}", e),
+        }
+    }
+
+    let req = FibonacciGetResultRequest { goal_id: goal_id };
+    let buf = cdr::serialize::<_, _, CdrLe>(&req, Infinite).unwrap();
+    let replies = session
+        .get("fibonacci/_action/get_result")
+        .with_value(buf)
+        .res()
+        .await
+        .unwrap();
+    while let Ok(reply) = replies.recv_async().await {
+        match cdr::deserialize_from::<_, FibonacciGetResultResponse, _>(
+            reply.sample.unwrap().payload.reader(),
+            cdr::size::Infinite,
+        ) {
+            Ok(res) => {
+                println!("Result: {:?}", res.sequence);
+            }
+            Err(e) => log::warn!("Error decoding message: {}", e),
+        }
+    }
+}
+
+fn parse_args() -> Config {
+    let args = App::new("zenoh sub example")
+        .arg(Arg::from_usage(
+            "-c, --config=[FILE]      'A configuration file.'",
+        ))
+        .get_matches();
+
+    let config = if let Some(conf_file) = args.value_of("config") {
+        Config::from_file(conf_file).unwrap()
+    } else {
+        Config::default()
+    };
+
+    config
+}

examples/rust/src/bin/listener.rs

@@ -0,0 +1,64 @@
+//
+// Copyright (c) 2023 ZettaScale Technology
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
+// which is available at https://www.apache.org/licenses/LICENSE-2.0.
+//
+// SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
+//
+// Contributors:
+//   ZettaScale Zenoh Team, <zenoh@zettascale.tech>
+//
+use clap::{App, Arg};
+use serde::Deserialize;
+use zenoh::config::Config;
+use zenoh::prelude::r#async::*;
+
+#[derive(Deserialize, PartialEq, Debug)]
+struct Message {
+    data: String,
+}
+#[async_std::main]
+async fn main() {
+    // Initiate logging
+    env_logger::init();
+
+    let config = parse_args();
+
+    println!("Opening session...");
+    let session = zenoh::open(config).res().await.unwrap();
+
+    let key_expr = "chatter";
+    println!("Declaring Subscriber on '{}'...", &key_expr);
+    let subscriber = session.declare_subscriber(key_expr).res().await.unwrap();
+
+    while let Ok(sample) = subscriber.recv_async().await {
+        match cdr::deserialize_from::<_, Message, _>(
+            sample.value.payload.reader(),
+            cdr::size::Infinite,
+        ) {
+            Ok(msg) => {
+                println!("I heard: [{}]", msg.data);
+            }
+            Err(e) => log::warn!("Error decoding message: {}", e),
+        }
+    }
+}
+
+fn parse_args() -> Config {
+    let args = App::new("zenoh sub example")
+        .arg(Arg::from_usage(
+            "-c, --config=[FILE]      'A configuration file.'",
+        ))
+        .get_matches();
+
+    let config = if let Some(conf_file) = args.value_of("config") {
+        Config::from_file(conf_file).unwrap()
+    } else {
+        Config::default()
+    };
+
+    config
+}