rnacos 0.8.3

Nacos server re-implemented in Rust.
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

use crate::common::appdata::AppShareData;
use crate::common::option_utils::OptionUtils;
use crate::common::string_utils::StringUtils;
use crate::console::model::{ConsoleResult, NamespaceInfo};
use crate::console::NamespaceUtils;
use crate::merge_web_param;
use actix_web::{web, HttpResponse, Responder};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use uuid::Uuid;

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
#[serde(rename_all = "camelCase")]
pub struct NamespaceVO {
    pub namespace: Option<Arc<String>>,
    pub namespace_show_name: Option<String>,
    pub namespace_desc: Option<String>,
    pub quota: u32,
    pub config_count: u32,
    pub r#type: u32,
}

impl From<NamespaceInfo> for NamespaceVO {
    fn from(value: NamespaceInfo) -> Self {
        Self {
            namespace: value.namespace_id,
            namespace_show_name: value.namespace_name,
            namespace_desc: None,
            quota: 200,
            config_count: 0,
            r#type: value
                .r#type
                .unwrap_or("2".to_string())
                .parse()
                .unwrap_or_default(),
        }
    }
}

///
/// 命名空间接口参数
/// 这里参数字段需要与nacos对应接口完全兼容
///
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
#[serde(rename_all = "camelCase")]
pub struct NamespaceParam {
    /// custom_namespace_id,创建时的id
    pub custom_namespace_id: Option<Arc<String>>,
    /// namespace,更新时的id
    pub namespace: Option<Arc<String>>,
    /// namespace_id,删除时的id
    pub namespace_id: Option<Arc<String>>,
    /// namespace_name,创建时的名称
    pub namespace_name: Option<String>,
    /// namespace_show_name,更新时的名称
    pub namespace_show_name: Option<String>,
    pub namespace_desc: Option<String>,
}

impl NamespaceParam {
    pub fn merge(self, other: Self) -> Self {
        Self {
            custom_namespace_id: OptionUtils::select(
                self.custom_namespace_id,
                other.custom_namespace_id,
            ),
            namespace: OptionUtils::select(self.namespace, other.namespace),
            namespace_id: OptionUtils::select(self.namespace_id, other.namespace_id),
            namespace_name: OptionUtils::select(self.namespace_name, other.namespace_name),
            namespace_show_name: OptionUtils::select(
                self.namespace_show_name,
                other.namespace_show_name,
            ),
            namespace_desc: OptionUtils::select(self.namespace_desc, other.namespace_desc),
        }
    }
}

impl From<NamespaceParam> for NamespaceInfo {
    fn from(value: NamespaceParam) -> Self {
        Self {
            namespace_id: OptionUtils::select(
                OptionUtils::select(value.custom_namespace_id, value.namespace),
                value.namespace_id,
            ),
            namespace_name: OptionUtils::select(value.namespace_show_name, value.namespace_name),
            r#type: None,
        }
    }
}

pub async fn query_namespace_list(app_data: web::Data<Arc<AppShareData>>) -> impl Responder {
    let namespaces = if let Ok(namespaces) = NamespaceUtils::get_namespaces(&app_data).await {
        namespaces
    } else {
        return HttpResponse::InternalServerError().body("system error");
    };
    let list: Vec<NamespaceVO> = namespaces.iter().map(|e| e.clone().into()).collect();
    let result = ConsoleResult::success(list);
    HttpResponse::Ok().json(result)
}

pub async fn add_namespace(
    web::Query(param): web::Query<NamespaceParam>,
    payload: web::Payload,
    app_data: web::Data<Arc<AppShareData>>,
) -> impl Responder {
    let param = merge_web_param!(param, payload);
    let mut param: NamespaceInfo = param.into();
    if StringUtils::is_option_empty_arc(&param.namespace_id) {
        param.namespace_id = Some(Arc::new(Uuid::new_v4().to_string()));
    }
    match NamespaceUtils::add_namespace(&app_data, param).await {
        Ok(_) => HttpResponse::Ok()
            .content_type("text/html; charset=utf-8")
            .body("true"),
        Err(e) => HttpResponse::InternalServerError()
            .content_type("text/html; charset=utf-8")
            .body(e.to_string()),
    }
}

pub async fn update_namespace(
    web::Query(param): web::Query<NamespaceParam>,
    payload: web::Payload,
    app_data: web::Data<Arc<AppShareData>>,
) -> impl Responder {
    let param = merge_web_param!(param, payload);
    match NamespaceUtils::update_namespace(&app_data, param.into()).await {
        Ok(_) => HttpResponse::Ok()
            .content_type("text/html; charset=utf-8")
            .body("true"),
        Err(e) => HttpResponse::InternalServerError()
            .content_type("text/html; charset=utf-8")
            .body(e.to_string()),
    }
}

pub async fn remove_namespace(
    web::Query(param): web::Query<NamespaceParam>,
    payload: web::Payload,
    app_data: web::Data<Arc<AppShareData>>,
) -> impl Responder {
    let param = merge_web_param!(param, payload);
    match NamespaceUtils::remove_namespace(&app_data, param.namespace_id).await {
        Ok(_) => HttpResponse::Ok()
            .content_type("text/html; charset=utf-8")
            .body("true"),
        Err(e) => HttpResponse::InternalServerError()
            .content_type("text/html; charset=utf-8")
            .body(e.to_string()),
    }
}