[server] Add config to db pool #1393

agdb_server/src/action.rs

@@ -33,7 +33,6 @@ use crate::action::db_user_add::DbUserAdd;
 use crate::action::db_user_remove::DbUserRemove;
 use crate::action::user_add::UserAdd;
 use crate::action::user_remove::UserRemove;
-use crate::config::Config;
 use crate::db_pool::DbPool;
 use crate::server_db::ServerDb;
 use crate::server_error::ServerResult;
@@ -68,39 +67,33 @@ pub(crate) enum ClusterActionResult {
 }
 
 pub(crate) trait Action: Sized {
-    async fn exec(
-        self,
-        db: ServerDb,
-        db_pool: DbPool,
-        config: &Config,
-    ) -> ServerResult<ClusterActionResult>;
+    async fn exec(self, db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult>;
 }
 
 impl ClusterAction {
     pub(crate) async fn exec(
         self,
         db: ServerDb,
         db_pool: DbPool,
-        config: &Config,
     ) -> ServerResult<ClusterActionResult> {
         match self {
-            ClusterAction::UserAdd(action) => action.exec(db, db_pool, config).await,
-            ClusterAction::ClusterLogin(action) => action.exec(db, db_pool, config).await,
-            ClusterAction::ChangePassword(action) => action.exec(db, db_pool, config).await,
-            ClusterAction::UserRemove(action) => action.exec(db, db_pool, config).await,
-            ClusterAction::DbAdd(action) => action.exec(db, db_pool, config).await,
-            ClusterAction::DbBackup(action) => action.exec(db, db_pool, config).await,
-            ClusterAction::DbClear(action) => action.exec(db, db_pool, config).await,
-            ClusterAction::DbConvert(action) => action.exec(db, db_pool, config).await,
-            ClusterAction::DbCopy(action) => action.exec(db, db_pool, config).await,
-            ClusterAction::DbDelete(action) => action.exec(db, db_pool, config).await,
-            ClusterAction::DbRemove(action) => action.exec(db, db_pool, config).await,
-            ClusterAction::DbExec(action) => action.exec(db, db_pool, config).await,
-            ClusterAction::DbOptimize(action) => action.exec(db, db_pool, config).await,
-            ClusterAction::DbRestore(action) => action.exec(db, db_pool, config).await,
-            ClusterAction::DbRename(action) => action.exec(db, db_pool, config).await,
-            ClusterAction::DbUserAdd(action) => action.exec(db, db_pool, config).await,
-            ClusterAction::DbUserRemove(action) => action.exec(db, db_pool, config).await,
+            ClusterAction::UserAdd(action) => action.exec(db, db_pool).await,
+            ClusterAction::ClusterLogin(action) => action.exec(db, db_pool).await,
+            ClusterAction::ChangePassword(action) => action.exec(db, db_pool).await,
+            ClusterAction::UserRemove(action) => action.exec(db, db_pool).await,
+            ClusterAction::DbAdd(action) => action.exec(db, db_pool).await,
+            ClusterAction::DbBackup(action) => action.exec(db, db_pool).await,
+            ClusterAction::DbClear(action) => action.exec(db, db_pool).await,
+            ClusterAction::DbConvert(action) => action.exec(db, db_pool).await,
+            ClusterAction::DbCopy(action) => action.exec(db, db_pool).await,
+            ClusterAction::DbDelete(action) => action.exec(db, db_pool).await,
+            ClusterAction::DbRemove(action) => action.exec(db, db_pool).await,
+            ClusterAction::DbExec(action) => action.exec(db, db_pool).await,
+            ClusterAction::DbOptimize(action) => action.exec(db, db_pool).await,
+            ClusterAction::DbRestore(action) => action.exec(db, db_pool).await,
+            ClusterAction::DbRename(action) => action.exec(db, db_pool).await,
+            ClusterAction::DbUserAdd(action) => action.exec(db, db_pool).await,
+            ClusterAction::DbUserRemove(action) => action.exec(db, db_pool).await,
         }
     }
 }

agdb_server/src/action/change_password.rs

@@ -2,7 +2,6 @@ use super::DbPool;
 use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
-use crate::action::Config;
 use crate::server_error::ServerResult;
 use agdb::UserValue;
 use serde::Deserialize;
@@ -16,12 +15,7 @@ pub(crate) struct ChangePassword {
 }
 
 impl Action for ChangePassword {
-    async fn exec(
-        self,
-        db: ServerDb,
-        _db_pool: DbPool,
-        _config: &Config,
-    ) -> ServerResult<ClusterActionResult> {
+    async fn exec(self, db: ServerDb, _db_pool: DbPool) -> ServerResult<ClusterActionResult> {
         let mut user = db.user(&self.user).await?;
         user.password = self.new_password;
         user.salt = self.new_salt;

agdb_server/src/action/cluster_login.rs

@@ -2,7 +2,6 @@ use super::DbPool;
 use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
-use crate::action::Config;
 use crate::server_error::ServerResult;
 use agdb::UserValue;
 use serde::Deserialize;
@@ -15,12 +14,7 @@ pub(crate) struct ClusterLogin {
 }
 
 impl Action for ClusterLogin {
-    async fn exec(
-        self,
-        db: ServerDb,
-        _db_pool: DbPool,
-        _config: &Config,
-    ) -> ServerResult<ClusterActionResult> {
+    async fn exec(self, db: ServerDb, _db_pool: DbPool) -> ServerResult<ClusterActionResult> {
         let user_id = db.user_id(&self.user).await?;
         db.save_token(user_id, &self.new_token).await?;
 

agdb_server/src/action/db_add.rs

@@ -2,7 +2,6 @@ use super::DbPool;
 use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
-use crate::action::Config;
 use crate::server_db::Database;
 use crate::server_error::ServerResult;
 use crate::utilities::db_name;
@@ -19,16 +18,11 @@ pub(crate) struct DbAdd {
 }
 
 impl Action for DbAdd {
-    async fn exec(
-        self,
-        db: ServerDb,
-        db_pool: DbPool,
-        config: &Config,
-    ) -> ServerResult<ClusterActionResult> {
+    async fn exec(self, db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult> {
         let name = db_name(&self.owner, &self.db);
 
         let backup = db_pool
-            .add_db(&self.owner, &self.db, &name, self.db_type, config)
+            .add_db(&self.owner, &self.db, &name, self.db_type)
             .await?;
 
         let owner = db.user_id(&self.owner).await?;

agdb_server/src/action/db_backup.rs

@@ -2,7 +2,6 @@ use super::DbPool;
 use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
-use crate::action::Config;
 use crate::server_error::ServerResult;
 use crate::utilities::db_name;
 use agdb::UserValue;
@@ -16,17 +15,12 @@ pub(crate) struct DbBackup {
 }
 
 impl Action for DbBackup {
-    async fn exec(
-        self,
-        db: ServerDb,
-        db_pool: DbPool,
-        config: &Config,
-    ) -> ServerResult<ClusterActionResult> {
+    async fn exec(self, db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult> {
         let owner = db.user_id(&self.owner).await?;
         let name = db_name(&self.owner, &self.db);
         let mut database = db.user_db(owner, &name).await?;
         database.backup = db_pool
-            .backup_db(&self.owner, &self.db, &name, database.db_type, config)
+            .backup_db(&self.owner, &self.db, &name, database.db_type)
             .await?;
         db.save_db(&database).await?;
         Ok(ClusterActionResult::None)

agdb_server/src/action/db_clear.rs

@@ -2,7 +2,6 @@ use super::DbPool;
 use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
-use crate::action::Config;
 use crate::server_error::ServerResult;
 use crate::utilities::db_name;
 use agdb::UserValue;
@@ -18,17 +17,12 @@ pub(crate) struct DbClear {
 }
 
 impl Action for DbClear {
-    async fn exec(
-        self,
-        db: ServerDb,
-        db_pool: DbPool,
-        config: &Config,
-    ) -> ServerResult<ClusterActionResult> {
+    async fn exec(self, db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult> {
         let owner = db.user_id(&self.owner).await?;
         let name = db_name(&self.owner, &self.db);
         let mut database = db.user_db(owner, &name).await?;
         db_pool
-            .clear_db(&self.owner, &self.db, &mut database, config, self.resource)
+            .clear_db(&self.owner, &self.db, &mut database, self.resource)
             .await?;
         db.save_db(&database).await?;
         Ok(ClusterActionResult::None)

agdb_server/src/action/db_convert.rs

@@ -2,7 +2,6 @@ use super::DbPool;
 use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
-use crate::action::Config;
 use crate::server_error::ServerResult;
 use crate::utilities::db_name;
 use agdb::UserValue;
@@ -18,24 +17,12 @@ pub(crate) struct DbConvert {
 }
 
 impl Action for DbConvert {
-    async fn exec(
-        self,
-        db: ServerDb,
-        db_pool: DbPool,
-        config: &Config,
-    ) -> ServerResult<ClusterActionResult> {
+    async fn exec(self, db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult> {
         let owner = db.user_id(&self.owner).await?;
         let name = db_name(&self.owner, &self.db);
         let mut database = db.user_db(owner, &name).await?;
         db_pool
-            .convert_db(
-                &self.owner,
-                &self.db,
-                &name,
-                database.db_type,
-                self.db_type,
-                config,
-            )
+            .convert_db(&self.owner, &self.db, &name, database.db_type, self.db_type)
             .await?;
         database.db_type = self.db_type;
         db.save_db(&database).await?;

agdb_server/src/action/db_copy.rs

@@ -2,7 +2,6 @@ use super::DbPool;
 use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
-use crate::action::Config;
 use crate::server_db::Database;
 use crate::server_error::ServerResult;
 use crate::utilities::db_name;
@@ -21,17 +20,12 @@ pub(crate) struct DbCopy {
 }
 
 impl Action for DbCopy {
-    async fn exec(
-        self,
-        db: ServerDb,
-        db_pool: DbPool,
-        config: &Config,
-    ) -> ServerResult<ClusterActionResult> {
+    async fn exec(self, db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult> {
         let name = db_name(&self.owner, &self.db);
         let target_name = db_name(&self.new_owner, &self.new_db);
         let new_owner_id = db.user_id(&self.new_owner).await?;
         db_pool
-            .copy_db(&name, &self.new_owner, &self.new_db, &target_name, config)
+            .copy_db(&name, &self.new_owner, &self.new_db, &target_name)
             .await?;
         db.insert_db(
             new_owner_id,

agdb_server/src/action/db_delete.rs

@@ -2,7 +2,6 @@ use super::DbPool;
 use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
-use crate::action::Config;
 use crate::server_error::ServerResult;
 use crate::utilities::db_name;
 use agdb::UserValue;
@@ -16,18 +15,11 @@ pub(crate) struct DbDelete {
 }
 
 impl Action for DbDelete {
-    async fn exec(
-        self,
-        db: ServerDb,
-        db_pool: DbPool,
-        config: &Config,
-    ) -> ServerResult<ClusterActionResult> {
+    async fn exec(self, db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult> {
         let name = db_name(&self.owner, &self.db);
         let user_id = db.user_id(&self.owner).await?;
         db.remove_db(user_id, &name).await?;
-        db_pool
-            .delete_db(&self.owner, &self.db, &name, config)
-            .await?;
+        db_pool.delete_db(&self.owner, &self.db, &name).await?;
         Ok(ClusterActionResult::None)
     }
 }

agdb_server/src/action/db_exec.rs

@@ -2,7 +2,6 @@ use super::DbPool;
 use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
-use crate::action::Config;
 use crate::server_error::ServerResult;
 use crate::utilities::db_name;
 use agdb::DbUserValue;
@@ -20,23 +19,11 @@ pub(crate) struct DbExec {
 }
 
 impl Action for DbExec {
-    async fn exec(
-        self,
-        _db: ServerDb,
-        db_pool: DbPool,
-        config: &Config,
-    ) -> ServerResult<ClusterActionResult> {
+    async fn exec(self, _db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult> {
         let name = db_name(&self.owner, &self.db);
         Ok(ClusterActionResult::QueryResults(
             db_pool
-                .exec_mut(
-                    &self.owner,
-                    &self.db,
-                    &name,
-                    &self.user,
-                    self.queries,
-                    config,
-                )
+                .exec_mut(&self.owner, &self.db, &name, &self.user, self.queries)
                 .await?,
         ))
     }

agdb_server/src/action/db_optimize.rs

@@ -2,7 +2,6 @@ use super::DbPool;
 use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
-use crate::action::Config;
 use crate::server_error::ServerResult;
 use crate::utilities::db_name;
 use agdb::UserValue;
@@ -16,12 +15,7 @@ pub(crate) struct DbOptimize {
 }
 
 impl Action for DbOptimize {
-    async fn exec(
-        self,
-        _db: ServerDb,
-        db_pool: DbPool,
-        _config: &Config,
-    ) -> ServerResult<ClusterActionResult> {
+    async fn exec(self, _db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult> {
         let name = db_name(&self.owner, &self.db);
         db_pool.optimize_db(&name).await?;
 

agdb_server/src/action/db_remove.rs

@@ -2,7 +2,6 @@ use super::DbPool;
 use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
-use crate::action::Config;
 use crate::server_error::ServerResult;
 use crate::utilities::db_name;
 use agdb::UserValue;
@@ -16,12 +15,7 @@ pub(crate) struct DbRemove {
 }
 
 impl Action for DbRemove {
-    async fn exec(
-        self,
-        db: ServerDb,
-        db_pool: DbPool,
-        _config: &Config,
-    ) -> ServerResult<ClusterActionResult> {
+    async fn exec(self, db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult> {
         let name = db_name(&self.owner, &self.db);
         let user_id = db.user_id(&self.owner).await?;
         db.remove_db(user_id, &name).await?;

agdb_server/src/action/db_rename.rs

@@ -2,7 +2,6 @@ use super::DbPool;
 use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
-use crate::action::Config;
 use crate::server_error::ServerResult;
 use crate::utilities::db_name;
 use agdb::UserValue;
@@ -19,12 +18,7 @@ pub(crate) struct DbRename {
 }
 
 impl Action for DbRename {
-    async fn exec(
-        self,
-        db: ServerDb,
-        db_pool: DbPool,
-        config: &Config,
-    ) -> ServerResult<ClusterActionResult> {
+    async fn exec(self, db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult> {
         let owner_id = db.user_id(&self.owner).await?;
         let name = db_name(&self.owner, &self.db);
         let new_name = db_name(&self.new_owner, &self.new_db);
@@ -37,7 +31,6 @@ impl Action for DbRename {
                 &self.new_owner,
                 &self.new_db,
                 &new_name,
-                config,
             )
             .await?;
         database.name = new_name;