listener and sending support

Author: seun-ja

src/cli.rs

@@ -13,6 +13,10 @@ pub struct Args {
     /// Node's role
     #[arg(short, long, default_value_t = Role::Sender)]
     pub role: Role,
+
+    /// Node's address
+    #[arg(short, long, default_value_t = String::from("127.0.0.1:8000"))]
+    pub address: String,
 }
 
 #[derive(Clone, Debug, ValueEnum)]

src/comms/message.rs

@@ -1,4 +1,27 @@
-#[derive(Debug)]
+use std::fmt::Display;
+
+use serde::Serialize;
+
+#[derive(Debug, Serialize)]
 pub enum Message {
     RememeberMe,
+    Comms(String),
+}
+
+impl From<String> for Message {
+    fn from(s: String) -> Self {
+        match s.as_str() {
+            "RememeberMe" => Message::RememeberMe,
+            s => Message::Comms(s.to_owned()),
+        }
+    }
+}
+
+impl Display for Message {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Message::RememeberMe => write!(f, "RememeberMe"),
+            Message::Comms(s) => write!(f, "{s}"),
+        }
+    }
 }

src/lib.rs

@@ -1,5 +1,6 @@
 pub mod cli;
 pub mod comms;
+pub mod storage;
 
 pub mod tracing {
     use tracing_subscriber::{EnvFilter, layer::SubscriberExt as _};

src/main.rs

@@ -1,10 +1,13 @@
 use std::{
-    io::Read,
-    net::{Ipv4Addr, SocketAddrV4, TcpListener},
+    io::{self, Read, Write as _},
+    net::{Ipv4Addr, SocketAddrV4, TcpListener, TcpStream},
 };
 
 use clap::Parser as _;
-use peer_node::cli::Args;
+use peer_node::{
+    cli::{Args, Role},
+    comms::message::Message,
+};
 
 #[tokio::main]
 async fn main() -> Result<(), std::io::Error> {
@@ -17,12 +20,35 @@ async fn main() -> Result<(), std::io::Error> {
     tracing::info!("Node address: {}", address);
     tracing::info!("A {}", args.role);
 
-    loop {
-        for mut incoming_stream in listerner.incoming().flatten() {
-            let mut msg = [0; 16];
-            let _byte_count = incoming_stream.read(&mut msg)?;
+    match args.role {
+        Role::Receiver => loop {
+            for mut incoming_stream in listerner.incoming().flatten() {
+                let mut msg = [0; 5];
+                let _byte_count = incoming_stream.read(&mut msg)?;
+
+                let msg: Message = String::from_utf8_lossy(&msg).trim().to_string().into();
+
+                // If it's a rememberMe, store to some DHT and if Comms: Act as instructed
+
+                tracing::info!("Message received: {msg:?}");
+            }
+        },
+        Role::Sender => {
+            let mut msg = String::new();
+            io::stdin().read_line(&mut msg)?;
+
+            tracing::info!("Sending: {msg}");
+
+            let mut outgoing_stream = TcpStream::connect(args.address)?;
+
+            let msg: Message = msg.into();
+
+            outgoing_stream.write_all(msg.to_string().as_bytes())?;
+
+            // Wait for the message to be sent before exiting
+            outgoing_stream.flush()?;
 
-            tracing::info!("Message received: {:?}", msg);
+            Ok(())
         }
     }
 }