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
154
155
156
157
158
159
160
161
162
163
164
165

use std::collections::HashMap;

pub mod err;
pub mod service_dto;
pub mod service_vo;

/// Dto接口 请求参数结构体实现该特征
pub trait Dto {
    /// 该方法用于将 dto中的属性装填入map中 也就是定义名称与值映射
    fn mapping(&self, map: &mut HashMap<String, String>);
}

pub(crate) fn catch_mapping<T: Dto>(map: &mut HashMap<String, String>, option: &Option<T>) {
    if let Some(s) = option { s.mapping(map); }
}

#[derive(Clone)]
pub struct NacosConfig {
    scheme: String,
    nacos_ip: String,
    nacos_port: u32,
}

impl Default for NacosConfig {
    fn default() -> Self {
        Self {
            scheme: "http".to_string(),
            nacos_ip: "127.0.0.1".to_string(),
            nacos_port: 8848,
        }
    }
}

impl NacosConfig {
    pub fn new(scheme: &str, nacos_ip: &str, nacos_port: u32) -> Self {
        Self {
            scheme: scheme.to_string(),
            nacos_ip: nacos_ip.to_string(),
            nacos_port,
        }
    }

    pub fn exchange(&mut self, ex: Self) -> Self {
        let prev = self.clone();
        self.scheme = ex.scheme;
        self.nacos_ip = ex.nacos_ip;
        self.nacos_port = ex.nacos_port;
        prev
    }

    pub fn addr(&self, target: &str) -> String {
        let sub_path = if target.starts_with('/')
        { target.to_string() } else { format!("/{}", target) };
        format!(
            "{}://{}:{}/nacos{}",
            self.scheme, self.nacos_ip, self.nacos_port, sub_path
        )
    }
}

#[derive(Default, Debug, Clone)]
pub struct ServerConfig {
    server_ip: String,
    server_port: u16,
    server_name: String,
    ephemeral: bool,
    group_name: Option<String>,
}

impl ServerConfig {
    pub fn set_server_ip(&mut self, server_ip: String) {
        self.server_ip = server_ip;
    }
    pub fn set_server_port(&mut self, server_port: u16) {
        self.server_port = server_port;
    }
    pub fn set_server_name(&mut self, server_name: String) {
        self.server_name = server_name;
    }
    pub fn set_ephemeral(&mut self, ephemeral: bool) {
        self.ephemeral = ephemeral;
    }
    pub fn set_group_name(&mut self, group_name: Option<String>) {
        self.group_name = group_name;
    }
}

impl ServerConfig {
    pub fn server_ip(&self) -> &str { &self.server_ip }
    pub fn server_port(&self) -> u16 {
        self.server_port
    }
    pub fn server_name(&self) -> &str {
        &self.server_name
    }
    pub fn ephemeral(&self) -> bool {
        self.ephemeral
    }
    pub fn group_name(&self) -> &Option<String> {
        &self.group_name
    }
}

impl ServerConfig {
    pub fn new(server_ip: &str, server_port: u16, server_name: &str) -> Self {
        Self {
            server_ip: server_ip.to_string(),
            server_port,
            server_name: server_name.to_string(),
            ephemeral: false,
            group_name: None,
        }
    }

    pub(crate) fn init_map(&self) -> HashMap<String, String> {
        let mut map = HashMap::<String, String>::new();
        map.insert("ip".to_string(), self.server_ip().to_string());
        map.insert("port".to_string(), self.server_port().to_string());
        map.insert("serviceName".to_string(), self.server_name().to_string());
        if self.ephemeral {
            map.insert("ephemeral".to_string(), true.to_string());
        }
        if let Some(s) = &self.group_name {
            map.insert("groupName".to_string(), s.to_string());
        }
        map
    }
}

#[derive(Default, Debug, Clone)]
pub struct DeployConfig {
    data_id: String,
    group: String,
    tenant: Option<String>,
}

impl DeployConfig {
    pub fn new(data_id: &str, group: &str, tenant: Option<String>) -> Self {
        Self {
            data_id: data_id.to_string(),
            group: group.to_string(),
            tenant,
        }
    }

    pub fn init_map(&self) -> HashMap<String, String> {
        let mut map = HashMap::<String, String>::new();
        map.insert("dataId".to_string(), self.data_id.clone());
        map.insert("group".to_string(), self.group.clone());
        if let Some(tenant) = &self.tenant {
            map.insert("tenant".to_string(), tenant.clone());
        };
        map
    }

    pub fn data_id(&self) -> &str {
        &self.data_id
    }
    pub fn group(&self) -> &str {
        &self.group
    }
    pub fn tenant(&self) -> &Option<String> {
        &self.tenant
    }
}