.gitignore

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

Cargo.toml

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

src/bin/server.rs

@@ -2,9 +2,6 @@ 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,9 +4,8 @@ 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)]
@@ -21,10 +20,12 @@ 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,
         })
     }
@@ -40,16 +41,4 @@ 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,10 +1,7 @@
-use tokio::{io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader}, net::{tcp::WriteHalf, TcpListener}, sync::mpsc};
+use tokio::{io::{AsyncReadExt, AsyncWriteExt, BufReader}, net::{tcp::WriteHalf, TcpListener}};
-use tokio::sync::broadcast;
+use std::net::SocketAddr;
-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,
@@ -18,34 +15,7 @@ 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!(
             "{}:{}",
@@ -55,18 +25,46 @@ impl Server {
 
         println!("Server is running on {}:{}", self.host, self.port);
 
-        // let mut db = HashMap::new();
-
         loop {
-            match listener.accept().await {
+            let (mut socket, addr) = listener.accept().await?;
-                Ok((stream, addr)) => {
+            println!("Connection received from {}", addr);
-                    println!("connected to: {}", addr);
+
-                    tokio::spawn(async move {
+            tokio::task::spawn(async move {
-                        Self::process_connection(stream, addr).await;
+                let mut message_reader = MessageReader::new();
-                    });
+
+
+                let (mut rd, mut wr) = socket.split();
+                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;
                         },
-                Err(e) => eprintln!("error connecting: {}", e) 
+                        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(())