refactor: split config into multiple modules

Signed-off-by: Harsh1s <thisishraj@gmail.com>

crates/benchmark/src/runner.rs

@@ -19,7 +19,7 @@ use tokio::{
     time::{Duration, Instant},
 };
 use tracing::debug;
-use utils::config::ClientConfig;
+use utils::config::client_config::ClientConfig;
 use xline_client::{types::kv::PutRequest, ClientOptions};
 
 use crate::{args::Commands, bench_client::BenchClient, Benchmark};

crates/curp-test-utils/src/test_cmd.rs

@@ -18,7 +18,7 @@ use serde::{Deserialize, Serialize};
 use thiserror::Error;
 use tokio::{sync::mpsc, time::sleep};
 use tracing::debug;
-use utils::config::EngineConfig;
+use utils::config::engine_config::EngineConfig;
 
 use crate::{META_TABLE, REVISION_TABLE, TEST_TABLE};
 
@@ -422,7 +422,7 @@ impl TestCE {
         after_sync_sender: mpsc::UnboundedSender<(TestCommand, LogIndex)>,
         engine_cfg: EngineConfig,
     ) -> Self {
-        let engine_type = match engine_cfg {
+        let engine_type: EngineType = match engine_cfg {
             EngineConfig::Memory => EngineType::Memory,
             EngineConfig::RocksDB(path) => EngineType::Rocks(path),
             _ => unreachable!("Not supported storage type"),

crates/curp/src/client/mod.rs

@@ -30,9 +30,9 @@ use tokio::task::JoinHandle;
 #[cfg(not(madsim))]
 use tonic::transport::ClientTlsConfig;
 use tracing::debug;
+use utils::{build_endpoint, config::client_config::ClientConfig};
 #[cfg(madsim)]
 use utils::ClientTlsConfig;
-use utils::{build_endpoint, config::ClientConfig};
 
 use self::{
     retry::{Retry, RetryConfig},

crates/curp/src/server/cmd_worker/mod.rs

@@ -422,7 +422,7 @@ mod tests {
     use test_macros::abort_on_panic;
     use tokio::{sync::mpsc, time::Instant};
     use tracing_test::traced_test;
-    use utils::config::EngineConfig;
+    use utils::config::engine_config::EngineConfig;
 
     use super::*;
     use crate::{log_entry::LogEntry, rpc::ProposeId};

crates/curp/src/server/curp_node.rs

@@ -18,12 +18,9 @@ use tokio::{
 #[cfg(not(madsim))]
 use tonic::transport::ClientTlsConfig;
 use tracing::{debug, error, info, trace, warn};
+use utils::{config::curp_config::CurpConfig, task_manager::{tasks::TaskName, Listener, State, TaskManager}};
 #[cfg(madsim)]
 use utils::ClientTlsConfig;
-use utils::{
-    config::CurpConfig,
-    task_manager::{tasks::TaskName, Listener, State, TaskManager},
-};
 
 use super::{
     cmd_board::{CmdBoardRef, CommandBoard},

crates/curp/src/server/mod.rs

@@ -7,7 +7,7 @@ use tonic::transport::ClientTlsConfig;
 use tracing::instrument;
 #[cfg(madsim)]
 use utils::ClientTlsConfig;
-use utils::{config::CurpConfig, task_manager::TaskManager, tracing::Extract};
+use utils::{config::curp_config::CurpConfig, task_manager::TaskManager, tracing::Extract};
 
 use self::curp_node::CurpNode;
 pub use self::raw_curp::RawCurp;

crates/curp/src/server/raw_curp/log.rs

@@ -455,7 +455,7 @@ mod tests {
     use std::{iter::repeat, ops::Index, sync::Arc};
 
     use curp_test_utils::test_cmd::TestCommand;
-    use utils::config::{default_batch_max_size, default_log_entries_cap};
+    use utils::config::curp_config::{default_batch_max_size, default_log_entries_cap};
 
     use super::*;
 

crates/curp/src/server/raw_curp/mod.rs

@@ -37,7 +37,7 @@ use tracing::{
 #[cfg(madsim)]
 use utils::ClientTlsConfig;
 use utils::{
-    config::CurpConfig,
+    config::curp_config::CurpConfig,
     parking_lot_lock::{MutexMap, RwLockMap},
     task_manager::TaskManager,
 };

crates/curp/src/server/raw_curp/tests.rs

@@ -7,7 +7,7 @@ use tokio::{
     time::{sleep, Instant},
 };
 use tracing_test::traced_test;
-use utils::config::{
+use utils::config::curp_config::{
     default_candidate_timeout_ticks, default_follower_timeout_ticks, default_heartbeat_interval,
     CurpConfigBuilder,
 };

crates/curp/src/server/storage/db.rs

@@ -3,7 +3,7 @@ use std::marker::PhantomData;
 use async_trait::async_trait;
 use engine::{Engine, EngineType, StorageEngine, WriteOperation};
 use prost::Message;
-use utils::config::EngineConfig;
+use utils::config::engine_config::EngineConfig;
 
 use super::{StorageApi, StorageError};
 use crate::{

crates/curp/tests/it/common/curp_group.rs

@@ -39,7 +39,8 @@ use tracing::debug;
 use utils::{
     build_endpoint,
     config::{
-        default_quota, ClientConfig, CurpConfig, CurpConfigBuilder, EngineConfig, StorageConfig,
+        client_config::ClientConfig, curp_config::CurpConfig, curp_config::CurpConfigBuilder,
+        engine_config::EngineConfig, storage_config::default_quota, storage_config::StorageConfig,
     },
     task_manager::{tasks::TaskName, Listener, TaskManager},
 };

crates/curp/tests/it/server.rs

@@ -15,7 +15,7 @@ use curp_test_utils::{
 use madsim::rand::{thread_rng, Rng};
 use test_macros::abort_on_panic;
 use tokio::net::TcpListener;
-use utils::{config::ClientConfig, timestamp};
+use utils::{config::client_config::ClientConfig, timestamp};
 
 use crate::common::curp_group::{
     commandpb::ProposeId, CurpGroup, FetchClusterRequest, ProposeRequest, ProposeResponse,

crates/utils/src/config/auth_config.rs

@@ -0,0 +1,28 @@
+use std::path::PathBuf;
+
+use getset::Getters;
+use serde::Deserialize;
+
+/// Xline auth configuration object
+#[allow(clippy::module_name_repetitions)]
+#[derive(Clone, Debug, Deserialize, PartialEq, Eq, Getters, Default)]
+pub struct AuthConfig {
+    /// The public key file
+    #[getset(get = "pub")]
+    pub auth_public_key: Option<PathBuf>,
+    /// The private key file
+    #[getset(get = "pub")]
+    pub auth_private_key: Option<PathBuf>,
+}
+
+impl AuthConfig {
+    /// Generate a new `AuthConfig` object
+    #[must_use]
+    #[inline]
+    pub fn new(auth_public_key: Option<PathBuf>, auth_private_key: Option<PathBuf>) -> Self {
+        Self {
+            auth_public_key,
+            auth_private_key,
+        }
+    }
+}

crates/utils/src/config/client_config.rs

@@ -0,0 +1,157 @@
+use std::time::Duration;
+
+use getset::Getters;
+use serde::Deserialize;
+
+/// Curp client settings
+#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Eq, Getters)]
+#[allow(clippy::module_name_repetitions)]
+pub struct ClientConfig {
+    /// Curp client wait sync timeout
+    #[getset(get = "pub")]
+    #[serde(
+        with = "duration_format",
+        default = "default_client_wait_synced_timeout"
+    )]
+    wait_synced_timeout: Duration,
+
+    /// Curp client propose request timeout
+    #[getset(get = "pub")]
+    #[serde(with = "duration_format", default = "default_propose_timeout")]
+    propose_timeout: Duration,
+
+    /// Curp client initial retry interval
+    #[getset(get = "pub")]
+    #[serde(with = "duration_format", default = "default_initial_retry_timeout")]
+    initial_retry_timeout: Duration,
+
+    /// Curp client max retry interval
+    #[getset(get = "pub")]
+    #[serde(with = "duration_format", default = "default_max_retry_timeout")]
+    max_retry_timeout: Duration,
+
+    /// Curp client retry interval
+    #[getset(get = "pub")]
+    #[serde(default = "default_retry_count")]
+    retry_count: usize,
+
+    /// Whether to use exponential backoff in retries
+    #[getset(get = "pub")]
+    #[serde(default = "default_fixed_backoff")]
+    fixed_backoff: bool,
+}
+
+impl ClientConfig {
+    /// Create a new client timeout
+    ///
+    /// # Panics
+    ///
+    /// Panics if `initial_retry_timeout` is larger than `max_retry_timeout`
+    #[must_use]
+    #[inline]
+    pub fn new(
+        wait_synced_timeout: Duration,
+        propose_timeout: Duration,
+        initial_retry_timeout: Duration,
+        max_retry_timeout: Duration,
+        retry_count: usize,
+        fixed_backoff: bool,
+    ) -> Self {
+        assert!(
+            initial_retry_timeout <= max_retry_timeout,
+            "`initial_retry_timeout` should less or equal to `max_retry_timeout`"
+        );
+        Self {
+            wait_synced_timeout,
+            propose_timeout,
+            initial_retry_timeout,
+            max_retry_timeout,
+            retry_count,
+            fixed_backoff,
+        }
+    }
+}
+
+impl Default for ClientConfig {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            wait_synced_timeout: default_client_wait_synced_timeout(),
+            propose_timeout: default_propose_timeout(),
+            initial_retry_timeout: default_initial_retry_timeout(),
+            max_retry_timeout: default_max_retry_timeout(),
+            retry_count: default_retry_count(),
+            fixed_backoff: default_fixed_backoff(),
+        }
+    }
+}
+
+/// default client wait synced timeout
+#[must_use]
+#[inline]
+pub const fn default_client_wait_synced_timeout() -> Duration {
+    Duration::from_secs(2)
+}
+
+/// default client propose timeout
+#[must_use]
+#[inline]
+pub const fn default_propose_timeout() -> Duration {
+    Duration::from_secs(1)
+}
+
+/// default initial retry timeout
+#[must_use]
+#[inline]
+pub const fn default_initial_retry_timeout() -> Duration {
+    Duration::from_millis(1500)
+}
+
+/// default max retry timeout
+#[must_use]
+#[inline]
+pub const fn default_max_retry_timeout() -> Duration {
+    Duration::from_millis(10_000)
+}
+
+/// default retry count
+#[cfg(not(madsim))]
+#[must_use]
+#[inline]
+pub const fn default_retry_count() -> usize {
+    3
+}
+
+/// default retry count
+#[cfg(madsim)]
+#[must_use]
+#[inline]
+pub const fn default_retry_count() -> usize {
+    10
+}
+
+/// default use backoff
+#[must_use]
+#[inline]
+pub const fn default_fixed_backoff() -> bool {
+    false
+}
+
+/// `Duration` deserialization formatter
+pub mod duration_format {
+    use std::time::Duration;
+
+    use serde::{self, Deserialize, Deserializer};
+
+    use crate::parse_duration;
+
+    /// deserializes a cluster duration
+    #[allow(single_use_lifetimes)] //  the false positive case blocks us
+    pub(crate) fn deserialize<'de, D>(deserializer: D) -> Result<Duration, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        parse_duration(&s).map_err(serde::de::Error::custom)
+    }
+}