Create euphoxide-client crate

euphoxide-client/src/multi.rs

@@ -0,0 +1,228 @@
+use std::{collections::HashMap, sync::Arc};
+
+use euphoxide::{
+    api::ParsedPacket,
+    client::{conn::ClientConnHandle, state::State},
+};
+use tokio::{
+    select,
+    sync::{mpsc, oneshot},
+};
+
+use crate::{
+    Client, ClientBuilder, ClientBuilderBase, ClientConfig, ClientEvent, MultiClientConfig,
+};
+
+#[derive(Debug)]
+pub enum MultiClientEvent {
+    Started {
+        client: Client,
+    },
+    Connecting {
+        client: Client,
+    },
+    Connected {
+        client: Client,
+        conn: ClientConnHandle,
+        state: State,
+    },
+    Joined {
+        client: Client,
+        conn: ClientConnHandle,
+        state: State,
+    },
+    Packet {
+        client: Client,
+        conn: ClientConnHandle,
+        state: State,
+        packet: ParsedPacket,
+    },
+    Disconnected {
+        client: Client,
+    },
+    Stopped {
+        client: Client,
+    },
+}
+
+impl MultiClientEvent {
+    fn from_client_event(client: Client, event: ClientEvent) -> Self {
+        match event {
+            ClientEvent::Started { id: _ } => Self::Started { client },
+            ClientEvent::Connecting { id: _ } => Self::Connecting { client },
+            ClientEvent::Connected { id: _, conn, state } => Self::Connected {
+                client,
+                conn,
+                state,
+            },
+            ClientEvent::Joined { id: _, conn, state } => Self::Joined {
+                client,
+                conn,
+                state,
+            },
+            ClientEvent::Packet {
+                id: _,
+                conn,
+                state,
+                packet,
+            } => Self::Packet {
+                client,
+                conn,
+                state,
+                packet,
+            },
+            ClientEvent::Disconnected { id: _ } => Self::Disconnected { client },
+            ClientEvent::Stopped { id: _ } => Self::Stopped { client },
+        }
+    }
+
+    pub fn client(&self) -> &Client {
+        match self {
+            Self::Started { client } => client,
+            Self::Connecting { client, .. } => client,
+            Self::Connected { client, .. } => client,
+            Self::Joined { client, .. } => client,
+            Self::Packet { client, .. } => client,
+            Self::Disconnected { client } => client,
+            Self::Stopped { client } => client,
+        }
+    }
+}
+
+#[allow(clippy::large_enum_variant)]
+enum Command {
+    GetClients(oneshot::Sender<Vec<Client>>),
+    AddClient(ClientConfig, oneshot::Sender<Client>),
+}
+
+struct MultiClientTask {
+    next_id: usize,
+    clients: HashMap<usize, Client>,
+
+    cmd_rx: mpsc::Receiver<Command>,
+    event_rx: mpsc::Receiver<ClientEvent>,
+    event_tx: mpsc::Sender<ClientEvent>,
+    out_tx: mpsc::Sender<MultiClientEvent>,
+}
+
+impl MultiClientTask {
+    fn purge_clients(&mut self) {
+        self.clients.retain(|_, v| !v.stopped());
+    }
+
+    async fn on_event(&self, event: ClientEvent) {
+        if let Some(client) = self.clients.get(&event.id()) {
+            let event = MultiClientEvent::from_client_event(client.clone(), event);
+            let _ = self.out_tx.send(event).await;
+        }
+    }
+
+    async fn on_cmd(&mut self, cmd: Command) {
+        match cmd {
+            Command::GetClients(tx) => {
+                self.purge_clients(); // Not necessary for correctness
+                let _ = tx.send(self.clients.values().cloned().collect());
+            }
+            Command::AddClient(config, tx) => {
+                let id = self.next_id;
+                assert!(!self.clients.contains_key(&id));
+                self.next_id += 1;
+
+                let client = Client::new(id, config, self.event_tx.clone());
+                self.clients.insert(id, client.clone());
+
+                let _ = tx.send(client);
+            }
+        }
+    }
+
+    async fn run(mut self) {
+        loop {
+            // Prevent potential memory leak
+            self.purge_clients();
+
+            let received = select! {
+                r = self.event_rx.recv() => Ok(r),
+                r = self.cmd_rx.recv() => Err(r),
+            };
+
+            match received {
+                Ok(None) => break,
+                Ok(Some(event)) => self.on_event(event).await,
+                Err(None) => break,
+                Err(Some(cmd)) => self.on_cmd(cmd).await,
+            }
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct MultiClient {
+    config: Arc<MultiClientConfig>,
+    cmd_tx: mpsc::Sender<Command>,
+}
+
+impl MultiClient {
+    pub fn new(event_tx: mpsc::Sender<MultiClientEvent>) -> Self {
+        Self::new_with_config(MultiClientConfig::default(), event_tx)
+    }
+
+    pub fn new_with_config(
+        config: MultiClientConfig,
+        event_tx: mpsc::Sender<MultiClientEvent>,
+    ) -> Self {
+        let config = Arc::new(config);
+        let out_tx = event_tx;
+
+        let (cmd_tx, cmd_rx) = mpsc::channel(config.cmd_channel_bufsize);
+        let (event_tx, event_rx) = mpsc::channel(config.event_channel_bufsize);
+
+        let task = MultiClientTask {
+            next_id: 0,
+            clients: HashMap::new(),
+            cmd_rx,
+            event_rx,
+            event_tx,
+            out_tx,
+        };
+
+        tokio::task::spawn(task.run());
+
+        Self { config, cmd_tx }
+    }
+
+    pub async fn get_clients(&self) -> Vec<Client> {
+        let (tx, rx) = oneshot::channel();
+        let _ = self.cmd_tx.send(Command::GetClients(tx)).await;
+        rx.await.expect("task should still be running")
+    }
+
+    pub async fn add_client(&self, config: ClientConfig) -> Client {
+        let (tx, rx) = oneshot::channel();
+        let _ = self.cmd_tx.send(Command::AddClient(config, tx)).await;
+        rx.await.expect("task should still be running")
+    }
+}
+
+/////////////
+// Builder //
+/////////////
+
+impl<'a> ClientBuilderBase<'a> for MultiClient {
+    type Base = &'a Self;
+}
+
+impl MultiClient {
+    pub fn client_builder(&self, room: impl ToString) -> ClientBuilder<'_, Self> {
+        ClientBuilder {
+            base: self,
+            config: ClientConfig::new(self.config.server.clone(), room.to_string()),
+        }
+    }
+}
+
+impl ClientBuilder<'_, MultiClient> {
+    pub async fn build_and_add(self) -> Client {
+        self.base.add_client(self.config).await
+    }
+}