Content when create instance supported now !

EliXorZz · EliXorZz · commit 429791d50efc · 2022-08-03T19:00:29.000+02:00
diff --git a/resources/epsilon_instance-definition.yaml b/resources/epsilon_instance-definition.yaml
@@ -33,18 +33,19 @@ spec:
           properties:
             spec:
               properties:
+                content: {}
                 template:
                   type: string
               required:
+                - content
                 - template
               type: object
             status:
               nullable: true
               properties:
                 close:
                   type: boolean
-                content:
-                  type: string
+                content: {}
                 hub:
                   type: boolean
                 ip:
diff --git a/src/controller/definitions/epsilon_instance.rs b/src/controller/definitions/epsilon_instance.rs
@@ -9,6 +9,7 @@ use async_minecraft_ping::{ConnectionConfig, StatusResponse};
 use kube::CustomResource;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
+use serde_json::Value;
 use std::time::Duration;
 use tokio::time::timeout;
 
@@ -25,6 +26,7 @@ use tokio::time::timeout;
 )]
 pub struct EpsilonInstanceSpec {
     pub template: String,
+    pub content: Value,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone, JsonSchema)]
@@ -36,7 +38,7 @@ pub struct EpsilonInstanceStatus {
 
     pub hub: bool,
 
-    pub content: String,
+    pub content: Value,
 
     pub state: EpsilonState,
 
@@ -157,7 +159,7 @@ pub struct InstanceJson {
     pub name: String,
     pub template: String,
 
-    pub content: String,
+    pub content: Value,
 
     pub hub: bool,
 
diff --git a/src/controller/epsilon_controller.rs b/src/controller/epsilon_controller.rs
@@ -18,7 +18,7 @@ use kube::runtime::reflector::{ObjectRef, Store};
 use kube::runtime::Controller;
 use kube::{Api, Client, Config};
 use kube::{Error, Resource};
-use serde_json::json;
+use serde_json::{json, Value};
 use std::collections::BTreeMap;
 use std::env;
 use std::sync::Arc;
@@ -90,7 +90,10 @@ impl EpsilonController {
         let instance_status = epsilon_instance.status.clone();
 
         let instance_name = epsilon_instance.get_name();
-        let template_name = &instance_spec.template;
+
+        let instance_content = instance_spec.content.clone();
+
+        let instance_template_name = &instance_spec.template;
 
         if let Ok(pod_option) = pod_api.get_opt(&instance_name).await {
             match pod_option {
@@ -99,7 +102,10 @@ impl EpsilonController {
                         epsilon_instance.controller_owner_ref(&()).unwrap();
                     instance_owner_reference.block_owner_deletion = Some(true);
 
-                    let template = template_provider.get_template(template_name).await.unwrap();
+                    let template = template_provider
+                        .get_template(instance_template_name)
+                        .await
+                        .unwrap();
 
                     let instance_type = &template.t;
                     let instance_resource = &template.resources;
@@ -121,7 +127,7 @@ impl EpsilonController {
                             restart_policy: Some(String::from("Never")),
                             containers: vec![Container {
                                 name: String::from("main"),
-                                image: Some(Self::get_image(&template_name)),
+                                image: Some(Self::get_image(&instance_template_name)),
                                 image_pull_policy: Some(String::from("Always")),
                                 env_from: Some(vec![
                                     EnvFromSource {
@@ -196,20 +202,22 @@ impl EpsilonController {
 
                         let mut new_status = match instance_status {
                             None => {
-                                let template =
-                                    template_provider.get_template(template_name).await.unwrap();
+                                let template = template_provider
+                                    .get_template(instance_template_name)
+                                    .await
+                                    .unwrap();
 
                                 let template_type = template.t.clone();
 
                                 EpsilonInstanceStatus {
                                     ip: pod_ip,
 
-                                    template: template_name.to_owned(),
+                                    template: instance_template_name.to_owned(),
                                     t: template_type,
 
                                     hub: template_provider.is_hub(&template),
 
-                                    content: String::from(""),
+                                    content: instance_content,
 
                                     slots: template.slots,
                                     online: 0,
@@ -221,6 +229,7 @@ impl EpsilonController {
                             }
                             Some(mut status) => {
                                 status.ip = pod_ip;
+                                status.content = instance_content;
                                 status.state = state;
 
                                 if state == EpsilonState::Running {
@@ -282,6 +291,7 @@ impl EpsilonController {
     pub async fn create_epsilon_instance(
         &self,
         template_name: &str,
+        content: Value,
     ) -> Result<EpsilonInstance, EpsilonError> {
         let epsilon_instance_api = &self.context.epsilon_instance_api;
 
@@ -292,6 +302,7 @@ impl EpsilonController {
             },
             spec: EpsilonInstanceSpec {
                 template: template_name.to_owned(),
+                content,
             },
             status: None,
         };
diff --git a/src/epsilon/server/instances/common/instance_type.rs b/src/epsilon/server/instances/common/instance_type.rs
@@ -1,6 +1,3 @@
-use std::io;
-use std::str::FromStr;
-
 use k8s_openapi::api::core::v1::ContainerPort;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
diff --git a/src/epsilon/server/instances/instance_provider.rs b/src/epsilon/server/instances/instance_provider.rs
@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use kube::api::DeleteParams;
-use kube::runtime::wait::await_condition;
+use serde_json::Value;
 
 use crate::controller::definitions::epsilon_instance::EpsilonInstance;
 use crate::epsilon::epsilon_error::EpsilonError;
@@ -23,10 +23,11 @@ impl InstanceProvider {
     pub async fn start_instance(
         &self,
         template_name: &str,
+        content: Option<Value>,
     ) -> Result<EpsilonInstance, EpsilonError> {
         Ok(self
             .epsilon_controller
-            .create_epsilon_instance(template_name)
+            .create_epsilon_instance(template_name, content.unwrap_or_default())
             .await?)
     }
 
diff --git a/src/epsilon/server/instances/routes.rs b/src/epsilon/server/instances/routes.rs
@@ -2,18 +2,25 @@ use std::sync::Arc;
 
 use rocket::State;
 use serde_json::json;
+use serde_json::Value;
 
 use crate::controller::definitions::epsilon_instance::InstanceJson;
 use crate::epsilon::epsilon_error::EpsilonError;
 use crate::epsilon::server::instances::common::instance_type::InstanceType;
 use crate::Context;
 
-#[rocket::post("/create/<template>")]
-pub async fn create(template: &str, context: &State<Arc<Context>>) -> Result<(), EpsilonError> {
+use rocket::serde::json::Json;
+
+#[rocket::post("/create/<template>", format = "json", data = "<content>")]
+pub async fn create(
+    template: &str,
+    content: Json<Value>,
+    context: &State<Arc<Context>>,
+) -> Result<(), EpsilonError> {
     let instance_provider = context.get_instance_provider();
 
     instance_provider
-        .start_instance(template)
+        .start_instance(template, Some(content.0))
         .await
         .map_err(|_| {
             EpsilonError::ApiServerError(format!(
diff --git a/src/tasks/hub_task.rs b/src/tasks/hub_task.rs
@@ -66,7 +66,9 @@ impl Task for HubTask {
                         + 1.0) as u32;
 
                     if hub_number < hub_necessary {
-                        instance_provider.start_instance(template_name).await?;
+                        instance_provider
+                            .start_instance(template_name, None)
+                            .await?;
                     }
 
                     if hub_number > hub_necessary {
diff --git a/src/tasks/proxy_task.rs b/src/tasks/proxy_task.rs
@@ -32,7 +32,9 @@ impl Task for ProxyTask {
             .await?;
 
         if proxies.is_empty() {
-            instance_provider.start_instance(template_name).await?;
+            instance_provider
+                .start_instance(template_name, None)
+                .await?;
         }
 
         Ok(())
diff --git a/src/tasks/queue_task.rs b/src/tasks/queue_task.rs
@@ -43,15 +43,19 @@ impl Task for QueueTask {
                     .await?;
 
                 if instances_starting.is_empty() && instances_ready.is_empty() {
-                    instance_provider.start_instance(template_name).await?;
+                    instance_provider
+                        .start_instance(template_name, None)
+                        .await?;
                     return Ok(());
                 }
 
                 let ready_available_slots_result = instances_ready.get_available_slots().await;
 
                 if let Ok(ready_available_slots) = ready_available_slots_result {
                     if instances_starting.is_empty() && ready_available_slots < 1 {
-                        instance_provider.start_instance(template_name).await?;
+                        instance_provider
+                            .start_instance(template_name, None)
+                            .await?;
                     }
                 }
 

Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,9 @@ impl Task for HubTask {`
`66`	`66`	`+ 1.0) as u32;`
`67`	`67`
`68`	`68`	`if hub_number < hub_necessary {`
`69`		`- instance_provider.start_instance(template_name).await?;`
	`69`	`+ instance_provider`
	`70`	`+ .start_instance(template_name, None)`
	`71`	`+ .await?;`
`70`	`72`	`}`
`71`	`73`
`72`	`74`	`if hub_number > hub_necessary {`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,9 @@ impl Task for ProxyTask {`
`32`	`32`	`.await?;`
`33`	`33`
`34`	`34`	`if proxies.is_empty() {`
`35`		`- instance_provider.start_instance(template_name).await?;`
	`35`	`+ instance_provider`
	`36`	`+ .start_instance(template_name, None)`
	`37`	`+ .await?;`
`36`	`38`	`}`
`37`	`39`
`38`	`40`	`Ok(())`
Original file line number	Diff line number	Diff line change
`@@ -43,15 +43,19 @@ impl Task for QueueTask {`
`43`	`43`	`.await?;`
`44`	`44`
`45`	`45`	`if instances_starting.is_empty() && instances_ready.is_empty() {`
`46`		`- instance_provider.start_instance(template_name).await?;`
	`46`	`+ instance_provider`
	`47`	`+ .start_instance(template_name, None)`
	`48`	`+ .await?;`
`47`	`49`	`return Ok(());`
`48`	`50`	`}`
`49`	`51`
`50`	`52`	`let ready_available_slots_result = instances_ready.get_available_slots().await;`
`51`	`53`
`52`	`54`	`if let Ok(ready_available_slots) = ready_available_slots_result {`
`53`	`55`	`if instances_starting.is_empty() && ready_available_slots < 1 {`
`54`		`- instance_provider.start_instance(template_name).await?;`
	`56`	`+ instance_provider`
	`57`	`+ .start_instance(template_name, None)`
	`58`	`+ .await?;`
`55`	`59`	`}`
`56`	`60`	`}`
`57`	`61`