refactor: Do not require traits to implement Clone (#488)

Replace `Box<dyn Trait>` with `Arc<dyn Trait>` and remove unnecessary
Clone and Debug requirements from backend and api traits.

Author: gtema

src/application_credential/backend.rs

@@ -16,21 +16,17 @@ pub mod error;
 pub mod sql;
 
 use async_trait::async_trait;
-use dyn_clone::DynClone;
 
 use crate::application_credential::ApplicationCredentialProviderError;
 use crate::application_credential::types::*;
-use crate::config::Config;
 use crate::keystone::ServiceState;
 
 pub use sql::SqlBackend;
 
 /// Application Credential backend driver interface.
+#[cfg_attr(test, mockall::automock)]
 #[async_trait]
-pub trait ApplicationCredentialBackend: DynClone + Send + Sync + std::fmt::Debug {
-    /// Set config
-    fn set_config(&mut self, config: Config);
-
+pub trait ApplicationCredentialBackend: Send + Sync {
     /// Create a new application credential.
     async fn create_application_credential(
         &self,
@@ -52,5 +48,3 @@ pub trait ApplicationCredentialBackend: DynClone + Send + Sync + std::fmt::Debug
         params: &ApplicationCredentialListParameters,
     ) -> Result<Vec<ApplicationCredential>, ApplicationCredentialProviderError>;
 }
-
-dyn_clone::clone_trait_object!(ApplicationCredentialBackend);

src/application_credential/backend/sql.rs

@@ -18,26 +18,17 @@ use super::super::types::*;
 use crate::application_credential::{
     ApplicationCredentialProviderError, backend::ApplicationCredentialBackend,
 };
-use crate::config::Config;
 use crate::keystone::ServiceState;
 
 mod application_credential;
 
 /// SQL backend provider implementing the ApplicationCredentialBackend
 /// interface.
-#[derive(Clone, Debug, Default)]
-pub struct SqlBackend {
-    /// Config.
-    pub config: Config,
-}
+#[derive(Default)]
+pub struct SqlBackend {}
 
 #[async_trait]
 impl ApplicationCredentialBackend for SqlBackend {
-    /// Set config
-    fn set_config(&mut self, config: Config) {
-        self.config = config;
-    }
-
     /// Create a new application credential.
     #[tracing::instrument(level = "debug", skip(self, state))]
     async fn create_application_credential(

src/application_credential/backend/sql/application_credential/get.rs

@@ -81,7 +81,7 @@ mod tests {
                 "app_cred_id",
                 Some(12345),
             )]])
-            .append_query_results([vec![get_role_mock("role_id")]])
+            .append_query_results([vec![get_role_mock("role_id", "foo")]])
             .append_query_results([vec![get_access_rule_mock("app_cred_rule_id", None)]])
             .into_connection();
 

src/application_credential/backend/sql/application_credential/list.rs

@@ -133,7 +133,10 @@ mod tests {
                     role_id: "role_id2".into(),
                 },
             ]])
-            .append_query_results([vec![get_role_mock("role_id1"), get_role_mock("role_id2")]])
+            .append_query_results([vec![
+                get_role_mock("role_id1", "foo"),
+                get_role_mock("role_id2", "foo"),
+            ]])
             .append_query_results([vec![
                 db_application_credential_access_rule::Model {
                     application_credential_id: 1,

src/application_credential/mock.rs

@@ -47,8 +47,4 @@ mock! {
             params: &ApplicationCredentialListParameters,
         ) -> Result<Vec<ApplicationCredential>, ApplicationCredentialProviderError>;
     }
-
-    impl Clone for ApplicationCredentialProvider {
-        fn clone(&self) -> Self;
-    }
 }

src/application_credential/mod.rs

@@ -116,6 +116,7 @@ use async_trait::async_trait;
 use base64::{Engine as _, engine::general_purpose};
 use rand::{Rng, rng};
 use secrecy::SecretString;
+use std::sync::Arc;
 use uuid::Uuid;
 use validator::Validate;
 
@@ -138,31 +139,30 @@ mod mock;
 pub mod types;
 
 /// Application Credential Provider.
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub struct ApplicationCredentialProvider {
-    backend_driver: Box<dyn ApplicationCredentialBackend>,
+    backend_driver: Arc<dyn ApplicationCredentialBackend>,
 }
 
 impl ApplicationCredentialProvider {
     pub fn new(
         config: &Config,
         plugin_manager: &PluginManager,
     ) -> Result<Self, ApplicationCredentialProviderError> {
-        let mut backend_driver = if let Some(driver) = plugin_manager
+        let backend_driver = if let Some(driver) = plugin_manager
             .get_application_credential_backend(config.application_credential.driver.clone())
         {
             driver.clone()
         } else {
             match config.application_credential.driver.as_str() {
-                "sql" => Box::new(SqlBackend::default()),
+                "sql" => Arc::new(SqlBackend::default()),
                 other => {
                     return Err(ApplicationCredentialProviderError::UnsupportedDriver(
                         other.to_string(),
                     ));
                 }
             }
         };
-        backend_driver.set_config(config.clone());
         Ok(Self { backend_driver })
     }
 }

src/application_credential/types.rs

@@ -14,36 +14,8 @@
 //! # Application credential related types
 mod access_rule;
 mod application_credential;
-
-use async_trait::async_trait;
-
-use crate::application_credential::error::ApplicationCredentialProviderError;
-use crate::keystone::ServiceState;
+mod provider_api;
 
 pub use access_rule::*;
 pub use application_credential::*;
-
-/// Application credentials API.
-#[async_trait]
-pub trait ApplicationCredentialApi: Send + Sync + Clone {
-    /// Create a new application credential.
-    async fn create_application_credential(
-        &self,
-        state: &ServiceState,
-        rec: ApplicationCredentialCreate,
-    ) -> Result<ApplicationCredentialCreateResponse, ApplicationCredentialProviderError>;
-
-    /// Get a single application credential by ID.
-    async fn get_application_credential<'a>(
-        &self,
-        state: &ServiceState,
-        id: &'a str,
-    ) -> Result<Option<ApplicationCredential>, ApplicationCredentialProviderError>;
-
-    /// List application credentials.
-    async fn list_application_credentials(
-        &self,
-        state: &ServiceState,
-        params: &ApplicationCredentialListParameters,
-    ) -> Result<impl IntoIterator<Item = ApplicationCredential>, ApplicationCredentialProviderError>;
-}
+pub use provider_api::*;

src/application_credential/types/provider_api.rs

@@ -0,0 +1,44 @@
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-License-Identifier: Apache-2.0
+
+use async_trait::async_trait;
+
+use super::application_credential::*;
+use crate::application_credential::error::ApplicationCredentialProviderError;
+use crate::keystone::ServiceState;
+
+/// Application credentials API.
+#[async_trait]
+pub trait ApplicationCredentialApi: Send + Sync {
+    /// Create a new application credential.
+    async fn create_application_credential(
+        &self,
+        state: &ServiceState,
+        rec: ApplicationCredentialCreate,
+    ) -> Result<ApplicationCredentialCreateResponse, ApplicationCredentialProviderError>;
+
+    /// Get a single application credential by ID.
+    async fn get_application_credential<'a>(
+        &self,
+        state: &ServiceState,
+        id: &'a str,
+    ) -> Result<Option<ApplicationCredential>, ApplicationCredentialProviderError>;
+
+    /// List application credentials.
+    async fn list_application_credentials(
+        &self,
+        state: &ServiceState,
+        params: &ApplicationCredentialListParameters,
+    ) -> Result<impl IntoIterator<Item = ApplicationCredential>, ApplicationCredentialProviderError>;
+}

