Add version returning grpc call to host-service

Signed-off-by: Guvenc Gulce <guevenc.guelce@sap.com>

Author: guvenc

cli/src/host_commands.rs

@@ -2,8 +2,8 @@ use anyhow::{Context, Result};
 use clap::{Args, Subcommand};
 use feos_proto::host_service::{
     host_service_client::HostServiceClient, GetCpuInfoRequest, GetNetworkInfoRequest,
-    HostnameRequest, MemoryRequest, RebootRequest, ShutdownRequest, StreamFeosLogsRequest,
-    StreamKernelLogsRequest, UpgradeFeosBinaryRequest,
+    GetVersionInfoRequest, HostnameRequest, MemoryRequest, RebootRequest, ShutdownRequest,
+    StreamFeosLogsRequest, StreamKernelLogsRequest, UpgradeFeosBinaryRequest,
 };
 use tokio_stream::StreamExt;
 use tonic::transport::Channel;
@@ -47,6 +47,8 @@ pub enum HostCommand {
     Shutdown,
     /// Reboot the host machine
     Reboot,
+    /// Get kernel and FeOS version information
+    VersionInfo,
 }
 
 pub async fn handle_host_command(args: HostArgs) -> Result<()> {
@@ -66,6 +68,7 @@ pub async fn handle_host_command(args: HostArgs) -> Result<()> {
         HostCommand::Flogs => stream_flogs(&mut client).await?,
         HostCommand::Shutdown => shutdown_host(&mut client).await?,
         HostCommand::Reboot => reboot_host(&mut client).await?,
+        HostCommand::VersionInfo => get_version_info(&mut client).await?,
     }
 
     Ok(())
@@ -286,6 +289,15 @@ async fn upgrade_feos(
     Ok(())
 }
 
+async fn get_version_info(client: &mut HostServiceClient<Channel>) -> Result<()> {
+    println!("Requesting version information...");
+    let request = GetVersionInfoRequest {};
+    let response = client.get_version_info(request).await?.into_inner();
+    println!("FeOS Version:    {}", response.feos_version);
+    println!("Kernel Version:  {}", response.kernel_version);
+    Ok(())
+}
+
 async fn shutdown_host(client: &mut HostServiceClient<Channel>) -> Result<()> {
     println!("Requesting host shutdown...");
     let request = ShutdownRequest {};

feos/services/host-service/src/api.rs

@@ -1,10 +1,10 @@
 use crate::Command;
 use feos_proto::host_service::{
     host_service_server::HostService, FeosLogEntry, GetCpuInfoRequest, GetCpuInfoResponse,
-    GetNetworkInfoRequest, GetNetworkInfoResponse, HostnameRequest, HostnameResponse,
-    KernelLogEntry, MemoryRequest, MemoryResponse, RebootRequest, RebootResponse, ShutdownRequest,
-    ShutdownResponse, StreamFeosLogsRequest, StreamKernelLogsRequest, UpgradeFeosBinaryRequest,
-    UpgradeFeosBinaryResponse,
+    GetNetworkInfoRequest, GetNetworkInfoResponse, GetVersionInfoRequest, GetVersionInfoResponse,
+    HostnameRequest, HostnameResponse, KernelLogEntry, MemoryRequest, MemoryResponse,
+    RebootRequest, RebootResponse, ShutdownRequest, ShutdownResponse, StreamFeosLogsRequest,
+    StreamKernelLogsRequest, UpgradeFeosBinaryRequest, UpgradeFeosBinaryResponse,
 };
 use log::info;
 use std::pin::Pin;
@@ -204,4 +204,25 @@ impl HostService for HostApiHandler {
         let output_stream = ReceiverStream::new(stream_rx);
         Ok(Response::new(Box::pin(output_stream)))
     }
+
+    async fn get_version_info(
+        &self,
+        _request: Request<GetVersionInfoRequest>,
+    ) -> Result<Response<GetVersionInfoResponse>, Status> {
+        info!("HOST_API_HANDLER: Received GetVersionInfo request.");
+        let (resp_tx, resp_rx) = oneshot::channel();
+        let cmd = Command::GetVersionInfo(resp_tx);
+        self.dispatcher_tx
+            .send(cmd)
+            .await
+            .map_err(|e| Status::internal(format!("Failed to send command to dispatcher: {e}")))?;
+
+        match resp_rx.await {
+            Ok(Ok(result)) => Ok(Response::new(result)),
+            Ok(Err(status)) => Err(status),
+            Err(_) => Err(Status::internal(
+                "Dispatcher task dropped response channel.",
+            )),
+        }
+    }
 }

feos/services/host-service/src/dispatcher.rs

@@ -38,6 +38,9 @@ impl HostServiceDispatcher {
                 Command::GetNetworkInfo(responder) => {
                     tokio::spawn(worker::handle_get_network_info(responder));
                 }
+                Command::GetVersionInfo(responder) => {
+                    tokio::spawn(worker::handle_get_version_info(responder));
+                }
                 Command::UpgradeFeosBinary(req, responder) => {
                     let restart_tx = self.restart_tx.clone();
                     tokio::spawn(worker::handle_upgrade(restart_tx, req, responder));

feos/services/host-service/src/lib.rs

@@ -1,7 +1,7 @@
 use feos_proto::host_service::{
-    FeosLogEntry, GetCpuInfoResponse, GetNetworkInfoResponse, HostnameResponse, KernelLogEntry,
-    MemoryResponse, RebootRequest, RebootResponse, ShutdownRequest, ShutdownResponse,
-    UpgradeFeosBinaryRequest, UpgradeFeosBinaryResponse,
+    FeosLogEntry, GetCpuInfoResponse, GetNetworkInfoResponse, GetVersionInfoResponse,
+    HostnameResponse, KernelLogEntry, MemoryResponse, RebootRequest, RebootResponse,
+    ShutdownRequest, ShutdownResponse, UpgradeFeosBinaryRequest, UpgradeFeosBinaryResponse,
 };
 use std::path::PathBuf;
 use tokio::sync::{mpsc, oneshot};
@@ -17,6 +17,7 @@ pub enum Command {
     GetMemory(oneshot::Sender<Result<MemoryResponse, Status>>),
     GetCPUInfo(oneshot::Sender<Result<GetCpuInfoResponse, Status>>),
     GetNetworkInfo(oneshot::Sender<Result<GetNetworkInfoResponse, Status>>),
+    GetVersionInfo(oneshot::Sender<Result<GetVersionInfoResponse, Status>>),
     UpgradeFeosBinary(
         UpgradeFeosBinaryRequest,
         oneshot::Sender<Result<UpgradeFeosBinaryResponse, Status>>,

feos/services/host-service/src/worker/info.rs

@@ -1,6 +1,6 @@
 use feos_proto::host_service::{
-    CpuInfo, GetCpuInfoResponse, GetNetworkInfoResponse, HostnameResponse, MemInfo, MemoryResponse,
-    NetDev,
+    CpuInfo, GetCpuInfoResponse, GetNetworkInfoResponse, GetVersionInfoResponse, HostnameResponse,
+    MemInfo, MemoryResponse, NetDev,
 };
 use log::{error, info, warn};
 use nix::unistd;
@@ -22,7 +22,7 @@ pub async fn handle_hostname(responder: oneshot::Sender<Result<HostnameResponse,
         }
         Err(e) => {
             let msg = format!("Failed to get system hostname: {e}");
-            error!("HOST_WORKER: ERROR - {msg}");
+            error!("HOST_WORKER: {msg}");
             Err(Status::internal(msg))
         }
     };
@@ -117,7 +117,7 @@ pub async fn handle_get_memory(responder: oneshot::Sender<Result<MemoryResponse,
             mem_info: Some(mem_info),
         }),
         Err(e) => {
-            error!("HOST_WORKER: ERROR - Failed to get memory info: {e}");
+            error!("HOST_WORKER: Failed to get memory info: {e}");
             Err(Status::internal(format!("Failed to get memory info: {e}")))
         }
     };
@@ -208,7 +208,7 @@ pub async fn handle_get_cpu_info(responder: oneshot::Sender<Result<GetCpuInfoRes
     let result = match read_and_parse_cpuinfo().await {
         Ok(cpu_info) => Ok(GetCpuInfoResponse { cpu_info }),
         Err(e) => {
-            error!("HOST_WORKER: ERROR - Failed to get CPU info: {e}");
+            error!("HOST_WORKER: Failed to get CPU info: {e}");
             Err(Status::internal(format!("Failed to get CPU info: {e}")))
         }
     };
@@ -281,7 +281,7 @@ pub async fn handle_get_network_info(
     let result = match read_all_net_stats().await {
         Ok(devices) => Ok(GetNetworkInfoResponse { devices }),
         Err(e) => {
-            error!("HOST_WORKER: ERROR - Failed to get network info: {e}");
+            error!("HOST_WORKER: Failed to get network info: {e}");
             Err(Status::internal(format!(
                 "Failed to get network info from sysfs: {e}"
             )))
@@ -294,3 +294,32 @@ pub async fn handle_get_network_info(
         );
     }
 }
+
+pub async fn handle_get_version_info(
+    responder: oneshot::Sender<Result<GetVersionInfoResponse, Status>>,
+) {
+    info!("HOST_WORKER: Processing GetVersionInfo request.");
+
+    let kernel_version_res = fs::read_to_string("/proc/version").await;
+
+    let result = match kernel_version_res {
+        Ok(kernel_version) => {
+            let feos_version = env!("CARGO_PKG_VERSION").to_string();
+            Ok(GetVersionInfoResponse {
+                kernel_version: kernel_version.trim().to_string(),
+                feos_version,
+            })
+        }
+        Err(e) => {
+            let msg = format!("Failed to read kernel version from /proc/version: {e}");
+            error!("HOST_WORKER: {msg}");
+            Err(Status::internal(msg))
+        }
+    };
+
+    if responder.send(result).is_err() {
+        error!(
+            "HOST_WORKER: Failed to send response for GetVersionInfo. API handler may have timed out."
+        );
+    }
+}

feos/services/host-service/src/worker/mod.rs

@@ -2,6 +2,9 @@ pub mod info;
 pub mod ops;
 pub mod power;
 
-pub use info::{handle_get_cpu_info, handle_get_memory, handle_get_network_info, handle_hostname};
+pub use info::{
+    handle_get_cpu_info, handle_get_memory, handle_get_network_info, handle_get_version_info,
+    handle_hostname,
+};
 pub use ops::{handle_stream_feos_logs, handle_stream_kernel_logs, handle_upgrade};
 pub use power::{handle_reboot, handle_shutdown};

proto/v1/host.proto

@@ -23,6 +23,9 @@ service HostService {
 
   // Streams logs from the internal FeOS logger.
   rpc StreamFeOSLogs(StreamFeosLogsRequest) returns (stream FeosLogEntry);
+
+  // Retrieves version information about the host system.
+  rpc GetVersionInfo(GetVersionInfoRequest) returns (GetVersionInfoResponse);
 }
 
 message HostnameRequest {}
@@ -181,4 +184,13 @@ message FeosLogEntry {
   string level = 3;
   string target = 4;
   string message = 5;
+}
+
+message GetVersionInfoRequest {}
+
+message GetVersionInfoResponse {
+  // The version of the Linux kernel (e.g., from /proc/version).
+  string kernel_version = 1;
+  // The version of the running FeOS binary.
+  string feos_version = 2;
 }