(rust) get tcpstream peer address

rust/src/main.rs

@@ -1,63 +1,38 @@
 #![allow(dead_code, unused)]
 
-use axum::{extract::{Extension, Json, Path}, routing::{get, post}, Router};
+use std::net::{IpAddr, SocketAddr, TcpStream};
+
+use clap::Parser;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use tokio::{fs, net::TcpListener, sync::mpsc};
+use tokio::{fs, io::AsyncWriteExt, net::TcpListener, sync::mpsc};
 
-#[derive(Clone, Debug, Deserialize, Serialize)]
+#[derive(Clone, Debug, Parser)]
-pub struct Status {
+pub struct Args {
-    pub id: u64,
+    #[arg(long, default_value_t = false)]
-    pub name: String,
+    pub host: bool,
-    pub data: Vec<u8>,
+
+    #[arg(short, long)]
+    pub address: SocketAddr,
 }
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
-    let (log_sender, mut log_receiver): (mpsc::Sender<String>, mpsc::Receiver<String>) = mpsc::channel(4);
+    let args: Args = Parser::parse();
-    let listener: TcpListener = TcpListener::bind("127.0.0.1:8080").await?;
-    let service: Router = Router::new()
-        .route("/", get(|| async {"hier ist nichts"}))
-        .route("/status", get(get_status).post(create_status))
-        .layer(Extension(log_sender));
 
-    tokio::spawn(log_task(log_receiver));
+    if args.host {
+        let listener: TcpListener = TcpListener::bind(args.address).await?;
 
-    axum::serve(listener, service).await.unwrap();
+        loop {
+            if let Ok((mut stream, _)) = listener.accept().await {
+                println!("local address = {}, peer address = {}", stream.local_addr()?, stream.peer_addr()?);
+                stream.shutdown();
+            }
+        }
+    } else {
+        let mut stream: TcpStream = TcpStream::connect(args.address)?;
+    }
 
     Ok(())
 }
 
-async fn get_status(Extension(logger): Extension<mpsc::Sender<String>>) -> Json<String> {
-    let input: String = match fs::read_to_string("./test_status.json").await {
-        Ok(value) => value,
-        Err(error) => {
-            _ = logger.send(format!("no file `test_status.json` found")).await;
-            return Json(format!("failed to read status: {}", error));
-        }
-    };
-    let mut status: Vec<Status> = match serde_json::from_str(&input) {
-        Ok(value) => value,
-        Err(error) => {
-            _ = logger.send(format!("can't parse file `test_status.json`")).await;
-            return Json(format!("failed to parse 'json' file: {}", error));
-        }
-    };
-
-    Json(serde_json::to_string_pretty(&status).unwrap())
-}
-
-async fn create_status(Extension(logger): Extension<mpsc::Sender<String>>) -> Json<String> {
-    _ = logger.send(format!("BLARGH?")).await;
-
-    Json(format!("PATIENCE!"))
-}
-
-async fn log_task(mut receiver: mpsc::Receiver<String>) -> () {
-    while !receiver.is_closed() {
-        match receiver.recv().await {
-            Some(log) => println!("{log}"),
-            None => break,
-        }
-    }
-}