Re-enable RCON

pumpkin/src/main.rs

@@ -1,4 +1,5 @@
 #![allow(clippy::await_holding_refcell_ref)]
+#![allow(clippy::await_holding_lock)]
 
 use mio::net::TcpListener;
 use mio::{Events, Interest, Poll, Token};
@@ -8,7 +9,7 @@ use client::Client;
 use commands::handle_command;
 use config::AdvancedConfiguration;
 
-use std::{collections::HashMap, thread};
+use std::collections::HashMap;
 
 use client::interrupted;
 use config::BasicConfiguration;
@@ -35,6 +36,7 @@ fn main() -> io::Result<()> {
 
     use entity::player::Player;
     use pumpkin_core::text::{color::NamedColor, TextComponent};
+    use rcon::RCONServer;
 
     #[cfg(feature = "dhat-heap")]
     let _profiler = dhat::Profiler::new_heap();
@@ -61,8 +63,6 @@ fn main() -> io::Result<()> {
         const SERVER: Token = Token(0);
         use std::time::Instant;
 
-        
-
         let time = Instant::now();
         let basic_config = BasicConfiguration::load("configuration.toml");
 
@@ -99,7 +99,7 @@ fn main() -> io::Result<()> {
         let mut clients: HashMap<Token, Client> = HashMap::new();
         let mut players: HashMap<Arc<Token>, Arc<Mutex<Player>>> = HashMap::new();
 
-        let server = Arc::new(Mutex::new(Server::new((
+        let server = Arc::new(tokio::sync::Mutex::new(Server::new((
             basic_config,
             advanced_configuration,
         ))));
@@ -108,7 +108,7 @@ fn main() -> io::Result<()> {
 
         let server1 = server.clone();
         if use_console {
-            thread::spawn(move || {
+            tokio::spawn(async move {
                 let stdin = std::io::stdin();
                 loop {
                     let mut out = String::new();
@@ -117,7 +117,7 @@ fn main() -> io::Result<()> {
                         .expect("Failed to read console line");
 
                     if !out.is_empty() {
-                        let mut server = server1.lock().unwrap();
+                        let mut server = server1.lock().await;
                         handle_command(&mut commands::CommandSender::Console, &mut server, &out);
                     }
                 }
@@ -125,9 +125,9 @@ fn main() -> io::Result<()> {
         }
         if rcon.enabled {
             let server = server.clone();
-            // tokio::spawn(async move {
+            tokio::spawn(async move {
-            //     RCONServer::new(&rcon, &server).await.unwrap();
+                RCONServer::new(&rcon, server).await.unwrap();
-            // });
+            });
         }
         loop {
             if let Err(err) = poll.poll(&mut events, None) {
@@ -179,7 +179,7 @@ fn main() -> io::Result<()> {
                         let done = if let Some(player) = players.get_mut(&token) {
                             let mut player = player.lock().unwrap();
                             player.client.poll(event).await;
-                            let mut server = server.lock().unwrap();
+                            let mut server = server.lock().await;
                             player.process_packets(&mut server);
                             player.client.closed
                         } else {
@@ -188,7 +188,7 @@ fn main() -> io::Result<()> {
 
                         if done {
                             if let Some(player) = players.remove(&token) {
-                                let mut server = server.lock().unwrap();
+                                let mut server = server.lock().await;
                                 server.remove_player(&token);
                                 let mut player = player.lock().unwrap();
                                 poll.registry().deregister(&mut player.client.connection)?;
@@ -199,7 +199,7 @@ fn main() -> io::Result<()> {
                         // Maybe received an event for a TCP connection.
                         let (done, make_player) = if let Some(client) = clients.get_mut(&token) {
                             client.poll(event).await;
-                            let mut server = server.lock().unwrap();
+                            let mut server = server.lock().await;
                             client.process_packets(&mut server).await;
                             (client.closed, client.make_player)
                         } else {
@@ -212,7 +212,7 @@ fn main() -> io::Result<()> {
                                     poll.registry().deregister(&mut client.connection)?;
                                 } else if make_player {
                                     let token = client.token.clone();
-                                    let mut server = server.lock().unwrap();
+                                    let mut server = server.lock().await;
                                     let player = server.add_player(token.clone(), client);
                                     players.insert(token, player.clone());
                                     let mut player = player.lock().unwrap();

pumpkin/src/rcon/mod.rs

@@ -1,7 +1,7 @@
 use std::{
     collections::HashMap,
     io::{self, Read},
-    sync::{Arc, Mutex},
+    sync::Arc,
 };
 
 use mio::{
@@ -30,7 +30,10 @@ const SERVER: Token = Token(0);
 pub struct RCONServer {}
 
 impl RCONServer {
-    pub async fn new(config: &RCONConfig, server: &Arc<Mutex<Server>>) -> Result<Self, io::Error> {
+    pub async fn new(
+        config: &RCONConfig,
+        server: Arc<tokio::sync::Mutex<Server>>,
+    ) -> Result<Self, io::Error> {
         assert!(config.enabled, "RCON is not enabled");
         let addr = format!("{}:{}", config.ip, config.port)
             .parse()
@@ -44,7 +47,7 @@ impl RCONServer {
 
         let mut unique_token = Token(SERVER.0 + 1);
 
-        let mut events = Events::with_capacity(128);
+        let mut events = Events::with_capacity(20);
 
         let mut connections: HashMap<Token, RCONClient> = HashMap::new();
 
@@ -88,7 +91,7 @@ impl RCONServer {
 
                     token => {
                         let done = if let Some(client) = connections.get_mut(&token) {
-                            client.handle(server, &password).await
+                            client.handle(&server, &password).await
                         } else {
                             false
                         };
@@ -127,7 +130,11 @@ impl RCONClient {
         }
     }
 
-    pub async fn handle(&mut self, server: &Arc<Mutex<Server>>, password: &str) -> bool {
+    pub async fn handle(
+        &mut self,
+        server: &Arc<tokio::sync::Mutex<Server>>,
+        password: &str,
+    ) -> bool {
         if !self.closed {
             loop {
                 match self.read_bytes() {
@@ -155,7 +162,7 @@ impl RCONClient {
 
     async fn poll(
         &mut self,
-        server: &Arc<Mutex<Server>>,
+        server: &Arc<tokio::sync::Mutex<Server>>,
         password: &str,
     ) -> Result<(), PacketError> {
         loop {
@@ -188,7 +195,7 @@ impl RCONClient {
                 PacketType::ExecCommand => {
                     if self.logged_in {
                         let mut output = Vec::new();
-                        let mut server = server.lock().unwrap();
+                        let mut server = server.lock().await;
                         handle_command(
                             &mut crate::commands::CommandSender::Rcon(&mut output),
                             &mut server,