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

lots of things

Browse source
This commit is contained in:
clizia 2025-02-27 21:01:28 +01:00
parent 45f9b5b137
commit 4a119cd5a3
6 changed files with 882 additions and 88 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

791
Cargo.lock generated
View file

File diff suppressed because it is too large Load diff

6
Cargo.toml
View file

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

67
src/bin/client.rs
View file

@ -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 {
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) = io::split(client.stream);
// 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();
// 'handler: loop {
// let mut buffer = vec![];
// if tokio::io::copy(&mut rd, &mut buffer).await.is_err() {
// println!("failed to copy");
// }
loop {
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 {
// let n = rd.read_exact(&mut buf).await.expect("fallito lettura");
// 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");
// if n == 0 {
// break;
// }
// let message = message_reader.read(&buffer)?;
// println!("{:?}", message);
// let message = message_reader.read(&buf)?;
// 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(())
}

3
src/bin/server.rs
View file

@ -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(())

17
src/message.rs
View file

@ -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)
}
}

86
src/server.rs
View file

@ -1,7 +1,10 @@
use tokio::{io::{AsyncReadExt, AsyncWriteExt, BufReader}, net::{tcp::WriteHalf, TcpListener}};
use std::net::SocketAddr;
use tokio::{io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader}, net::{tcp::WriteHalf, TcpListener}, sync::mpsc};
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?;
println!("Connection received from {}", addr);
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?;
}
Ok::<(), anyhow::Error>(())
});
match listener.accept().await {
Ok((stream, addr)) => {
println!("connected to: {}", addr);
tokio::spawn(async move {
Self::process_connection(stream, addr).await;
});
},
Err(e) => eprintln!("error connecting: {}", e)
}
}
Ok(())
}
}