refactor: FPConfig

Author: SSebo

examples/demo.rs

@@ -1,5 +1,6 @@
-use feature_probe_server_sdk::{FPConfigBuilder, FPError, FPUser, FeatureProbe};
+use feature_probe_server_sdk::{FPConfig, FPError, FPUser, FeatureProbe};
 use std::time::Duration;
+use url::Url;
 
 // Connect to demo docker environment.
 // cargo run --example demo
@@ -8,13 +9,18 @@ use std::time::Duration;
 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";
+    let remote_url = Url::parse("https://featureprobe.io/server").expect("invalid url");
     // Server SDK key in Project List Page.
-    let server_sdk_key = "server-7fa2f771259cb7235b96433d70b91e99abcf6ff8";
-    let interval = Duration::from_millis(2000);
-    let config = FPConfigBuilder::new(remote_url.to_owned(), server_sdk_key.to_owned(), interval)
-        .start_wait(Duration::from_secs(5))
-        .build()?;
+    let server_sdk_key = "server-7fa2f771259cb7235b96433d70b91e99abcf6ff8".to_owned();
+    let refresh_interval = Duration::from_millis(2000);
+
+    let config = FPConfig {
+        remote_url,
+        server_sdk_key,
+        refresh_interval,
+        start_wait: Some(Duration::from_secs(5)),
+        ..Default::default()
+    };
 
     let fp = FeatureProbe::new(config);
     if !fp.initialized() {

src/config.rs

@@ -5,13 +5,11 @@ 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>,
+#[derive(Debug, Clone)]
+pub struct FPConfig {
+    pub remote_url: Url,
+    pub toggles_url: Option<Url>,
+    pub events_url: Option<Url>,
     pub server_sdk_key: String,
     pub refresh_interval: Duration,
     #[cfg(feature = "use_tokio")]
@@ -20,7 +18,7 @@ pub struct FPConfigBuilder {
 }
 
 #[derive(Debug, Clone)]
-pub struct FPConfig {
+pub(crate) struct Config {
     pub toggles_url: Url,
     pub events_url: Url,
     pub server_sdk_key: String,
@@ -34,8 +32,9 @@ 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(),
+            remote_url: Url::parse("http://127.0.0.1:8080").unwrap(),
+            toggles_url: None,
+            events_url: None,
             refresh_interval: Duration::from_secs(5),
             start_wait: None,
             #[cfg(feature = "use_tokio")]
@@ -44,78 +43,49 @@ impl Default for FPConfig {
     }
 }
 
-impl FPConfigBuilder {
-    pub fn new(
-        remote_url: String,
-        server_sdk_key: String,
-        refresh_interval: Duration,
-    ) -> FPConfigBuilder {
+impl Default for Config {
+    fn default() -> Self {
         Self {
-            remote_url,
-            server_sdk_key,
-            refresh_interval,
-            ..Default::default()
+            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,
         }
     }
+}
 
-    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> {
+impl FPConfig {
+    pub(crate) fn build(&self) -> Config {
         info!("build_config from {:?}", self);
-        let remote_url = {
-            if !self.remote_url.ends_with('/') {
-                self.remote_url.clone() + "/"
-            } else {
-                self.remote_url.clone()
-            }
+        let remote_url = self.remote_url.to_string();
+        let remote_url = match remote_url.ends_with('/') {
+            true => remote_url,
+            false => remote_url + "/",
         };
+
         let toggles_url = match &self.toggles_url {
-            None => remote_url.clone() + "api/server-sdk/toggles",
+            None => {
+                Url::parse(&(remote_url.clone() + "api/server-sdk/toggles")).expect("invalid url")
+            }
             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",
+            None => Url::parse(&(remote_url + "api/events")).expect("invalid url"),
             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 {
+        Config {
             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/feature_probe.rs

@@ -5,12 +5,12 @@ use std::fmt::Debug;
 use std::sync::Arc;
 use tracing::trace;
 
-use crate::sync::Synchronizer;
 use crate::user::FPUser;
 use crate::{
-    config::FPConfig,
+    config::Config,
     evalutate::{EvalDetail, Repository},
 };
+use crate::{sync::Synchronizer, FPConfig};
 use crate::{FPDetail, SdkAuthorization, Toggle};
 #[cfg(feature = "event")]
 use feature_probe_event_std::event::AccessEvent;
@@ -31,12 +31,13 @@ pub struct FeatureProbe {
     syncer: Option<Synchronizer>,
     #[cfg(any(feature = "event", feature = "event_tokio"))]
     event_recorder: Option<EventRecorder>,
-    config: FPConfig,
+    config: Config,
     should_stop: Arc<RwLock<bool>>,
 }
 
 impl FeatureProbe {
     pub fn new(config: FPConfig) -> Self {
+        let config = config.build();
         let mut slf = Self {
             config,
             ..Default::default()
@@ -102,7 +103,7 @@ impl FeatureProbe {
 
     pub fn new_with(server_key: String, repo: Repository) -> Self {
         Self {
-            config: FPConfig {
+            config: Config {
                 server_sdk_key: server_key,
                 ..Default::default()
             },

src/lib.rs

@@ -4,7 +4,7 @@ mod feature_probe;
 mod sync;
 mod user;
 
-pub use crate::config::{FPConfig, FPConfigBuilder};
+pub use crate::config::FPConfig;
 pub use crate::evalutate::{load_json, Repository, Segment, Toggle};
 pub use crate::feature_probe::FeatureProbe;
 pub use crate::user::FPUser;

tests/integration_test.rs

@@ -5,7 +5,7 @@ use feature_probe_server::{
     repo::SdkRepository,
     ServerConfig,
 };
-use feature_probe_server_sdk::{FPConfigBuilder, FPUser, FeatureProbe, Url};
+use feature_probe_server_sdk::{FPConfig, FPUser, FeatureProbe, Url};
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn integration_test() {
@@ -15,15 +15,13 @@ async fn integration_test() {
     let server_port = 19990;
     setup_server(api_port, server_port).await;
 
-    let config = FPConfigBuilder::new(
-        format!("http://127.0.0.1:{}", server_port),
-        "server-sdk-key1".to_owned(),
-        Duration::from_secs(5),
-    )
-    .start_wait(Duration::from_secs(5))
-    .build();
-    assert!(config.is_ok());
-    let config = config.unwrap();
+    let config = FPConfig {
+        remote_url: Url::parse(&format!("http://127.0.0.1:{}", server_port)).unwrap(),
+        server_sdk_key: "server-sdk-key1".to_owned(),
+        refresh_interval: Duration::from_secs(5),
+        start_wait: Some(Duration::from_secs(5)),
+        ..Default::default()
+    };
 
     let fp = FeatureProbe::new(config);