feat: move the packets library over to use async

src/main.rs

@@ -1,9 +1,13 @@
 //! This is a simple imitation of the basic functionality of kubectl:
 //! kubectl {get, delete, apply, watch, edit} <resource> [name]
 //! with labels and namespace selectors supported.
-use std::sync::Arc;
+use std::{net::SocketAddr, sync::Arc};
 
 use tokio::net::{TcpListener, TcpStream};
+use tracing::instrument;
+use tracing_subscriber::{prelude::*, EnvFilter};
+
+use crate::packets::Packet;
 
 mod KubeCache;
 mod packets;
@@ -11,31 +15,59 @@ mod types;
 
 #[tokio::main]
 async fn main() {
-    tracing_subscriber::fmt::init();
+    // tracing_subscriber::fmt::init();
+    let fmt_layer = tracing_subscriber::fmt::layer()
+        .with_target(false)
+        .with_level(true);
+    let filter_layer = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")); // default to INFO
+    tracing_subscriber::registry()
+        .with(fmt_layer)
+        .with(filter_layer)
+        .init();
 
     let commit_hash: &'static str = env!("COMMIT_HASH");
     tracing::info!("COMMIT_HASH: {}", commit_hash);
 
     let cache = KubeCache::Cache::create().unwrap();
-    let arcCache = Arc::new(cache);
+    let arc_cache = Arc::new(cache);
     tracing::info!("kube api initialized");
 
-    let mut listener = TcpListener::bind("0.0.0.0:25565").await.unwrap();
+    let listener = TcpListener::bind("0.0.0.0:25565").await.unwrap();
     tracing::info!("tcp server started");
 
     loop {
-        let (socket, _) = listener.accept().await.unwrap();
-        let acc = arcCache.clone();
+        let (socket, addr) = listener.accept().await.unwrap();
+        let acc = arc_cache.clone();
 
         tokio::spawn(async move {
-            if let Err(e) = process_socket(socket, acc).await {
+            if let Err(e) = process_socket(socket, addr, acc).await {
                 tracing::error!("socket error: {e:?}");
             }
         });
     }
 }
 
-async fn process_socket(stream: TcpStream, cache: Arc<KubeCache::Cache>) -> Result<(), ()> {
+#[instrument(level = "trace", skip(cache, stream))]
+async fn process_socket(
+    mut stream: TcpStream,
+    addr: SocketAddr,
+    cache: Arc<KubeCache::Cache>,
+) -> Result<(), ()> {
+    tracing::info!(
+        addr = format!("{}:{}", addr.ip().to_string(), addr.port().to_string()),
+        "Client connected"
+    );
+    let client_packet = match Packet::parse(&mut stream).await {
+        Some(x) => x,
+        None => {
+            tracing::trace!("Client HANDSHAKE -> bad packet; Disconnecting...");
+            return Ok(());
+        }
+    };
+    tracing::info!(
+        addr = format!("{}:{}", addr.ip().to_string(), addr.port().to_string()),
+        "Client disconnected"
+    );
     todo!()
 }
 // ----- Debug tools -----