New template API with resources management !

Author: EliXorZz

src/epsilon/server/instance.rs

@@ -14,8 +14,6 @@ use crate::epsilon::server::state::EpsilonState;
 use crate::epsilon::server::template::Template;
 use serde::Serialize;
 
-//TODO: Use Label from class::Label
-
 pub struct Instance {
     pod: Pod,
 }
@@ -32,19 +30,20 @@ pub struct InstanceJson {
 impl Instance {
     pub async fn new(kube: &Arc<Kube>, template: &Template) -> EResult<Self> {
         let template_name = &template.name;
-        let instance_type = &template.t.parse()?;
+        let instance_type = &template.t;
+        let resources = &template.resources;
         let slots = template.slots;
 
         let instance_label = Label::get_instance_type_label(instance_type);
         let template_label = Label::get_template_label(template_name);
         let slots_label = Label::get_slots_label(slots);
 
-        let port = instance_type.get_associated_port();
-
         let labels = vec![instance_label, template_label, slots_label];
 
+        let port = instance_type.get_associated_port();
+
         let pod = kube
-            .create_epsilon_pod(template_name, Some(&labels), port)
+            .create_epsilon_pod(template_name, Some(&labels), port, resources)
             .await?;
 
         Ok(Self { pod })
@@ -68,7 +67,7 @@ impl Instance {
             .labels
             .as_ref()
             .unwrap()
-            .get("epsilon.fr/template")
+            .get(Label::TEMPLATE_LABEL)
             .unwrap()
     }
 
@@ -78,7 +77,7 @@ impl Instance {
             .labels
             .as_ref()
             .unwrap()
-            .get("epsilon.fr/instance")
+            .get(Label::INSTANCE_TYPE_LABEL)
             .unwrap()
             .parse()
             .unwrap()
@@ -90,7 +89,7 @@ impl Instance {
             .labels
             .as_ref()
             .unwrap()
-            .get("epsilon.fr/slots")
+            .get(Label::SLOTS_LABEL)
             .unwrap()
             .parse()
             .unwrap()

src/epsilon/server/instance_provider.rs

@@ -68,8 +68,8 @@ impl InstanceProvider {
         }
     }
 
-    pub async fn enable_in_game_instance(&self, name: &str) -> EResult<()> {
-        let label = &Label::get_in_game_label();
+    pub async fn set_in_game_instance(&self, name: &str, enable: bool) -> EResult<()> {
+        let label = &Label::get_in_game_label(enable);
 
         let patch = json!({
             "metadata": {
@@ -83,24 +83,10 @@ impl InstanceProvider {
     }
 
     pub async fn get_template_host(&self, route: &str) -> String {
-        let labels = vec![Label::new("epsilon.fr/template-provider", "true")];
-
-        let pods_result = self.kube.get_pods(Some(&labels), None).await;
-
-        pods_result.as_ref().unwrap();
-
-        if let Ok(pods) = pods_result {
-            let pod = pods.first();
-
-            if let Some(pod) = pod {
-                let status = pod.status.as_ref().unwrap();
-                let pod_ip = status.pod_ip.as_ref().unwrap();
-
-                return format!("http://{}:3333/{}", pod_ip, route);
-            }
-        }
-
-        format!("http://127.0.0.1:3333/{}", route)
+        format!(
+            "http://template-service.epsilon.svc.cluster.local:3333/{}",
+            route
+        )
     }
 
     pub async fn get_template(&self, template_name: &str) -> EResult<Template> {
@@ -159,7 +145,7 @@ pub async fn close(instance_name: &str, instance_provider: &State<Arc<InstancePr
 #[rocket::post("/in_game/<instance>")]
 pub async fn in_game(instance: &str, instance_provider: &State<Arc<InstanceProvider>>) {
     instance_provider
-        .enable_in_game_instance(instance)
+        .set_in_game_instance(instance, true)
         .await
         .unwrap();
 

src/epsilon/server/instance_type.rs

@@ -1,6 +1,9 @@
 use std::io;
 use std::str::FromStr;
 
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize)]
 pub enum InstanceType {
     Server,
     Proxy,

src/epsilon/server/mod.rs

@@ -2,6 +2,7 @@ pub mod instance;
 pub mod instance_provider;
 pub mod instance_type;
 
+pub mod resources;
 pub mod state;
 pub mod template;
 

src/epsilon/server/resources.rs

@@ -0,0 +1,13 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize)]
+pub struct Resources {
+    pub minimum: ResourcesInfo,
+    pub maximum: ResourcesInfo,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct ResourcesInfo {
+    pub cpu: u8,
+    pub ram: u32,
+}

src/epsilon/server/template.rs

@@ -3,15 +3,19 @@ use std::collections::HashMap;
 
 use serde::{Deserialize, Serialize};
 
+use crate::epsilon::server::instance_type::InstanceType;
+use crate::epsilon::server::resources::Resources;
+
 #[derive(Serialize, Deserialize)]
 pub struct Template {
     pub name: String,
+    pub parent: String,
 
     #[serde(rename = "type")]
-    pub t: String,
+    pub t: InstanceType,
 
     pub slots: i32,
+    pub resources: Resources,
 
-    pub schema: String,
     pub labels: HashMap<String, Value>,
 }

src/k8s/kube.rs

@@ -7,6 +7,7 @@ use std::sync::Arc;
 use k8s_openapi::serde_json;
 use k8s_openapi::serde_json::{json, Value};
 
+use crate::epsilon::server::resources::Resources;
 use kube::api::{DeleteParams, ListParams, Patch, PatchParams, PostParams};
 use kube::{Api, Client, Error};
 
@@ -41,6 +42,7 @@ impl Kube {
         template: &str,
         labels_option: Option<&Vec<Label>>,
         port: u16,
+        resources: &Resources,
     ) -> Result<Pod, Error> {
         let default_label = self.get_default_label();
 
@@ -78,6 +80,16 @@ impl Kube {
                             "protocol": "TCP"
                         }
                     ],
+                    "resources": {
+                        "requests": {
+                            "cpu": resources.minimum.cpu,
+                            "memory": format!("{}M", resources.minimum.ram)
+                        },
+                        "limits": {
+                            "cpu": resources.maximum.cpu,
+                            "memory": format!("{}M", resources.maximum.ram)
+                        }
+                    },
                     "readinessProbe": {
                         "initialDelaySeconds": 5,
                         "periodSeconds": 1,