a

Cargo.toml

@@ -16,9 +16,21 @@ name = "client"
 path = "src/bin/client.rs"
 
 [dependencies]
+axum = "0.8.1"
+tower = "0.5.2"
+reqwest = "0.12.0"
+hyper = { version = "1", features = ["full"] }
+http-body-util = "0.1"
+hyper-util = { version = "0.1", features = ["full"] }
 rand = "0.9.0-beta.1"
 clap = "4.5.23"
+<<<<<<< HEAD
 tokio = { version = "1.42.0", features = ["full", "tracing"] }
+||||||| 45f9b5b
+tokio = { version = "1.42.0", features = ["full"] }
+=======
+tokio = { version = "1.42.0", features = ["full","tracing"] }
+>>>>>>> deke/ipertesto
 console-subscriber = "0.1.5"
 anyhow = "1.0.95"
 serde_json = "1.0.135"
@@ -28,4 +40,8 @@ petname = "2.0.2"
 crossterm = "0.28.1"
 tracing = "0.1.41"
 tracing-subscriber = "0.3.19"
+<<<<<<< HEAD
 
+||||||| 45f9b5b
+=======
+>>>>>>> deke/ipertesto

src/bin/client.rs

@@ -1,33 +1,56 @@
-use lib::{client::Client, message::{Message, MessageKind}, message_read::MessageReader};
+use std::{io::{Stdout, Write}, ops::BitOrAssign, time::Duration};
+
+use axum::response::sse::Event;
+use clap::builder::NonEmptyStringValueParser;
+use lib::{client::Client, message::{Message, MessageKind}, message_read::MessageReader, player::Player};
 use crossterm::{
-    execute,
+    cursor, event::{self, poll, Event as TermEvent, KeyCode, KeyModifiers}, execute, queue, style, terminal::{
-    terminal::{
+        disable_raw_mode, enable_raw_mode, Clear, ClearType, EnableLineWrap, EnterAlternateScreen
-        Clear,
+    }
-        ClearType,
-        enable_raw_mode,
-        disable_raw_mode
-    },
-    event::Event,
 };
 use tokio::io::{self, AsyncReadExt, AsyncWriteExt};
 
