Server: implement login

[dragonblocks-rs.git] / src / server.rs

diff --git a/src/server.rs b/src/server.rs
index 5f82b83be587113259becde59f555e430614118a..071019d66add85e2ce88f4f93a70caf275012ebd 100644 (file)
--- a/src/server.rs
+++ b/src/server.rs
@@ -4,16 +4,15 @@ mod remote_client;
 use crate::quit::Quit;
 use connect::{tcp::TcpListener, StreamExt};
 use log::*;
-use remote_client::{Client, ClientId};
+use remote_client::Client;
 use std::{
     collections::HashMap,
     sync::{Arc, RwLock},
 };
-use tokio::{sync::Mutex as AsyncMutex, task};
 
+#[derive(Debug)]
 pub struct ServerData {
-    clients_by_id: RwLock<HashMap<ClientId, Arc<Client>>>,
-    clients_by_name: RwLock<HashMap<String, Arc<Client>>>,
+    players: RwLock<HashMap<String, Arc<Client>>>,
 }
 
 pub struct Server {
@@ -28,49 +27,29 @@ impl Server {
             quit,
             listener: TcpListener::bind(addr).await.unwrap(),
             data: Arc::new(ServerData {
-                clients_by_id: RwLock::new(HashMap::new()),
-                clients_by_name: RwLock::new(HashMap::new()),
+                players: RwLock::new(HashMap::new()),
             }),
         }
     }
 
     pub async fn run(mut self) {
-        let mut next_id: ClientId = 0;
         let mut quit = self.quit.subscribe();
 
         loop {
             tokio::select! {
-                conn = self.listener.next() => {
-                    let conn = conn.expect("Listener interrupted");
-
-                    info!("Client from {} assigned id {next_id}", conn.peer_addr());
-
-                    let (reader, writer) = conn.split();
-                    let client = Arc::new(Client {
-                        id: next_id,
-                        conn: AsyncMutex::new(writer),
-                        server: Arc::downgrade(&self.data),
-                        quit: self.quit.clone(),
-                    });
-
-                    self.data
-                        .clients_by_id
-                        .write()
-                        .unwrap()
-                        .insert(next_id, Arc::clone(&client));
-
-                    next_id += 1;
-
-                    task::spawn(async move { (*client).run(reader).await });
-                },
+                conn = self.listener.next() => Client::create(
+                        conn.expect("listener interrupted"),
+                        Arc::downgrade(&self.data),
+                        self.quit.clone()
+                    ).await,
                 _ = quit.recv() => {
-                    trace!("Quit signal received");
+                    trace!("quit signal received");
                     break;
                 },
-                else => unreachable!("Quit channel broke"),
+                else => unreachable!("quit channel broke"),
             }
         }
 
-        info!("Stopped server");
+        info!("stopped server");
     }
 }