feat: 补充服务查询API接口，支持查询单个服务的详细信息； #274

Author: heqingpan

src/naming/core.rs

@@ -1063,6 +1063,8 @@ pub enum NamingCmd {
     QueryServiceSubscribersPageV2(ServiceQueryParam),
     //查询服务实际信息列表
     QueryServiceInfoPage(ServiceQueryParam),
+    // 只查服务自身信息
+    QueryServiceOnly(ServiceKey),
     //CreateService(ServiceDetailDto),
     UpdateService(ServiceDetailDto),
     UpdateServiceFromCluster(ServiceDetailDto),
@@ -1094,6 +1096,7 @@ pub enum NamingResult {
     ServicePage((usize, Vec<Arc<String>>)),
     ServiceSubscribersPage((usize, Vec<SubscriberInfoDto>)),
     ServiceInfoPage((usize, Vec<ServiceInfoDto>)),
+    ServiceDto(Option<ServiceInfoDto>),
     ClientInstanceCount(Vec<(Arc<String>, usize)>),
     RewriteToCluster(u64, Instance),
     Snapshot(SnapshotForSend),
@@ -1200,6 +1203,9 @@ impl Handler<NamingCmd> for NamingActor {
             NamingCmd::QueryServiceInfoPage(param) => Ok(NamingResult::ServiceInfoPage(
                 self.get_service_info_page(param),
             )),
+            NamingCmd::QueryServiceOnly(service_key) => Ok(NamingResult::ServiceDto(
+                self.get_service(&service_key).map(|s| s.get_service_info()),
+            )),
             NamingCmd::QueryServiceSubscribersPageV2(param) => Ok(
                 NamingResult::ServiceSubscribersPage(self.get_subscribers_list_by_param(param)),
             ),

src/openapi/naming/model.rs

@@ -1,7 +1,7 @@
 #![allow(unused_imports, unused_assignments, unused_variables)]
 use crate::common::option_utils::OptionUtils;
 use crate::naming::model::{Instance, ServiceKey};
-use crate::naming::service::SubscriberInfoDto;
+use crate::naming::service::{ServiceInfoDto, SubscriberInfoDto};
 use crate::naming::NamingUtils;
 use crate::utils::get_bool_from_string;
 use serde::{Deserialize, Serialize};
@@ -358,3 +358,48 @@ pub struct ServiceQuerySubscribersListResponce {
     pub count: usize,
     pub subscribers: Vec<SubscriberInfoDto>,
 }
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct ServiceInfoVo {
+    pub namespace_id: Arc<String>,
+    pub group_name: Arc<String>,
+    pub name: Arc<String>,
+    pub protect_threshold: f32,
+    pub metadata: Option<Arc<HashMap<String, String>>>,
+    pub selector: HashMap<String, String>,
+    pub clusters: Vec<ClusterVo>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct ClusterVo {
+    pub name: String,
+    pub health_checker: HashMap<String, String>,
+    pub metadata: HashMap<String, String>,
+}
+
+impl ServiceInfoVo {
+    /// 从 ServiceInfoDto 创建 ServiceInfoVo，使用默认的命名空间和集群信息
+    pub fn from_dto(dto: ServiceInfoDto, namespace_id: Arc<String>) -> Self {
+        let mut selector = HashMap::new();
+        selector.insert("type".to_owned(), "none".to_string());
+        selector.insert("contextType".to_owned(), "NONE".to_string());
+        let mut health_checker = HashMap::new();
+        health_checker.insert("type".to_owned(), "TCP".to_string());
+
+        Self {
+            namespace_id,
+            group_name: dto.group_name,
+            name: dto.service_name,
+            protect_threshold: dto.protect_threshold.unwrap_or(0.0),
+            metadata: dto.metadata,
+            selector,
+            clusters: vec![ClusterVo {
+                name: "DEFAULT".to_string(),
+                health_checker,
+                metadata: HashMap::new(),
+            }],
+        }
+    }
+}

src/openapi/naming/service.rs

@@ -5,7 +5,8 @@ use crate::naming::model::ServiceKey;
 use crate::naming::NamingUtils;
 use crate::openapi::constant::EMPTY;
 use crate::openapi::naming::model::{
-    ServiceQueryListRequest, ServiceQueryListResponce, ServiceQuerySubscribersListResponce,
+    ServiceInfoVo, ServiceQueryListRequest, ServiceQueryListResponce,
+    ServiceQuerySubscribersListResponce,
 };
 use actix::Addr;
 use actix_web::http::header;
@@ -25,10 +26,46 @@ pub(super) fn service() -> Scope {
 }
 
 pub async fn query_service(
-    _param: web::Query<ServiceQueryListRequest>,
-    _naming_addr: web::Data<Addr<NamingActor>>,
+    param: web::Query<ServiceQueryListRequest>,
+    naming_addr: web::Data<Addr<NamingActor>>,
 ) -> impl Responder {
-    HttpResponse::InternalServerError().body("error,not support at present")
+    if let Some((group, service_name)) =
+        NamingUtils::split_group_and_service_name(&param.0.service_name.clone().unwrap_or_default())
+    {
+        let namespace_id = NamingUtils::default_namespace(
+            param
+                .namespace_id
+                .as_ref()
+                .unwrap_or(&"".to_owned())
+                .to_owned(),
+        );
+        let service_key = ServiceKey::new(&namespace_id, &group, &service_name);
+        match naming_addr
+            .send(NamingCmd::QueryServiceOnly(service_key.clone()))
+            .await
+        {
+            Ok(res) => {
+                let result: NamingResult = res.unwrap();
+                match result {
+                    NamingResult::ServiceDto(service) => {
+                        if let Some(service_dto) = service {
+                            let vo = ServiceInfoVo::from_dto(service_dto, service_key.namespace_id);
+                            HttpResponse::Ok().json(&vo)
+                        } else {
+                            HttpResponse::InternalServerError().body(format!(
+                                "service not found,namespace_id:{},service_name:{}",
+                                &namespace_id, &service_name
+                            ))
+                        }
+                    }
+                    _ => HttpResponse::InternalServerError().body("error"),
+                }
+            }
+            Err(err) => HttpResponse::InternalServerError().body(err.to_string()),
+        }
+    } else {
+        HttpResponse::InternalServerError().body("error,service_name is valid")
+    }
 }
 
 pub async fn update_service(