chore: rename things to be more to my liking

src/kube_cache.rs

@@ -18,12 +18,13 @@ use crate::{
 };
 const MAIN_LABEL: &str = "tami.moe/minecraft";
 const PORT_LABEL: &str = "tami.moe/minecraft-port";
+const URL_ANNOTATION: &str = "tami.moe/minecraft-url";
 
 /// This is the layer who is respinsible for caching requests.
-///
+
-/// TODO:
+// A heads-up:
-/// It should be also clone-able freely, because it deals with
+// It should be also clone-able freely, because it deals with
-/// the underlying async data access.
+// the underlying async data access.
 #[derive(Debug, Clone)]
 pub struct KubeCache {
     // When the store gets copied, it points to the same backing store
@@ -40,6 +41,11 @@ impl KubeCache {
     ///
     /// It also returns a JoinHandle which is tied to the api watcher
     /// and if it returns that means that the kubecache is not responsive now.
+    ///
+    /// # Example:
+    /// ```no_run
+    /// let (kube_cache, api_task) = kube_cache::KubeCache::create().await.unwrap();
+    /// ```
     pub async fn create() -> Option<(KubeCache, JoinHandle<()>)> {
         let in_cluster = match std::env::var("KUBERNETES_SERVICE_HOST") {
             Ok(_) => true,
@@ -60,7 +66,7 @@ impl KubeCache {
                 .for_each(|_o| std::future::ready(()));
             let _res = infinite_watch.await;
             tracing::error!(
-                "Deployments watcher ended. This should not happen. (Program should exit now)"
+                "deployments watcher ended; this should not happen; (program should exit now)"
             );
         });
 
@@ -77,6 +83,9 @@ impl KubeCache {
         ));
     }
     fn get_dep(&self, name: &str) -> Option<Arc<Deployment>> {
+        // dep.name_any() has the caveat of returning "" if it can't query for
+        // a name, resulting in unexpected behaviour if that happens and also
+        // a query for "" comes as well.
         self.dep_cache.find(|x| x.name_any() == name)
     }
     async fn get_srv(&self, name: &str) -> Result<Service, kube::Error> {
@@ -298,13 +307,16 @@ impl MinecraftServerHandle for Server {
     fn get_internal_address(&self) -> &str {
         self.internal_address.as_str()
     }
-
+    fn get_internal_id(&self) -> &str {
-    fn get_addr(&self) -> String {
+        self.internal_id.as_str()
-        self.server_addr.clone()
     }
 
-    fn get_port(&self) -> String {
+    fn get_join_addr(&self) -> &str {
-        self.server_port.clone()
+        self.server_addr.as_ref()
+    }
+
+    fn get_join_port(&self) -> &str {
+        self.server_port.as_ref()
     }
 
     fn get_motd(&self) -> Option<String> {

src/mc_server.rs

@@ -70,8 +70,9 @@ pub trait MinecraftServerHandle: Send + Sync + 'static + Clone {
     async fn stop(&self) -> Result<(), OpaqueError>;
     async fn query_status(&self) -> Result<ServerDeploymentStatus, OpaqueError>;
     fn get_internal_address(&self) -> &str;
-    fn get_addr(&self) -> String;
+    fn get_internal_id(&self) -> &str;
-    fn get_port(&self) -> String;
+    fn get_join_addr(&self) -> &str;
+    fn get_join_port(&self) -> &str;
     fn get_motd(&self) -> Option<String>;
 
     async fn query_server_connectable(&self) -> Result<TcpStream, OpaqueError> {
@@ -122,7 +123,7 @@ pub trait MinecraftServerHandle: Send + Sync + 'static + Clone {
             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()),
+                    crate::types::VarString::from(self.get_join_addr().to_string()),
                     crate::types::UShort::from(1234),
                     crate::types::VarInt::from(1).ok_or("could not create VarInt WTF?")?,
                 )
@@ -162,7 +163,6 @@ pub trait MinecraftAPI<T>: Send + Sync + 'static {
     async fn query_server(&self, addr: &str, port: &str) -> Result<T, OpaqueError>;
     fn get_map(&self) -> Arc<tokio::sync::Mutex<HashMap<String, tokio::task::JoinHandle<()>>>>;
 
-    // TODO: move the implementation to here, but
     /// This should be callable even if there is already a watcher,
     /// and it should handle the collision itself while returning OK().
     async fn start_watch(
@@ -171,18 +171,18 @@ pub trait MinecraftAPI<T>: Send + Sync + 'static {
         frequency: std::time::Duration,
     ) -> Result<(), OpaqueError>
     where
-        Self: Send + Sync + 'static + Clone,
+        Self: Clone,
     {
-        let inter_addr = server.get_internal_address().to_string();
+        let internal_id = server.get_internal_id().to_string();
 
-        if let Some(handle) = self.get_map().lock().await.get(&inter_addr) {
+        if let Some(handle) = self.get_map().lock().await.get(&internal_id) {
             if !handle.is_finished() {
                 return Ok(());
             }
         }
-        let span = tracing::span!(parent: None,tracing::Level::INFO, "server_watcher", inter_addr, join_addr = server.get_addr(), join_port = server.get_port());
+        let span = tracing::span!(parent: None,tracing::Level::INFO, "server_watcher", internal_id, join_addr = server.get_join_addr(), join_port = server.get_join_port());
 
-        let full_addr_clone = inter_addr.clone();
+        let internal_id_clone = internal_id.clone();
         let api = self.clone();
         let handle = tokio::spawn(
             async move {
@@ -208,7 +208,7 @@ pub trait MinecraftAPI<T>: Send + Sync + 'static {
                         drop(status_json);
                         let map = api.get_map();
                         let mut guard = map.lock().await;
-                        guard.remove(&full_addr_clone);
+                        guard.remove(&internal_id_clone);
                         drop(guard);
                         drop(map);
                         if let Err(err) = server.stop().await {
@@ -226,7 +226,7 @@ pub trait MinecraftAPI<T>: Send + Sync + 'static {
         );
         let map = self.get_map();
         let mut guard = map.lock().await;
-        guard.insert(inter_addr.clone(), handle);
+        guard.insert(internal_id, handle);
         drop(guard);
 
         Ok(())

src/proxy.rs

@@ -1,5 +1,4 @@
 use evalexpr::*;
-use std::collections::HashMap;
 use std::env;
 use std::net::SocketAddr;
 use std::time::Duration;