From a549a8544b927ce58e50c4e84f0ef20d37e358aa Mon Sep 17 00:00:00 2001 From: leone Date: Wed, 20 Dec 2023 00:32:06 +0100 Subject: [PATCH] refactor/nanocld: resource kind repository (#732) --- bin/nanocld/src/models/resource_kind.rs | 145 +----------------- bin/nanocld/src/repositories/mod.rs | 1 + bin/nanocld/src/repositories/process.rs | 2 +- bin/nanocld/src/repositories/resource_kind.rs | 117 ++++++++++++++ bin/nanocld/src/utils/resource.rs | 29 ++-- 5 files changed, 136 insertions(+), 158 deletions(-) create mode 100644 bin/nanocld/src/repositories/resource_kind.rs diff --git a/bin/nanocld/src/models/resource_kind.rs b/bin/nanocld/src/models/resource_kind.rs index 632258473..c515161c1 100644 --- a/bin/nanocld/src/models/resource_kind.rs +++ b/bin/nanocld/src/models/resource_kind.rs @@ -1,18 +1,6 @@ -use std::sync::Arc; - use diesel::prelude::*; -use ntex::rt::JoinHandle; - -use nanocl_error::io::{IoError, IoResult}; - -use nanocl_stubs::generic::{GenericFilter, GenericClause}; - -use crate::{ - utils, gen_where4string, - schema::{resource_kinds, resource_kind_versions}, -}; -use super::{Repository, Pool}; +use crate::schema::{resource_kinds, resource_kind_versions}; /// This structure represent the resource kind verion in the database. /// A resource kind version represent the version of a resource kind. @@ -73,86 +61,6 @@ impl From<&ResourceKindPartial> for ResourceKindVersionDb { } } -impl Repository for ResourceKindVersionDb { - type Table = resource_kind_versions::table; - type Item = ResourceKindVersionDb; - type UpdateItem = ResourceKindVersionDb; - - fn find_one( - filter: &GenericFilter, - pool: &Pool, - ) -> JoinHandle> { - log::trace!("ResourceKindVersionDb::find_one: {filter:?}"); - let r#where = filter.r#where.to_owned().unwrap_or_default(); - let mut query = - resource_kind_versions::dsl::resource_kind_versions.into_boxed(); - if let Some(value) = r#where.get("resource_kind_name") { - gen_where4string!( - query, - resource_kind_versions::dsl::resource_kind_name, - value - ); - } - if let Some(value) = r#where.get("version") { - gen_where4string!(query, resource_kind_versions::dsl::version, value); - } - let pool = Arc::clone(pool); - ntex::rt::spawn_blocking(move || { - let mut conn = utils::store::get_pool_conn(&pool)?; - let items = query - .get_result::(&mut conn) - .map_err(Self::map_err_context)?; - Ok::<_, IoError>(items) - }) - } - - fn find( - filter: &GenericFilter, - pool: &Pool, - ) -> JoinHandle>> { - log::trace!("ResourceKindVersionDb::find: {filter:?}"); - let r#where = filter.r#where.to_owned().unwrap_or_default(); - let mut query = - resource_kind_versions::dsl::resource_kind_versions.into_boxed(); - if let Some(value) = r#where.get("resource_kind_name") { - gen_where4string!( - query, - resource_kind_versions::dsl::resource_kind_name, - value - ); - } - if let Some(value) = r#where.get("version") { - gen_where4string!(query, resource_kind_versions::dsl::version, 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::(&mut conn) - .map_err(Self::map_err_context)?; - Ok::<_, IoError>(items) - }) - } -} - -impl ResourceKindVersionDb { - pub(crate) async fn get_version( - name: &str, - version: &str, - pool: &Pool, - ) -> IoResult { - let filter = GenericFilter::new() - .r#where("resource_kind_name", GenericClause::Eq(name.to_owned())) - .r#where("version", GenericClause::Eq(version.to_owned())); - ResourceKindVersionDb::find_one(&filter, pool).await? - } -} - impl From<&ResourceKindPartial> for ResourceKindDb { fn from(p: &ResourceKindPartial) -> Self { ResourceKindDb { @@ -161,54 +69,3 @@ impl From<&ResourceKindPartial> for ResourceKindDb { } } } - -impl Repository for ResourceKindDb { - type Table = resource_kinds::table; - type Item = ResourceKindDb; - type UpdateItem = ResourceKindDb; - - fn find_one( - filter: &GenericFilter, - pool: &Pool, - ) -> JoinHandle> { - log::trace!("ResourceKindDb::find_one: {filter:?}"); - let r#where = filter.r#where.to_owned().unwrap_or_default(); - let mut query = resource_kinds::dsl::resource_kinds.into_boxed(); - if let Some(value) = r#where.get("name") { - gen_where4string!(query, resource_kinds::dsl::name, 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::(&mut conn) - .map_err(Self::map_err_context)?; - Ok::<_, IoError>(item) - }) - } - - fn find( - filter: &GenericFilter, - pool: &Pool, - ) -> JoinHandle>> { - log::trace!("ResourceKindDb::find: {filter:?}"); - let r#where = filter.r#where.to_owned().unwrap_or_default(); - let mut query = resource_kinds::dsl::resource_kinds.into_boxed(); - if let Some(value) = r#where.get("name") { - gen_where4string!(query, resource_kinds::dsl::name, 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::(&mut conn) - .map_err(Self::map_err_context)?; - Ok::<_, IoError>(items) - }) - } -} diff --git a/bin/nanocld/src/repositories/mod.rs b/bin/nanocld/src/repositories/mod.rs index 144000307..4da101e7c 100644 --- a/bin/nanocld/src/repositories/mod.rs +++ b/bin/nanocld/src/repositories/mod.rs @@ -2,5 +2,6 @@ mod node; mod cargo; mod process; mod namespace; +mod resource_kind; pub mod generic; diff --git a/bin/nanocld/src/repositories/process.rs b/bin/nanocld/src/repositories/process.rs index 986e5ee84..464e85f1d 100644 --- a/bin/nanocld/src/repositories/process.rs +++ b/bin/nanocld/src/repositories/process.rs @@ -38,7 +38,7 @@ impl RepositoryDelBy for ProcessDb { Self: diesel::associations::HasTable, { let r#where = filter.r#where.to_owned().unwrap_or_default(); - let mut query = diesel::delete(processes::dsl::processes).into_boxed(); + let mut query = diesel::delete(processes::table).into_boxed(); if let Some(value) = r#where.get("key") { gen_where4string!(query, processes::dsl::key, value); } diff --git a/bin/nanocld/src/repositories/resource_kind.rs b/bin/nanocld/src/repositories/resource_kind.rs new file mode 100644 index 000000000..5aed83507 --- /dev/null +++ b/bin/nanocld/src/repositories/resource_kind.rs @@ -0,0 +1,117 @@ +use diesel::prelude::*; + +use nanocl_error::io::IoResult; + +use nanocl_stubs::generic::{GenericFilter, GenericClause}; + +use crate::{ + gen_where4string, + models::{Pool, ResourceKindDb, ResourceKindVersionDb}, + schema::{resource_kinds, resource_kind_versions}, +}; + +use super::generic::*; + +impl RepositoryBase for ResourceKindDb {} + +impl RepositoryCreate for ResourceKindDb {} + +impl RepositoryDelByPk for ResourceKindDb {} + +impl RepositoryRead for ResourceKindDb { + type Output = ResourceKindDb; + type Query = resource_kinds::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 = resource_kinds::dsl::resource_kinds.into_boxed(); + if let Some(value) = r#where.get("name") { + gen_where4string!(query, resource_kinds::dsl::name, value); + } + if is_multiple { + query = query.order(resource_kinds::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 RepositoryBase for ResourceKindVersionDb {} + +impl RepositoryCreate for ResourceKindVersionDb {} + +impl RepositoryDelByPk for ResourceKindVersionDb {} + +impl RepositoryRead for ResourceKindVersionDb { + type Output = ResourceKindVersionDb; + type Query = resource_kind_versions::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 = + resource_kind_versions::dsl::resource_kind_versions.into_boxed(); + if let Some(value) = r#where.get("resource_kind_name") { + gen_where4string!( + query, + resource_kind_versions::dsl::resource_kind_name, + value + ); + } + if let Some(value) = r#where.get("version") { + gen_where4string!(query, resource_kind_versions::dsl::version, value); + } + if is_multiple { + query = query.order(resource_kind_versions::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 RepositoryDelBy for ResourceKindVersionDb { + fn gen_del_query( + filter: &GenericFilter, + ) -> diesel::query_builder::BoxedDeleteStatement< + 'static, + diesel::pg::Pg, + ::Table, + > + where + Self: diesel::associations::HasTable, + { + let r#where = filter.r#where.to_owned().unwrap_or_default(); + let mut query = diesel::delete(resource_kind_versions::table).into_boxed(); + if let Some(value) = r#where.get("resource_kind_name") { + gen_where4string!( + query, + resource_kind_versions::dsl::resource_kind_name, + value + ); + } + if let Some(value) = r#where.get("version") { + gen_where4string!(query, resource_kind_versions::dsl::version, value); + } + query + } +} + +impl ResourceKindVersionDb { + pub(crate) async fn get_version( + name: &str, + version: &str, + pool: &Pool, + ) -> IoResult { + let filter = GenericFilter::new() + .r#where("resource_kind_name", GenericClause::Eq(name.to_owned())) + .r#where("version", GenericClause::Eq(version.to_owned())); + ResourceKindVersionDb::read_one(&filter, pool).await? + } +} diff --git a/bin/nanocld/src/utils/resource.rs b/bin/nanocld/src/utils/resource.rs index 323b65960..14930f2b0 100644 --- a/bin/nanocld/src/utils/resource.rs +++ b/bin/nanocld/src/utils/resource.rs @@ -7,11 +7,15 @@ use nanocl_error::http::{HttpError, HttpResult}; use nanocl_stubs::{ system::EventAction, resource::{Resource, ResourcePartial}, + generic::{GenericFilter, GenericClause}, }; -use crate::models::{ - Pool, ResourceKindPartial, DaemonState, ResourceKindVersionDb, Repository, - ResourceKindDb, ResourceSpecDb, ResourceDb, +use crate::{ + repositories::generic::*, + models::{ + Pool, ResourceKindPartial, DaemonState, ResourceKindVersionDb, Repository, + ResourceKindDb, ResourceSpecDb, ResourceDb, + }, }; use super::ctrl_client::CtrlClient; @@ -43,13 +47,13 @@ async fn hook_create_resource( if resource_kind.schema.is_none() && resource_kind.url.is_none() { return Err(HttpError::bad_request("Neither schema nor url provided")); } - if ResourceKindDb::find_by_pk(&resource.name, pool) + if ResourceKindDb::read_by_pk(&resource.name, pool) .await? .is_err() { - ResourceKindDb::create(&resource_kind, pool).await??; + ResourceKindDb::create_from(&resource_kind, pool).await??; } - ResourceKindVersionDb::create(&resource_kind, pool).await??; + ResourceKindVersionDb::create_from(&resource_kind, pool).await??; } _ => { let kind = ResourceKindVersionDb::get_version( @@ -156,13 +160,12 @@ pub(crate) async fn delete( log::warn!("{err}"); } if resource.kind.as_str() == "Kind" { - ResourceKindVersionDb::delete_by( - crate::schema::resource_kind_versions::dsl::resource_kind_name - .eq(resource.spec.resource_key.to_owned()), - &state.pool, - ) - .await??; - ResourceKindDb::delete_by_pk(&resource.spec.resource_key, &state.pool) + let filter = GenericFilter::new().r#where( + "resource_kind_name", + GenericClause::Eq(resource.spec.resource_key.to_owned()), + ); + ResourceKindVersionDb::del_by(&filter, &state.pool).await??; + ResourceKindDb::del_by_pk(&resource.spec.resource_key, &state.pool) .await??; } ResourceDb::delete_by_pk(&resource.spec.resource_key, &state.pool).await??;