Feature/service custom settings (#13)

* feat: support for services custom definitions

- Adding support for services to use the definitions file for custom
  settings.

* chore: update repo ignore rules

* refactor: remove duplicated code

* chore: update repo README file

Author: rsfreitas

.gitignore

@@ -20,3 +20,6 @@ Cargo.lock
 /Cargo.lock
 .stfolder
 
+# misc files
+.DS_Store
+

README.md

@@ -134,7 +134,6 @@ using service definitions.
 * Enable features and services to use the same env system that the core uses.
 * Improve unit tests.
 * Full compatibility between go and rust gRPC services.
-* Allow using the service definitions file for custom service definitions.
 
 ## License
 

resources/test/definitions/service.toml.ok_custom_settings

@@ -0,0 +1,9 @@
+name = "my-service"
+types = ["grpc"]
+version = "v1.0.0"
+language = "rust"
+product = "incredible-product"
+
+[service]
+direction = "forward"
+ipc_port = 9991

src/definition/mod.rs

@@ -6,7 +6,6 @@ use std::collections::HashMap;
 use std::fmt::{Display, Formatter};
 use std::sync::Arc;
 use std::str::FromStr;
-
 use serde::de::DeserializeOwned;
 use validator::{ValidateArgs};
 
@@ -28,6 +27,7 @@ pub struct Definitions {
     features: Option<HashMap<String, serde_json::Value>>,
     services: Option<HashMap<String, serde_json::Value>>,
     clients: Option<HashMap<String, Client>>,
+    service: Option<serde_json::Value>,
 
     #[serde(deserialize_with = "service::deserialize_services")]
     pub types: Vec<service::Service>,
@@ -138,14 +138,7 @@ impl Definitions {
     where
         T: DeserializeOwned,
     {
-        if let Some(d) = self.feature(feature) {
-            return match serde_json::from_value::<T>(d.clone()) {
-                Err(e) => Err(merrors::Error::DefinitionLoadingFailure(feature.to_string(), e.to_string())),
-                Ok(defs) => Ok(Some(defs)),
-            }
-        }
-
-        Ok(None)
+        self.decode(self.feature(feature), feature)
     }
 
     fn feature(&self, feature: &str) -> Option<serde_json::Value> {
@@ -159,14 +152,7 @@ impl Definitions {
     where
         T: DeserializeOwned,
     {
-        if let Some(d) = self.service(&service_kind) {
-            return match serde_json::from_value::<T>(d.clone()) {
-                Err(e) => Err(merrors::Error::DefinitionLoadingFailure(service_kind.to_string(), e.to_string())),
-                Ok(defs) => Ok(Some(defs)),
-            }
-        }
-
-        Ok(None)
+        self.decode(self.service(&service_kind), &service_kind.to_string())
     }
 
     fn service(&self, service_kind: &ServiceKind) -> Option<serde_json::Value> {
@@ -176,9 +162,36 @@ impl Definitions {
         }
     }
 
+    fn decode<T>(&self, data: Option<serde_json::Value>, name: &str) -> merrors::Result<Option<T>>
+    where
+        T: DeserializeOwned,
+    {
+        if let Some(d) = data {
+            return match serde_json::from_value::<T>(d.clone()) {
+                Ok(defs) => Ok(Some(defs)),
+                Err(e) => Err(merrors::Error::DefinitionLoadingFailure(name.to_string(), e.to_string())),
+            }
+        }
+
+        Ok(None)
+    }
+
     pub fn client(&self, name: &str) -> Option<Client> {
         self.clients.clone()?.get(name).cloned()
     }
+
+    pub fn custom_settings<T>(&self) -> merrors::Result<Option<T>>
+    where
+        T: DeserializeOwned,
+    {
+        match &self.service {
+            None => Ok(None),
+            Some(settings) => match serde_json::from_value::<T>(settings.clone()) {
+                Err(e) => Err(merrors::Error::DefinitionLoadingFailure("custom_settings".to_string(), e.to_string())),
+                Ok(settings) => Ok(Some(settings)),
+            }
+        }
+    }
 }
 
 #[cfg(test)]
@@ -326,4 +339,26 @@ mod tests {
         assert_eq!(address.clone().unwrap().host, "127.0.0.1");
         assert_eq!(address.unwrap().port, 7071);
     }
+
+    #[test]
+    fn test_load_service_custom_settings() {
+        let filename = assets_path().join("definitions/service.toml.ok_custom_settings");
+        let defs = Definitions::new(filename.to_str(), None);
+        assert!(defs.is_ok());
+
+        let defs = defs.unwrap();
+
+        #[derive(Deserialize)]
+        struct Service {
+            direction: String,
+            ipc_port: i32,
+        }
+
+        let s: merrors::Result<Option<Service>> = defs.custom_settings();
+        assert!(s.is_ok());
+
+        let settings = s.unwrap().unwrap();
+        assert_eq!(settings.direction, "forward");
+        assert_eq!(settings.ipc_port, 9991);
+    }
 }