src/kube_cache.rs

@@ -12,7 +12,11 @@ use tracing::Instrument;
 
 use crate::{
     mc_server::{sanitize_addr, MinecraftAPI, MinecraftServerHandle, ServerDeploymentStatus},
-    packets::{clientbound::status::StatusTrait, SendPacket},
+    packets::{
+        clientbound::status::StatusTrait,
+        serverbound::handshake::{self},
+        SendPacket,
+    },
     OpaqueError,
 };
 
@@ -434,7 +438,6 @@ impl fmt::Debug for ServerDeploymentStatus {
             Self::Starting => write!(f, "Starting"),
             Self::PodOk => write!(f, "PodOk"),
             Self::Offline => write!(f, "Offline"),
-            Self::Unavailable(s) => write!(f, "Unavailable ({s})"),
         }
     }
 }

src/main.rs

@@ -103,49 +103,35 @@ async fn process_connection<T: MinecraftServerHandle>(
     api: impl MinecraftAPI<T>,
     config: Config,
 ) -> Result<(), OpaqueError> {
-    // this is wrapper so that async doesnt mess up the span, and
-    // to make sure this doesn't propagate to later `handle_*`
-    #[tracing::instrument(level = "info", skip(client_stream, config))]
-    async fn first_packet(
-        client_stream: &mut TcpStream,
-        config: Config,
-    ) -> Result<Option<packets::serverbound::handshake::Handshake>, OpaqueError> {
-        let client_packet = Packet::parse(client_stream).await?;
+    let client_packet = Packet::parse(&mut client_stream).await?;
 
-        // --- Handshake ---
-        let handshake;
-        let packet_id = client_packet.id.get_int();
-        if packet_id != 0 {
-            return Err(OpaqueError::create(&format!(
-                "Client HANDSHAKE -> bad packet; id={packet_id} Disconnecting..."
-            )));
-        }
-        handshake = packets::serverbound::handshake::Handshake::parse(client_packet)
-            .await
-            .ok_or_else(|| "Client HANDSHAKE -> malformed packet; Disconnecting...".to_string())?;
-
-        let filter = eval_boolean(&format!(
-            "addr=\"{}\";{}",
-            handshake.get_server_address(),
-            config.filter_conn
-        ))
-        .map_err(|e| format!("filter error! err={:?}", e))?;
-        if filter {
-            // TODO: if the server just returns here, the client does not know it
-            // and sends a packet with the 122 WeirdID
-            tracing::trace!("filtered out the connection");
-            return Ok(None);
-        }
-
-        Ok(Some(handshake))
+    // --- Handshake ---
+    let handshake;
+    let next_server_state;
+    let packet_id = client_packet.id.get_int();
+    if packet_id != 0 {
+        return Err(OpaqueError::create(&format!(
+            "Client HANDSHAKE -> bad packet; id={packet_id} Disconnecting..."
+        )));
     }
-    let handshake = match first_packet(&mut client_stream, config).await? {
-        Some(x) => x,
-        // this is needed because of the filter
-        None => return Ok(()),
-    };
+    handshake = packets::serverbound::handshake::Handshake::parse(client_packet)
+        .await
+        .ok_or_else(|| "Client HANDSHAKE -> malformed packet; Disconnecting...".to_string())?;
+
+    let filter = eval_boolean(&format!(
+        "addr=\"{}\";{}",
+        handshake.get_server_address(),
+        config.filter_conn
+    ))
+    .map_err(|e| format!("filter error! err={:?}", e))?;
+    if filter {
+        // TODO: if the server just returns here, the client does not know it
+        // and sends a packet with the 122 WeirdID
+        return Ok(());
+    }
+
+    next_server_state = handshake.get_next_state();
 
-    let next_server_state = handshake.get_next_state();
     match next_server_state {
         packets::ProtocolState::Status => {
             handle_status(&mut client_stream, &handshake, api).await?;
@@ -235,9 +221,9 @@ async fn handle_status<T: MinecraftServerHandle>(
                 .instrument(span.clone())
                 .await
                 .map_err(|_| tracing::debug!("failed to send pong packet"));
+            let _guard = span.enter();
 
-            let status = ServerDeploymentStatus::Unavailable(e.get_kind().to_string());
-            tracing::info!(status = ?status, "status request");
+            tracing::info!(status = "unavailable", "status request");
             return Ok(());
         }
     };
@@ -264,7 +250,6 @@ async fn handle_status<T: MinecraftServerHandle>(
             status_struct.description.text =
                 format!("{motd}\n§4Offline§r §oJoin to start!§r - {BYE_MESSAGE}");
         }
-        ServerDeploymentStatus::Unavailable(_) => unreachable!(),
     };
 
     mc_server::complete_status_request(client_stream, status_struct).await?;
@@ -322,7 +307,7 @@ async fn handle_login<T: MinecraftServerHandle>(
 
             match traffic.error {
                 Some(e) => {
-                    tracing::warn!(
+                    tracing::info!(
                         tx = traffic.tx,
                         rx = traffic.rx,
                         err = ?e,
@@ -345,7 +330,6 @@ async fn handle_login<T: MinecraftServerHandle>(
                 .await?;
             mc_server::send_disconnect(client_stream, format!("[\"\",{{\"text\":\"Okayy, §2starting§r the server!\n\n\"}},{{\"text\":\"{BYE_MESSAGE}\"}}]").as_str()).await?;
         }
-        ServerDeploymentStatus::Unavailable(_) => unreachable!(),
     }
     Ok(())
 }

src/mc_server.rs

@@ -139,7 +139,6 @@ pub enum ServerDeploymentStatus {
     Starting,
     PodOk,
     Offline,
-    Unavailable(String),
 }
 
 pub fn sanitize_addr(addr: &str) -> &str {