Optimization

Author: EliXorZz

src/epsilon/queue/epsilon_queue.rs

@@ -1,27 +1,20 @@
 use crate::epsilon::queue::queue_provider::Group;
-use crate::epsilon::server::templates::template::Template;
 
 use std::collections::{HashSet, VecDeque};
 
 pub struct Queue {
-    template: Template,
     queue: VecDeque<Group>,
     in_queue: HashSet<String>,
 }
 
 impl Queue {
-    pub fn new(template: Template) -> Self {
+    pub fn new() -> Self {
         Self {
-            template,
             queue: VecDeque::new(),
             in_queue: HashSet::new(),
         }
     }
 
-    pub fn get_template(&self) -> &Template {
-        &self.template
-    }
-
     pub fn push(&mut self, group: Group) {
         for player in &group.players {
             if self.in_queue.contains(player) {

src/epsilon/queue/queue_provider.rs

@@ -19,7 +19,7 @@ impl QueueProvider {
         let mut map = HashMap::new();
 
         for template in instance_provider.get_templates().await? {
-            map.insert(String::from(&template.name), Queue::new(template));
+            map.insert(String::from(&template.name), Queue::new());
         }
 
         Ok(Arc::new(Mutex::new(QueueProvider { queue_map: map })))

src/epsilon/server/instance.rs

@@ -4,8 +4,7 @@ use crate::epsilon::server::instance_type::InstanceType;
 use crate::k8s::label::Label;
 use crate::{EResult, Kube};
 use anyhow::format_err;
-use async_minecraft_ping::ServerDescription::Plain;
-use async_minecraft_ping::{ConnectionConfig, ServerPlayers, ServerVersion, StatusResponse};
+use async_minecraft_ping::{ConnectionConfig, StatusResponse};
 use k8s_openapi::api::core::v1::Pod;
 use std::sync::Arc;
 use std::time::Duration;
@@ -103,27 +102,20 @@ impl Instance {
             let timeout = Duration::from_millis(500);
             let config = ConnectionConfig::build(address).with_timeout(timeout);
 
-            match config.connect().await {
-                Ok(connection) => Ok(connection.status().await?.status),
-                Err(_) => Ok(StatusResponse {
-                    version: ServerVersion {
-                        name: "".to_string(),
-                        protocol: 0,
-                    },
-                    players: ServerPlayers {
-                        max: 10,
-                        online: 0,
-                        sample: None,
-                    },
-                    description: Plain("Description".to_string()),
-                    favicon: None,
-                }),
-            }
+            Ok(config.connect().await.unwrap().status().await?.status)
         } else {
             Err(format_err!("No address found"))
         }
     }
 
+    pub async fn get_online_count(&self) -> i32 {
+        self.get_info().await.unwrap().players.online as i32
+    }
+
+    pub async fn get_available_slots(&self) -> i32 {
+        self.get_instance_slots() - self.get_online_count().await
+    }
+
     pub fn need_close(&self) -> bool {
         let phase = self.pod.status.as_ref().unwrap().phase.as_ref().unwrap();
 
@@ -143,7 +135,7 @@ impl Instance {
             .any(|condition| condition.type_ == "Ready" && condition.status == "True")
             && status.phase.as_ref().unwrap() == "Running";
 
-        let label = &labels.get("epsilon.fr/in-game");
+        let label = &labels.get(Label::IN_GAME_LABEL);
         let is_in_game = label.is_some() && label.unwrap() == "true";
 
         let is_stopping = metadata.deletion_timestamp.is_some() || self.need_close();
@@ -165,7 +157,7 @@ impl Instance {
             .labels
             .as_ref()
             .unwrap()
-            .contains_key("epsilon.fr/main")
+            .contains_key(Label::DEFAULT_LABEL)
     }
 
     pub async fn to_json(&self) -> InstanceJson {
@@ -186,16 +178,27 @@ impl Instance {
 
 #[async_trait]
 pub trait VectorOfInstance {
-    async fn get_online_count(&self) -> EResult<u32>;
+    async fn get_available_slots(&self) -> EResult<i32>;
+    async fn get_online_count(&self) -> EResult<i32>;
 }
 
 #[async_trait]
 impl VectorOfInstance for Vec<Instance> {
-    async fn get_online_count(&self) -> EResult<u32> {
+    async fn get_available_slots(&self) -> EResult<i32> {
+        let mut available_slots = 0;
+
+        for instance in self {
+            available_slots += instance.get_available_slots().await;
+        }
+
+        Ok(available_slots)
+    }
+
+    async fn get_online_count(&self) -> EResult<i32> {
         let mut number = 0;
 
         for instance in self {
-            number += instance.get_info().await?.players.online;
+            number += instance.get_online_count().await
         }
 
         Ok(number)

src/k8s/label.rs

@@ -7,6 +7,8 @@ pub struct Label {
 }
 
 impl Label {
+    pub const DEFAULT_LABEL: &'static str = "epsilon.fr/default";
+
     pub const INSTANCE_TYPE_LABEL: &'static str = "epsilon.fr/instance";
     pub const TEMPLATE_LABEL: &'static str = "epsilon.fr/template";
     pub const SLOTS_LABEL: &'static str = "epsilon.fr/slots";
@@ -43,7 +45,7 @@ impl Label {
     }
 
     pub fn get_default_label() -> Label {
-        Label::new("epsilon.fr/default", "true")
+        Label::new(Self::DEFAULT_LABEL, "true")
     }
 
     pub fn get_instance_type_label(instance_type: &InstanceType) -> Label {

src/tasks/queue_task.rs

@@ -32,8 +32,6 @@ impl Task for QueueTask {
     async fn run(&mut self) -> EResult<()> {
         for (template_name, queue) in self.queue_provider.lock().await.get_queues() {
             if !queue.is_empty() {
-                let template = queue.get_template();
-
                 let instances_starting = self
                     .instance_provider
                     .get_instances(
@@ -57,23 +55,17 @@ impl Task for QueueTask {
                 }
 
                 if let Some(instance) = instances_ready.first() {
-                    let info_result = instance.get_info().await;
-
-                    if let Ok(info) = info_result {
-                        let mut available_slots = template.slots as u32 - info.players.online;
+                    let mut available_slots = instance.get_available_slots().await;
 
-                        while !queue.is_empty() && available_slots != 0 {
-                            if let Some(group) = queue.pop() {
-                                let group_size = group.players.len() as u32;
+                    while !queue.is_empty() && available_slots != 0 {
+                        if let Some(group) = queue.pop() {
+                            let group_size = group.players.len() as i32;
 
-                                if group_size <= available_slots {
-                                    available_slots -= group_size;
+                            if group_size <= available_slots {
+                                available_slots -= group_size;
 
-                                    self.epsilon_api.send(SendToServer(
-                                        group,
-                                        String::from(instance.get_name()),
-                                    ));
-                                }
+                                self.epsilon_api
+                                    .send(SendToServer(group, String::from(instance.get_name())));
                             }
                         }
                     }