feat(jans-cedarling): add loading policy store to Cedarling

Signed-off-by: Oleh Bohzok <olehbozhok@gmail.com>

jans-cedarling/cedarling/src/authz/mod.rs

@@ -12,7 +12,8 @@
 use crate::log::{LogWriter, Logger};
 use crate::models::authz_config::AuthzConfig;
 use crate::models::log_entry::{LogEntry, LogType};
-use uuid7::{uuid4, Uuid};
+use crate::models::policy_store::PolicyStore;
+use uuid7::Uuid;
 
 /// Authorization Service
 /// The primary service of the Cedarling application responsible for evaluating authorization requests.
@@ -22,13 +23,12 @@ pub struct Authz {
     log_service: Logger,
     pdp_id: Uuid,
     application_name: String,
+    policy_store: PolicyStore,
 }
 
 impl Authz {
     /// Create a new Authorization Service
-    pub fn new(config: AuthzConfig, log: Logger) -> Self {
-        // we use uuid v4 because it is generated based on random numbers.
-        let pdp_id = uuid4();
+    pub fn new(config: AuthzConfig, pdp_id: Uuid, log: Logger, policy_store: PolicyStore) -> Self {
         let application_name = config.application_name;
 
         log.log(
@@ -40,6 +40,7 @@ impl Authz {
             log_service: log,
             pdp_id,
             application_name,
+            policy_store,
         }
     }
 }

jans-cedarling/cedarling/src/init/policy_store.rs

@@ -3,7 +3,7 @@ use crate::models::policy_store_config::{PolicyStoreConfig, PolicyStoreSource};
 
 /// Error cases for loading policy
 #[derive(Debug, thiserror::Error)]
-pub enum ErrorLoadPolicy {
+pub enum ErrorLoadPolicyStore {
     #[error("{0}")]
     JsonParce(#[from] serde_json::Error),
     #[error("store policy is empty")]
@@ -17,22 +17,24 @@ pub enum ErrorLoadPolicy {
 /// Load policy store based on config
 //
 // Unit tests will be added when will be implemented other types of sources
-pub(crate) fn load_policy_store(config: PolicyStoreConfig) -> Result<PolicyStore, ErrorLoadPolicy> {
+pub(crate) fn load_policy_store(
+    config: PolicyStoreConfig,
+) -> Result<PolicyStore, ErrorLoadPolicyStore> {
     let mut policy_store_map: PolicyStoreMap = match config.source {
         PolicyStoreSource::Json(json_raw) => serde_json::from_str(json_raw.as_str())?,
     };
 
     if policy_store_map.policy_stores.is_empty() {
-        return Err(ErrorLoadPolicy::PolicyEmpty);
+        return Err(ErrorLoadPolicyStore::PolicyEmpty);
     }
 
     let policy: PolicyStore = match (config.store_id, policy_store_map.policy_stores.len()) {
         (Some(store_id), _) => policy_store_map
             .policy_stores
             .remove(store_id.as_str())
-            .ok_or(ErrorLoadPolicy::FindPolicy(store_id))?,
+            .ok_or(ErrorLoadPolicyStore::FindPolicy(store_id))?,
         (None, 0) => {
-            return Err(ErrorLoadPolicy::PolicyEmpty);
+            return Err(ErrorLoadPolicyStore::PolicyEmpty);
         },
         (None, 1) => {
             // getting first element and we know it is save to use unwrap here,
@@ -45,7 +47,7 @@ pub(crate) fn load_policy_store(config: PolicyStoreConfig) -> Result<PolicyStore
                 .unwrap()
         },
         (None, 2..) => {
-            return Err(ErrorLoadPolicy::MoreThanOnePolicy);
+            return Err(ErrorLoadPolicyStore::MoreThanOnePolicy);
         },
     };
 

jans-cedarling/cedarling/src/lib.rs

@@ -27,9 +27,20 @@ mod tests;
 use std::rc::Rc;
 
 use authz::Authz;
-use log::init_logger;
+use init::policy_store::{load_policy_store, ErrorLoadPolicyStore};
 pub use log::LogStorage;
+use log::{init_logger, LogWriter};
 pub use models::config::*;
+use models::log_entry::{LogEntry, LogType};
+use uuid7::uuid4;
+
+/// Errors that can occur during initialization Cedarling.
+#[derive(Debug, thiserror::Error)]
+pub enum ErrorInitCedarling {
+    /// Error that may occur during loading the policy store.
+    #[error("Could not load policy :{0}")]
+    PolicyStore(#[from] ErrorLoadPolicyStore),
+}
 
 /// The instance of the Cedarling application.
 #[derive(Clone)]
@@ -41,14 +52,32 @@ pub struct Cedarling {
 
 impl Cedarling {
     /// Create a new instance of the Cedarling application.
-    pub fn new(config: BootstrapConfig) -> Cedarling {
-        let log = init_logger(config.log_config);
-        let authz = Authz::new(config.authz_config, log.clone());
+    pub fn new(config: BootstrapConfig) -> Result<Cedarling, ErrorInitCedarling> {
+        let log: Rc<log::LogStrategy> = init_logger(config.log_config);
+        // we use uuid v4 because it is generated based on random numbers.
+        let pdp_id = uuid4();
+        let application_id = config.authz_config.application_name.clone();
+
+        let policy_store = load_policy_store(config.policy_store_config)
+            .inspect(|_| {
+                log.log(
+                    LogEntry::new_with_data(pdp_id, application_id.clone(), LogType::System)
+                        .set_message("PolicyStore loaded successfully".to_string()),
+                );
+            })
+            .inspect_err(|err| {
+                log.log(
+                    LogEntry::new_with_data(pdp_id, application_id, LogType::System)
+                        .set_message(format!("Could not load PolicyStore: {}", err.to_string())),
+                )
+            })?;
+
+        let authz = Authz::new(config.authz_config, pdp_id, log.clone(), policy_store);
 
-        Cedarling {
+        Ok(Cedarling {
             log,
             authz: Rc::new(authz),
-        }
+        })
     }
 }
 

jans-cedarling/cedarling/src/models/bootstrap_config.rs

@@ -7,6 +7,7 @@
 
 use super::authz_config::AuthzConfig;
 use super::log_config::LogConfig;
+use super::policy_store_config::PolicyStoreConfig;
 
 /// Bootstrap configuration
 /// properties for configuration `Cedarling` application.
@@ -16,4 +17,6 @@ pub struct BootstrapConfig {
     pub authz_config: AuthzConfig,
     /// A set of properties used to configure logging in the `Cedarling` application.
     pub log_config: LogConfig,
+    /// A set of properties used to load `PolicyStore` in the `Cedarling` application.
+    pub policy_store_config: PolicyStoreConfig,
 }