trying a new approach

src/bin/client.rs

@@ -1,4 +1,4 @@
-use lib::{client::Client, message::{Message, MessageKind}};
+use lib::{client::Client, message::{Message, MessageKind}, message_read::MessageReader};
 use crossterm::{
     execute,
     terminal::{
@@ -10,19 +10,56 @@ use crossterm::{
     event::Event,
 };
 
+#[allow(unreachable_code)]
 #[tokio::main]
 pub async fn main() -> anyhow::Result<()> {
     let mut client = Client::connect("127.0.0.1", 8080).await?;
-    let local_address = &client.stream.local_addr()?;
+    let local_address = client.stream.local_addr()?;
 
-    enable_raw_mode()?;
+    // enable_raw_mode()?;
-    execute!(
+    // execute!(
-        std::io::stdout(),
+    //     std::io::stdout(),
-        Clear(ClearType::All),
+    //     Clear(ClearType::All),
-    )?;
+    // )?;
 
-    client.send_message(Message::new(&local_address.to_string(), MessageKind::Test, "test json").unwrap()).await?;
+    // 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");
 
-    disable_raw_mode()?;
+        // 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).expect("failed to read from socket");
+        //     println!("{:?}", message);
+
+        //     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)?;
+    //     println!("{:?}", message);
+
+    //     break 'handler;
+    // }
+
+    // disable_raw_mode()?;
     Ok(())
 }

src/server.rs

@@ -1,6 +1,6 @@
-use tokio::{io::{AsyncReadExt, AsyncWriteExt}, net::TcpListener};
+use tokio::{io::{AsyncReadExt, AsyncWriteExt, BufReader}, net::{tcp::WriteHalf, TcpListener}};
 use std::net::SocketAddr;
-use crate::{message::Message, message_read::MessageReader};
+use crate::{message::{Message, MessageKind}, message_read::MessageReader, server};
 
 pub struct Server {
     pub host: String,
@@ -15,6 +15,7 @@ impl Server {
         }
     }
 
+    #[allow(unreachable_code)]
     pub async fn run(&mut self) -> anyhow::Result<()> {
         let listener = TcpListener::bind(format!(
             "{}:{}",
@@ -31,18 +32,35 @@ impl Server {
             tokio::task::spawn(async move {
                 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![];
-                    if tokio::io::copy(&mut rd, &mut buffer).await.is_err() {
+                    let _bytes_read = match bufread.read_to_end(&mut buffer).await {
-                        eprintln!("failed to copy");
+                        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)?;
+                    // let message =  message_reader.read(&buffer)?;
-                    println!("{:?}", message.content);
+                    // println!("{:?}", message);
 
-                    break 'handler;
+                    // 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>(())
@@ -51,8 +69,4 @@ impl Server {
 
         Ok(())
     }
-
-    pub async fn send_message(addr: SocketAddr, message: Message) {
-        todo!()
-    }
 }