add server_info cpus net_info api

Signed-off-by: mujunxiang <1948535941@qq.com>

rustfs/Cargo.toml

@@ -9,6 +9,7 @@ rust-version.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+madmin.workspace = true
 log.workspace = true
 async-trait.workspace = true
 bytes.workspace = true

rustfs/src/grpc.rs

@@ -16,6 +16,7 @@ use ecstore::{
 use futures::{Stream, StreamExt};
 use lock::{lock_args::LockArgs, Locker, GLOBAL_LOCAL_SERVER};
 
+use madmin::health::get_cpus;
 use protos::{
     models::{PingBody, PingBodyBuilder},
     proto_gen::node_service::{node_service_server::NodeService as Node, *},
@@ -1551,7 +1552,20 @@ impl Node for NodeService {
     }
 
     async fn get_cpus(&self, _request: Request<GetCpusRequest>) -> Result<Response<GetCpusResponse>, Status> {
-        todo!()
+        let info = get_cpus();
+        let mut buf = Vec::new();
+        if let Err(err) = info.serialize(&mut Serializer::new(&mut buf)) {
+            return Ok(tonic::Response::new(GetCpusResponse {
+                success: false,
+                cpus: vec![],
+                error_info: Some(err.to_string()),
+            }));
+        }
+        Ok(tonic::Response::new(GetCpusResponse {
+            success: true,
+            cpus: buf,
+            error_info: None,
+        }))
     }
 
     async fn get_net_info(&self, _request: Request<GetNetInfoRequest>) -> Result<Response<GetNetInfoResponse>, Status> {

rustfs/src/peer_rest_client.rs

@@ -2,7 +2,11 @@ use std::io::Cursor;
 
 use common::error::{Error, Result};
 use ecstore::{admin_server_info::ServerProperties, store_api::StorageInfo};
-use protos::{node_service_time_out_client, proto_gen::node_service::LocalStorageInfoRequest};
+use madmin::health::Cpus;
+use protos::{
+    node_service_time_out_client,
+    proto_gen::node_service::{GetCpusRequest, LocalStorageInfoRequest, ServerInfoRequest},
+};
 use rmp_serde::Deserializer;
 use serde::Deserialize;
 use tonic::Request;
@@ -33,15 +37,53 @@ impl PeerRestClient {
             }
             return Err(Error::msg(""));
         }
-        let info = response.storage_info;
+        let data = response.storage_info;
 
-        let mut buf = Deserializer::new(Cursor::new(info));
+        let mut buf = Deserializer::new(Cursor::new(data));
         let storage_info: StorageInfo = Deserialize::deserialize(&mut buf).unwrap();
 
         Ok(storage_info)
     }
 
-    pub async fn server_info(&self) -> Request<ServerProperties> {
-        todo!()
+    pub async fn server_info(&self) -> Result<ServerProperties> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(ServerInfoRequest { metrics: true });
+
+        let response = client.server_info(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        let data = response.server_properties;
+
+        let mut buf = Deserializer::new(Cursor::new(data));
+        let storage_properties: ServerProperties = Deserialize::deserialize(&mut buf).unwrap();
+
+        Ok(storage_properties)
+    }
+
+    pub async fn get_cpus(&self) -> Result<Cpus> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(GetCpusRequest {});
+
+        let response = client.get_cpus(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        let data = response.cpus;
+
+        let mut buf = Deserializer::new(Cursor::new(data));
+        let cpus: Cpus = Deserialize::deserialize(&mut buf).unwrap();
+
+        Ok(cpus)
     }
 }