Fix players timing out after a command executes for a while (#460)

* Fix players not being removed from world on timeout

* Spawn new task for each command
Undo bandaid fix

* Fix cargo fmt

* Move console commands and RCON commands into seperate tokio task

pumpkin/src/entity/player.rs

@@ -719,8 +719,7 @@ impl Player {
                     .await;
             }
             SChatCommand::PACKET_ID => {
-                self.handle_chat_command(server, SChatCommand::read(bytebuf)?)
-                    .await;
+                self.handle_chat_command(server, &(SChatCommand::read(bytebuf)?));
             }
             SChatMessage::PACKET_ID => {
                 self.handle_chat_message(SChatMessage::read(bytebuf)?).await;

pumpkin/src/main.rs

@@ -308,10 +308,13 @@ fn setup_console(server: Arc<Server>) {
                 .expect("Failed to read console line");
 
             if !out.is_empty() {
-                let dispatcher = server.command_dispatcher.read().await;
-                dispatcher
-                    .handle_command(&mut command::CommandSender::Console, &server, &out)
-                    .await;
+                let server_clone = server.clone();
+                tokio::spawn(async move {
+                    let dispatcher = server_clone.command_dispatcher.read().await;
+                    dispatcher
+                        .handle_command(&mut command::CommandSender::Console, &server_clone, &out)
+                        .await;
+                });
             }
         }
     });

pumpkin/src/net/packet/play.rs

@@ -300,19 +300,23 @@ impl Player {
             .await;
     }
 
-    pub async fn handle_chat_command(
-        self: &Arc<Self>,
-        server: &Arc<Server>,
-        command: SChatCommand,
-    ) {
-        let dispatcher = server.command_dispatcher.read().await;
-        dispatcher
-            .handle_command(
-                &mut CommandSender::Player(self.clone()),
-                server,
-                &command.command,
-            )
-            .await;
+    pub fn handle_chat_command(self: &Arc<Self>, server: &Arc<Server>, command: &SChatCommand) {
+        let player_clone = self.clone();
+        let server_clone = server.clone();
+        let command_clone = command.command.clone();
+        // Some commands can take a long time to execute. If they do, they block packet processing for the player
+        // Thats why we will spawn a task instead
+        tokio::spawn(async move {
+            let dispatcher = server_clone.command_dispatcher.read().await;
+            dispatcher
+                .handle_command(
+                    &mut CommandSender::Player(player_clone),
+                    &server_clone,
+                    &command_clone,
+                )
+                .await;
+        });
+
         if ADVANCED_CONFIG.commands.log_console {
             log::info!(
                 "Player ({}): executed command /{}",

pumpkin/src/net/rcon/mod.rs

@@ -103,15 +103,22 @@ impl RCONClient {
             }
             ServerboundPacket::ExecCommand => {
                 if self.logged_in {
-                    let output = tokio::sync::Mutex::new(Vec::new());
-                    let dispatcher = server.command_dispatcher.read().await;
-                    dispatcher
-                        .handle_command(
-                            &mut crate::command::CommandSender::Rcon(&output),
-                            server,
-                            packet.get_body(),
-                        )
-                        .await;
+                    let output = Arc::new(tokio::sync::Mutex::new(Vec::new()));
+
+                    let server_clone = server.clone();
+                    let output_clone = output.clone();
+                    let packet_body = packet.get_body().to_owned();
+                    tokio::spawn(async move {
+                        let dispatcher = server_clone.command_dispatcher.read().await;
+                        dispatcher
+                            .handle_command(
+                                &mut crate::command::CommandSender::Rcon(&output_clone),
+                                &server_clone,
+                                &packet_body,
+                            )
+                            .await;
+                    });
+
                     let output = output.lock().await;
                     for line in output.iter() {
                         if config.logging.log_commands {