conreg-client 0.2.0

Conreg is a distributed configuration and registration center similar to Nacos, and conreg client is conreg's client SDK
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

/// Configuration component
use crate::utils;
use derive_builder::Builder;
use serde::Deserialize;
use serde_yaml::Value;
use std::collections::HashMap;

/// Overall configuration for config/registry center
/// Wrapped because the top-level key in bootstrap.yaml is conreg
#[derive(Debug, Clone, Deserialize)]
pub(crate) struct ConRegConfigWrapper {
    pub(crate) conreg: ConRegConfig,
}

/// Config/Registry Center Configuration
#[derive(Debug, Clone, Deserialize, Builder)]
#[serde(rename_all = "kebab-case")]
pub struct ConRegConfig {
    /// Service ID
    #[allow(unused)]
    #[serde(default = "ConRegConfig::default_service_id")]
    #[builder(setter(into), default = "ConRegConfig::default_service_id()")]
    pub service_id: String,
    /// Client configuration
    #[builder(default = "ClientConfig::default()")]
    pub client: ClientConfig,
    /// Configuration center configuration
    #[serde(default)]
    #[builder(setter(strip_option), default)]
    pub config: Option<ConfigConfig>,
    /// Registry center configuration
    #[serde(default)]
    #[builder(setter(strip_option), default)]
    pub discovery: Option<DiscoveryConfig>,
}

impl Default for ConRegConfig {
    fn default() -> Self {
        ConRegConfig {
            client: ClientConfig::default(),
            service_id: utils::current_process_name(),
            config: None,
            discovery: None,
        }
    }
}

impl ConRegConfig {
    fn default_service_id() -> String {
        utils::current_process_name()
    }
}

#[derive(Debug, Default, Deserialize, Clone)]
#[serde(untagged)]
pub enum ServerAddr {
    Single(String),
    Cluster(Vec<String>),
    #[default]
    Unset,
}

impl From<&str> for ServerAddr {
    fn from(value: &str) -> Self {
        ServerAddr::Single(value.to_string())
    }
}
impl From<Vec<&str>> for ServerAddr {
    fn from(value: Vec<&str>) -> Self {
        ServerAddr::Cluster(value.into_iter().map(|s| s.to_string()).collect())
    }
}
impl From<Vec<String>> for ServerAddr {
    fn from(value: Vec<String>) -> Self {
        ServerAddr::Cluster(value)
    }
}

#[derive(Debug, Deserialize, Clone, Builder)]
pub struct ClientConfig {
    #[builder(setter(into), default = "ClientConfig::default_address()")]
    pub address: String,
    pub port: u16,
}
impl Default for ClientConfig {
    fn default() -> Self {
        ClientConfig {
            address: ClientConfig::default_address(),
            port: 8080,
        }
    }
}

impl ClientConfig {
    pub fn gen_instance_id(&self) -> String {
        let digest = md5::compute(format!("{}:{}", self.address, self.port));
        format!("{:x}", digest)
    }
    pub fn default_address() -> String {
        "127.0.0.1".to_string()
    }
}

#[derive(Debug, Clone, Deserialize, Default, Builder)]
#[serde(rename_all = "kebab-case")]
pub struct ConfigConfig {
    /// Configuration center address
    #[builder(setter(into))]
    pub server_addr: ServerAddr,
    /// Namespace, default: public
    #[serde(default = "ConfigConfig::default_namespace")]
    #[builder(setter(into), default = "ConfigConfig::default_namespace()")]
    pub namespace: String,
    /// Configuration IDs, e.g.: `["application.yaml"]`
    #[serde(default)]
    pub config_ids: Vec<String>,
    /// Namespace authentication token
    #[builder(setter(into), default = "Default::default()")]
    pub auth_token: Option<String>,
}

impl ConfigConfig {
    /// Default namespace
    fn default_namespace() -> String {
        "public".to_string()
    }
}

#[derive(Debug, Clone, Deserialize, Default, Builder)]
#[serde(rename_all = "kebab-case")]
pub struct DiscoveryConfig {
    /// Configuration center address, e.g.: 127.0.0.1:8000
    #[builder(setter(into))]
    pub server_addr: ServerAddr,
    /// Namespace, default: public
    #[serde(default = "DiscoveryConfig::default_namespace")]
    #[builder(setter(into), default = "DiscoveryConfig::default_namespace()")]
    pub namespace: String,
    /// Metadata
    #[serde(default = "HashMap::default")]
    #[builder(setter(into), default = "HashMap::default()")]
    pub meta: HashMap<String, Value>,
    /// Namespace authentication token
    #[builder(setter(into), default = "Default::default()")]
    pub auth_token: Option<String>,
}

impl DiscoveryConfig {
    /// Default namespace
    fn default_namespace() -> String {
        "public".to_string()
    }
}