rs-zero 0.2.10

Rust-first microservice framework inspired by go-zero engineering practices
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use serde::Deserialize;

#[cfg(feature = "discovery-etcd")]
use crate::core::CoreResult;

#[cfg(feature = "discovery-etcd")]
use super::rpc::RpcClientProvider;
use super::rpc::RpcClientSection;

/// Serializable etcd discovery configuration.
#[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
#[serde(default, deny_unknown_fields)]
pub struct EtcdDiscoverySection {
    pub endpoints: Vec<String>,
    pub prefix: String,
    pub lease_ttl: i64,
    pub reconnect_interval_ms: u64,
    pub connect_timeout_ms: u64,
    pub operation_timeout_ms: u64,
    pub keep_alive_interval_ms: u64,
    pub keep_alive_timeout_ms: u64,
    pub watch_backoff: EtcdBackoffSection,
    pub auth: Option<EtcdAuthSection>,
}

impl Default for EtcdDiscoverySection {
    fn default() -> Self {
        Self {
            endpoints: vec!["http://127.0.0.1:2379".to_string()],
            prefix: "/rs-zero".to_string(),
            lease_ttl: 30,
            reconnect_interval_ms: 1000,
            connect_timeout_ms: 3000,
            operation_timeout_ms: 3000,
            keep_alive_interval_ms: 5000,
            keep_alive_timeout_ms: 3000,
            watch_backoff: EtcdBackoffSection::default(),
            auth: None,
        }
    }
}

impl EtcdDiscoverySection {
    #[cfg(feature = "discovery-etcd")]
    fn to_etcd_discovery_config(&self) -> crate::discovery_etcd::EtcdDiscoveryConfig {
        crate::discovery_etcd::EtcdDiscoveryConfig {
            endpoints: self.endpoints.clone(),
            prefix: self.prefix.clone(),
            lease_ttl: self.lease_ttl,
            reconnect_interval: std::time::Duration::from_millis(self.reconnect_interval_ms),
            connect_timeout: std::time::Duration::from_millis(self.connect_timeout_ms),
            operation_timeout: std::time::Duration::from_millis(self.operation_timeout_ms),
            keep_alive_interval: std::time::Duration::from_millis(self.keep_alive_interval_ms),
            keep_alive_timeout: std::time::Duration::from_millis(self.keep_alive_timeout_ms),
            watch_backoff: crate::discovery_etcd::BackoffConfig {
                initial: std::time::Duration::from_millis(self.watch_backoff.initial_ms),
                max: std::time::Duration::from_millis(self.watch_backoff.max_ms),
            },
            auth: self
                .auth
                .as_ref()
                .map(|auth| crate::discovery_etcd::EtcdAuthConfig {
                    username: auth.username.clone(),
                    password: auth.password.clone(),
                }),
        }
    }
}

impl RpcClientSection {
    /// Converts nested etcd settings into the runtime etcd discovery config.
    #[cfg(feature = "discovery-etcd")]
    pub fn to_etcd_discovery_config(
        &self,
    ) -> CoreResult<crate::discovery_etcd::EtcdDiscoveryConfig> {
        if self.provider != RpcClientProvider::Etcd {
            return Err(super::config_error(
                "etcd discovery config requires provider = \"etcd\"",
            ));
        }
        Ok(self
            .etcd
            .clone()
            .unwrap_or_default()
            .to_etcd_discovery_config())
    }
}

/// Serializable reconnect backoff configuration.
#[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
#[serde(default, deny_unknown_fields)]
pub struct EtcdBackoffSection {
    pub initial_ms: u64,
    pub max_ms: u64,
}

impl Default for EtcdBackoffSection {
    fn default() -> Self {
        Self {
            initial_ms: 200,
            max_ms: 5000,
        }
    }
}

/// Serializable etcd authentication configuration.
#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Default)]
#[serde(default, deny_unknown_fields)]
pub struct EtcdAuthSection {
    pub username: String,
    pub password: String,
}