Feature/bknd python

.gitignore

@@ -0,0 +1,3 @@
+**/__pycache__
+**/.idea
+venv/

docker-compose.yaml

@@ -0,0 +1,36 @@
+version: "3.8"
+
+services:
+  rust_service:
+    build: rust-server/
+    ports:
+      - 8080:8080
+    depends_on:
+      - postgres_db
+
+  python_service:
+    build: web-app/
+    environment:
+      FLASK_ENV: development
+      FLASK_APP: app_start.py
+    ports:
+      - 8888:8888
+    depends_on:
+      - postgres_db
+
+  postgres_db:
+    image: postgres
+    container_name: database
+    restart: always
+    environment:
+      POSTGRES_DB: test
+      POSTGRES_USER: test
+      POSTGRES_PASSWORD: test
+    ports:
+      - 5432:5432
+    volumes:
+      - postgres_db:/var/lib/postgresql/data
+
+
+volumes:
+    postgres_db:

rust-server/.dockerignore

@@ -0,0 +1 @@
+target

rust-server/.gitignore

@@ -0,0 +1,2 @@
+target/
+Cargo.lock

rust-server/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "rust-server"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+rand = "0.8.5"
+rocket = { version = "=0.5.0-rc.2", features = ["json"] }
+async-trait = "0.1.56"
+
+[dependencies.sqlx]
+version = "0.5.13"
+default-features = false
+features = ["runtime-tokio-native-tls", "macros", "offline", "any", "postgres", "mysql", "sqlite", "mssql"]

rust-server/Dockerfile

@@ -0,0 +1,7 @@
+FROM rust:1.61
+
+COPY ./ ./
+COPY Cargo.toml Cargo.toml
+
+RUN cargo build --release
+CMD ["./target/release/rust-server"]

rust-server/README.md

@@ -0,0 +1,11 @@
+# Building
+
+Install rust using rustup [here](https://www.rust-lang.org/tools/install)
+
+Build the project using
+
+```rust
+cargo build --release
+```
+
+The executable file will be generated at `target/release/`

rust-server/src/database/mod.rs

@@ -0,0 +1,38 @@
+use async_trait::async_trait;
+pub use sqlx::any::AnyPool as DBPool;
+
+pub mod sql;
+
+pub type QuizId = u64;
+
+/// The type of error that may occur when interacting
+/// with the database
+#[derive(Debug)]
+pub enum DBError {
+    /// A game could not be created because another
+    /// with confliting properties already exists
+    QuizNotFound(QuizId),
+    /// The database is corrupted and could not be
+    /// processed properly
+    DBCorrupt(String),
+    /// Some other error occured
+    Other(Box<dyn std::error::Error>),
+}
+
+pub type DBResult<T> = Result<T, DBError>;
+
+/// Trait representing a handler for the database
+#[async_trait]
+pub trait DBAccessor: Send + Sync {}
+
+impl std::fmt::Display for DBError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::QuizNotFound(id) => write!(f, "Failed to find a quiz with id: {id}"),
+            Self::DBCorrupt(msg) => write!(f, "Database is corrupted: {msg}"),
+            Self::Other(error) => error.fmt(f),
+        }
+    }
+}
+
+impl std::error::Error for DBError {}

rust-server/src/database/sql.rs

@@ -0,0 +1,31 @@
+use super::*;
+
+use sqlx::AnyPool;
+
+/// Handles access to the postgres games database
+pub struct SqlAccess {
+    pool: AnyPool,
+}
+
+impl SqlAccess {
+    /// Sets up access to the database and initializes all the neccessary tables
+    pub async fn new(db_uri: &str) -> DBResult<Self> {
+        let pool = DBPool::connect(db_uri).await?;
+        let sql = Self { pool }.init().await?;
+        Ok(sql)
+    }
+
+    /// Initialize all the neccessary database stuff
+    async fn init(self) -> DBResult<Self> {
+        Ok(self)
+    }
+}
+
+#[async_trait]
+impl DBAccessor for SqlAccess {}
+
+impl From<sqlx::Error> for DBError {
+    fn from(error: sqlx::Error) -> Self {
+        Self::Other(Box::new(error))
+    }
+}

rust-server/src/main.rs

@@ -0,0 +1,16 @@
+mod database;
+mod server;
+
+#[cfg(test)]
+mod tests;
+
+#[rocket::launch]
+async fn launch() -> _ {
+    let config = rocket::Config {
+        log_level: rocket::log::LogLevel::Debug,
+        address: std::net::Ipv4Addr::new(0, 0, 0, 0).into(),
+        port: 8080,
+        ..Default::default()
+    };
+    server::rocket(config, "postgresql://test:test@postgres_db:5432/test").await
+}

rust-server/src/server/games.rs

@@ -0,0 +1,89 @@
+use rocket::serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(crate = "rocket::serde")]
+pub struct Games {
+    map: HashMap<GameCode, Game>,
+}
+
+/// Represents different states of a game
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[serde(crate = "rocket::serde")]
+pub enum GameState {
+    /// Initial state of the game
+    Lobby,
+    InProgress,
+    Finished,
+}
+
+pub type GameCode = String;
+pub type PlayerName = String;
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(crate = "rocket::serde")]
+pub struct Player {}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(crate = "rocket::serde")]
+pub struct Game {
+    players: HashMap<PlayerName, Player>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(crate = "rocket::serde")]
+pub struct GameAnswer {}
+
+impl Games {
+    pub fn new() -> Self {
+        Self {
+            map: HashMap::new(),
+        }
+    }
+
+    pub fn create_game(&mut self) -> GameCode {
+        let code = loop {
+            let code = game_code_generator();
+            if !self.map.contains_key(&code) {
+                break code;
+            }
+        };
+        let game = Game::new();
+        let res = self.map.insert(code.clone(), game);
+        assert!(res.is_none());
+        code
+    }
+
+    pub fn get_game(&self, code: &GameCode) -> Option<&Game> {
+        self.map.get(code)
+    }
+
+    pub fn get_game_mut(&mut self, code: &GameCode) -> Option<&mut Game> {
+        self.map.get_mut(code)
+    }
+}
+
+impl Game {
+    pub fn new() -> Self {
+        Self {
+            players: HashMap::new(),
+        }
+    }
+
+    pub fn player_join(&mut self, player_name: PlayerName) {
+        self.players.entry(player_name).or_insert_with(|| Player {});
+    }
+}
+
+pub fn game_code_generator() -> GameCode {
+    use rand::Rng;
+    const LEN: usize = 4;
+
+    let mut rng = rand::thread_rng();
+    let mut code = String::new();
+    for _ in 0..LEN {
+        let symbol = rng.gen_range('A'..='Z');
+        code.push(symbol);
+    }
+    code
+}