refactor: Add TCP examples

Extend examples to use a TCP socket if the `--tcp` flag is provided and
add the TCP versions to `run-examples`

Signed-off-by: Kostis Papazafeiropoulos <papazof@gmail.com>

Author: papazof

example/Cargo.toml

@@ -23,7 +23,7 @@ ctrlc = { version = "3.0", features = ["termination"] }
 tokio = { version = "1.0.1", features = ["signal", "time"] }
 async-trait = "0.1.42"
 rand = "0.8.5"
-
+clap = { version = "4.5.40", features = ["derive"] }
 
 [[example]]
 name = "client"

example/async-client.rs

@@ -11,7 +11,9 @@ use ttrpc::r#async::Client;
 
 #[tokio::main(flavor = "current_thread")]
 async fn main() {
-    let c = Client::connect(utils::SOCK_ADDR).await.unwrap();
+    let sock_addr = utils::get_sock_addr();
+    let c = Client::connect(sock_addr).await.unwrap();
+
     let hc = health_ttrpc::HealthClient::new(c.clone());
     let ac = agent_ttrpc::AgentServiceClient::new(c);
 

example/async-server.rs

@@ -58,10 +58,11 @@ async fn main() {
     let hservice = health_ttrpc::create_health(Arc::new(HealthService {}));
     let aservice = agent_ttrpc::create_agent_service(Arc::new(AgentService {}));
 
-    utils::remove_if_sock_exist(utils::SOCK_ADDR).unwrap();
+    let sock_addr = utils::get_sock_addr();
+    utils::remove_if_sock_exist(sock_addr).unwrap();
 
     let mut server = Server::new()
-        .bind(utils::SOCK_ADDR)
+        .bind(sock_addr)
         .unwrap()
         .register_service(hservice)
         .register_service(aservice);

example/async-stream-client.rs

@@ -13,7 +13,9 @@ use ttrpc::r#async::Client;
 async fn main() {
     simple_logging::log_to_stderr(log::LevelFilter::Info);
 
-    let c = Client::connect(utils::SOCK_ADDR).await.unwrap();
+    let sock_addr = utils::get_sock_addr();
+    let c = Client::connect(sock_addr).await.unwrap();
+
     let sc = streaming_ttrpc::StreamingClient::new(c);
 
     let _now = std::time::Instant::now();

example/async-stream-server.rs

@@ -171,10 +171,12 @@ impl streaming_ttrpc::Streaming for StreamingService {
 async fn main() {
     simple_logging::log_to_stderr(LevelFilter::Info);
     let service = streaming_ttrpc::create_streaming(Arc::new(StreamingService {}));
-    utils::remove_if_sock_exist(utils::SOCK_ADDR).unwrap();
+
+    let sock_addr = utils::get_sock_addr();
+    utils::remove_if_sock_exist(sock_addr).unwrap();
 
     let mut server = Server::new()
-        .bind(utils::SOCK_ADDR)
+        .bind(sock_addr)
         .unwrap()
         .register_service(service);
 

example/client.rs

@@ -50,7 +50,9 @@ fn main() {
 fn connect_once() {
     simple_logging::log_to_stderr(LevelFilter::Trace);
 
-    let c = Client::connect(utils::SOCK_ADDR).unwrap();
+    let sock_addr = utils::get_sock_addr();
+    let c = Client::connect(sock_addr).unwrap();
+
     let hc = health_ttrpc::HealthClient::new(c.clone());
     let ac = agent_ttrpc::AgentServiceClient::new(c);
 

example/server.rs

@@ -58,9 +58,11 @@ fn main() {
     let hservice = health_ttrpc::create_health(Arc::new(HealthService {}));
     let aservice = agent_ttrpc::create_agent_service(Arc::new(AgentService {}));
 
-    utils::remove_if_sock_exist(utils::SOCK_ADDR).unwrap();
+    let sock_addr = utils::get_sock_addr();
+    utils::remove_if_sock_exist(sock_addr).unwrap();
+
     let mut server = ttrpc::Server::new()
-        .bind(utils::SOCK_ADDR)
+        .bind(sock_addr)
         .unwrap()
         .register_service(hservice)
         .register_service(aservice);

example/utils.rs

@@ -1,14 +1,42 @@
 #![allow(dead_code)]
+use clap::Parser;
+use log::warn;
 use std::io::Result;
 
 #[cfg(unix)]
-pub const SOCK_ADDR: &str = r"unix:///tmp/ttrpc-test";
+pub const SOCK_ADDR_LOCAL: &str = r"unix:///tmp/ttrpc-test";
 
 #[cfg(windows)]
-pub const SOCK_ADDR: &str = r"\\.\pipe\ttrpc-test";
+pub const SOCK_ADDR_LOCAL: &str = r"\\.\pipe\ttrpc-test";
+
+pub const SOCK_ADDR_TCP: &str = r"tcp://127.0.0.1:65500";
+
+#[derive(Debug, Default, Parser)]
+pub struct Cli {
+    #[arg(long = "tcp")]
+    #[arg(help = "Use a TCP socket instead of a local one")]
+    pub tcp: bool,
+}
+
+pub fn get_sock_addr() -> &'static str {
+    let cli = Cli::parse();
+    if cli.tcp {
+        if cfg!(windows) {
+            warn!("'--tcp' flag ignored; TCP sockets not supported on Windows");
+            return SOCK_ADDR_LOCAL;
+        }
+        SOCK_ADDR_TCP
+    } else {
+        SOCK_ADDR_LOCAL
+    }
+}
 
 #[cfg(unix)]
 pub fn remove_if_sock_exist(sock_addr: &str) -> Result<()> {
+    if sock_addr.starts_with("tcp://") {
+        return Ok(());
+    }
+
     let path = sock_addr
         .strip_prefix("unix://")
         .expect("socket address is not expected");

tests/run-examples.rs

@@ -4,12 +4,16 @@ use std::{
     time::Duration,
 };
 
-fn run_example(server: &str, client: &str) -> Result<(), Box<dyn std::error::Error>> {
+fn run_example(
+    server: &str,
+    client: &str,
+    args: &[&str],
+) -> Result<(), Box<dyn std::error::Error>> {
     // start the server and give it a moment to start.
-    let mut server = do_run_example(server).spawn().unwrap();
+    let mut server = do_run_example(server, args).spawn().unwrap();
     std::thread::sleep(Duration::from_secs(2));
 
-    let mut client = do_run_example(client).spawn().unwrap();
+    let mut client = do_run_example(client, args).spawn().unwrap();
     let mut client_succeeded = false;
     let start = std::time::Instant::now();
     let timeout = Duration::from_secs(600);
@@ -55,12 +59,15 @@ fn run_example(server: &str, client: &str) -> Result<(), Box<dyn std::error::Err
     Ok(())
 }
 
-fn do_run_example(example: &str) -> Command {
+fn do_run_example(example: &str, args: &[&str]) -> Command {
     let mut cmd = Command::new("cargo");
-    cmd.arg("run")
-        .arg("--example")
-        .arg(example)
-        .stdout(std::process::Stdio::piped())
+    cmd.arg("run").arg("--example").arg(example);
+
+    if !args.is_empty() {
+        cmd.arg("--").args(args);
+    }
+
+    cmd.stdout(std::process::Stdio::piped())
         .stderr(std::process::Stdio::piped())
         .current_dir("example");
     cmd
@@ -83,9 +90,18 @@ fn wait_with_output(name: &str, cmd: Child) {
 
 #[test]
 fn run_examples() -> Result<(), Box<dyn std::error::Error>> {
-    run_example("server", "client")?;
-    run_example("async-server", "async-client")?;
-    run_example("async-stream-server", "async-stream-client")?;
+    // Local
+    run_example("server", "client", &[])?;
+    run_example("async-server", "async-client", &[])?;
+    run_example("async-stream-server", "async-stream-client", &[])?;
+
+    // TCP
+    #[cfg(not(windows))]
+    {
+        run_example("server", "client", &["--tcp"])?;
+        run_example("async-server", "async-client", &["--tcp"])?;
+        run_example("async-stream-server", "async-stream-client", &["--tcp"])?;
+    }
 
     Ok(())
 }