-#[allow(unreachable_code)]
+const HELP: &str = r#"CIAOTERPIA
-#[tokio::main]
+atm posso fare questo:
-pub async fn main() -> anyhow::Result<()> {
+(ricorda di premere i bottoni)
-    let mut client = Client::connect("127.0.0.1", 8080).await?;
+- '1' mando giocante
-    let local_address = client.stream.local_addr()?;
+- '2' mando lobbando (futuro)
+"#;
 
-    // enable_raw_mode()?;
+fn create_message_player(player: &Player) -> anyhow::Result<Message, anyhow::Error> {
-    // execute!(
+    Message::new(
-    //     std::io::stdout(),
+        &player.get_name(),
-    //     Clear(ClearType::All),
+        MessageKind::Test,
-    // )?;
+        player.encode()?
+    )
+}
 
+<<<<<<< HEAD
     let (mut rd, mut wr) = io::split(client.stream);
+||||||| 45f9b5b
+    // 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");
+=======
+async fn delete_player(player: &Player, client: reqwest::Client, addr: &str) -> anyhow::Result<()> {
+    let player_id = &player.name;
+    let response = client
+        .get([&addr, "/delete/", &player_id].concat())
+        .send().await;
+>>>>>>> deke/ipertesto
 
+<<<<<<< HEAD
     let mut buf: Vec<u8> = Vec::with_capacity(4);
     let mut message_reader = MessageReader::new();
+||||||| 45f9b5b
+        // let (mut rd, mut wr) = client.stream.split();
+=======
+    if let Err(e) = &response {
+        println!("{e}\n");
+        return Ok(())
+    }
+>>>>>>> deke/ipertesto
 
+<<<<<<< HEAD
     loop {
         match rd.read_exact(&mut buf).await {
             Ok(0) => {
@@ -43,7 +66,92 @@ pub async fn main() -> anyhow::Result<()> {
             Err(e) => eprintln!("failed reading from socket: {}", e),
         }
     }
+||||||| 45f9b5b
+        // 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");
+        //     }
+=======
+    println!("{}", response?.text().await?);
 
+    Ok(())
+}
+
+async fn send_player(player: &Player, client: reqwest::Client, addr: &str) -> anyhow::Result<()> {
+    let player_message = create_message_player(&player)?;
+    let response = client
+        .post([&addr, "/create/player"].concat())
+        .header("Content-Type", "application/json")
+        .body(player_message.encode()?)
+        .send().await;
+
+    if let Err(e) = &response {
+        println!("{e}\n");
+        return Ok(())
+    }
+
+    println!("{}", response?.text().await?);
+
+    Ok(())
+}
+async fn handle_terminal(player: &Player, stdout: &mut Stdout, client: reqwest::Client, addr: &str) -> anyhow::Result<()> {
+    'handler: loop {
+        while let Ok(_event_happened) = poll(Duration::from_millis(2)) {
+            match event::read().expect("diomerds") {
+                TermEvent::Key(key) => {
+                    match (key.code, key.modifiers) {
+                        (KeyCode::Char('c'), KeyModifiers::CONTROL) => break 'handler,
+                        (KeyCode::Char('h'), KeyModifiers::NONE) => {
+                            for line in HELP.split('\n') {
+                                println!("{line}")
+                            }
+                        }, 
+                        (KeyCode::Char('1'), KeyModifiers::NONE) => {
+                            send_player(&player, client.clone(), addr).await?;
+                        },
+                        (KeyCode::Char('2'), KeyModifiers::NONE) => {
+                            delete_player(&player, client.clone(), addr).await?;
+                        },
+                        (_, _) => println!("{:?}\n", key),
+                    }
+                },
+                _ => continue,
+            }
+        }
+    }
+
+    Ok(())
+}
+
+#[tokio::main]
+pub async fn main() -> anyhow::Result<()> {
+    let mut stdout = std::io::stdout();
+
+    enable_raw_mode()?;
+    execute!(
+        stdout,
+        Clear(ClearType::All),
+        EnableLineWrap,
+        cursor::Show,
+        cursor::EnableBlinking,
+        EnterAlternateScreen,
+    )?;
+
+    let player = Player::new()?;
+
+    let addr = "http://127.0.0.1:8080";
+    let client = reqwest::Client::new();
+
+    // println!("{}", HELP);
+
+    handle_terminal(&player, &mut stdout, client.clone(), &addr).await?;
+    disable_raw_mode()?;
+>>>>>>> deke/ipertesto
+
+<<<<<<< HEAD
     // loop {
     //     let n = rd.read_exact(&mut buf).await.expect("fallito lettura");
 
@@ -70,5 +178,34 @@ pub async fn main() -> anyhow::Result<()> {
 
     // disable_raw_mode()?;
 
+||||||| 45f9b5b
+
+        //     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()?;
+=======
+>>>>>>> deke/ipertesto
     Ok(())
 }

src/db.rs

@@ -0,0 +1,23 @@
+use std::sync::{Arc, Mutex};
+use std::collections::HashMap;
+use axum::body::Bytes;
+
+pub type Db = Arc<Mutex<HashMap<String, Bytes>>>;
+
+#[derive(Clone)]
+pub struct AppState {
+    pub lobbies: Db,
+    pub players: Db,
+}
+
+impl AppState {
+    pub fn new() -> Self {
+        let lobbies = Arc::new(Mutex::new(HashMap::new()));
+        let players = Arc::new(Mutex::new(HashMap::new()));
+
+        Self {
+            lobbies,
+            players,
+        }
+    }
+}

src/lib.rs

@@ -8,3 +8,5 @@ pub mod message;
 pub mod message_read;
 pub mod constant;
 pub mod routine;
+pub mod db;
+pub mod router;

src/main.rs

@@ -1,69 +0,0 @@
-use std::collections::HashMap;
-use std::io::{self, Error};
-use std::net::SocketAddr;
-
-use lib::lobby::Lobby;
-use lib::player::Player;
-use std::sync::{Arc, Mutex};
-
-use anyhow::Result;
-use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
-use tokio::net::{TcpListener, TcpStream};
-
-async fn handle_connection(mut stream: TcpStream, addr: SocketAddr) -> (Option<Player>, Option<Lobby>) {
-    let (mut read, mut write) = stream.split();
-
-    let mut buf = [0; 1024];
-
-    let mut name = String::new();
-    write.write_all(b"provide name\n").await.expect("failed to write to socket");
-
-    let n = match read.read(&mut buf).await {
-        Ok(0) => return (None, None),
-        Ok(n) => n,
-        Err(e) => {
-            eprintln!("failed to read from socket; err: {:?}", e);
-            return (None, None);
-        },
-    };
-
-    name = String::from_utf8_lossy(&buf[0..n]).to_string();
-
-//    if let Err(e) = write.write_all(&buf[0..n]).await {
-//        eprintln!("failed to write to socket; err = {:?}", e);
-//        return (None, None);
-//    }
-
-    let player = Player::new(addr, &name);
-
-    write.write_all(b"your name is\n").await.expect("failed to write to socket");
-    write.write_all(name.as_bytes()).await.expect("failed to write to socket");
-
-    (Some(player), None)
-}
-
-#[tokio::main]
-async fn main() -> io::Result<()> {
-    let address = "127.0.0.1:8080".to_string();
-    let listener = TcpListener::bind(&address).await?;
-
-    let mut lobbies: Arc<Mutex<HashMap<String, Lobby>>> = Arc::new(Mutex::new(HashMap::new()));
-
-    loop {
-        let (mut stream, addr) = listener.accept().await?;
-
-        println!("new connection from: {}", addr);
-
-        let lobby_player_handle = tokio::spawn(handle_connection(stream, addr));
-
-        let (player, lobby) = lobby_player_handle.await?;
-
-        match lobby {
-            Some(lobby) => lobbies.insert(lobby.get_id(), lobby),
-            None => continue,
-        };
-
-    }
-
-    Ok(())
-}

src/message.rs

@@ -1,3 +1,5 @@
+use std::fmt::Display;
+use axum::body::to_bytes;
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -15,6 +17,8 @@ pub enum MessageKind {
     Move,
     CreatePlayer,
     CreateLobby,
+    DeletePlayer,
+    DeleteLobby,
 }
 
 impl Message {
@@ -53,3 +57,9 @@ impl Message {
         Ok(buffer)
     }
 }
+
+impl Display for Message {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        todo!()
+    }
+}

src/player.rs

@@ -1,48 +1,51 @@
-use tokio::{io::AsyncReadExt, net::TcpStream};
+use petname::Generator;
-use std::net::SocketAddr;
 use serde::{Deserialize, Serialize};
 use sha256::digest;
 
-use crate::{card::Card, message_read::MessageReader};
+use axum::Json;
+
+use crate::card::Card;
 
 #[derive(Serialize, Deserialize, Eq, PartialEq, Hash, Clone)]
 pub struct Player {
-    // addr will change because at this stage i really
-    // don't know what i am doing
-    // it will probably be something like id or playerid
-    // or some other identifier idk
-    pub addr: SocketAddr,
-    // same goes for id because rn it's just the sha256 of
-    // the ip
     pub id: String,
     pub name: String,
     pub hand: Vec<Card>,
 }
 
 impl Player {
-    pub async fn new(addr: SocketAddr, name: &str) -> anyhow::Result<Option<Self>> {
+    pub fn new() -> anyhow::Result<Self> {
         let hand_empty: Vec<Card> = Vec::new();
 
-        let to_digest: String = addr.to_string();
+
+        let name = petname::Petnames::default().generate_one(2, "-").expect("no nomi");
+        let to_digest = &name;
         let id = digest(to_digest);
 
-        Ok(Some(Player {
+        Ok(Player {
-            addr,
             id,
-            name: name.to_string(),
+            name,
             hand: hand_empty,
-        }))
+        })
     }
 
-    pub fn get_addr(self) -> SocketAddr {
+    pub fn encode(&self) -> anyhow::Result<String> {
-        self.addr
+        let player_json = serde_json::to_string(self)?;
+
+        Ok(player_json)
     }
 
-    pub fn get_name(self) -> String {
+    pub fn decode(player: String) -> anyhow::Result<Self> {
-        self.name
+        let player: Player = serde_json::from_str(&player)?;
+
+        Ok(player)
     }
 
-    pub fn get_hand(self) -> Vec<Card> {
+    pub fn get_name(&self) -> String {
-        self.hand
+        self.name.clone()
+    }
+
+    pub fn get_hand(&self) -> Vec<Card> {
+        self.hand.clone()
     }
 }

src/router.rs

@@ -0,0 +1,89 @@
+use anyhow::Result;
+use axum::{
+    body::Bytes, extract::{
+        rejection::JsonRejection, Json, Path, State
+    },
+    http::StatusCode,
+    Router
+};
+
+use crate::{message::Message, player::Player};
+use crate::db::AppState;
+use crate::message::MessageKind;
+
+pub struct App {
+    pub db: AppState,
+    pub router: Router<AppState>,
+}
+
+impl App {
+    pub fn new() -> Self {
+        let db = AppState::new();    
+        let router: Router<AppState> = Router::new();
+
+        Self {
+            db,
+            router,
+        }
+    }
+    
+    pub async fn echo(body: Bytes) -> Bytes {
+        body
+    }
+
+    pub async fn create_player(
+        State(db): State<AppState>,
+        json_body: Result<Json<Message>, JsonRejection>,
+    ) -> Result<axum::Json<Message>, StatusCode> {
+        match json_body {
+            Ok(Json(message)) => {
+                println!("{:?}", message);
+                let player: Player = serde_json::from_str(&message.content).expect("niente json");
+                {
+                    let mut players = db.players
+                        .lock().expect("ciao");
+
+                    if players.contains_key(&player.name) {
+                        return Err(StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS)
+                    }
+
+                    players.insert(
+                        player.get_name(),
+                        Bytes::copy_from_slice(player.encode().expect("failed encoding player").as_ref())
+                    );
+                }
+
+                println!("{:?}", db.players);
+                Ok(Json(Message::new("server", MessageKind::CreatePlayer, "user created").expect("failed creating message")))
+            }
+            Err(_) => Err(StatusCode::UNPROCESSABLE_ENTITY)
+        }
+    }
+
+    pub async fn delete_player(
+        State(db): State<AppState>,
+        Path(player_id): Path<String>
+    ) -> Result<axum::response::Json<Message>, StatusCode> {
+        {
+            let mut players = db.players
+                .lock().expect("ciao");
+
+            match players.contains_key(&player_id) {
+                true => {
+                    players.remove(&player_id);
+                    println!("{:?}", players);
+                    Ok(Json(Message::new("server", MessageKind::DeletePlayer, "user deleted").expect("a")))
+                },
+                false => Err(StatusCode::NOT_FOUND),
+            }
+        }
+      
+    }
+
+    pub async fn create_lobby(
+        State(db): State<AppState>,
+        json_body: Result<Json<Message>, JsonRejection>,
+    ) -> Result<axum::Json<Message>, StatusCode> {
+        todo!()
+    }
+}

src/server.rs

@@ -1,8 +1,19 @@
+<<<<<<< HEAD
 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};
+||||||| 45f9b5b
+use tokio::{io::{AsyncReadExt, AsyncWriteExt, BufReader}, net::{tcp::WriteHalf, TcpListener}};
+use std::net::SocketAddr;
+use crate::{message::{Message, MessageKind}, message_read::MessageReader, server};
+=======
+use tokio::net::TcpListener;
+use crate::router::App;
+
+use axum::routing::{get, post};
+>>>>>>> deke/ipertesto
 
 #[derive(Debug)]
 pub struct Server {
@@ -18,6 +29,7 @@ impl Server {
         }
     }
 
+<<<<<<< HEAD
     async fn process_connection(mut stream: TcpStream, addr: SocketAddr) -> anyhow::Result<()> {
         let (mut rd, mut wr) = stream.split();
 
@@ -46,15 +58,20 @@ impl Server {
 
     #[allow(unreachable_code)]
     #[tracing::instrument]
+||||||| 45f9b5b
+    #[allow(unreachable_code)]
+=======
+
+>>>>>>> deke/ipertesto
     pub async fn run(&mut self) -> anyhow::Result<()> {
         let listener = TcpListener::bind(format!(
             "{}:{}",
             self.host,
             self.port
         )).await?;
-
         println!("Server is running on {}:{}", self.host, self.port);
 
+<<<<<<< HEAD
         // let mut db = HashMap::new();
 
         loop {
@@ -69,6 +86,62 @@ impl Server {
             }
         }
       
+||||||| 45f9b5b
+        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>(())
+            });
+        }
+
+=======
+        let app = App::new();
+
+        let router = app.router
+            .route("/echo", post(App::echo))
+            .route("/create/player", post(App::create_player))
+            .route("/create/lobby", post(App::create_lobby))
+            .route("/delete/{player-id}", get(App::delete_player))
+            .with_state(app.db);
+
+        axum::serve(listener, router).await.unwrap();
+
+>>>>>>> deke/ipertesto
         Ok(())
     }
 }