src/assignment/backend.rs

@@ -16,20 +16,16 @@ pub mod error;
 pub mod sql;
 
 use async_trait::async_trait;
-use dyn_clone::DynClone;
 
 use crate::assignment::AssignmentProviderError;
-use crate::config::Config;
 use crate::keystone::ServiceState;
 
 use crate::assignment::types::{assignment::*, role::*};
 pub use sql::SqlBackend;
 
+#[cfg_attr(test, mockall::automock)]
 #[async_trait]
-pub trait AssignmentBackend: DynClone + Send + Sync + std::fmt::Debug {
-    /// Set config
-    fn set_config(&mut self, config: Config);
-
+pub trait AssignmentBackend: Send + Sync {
     /// Check assignment grant.
     async fn check_grant(
         &self,
@@ -91,5 +87,3 @@ pub trait AssignmentBackend: DynClone + Send + Sync + std::fmt::Debug {
         params: &RoleListParameters,
     ) -> Result<Vec<Role>, AssignmentProviderError>;
 }
-
-dyn_clone::clone_trait_object!(AssignmentBackend);

src/assignment/backend/sql.rs

@@ -18,27 +18,17 @@ use std::collections::HashSet;
 use super::super::types::*;
 use crate::assignment::backend::RoleCreate;
 use crate::assignment::{AssignmentProviderError, backend::AssignmentBackend};
-use crate::config::Config;
 use crate::keystone::ServiceState;
 
 pub(crate) mod assignment;
 pub(crate) mod implied_role;
 pub(crate) mod role;
 
-#[derive(Clone, Debug, Default)]
-pub struct SqlBackend {
-    pub config: Config,
-}
-
-impl SqlBackend {}
+#[derive(Default)]
+pub struct SqlBackend {}
 
 #[async_trait]
 impl AssignmentBackend for SqlBackend {
-    /// Set config.
-    fn set_config(&mut self, config: Config) {
-        self.config = config;
-    }
-
     /// Check assignment grant.
     #[tracing::instrument(level = "info", skip(self, state))]
     async fn check_grant(
@@ -76,7 +66,7 @@ impl AssignmentBackend for SqlBackend {
         state: &ServiceState,
         id: &'a str,
     ) -> Result<Option<Role>, AssignmentProviderError> {
-        Ok(role::get(&self.config, &state.db, id).await?)
+        Ok(role::get(&state.db, id).await?)
     }
 
     /// Expand implied roles.
@@ -118,7 +108,7 @@ impl AssignmentBackend for SqlBackend {
         state: &ServiceState,
         params: &RoleListParameters,
     ) -> Result<Vec<Role>, AssignmentProviderError> {
-        Ok(role::list(&self.config, &state.db, params).await?)
+        Ok(role::list(&state.db, params).await?)
     }
 
     /// List role assignments.
@@ -128,7 +118,7 @@ impl AssignmentBackend for SqlBackend {
         state: &ServiceState,
         params: &RoleAssignmentListParameters,
     ) -> Result<Vec<Assignment>, AssignmentProviderError> {
-        Ok(assignment::list(&self.config, &state.db, params).await?)
+        Ok(assignment::list(&state.db, params).await?)
     }
 
     /// List role assignments for multiple actors/targets.
@@ -138,9 +128,6 @@ impl AssignmentBackend for SqlBackend {
         state: &ServiceState,
         params: &RoleAssignmentListForMultipleActorTargetParameters,
     ) -> Result<Vec<Assignment>, AssignmentProviderError> {
-        Ok(
-            assignment::list_for_multiple_actors_and_targets(&self.config, &state.db, params)
-                .await?,
-        )
+        Ok(assignment::list_for_multiple_actors_and_targets(&state.db, params).await?)
     }
 }