Ping proxy work now !

Author: EliXorZz

src/controller/definitions/epsilon_instance.rs

@@ -50,7 +50,8 @@ impl EpsilonInstance {
         let status = self
             .status
             .as_ref()
-            .ok_or(EpsilonError::RetrieveStatusError)?.clone();
+            .ok_or(EpsilonError::RetrieveStatusError)?
+            .clone();
 
         Ok(InstanceJson {
             name: self.get_name(),
@@ -82,13 +83,21 @@ impl EpsilonInstance {
     }
 
     pub async fn get_info(&self) -> Result<StatusResponse, EpsilonError> {
-        let address = self
+        let status = self
             .status
             .as_ref()
-            .and_then(|status| status.ip.as_ref())
             .ok_or(EpsilonError::RetrieveStatusError)?;
 
-        let config = ConnectionConfig::build(address);
+        let address = status
+            .ip
+            .as_ref()
+            .ok_or(EpsilonError::RetrieveIpAddressError)?;
+
+        let port = status.t.get_entry_port();
+
+        let mut config = ConnectionConfig::build(address);
+        config = config.with_port(port as u16);
+
         let duration = Duration::from_millis(150);
 
         let status_result: Result<StatusResponse, EpsilonError> = timeout(duration, async move {
@@ -158,5 +167,5 @@ pub struct InstanceJson {
     pub slots: i32,
     pub online_count: i32,
 
-    pub ip: Option<String>
+    pub ip: Option<String>,
 }

src/controller/epsilon_controller.rs

@@ -134,7 +134,7 @@ impl EpsilonController {
                                         ..Default::default()
                                     },
                                 ]),
-                                ports: Some(instance_type.get_associated_ports()),
+                                ports: Some(instance_type.get_container_ports()),
                                 resources: Some(instance_resource.kube_resources()),
                                 readiness_probe: Some(Probe {
                                     initial_delay_seconds: Some(5),
@@ -176,7 +176,9 @@ impl EpsilonController {
 
                         let state = if is_starting
                             || !instance_status.is_some()
-                            || (is_running && !is_ready && instance_status.as_ref().unwrap().state != EpsilonState::Running)
+                            || (is_running
+                                && !is_ready
+                                && instance_status.as_ref().unwrap().state != EpsilonState::Running)
                         {
                             EpsilonState::Starting
                         } else if is_running && is_ready {
@@ -215,7 +217,8 @@ impl EpsilonController {
                                 status.state = state;
 
                                 if state == EpsilonState::Running {
-                                    status.online = epsilon_instance.get_online_count().await.unwrap_or(0);
+                                    status.online =
+                                        epsilon_instance.get_online_count().await.unwrap_or(0);
                                 }
 
                                 status

src/epsilon/epsilon_error.rs

@@ -26,6 +26,9 @@ pub enum EpsilonError {
     #[error("Retrieve status error")]
     RetrieveStatusError,
 
+    #[error("Retrieve Ip address error")]
+    RetrieveIpAddressError,
+
     #[error("Queue not found error {0}")]
     QueueNotFoundError(String),
 

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

@@ -12,17 +12,17 @@ pub enum InstanceType {
 }
 
 impl InstanceType {
-    pub fn get_associated_ports(&self) -> Vec<ContainerPort> {
+    pub fn get_container_ports(&self) -> Vec<ContainerPort> {
         match self {
             InstanceType::Server => vec![ContainerPort {
-                container_port: 25565,
+                container_port: self.get_entry_port(),
                 name: Some(String::from("server")),
                 protocol: Some(String::from("TCP")),
                 ..Default::default()
             }],
             InstanceType::Proxy => vec![
                 ContainerPort {
-                    container_port: 25577,
+                    container_port: self.get_entry_port(),
                     name: Some(String::from("proxy")),
                     protocol: Some(String::from("TCP")),
                     ..Default::default()
@@ -36,19 +36,11 @@ impl InstanceType {
             ],
         }
     }
-}
-
-impl FromStr for InstanceType {
-    type Err = io::Error;
 
-    fn from_str(input: &str) -> Result<InstanceType, Self::Err> {
-        match input.to_lowercase().as_str() {
-            "server" => Ok(InstanceType::Server),
-            "proxy" => Ok(InstanceType::Proxy),
-            _ => Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                format!("Invalid instance type, {}", input),
-            )),
+    pub fn get_entry_port(&self) -> i32 {
+        match self {
+            InstanceType::Server => 25565,
+            InstanceType::Proxy => 25577,
         }
     }
 }