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

#![allow(unused_imports)]

use actix_web::{http::header, web, HttpMessage, HttpRequest, HttpResponse, Responder};

use actix::prelude::Addr;

use super::model::{
    naming_model::{OpsNamingQueryListResponse, QueryAllInstanceListParam},
    PageResult,
};
use crate::naming::core::{NamingActor, NamingCmd, NamingResult};
use crate::user_namespace_privilege;

pub async fn query_ops_instances_list(
    req: HttpRequest,
    param: web::Query<QueryAllInstanceListParam>,
    naming_addr: web::Data<Addr<NamingActor>>,
) -> impl Responder {
    match param.0.to_service_key() {
        Ok(key) => {
            let namespace_privilege = user_namespace_privilege!(req);
            if !namespace_privilege.check_permission(&key.namespace_id) {
                return HttpResponse::Unauthorized().body(format!(
                    "user no such namespace permission: {}",
                    &key.namespace_id
                ));
            }
            match naming_addr.send(NamingCmd::QueryAllInstanceList(key)).await {
                Ok(res) => match res as anyhow::Result<NamingResult> {
                    Ok(result) => match result {
                        NamingResult::InstanceList(list) => {
                            let resp = OpsNamingQueryListResponse {
                                count: list.len() as u64,
                                list,
                            };
                            let v = serde_json::to_string(&resp).unwrap();
                            HttpResponse::Ok()
                                .insert_header(header::ContentType(mime::APPLICATION_JSON))
                                .body(v)
                        }
                        _ => HttpResponse::InternalServerError().body("error result"),
                    },
                    Err(err) => HttpResponse::InternalServerError().body(err.to_string()),
                },
                Err(err) => HttpResponse::InternalServerError().body(err.to_string()),
            }
        }
        Err(err) => HttpResponse::InternalServerError().body(err.to_string()),
    }
}

pub async fn query_grpc_client_instance_count(
    naming_addr: web::Data<Addr<NamingActor>>,
) -> impl Responder {
    match naming_addr.send(NamingCmd::QueryClientInstanceCount).await {
        Ok(res) => match res as anyhow::Result<NamingResult> {
            Ok(result) => match result {
                NamingResult::ClientInstanceCount(list) => {
                    let resp = PageResult {
                        count: list.len() as u64,
                        list,
                    };
                    let v = serde_json::to_string(&resp).unwrap();
                    HttpResponse::Ok()
                        .insert_header(header::ContentType(mime::APPLICATION_JSON))
                        .body(v)
                }
                _ => HttpResponse::InternalServerError().body("error result"),
            },
            Err(err) => HttpResponse::InternalServerError().body(err.to_string()),
        },
        Err(err) => HttpResponse::InternalServerError().body(err.to_string()),
    }
}