Coherent clean task, and little refactor

Author: EliXorZz

src/epsilon/server/instance.rs

@@ -119,10 +119,14 @@ impl Instance {
         self.get_instance_slots() - self.get_online_count().await
     }
 
-    pub fn need_close(&self) -> bool {
+    pub fn is_succeeded(&self) -> bool {
+        self.pod.status.as_ref().unwrap().phase.as_ref().unwrap() == "Succeeded"
+    }
+
+    pub fn is_failed(&self) -> bool {
         let phase = self.pod.status.as_ref().unwrap().phase.as_ref().unwrap();
 
-        phase == "Failed" || phase == "Unknown" || phase == "Succeeded"
+        phase == "Failed" || phase == "Unknown"
     }
 
     pub fn get_state(&self) -> EpsilonState {
@@ -141,7 +145,7 @@ impl Instance {
         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();
+        let is_stopping = metadata.deletion_timestamp.is_some() || self.is_succeeded();
 
         if is_ready && is_in_game {
             EpsilonState::InGame

src/epsilon/server/instance_provider.rs

@@ -48,6 +48,7 @@ impl InstanceProvider {
         instance_type: &InstanceType,
         template_option: Option<&str>,
         state_option: Option<&EpsilonState>,
+        get_all: bool,
     ) -> EResult<Vec<Instance>> {
         let mut labels = vec![Label::get_instance_type_label(instance_type)];
 
@@ -61,10 +62,12 @@ impl InstanceProvider {
 
         match state_option {
             Some(state) => Ok(map
-                .filter(|instance| instance.get_state().eq(state))
+                .filter(|instance| instance.get_state() == *state)
                 .collect()),
 
-            None => Ok(map.collect()),
+            None => Ok(map
+                .filter(|instance| get_all || !instance.is_failed())
+                .collect()),
         }
     }
 
@@ -167,7 +170,7 @@ pub async fn in_game(instance: &str, instance_provider: &State<Arc<InstanceProvi
 #[rocket::get("/get/<template>")]
 pub async fn get(template: &str, instance_provider: &State<Arc<InstanceProvider>>) -> String {
     let instances = instance_provider
-        .get_instances(&InstanceType::Server, Some(template), None)
+        .get_instances(&InstanceType::Server, Some(template), None, false)
         .await
         .map_err(|_| {
             EpsilonError::ApiServerError(format!(
@@ -190,7 +193,7 @@ pub async fn get(template: &str, instance_provider: &State<Arc<InstanceProvider>
 #[rocket::get("/get_all")]
 pub async fn get_all(instance_provider: &State<Arc<InstanceProvider>>) -> String {
     let instances = instance_provider
-        .get_instances(&InstanceType::Server, None, None)
+        .get_instances(&InstanceType::Server, None, None, false)
         .await
         .map_err(|_| EpsilonError::ApiServerError("Failed to get every instance".to_string()))
         .unwrap()

src/main.rs

@@ -6,6 +6,7 @@ use crate::epsilon::queue::queue_provider::QueueProvider;
 use crate::epsilon::server::instance_provider::InstanceProvider;
 use crate::epsilon::server::EResult;
 use crate::k8s::kube::Kube;
+use crate::tasks::clean_task::CleanTask;
 use crate::tasks::hub_task::HubTask;
 use crate::tasks::proxy_task::ProxyTask;
 use crate::tasks::queue_task::QueueTask;
@@ -94,10 +95,10 @@ async fn main() -> EResult<()> {
             HubTask::init(&epsilon_api, &instance_provider, &queue_provider).await?,
             2000,
         )
-        // .ignite_task(
-        //     CleanTask::init(&epsilon_api, &instance_provider, &queue_provider).await?,
-        //     10000,
-        // )
+        .ignite_task(
+            CleanTask::init(&epsilon_api, &instance_provider, &queue_provider).await?,
+            10000,
+        )
         .ignite_task(
             QueueTask::init(&epsilon_api, &instance_provider, &queue_provider).await?,
             2000,

src/tasks/clean_task.rs

@@ -27,42 +27,38 @@ impl Task for CleanTask {
     async fn run(&mut self) -> EResult<()> {
         let servers = self
             .instance_provider
-            .get_instances(&InstanceType::Server, None, None)
+            .get_instances(&InstanceType::Server, None, None, false)
             .await?;
 
         let proxies = self
             .instance_provider
-            .get_instances(&InstanceType::Proxy, None, None)
+            .get_instances(&InstanceType::Proxy, None, None, false)
             .await?;
 
         for instance in servers {
-            if instance.need_close() {
+            if instance.is_succeeded() {
                 let name = instance.get_name();
                 let event = EpsilonEvent::ClearServer(name.to_string());
 
                 self.epsilon_api.send(event);
                 self.instance_provider.remove_instance(name).await?;
-
-                info!("Cleaned server: {}", name);
             }
         }
 
         for instance in proxies {
-            if instance.need_close() {
+            if instance.is_succeeded() {
                 let name = instance.get_name();
                 let event = EpsilonEvent::ClearServer(name.to_string());
 
                 self.epsilon_api.send(event);
                 self.instance_provider.remove_instance(name).await?;
-
-                info!("Clean proxy: {}", name);
             }
         }
 
         Ok(())
     }
 
     fn get_name(&self) -> &'static str {
-        "Clean:Task, clean all servers and proxies that need to be closed"
+        "Clean:Task, clean all servers and proxies that need to be closed (Succeeded = true)"
     }
 }

src/tasks/hub_task.rs

@@ -38,7 +38,12 @@ impl Task for HubTask {
 
         let proxies = self
             .instance_provider
-            .get_instances(&InstanceType::Proxy, None, Some(&EpsilonState::Running))
+            .get_instances(
+                &InstanceType::Proxy,
+                None,
+                Some(&EpsilonState::Running),
+                false,
+            )
             .await?;
 
         let proxy_number = proxies.len();
@@ -50,6 +55,7 @@ impl Task for HubTask {
                     &InstanceType::Server,
                     Some(template_name),
                     Some(&EpsilonState::Starting),
+                    false,
                 )
                 .await?;
 
@@ -60,6 +66,7 @@ impl Task for HubTask {
                         &InstanceType::Server,
                         Some(template_name),
                         Some(&EpsilonState::Running),
+                        false,
                     )
                     .await?;
 

src/tasks/proxy_task.rs

@@ -30,7 +30,7 @@ impl Task for ProxyTask {
 
         let proxies = self
             .instance_provider
-            .get_instances(&InstanceType::Proxy, None, None)
+            .get_instances(&InstanceType::Proxy, None, None, false)
             .await?;
 
         if proxies.is_empty() {

src/tasks/queue_task.rs

@@ -39,6 +39,7 @@ impl Task for QueueTask {
                         &InstanceType::Server,
                         Some(template_name),
                         Some(&EpsilonState::Starting),
+                        false,
                     )
                     .await?;
 
@@ -48,6 +49,7 @@ impl Task for QueueTask {
                         &InstanceType::Server,
                         Some(template_name),
                         Some(&EpsilonState::Running),
+                        false,
                     )
                     .await?;