refactor: FeatureProbe Constructor and Config

Author: SSebo

examples/demo.rs

@@ -1,33 +1,25 @@
-use feature_probe_server_sdk::{FPConfig, FPUser, FeatureProbe};
+use feature_probe_server_sdk::{FPConfigBuilder, FPError, FPUser, FeatureProbe};
 use std::time::Duration;
 
 // Connect to demo docker environment.
 // cargo run --example demo
 
 #[tokio::main]
-async fn main() {
+async fn main() -> Result<(), FPError> {
+    let _ = tracing_subscriber::fmt().init();
     // let remote_url = "http://localhost:4009/server"; // for local docker
     let remote_url = "https://featureprobe.io/server";
     // Server SDK key in Project List Page.
     let server_sdk_key = "server-7fa2f771259cb7235b96433d70b91e99abcf6ff8";
     let interval = Duration::from_millis(2000);
-    let config = FPConfig {
-        remote_url: remote_url.to_owned(),
-        server_sdk_key: server_sdk_key.to_owned(),
-        refresh_interval: interval,
-        #[cfg(feature = "use_tokio")]
-        http_client: None,
-        start_wait: Some(Duration::from_secs(5)),
-        ..Default::default()
-    };
+    let config = FPConfigBuilder::new(remote_url.to_owned(), server_sdk_key.to_owned(), interval)
+        .start_wait(Duration::from_secs(5))
+        .build()?;
 
-    let fp = match FeatureProbe::new(config) {
-        Ok(fp) => fp,
-        Err(e) => {
-            tracing::error!("{:?}", e);
-            return;
-        }
-    };
+    let fp = FeatureProbe::new(config);
+    if !fp.initialized() {
+        println!("FeatureProbe failed to initialize, will return default value");
+    }
 
     let mut user = FPUser::new();
     user = user.with("userId", "00001");
@@ -40,4 +32,5 @@ async fn main() {
     println!("       => rule index  : {:?}", detail.rule_index);
 
     fp.close();
+    Ok(())
 }

src/config.rs

@@ -0,0 +1,121 @@
+use std::time::Duration;
+
+#[cfg(feature = "use_tokio")]
+use reqwest::Client;
+use tracing::info;
+use url::Url;
+
+use crate::FPError;
+
+#[derive(Debug, Default, Clone)]
+pub struct FPConfigBuilder {
+    pub remote_url: String,
+    pub toggles_url: Option<String>,
+    pub events_url: Option<String>,
+    pub server_sdk_key: String,
+    pub refresh_interval: Duration,
+    #[cfg(feature = "use_tokio")]
+    pub http_client: Option<Client>,
+    pub start_wait: Option<Duration>,
+}
+
+#[derive(Debug, Clone)]
+pub struct FPConfig {
+    pub toggles_url: Url,
+    pub events_url: Url,
+    pub server_sdk_key: String,
+    pub refresh_interval: Duration,
+    #[cfg(feature = "use_tokio")]
+    pub http_client: Option<Client>,
+    pub start_wait: Option<Duration>,
+}
+
+impl Default for FPConfig {
+    fn default() -> Self {
+        Self {
+            server_sdk_key: "".to_owned(),
+            toggles_url: Url::parse("http://127.0.0.1:8080").unwrap(),
+            events_url: Url::parse("http://127.0.0.1:8080").unwrap(),
+            refresh_interval: Duration::from_secs(5),
+            start_wait: None,
+            #[cfg(feature = "use_tokio")]
+            http_client: None,
+        }
+    }
+}
+
+impl FPConfigBuilder {
+    pub fn new(
+        remote_url: String,
+        server_sdk_key: String,
+        refresh_interval: Duration,
+    ) -> FPConfigBuilder {
+        Self {
+            remote_url,
+            server_sdk_key,
+            refresh_interval,
+            ..Default::default()
+        }
+    }
+
+    pub fn toggles_url(mut self, toggles_url: String) -> FPConfigBuilder {
+        self.toggles_url = Some(toggles_url);
+        self
+    }
+
+    pub fn events_url(mut self, events_url: String) -> FPConfigBuilder {
+        self.events_url = Some(events_url);
+        self
+    }
+
+    pub fn start_wait(mut self, start_wait: Duration) -> FPConfigBuilder {
+        self.start_wait = Some(start_wait);
+        self
+    }
+
+    #[cfg(feature = "use_tokio")]
+    pub fn http_client(mut self, http_client: Client) -> FPConfigBuilder {
+        self.http_client = Some(http_client);
+        self
+    }
+
+    pub fn build(&self) -> Result<FPConfig, FPError> {
+        info!("build_config from {:?}", self);
+        let remote_url = {
+            if !self.remote_url.ends_with('/') {
+                self.remote_url.clone() + "/"
+            } else {
+                self.remote_url.clone()
+            }
+        };
+        let toggles_url = match &self.toggles_url {
+            None => remote_url.clone() + "api/server-sdk/toggles",
+            Some(url) => url.to_owned(),
+        };
+
+        let toggles_url: Url = match Url::parse(&toggles_url) {
+            Err(e) => return Err(FPError::UrlError(e.to_string())),
+            Ok(url) => url,
+        };
+
+        let events_url = match &self.events_url {
+            None => remote_url + "api/events",
+            Some(url) => url.to_owned(),
+        };
+
+        let events_url: Url = match Url::parse(&events_url) {
+            Err(e) => return Err(FPError::UrlError(e.to_string())),
+            Ok(url) => url,
+        };
+
+        Ok(FPConfig {
+            toggles_url,
+            events_url,
+            server_sdk_key: self.server_sdk_key.clone(),
+            refresh_interval: self.refresh_interval,
+            start_wait: self.start_wait,
+            #[cfg(feature = "use_tokio")]
+            http_client: self.http_client.clone(),
+        })
+    }
+}

src/evalutate.rs

@@ -483,6 +483,7 @@ impl Segment {
 pub struct Repository {
     pub(crate) segments: HashMap<String, Segment>,
     pub(crate) toggles: HashMap<String, Toggle>,
+    pub(crate) version: Option<String>,
 }
 
 fn validate_toggle(_toggle: &Toggle) -> Result<(), FPError> {

src/feature_probe.rs

@@ -3,14 +3,15 @@ use serde_json::Value;
 use std::collections::HashMap;
 use std::fmt::Debug;
 use std::sync::Arc;
-use std::time::Duration;
-use tracing::info;
-use url::Url;
+use tracing::trace;
 
-use crate::evalutate::{EvalDetail, Repository};
 use crate::sync::Synchronizer;
 use crate::user::FPUser;
-use crate::{FPDetail, FPError, SdkAuthorization, Toggle};
+use crate::{
+    config::FPConfig,
+    evalutate::{EvalDetail, Repository},
+};
+use crate::{FPDetail, SdkAuthorization, Toggle};
 #[cfg(feature = "event")]
 use feature_probe_event_std::event::AccessEvent;
 #[cfg(feature = "event")]
@@ -23,31 +24,26 @@ use feature_probe_event_tokio::event::AccessEvent;
 use feature_probe_event_tokio::recorder::unix_timestamp;
 #[cfg(feature = "event_tokio")]
 use feature_probe_event_tokio::recorder::EventRecorder;
-#[cfg(feature = "use_tokio")]
-use reqwest::Client;
 
 #[derive(Debug, Default, Clone)]
 pub struct FeatureProbe {
     repo: Arc<RwLock<Repository>>,
     syncer: Option<Synchronizer>,
     #[cfg(any(feature = "event", feature = "event_tokio"))]
     event_recorder: Option<EventRecorder>,
-    config: InnerConfig,
+    config: FPConfig,
     should_stop: Arc<RwLock<bool>>,
 }
 
 impl FeatureProbe {
-    pub fn new(config: FPConfig) -> Result<Self, FPError> {
-        let config = build_config(config);
+    pub fn new(config: FPConfig) -> Self {
         let mut slf = Self {
             config,
             ..Default::default()
         };
 
-        match slf.start() {
-            Ok(_) => Ok(slf),
-            Err(e) => Err(e),
-        }
+        slf.start();
+        slf
     }
 
     pub fn new_for_test(toggle: &str, value: Value) -> Self {
@@ -106,7 +102,7 @@ impl FeatureProbe {
 
     pub fn new_with(server_key: String, repo: Repository) -> Self {
         Self {
-            config: InnerConfig {
+            config: FPConfig {
                 server_sdk_key: server_key,
                 ..Default::default()
             },
@@ -119,7 +115,7 @@ impl FeatureProbe {
     }
 
     pub fn close(&self) {
-        info!("closing featureprobe client");
+        trace!("closing featureprobe client");
         #[cfg(any(feature = "event", feature = "event_tokio"))]
         if let Some(recorder) = &self.event_recorder {
             recorder.flush();
@@ -195,19 +191,15 @@ impl FeatureProbe {
         None
     }
 
-    fn start(&mut self) -> Result<(), FPError> {
-        self.sync()?;
+    fn start(&mut self) {
+        self.sync();
         #[cfg(any(feature = "event", feature = "event_tokio"))]
-        self.flush_events()?;
-        Ok(())
+        self.flush_events();
     }
 
-    fn sync(&mut self) -> Result<(), FPError> {
-        info!("sync url {}", &self.config.toggles_url);
-        let toggles_url: Url = match Url::parse(&self.config.toggles_url) {
-            Err(e) => return Err(FPError::UrlError(e.to_string())),
-            Ok(url) => url,
-        };
+    fn sync(&mut self) {
+        trace!("sync url {}", &self.config.toggles_url);
+        let toggles_url = self.config.toggles_url.clone();
         let refresh_interval = self.config.refresh_interval;
         let auth = SdkAuthorization(self.config.server_sdk_key.clone()).encode();
         let repo = self.repo.clone();
@@ -220,17 +212,13 @@ impl FeatureProbe {
             repo,
         );
         self.syncer = Some(syncer.clone());
-        syncer.sync(self.config.start_wait, self.should_stop.clone())?;
-        Ok(())
+        syncer.sync(self.config.start_wait, self.should_stop.clone());
     }
 
     #[cfg(any(feature = "event", feature = "event_tokio"))]
-    fn flush_events(&mut self) -> Result<(), FPError> {
-        info!("flush_events");
-        let events_url: Url = match Url::parse(&self.config.events_url) {
-            Err(e) => return Err(FPError::UrlError(e.to_string())),
-            Ok(url) => url,
-        };
+    fn flush_events(&mut self) {
+        trace!("flush_events");
+        let events_url = self.config.events_url.clone();
         let flush_interval = self.config.refresh_interval;
         let auth = SdkAuthorization(self.config.server_sdk_key.clone()).encode();
         let should_stop = self.should_stop.clone();
@@ -243,7 +231,6 @@ impl FeatureProbe {
             should_stop,
         );
         self.event_recorder = Some(event_recorder);
-        Ok(())
     }
 
     #[cfg(feature = "internal")]
@@ -252,52 +239,6 @@ impl FeatureProbe {
     }
 }
 
-#[derive(Debug, Default, Clone)]
-pub struct FPConfig {
-    pub remote_url: String,
-    pub toggles_url: Option<String>,
-    pub events_url: Option<String>,
-    pub server_sdk_key: String,
-    pub refresh_interval: Duration,
-    #[cfg(feature = "use_tokio")]
-    pub http_client: Option<Client>,
-    pub start_wait: Option<Duration>,
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct InnerConfig {
-    pub toggles_url: String,
-    pub events_url: String,
-    pub server_sdk_key: String,
-    pub refresh_interval: Duration,
-    #[cfg(feature = "use_tokio")]
-    pub http_client: Option<Client>,
-    pub start_wait: Option<Duration>,
-}
-
-fn build_config(mut config: FPConfig) -> InnerConfig {
-    info!("build_config from {:?}", config);
-    if !config.remote_url.ends_with('/') {
-        config.remote_url += "/";
-    }
-    if config.toggles_url.is_none() {
-        config.toggles_url = Some(config.remote_url.clone() + "api/server-sdk/toggles")
-    }
-    if config.events_url.is_none() {
-        config.events_url = Some(config.remote_url + "api/events")
-    }
-
-    InnerConfig {
-        toggles_url: config.toggles_url.expect("not none"),
-        events_url: config.events_url.expect("not none"),
-        server_sdk_key: config.server_sdk_key,
-        refresh_interval: config.refresh_interval,
-        start_wait: config.start_wait,
-        #[cfg(feature = "use_tokio")]
-        http_client: config.http_client,
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use serde_json::json;

src/lib.rs

@@ -1,10 +1,12 @@
+mod config;
 mod evalutate;
 mod feature_probe;
 mod sync;
 mod user;
 
+pub use crate::config::{FPConfig, FPConfigBuilder};
 pub use crate::evalutate::{load_json, Repository, Segment, Toggle};
-pub use crate::feature_probe::{FPConfig, FeatureProbe};
+pub use crate::feature_probe::FeatureProbe;
 pub use crate::user::FPUser;
 use headers::{Error, Header, HeaderName, HeaderValue};
 use http::header::AUTHORIZATION;