Print version in log

Release 0.2.0

Cargo.lock

@@ -44,7 +44,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "clichess"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "colored 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "ctrlc 3.1.3 (registry+https://github.com/rust-lang/crates.io-index)",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "clichess"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["Artlef <artlef@localhost>"]
 edition = "2018"
 

src/bin/client.rs

@@ -1,11 +1,10 @@
 extern crate ctrlc;
-use clichess::{RecvPositionError, UserRole, EXIT_MSG};
+use clichess::{GameInfo, RecvPositionError, UserRole, EXIT_MSG};
 use serde_json::json;
 use shakmaty::fen::Fen;
 use shakmaty::{Chess, Color, Outcome, Position, Setup};
 use std::io;
 use std::os::unix::net::UnixStream;
-use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::{channel, Receiver, TryRecvError};
 use std::sync::{Arc, Mutex};
 use std::thread;
@@ -14,13 +13,14 @@ use std::time;
 struct Client {
     player: clichess::Player,
     side: Color,
-    running: Arc<AtomicBool>,
     input_buffer: Arc<Mutex<String>>,
     server_message_recv: Receiver<String>,
+    opponent_name: Option<String>,
 }
 
 fn main() {
-    let running = setupctrlc();
+    let version = env!("CARGO_PKG_VERSION");
+    println!("Running clichess version {}", version);
     let username = std::env::args().nth(1).expect("no name given");
     let public_key = std::env::args().nth(2).expect("no public key given");
     //send username and public key to server
@@ -43,19 +43,22 @@ fn main() {
     let mut client = Client {
         player: clichess::Player {
             role: UserRole::Spectator,
-            username: username,
-            public_key: public_key,
+            username,
+            public_key,
         },
         side: Color::White,
-        running: running.clone(),
         input_buffer: input_buffer.clone(),
         server_message_recv,
+        opponent_name: Option::None,
     };
 
     match prompt_user_for_role(&client, &mut stream) {
         Some(role) => client.player.role = role.clone(),
         None => return,
     };
+    if client.player.role == UserRole::Black {
+        client.side = Color::Black;
+    }
     if client.player.role == UserRole::Spectator {
         println!(
             "Hello, {} !\n\r You're spectating !",
@@ -70,6 +73,10 @@ fn main() {
     }
     let mut current_position = fetch_initial_chess_position(&client);
     loop {
+        client
+            .opponent_name
+            .clone()
+            .map(|name| println!("{} played", &name[1..(name.len() - 1)]));
         println!(
             "{}",
             clichess::board_representation(&current_position, client.side)
@@ -87,7 +94,7 @@ fn main() {
             }
         }
         //update position after playing.
-        match get_current_position(&client) {
+        match get_current_position(&mut client) {
             Ok(position) => current_position = position,
             Err(_) => {
                 clichess::write_to_stream(&mut stream, String::from(EXIT_MSG)).unwrap();
@@ -130,16 +137,6 @@ fn setup_input_buffer() -> Arc<Mutex<String>> {
     buf
 }
 
-fn setupctrlc() -> Arc<AtomicBool> {
-    let running = Arc::new(AtomicBool::new(true));
-    let r = running.clone();
-    ctrlc::set_handler(move || {
-        r.store(false, Ordering::SeqCst);
-    })
-    .expect("Error setting Ctrl-C handler");
-    running
-}
-
 fn setup_server_message_recv(stream: &UnixStream) -> io::Result<Receiver<String>> {
     let (sender, receiver) = channel();
     let thread_stream = stream.try_clone()?;
@@ -161,8 +158,8 @@ fn read_user_input(client: &Client) -> String {
         let mut user_input = client.input_buffer.lock().unwrap();
         user_input.clear();
     }
-    let mut input = String::new();
-    while client.running.load(Ordering::SeqCst) {
+    let input;
+    loop {
         thread::sleep(time::Duration::from_millis(10));
         {
             let user_input = client.input_buffer.lock().unwrap();
@@ -174,26 +171,26 @@ fn read_user_input(client: &Client) -> String {
             }
         }
     }
-    if client.running.load(Ordering::SeqCst) {
     input
-    } else {
-        String::from(EXIT_MSG)
-    }
 }
 
 //wait for next position from server, then return the current board.
-fn get_current_position(client: &Client) -> Result<Chess, RecvPositionError> {
+fn get_current_position(client: &mut Client) -> Result<Chess, RecvPositionError> {
     let response = fetch_message_from_server(client);
+    let game_info: GameInfo = serde_json::from_str(&response).unwrap();
+    if game_info.opponent_name != "" {
+        client.opponent_name = Some(game_info.opponent_name);
+    }
     if response.is_empty() {
         Err(RecvPositionError::UserCanceledError)
     } else {
-        Ok(parse_position(&response))
+        Ok(parse_position(&game_info.game_fen))
     }
 }
 
 fn fetch_message_from_server(client: &Client) -> String {
-    let mut response = String::new();
-    while client.running.load(Ordering::SeqCst) {
+    let response;
+    loop {
         thread::sleep(time::Duration::from_millis(10));
         {
             let server_response_recv = &client.server_message_recv;

src/bin/server.rs

@@ -1,26 +1,29 @@
 use clichess;
-use clichess::{Player, RecvPositionError, UserRole, EXIT_MSG};
+use clichess::{GameInfo, Player, RecvPositionError, UserRole, EXIT_MSG};
 use serde_json::Value;
 use shakmaty::{fen, Chess, Color, Setup};
 use std::collections::HashMap;
 use std::fs;
 use std::io;
 use std::os::unix::net::{UnixListener, UnixStream};
-use std::sync::mpsc::{channel, Receiver, TryRecvError};
-use std::sync::{Arc, Mutex};
+use std::sync::mpsc::{channel, Receiver, Sender, TryRecvError};
+use std::sync::{Arc, Condvar, Mutex};
 
 use std::thread;
-use std::time;
 
 struct Server {
     id: usize,
     chess_position: Arc<Mutex<Chess>>,
-    players: Arc<Mutex<HashMap<usize, (Player, Arc<Mutex<String>>)>>>,
-    others_serv_msg_buf: Arc<Mutex<String>>,
+    players: Arc<Mutex<HashMap<usize, (Player, Sender<GameInfo>, Arc<(Mutex<bool>, Condvar)>)>>>,
+    others_serv_msg_recv: Receiver<GameInfo>,
     client_message_recv: Receiver<String>,
+    cvar: Arc<(Mutex<bool>, Condvar)>,
+    opponent_name: Option<String>,
 }
 
 fn main() {
+    let version = env!("CARGO_PKG_VERSION");
+    println!("Running clichess version {}", version);
     let chess = Arc::new(Mutex::new(Chess::default()));
     let players = Arc::new(Mutex::new(HashMap::new()));
     let mut counter = 0;
@@ -32,16 +35,21 @@ fn main() {
     for stream in listener.incoming() {
         match stream {
             Ok(stream) => {
-                let client_message_recv = setup_client_message_recv(&stream).unwrap();
-                let server = Server {
+                let condvar_pair = Arc::new((Mutex::new(false), Condvar::new()));
+                let client_message_recv =
+                    setup_client_message_recv(&stream, condvar_pair.clone()).unwrap();
+                let (others_serv_msg_sender, others_serv_msg_recv) = channel();
+                let mut server = Server {
                     id: counter,
                     chess_position: chess.clone(),
                     players: players.clone(),
-                    others_serv_msg_buf: Arc::new(Mutex::new(String::new())),
+                    others_serv_msg_recv,
                     client_message_recv,
+                    cvar: condvar_pair,
+                    opponent_name: Option::None,
                 };
                 /* connection succeeded */
-                thread::spawn(move || handle_player(stream, server));
+                thread::spawn(move || handle_player(stream, &mut server, others_serv_msg_sender));
                 counter += 1;
             }
             Err(err) => {
@@ -52,9 +60,13 @@ fn main() {
     }
 }
 
-fn handle_player(mut stream: UnixStream, server: Server) {
-    match initialize_client(&mut stream, &server) {
-        Ok((player, player_turn)) => main_loop(&mut stream, &server, player, player_turn),
+fn handle_player(
+    mut stream: UnixStream,
+    server: &mut Server,
+    others_serv_msg_sender: Sender<GameInfo>,
+) {
+    match initialize_client(&mut stream, &server, others_serv_msg_sender) {
+        Ok((player, player_turn)) => main_loop(&mut stream, server, player, player_turn),
         Err(e) => println!("User id {} could not be initialized: {}", server.id, e),
     };
     player_disconnected(&server);
@@ -63,9 +75,10 @@ fn handle_player(mut stream: UnixStream, server: Server) {
 fn initialize_client(
     stream: &mut UnixStream,
     server: &Server,
+    others_serv_msg_sender: Sender<GameInfo>,
 ) -> Result<(Player, Color), RecvPositionError> {
     //create player
-    let player = create_player(server, stream)?;
+    let player = create_player(server, stream, others_serv_msg_sender)?;
     let player_turn: Color;
     //send current position to the player
     println!(
@@ -81,7 +94,7 @@ fn initialize_client(
     Ok((player, player_turn))
 }
 
-fn main_loop(stream: &mut UnixStream, server: &Server, player: Player, mut player_turn: Color) {
+fn main_loop(stream: &mut UnixStream, server: &mut Server, player: Player, mut player_turn: Color) {
     loop {
         if clichess::is_player_turn(&player, player_turn) {
             //let go of the lock while waiting for user input.
@@ -105,66 +118,96 @@ fn main_loop(stream: &mut UnixStream, server: &Server, player: Player, mut playe
                     Ok(played_chess) => *chess = played_chess,
                     Err(e) => println!("Error: {}", e),
                 };
-                let chessfen = fen::fen(&*chess);
-                for (id, (_, others_serv_msg_buf)) in players.iter() {
+                let game_info_to_send = GameInfo {
+                    game_fen: fen::fen(&*chess),
+                    opponent_name: players
+                        .get(&server.id)
+                        .expect("current server is in the server list")
+                        .0
+                        .username
+                        .clone(),
+                };
+                for (id, (_, others_serv_msg_sender, cvar_pair)) in players.iter() {
                     if server.id != *id {
-                        others_serv_msg_buf.lock().unwrap().push_str(&chessfen);
+                        others_serv_msg_sender
+                            .send(game_info_to_send.clone())
+                            .unwrap();
+                        let (lock, cvar) = &**cvar_pair;
+                        let mut message_sent = lock.lock().unwrap();
+                        *message_sent = true;
+                        cvar.notify_one();
                     }
                 }
-                clichess::write_to_stream(stream, chessfen).unwrap();
+                if clichess::write_to_stream(
+                    stream,
+                    serde_json::to_string(&GameInfo {
+                        game_fen: fen::fen(&*chess),
+                        opponent_name: server.opponent_name.clone().unwrap_or_default(),
+                    })
+                    .unwrap(),
+                )
+                .is_err()
+                {
+                    break;
+                }
                 player_turn = chess.turn();
             }
         } else {
-            let position_as_fen_result = wait_for_opponent_move(server);
-            if position_as_fen_result.is_err() {
+            let game_info_result = wait_for_opponent_move(server);
+            if game_info_result.is_err() {
                 break;
             }
-            let position_as_fen = position_as_fen_result.unwrap();
-            println!("server id: {}, sending {}", server.id, position_as_fen);
-            clichess::write_to_stream(stream, position_as_fen.clone()).unwrap();
+            let game_info = game_info_result.unwrap();
+            clichess::write_to_stream(stream, serde_json::to_string(&game_info).unwrap()).unwrap();
+            server.opponent_name = Some(game_info.opponent_name);
             let chess = server.chess_position.lock().unwrap();
             player_turn = chess.turn();
         }
     }
 }
 
-fn wait_for_opponent_move(server: &Server) -> Result<String, RecvPositionError> {
+fn wait_for_opponent_move(server: &Server) -> Result<GameInfo, RecvPositionError> {
     println!("server id: {}, waiting for move to send...", server.id);
     //wait: either we receive next position from other server threads, or we receive
     //"exit" from the client.
-    let returned_result: Result<String, RecvPositionError>;
-    loop {
-        {
-            let mut others_serv_msg_buf = server.others_serv_msg_buf.lock().unwrap();
-            if !others_serv_msg_buf.is_empty() {
-                returned_result = Ok(others_serv_msg_buf.clone());
-                others_serv_msg_buf.clear();
-                break;
-            } else {
+    let mut returned_result = Err(RecvPositionError::UserCanceledError);
+    let (lock, cvar) = &*server.cvar;
+    let mut message_sent = lock.lock().unwrap();
+    *message_sent = false;
+    while !*message_sent {
+        message_sent = cvar.wait(message_sent).unwrap();
+    }
+    *message_sent = false;
+    match server.others_serv_msg_recv.try_recv() {
+        Ok(msg) => {
+            returned_result = Ok(msg);
+        }
+        Err(TryRecvError::Disconnected) => {
+            println!("Error: other server thread disconnected while sending move.")
+        }
+        Err(TryRecvError::Empty) => { /*nothing to do*/ }
+    }
     match server.client_message_recv.try_recv() {
         Ok(msg) => {
             if msg == EXIT_MSG {
                 returned_result = Err(RecvPositionError::UserCanceledError);
-                            break;
             } else {
-                            println!(
-                                "Client sent message while it's not its turn, this is an error."
-                            );
+                println!("Client sent message while it's not its turn, this is an error.");
                 println!("Here is the message: {}", msg);
-                            continue;
+                returned_result = Err(RecvPositionError::UserCanceledError);
             }
         }
         Err(TryRecvError::Disconnected) => println!("Error: client disconnected."),
-                    Err(TryRecvError::Empty) => continue,
-                }
-            }
-        }
-        thread::sleep(time::Duration::from_millis(10));
+        Err(TryRecvError::Empty) => {}
     }
     returned_result
 }
 
-fn create_player(server: &Server, stream: &mut UnixStream) -> Result<Player, RecvPositionError> {
+fn create_player(
+    server: &Server,
+    stream: &mut UnixStream,
+    others_serv_msg_sender: Sender<GameInfo>,
+) -> Result<Player, RecvPositionError> {
     println!("Creating player {}...", server.id);
     //get player name and pubkey
     let username_pubkey_json = server
@@ -185,7 +228,7 @@ fn create_player(server: &Server, stream: &mut UnixStream) -> Result<Player, Rec
     };
     players.insert(
         server.id,
-        (player.clone(), server.others_serv_msg_buf.clone()),
+        (player.clone(), others_serv_msg_sender, server.cvar.clone()),
     );
     println!("Created player {}", server.id);
     Ok(player)
@@ -221,7 +264,7 @@ fn receive_user_role(
             let mut available_roles_after_choice =
                 vec![UserRole::White, UserRole::Black, UserRole::Spectator];
             let players = server.players.lock().unwrap();
-            for (_, (player, _)) in players.iter() {
+            for (_, (player, _, _)) in players.iter() {
                 match available_roles_after_choice
                     .iter()
                     .position(|r| *r == player.role)
@@ -255,7 +298,7 @@ fn receive_user_role(
 fn compute_available_roles_to_str(server: &Server) -> String {
     let mut available_roles = vec![UserRole::White, UserRole::Black, UserRole::Spectator];
     let players = server.players.lock().unwrap();
-    for (_, (player, _)) in players.iter() {
+    for (_, (player, _, _)) in players.iter() {
         match available_roles.iter().position(|r| *r == player.role) {
             Some(index) => available_roles.remove(index),
             None => continue,
@@ -272,13 +315,16 @@ fn player_disconnected(server: &Server) {
     let mut players = server.players.lock().unwrap();
     let player_and_receiving_buf = players.get(&server.id);
     if player_and_receiving_buf.is_some() {
-        let (player, _) = player_and_receiving_buf.expect("is some");
+        let (player, _, _) = player_and_receiving_buf.expect("is some");
         println!("Player {} disconnected.", player.username);
     }
     players.remove(&server.id);
 }
 
-fn setup_client_message_recv(stream: &UnixStream) -> io::Result<Receiver<String>> {
+fn setup_client_message_recv(
+    stream: &UnixStream,
+    cvar_pair: Arc<(Mutex<bool>, Condvar)>,
+) -> io::Result<Receiver<String>> {
     let (sender, receiver) = channel();
     let thread_stream = stream.try_clone()?;
 
@@ -287,6 +333,11 @@ fn setup_client_message_recv(stream: &UnixStream) -> io::Result<Receiver<String>
             //wait for client message
             let buffer =
                 clichess::read_line_from_stream(&thread_stream).expect("Error message from server");
+            //notify the server if waiting
+            let (lock, cvar) = &*cvar_pair;
+            let mut message_sent = lock.lock().unwrap();
+            *message_sent = true;
+            cvar.notify_one();
             let send_result = sender.send(buffer);
             // stop the thread during a disconnection
             if send_result.is_err() {

src/lib.rs

@@ -1,4 +1,5 @@
 use colored::Colorize;
+use serde::{Deserialize, Serialize};
 use shakmaty::san::ParseSanError;
 use shakmaty::san::San;
 use shakmaty::san::SanError;
@@ -20,6 +21,12 @@ pub struct Player {
     pub public_key: String,
 }
 
+#[derive(Serialize, Deserialize, Clone)]
+pub struct GameInfo {
+    pub game_fen: String,
+    pub opponent_name: String,
+}
+
 #[derive(PartialEq, Copy, Clone)]
 pub enum UserRole {
     White,