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

#![allow(unused_imports)]

use std::sync::Arc;

use crate::grpc::HandlerResult;
use crate::{
    common::appdata::AppShareData,
    grpc::{
        api_model::{
            Instance as ApiInstance, ServiceInfo as ApiServiceInfo, ServiceQueryRequest,
            ServiceQueryResponse, ERROR_CODE, SUCCESS_CODE,
        },
        nacos_proto::Payload,
        PayloadHandler, PayloadUtils,
    },
    naming::{
        core::{NamingActor, NamingCmd, NamingResult},
        model::{Instance, ServiceInfo, ServiceKey},
        NamingUtils,
    },
    now_millis_i64,
};
use actix::prelude::Addr;
use async_trait::async_trait;

use super::converter::ModelConverter;

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

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

    fn convert_to_service_info(&self, info: ServiceInfo) -> ApiServiceInfo {
        ModelConverter::to_api_service_info(info)
    }
}

#[async_trait]
impl PayloadHandler for ServiceQueryRequestHandler {
    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: ServiceQueryRequest = serde_json::from_slice(&body_vec)?;
        let mut response = ServiceQueryResponse {
            request_id: request.request_id,
            ..Default::default()
        };
        let cluster = if let Some(v) = request.cluster.as_ref() {
            v.clone()
        } else {
            "".to_owned()
        };
        let namespace = NamingUtils::default_namespace(
            request
                .namespace
                .as_ref()
                .unwrap_or(&"".to_owned())
                .to_owned(),
        );
        let key = ServiceKey::new(
            &namespace,
            &NamingUtils::default_group(request.group_name.unwrap_or_default()),
            &request.service_name.unwrap_or_default(),
        );
        let cmd = NamingCmd::QueryServiceInfo(key, cluster, true);
        match self.app_data.naming_addr.send(cmd).await {
            Ok(res) => {
                let result: NamingResult = res.unwrap();
                match result {
                    NamingResult::ServiceInfo(service_info) => {
                        let api_service_info = self.convert_to_service_info(service_info);
                        response.service_info = Some(api_service_info);
                        response.result_code = SUCCESS_CODE;
                    }
                    _ => {
                        response.result_code = ERROR_CODE;
                        response.error_code = 500u16;
                        response.message = Some("naming handler result type is error".to_owned());
                    }
                };
            }
            Err(err) => {
                response.result_code = ERROR_CODE;
                response.error_code = 500u16;
                response.message = Some(err.to_string());
                return Ok(HandlerResult::success(PayloadUtils::build_payload(
                    "ErrorResponse",
                    serde_json::to_string(&response)?,
                )));
            }
        };
        Ok(HandlerResult::success(PayloadUtils::build_payload(
            "QueryServiceResponse",
            serde_json::to_string(&response)?,
        )))
    }
}