EN605.607.81.SP22_ASDM_Project/back_end/src/db_handler.rs

1018 lines
37 KiB
Rust
Raw Normal View History

use crate::ai::{get_ai_choice, AIDifficulty};
use crate::constants::{
COLS, GAME_CLEANUP_TIMEOUT, PLAYER_CLEANUP_TIMEOUT, PLAYER_COUNT_LIMIT, ROWS, TURN_SECONDS,
};
use crate::state::{board_from_string, new_string_board, string_from_board, BoardState, Turn};
use std::sync::mpsc::{Receiver, RecvTimeoutError, SyncSender};
use std::time::Duration;
use std::{fmt, thread};
use rand::{thread_rng, Rng};
use rusqlite::{params, Connection, Error as RusqliteError};
pub type GetIDSenderType = (u32, Option<bool>);
/// first bool is player exists,
/// second bool is if paired,
/// third bool is if cyan player
pub type CheckPairingType = (bool, bool, bool);
pub type BoardStateType = (DBGameState, Option<String>);
pub type PlaceResultType = Result<(DBPlaceStatus, Option<String>), DBPlaceError>;
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum DBGameState {
CyanTurn,
MagentaTurn,
CyanWon,
MagentaWon,
Draw,
NotPaired,
OpponentDisconnected,
UnknownID,
InternalError,
}
impl fmt::Display for DBGameState {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
DBGameState::CyanTurn => write!(f, "cyan_turn"),
DBGameState::MagentaTurn => write!(f, "magenta_turn"),
DBGameState::CyanWon => write!(f, "cyan_won"),
DBGameState::MagentaWon => write!(f, "magenta_won"),
DBGameState::Draw => write!(f, "draw"),
DBGameState::NotPaired => write!(f, "not_paired"),
DBGameState::OpponentDisconnected => write!(f, "opponent_disconnected"),
DBGameState::UnknownID => write!(f, "unknown_id"),
DBGameState::InternalError => write!(f, "internal_error"),
}
}
}
impl From<i64> for DBGameState {
fn from(value: i64) -> Self {
match value {
0 => DBGameState::CyanTurn,
1 => DBGameState::MagentaTurn,
2 => DBGameState::CyanWon,
3 => DBGameState::MagentaWon,
4 => DBGameState::Draw,
_ => DBGameState::InternalError,
}
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum DBPlaceStatus {
Accepted,
GameEndedDraw,
GameEndedCyanWon,
GameEndedMagentaWon,
}
impl fmt::Display for DBPlaceStatus {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
DBPlaceStatus::Accepted => write!(f, "accepted"),
DBPlaceStatus::GameEndedDraw => write!(f, "game_ended_draw"),
DBPlaceStatus::GameEndedCyanWon => write!(f, "game_ended_cyan_won"),
DBPlaceStatus::GameEndedMagentaWon => write!(f, "game_ended_magenta_won"),
}
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum DBPlaceError {
NotPairedYet,
NotYourTurn,
Illegal,
OpponentDisconnected,
UnknownID,
InternalError,
}
impl fmt::Display for DBPlaceError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
DBPlaceError::NotPairedYet => write!(f, "not_paired_yet"),
DBPlaceError::NotYourTurn => write!(f, "not_your_turn"),
DBPlaceError::Illegal => write!(f, "illegal"),
DBPlaceError::OpponentDisconnected => write!(f, "opponent_disconnected"),
DBPlaceError::UnknownID => write!(f, "unknown_id"),
DBPlaceError::InternalError => write!(f, "internal_error"),
}
}
}
#[derive(Clone, Debug)]
pub enum DBHandlerRequest {
GetID(SyncSender<GetIDSenderType>),
CheckPairing {
id: u32,
response_sender: SyncSender<CheckPairingType>,
},
GetGameState {
id: u32,
response_sender: SyncSender<BoardStateType>,
},
DisconnectID {
id: u32,
response_sender: SyncSender<bool>,
},
PlaceToken {
id: u32,
pos: usize,
response_sender: SyncSender<PlaceResultType>,
},
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
enum DBFirstRun {
FirstRun,
NotFirstRun,
}
struct DBHandler {
rx: Receiver<DBHandlerRequest>,
sqlite_path: String,
shutdown_tx: SyncSender<()>,
}
impl DBHandler {
/// Returns true if should break out of outer loop
fn handle_request(&mut self) -> bool {
let rx_recv_result = self.rx.recv_timeout(Duration::from_secs(1));
if let Err(RecvTimeoutError::Timeout) = rx_recv_result {
return false;
} else if let Err(e) = rx_recv_result {
println!("Failed to get DBHandlerRequest: {:?}", e);
self.shutdown_tx.send(()).ok();
return false;
}
let db_request = rx_recv_result.unwrap();
match db_request {
DBHandlerRequest::GetID(player_tx) => {
// got request to create new player, create new player
let conn_result = self.get_conn(DBFirstRun::NotFirstRun);
if let Err(e) = conn_result {
println!("{}", e);
return true;
}
let conn = conn_result.unwrap();
let create_player_result = self.create_new_player(Some(&conn));
if let Err(e) = create_player_result {
println!("{}", e);
// don't stop server because player limit may have been reached
return false;
}
let player_id = create_player_result.unwrap();
let pair_up_result = self.pair_up_players(Some(&conn));
if let Err(e) = pair_up_result {
println!("{}", e);
return true;
}
// Check if current player has been paired
let paired_check_result = self.check_if_player_is_paired(Some(&conn), player_id);
if let Err(e) = paired_check_result {
println!("{}", e);
return true;
} else if let Ok((exists, paired, is_cyan)) = paired_check_result {
if exists {
if paired {
// don't stop server on send fail, may have timed
// out and dropped the receiver
player_tx.send((player_id, Some(is_cyan))).ok();
} else {
// don't stop server on send fail, may have timed
// out and dropped the receiver
player_tx.send((player_id, None)).ok();
}
} else {
println!("Internal error, created player doesn't exist");
return true;
}
} else {
unreachable!();
}
}
DBHandlerRequest::CheckPairing {
id,
response_sender,
} => {
if let Ok((exists, is_paired, is_cyan)) = self.check_if_player_is_paired(None, id) {
// don't stop server on send fail, may have timed out and
// dropped the receiver
response_sender.send((exists, is_paired, is_cyan)).ok();
} else {
// On error, just respond that the given player_id doesn't
// exist
response_sender.send((false, false, true)).ok();
}
}
DBHandlerRequest::GetGameState {
id,
response_sender,
} => {
let get_board_result = self.get_board_state(None, id);
if let Err(e) = get_board_result {
println!("{}", e);
// don't stop server on send fail, may have timed out and
// dropped the receiver
response_sender.send((DBGameState::UnknownID, None)).ok();
return false;
}
// don't stop server on send fail, may have timed out and
// dropped the receiver
response_sender.send(get_board_result.unwrap()).ok();
}
DBHandlerRequest::DisconnectID {
id,
response_sender,
} => {
// don't stop server on send fail, may have timed out and
// dropped the receiver
response_sender
.send(self.disconnect_player(None, id).is_ok())
.ok();
}
DBHandlerRequest::PlaceToken {
id,
pos,
response_sender,
} => {
let place_result = self.place_token(None, id, pos);
// don't stop server on send fail, may have timed out and
// dropped the receiver
response_sender.send(place_result).ok();
}
} // match db_request
false
}
fn get_conn(&self, first_run: DBFirstRun) -> Result<Connection, String> {
if let Ok(conn) = Connection::open(&self.sqlite_path) {
conn.execute("PRAGMA foreign_keys = ON;", [])
.map_err(|e| format!("Should be able to handle \"foreign_keys\": {:?}", e))?;
let result = conn.execute(
"
CREATE TABLE players (id INTEGER PRIMARY KEY NOT NULL,
date_added TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
game_id INTEGER,
FOREIGN KEY(game_id) REFERENCES games(id) ON DELETE CASCADE);
",
[],
);
if result.is_ok() {
if first_run == DBFirstRun::FirstRun {
println!("Created \"players\" table");
}
} else if first_run == DBFirstRun::FirstRun {
println!("\"players\" table exists");
}
let result = conn.execute(
"
CREATE TABLE games (id INTEGER PRIMARY KEY NOT NULL,
cyan_player INTEGER UNIQUE,
magenta_player INTEGER UNIQUE,
date_added TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
board TEXT NOT NULL,
status INTEGER NOT NULL,
turn_time_start TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY(cyan_player) REFERENCES players (id) ON DELETE SET NULL,
FOREIGN KEY(magenta_player) REFERENCES players (id) ON DELETE SET NULL);
",
[],
);
if result.is_ok() {
if first_run == DBFirstRun::FirstRun {
println!("Created \"games\" table");
}
} else if first_run == DBFirstRun::FirstRun {
println!("\"games\" table exists");
}
Ok(conn)
} else {
Err(String::from("Failed to open connection"))
}
}
fn create_new_player(&self, conn: Option<&Connection>) -> Result<u32, String> {
if conn.is_none() {
return self.create_new_player(Some(&self.get_conn(DBFirstRun::NotFirstRun)?));
}
let conn = conn.unwrap();
let row_result: Result<usize, _> =
conn.query_row("SELECT count(id) FROM players;", [], |row| row.get(0));
if let Ok(count) = row_result {
if count > PLAYER_COUNT_LIMIT {
return Err(String::from(
"Player limit reached, cannot create new players",
));
}
} else {
return Err(String::from("Failed to get player count in db"));
}
let mut player_id: u32 = thread_rng().gen();
loop {
let exists_result = self.check_if_player_exists(Some(conn), player_id);
if let Ok(exists) = exists_result {
if exists {
player_id = thread_rng().gen();
} else {
break;
}
} else {
let error = exists_result.unwrap_err();
return Err(format!(
"Failed to check if player exists in db: {:?}",
error
));
}
}
let insert_result = conn.execute("INSERT INTO players (id) VALUES (?);", [player_id]);
if let Err(e) = insert_result {
return Err(format!("Failed to insert player into db: {:?}", e));
}
Ok(player_id)
}
fn pair_up_players(&self, conn: Option<&Connection>) -> Result<(), String> {
if conn.is_none() {
return self.pair_up_players(Some(&self.get_conn(DBFirstRun::NotFirstRun)?));
}
let conn = conn.unwrap();
let mut to_pair: Option<u32> = None;
let mut unpaired_players_stmt = conn
.prepare("SELECT id FROM players WHERE game_id ISNULL ORDER BY date_added;")
.map_err(|e| format!("{:?}", e))?;
let mut unpaired_players_rows = unpaired_players_stmt
.query([])
.map_err(|e| format!("{:?}", e))?;
while let Some(row) = unpaired_players_rows
.next()
.map_err(|e| format!("{:?}", e))?
{
if to_pair.is_none() {
to_pair = Some(row.get(0).map_err(|e| format!("{:?}", e))?);
} else {
let players: [u32; 2] = [
to_pair.take().unwrap(),
row.get(0).map_err(|e| format!("{:?}", e))?,
];
self.create_game(Some(conn), &players)?;
}
}
Ok(())
}
fn create_game(&self, conn: Option<&Connection>, players: &[u32; 2]) -> Result<u32, String> {
if conn.is_none() {
return self.create_game(Some(&self.get_conn(DBFirstRun::NotFirstRun)?), players);
}
let conn = conn.unwrap();
let mut game_id: u32 = thread_rng().gen();
{
let mut get_game_stmt = conn
.prepare("SELECT id FROM games WHERE id = ?;")
.map_err(|e| format!("{:?}", e))?;
while get_game_stmt.query_row([game_id], |_row| Ok(())).is_ok() {
game_id = thread_rng().gen();
}
}
// TODO randomize players (or first-come-first-serve ok to do?)
conn.execute(
"INSERT INTO games (id, cyan_player, magenta_player, board, status) VALUES (?, ?, ?, ?, 0);",
params![game_id, players[0], players[1], new_string_board()]
)
.map_err(|e| format!("{:?}", e))?;
conn.execute(
"UPDATE players SET game_id = ? WHERE id = ?",
[game_id, players[0]],
)
.map_err(|e| format!("{:?}", e))?;
conn.execute(
"UPDATE players SET game_id = ? WHERE id = ?",
[game_id, players[1]],
)
.map_err(|e| format!("{:?}", e))?;
Ok(game_id)
}
fn check_if_player_is_paired(
&self,
conn: Option<&Connection>,
player_id: u32,
) -> Result<CheckPairingType, String> {
{
let player_exists_result = self.check_if_player_exists(None, player_id);
if player_exists_result.is_err() || !player_exists_result.unwrap() {
// player doesn't exist
return Ok((false, false, true));
}
}
if conn.is_none() {
return self.check_if_player_is_paired(
Some(&self.get_conn(DBFirstRun::NotFirstRun)?),
player_id,
);
}
let conn = conn.unwrap();
let check_player_row = conn.query_row("SELECT games.cyan_player FROM players JOIN games where games.id = players.game_id AND players.id = ?;", [player_id], |row| row.get::<usize, u32>(0));
if let Ok(cyan_player) = check_player_row {
if cyan_player == player_id {
// is cyan player
Ok((true, true, true))
} else {
// is magenta player
Ok((true, true, false))
}
} else if let Err(rusqlite::Error::QueryReturnedNoRows) = check_player_row {
// either does not exist or is not paired
let exists_check_result = self.check_if_player_exists(Some(conn), player_id);
if let Ok(exists) = exists_check_result {
if exists {
Ok((true, false, true))
} else {
Ok((false, false, true))
}
} else {
// pass the error contained in result, making sure the Ok type
// is the expected type
exists_check_result.map(|_| (false, false, false))
}
} else if let Err(e) = check_player_row {
Err(format!("check_if_player_is_paired: {:?}", e))
} else {
unreachable!("All possible Ok and Err results are already checked");
}
}
fn check_if_player_exists(
&self,
conn: Option<&Connection>,
player_id: u32,
) -> Result<bool, String> {
if conn.is_none() {
return self
.check_if_player_exists(Some(&self.get_conn(DBFirstRun::NotFirstRun)?), player_id);
}
let conn = conn.unwrap();
let check_player_row: Result<u32, _> =
conn.query_row("SELECT id FROM players WHERE id = ?;", [player_id], |row| {
row.get(0)
});
if let Ok(_id) = check_player_row {
Ok(true)
} else {
Ok(false)
}
}
fn check_if_player_in_game(
&self,
conn: Option<&Connection>,
player_id: u32,
) -> Result<bool, String> {
if conn.is_none() {
return self.check_if_player_in_game(
Some(&self.get_conn(DBFirstRun::NotFirstRun)?),
player_id,
);
}
let conn = conn.unwrap();
let check_player_game_row: Result<u32, _> = conn.query_row(
"SELECT games.id FROM games JOIN players WHERE players.id = ? AND players.game_id NOTNULL AND players.game_id = games.id;",
[player_id],
|row| row.get(0));
if check_player_game_row.is_ok() {
Ok(true)
} else {
Ok(false)
}
}
fn get_board_state(
&self,
conn: Option<&Connection>,
player_id: u32,
) -> Result<BoardStateType, String> {
if conn.is_none() {
return self.get_board_state(Some(&self.get_conn(DBFirstRun::NotFirstRun)?), player_id);
}
let conn = conn.unwrap();
// TODO maybe handle "opponent_disconnected" case
let row_result: Result<(String, i64, Option<u32>, Option<u32>), RusqliteError> = conn.query_row(
"SELECT games.board, games.status, games.cyan_player, games.magenta_player FROM games JOIN players WHERE players.id = ? AND games.id = players.game_id;",
[player_id],
|row| {
let board_result = row.get(0);
let status_result = row.get(1);
let cyan_player = row.get(2);
let magenta_player = row.get(3);
if board_result.is_ok() && status_result.is_ok() && cyan_player.is_ok() && magenta_player.is_ok() {
if let (Ok(board), Ok(status), Ok(cyan_id), Ok(magenta_id)) = (board_result, status_result, cyan_player, magenta_player) {
Ok((board, status, cyan_id, magenta_id))
} else {
unreachable!("Both row items should be Ok");
}
} else if board_result.is_err() {
board_result
.map(|_| (String::from("this value should never be returned"), 0, None, None))
} else if status_result.is_err() {
status_result
.map(|_| (String::from("this value should never be returned"), 0, None, None))
} else if cyan_player.is_err() {
cyan_player
.map(|_| (String::from("this value should never be returned"), 0, None, None))
} else {
magenta_player
.map(|_| (String::from("this value should never be returned"), 0, None, None))
}
}
);
if let Ok((board, status, cyan_opt, magenta_opt)) = row_result {
if board.len() != (ROWS * COLS) as usize {
// board is invalid size
Ok((DBGameState::InternalError, None))
} else if cyan_opt.is_none() || magenta_opt.is_none() {
// One player disconnected
self.disconnect_player(Some(conn), player_id).ok();
// Remove the game(s) with disconnected players
if self.clear_empty_games(Some(conn)).is_err() {
Ok((DBGameState::InternalError, None))
} else if status == 2 || status == 3 {
Ok((DBGameState::from(status), Some(board)))
} else {
Ok((DBGameState::OpponentDisconnected, Some(board)))
}
} else {
// Game in progress, or other state depending on "status"
Ok((DBGameState::from(status), Some(board)))
}
} else if let Err(RusqliteError::QueryReturnedNoRows) = row_result {
// No rows is either player doesn't exist or not paired
let (exists, is_paired, _is_cyan) =
self.check_if_player_is_paired(Some(conn), player_id)?;
if !exists {
Ok((DBGameState::UnknownID, None))
} else if !is_paired {
Ok((DBGameState::NotPaired, None))
} else {
unreachable!("either exists or is_paired must be false");
}
} else {
// TODO use internal error enum instead of string
Err(String::from("internal_error"))
}
}
fn disconnect_player(&self, conn: Option<&Connection>, player_id: u32) -> Result<(), String> {
if conn.is_none() {
return self
.disconnect_player(Some(&self.get_conn(DBFirstRun::NotFirstRun)?), player_id);
}
let conn = conn.unwrap();
let stmt_result = conn.execute("DELETE FROM players WHERE id = ?;", [player_id]);
if let Ok(1) = stmt_result {
Ok(())
} else {
Err(String::from("id not found"))
}
}
fn clear_empty_games(&self, conn: Option<&Connection>) -> Result<(), String> {
if conn.is_none() {
return self.clear_empty_games(Some(&self.get_conn(DBFirstRun::NotFirstRun)?));
}
let conn = conn.unwrap();
// Only fails if no rows were removed, and that is not an issue
conn.execute(
"DELETE FROM games WHERE cyan_player ISNULL AND magenta_player ISNULL;",
[],
)
.ok();
Ok(())
}
fn place_token(
&self,
conn: Option<&Connection>,
player_id: u32,
pos: usize,
) -> PlaceResultType {
if conn.is_none() {
return self.place_token(
Some(
&self
.get_conn(DBFirstRun::NotFirstRun)
.map_err(|_| DBPlaceError::InternalError)?,
),
player_id,
pos,
);
}
let conn = conn.unwrap();
// check if player exists
let player_exist_check_result = self.check_if_player_exists(Some(conn), player_id);
if let Ok(exists) = player_exist_check_result {
if !exists {
return Err(DBPlaceError::UnknownID);
}
} else {
return Err(DBPlaceError::InternalError);
}
// check if player belongs to a game
let player_game_result = self.check_if_player_in_game(Some(conn), player_id);
if let Ok(is_in_game) = player_game_result {
if !is_in_game {
return Err(DBPlaceError::NotPairedYet);
}
} else {
return Err(DBPlaceError::InternalError);
}
// check if player is cyan or magenta
let query_result_result: Result<Result<(bool, u32, String), DBPlaceError>, _> =
conn.query_row(
"SELECT cyan_player, magenta_player, status, board FROM games JOIN players WHERE players.id = ? AND players.game_id = games.id;",
[player_id],
|row| {
let cyan_id_result: Result<Option<u32>, _> = row.get(0);
let magenta_id_result: Result<Option<u32>, _> = row.get(1);
let status_result: Result<u32, _> = row.get(2);
let board_result: Result<String, _> = row.get(3);
if status_result.is_err() {
return status_result.map(|_| Ok((false, 0, "".into())));
}
let status: u32 = status_result.unwrap();
if board_result.is_err() {
return board_result.map(|_| Ok((false, 0, "".into())));
}
let board = board_result.unwrap();
if cyan_id_result.is_ok() && magenta_id_result.is_ok() {
if let (Ok(cyan_id_opt), Ok(magenta_id_opt)) = (cyan_id_result, magenta_id_result) {
if let (Some(cyan_id), Some(_magenta_id)) = (cyan_id_opt, magenta_id_opt) {
Ok(Ok((cyan_id == player_id, status, board)))
} else if (2..=4).contains(&status) {
// game has ended, don't return error
// first result will be safely ignored
Ok(Ok((false, status, board)))
} else {
Ok(Err(DBPlaceError::OpponentDisconnected))
}
} else {
unreachable!("both row items should be Ok")
}
} else if cyan_id_result.is_err() {
cyan_id_result.map(|_| Err(DBPlaceError::InternalError))
} else {
magenta_id_result.map(|_| Err(DBPlaceError::InternalError))
}
});
let query_result = query_result_result.map_err(|_| DBPlaceError::InternalError)?;
// if opponent has disconnected, disconnect the remaining player as well
if let Err(DBPlaceError::OpponentDisconnected) = query_result {
self.disconnect_player(Some(conn), player_id).ok();
if self.clear_empty_games(Some(conn)).is_err() {
return Err(DBPlaceError::InternalError);
}
}
let (is_cyan, status, board_string) = query_result?;
match status {
0 => {
// cyan's turn
if !is_cyan {
return Err(DBPlaceError::NotYourTurn);
}
}
1 => {
// magenta's turn
if is_cyan {
return Err(DBPlaceError::NotYourTurn);
}
}
2 => {
// game over, cyan won
self.disconnect_player(Some(conn), player_id).ok();
if self.clear_empty_games(Some(conn)).is_err() {
return Err(DBPlaceError::InternalError);
}
return Ok((DBPlaceStatus::GameEndedCyanWon, Some(board_string)));
}
3 => {
// game over, magenta won
self.disconnect_player(Some(conn), player_id).ok();
if self.clear_empty_games(Some(conn)).is_err() {
return Err(DBPlaceError::InternalError);
}
return Ok((DBPlaceStatus::GameEndedMagentaWon, Some(board_string)));
}
4 => {
// game over, draw
self.disconnect_player(Some(conn), player_id).ok();
if self.clear_empty_games(Some(conn)).is_err() {
return Err(DBPlaceError::InternalError);
}
return Ok((DBPlaceStatus::GameEndedDraw, Some(board_string)));
}
_ => (),
}
// get board state
let board = board_from_string(board_string);
// find placement position or return "illegal move" if unable to
let mut final_pos = pos;
loop {
if board[final_pos].get() == BoardState::Empty {
if final_pos + COLS as usize >= board.len()
|| board[final_pos + COLS as usize].get() != BoardState::Empty
{
break;
} else if board[final_pos + COLS as usize].get() == BoardState::Empty {
final_pos += COLS as usize;
}
} else {
return Err(DBPlaceError::Illegal);
}
}
// place into board
if is_cyan {
board[final_pos].replace(BoardState::Cyan);
} else {
board[final_pos].replace(BoardState::Magenta);
}
// board back to string
let (board_string, ended_state_opt) = string_from_board(board, final_pos);
// update DB
let update_result = if ended_state_opt.is_none() {
conn.execute(
"UPDATE games SET status = ?, board = ?, turn_time_start = datetime() FROM players WHERE players.game_id = games.id AND players.id = ?;",
params![if status == 0 { 1u8 }
else { 0u8 },
board_string,
player_id]
)
} else {
conn.execute(
"UPDATE games SET status = ?, board = ? FROM players WHERE players.game_id = games.id AND players.id = ?;",
params![if ended_state_opt.unwrap() == BoardState::Empty { 4u8 }
else if ended_state_opt.unwrap() == BoardState::CyanWin { 2u8 }
else { 3u8 },
board_string,
player_id]
)
};
if let Err(_e) = update_result {
return Err(DBPlaceError::InternalError);
} else if let Ok(count) = update_result {
if count != 1 {
return Err(DBPlaceError::InternalError);
}
}
if let Some(ended_state) = ended_state_opt {
self.disconnect_player(Some(conn), player_id).ok();
Ok((
match ended_state {
BoardState::Empty => DBPlaceStatus::GameEndedDraw,
BoardState::Cyan | BoardState::Magenta => unreachable!(),
BoardState::CyanWin => DBPlaceStatus::GameEndedCyanWon,
BoardState::MagentaWin => DBPlaceStatus::GameEndedMagentaWon,
},
Some(board_string),
))
} else {
Ok((DBPlaceStatus::Accepted, Some(board_string)))
}
}
fn check_turn_times(&self) -> Result<(), String> {
let conn = self.get_conn(DBFirstRun::NotFirstRun)?;
let mut prepared_stmt = conn
.prepare(
"SELECT id, status, board FROM games WHERE unixepoch() - unixepoch(turn_time_start) > ? AND cyan_player NOTNULL and magenta_player NOTNULL AND status < 2;",
)
.map_err(|_| String::from("Failed to prepare db query based on turn time"))?;
let rows = prepared_stmt
.query_map([TURN_SECONDS], |row| {
let id_result = row.get(0);
let status_result = row.get(1);
let board_result = row.get(2);
if id_result.is_ok() && status_result.is_ok() && board_result.is_ok() {
if let (Ok(id), Ok(status), Ok(board)) =
(id_result, status_result, board_result)
{
Ok((id, status, board))
} else {
unreachable!();
}
} else if id_result.is_err() {
id_result.map(|_| (0, 0, String::new()))
} else if status_result.is_err() {
status_result.map(|_| (0, 0, String::new()))
} else {
board_result.map(|_| (0, 0, String::new()))
}
})
.map_err(|_| String::from("Failed to query db based on turn time"))?;
for row_result in rows {
if let Ok((id, status, board)) = row_result {
self.have_ai_take_players_turn(Some(&conn), id, status, board)?;
} else {
unreachable!("This part should never execute");
}
}
Ok(())
}
fn have_ai_take_players_turn(
&self,
conn: Option<&Connection>,
game_id: u32,
status: u32,
board_string: String,
) -> Result<(), String> {
if status > 1 {
return Err(String::from(
"have_ai_take_players_turn: got invalid status",
));
}
if conn.is_none() {
return self.have_ai_take_players_turn(
Some(&self.get_conn(DBFirstRun::NotFirstRun)?),
game_id,
status,
board_string,
);
}
let conn = conn.unwrap();
let is_cyan = status == 0;
let board = board_from_string(board_string);
let mut ai_choice_pos: usize = get_ai_choice(
AIDifficulty::Hard,
if is_cyan {
Turn::CyanPlayer
} else {
Turn::MagentaPlayer
},
&board,
)
.map_err(|_| String::from("Failed to get ai choice on turn timeout"))?
.into();
if board[ai_choice_pos].get() != BoardState::Empty {
return Err(String::from("ai returned illegal move on turn timeout"));
}
// get final position of token
loop {
if board.len() <= ai_choice_pos + COLS as usize {
break;
} else if board[ai_choice_pos + COLS as usize].get() == BoardState::Empty {
ai_choice_pos += COLS as usize;
} else {
break;
}
}
// place token
board[ai_choice_pos].replace(if is_cyan {
BoardState::Cyan
} else {
BoardState::Magenta
});
// get board string from board while checking if game has ended
let (board_string, end_state_opt) = string_from_board(board, ai_choice_pos);
let state;
if let Some(board_state) = end_state_opt {
if board_state == BoardState::Empty {
state = 4;
} else if board_state.from_win() == BoardState::Cyan {
state = 2;
} else if board_state.from_win() == BoardState::Magenta {
state = 3;
} else {
unreachable!();
}
} else {
state = if is_cyan { 1 } else { 0 };
}
conn.execute(
"UPDATE games SET board = ?, status = ?, turn_time_start = datetime() WHERE id = ?;",
params![board_string, state, game_id],
)
.map_err(|_| String::from("Failed to update game with ai choice on turn timeout"))?;
Ok(())
}
fn cleanup_stale_games(&self, conn: Option<&Connection>) -> Result<(), String> {
if conn.is_none() {
return self.cleanup_stale_games(Some(&self.get_conn(DBFirstRun::NotFirstRun)?));
}
let conn = conn.unwrap();
conn.execute(
"DELETE FROM games WHERE unixepoch() - unixepoch(date_added) > ?;",
[GAME_CLEANUP_TIMEOUT],
)
.ok();
Ok(())
}
fn cleanup_stale_players(&self, conn: Option<&Connection>) -> Result<(), String> {
if conn.is_none() {
return self.cleanup_stale_games(Some(&self.get_conn(DBFirstRun::NotFirstRun)?));
}
let conn = conn.unwrap();
conn.execute(
"DELETE FROM players WHERE unixepoch() - unixepoch(date_added) > ? AND game_id ISNULL;",
[PLAYER_CLEANUP_TIMEOUT],
)
.ok();
Ok(())
}
}
pub fn start_db_handler_thread(
rx: Receiver<DBHandlerRequest>,
sqlite_path: String,
shutdown_tx: SyncSender<()>,
) {
let mut handler = DBHandler {
rx,
sqlite_path,
shutdown_tx,
};
thread::spawn(move || {
// temporarily get conn which should initialize on first setup of db
if let Ok(_conn) = handler.get_conn(DBFirstRun::FirstRun) {
} else {
println!("ERROR: Failed init sqlite db connection");
handler.shutdown_tx.send(()).ok();
return;
}
'outer: loop {
if handler.handle_request() {
handler.shutdown_tx.send(()).ok();
break 'outer;
}
if let Err(e) = handler.check_turn_times() {
println!("{}", e);
}
if let Err(e) = handler.cleanup_stale_games(None) {
println!("{}", e);
}
if let Err(e) = handler.cleanup_stale_players(None) {
println!("{}", e);
}
}
});
}