Better error handling, Clean up and add timout for ping Minecraft

Author: EliXorZz

src/controller/definitions/epsilon_instance.rs

@@ -3,8 +3,9 @@ use std::sync::Arc;
 
 use crate::epsilon::server::instances::common::instance_type::InstanceType;
 use crate::epsilon::server::instances::common::state::EpsilonState;
-use crate::EResult;
 
+use crate::epsilon::epsilon_error::EpsilonError;
+use anyhow::format_err;
 use async_minecraft_ping::{ConnectionConfig, StatusResponse};
 use kube::CustomResource;
 use schemars::JsonSchema;
@@ -45,14 +46,24 @@ pub struct EpsilonInstanceStatus {
 }
 
 impl EpsilonInstance {
-    pub async fn to_json(&self) -> InstanceJson {
-        InstanceJson {
-            name: self.metadata.name.as_ref().unwrap().clone(),
+    pub async fn to_json(&self) -> Result<InstanceJson, EpsilonError> {
+        Ok(InstanceJson {
+            name: self.get_name(),
             template: self.spec.template.clone(),
-            state: self.get_state().clone(),
-            slots: self.status.as_ref().unwrap().slots,
+            state: *self.get_state(),
+
+            slots: self
+                .status
+                .as_ref()
+                .ok_or(EpsilonError::RetrieveStatusError)?
+                .slots,
+
             online_count: self.get_online_count().await.unwrap_or(0),
-        }
+        })
+    }
+
+    pub fn get_name(&self) -> String {
+        self.metadata.name.as_ref().unwrap().to_owned()
     }
 
     pub fn get_state(&self) -> &EpsilonState {
@@ -62,38 +73,51 @@ impl EpsilonInstance {
         }
     }
 
-    pub async fn get_info(&self) -> EResult<StatusResponse> {
-        let status = self.status.as_ref().unwrap();
-        let address = status.ip.as_ref().unwrap();
-        let config = ConnectionConfig::build(address);
+    pub async fn get_info(&self) -> Result<StatusResponse, EpsilonError> {
+        let status = self
+            .status
+            .as_ref()
+            .ok_or(EpsilonError::RetrieveStatusError)?;
 
-        let duration = Duration::from_millis(100);
+        let address = status
+            .ip
+            .as_ref()
+            .ok_or(EpsilonError::RetrieveStatusError)?;
 
-        let connect = timeout(duration, async move { config.connect().await }).await??;
+        let config = ConnectionConfig::build(address);
+        let duration = Duration::from_millis(150);
 
-        let status = timeout(duration, async move { connect.status().await }).await??;
+        let status_result: Result<StatusResponse, EpsilonError> = timeout(duration, async move {
+            Ok(config.connect().await?.status().await?.status)
+        })
+        .await?;
 
-        Ok(status.status)
+        status_result
     }
 
-    pub async fn get_online_count(&self) -> EResult<i32> {
+    pub async fn get_online_count(&self) -> Result<i32, EpsilonError> {
         Ok(self.get_info().await?.players.online as i32)
     }
 
-    pub async fn get_available_slots(&self) -> EResult<i32> {
-        Ok(&self.status.as_ref().unwrap().slots - self.get_online_count().await?)
+    pub async fn get_available_slots(&self) -> Result<i32, EpsilonError> {
+        Ok(&self
+            .status
+            .as_ref()
+            .ok_or(EpsilonError::RetrieveStatusError)?
+            .slots
+            - self.get_online_count().await?)
     }
 }
 
 #[async_trait]
 pub trait VectorOfInstance {
-    async fn get_available_slots(&self) -> EResult<i32>;
-    async fn get_online_count(&self) -> EResult<i32>;
+    async fn get_available_slots(&self) -> Result<i32, EpsilonError>;
+    async fn get_online_count(&self) -> Result<i32, EpsilonError>;
 }
 
 #[async_trait]
 impl VectorOfInstance for Vec<Arc<EpsilonInstance>> {
-    async fn get_available_slots(&self) -> EResult<i32> {
+    async fn get_available_slots(&self) -> Result<i32, EpsilonError> {
         let mut available_slots = 0;
 
         for instance in self {
@@ -103,7 +127,7 @@ impl VectorOfInstance for Vec<Arc<EpsilonInstance>> {
         Ok(available_slots)
     }
 
-    async fn get_online_count(&self) -> EResult<i32> {
+    async fn get_online_count(&self) -> Result<i32, EpsilonError> {
         let mut number = 0;
 
         for instance in self {

src/controller/epsilon_controller.rs

@@ -3,6 +3,7 @@ use crate::controller::definitions::epsilon_instance::{
     EpsilonInstance, EpsilonInstanceSpec, EpsilonInstanceStatus,
 };
 use crate::controller::definitions::epsilon_queue::EpsilonQueue;
+use crate::epsilon::epsilon_error::EpsilonError;
 use crate::epsilon::server::instances::common::state::EpsilonState;
 use crate::{EResult, TemplateProvider};
 use anyhow::format_err;
@@ -264,7 +265,10 @@ impl EpsilonController {
         )
     }
 
-    pub async fn create_epsilon_instance(&self, template_name: &str) -> EResult<EpsilonInstance> {
+    pub async fn create_epsilon_instance(
+        &self,
+        template_name: &str,
+    ) -> Result<EpsilonInstance, EpsilonError> {
         let epsilon_instance_api = &self.context.epsilon_instance_api;
 
         let epsilon_instance = EpsilonInstance {
@@ -278,17 +282,25 @@ impl EpsilonController {
             status: None,
         };
 
-        Ok(epsilon_instance_api
+        let instance_result = epsilon_instance_api
             .create(&PostParams::default(), &epsilon_instance)
-            .await?)
+            .await
+            .map_err(|_| EpsilonError::CreateInstanceError(String::from(template_name)));
+
+        Ok(instance_result?)
     }
 
-    pub async fn in_game_epsilon_instance(&self, instance_name: &str) -> EResult<()> {
+    pub async fn in_game_epsilon_instance(&self, instance_name: &str) -> Result<(), EpsilonError> {
         let epsilon_instance_api = &self.context.epsilon_instance_api;
         let store = &self.store;
 
         if let Some(epsilon_instance) = store.get(&ObjectRef::new(instance_name)) {
-            let mut instance_status = epsilon_instance.status.as_ref().unwrap().clone();
+            let mut instance_status = epsilon_instance
+                .status
+                .as_ref()
+                .ok_or(EpsilonError::RetrieveStatusError)?
+                .clone();
+
             instance_status.state = EpsilonState::InGame;
 
             epsilon_instance_api
@@ -297,12 +309,11 @@ impl EpsilonController {
                     &PatchParams::default(),
                     &Patch::Merge(json!({ "status": instance_status })),
                 )
-                .await?;
-
-            Ok(())
-        } else {
-            Err(format_err!("Instance not found: {}", instance_name))
+                .await
+                .map_err(|_| EpsilonError::RemoveInstanceError(String::from(instance_name)))?;
         }
+
+        Ok(())
     }
 
     pub fn get_epsilon_instance_api(&self) -> &Api<EpsilonInstance> {

src/epsilon/epsilon_error.rs

@@ -1,7 +1,41 @@
+use rocket::http::Status;
+use rocket::http::StatusClass::ServerError;
+use rocket::response::Responder;
+use rocket::{response, Request, Response};
 use thiserror::Error;
 
 #[derive(Error, Debug)]
 pub enum EpsilonError {
-    #[error("API server error -> {0}")]
+    #[error("API server error {0}")]
     ApiServerError(String),
+
+    #[error("Failed to parse json")]
+    ParseJsonError,
+
+    #[error("Create instance error, template is ({0})")]
+    CreateInstanceError(String),
+
+    #[error("Remove instance error {0}")]
+    RemoveInstanceError(String),
+
+    #[error("Retrieve instance error")]
+    RetrieveInstanceError,
+
+    #[error("Retrieve status error")]
+    RetrieveStatusError,
+
+    #[error("Request error {0}")]
+    RequestError(#[from] reqwest::Error),
+
+    #[error("Ping response error {0}")]
+    PingMinecraftError(#[from] async_minecraft_ping::ServerError),
+
+    #[error("Timeout error {0}")]
+    TimeoutError(#[from] tokio::time::error::Elapsed),
+}
+
+impl<'r> Responder<'r, 'static> for EpsilonError {
+    fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {
+        Response::build().status(Status::InternalServerError).ok()
+    }
 }

src/epsilon/queue/queue_provider.rs

@@ -3,8 +3,9 @@ use std::sync::Arc;
 
 use tokio::sync::RwLock;
 
+use crate::epsilon::epsilon_error::EpsilonError;
 use crate::epsilon::queue::common::epsilon_queue::Queue;
-use crate::{EResult, InstanceProvider, TemplateProvider};
+use crate::{InstanceProvider, TemplateProvider};
 
 pub struct QueueProvider {
     queue_map: HashMap<String, RwLock<Queue>>,
@@ -14,7 +15,7 @@ impl QueueProvider {
     pub async fn new(
         _instance_provider: &InstanceProvider,
         template_provider: &Arc<TemplateProvider>,
-    ) -> EResult<QueueProvider> {
+    ) -> Result<QueueProvider, EpsilonError> {
         let mut map = HashMap::new();
 
         for template in template_provider.get_templates().await? {

src/epsilon/server/instances/common/state.rs

@@ -1,7 +1,7 @@
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone, JsonSchema)]
+#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone, Copy, JsonSchema)]
 pub enum EpsilonState {
     Starting,
     Running,

src/epsilon/server/instances/instance_provider.rs

@@ -1,12 +1,14 @@
+use futures::TryFutureExt;
 use std::sync::Arc;
 
 use kube::api::DeleteParams;
 use kube::runtime::wait::await_condition;
 
 use crate::controller::definitions::epsilon_instance::EpsilonInstance;
+use crate::epsilon::epsilon_error::EpsilonError;
 use crate::epsilon::server::instances::common::instance_type::InstanceType;
 use crate::epsilon::server::instances::common::state::EpsilonState;
-use crate::{EResult, EpsilonController};
+use crate::EpsilonController;
 
 pub struct InstanceProvider {
     epsilon_controller: Arc<EpsilonController>,
@@ -19,68 +21,59 @@ impl InstanceProvider {
         }
     }
 
-    pub async fn start_instance(&self, template_name: &str) -> EResult<EpsilonInstance> {
+    pub async fn start_instance(
+        &self,
+        template_name: &str,
+    ) -> Result<EpsilonInstance, EpsilonError> {
         Ok(self
             .epsilon_controller
             .create_epsilon_instance(template_name)
             .await?)
     }
 
-    pub async fn remove_instance(&self, name: &str) -> EResult<()> {
+    pub async fn remove_instance(&self, name: &str) -> Result<(), EpsilonError> {
         info!("An instance has been removed (name={})", name);
 
         self.epsilon_controller
             .get_epsilon_instance_api()
             .delete(name, &DeleteParams::default())
-            .await?;
+            .await
+            .map_err(|_| EpsilonError::RemoveInstanceError(String::from(name)))?;
 
         Ok(())
     }
 
-    pub async fn get_instance(&self, instance_name: &str) -> EResult<EpsilonInstance> {
+    pub async fn get_instance(&self, instance_name: &str) -> Result<EpsilonInstance, EpsilonError> {
         Ok(self
             .epsilon_controller
             .get_epsilon_instance_api()
             .get(instance_name)
-            .await?)
+            .await
+            .map_err(|_| EpsilonError::RetrieveInstanceError)?)
     }
 
     pub async fn get_instances(
         &self,
         instance_type: &InstanceType,
         template_option: Option<&str>,
         state_option: Option<&EpsilonState>,
-    ) -> EResult<Vec<Arc<EpsilonInstance>>> {
+    ) -> Result<Vec<Arc<EpsilonInstance>>, EpsilonError> {
         let mut instances = self.epsilon_controller.get_epsilon_instance_store().state();
 
         for instance in &instances {
+            let name = instance.get_name();
+
             let condition = await_condition(
                 self.epsilon_controller.get_epsilon_instance_api().clone(),
-                instance.metadata.name.as_ref().unwrap(),
+                &name,
                 move |object: Option<&EpsilonInstance>| {
-                    object.map_or(false, |instance| {
-                        info!(
-                            "Instance status ({}) : {}",
-                            instance.metadata.name.as_ref().unwrap(),
-                            instance.status.is_some()
-                        );
-
-                        instance.status.is_some()
-                    })
+                    object.map_or(false, |instance| instance.status.is_some())
                 },
             );
 
             let _ = tokio::time::timeout(std::time::Duration::from_secs(5), condition).await?;
         }
 
-        for instance in &instances {
-            info!(
-                "Instance ({}) : {}",
-                instance.metadata.name.as_ref().unwrap(),
-                instance.status.is_some()
-            );
-        }
-
         instances = instances
             .into_iter()
             .filter(|instance| instance.status.as_ref().unwrap().t == *instance_type)
@@ -103,7 +96,7 @@ impl InstanceProvider {
         Ok(instances)
     }
 
-    pub async fn enable_in_game_instance(&self, name: &str) -> EResult<()> {
+    pub async fn enable_in_game_instance(&self, name: &str) -> Result<(), EpsilonError> {
         self.epsilon_controller.in_game_epsilon_instance(name).await
     }
 }