refactor/nanocld: vm image repository

bin/nanocld/src/models/vm_image.rs

@@ -1,19 +1,9 @@
-use std::sync::Arc;
-
 use diesel::prelude::*;
-use ntex::rt::JoinHandle;
 use serde::{Serialize, Deserialize};
 
-use nanocl_error::io::{IoResult, IoError};
-
-use nanocl_stubs::{
-  generic::{GenericFilter, GenericClause},
-  vm_image::VmImage,
-};
-
-use crate::{utils, gen_where4string, schema::vm_images};
+use nanocl_stubs::vm_image::VmImage;
 
-use super::{Pool, Repository};
+use crate::schema::vm_images;
 
 /// This structure represent a virtual machine image in the database.
 /// A virtual machine image is a file that represent a virtual machine disk.
@@ -84,89 +74,3 @@ impl From<VmImageDb> for VmImage {
     }
   }
 }
-
-impl Repository for VmImageDb {
-  type Table = vm_images::table;
-  type Item = VmImageDb;
-  type UpdateItem = VmImageUpdateDb;
-
-  fn find_one(
-    filter: &GenericFilter,
-    pool: &Pool,
-  ) -> JoinHandle<IoResult<Self::Item>> {
-    log::trace!("VmImageDb::find_one: {filter:?}");
-    let r#where = filter.r#where.to_owned().unwrap_or_default();
-    let mut query = vm_images::dsl::vm_images.into_boxed();
-    if let Some(value) = r#where.get("name") {
-      gen_where4string!(query, vm_images::dsl::name, value);
-    }
-    if let Some(value) = r#where.get("kind") {
-      gen_where4string!(query, vm_images::dsl::kind, value);
-    }
-    if let Some(value) = r#where.get("parent") {
-      gen_where4string!(query, vm_images::dsl::parent, value);
-    }
-    if let Some(value) = r#where.get("format") {
-      gen_where4string!(query, vm_images::dsl::format, value);
-    }
-    if let Some(value) = r#where.get("path") {
-      gen_where4string!(query, vm_images::dsl::path, value);
-    }
-    let pool = Arc::clone(pool);
-    ntex::rt::spawn_blocking(move || {
-      let mut conn = utils::store::get_pool_conn(&pool)?;
-      let item = query
-        .get_result::<Self>(&mut conn)
-        .map_err(Self::map_err_context)?;
-      Ok::<_, IoError>(item)
-    })
-  }
-
-  fn find(
-    filter: &GenericFilter,
-    pool: &Pool,
-  ) -> JoinHandle<IoResult<Vec<Self::Item>>> {
-    log::trace!("VmImageDb::find: {filter:?}");
-    let r#where = filter.r#where.to_owned().unwrap_or_default();
-    let mut query = vm_images::dsl::vm_images.into_boxed();
-    if let Some(value) = r#where.get("name") {
-      gen_where4string!(query, vm_images::dsl::name, value);
-    }
-    if let Some(value) = r#where.get("kind") {
-      gen_where4string!(query, vm_images::dsl::kind, value);
-    }
-    if let Some(value) = r#where.get("parent") {
-      gen_where4string!(query, vm_images::dsl::parent, value);
-    }
-    if let Some(value) = r#where.get("format") {
-      gen_where4string!(query, vm_images::dsl::format, value);
-    }
-    if let Some(value) = r#where.get("path") {
-      gen_where4string!(query, vm_images::dsl::path, value);
-    }
-    let limit = filter.limit.unwrap_or(100);
-    query = query.limit(limit as i64);
-    if let Some(offset) = filter.offset {
-      query = query.offset(offset as i64);
-    }
-    let pool = Arc::clone(pool);
-    ntex::rt::spawn_blocking(move || {
-      let mut conn = utils::store::get_pool_conn(&pool)?;
-      let items = query
-        .get_results::<Self>(&mut conn)
-        .map_err(Self::map_err_context)?;
-      Ok::<_, IoError>(items)
-    })
-  }
-}
-
-impl VmImageDb {
-  pub(crate) async fn find_by_parent(
-    name: &str,
-    pool: &Pool,
-  ) -> IoResult<Vec<VmImageDb>> {
-    let filter = GenericFilter::new()
-      .r#where("parent", GenericClause::Eq(name.to_owned()));
-    VmImageDb::find(&filter, pool).await?
-  }
-}

bin/nanocld/src/repositories/mod.rs

@@ -5,5 +5,6 @@ mod process;
 mod namespace;
 mod resource_kind;
 mod resource_spec;
+mod vm_image;
 
 pub mod generic;

bin/nanocld/src/repositories/vm_image.rs

