updated gitignore

.gitignore

@@ -1 +1,2 @@
 /target
+/src/main-backup.rs

Cargo.toml

@@ -18,10 +18,14 @@ path = "src/bin/client.rs"
 [dependencies]
 rand = "0.9.0-beta.1"
 clap = "4.5.23"
-tokio = { version = "1.42.0", features = ["full"] }
+tokio = { version = "1.42.0", features = ["full", "tracing"] }
+console-subscriber = "0.1.5"
 anyhow = "1.0.95"
 serde_json = "1.0.135"
 serde = { version = "1.0.217", features = ["derive"] }
 sha256 = "1.5.0"
 petname = "2.0.2"
 crossterm = "0.28.1"
+tracing = "0.1.41"
+tracing-subscriber = "0.3.19"
+

src/bin/client.rs

@@ -9,6 +9,7 @@ use crossterm::{
     },
     event::Event,
 };
+use tokio::io::{self, AsyncReadExt, AsyncWriteExt};
 
 #[allow(unreachable_code)]
 #[tokio::main]
@@ -22,44 +23,52 @@ pub async fn main() -> anyhow::Result<()> {
     //     Clear(ClearType::All),
     // )?;
 
-    // tokio::task::spawn(async move {
+    let (mut rd, mut wr) = io::split(client.stream);
-        client.send_message(Message::new(&local_address.to_string(), MessageKind::Test, "test json").unwrap()).await.expect("failed to write to socket");
 
-        // let (mut rd, mut wr) = client.stream.split();
+    let mut buf: Vec<u8> = Vec::with_capacity(4);
+    let mut message_reader = MessageReader::new();
 
-        // let mut message_reader = MessageReader::new();
+    loop {
-    
+        match rd.read_exact(&mut buf).await {
-        // 'handler: loop {
+            Ok(0) => {
-        //     let mut buffer = vec![];
+                println!("connection closed by server");
-        //     if tokio::io::copy(&mut rd, &mut buffer).await.is_err() {
+                continue;
-        //         println!("failed to copy");
+            },
-        //     }
+            Ok(n) => {
+                let mut buf = Vec::with_capacity(n);
+                rd.read_exact(&mut buf).await?;
+                let message = message_reader.read(&buf)?;
+                println!("{:?}", message);
+            },
+            Err(e) => eprintln!("failed reading from socket: {}", e),
+        }
+    }
 
+    // loop {
+    //     let n = rd.read_exact(&mut buf).await.expect("fallito lettura");
 
-        //     let message =  message_reader.read(&buffer).expect("failed to read from socket");
+    //     if n == 0 {
-        //     println!("{:?}", message);
+    //         break;
-
-        //     break 'handler;
-        // }
-    // });
-    // client.send_message(Message::new(&local_address.to_string(), MessageKind::Test, "test json").unwrap()).await?;
-
-    // let (mut rd, mut wr) = client.stream.split();
-
-    // let mut message_reader = MessageReader::new();
-    
-    // 'handler: loop {
-    //     let mut buffer = vec![];
-    //     if tokio::io::copy(&mut rd, &mut buffer).await.is_err() {
-    //         println!("failed to copy");
     //     }
 
-    //     let message =  message_reader.read(&buffer)?;
+    //     let message =  message_reader.read(&buf)?;
-    //     println!("{:?}", message);
+    //     println!("GOT {:?}", message);
 
-    //     break 'handler;
+    //     let response = match &message.message_kind {
+    //         MessageKind::Test => Message::new(&local_address.to_string(), MessageKind::Test, "risposta")?.as_bytes_vec()?,
+    //         MessageKind::Move => todo!(),
+    //         MessageKind::CreatePlayer => todo!(),
+    //         MessageKind::CreateLobby => todo!(),
+    //     };
+
+    //     wr.write_all(&response.as_bytes()).await?;
+
+    //     buf.clear();
+    //     message_reader.buffer.clear();
+    //     break;
     // }
 
     // disable_raw_mode()?;
+
     Ok(())
 }

src/bin/server.rs

@@ -2,6 +2,9 @@ use lib::server::Server;
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
+    console_subscriber::init();
+    // tracing::subscriber::set_global_default(subscriber)?;
+
     let mut server = Server::new("127.0.0.1", 8080);
     server.run().await?;
     Ok(())

src/message.rs

