refactor(service/tikv): Add TikvConfig to implement ConfigDeserializer

core/src/services/mod.rs

@@ -220,6 +220,8 @@ pub use self::redb::Redb;
 mod tikv;
 #[cfg(feature = "services-tikv")]
 pub use self::tikv::Tikv;
+#[cfg(feature = "services-tikv")]
+pub use self::tikv::TikvConfig;
 
 #[cfg(feature = "services-foundationdb")]
 mod foundationdb;

core/src/services/tikv/backend.rs

@@ -20,69 +20,101 @@ use std::fmt::Debug;
 use std::fmt::Formatter;
 
 use async_trait::async_trait;
+use serde::Deserialize;
 use tikv_client::Config;
 use tikv_client::RawClient;
 use tokio::sync::OnceCell;
 
 use crate::raw::adapters::kv;
+use crate::raw::*;
 use crate::Builder;
 use crate::Capability;
 use crate::Error;
 use crate::ErrorKind;
 use crate::Scheme;
 use crate::*;
 
-/// TiKV backend builder
-#[doc = include_str!("docs.md")]
-#[derive(Clone, Default)]
-pub struct TikvBuilder {
+/// Config for Tikv services support.
+#[derive(Default, Deserialize, Clone)]
+#[serde(default)]
+#[non_exhaustive]
+pub struct TikvConfig {
     /// network address of the TiKV service.
-    endpoints: Option<Vec<String>>,
+    pub endpoints: Option<Vec<String>>,
     /// whether using insecure connection to TiKV
-    insecure: bool,
+    pub insecure: bool,
     /// certificate authority file path
-    ca_path: Option<String>,
+    pub ca_path: Option<String>,
     /// cert path
-    cert_path: Option<String>,
+    pub cert_path: Option<String>,
     /// key path
-    key_path: Option<String>,
+    pub key_path: Option<String>,
+}
+
+impl Debug for TikvConfig {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let mut d = f.debug_struct("TikvConfig");
+
+        d.field("endpoints", &self.endpoints)
+            .field("insecure", &self.insecure)
+            .field("ca_path", &self.ca_path)
+            .field("cert_path", &self.cert_path)
+            .field("key_path", &self.key_path)
+            .finish()
+    }
+}
+
+/// TiKV backend builder
+#[doc = include_str!("docs.md")]
+#[derive(Clone, Default)]
+pub struct TikvBuilder {
+    config: TikvConfig,
+}
+
+impl Debug for TikvBuilder {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let mut d = f.debug_struct("TikvBuilder");
+
+        d.field("config", &self.config);
+        d.finish_non_exhaustive()
+    }
 }
 
 impl TikvBuilder {
     /// Set the network address of the TiKV service.
     pub fn endpoints(&mut self, endpoints: Vec<String>) -> &mut Self {
         if !endpoints.is_empty() {
-            self.endpoints = Some(endpoints)
+            self.config.endpoints = Some(endpoints)
         }
         self
     }
 
     /// Set the insecure connection to TiKV.
     pub fn insecure(&mut self) -> &mut Self {
-        self.insecure = true;
+        self.config.insecure = true;
         self
     }
 
     /// Set the certificate authority file path.
     pub fn ca_path(&mut self, ca_path: &str) -> &mut Self {
         if !ca_path.is_empty() {
-            self.ca_path = Some(ca_path.to_string())
+            self.config.ca_path = Some(ca_path.to_string())
         }
         self
     }
 
     /// Set the certificate file path.
     pub fn cert_path(&mut self, cert_path: &str) -> &mut Self {
         if !cert_path.is_empty() {
-            self.cert_path = Some(cert_path.to_string())
+            self.config.cert_path = Some(cert_path.to_string())
         }
         self
     }
 
     /// Set the key file path.
     pub fn key_path(&mut self, key_path: &str) -> &mut Self {
         if !key_path.is_empty() {
-            self.key_path = Some(key_path.to_string())
+            self.config.key_path = Some(key_path.to_string())
         }
         self
     }
@@ -93,32 +125,25 @@ impl Builder for TikvBuilder {
     type Accessor = Backend;
 
     fn from_map(map: HashMap<String, String>) -> Self {
-        let mut builder = TikvBuilder::default();
-
-        map.get("endpoints")
-            .map(|v| v.split(',').map(|s| s.to_owned()).collect::<Vec<String>>())
-            .map(|v| builder.endpoints(v));
-        map.get("insecure")
-            .filter(|v| *v == "on" || *v == "true")
-            .map(|_| builder.insecure());
-        map.get("ca_path").map(|v| builder.ca_path(v));
-        map.get("cert_path").map(|v| builder.cert_path(v));
-        map.get("key_path").map(|v| builder.key_path(v));
-
-        builder
+        let config = TikvConfig::deserialize(ConfigDeserializer::new(map))
+            .expect("config deserialize must succeed");
+
+        TikvBuilder { config }
     }
 
     fn build(&mut self) -> Result<Self::Accessor> {
-        let endpoints = self.endpoints.take().ok_or_else(|| {
+        let endpoints = self.config.endpoints.take().ok_or_else(|| {
             Error::new(
                 ErrorKind::ConfigInvalid,
                 "endpoints is required but not set",
             )
             .with_context("service", Scheme::Tikv)
         })?;
 
-        if self.insecure
-            && (self.ca_path.is_some() || self.key_path.is_some() || self.cert_path.is_some())
+        if self.config.insecure
+            && (self.config.ca_path.is_some()
+                || self.config.key_path.is_some()
+                || self.config.cert_path.is_some())
         {
             return Err(
                 Error::new(ErrorKind::ConfigInvalid, "invalid tls configuration")
@@ -130,10 +155,10 @@ impl Builder for TikvBuilder {
         Ok(Backend::new(Adapter {
             client: OnceCell::new(),
             endpoints,
-            insecure: self.insecure,
-            ca_path: self.ca_path.clone(),
-            cert_path: self.cert_path.clone(),
-            key_path: self.key_path.clone(),
+            insecure: self.config.insecure,
+            ca_path: self.config.ca_path.clone(),
+            cert_path: self.config.cert_path.clone(),
+            key_path: self.config.key_path.clone(),
         }))
     }
 }
@@ -154,6 +179,7 @@ pub struct Adapter {
 impl Debug for Adapter {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let mut ds = f.debug_struct("Adapter");
+
         ds.field("endpoints", &self.endpoints);
         ds.finish()
     }

core/src/services/tikv/mod.rs

@@ -18,3 +18,4 @@
 mod backend;
 
 pub use backend::TikvBuilder as Tikv;
+pub use backend::TikvConfig;