@@ -0,0 +1,68 @@
+use diesel::prelude::*;
+
+use nanocl_error::io::IoResult;
+
+use nanocl_stubs::generic::{GenericFilter, GenericClause};
+
+use crate::{
+  gen_where4string,
+  models::{Pool, VmImageDb, VmImageUpdateDb},
+  schema::vm_images,
+};
+
+use super::generic::*;
+
+impl RepositoryBase for VmImageDb {}
+
+impl RepositoryCreate for VmImageDb {}
+
+impl RepositoryUpdate for VmImageDb {
+  type UpdateItem = VmImageUpdateDb;
+}
+
+impl RepositoryDelByPk for VmImageDb {}
+
+impl RepositoryRead for VmImageDb {
+  type Output = VmImageDb;
+  type Query = vm_images::BoxedQuery<'static, diesel::pg::Pg>;
+
+  fn gen_read_query(filter: &GenericFilter, is_multiple: bool) -> Self::Query {
+    let r#where = filter.r#where.to_owned().unwrap_or_default();
+    let mut query = vm_images::dsl::vm_images.into_boxed();
+    if let Some(value) = r#where.get("name") {
+      gen_where4string!(query, vm_images::dsl::name, value);
+    }
+    if let Some(value) = r#where.get("kind") {
+      gen_where4string!(query, vm_images::dsl::kind, value);
+    }
+    if let Some(value) = r#where.get("parent") {
+      gen_where4string!(query, vm_images::dsl::parent, value);
+    }
+    if let Some(value) = r#where.get("format") {
+      gen_where4string!(query, vm_images::dsl::format, value);
+    }
+    if let Some(value) = r#where.get("path") {
+      gen_where4string!(query, vm_images::dsl::path, value);
+    }
+    if is_multiple {
+      query = query.order(vm_images::dsl::created_at.desc());
+      let limit = filter.limit.unwrap_or(100);
+      query = query.limit(limit as i64);
+      if let Some(offset) = filter.offset {
+        query = query.offset(offset as i64);
+      }
+    }
+    query
+  }
+}
+
+impl VmImageDb {
+  pub(crate) async fn find_by_parent(
+    name: &str,
+    pool: &Pool,
+  ) -> IoResult<Vec<VmImageDb>> {
+    let filter = GenericFilter::new()
+      .r#where("parent", GenericClause::Eq(name.to_owned()));
+    VmImageDb::read(&filter, pool).await?
+  }
+}

bin/nanocld/src/services/vm_image.rs

@@ -12,7 +12,8 @@
 
 use crate::{
   utils,
-  models::{DaemonState, VmImageDb, Repository},
+  repositories::generic::*,
+  models::{DaemonState, VmImageDb},
 };
 
 /// List virtual machine images
@@ -34,7 +35,7 @@
 ) -> HttpResult<web::HttpResponse> {
   let filter = GenericFilter::try_from(query.into_inner())
     .map_err(|err| HttpError::bad_request(err.to_string()))?;
-  let images = VmImageDb::find(&filter, &state.pool).await??;
+  let images = VmImageDb::read(&filter, &state.pool).await??;
   Ok(web::HttpResponse::Ok().json(&images))
 }
 
@@ -59,10 +60,8 @@
 ) -> HttpResult<web::HttpResponse> {
   let name = path.1.to_owned();
   utils::key::validate_name(&name)?;
-  if VmImageDb::find_by_pk(&name, &state.pool).await?.is_ok() {
-    return Err(HttpError::bad_request(format!(
-      "Vm image {name} already used"
-    )));
+  if VmImageDb::read_by_pk(&name, &state.pool).await?.is_ok() {
+    return Err(HttpError::conflict(format!("Vm image {name} already used")));
   }
   let state_dir = state.config.state_dir.clone();
   let vm_images_dir = format!("{state_dir}/vms/images");
@@ -115,7 +114,7 @@
   let name = path.1.to_owned();
   let snapshot_name = path.2.to_owned();
   utils::key::validate_name(&snapshot_name)?;
-  let image = VmImageDb::find_by_pk(&name, &state.pool).await??;
+  let image = VmImageDb::read_by_pk(&name, &state.pool).await??;
   let vm_image =
     utils::vm_image::create_snap(&snapshot_name, 50, &image, &state).await?;
   Ok(web::HttpResponse::Ok().json(&vm_image))
@@ -143,7 +142,7 @@
   let name = path.1.to_owned();
   let clone_name = path.2.to_owned();
   utils::key::validate_name(&clone_name)?;
-  let image = VmImageDb::find_by_pk(&name, &state.pool).await??;
+  let image = VmImageDb::read_by_pk(&name, &state.pool).await??;
   let rx = utils::vm_image::clone(&clone_name, &image, &state).await?;
   Ok(web::HttpResponse::Ok().streaming(rx))
 }
@@ -191,7 +190,7 @@
   path: web::types::Path<(String, String)>,
 ) -> HttpResult<web::HttpResponse> {
   let name = path.1.to_owned();
-  let item = VmImageDb::find_by_pk(&name, &state.pool).await??;
+  let item = VmImageDb::read_by_pk(&name, &state.pool).await??;
   Ok(web::HttpResponse::Ok().json(&item))
 }
 

bin/nanocld/src/utils/system.rs

@@ -17,8 +17,7 @@
   utils, version,
   repositories::generic::*,
   models::{
-    DaemonState, ProcessUpdateDb, CargoDb, ProcessDb, Repository, NamespaceDb,
-    VmImageDb,
+    DaemonState, CargoDb, ProcessDb, NamespaceDb, VmImageDb, ProcessUpdateDb,
   },
 };
 
@@ -227,7 +226,7 @@
     };
     let file_path = file.path();
     let path = file_path.to_str().unwrap_or_default();
-    if VmImageDb::find_by_pk(&name, &state.pool).await.is_ok() {
+    if VmImageDb::read_by_pk(&name, &state.pool).await.is_ok() {
       continue;
     }
     if let Err(error) = utils::vm_image::create(&name, path, &state.pool).await