ipertesto test funziona

Cargo.toml

@@ -16,6 +16,7 @@ name = "client"
 path = "src/bin/client.rs"
 
 [dependencies]
+reqwest = "0.12.0"
 hyper = { version = "1", features = ["full"] }
 http-body-util = "0.1"
 hyper-util = { version = "0.1", features = ["full"] }

src/bin/client.rs

@@ -9,12 +9,17 @@ use crossterm::{
     },
     event::Event,
 };
+use http_body_util::Empty;
+use hyper::{client::conn::{self, http1::{self, handshake}}, Request};
+use hyper::body::Bytes;
+use hyper_util::rt::TokioIo;
+use tokio::net::TcpStream;
 
 #[allow(unreachable_code)]
 #[tokio::main]
 pub async fn main() -> anyhow::Result<()> {
-    let mut client = Client::connect("127.0.0.1", 8080).await?;
+    // 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()?;
     // execute!(
@@ -22,44 +27,8 @@ pub async fn main() -> anyhow::Result<()> {
     //     Clear(ClearType::All),
     // )?;
 
-    // tokio::task::spawn(async move {
+    let body = reqwest::get("http://127.0.0.1:8080").await?.text().await?;
-        client.send_message(Message::new(&local_address.to_string(), MessageKind::Test, "test json").unwrap()).await.expect("failed to write to socket");
+    println!("body = {body:?}");
 
-        // 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,13 @@
 use tokio::{io::{AsyncReadExt, AsyncWriteExt, BufReader}, net::{tcp::WriteHalf, TcpListener}};
 use std::net::SocketAddr;
 use crate::{message::{Message, MessageKind}, message_read::MessageReader, server};
+use std::convert::Infallible;
+use http_body_util::Full;
+use hyper::body::Bytes;
+use hyper::server::conn::http1;
+use hyper::service::service_fn;
+use hyper::{Request, Response};
+use hyper_util::rt::TokioIo;
 
 pub struct Server {
     pub host: String,
@@ -15,6 +22,10 @@ impl Server {
         }
     }
 
+    pub async fn handle_request(_: Request<hyper::body::Incoming>) -> Result<Response<Full<Bytes>>, Infallible> {
+        Ok(Response::new(Full::new(Bytes::from("Hello, toto"))))
+    }
+
     #[allow(unreachable_code)]
     pub async fn run(&mut self) -> anyhow::Result<()> {
         let listener = TcpListener::bind(format!(
@@ -26,44 +37,18 @@ impl Server {
         println!("Server is running on {}:{}", self.host, self.port);
 
         loop {
-            let (mut socket, addr) = listener.accept().await?;
+            let (mut stream, addr) = listener.accept().await?;
             println!("Connection received from {}", addr);
 
+            let io = TokioIo::new(stream);
+
             tokio::task::spawn(async move {
-                let mut message_reader = MessageReader::new();
+                if let Err(e) = http1::Builder::new()
-
+                    .serve_connection(io, service_fn(Self::handle_request))
-
+                    .await
-                let (mut rd, mut wr) = socket.split();
+                {
-                let mut bufread = BufReader::new(&mut rd);
+                    eprintln!("error serving connection: {:?}", e);
-
-                '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>(())
             });
         }