src/main.rs

@@ -22,15 +22,6 @@ async fn main() -> Result<(), anyhow::Error> {
 
     let args: Vec<String> = env::args().collect();
     let demo_mode = args.get(1).is_some() && args.get(1).unwrap() == "demo";
-    let tournament_type = if !demo_mode {
-        if let Some(tourney) = args.get(1) {
-            tourney.clone()
-        } else {
-            "round_robin".to_string()
-        }
-    } else {
-        "round_robin".to_string()
-    };
     let admin_password = env::var("ADMIN_AUTH").unwrap_or_else(|_| String::from("admin"));
     info!("Admin password: {}", admin_password);
     let admin_password = Arc::new(admin_password);
@@ -39,11 +30,7 @@ async fn main() -> Result<(), anyhow::Error> {
     let listener = TcpListener::bind(&addr).await?;
     info!("WebSocket server listening on: {}", addr);
 
-    let server_data = Arc::new(Server::new(
+    let server_data = Arc::new(Server::new(admin_password.as_ref().clone(), demo_mode));
-        admin_password.as_ref().clone(),
-        demo_mode,
-        tournament_type,
-    ));
 
     while let Ok((stream, addr)) = listener.accept().await {
         tokio::spawn(handle_connection(stream, addr, server_data.clone()));
@@ -183,8 +170,11 @@ async fn handle_connection(
                         }
                     }
                     "TOURNAMENT" => {
-                        if parts.get(1) == Some(&"START") {
+                        if parts.get(1) == Some(&"START") && parts.len() > 2 {
-                            if let Err(e) = sd.handle_tournament_start(tx.clone(), addr).await {
+                            if let Err(e) = sd
+                                .handle_tournament_start(tx.clone(), addr, parts[2].to_string())
+                                .await
+                            {
                                 error!("handle_tournament_start: {}", e);
                                 let _ = send(&tx, e.to_string().as_str());
                             }

src/server.rs

@@ -10,11 +10,10 @@ pub struct Server {
     pub tournament: WrappedTournament,
     pub waiting_timeout: Arc<RwLock<u64>>,
     pub demo_mode: bool,
-    pub tournament_type: String,
 }
 
 impl Server {
-    pub fn new(admin_password: String, demo_mode: bool, tournament_type: String) -> Server {
+    pub fn new(admin_password: String, demo_mode: bool) -> Server {
         Server {
             clients: Arc::new(RwLock::new(HashMap::new())),
             usernames: Arc::new(RwLock::new(HashMap::new())),
@@ -25,7 +24,6 @@ impl Server {
             tournament: Arc::new(RwLock::new(None)),
             waiting_timeout: Arc::new(RwLock::new(5000)),
             demo_mode,
-            tournament_type,
         }
     }
 
@@ -512,6 +510,7 @@ impl Server {
         &self,
         tx: UnboundedSender<Message>,
         addr: SocketAddr,
+        tournament_type: String,
     ) -> Result<(), anyhow::Error> {
         if !self.auth_check(addr).await {
             return Err(anyhow::anyhow!("ERROR:INVALID:AUTH"));
@@ -535,7 +534,7 @@ impl Server {
 
         drop(clients_guard);
 
-        let mut tourney = match self.tournament_type.as_str() {
+        let mut tourney = match tournament_type.as_str() {
             "round_robin" => crate::tournaments::round_robin::RoundRobin::new(&ready_players),
             &_ => crate::tournaments::round_robin::RoundRobin::new(&ready_players),
         };