@@ -4,8 +4,9 @@ use serde::{Deserialize, Serialize};
 pub struct Message {
     pub from: String,
     pub message_kind: MessageKind,
-    pub length: u16,
     pub content: String,
+    // placeholder for the future
+    // pub previous: String,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -20,12 +21,10 @@ impl Message {
     pub fn new(from: &str, message_kind: MessageKind, content: impl Into<String>) -> anyhow::Result<Self> {
         let from = from.into();
         let content = content.into();
-        let length = content.len() as u16;
 
         Ok(Self {
             from,
             message_kind,
-            length,
             content,
         })
     }
@@ -41,4 +40,16 @@ impl Message {
 
         Ok(message)
     }
+
+    pub fn as_bytes_vec(&self) -> anyhow::Result<Vec<u8>> {
+        let message_json = self.encode()?;
+        let message_bytes: &[u8] = message_json.as_bytes();
+        let bytes_length: u32 = message_bytes.len() as u32;
+
+        let mut buffer = Vec::new();
+        buffer.extend(bytes_length.to_be_bytes());
+        buffer.extend(message_bytes);
+
+        Ok(buffer)
+    }
 }

src/server.rs

@@ -1,7 +1,10 @@
-use tokio::{io::{AsyncReadExt, AsyncWriteExt, BufReader}, net::{tcp::WriteHalf, TcpListener}};
+use tokio::{io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader}, net::{tcp::WriteHalf, TcpListener}, sync::mpsc};
-use std::net::SocketAddr;
+use tokio::sync::broadcast;
+use std::{collections::HashMap, net::SocketAddr};
+use tokio::net::TcpStream;
 use crate::{message::{Message, MessageKind}, message_read::MessageReader, server};
 
+#[derive(Debug)]
 pub struct Server {
     pub host: String,
     pub port: u16,
@@ -15,7 +18,34 @@ impl Server {
         }
     }
 
+    async fn process_connection(mut stream: TcpStream, addr: SocketAddr) -> anyhow::Result<()> {
+        let (mut rd, mut wr) = stream.split();
+
+        let message = Message::new(&addr.to_string(), MessageKind::Test, "risposta")?.as_bytes_vec()?;
+        wr.write_all(&message).await?;
+
+        let mut message_reader = MessageReader::new();
+        let mut buf = Vec::with_capacity(4);
+
+        match rd.read_exact(&mut buf).await {
+            Ok(0) => {
+                println!("connection closed by client");
+                return Ok(())
+            },
+            Ok(n) => {
+                let mut buf = Vec::with_capacity(n);
+                rd.read_exact(&mut buf).await?;
+                let message = message_reader.read(&buf).expect("fallito lettura buffer");
+                println!("{:?}", message);
+            },
+            Err(e) => eprintln!("failed reading from socket: {}", e),
+        }
+
+        Ok(())
+    }
+
     #[allow(unreachable_code)]
+    #[tracing::instrument]
     pub async fn run(&mut self) -> anyhow::Result<()> {
         let listener = TcpListener::bind(format!(
             "{}:{}",
@@ -25,48 +55,20 @@ impl Server {
 
         println!("Server is running on {}:{}", self.host, self.port);
 
+        // let mut db = HashMap::new();
+
         loop {
-            let (mut socket, addr) = listener.accept().await?;
+            match listener.accept().await {
-            println!("Connection received from {}", addr);
+                Ok((stream, addr)) => {
-
+                    println!("connected to: {}", addr);
-            tokio::task::spawn(async move {
+                    tokio::spawn(async move {
-                let mut message_reader = MessageReader::new();
+                        Self::process_connection(stream, addr).await;
-
+                    });
-
+                },
-                let (mut rd, mut wr) = socket.split();
+                Err(e) => eprintln!("error connecting: {}", e) 
-                let mut bufread = BufReader::new(&mut rd);
+            }
-
-                'handler: loop {
-                    let mut buffer = vec![];
-                    let _bytes_read = match bufread.read_to_end(&mut buffer).await {
-                        Ok(0) => {
-                            println!("connection closed by client");
-                            break 'handler;
-                        },
-                        Ok(_n) => {
-                            let message = message_reader.read(&buffer).expect("failed to parse message");
-                            println!("{:?}", message);                      },
-                        Err(e) => {
-                            eprintln!("error reading from stream: {}", e);
-                            break 'handler;  
-                        },
-                    };
-                    // if tokio::io::copy(&mut rd, &mut buffer).await.is_err() {
-                    //     eprintln!("failed to copy");
-                    // }
-                    
-                    // let message =  message_reader.read(&buffer)?;
-                    // println!("{:?}", message);
-
-                    // let local_address = &rd.local_addr()?;
-                    // let message_client = Message::new(&local_address.to_string(), MessageKind::Test, "toto test")?;
-                    // wr.write_all(&message_client.encode()?.as_bytes()).await?;                       
-                }
-
-                Ok::<(), anyhow::Error>(())
-            });
         }
-
+      
         Ok(())
     }
 }