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

#![allow(unused_imports)]

use std::sync::Arc;

use actix::prelude::Addr;
use async_trait::async_trait;

use crate::grpc::HandlerResult;
use crate::{
    common::appdata::AppShareData,
    grpc::{
        api_model::{ServiceListRequest, ServiceListResponse, ERROR_CODE, SUCCESS_CODE},
        nacos_proto::Payload,
        PayloadHandler, PayloadUtils,
    },
    naming::{
        core::{NamingActor, NamingCmd, NamingResult},
        model::ServiceKey,
        NamingUtils,
    },
};

use super::converter::ModelConverter;

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

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

#[async_trait]
impl PayloadHandler for ServiceListRequestHandler {
    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: ServiceListRequest = serde_json::from_slice(&body_vec)?;
        let mut response = ServiceListResponse {
            request_id: request.request_id,
            message: Some("".to_string()),
            ..Default::default()
        };
        let namespace = NamingUtils::default_namespace(
            request
                .namespace
                .as_ref()
                .unwrap_or(&"".to_owned())
                .to_owned(),
        );
        let key = ServiceKey::new(
            &namespace,
            &request.group_name.unwrap_or_default(),
            &request.service_name.unwrap_or_default(),
        );
        let cmd =
            NamingCmd::QueryServicePage(key, request.page_size as usize, request.page_no as usize);
        match self.app_data.naming_addr.send(cmd).await {
            Ok(res) => {
                let result: NamingResult = res.unwrap();
                match result {
                    NamingResult::ServicePage((count, service_names)) => {
                        response.count = count;
                        response.service_names = Some(service_names);
                        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(
            "ServiceListResponse",
            serde_json::to_string(&response)?,
        )))
    }
}