continue mess

bin/nanocld/specs/swagger.yaml

@@ -499,46 +499,6 @@ paths:
           description: Cargo restarted
         '404':
           description: Cargo does not exist
-  /cargoes/{name}/scale:
-    patch:
-      tags:
-      - Cargoes
-      summary: Scale or Downscale number of instances
-      description: Scale or Downscale number of instances
-      operationId: scale_cargo
-      parameters:
-      - name: name
-        in: path
-        description: Name of the cargo
-        required: true
-        schema:
-          type: string
-      - name: namespace
-        in: query
-        description: Namespace where the cargo belongs
-        required: false
-        schema:
-          type: string
-          nullable: true
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/CargoScale'
-        required: true
-      responses:
-        '200':
-          description: Cargo scaled
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/Cargo'
-        '404':
-          description: Cargo does not exist
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/ApiError'
   /cargoes/{name}/stats:
     get:
       tags:
@@ -2168,15 +2128,6 @@ components:
         signal:
           type: string
           description: 'Signal to send to the container default: SIGKILL'
-    CargoScale:
-      type: object
-      description: Payload for the cargo scale endpoint
-      required:
-      - Replicas
-      properties:
-        Replicas:
-          type: integer
-          description: Number of replicas to scale up or down can be negative value
     CargoSpec:
       type: object
       description: |-

bin/nanocld/src/models/cargo.rs

@@ -1,5 +1,5 @@
 use diesel::prelude::*;
-use nanocl_stubs::cargo_spec::CargoSpecPartial;
+use nanocl_stubs::cargo_spec::{CargoSpecPartial, CargoSpecUpdate};
 
 use crate::schema::cargoes;
 
@@ -45,3 +45,13 @@ pub struct CargoObjCreateIn {
   pub spec: CargoSpecPartial,
   pub version: String,
 }
+
+pub struct CargoObjPutIn {
+  pub spec: CargoSpecPartial,
+  pub version: String,
+}
+
+pub struct CargoObjPatchIn {
+  pub spec: CargoSpecUpdate,
+  pub version: String,
+}

bin/nanocld/src/models/vm.rs

@@ -1,5 +1,5 @@
 use diesel::prelude::*;
-use nanocl_stubs::vm_spec::VmSpecPartial;
+use nanocl_stubs::vm_spec::{VmSpecPartial, VmSpecUpdate};
 
 use crate::schema::vms;
 
@@ -46,3 +46,13 @@ pub struct VmObjCreateIn {
   pub spec: VmSpecPartial,
   pub version: String,
 }
+
+pub struct VmObjPutIn {
+  pub spec: VmSpecPartial,
+  pub version: String,
+}
+
+pub struct VmObjPatchIn {
+  pub spec: VmSpecUpdate,
+  pub version: String,
+}

bin/nanocld/src/objects/cargo.rs

@@ -1,16 +1,23 @@
 use futures_util::{stream::FuturesUnordered, StreamExt};
-use bollard_next::container::RemoveContainerOptions;
+use bollard_next::{
+  container::{RemoveContainerOptions, Config},
+  service::HostConfig,
+};
 
 use nanocl_error::http::{HttpResult, HttpError};
 use nanocl_stubs::{
   cargo::{Cargo, CargoDeleteQuery},
-  cargo_spec::ReplicationMode,
+  cargo_spec::{ReplicationMode, CargoSpecPartial},
+  process::ProcessKind,
 };
 
 use crate::{
   utils,
   repositories::generic::*,
-  models::{CargoDb, SystemState, CargoObjCreateIn, ProcessDb, SpecDb},
+  models::{
+    CargoDb, SystemState, CargoObjCreateIn, ProcessDb, SpecDb, CargoObjPutIn,
+    CargoObjPatchIn,
+  },
 };
 
 use super::generic::*;
