acorn/src/server/server.rs

use std::collections::BTreeMap;
use std::collections::BTreeSet;
use std::time::{Duration, Instant};
use std::sync::{Mutex, RwLock, Arc};
use actix::dev::{MessageResponse, ResponseChannel};
use actix::prelude::*;
use actix_web::{web, Error, HttpRequest, HttpResponse};
use actix_web_actors::ws;
use crate::game;
use crate::websocket;
use crate::websocket::*;
use crate::datasource;
use crate::server::gamelobby::{GameLobby};
use crate::server::messages::*;

const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(5);
const CLIENT_TIMEOUT: Duration = Duration::from_secs(10);

pub async fn ws_initiate(server: web::Data<Addr<Server>>,
                         r: HttpRequest,
                         stream: web::Payload) -> Result<HttpResponse, Error> {
    println!("{:?}", r);
    let res = ws::start(GameConnection::new(server.as_ref().clone()), &r, stream)?;
    println!("{:?}", res);
    Ok(res)
}

pub struct Server {
    pub lobbies: BTreeMap<String, Addr<GameLobby>>,
    pub default_data: Arc<dyn datasource::DataSource<String>>
}

impl Actor for Server {
    type Context = Context<Self>;
    fn started(&mut self, ctx: &mut Self::Context) {
    }
}

impl Handler<JoinRequest> for Server {
    type Result = Answer;
    fn handle(&mut self, jr: JoinRequest, ctx: &mut Self::Context) -> Self::Result {
        let mb_lobby = self.lobbies.get(&jr.lobby_id);
        match mb_lobby {
            Some(lobby) => {
                let _sent = lobby.do_send(jr);
                Answer::LobbyJoined(lobby.clone())
            },
            None => {
                jr.p.do_send(NoSuchLobby(jr.lobby_id));
                Answer::NoSuchLobby
            }
        }
    }
}

impl Handler<CreateLobbyRequest> for Server {
    type Result = Answer;
    fn handle(&mut self, clr: CreateLobbyRequest, ctx: &mut Self::Context) -> Self::Result {
        let existing_lobby = self.lobbies.get(&clr.lobby_id);
        match existing_lobby {
            Some(_) => Answer::LobbyAlreadyExists,
            None => {
                let lobby = GameLobby::new(clr.lobby_id.clone(), self.default_data.clone());
                let lobby_addr = lobby.start();
                self.lobbies.insert(clr.lobby_id.clone(), lobby_addr.clone());
                Answer::LobbyCreated(lobby_addr)
            }
        }
    }
}

///
/// connection to one single client
/// 
pub struct GameConnection {
    heartbeat: Instant,
    nick: Option<String>,
    game_id: Option<String>,
    server: Addr<Server>,
    game_lobby: Option<Addr<GameLobby>>
}

impl Actor for GameConnection {
    type Context = ws::WebsocketContext<Self>;

    fn started(&mut self, ctx: &mut Self::Context) {
        self.initiate_heartbeat(ctx);
    }
}

impl Handler<LobbyJoined> for GameConnection {
    type Result = ();
    fn handle(&mut self, gu: LobbyJoined, ctx: &mut Self::Context) -> Self::Result {
        self.game_lobby = Some(gu.0);
    }
}

impl Handler<NoSuchLobby> for GameConnection {
    type Result = ();
    fn handle(&mut self, nsl: NoSuchLobby, ctx: &mut Self::Context) -> Self::Result {
        self.send_message(&UpdateMessage::GameNotFound{ game_id: nsl.0 }, ctx);
    }
}

impl Handler<GameUpdate> for GameConnection {
    type Result = ();
    fn handle(&mut self, gu: GameUpdate, ctx: &mut Self::Context) -> Self::Result {
        self.send_message(&UpdateMessage::GameState(gu.game_data), ctx);
    }
}

impl Handler<ResultMsg> for GameConnection {
    type Result = ();
    fn handle(&mut self, rm: ResultMsg, ctx: &mut Self::Context) -> Self::Result {
        self.send_message(&UpdateMessage::RoundResult(rm.results), ctx);
    }
}

impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for GameConnection {
    fn handle(
        &mut self,
        msg: Result<ws::Message, ws::ProtocolError>,
        ctx: &mut Self::Context,
    ) {
        match msg {
            Ok(ws::Message::Ping(msg)) => {
                self.heartbeat = Instant::now();
                ctx.pong(&msg);
            }
            Ok(ws::Message::Pong(_)) => {
                self.heartbeat = Instant::now();
            }
            Ok(ws::Message::Text(text)) => {
                println!("hmmm: {:?}", text);
                self.received_message(&text, ctx);
            },
            Ok(ws::Message::Binary(bin)) => ctx.binary(bin),
            Ok(ws::Message::Close(reason)) => {
                ctx.close(reason);
                ctx.stop();
            }
            _ => ctx.stop(),
        }
    }
}

impl GameConnection {
    pub fn new(server_addr: Addr<Server>) -> Self {
        GameConnection {
            heartbeat: Instant::now(),
            nick: None,
            game_id: None,
            server: server_addr,
            game_lobby: None
        }
    }

    pub fn initiate_heartbeat(&self, ctx: &mut <Self as Actor>::Context) {
        ctx.run_interval(HEARTBEAT_INTERVAL, |act, ctx| {
            if Instant::now().duration_since(act.heartbeat) > CLIENT_TIMEOUT {
                //println!("Websocket Client heartbeat failed, disconnecting!");
                ctx.stop();
                return;
            }
            ctx.ping(b"");
        });
    }

    pub fn send_message(&self, m: &UpdateMessage, ctx: &mut <Self as Actor>::Context) {
        let txt = serde_json::to_string(m).unwrap();
        println!("{:?}", txt);
        ctx.text(txt);
    }

    pub fn received_message(&mut self, text: &str, ctx: &mut <Self as Actor>::Context) {
        let parsed: Result<ClientMessage, _> = serde_json::from_str(text);
        if let Ok(msg) = parsed {
            match msg {
                ClientMessage::CreateGame{game_id, nick} => {
                    self.game_id = Some(game_id.clone());
                    self.nick = Some(nick);
                    self.server.do_send(CreateLobbyRequest{
                        lobby_id: game_id.clone(),
                        p: ctx.address()
                    });
                },
                ClientMessage::Join{game_id, nick} => {
                    self.server.do_send(JoinRequest{ lobby_id: game_id.clone(), nick: nick.clone(), p: ctx.address() });
                    self.game_id = Some(game_id.clone());
                    self.nick = Some(nick);
                },
                ClientMessage::Ready => {
                    if let Some(lobby) = &self.game_lobby {
                        if let Some(nick) = &self.nick {
                            lobby.do_send(ReadyMsg(nick.clone()));
                        }
                    }
                },
                ClientMessage::SubmitWord{ word } => {
                    if let Some(lobby) = &self.game_lobby {
                        if let Some(nick) = &self.nick {
                            lobby.do_send(SubmitWordMsg{ word: word, nick: nick.clone() });
                        }
                    }
                },
                ClientMessage::SubmitGuess{ guesses } => {
                    if let Some(lobby) = &self.game_lobby {
                        if let Some(nick) = &self.nick {
                            lobby.do_send(SubmitGuessMsg{ guesses: guesses, nick: nick.clone() });
                        }
                    }
                }
            }
        }
        else {
            println!("error parsing json");
        }
    }
}