refactored args parsing in examples, fixed build issue on benches

eclipse-zenoh · Jul 10, 2020 · 6cfc35d · 6cfc35d
1 parent af4f6b9
commit 6cfc35d
Show file tree

Hide file tree

Showing 18 changed files with 201 additions and 104 deletions.
diff --git a/plugins/zenoh-http/examples/zenoh-net/zn_serve_sse.rs b/plugins/zenoh-http/examples/zenoh-net/zn_serve_sse.rs
@@ -32,20 +32,27 @@ if(typeof(EventSource) !== "undefined") {
 }
 </script>"#;
 
+//
+// Argument parsing -- look at the main for the zenoh-related code
+//
+fn parse_args() -> Config {
+  let args = App::new("zenoh-net ssl server example")
+    .arg(Arg::from_usage("-m, --mode=[MODE] 'The zenoh session mode.")
+        .possible_values(&["peer", "client"]).default_value("peer"))
+    .arg(Arg::from_usage("-e, --peer=[LOCATOR]...  'Peer locators used to initiate the zenoh session.'"))
+    .get_matches();
+
+  Config::default()
+    .mode(args.value_of("mode").map(|m| Config::parse_mode(m)).unwrap().unwrap())
+    .add_peers(args.values_of("peer").map(|p| p.collect()).or_else(|| Some(vec![])).unwrap())
+}
+
 #[async_std::main]
 async fn main() {
     // initiate logging
     env_logger::init();
 
-    let args = App::new("zenoh-net ssl server example")
-      .arg(Arg::from_usage("-m, --mode=[MODE] 'The zenoh session mode.")
-          .possible_values(&["peer", "client"]).default_value("peer"))
-      .arg(Arg::from_usage("-e, --peer=[LOCATOR]...  'Peer locators used to initiate the zenoh session.'"))
-      .get_matches();
-
-    let config = Config::new()
-      .mode(args.value_of("mode").map(|m| Config::into_mode(m)).unwrap().unwrap())
-      .add_peers(args.values_of("peer").map(|p| p.collect()).or_else(|| Some(vec![])).unwrap());
+    let config = parse_args();
     let path    = "/demo/sse";
     let value   = "Pub from sse server!";
 

diff --git a/zenoh-ffi/src/lib.rs b/zenoh-ffi/src/lib.rs
@@ -71,8 +71,13 @@ pub unsafe extern "C" fn zn_properties_free(rps: *mut ZProperties ) {
 pub unsafe extern "C" fn zn_open(mode: c_int, locator: *const c_char, _ps: *const ZProperties) -> *mut ZNSession {  
 
   let s = task::block_on(async move {
-    let c = Config::new().mode(mode as u64);    
-    let config = if !locator.is_null() { c.add_peer(CStr::from_ptr(locator).to_str().unwrap()) } else { c };        
+    let c : Config = Default::default();    
+    let config = if !locator.is_null() { 
+      c
+        .mode(mode as u64)
+        .add_peer(CStr::from_ptr(locator).to_str().unwrap()) 
+      } else { c.mode(mode as u64) };
+
     open(config, None).await
   }).unwrap();
   Box::into_raw(Box::new(ZNSession(s)))

diff --git a/zenoh-protocol/src/core/mod.rs b/zenoh-protocol/src/core/mod.rs
@@ -37,7 +37,6 @@ pub mod whatami {
     // b4-b13: Reserved
 }
 
-
 pub type ResourceId = ZInt;
 
 pub const NO_RESOURCE_ID: ResourceId = 0;

diff --git a/zenoh-protocol/tests/channel.rs b/zenoh-protocol/tests/channel.rs
@@ -17,10 +17,10 @@ use async_trait::async_trait;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::time::Duration;
 
-use zenoh_protocol::core::{AtomicZInt, PeerId, ResKey, ZInt};
+use zenoh_protocol::core::*;
 use zenoh_protocol::io::RBuf;
 use zenoh_protocol::link::Locator;
-use zenoh_protocol::proto::{ZenohMessage, SeqNum, WhatAmI, whatami};
+use zenoh_protocol::proto::{ZenohMessage, SeqNum};
 use zenoh_protocol::session::{MsgHandler, SessionHandler, SessionManager, SessionManagerConfig, SessionManagerOptionalConfig};
 use zenoh_util::zasynclock;
 use zenoh_util::core::ZResult;

diff --git a/zenoh-protocol/tests/session.rs b/zenoh-protocol/tests/session.rs
@@ -18,7 +18,7 @@ use std::time::Duration;
 
 use zenoh_protocol::core::{PeerId, ZInt};
 use zenoh_protocol::link::Locator;
-use zenoh_protocol::proto::{WhatAmI, whatami};
+use zenoh_protocol::core::{WhatAmI, whatami};
 use zenoh_protocol::session::{
     DummyHandler,
     MsgHandler,

diff --git a/zenoh-router/benches/tables_bench.rs b/zenoh-router/benches/tables_bench.rs
@@ -18,7 +18,8 @@ use async_std::task;
 use async_std::sync::Arc;
 use criterion::{Criterion, BenchmarkId};
 use zenoh_protocol::io::RBuf;
-use zenoh_protocol::proto::{Mux, SubInfo, Reliability, SubMode, whatami};
+use zenoh_protocol::core::{SubInfo, Reliability, SubMode, whatami};
+use zenoh_protocol::proto::{Mux};
 use zenoh_protocol::session::DummyHandler;
 use zenoh_router::routing::broker::Tables;
 use zenoh_router::routing::resource::*;

diff --git a/zenoh-router/src/runtime/mod.rs b/zenoh-router/src/runtime/mod.rs
@@ -116,11 +116,7 @@ impl Config {
             multicast_interface: "auto".to_string(),
             scouting_delay: Duration::new(0, 250_000_000),
         }
-    }
-
-    pub fn new() -> Config {
-        Config::default(whatami::PEER)        
-    }
+    }        
 
     pub fn mode(mut self, w: whatami::Type) -> Self {
         self.whatami = w;
@@ -165,7 +161,7 @@ impl Config {
         self
     }
 
-    pub fn into_mode(m: &str) -> Result<whatami::Type, ()> {
+    pub fn parse_mode(m: &str) -> Result<whatami::Type, ()> {
         match m {
             "peer" => Ok(whatami::PEER),
             "client" => Ok(whatami::CLIENT),
@@ -176,6 +172,11 @@ impl Config {
     }
 }
 
+impl Default for Config {
+    fn default() -> Config {
+        Config::default(whatami::PEER)
+    }
+}
 impl fmt::Display for Config {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Debug::fmt(self, f)

diff --git a/zenoh-router/tests/tables.rs b/zenoh-router/tests/tables.rs
@@ -16,9 +16,9 @@ use async_std::task;
 use async_trait::async_trait;
 use std::convert::TryInto;
 use zenoh_protocol::core::rname::intersect;
-use zenoh_protocol::core::{ResKey, ZInt, PeerId};
+use zenoh_protocol::core::*;
 use zenoh_protocol::io::RBuf;
-use zenoh_protocol::proto::{Primitives, Mux, Reliability, SubMode, SubInfo, QueryConsolidation, QueryTarget, whatami};
+use zenoh_protocol::proto::{Primitives, Mux};
 use zenoh_protocol::session::DummyHandler;
 use zenoh_router::routing::broker::*;
 

diff --git a/zenoh/examples/zenoh-net/zn_eval.rs b/zenoh/examples/zenoh-net/zn_eval.rs
@@ -17,11 +17,10 @@ use futures::select;
 use zenoh::net::*;
 use zenoh::net::queryable::EVAL;
 
-#[async_std::main]
-async fn main() {
-    // initiate logging
-    env_logger::init();
-
+//
+// Argument parsing -- look at the main for the zenoh-related code
+//
+fn parse_args() -> (Config, String, String) {
     let args = App::new("zenoh-net eval example")
         .arg(Arg::from_usage("-m, --mode=[MODE] 'The zenoh session mode.")
             .possible_values(&["peer", "client"]).default_value("peer"))
@@ -32,12 +31,21 @@ async fn main() {
             .default_value("Eval from Rust!"))
         .get_matches();
 
-    let config = Config::new()
-        .mode(args.value_of("mode").map(|m| Config::into_mode(m)).unwrap().unwrap())
+    let config = Config::default()
+        .mode(args.value_of("mode").map(|m| Config::parse_mode(m)).unwrap().unwrap())
         .add_peers(args.values_of("peer").map(|p| p.collect()).or_else(|| Some(vec![])).unwrap());
     let path    = args.value_of("path").unwrap().to_string();
     let value   = args.value_of("value").unwrap().to_string();
 
+    (config, path.to_string(), value.to_string())
+}
+#[async_std::main]
+async fn main() {
+    // initiate logging
+    env_logger::init();
+
+    let (config, path, value) = parse_args();
+
     println!("Openning session...");
     let session = open(config, None).await.unwrap();
 

diff --git a/zenoh/examples/zenoh-net/zn_info.rs b/zenoh/examples/zenoh-net/zn_info.rs
@@ -14,21 +14,28 @@
 use clap::{App, Arg};
 use zenoh::net::*;
 
-#[async_std::main]
-async fn main() {
-    // initiate logging
-    env_logger::init();
-
+//
+// Argument parsing -- look at the main for the zenoh-related code
+//
+fn parse_args() -> Config {
     let args = App::new("zenoh-net info example")
         .arg(Arg::from_usage("-m, --mode=[MODE] 'The zenoh session mode.")
             .possible_values(&["peer", "client"]).default_value("peer"))
         .arg(Arg::from_usage("-e, --peer=[LOCATOR]...  'Peer locators used to initiate the zenoh session.'"))
         .get_matches();
-
-    let config = Config::new()
-        .mode(args.value_of("mode").map(|m| Config::into_mode(m)).unwrap().unwrap())
-        .add_peers(args.values_of("peer").map(|p| p.collect()).or_else(|| Some(vec![])).unwrap());
 
+    Config::default()    
+        .mode(args.value_of("mode").map(|m| Config::parse_mode(m)).unwrap().unwrap())
+        .add_peers(args.values_of("peer").map(|p| p.collect()).or_else(|| Some(vec![])).unwrap())        
+}
+
+#[async_std::main]
+async fn main() {
+    // initiate logging
+    env_logger::init();
+
+    let config : Config = parse_args();
+
     let mut ps = Properties::new();
     ps.insert(ZN_USER_KEY, b"user".to_vec());
     ps.insert(ZN_PASSWD_KEY, b"password".to_vec());

diff --git a/zenoh/examples/zenoh-net/zn_pub.rs b/zenoh/examples/zenoh-net/zn_pub.rs
@@ -14,11 +14,10 @@
 use clap::{App, Arg};
 use zenoh::net::*;
 
-#[async_std::main]
-async fn main() {
-    // initiate logging
-    env_logger::init();
-
+//
+// Argument parsing -- look at the main for the zenoh-related code
+//
+fn parse_args() -> (Config, String, String) {
     let args = App::new("zenoh-net pub example")
         .arg(Arg::from_usage("-m, --mode=[MODE] 'The zenoh session mode.")
             .possible_values(&["peer", "client"]).default_value("peer"))
@@ -29,12 +28,22 @@ async fn main() {
             .default_value("Pub from Rust!"))
         .get_matches();
 
-    let config = Config::new()
-        .mode(args.value_of("mode").map(|m| Config::into_mode(m)).unwrap().unwrap())
+    let config = Config::default()
+        .mode(args.value_of("mode").map(|m| Config::parse_mode(m)).unwrap().unwrap())
         .add_peers(args.values_of("peer").map(|p| p.collect()).or_else(|| Some(vec![])).unwrap());
     let path    = args.value_of("path").unwrap();
     let value   = args.value_of("value").unwrap();
 
+    (config, path.to_string(), value.to_string())
+}
+
+#[async_std::main]
+async fn main() {
+    // initiate logging
+    env_logger::init();
+
+    let (config, path, value) = parse_args();
+
     println!("Openning session...");
     let session = open(config, None).await.unwrap();
 

diff --git a/zenoh/examples/zenoh-net/zn_pub_thr.rs b/zenoh/examples/zenoh-net/zn_pub_thr.rs
@@ -15,22 +15,31 @@ use clap::{App, Arg};
 use zenoh::net::*;
 use zenoh::net::ResKey::*;
 
+//
+// Argument parsing -- look at the main for the zenoh-related code
+//
+fn parse_args() -> (Config, usize)  {
+    let args = App::new("zenoh-net throughput pub example")
+    .arg(Arg::from_usage("-m, --mode=[MODE] 'The zenoh session mode.")
+        .possible_values(&["peer", "client"]).default_value("peer"))
+    .arg(Arg::from_usage("-e, --peer=[LOCATOR]...  'Peer locators used to initiate the zenoh session.'"))
+    .arg(Arg::from_usage("<PAYLOAD_SIZE>          'Sets the size of the payload to publish'"))
+    .get_matches();
+
+    let config = Config::default()
+        .mode(args.value_of("mode").map(|m| Config::parse_mode(m)).unwrap().unwrap())
+        .add_peers(args.values_of("peer").map(|p| p.collect()).or_else(|| Some(vec![])).unwrap());
+
+    let size    = args.value_of("PAYLOAD_SIZE").unwrap().parse::<usize>().unwrap();
+
+    (config, size)
+}
+
 #[async_std::main]
 async fn main() {
     // initiate logging
     env_logger::init();
-
-    let args = App::new("zenoh-net throughput pub example")
-        .arg(Arg::from_usage("-m, --mode=[MODE] 'The zenoh session mode.")
-            .possible_values(&["peer", "client"]).default_value("peer"))
-        .arg(Arg::from_usage("-e, --peer=[LOCATOR]...  'Peer locators used to initiate the zenoh session.'"))
-        .arg(Arg::from_usage("<PAYLOAD_SIZE>          'Sets the size of the payload to publish'"))
-        .get_matches();
-
-    let config = Config::new()
-        .mode(args.value_of("mode").map(|m| Config::into_mode(m)).unwrap().unwrap())
-        .add_peers(args.values_of("peer").map(|p| p.collect()).or_else(|| Some(vec![])).unwrap());
-    let size    = args.value_of("PAYLOAD_SIZE").unwrap().parse::<usize>().unwrap();
+    let (config, size) = parse_args();
 
     let data: RBuf = (0usize..size).map(|i| (i%10) as u8).collect::<Vec<u8>>().into();
 

diff --git a/zenoh/examples/zenoh-net/zn_pull.rs b/zenoh/examples/zenoh-net/zn_pull.rs
@@ -16,11 +16,10 @@ use futures::prelude::*;
 use futures::select;
 use zenoh::net::*;
 
-#[async_std::main]
-async fn main() {
-    // initiate logging
-    env_logger::init();
-
+//
+// Argument parsing -- look at the main for the zenoh-related code
+//
+fn parse_args() -> (Config, String)  {
     let args = App::new("zenoh-net pull example")
         .arg(Arg::from_usage("-m, --mode=[MODE]  'The zenoh session mode.")
             .possible_values(&["peer", "client"]).default_value("peer"))
@@ -29,11 +28,22 @@ async fn main() {
             .default_value("/demo/example/**"))
         .get_matches();
 
-    let config = Config::new()
-        .mode(args.value_of("mode").map(|m| Config::into_mode(m)).unwrap().unwrap())
+    let config = Config::default()
+        .mode(args.value_of("mode").map(|m| Config::parse_mode(m)).unwrap().unwrap())
         .add_peers(args.values_of("peer").map(|p| p.collect()).or_else(|| Some(vec![])).unwrap());
+
     let selector = args.value_of("selector").unwrap().to_string();
 
+    (config, selector.to_string())
+}
+
+#[async_std::main]
+async fn main() {
+    // initiate logging
+    env_logger::init();
+
+    let (config, selector) = parse_args();
+
     println!("Openning session...");
     let session = open(config, None).await.unwrap();
 

diff --git a/zenoh/examples/zenoh-net/zn_query.rs b/zenoh/examples/zenoh-net/zn_query.rs
@@ -17,11 +17,10 @@ use clap::{App, Arg};
 use futures::prelude::*;
 use zenoh::net::*;
 
-#[async_std::main]
-async fn main() {
-    // initiate logging
-    env_logger::init();
-
+//
+// Argument parsing -- look at the main for the zenoh-related code
+//
+fn parse_args() -> (Config, String)  {
     let args = App::new("zenoh-net query example")
         .arg(Arg::from_usage("-m, --mode=[MODE]  'The zenoh session mode.")
             .possible_values(&["peer", "client"]).default_value("peer"))
@@ -30,11 +29,22 @@ async fn main() {
             .default_value("/demo/example/**"))
         .get_matches();
 
-    let config = Config::new()
-        .mode(args.value_of("mode").map(|m| Config::into_mode(m)).unwrap().unwrap())
+    let config = Config::default()
+        .mode(args.value_of("mode").map(|m| Config::parse_mode(m)).unwrap().unwrap())
         .add_peers(args.values_of("peer").map(|p| p.collect()).or_else(|| Some(vec![])).unwrap());
+
     let selector = args.value_of("selector").unwrap().to_string();
 
+    (config, selector.to_string())
+}
+
+#[async_std::main]
+async fn main() {
+    // initiate logging
+    env_logger::init();
+
+    let (config, selector) = parse_args();
+
     println!("Openning session...");
     let session = open(config, None).await.unwrap();