@@ -58,11 +65,11 @@ impl ObjDelByPk for CargoDb {
   type ObjDelOpts = CargoDeleteQuery;
 
   async fn fn_del_obj_by_pk(
-    key: &str,
+    pk: &str,
     opts: &Self::ObjDelOpts,
     state: &SystemState,
   ) -> HttpResult<Self::ObjDelOut> {
-    let cargo = CargoDb::transform_read_by_pk(key, &state.pool).await?;
+    let cargo = CargoDb::transform_read_by_pk(pk, &state.pool).await?;
     let processes =
       ProcessDb::read_by_kind_key(&cargo.spec.cargo_key, &state.pool).await?;
     processes
@@ -83,8 +90,194 @@ impl ObjDelByPk for CargoDb {
       .await
       .into_iter()
       .collect::<Result<Vec<_>, _>>()?;
-    CargoDb::del_by_pk(key, &state.pool).await?;
-    SpecDb::del_by_kind_key(key, &state.pool).await?;
+    CargoDb::del_by_pk(pk, &state.pool).await?;
+    SpecDb::del_by_kind_key(pk, &state.pool).await?;
     Ok(cargo)
   }
 }
+
+impl ObjPutByPk for CargoDb {
+  type ObjPutIn = CargoObjPutIn;
+  type ObjPutOut = Cargo;
+
+  async fn fn_put_obj_by_pk(
+    pk: &str,
+    obj: &Self::ObjPutIn,
+    state: &SystemState,
+  ) -> HttpResult<Self::ObjPutOut> {
+    let cargo =
+      CargoDb::update_from_spec(pk, &obj.spec, &obj.version, &state.pool)
+        .await?;
+    // Get the number of instance to create
+    let number = if let Some(mode) = &cargo.spec.replication {
+      match mode {
+        ReplicationMode::Static(replication_static) => {
+          replication_static.number
+        }
+        ReplicationMode::Auto => 1,
+        ReplicationMode::Unique => 1,
+        ReplicationMode::UniqueByNode => 1,
+        _ => 1,
+      }
+    } else {
+      1
+    };
+    let processes = ProcessDb::read_by_kind_key(pk, &state.pool).await?;
+    utils::cargo::restore_instances_backup(&processes, state).await?;
+    // Create instance with the new spec
+    let new_instances =
+      match utils::cargo::create_instances(&cargo, number, state).await {
+        // If the creation of the new instance failed, we rename the old containers
+        Err(err) => {
+          log::warn!("Unable to create cargo instance: {}", err);
+          log::warn!("Rollback to previous instance");
+          utils::cargo::rename_instances_original(&processes, state).await?;
+          Vec::default()
+        }
+        Ok(instances) => instances,
+      };
+    // start created containers
+    match utils::process::start_by_kind(&ProcessKind::Cargo, pk, state).await {
+      Err(err) => {
+        log::error!(
+          "Unable to start cargo instance {} : {err}",
+          cargo.spec.cargo_key
+        );
+        utils::cargo::delete_instances(
+          &new_instances
+            .iter()
+            .map(|i| i.key.clone())
+            .collect::<Vec<_>>(),
+          state,
+        )
+        .await?;
+        utils::cargo::rename_instances_original(&processes, state).await?;
+      }
+      Ok(_) => {
+        // Delete old containers
+        utils::cargo::delete_instances(
+          &processes.iter().map(|c| c.key.clone()).collect::<Vec<_>>(),
+          state,
+        )
+        .await?;
+      }
+    }
+    Ok(cargo)
+  }
+}
+
+impl ObjPatchByPk for CargoDb {
+  type ObjPatchIn = CargoObjPatchIn;
+  type ObjPatchOut = Cargo;
+
+  async fn fn_patch_obj_by_pk(
+    pk: &str,
+    obj: &Self::ObjPatchIn,
+    state: &SystemState,
+  ) -> HttpResult<Self::ObjPatchOut> {
+    let payload = &obj.spec;
+    let version = &obj.version;
+    let cargo = CargoDb::transform_read_by_pk(pk, &state.pool).await?;
+    let container = if let Some(container) = payload.container.clone() {
+      // merge env and ensure no duplicate key
+      let new_env = container.env.unwrap_or_default();
+      let mut env_vars: Vec<String> =
+        cargo.spec.container.env.unwrap_or_default();
+      // Merge environment variables from new_env into the merged array
+      for env_var in new_env {
+        let parts: Vec<&str> = env_var.split('=').collect();
+        if parts.len() < 2 {
+          continue;
+        }
+        let name = parts[0].to_owned();
+        let value = parts[1..].join("=");
+        if let Some(pos) = env_vars
+          .iter()
+          .position(|x| x.starts_with(&format!("{name}=")))
+        {
+          let old_value = env_vars[pos].to_owned();
+          log::trace!(
+            "env var: {name} old_value: {old_value} new_value: {value}"
+          );
+          if old_value != value && !value.is_empty() {
+            // Update the value if it has changed
+            env_vars[pos] = format!("{}={}", name, value);
+          } else if value.is_empty() {
+            // Remove the variable if the value is empty
+            env_vars.remove(pos);
+          }
+        } else {
+          // Add new environment variables
+          env_vars.push(env_var);
+        }
+      }
+      // merge volumes and ensure no duplication
+      let new_volumes = container
+        .host_config
+        .clone()
+        .unwrap_or_default()
+        .binds
+        .unwrap_or_default();
+      let mut volumes: Vec<String> = cargo
+        .spec
+        .container
+        .host_config
+        .clone()
+        .unwrap_or_default()
+        .binds
+        .unwrap_or_default();
+      for volume in new_volumes {
+        if !volumes.contains(&volume) {
+          volumes.push(volume);
+        }
+      }
+      let image = if let Some(image) = container.image.clone() {
+        Some(image)
+      } else {
+        cargo.spec.container.image
+      };
+      let cmd = if let Some(cmd) = container.cmd {
+        Some(cmd)
+      } else {
+        cargo.spec.container.cmd
+      };
+      Config {
+        cmd,
+        image,
+        env: Some(env_vars),
+        host_config: Some(HostConfig {
+          binds: Some(volumes),
+          ..cargo.spec.container.host_config.unwrap_or_default()
+        }),
+        ..cargo.spec.container
+      }
+    } else {
+      cargo.spec.container
+    };
+    let spec = CargoSpecPartial {
+      name: cargo.spec.name.clone(),
+      container,
+      init_container: if payload.init_container.is_some() {
+        payload.init_container.clone()
+      } else {
+        cargo.spec.init_container
+      },
+      replication: payload.replication.clone(),
+      secrets: if payload.secrets.is_some() {
+        payload.secrets.clone()
+      } else {
+        cargo.spec.secrets
+      },
+      metadata: if payload.metadata.is_some() {
+        payload.metadata.clone()
+      } else {
+        cargo.spec.metadata
+      },
+    };
+    let obj = &CargoObjPutIn {
+      spec,
+      version: version.to_owned(),
+    };
+    CargoDb::fn_put_obj_by_pk(pk, obj, state).await
+  }
+}

bin/nanocld/src/objects/generic/delete.rs

@@ -8,20 +8,20 @@ pub trait ObjDelByPk {
   type ObjDelOpts;
 
   async fn fn_del_obj_by_pk(
-    key: &str,
+    pk: &str,
     opts: &Self::ObjDelOpts,
     state: &SystemState,
   ) -> HttpResult<Self::ObjDelOut>;
 
   async fn del_obj_by_pk(
-    key: &str,
+    pk: &str,
     opts: &Self::ObjDelOpts,
     state: &SystemState,
   ) -> HttpResult<Self::ObjDelOut>
   where
     Self::ObjDelOut: Into<EventActor> + Clone,
   {
-    let obj = Self::fn_del_obj_by_pk(key, opts, state).await?;
+    let obj = Self::fn_del_obj_by_pk(pk, opts, state).await?;
     state.emit_normal_native_action(&obj, NativeEventAction::Delete);
     Ok(obj)
   }

bin/nanocld/src/objects/generic/mod.rs

@@ -1,7 +1,9 @@
 mod create;
 mod delete;
 mod patch;
+mod put;
 
 pub use create::*;
 pub use delete::*;
 pub use patch::*;
+pub use put::*;