feat: move start_watch into trait definition, to do that use async_traits

src/kube_cache.rs

@@ -166,7 +166,6 @@ impl MinecraftAPI<Server> for McApi {
                 a
             }
         };
-        tracing::info!(inter_addr = inter_addr);
         return Ok(Server {
             dep: deployment,
             srv: service,
@@ -177,77 +176,8 @@ impl MinecraftAPI<Server> for McApi {
         });
     }
 
-    async fn start_watch(
-        self,
-        server: impl MinecraftServerHandle,
-        frequency: Duration,
-    ) -> Result<(), OpaqueError> {
-        let addr = server.get_addr().ok_or("could not get addr of server")?;
-        let port = server.get_port().ok_or("could not get port of server")?;
-        let full_addr = format!("{addr}:{port}");
-
-        if let Some(handle) = self.map.lock().await.get(&full_addr) {
-            if !handle.is_finished() {
-                return Ok(());
-            }
-        }
-        let span = tracing::span!(parent: None,tracing::Level::INFO, "server_watcher", addr, port);
-
-        let full_addr_clone = full_addr.clone();
-        let api = self.clone();
-        let handle = tokio::spawn(
-            async move {
-                tracing::info!("starting watcher");
-                loop {
-                    tokio::time::sleep(frequency).await;
-                    let server = match api.query_server(&addr, &port).await {
-                        Ok(x) => x,
-                        Err(e) => {
-                            tracing::error!(
-                                err = format!("{}", e.context),
-                                "could not query server"
-                            );
-                            return;
-                        }
-                    };
-                    let status_json = match server.query_description().await {
-                        Ok(x) => x,
-                        Err(e) => {
-                            tracing::error!(
-                                err = format!("{}", e.context),
-                                "could not query description"
-                            );
-                            return;
-                        }
-                    };
-                    if status_json.get_players_online() == 0 {
-                        // With this I don't need to specify that StatusTrait
-                        // should be send as well.
-
-                        // Otherwise I would need to have it be defined as:
-                        // trait StatusTrait: Send { ... }
-                        drop(status_json);
-                        let mut guard = api.map.lock().await;
-                        guard.remove(&full_addr_clone);
-                        drop(guard);
-                        if let Err(err) = server.stop().await {
-                            tracing::error!(
-                                trace = %err.print_span_trace(),
-                                err = err.context,
-                                msg = "failed to stop server"
-                            );
-                        }
-                        return;
-                    }
-                }
-            }
-            .instrument(span),
-        );
-        let mut guard = self.map.lock().await;
-        guard.insert(full_addr.clone(), handle);
-        drop(guard);
-
-        Ok(())
+    fn get_map(&self) -> Arc<tokio::sync::Mutex<HashMap<String, tokio::task::JoinHandle<()>>>> {
+        self.map.clone()
     }
 }
 
@@ -290,10 +220,10 @@ impl fmt::Debug for Server {
                     .name
                     .unwrap_or("#error#".to_string()),
             )
-            .field("server_addr", &self.server_addr)
             .finish()
     }
 }
+#[async_trait::async_trait]
 impl MinecraftServerHandle for Server {
     async fn start(&self) -> Result<(), OpaqueError> {
         self.set_scale(1).await.map_err(|e| {
@@ -357,8 +287,8 @@ impl MinecraftServerHandle for Server {
         self.inter_addr.as_str()
     }
 
-    fn get_addr(&self) -> Option<String> {
-        Some(self.server_addr.clone())
+    fn get_addr(&self) -> String {
+        self.server_addr.clone()
     }
 
     async fn query_description(&self) -> Result<Box<dyn StatusTrait>, OpaqueError> {
@@ -367,9 +297,7 @@ impl MinecraftServerHandle for Server {
             ServerDeploymentStatus::Connectable(mut tcp_stream) => {
                 let handshake = crate::packets::serverbound::handshake::Handshake::create(
                     crate::types::VarInt::from(746).ok_or("could not create VarInt WTF?")?,
-                    crate::types::VarString::from(
-                        self.get_addr().ok_or("failed to get addr of server")?,
-                    ),
+                    crate::types::VarString::from(self.get_addr()),
                     crate::types::UShort::from(1234),
                     crate::types::VarInt::from(1).ok_or("could not create VarInt WTF?")?,
                 )
@@ -403,8 +331,8 @@ impl MinecraftServerHandle for Server {
         }
     }
 
-    fn get_port(&self) -> Option<String> {
-        Some(self.server_port.clone())
+    fn get_port(&self) -> String {
+        self.server_port.clone()
     }
 
     fn get_motd(&self) -> Option<String> {
@@ -434,15 +362,13 @@ impl MinecraftServerHandle for Server {
 impl Server {
     async fn set_scale(&self, num: i32) -> Result<(), kube::Error> {
         let name = self
-            .srv
+            .dep
             .metadata
             .clone()
             .name
             .unwrap_or("#error#".to_string());
-        let res = self.cache.set_dep_scale(&name, num).await;
-        if res.is_ok() {
-            tracing::info!("scaled replicas of {} to {num}", self.server_addr);
-        }
+        let _res = self.cache.set_dep_scale(&name, num).await?;
+        tracing::info!("scaled replicas of {} to {num}", self.server_addr);
         Ok(())
     }
 }