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

#![allow(unused_imports)]

use std::sync::Arc;

use crate::common::model::client_version::ClientNameType;
use crate::config::config_type::ConfigType;
use crate::config::ConfigUtils;
use crate::grpc::api_model::NOT_FOUND;
use crate::grpc::HandlerResult;
use crate::{
    common::appdata::AppShareData,
    config::core::{ConfigActor, ConfigCmd, ConfigKey, ConfigResult},
    grpc::{
        api_model::{
            BaseResponse, ConfigPublishRequest, ConfigQueryRequest, ConfigQueryResponse,
            ERROR_CODE, SUCCESS_CODE,
        },
        nacos_proto::Payload,
        PayloadHandler, PayloadUtils,
    },
};
use actix::prelude::Addr;
use async_trait::async_trait;

pub struct ConfigQueryRequestHandler {
    app_data: Arc<AppShareData>,
}

impl ConfigQueryRequestHandler {
    pub fn new(app_data: Arc<AppShareData>) -> Self {
        Self { app_data }
    }
}

#[async_trait]
impl PayloadHandler for ConfigQueryRequestHandler {
    async fn handle(
        &self,
        request_payload: crate::grpc::nacos_proto::Payload,
        request_meta: crate::grpc::RequestMeta,
    ) -> anyhow::Result<HandlerResult> {
        let body_vec = request_payload.body.unwrap_or_default().value;
        let request: ConfigQueryRequest = serde_json::from_slice(&body_vec)?;
        let cmd = ConfigCmd::GET(ConfigKey::new(
            &request.data_id,
            &request.group,
            &ConfigUtils::default_tenant(request.tenant),
        ));
        let mut response = ConfigQueryResponse {
            request_id: request.request_id,
            ..Default::default()
        };
        if request_meta.client_version.client.is_python_sdk() {
            response.message = Some("".to_string());
            response.tag = Some("false".to_string());
            response.encrypted_data_key = Some("".to_string());
            response.beta = false;
        }
        match self.app_data.config_addr.send(cmd).await {
            Ok(res) => {
                //let res:ConfigResult = res.unwrap();
                let r: ConfigResult = res.unwrap();
                match r {
                    ConfigResult::Data {
                        value: content,
                        md5,
                        config_type,
                        last_modified,
                        ..
                    } => {
                        //v.to_owned()
                        response.result_code = SUCCESS_CODE;
                        response.content = content;
                        response.content_type =
                            Some(config_type.unwrap_or(ConfigType::Text.get_value()));
                        //response.encrypted_data_key = Some("".to_owned());
                        //java nacos中定义tag类型是String;
                        //nacos-sdk-go中定义tag类型为bool, nacos-sdk-go中直接设置 response.tag = request.tag会报错
                        if let Some(tag) = request.tag {
                            if !tag.is_empty() {
                                response.tag = Some(tag);
                            }
                        }
                        if request_meta.client_version.client.is_go_sdk() {
                            response.tag = None;
                        }
                        response.last_modified = last_modified;
                        response.md5 = Some(md5);
                    }
                    _ => {
                        response.result_code = ERROR_CODE;
                        response.error_code = NOT_FOUND;
                        response.message = Some("config data not exist".to_owned());
                    }
                }
                Ok(HandlerResult::success(PayloadUtils::build_payload(
                    "ConfigQueryResponse",
                    serde_json::to_string(&response)?,
                )))
            }
            Err(err) => {
                response.result_code = ERROR_CODE;
                response.error_code = ERROR_CODE;
                response.message = Some(err.to_string());
                Ok(HandlerResult::success(PayloadUtils::build_payload(
                    "ErrorResponse",
                    serde_json::to_string(&response)?,
                )))
            }
        }
    }
}