clizia/durak
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

ipertesto test funziona

Browse source
This commit is contained in:
clizia 2025-02-27 22:06:45 +01:00
parent c1267d16e6
commit 94d7ec5e25
4 changed files with 800 additions and 80 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

777
Cargo.lock generated
View file

File diff suppressed because it is too large Load diff

1
Cargo.toml
View file

@ -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"] }

49
src/bin/client.rs
View file

@ -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 local_address = client.stream.local_addr()?;
// let mut client = Client::connect("127.0.0.1", 8080).await?;
// 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 {
client.send_message(Message::new(&local_address.to_string(), MessageKind::Test, "test json").unwrap()).await.expect("failed to write to socket");
let body = reqwest::get("http://127.0.0.1:8080").await?.text().await?;
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(())
}

53
src/server.rs
View file

@ -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();
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;
},
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?;
if let Err(e) = http1::Builder::new()
.serve_connection(io, service_fn(Self::handle_request))
.await
{
eprintln!("error serving connection: {:?}", e);
}
Ok::<(), anyhow::Error>(())
});
}