bitbroker 0.1.0

A language agnostic message broker designed for real-time communication.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

use std::collections::HashMap;

use tracing::info;

use crate::{broker::ConnectionListener, BitBrokerMessage, Connection, Error, Result};

pub struct BrokerSetup {
    pub players: HashMap<u8, Connection>,
    num_players: usize,
    pub game: Option<Connection>,
}

impl BrokerSetup {
    pub fn new(num_players: usize) -> Self {
        Self {
            players: HashMap::new(),
            num_players,
            game: None,
        }
    }

    pub async fn run(mut self, host: &str, port: usize) -> Result<Self> {
        let listener = ConnectionListener::new(host, port).await?;
        info!("Tcp listener setup");

        while self.expecting_connection() {
            info!("{}", self.expecting_msg());
            info!("Waiting for connection...");
            let mut connection = listener.accept().await?;
            let message: BitBrokerMessage = connection.read_message().await?;
            match message.codes() {
                (0x00, 0x01) => self.handle_game_connection(connection)?,
                (0x00, 0x02) => self.handle_player_connection(connection)?,
                _ => return Err(Error::from(message)),
            }
        }

        info!("All players and game connected");
        Ok(self)
    }

    fn handle_player_connection(&mut self, connection: Connection) -> Result<()> {
        info!("Handling new player connection");
        if self.expecting_player() {
            let player_id = self.players.len() as u8;
            self.players.insert(player_id, connection);
            Ok(())
        } else {
            Err(Error::BrokerError("Too many players tried to connect"))
        }
    }

    fn handle_game_connection(&mut self, connection: Connection) -> Result<()> {
        info!("Handling new game connection");
        if self.expecting_game() {
            self.game = Some(connection);
            Ok(())
        } else {
            Err(Error::BrokerError("Multiple games tried to connect"))
        }
    }

    fn expecting_msg(&self) -> String {
        let player_part = format!("{} player(s)", self.num_players - self.players.len());
        if self.expecting_game() {
            format!("Expecting {player_part} and a game")
        } else {
            format!("Expecting {player_part}")
        }
    }

    fn expecting_game(&self) -> bool {
        self.game.is_none()
    }

    fn expecting_player(&self) -> bool {
        self.players.len() < self.num_players
    }

    fn expecting_connection(&self) -> bool {
        self.expecting_game() || self.expecting_player()
    }
}