Add node resource availability

agent/doc/swdesign/README.md

@@ -2764,7 +2764,7 @@ Needs:
 
 Status: approved
 
-At an interval of 2 seconds, the AgentManager measures the global CPU load and the available free memory and sends them to the Ankaios server via an `AgentLoadStatus` message.
+At an interval of 2 seconds, the AgentManager measures the global CPU usage and the available free memory and sends them to the Ankaios server via an `AgentLoadStatus` message.
 
 Rationale:
 Available resources must be available in the cluster in order to enable dynamic scheduling, e.g., done by a workload.

agent/src/agent_manager.rs

@@ -16,7 +16,7 @@ use sysinfo::{CpuRefreshKind, MemoryRefreshKind, RefreshKind, System};
 use common::{
     commands::AgentLoadStatus,
     from_server_interface::{FromServer, FromServerReceiver},
-    objects::{CpuLoad, FreeMemory, WorkloadState},
+    objects::{CpuUsage, FreeMemory, WorkloadState},
     std_extensions::{GracefulExitResult, IllegalStateResult},
     to_server_interface::{ToServerInterface, ToServerSender},
 };
@@ -214,20 +214,20 @@ impl AgentManager {
 
         sys.refresh_all();
 
-        let cpu_load = sys.global_cpu_usage();
+        let cpu_usage = sys.global_cpu_usage();
         let free_memory = sys.free_memory();
 
         log::trace!(
-            "Agent '{}' reports resource usage: CPU Load: {:.2}%, Free Memory: {} B",
+            "Agent '{}' reports resource usage: CPU Usage: {:.2}%, Free Memory: {} B",
             self.agent_name,
-            cpu_load,
+            cpu_usage,
             free_memory,
         );
 
         self.to_server
             .agent_load_status(AgentLoadStatus {
                 agent_name: self.agent_name.clone(),
-                cpu_load: CpuLoad::new(cpu_load),
+                cpu_usage: CpuUsage::new(cpu_usage),
                 free_memory: FreeMemory { free_memory },
             })
             .await
@@ -580,8 +580,8 @@ mod tests {
         let result = server_receiver.recv().await.unwrap();
         if let ToServer::AgentLoadStatus(load_status) = result {
             assert_eq!(load_status.agent_name, AGENT_NAME.to_string());
-            assert_ne!(load_status.cpu_load.cpu_load, 0);
-            assert_ne!(load_status.cpu_load.cpu_load, 0);
+            assert_ne!(load_status.cpu_usage.cpu_usage, 0);
+            assert_ne!(load_status.cpu_usage.cpu_usage, 0);
         } else {
             panic!("Expected AgentLoadStatus, got something else");
         }

agent/src/runtime_manager.rs

@@ -1950,7 +1950,7 @@ mod tests {
             agents: HashMap::from([(
                 AGENT_NAME.to_owned(),
                 objects::AgentAttributes {
-                    cpu_load: Some(objects::CpuLoad { cpu_load: 42 }),
+                    cpu_usage: Some(objects::CpuUsage { cpu_usage: 42 }),
                     free_memory: Some(objects::FreeMemory { free_memory: 42 }),
                 }
                 .into(),

ank/doc/swdesign/README.md

@@ -903,9 +903,9 @@ Status: approved
 
 When the Ankaios CLI presents connected Ankaios agents to the user, the Ankaios CLI shall present the agents as rows in a table with the following content:
 
-| NAME                     | WORKLOADS                        | CPU USAGE                | FREE MEMORY                      |
-| ------------------------ | -------------------------------- | ------------------------ | -------------------------------- |
-| `<agent_name>` as text   | `<assigned_workloads>` as number | `<cpu_usage>` as load in percent | `<free_memory>` in bytes |
+| NAME                     | WORKLOADS                        | CPU USAGE                        | FREE MEMORY                      |
+| ------------------------ | -------------------------------- | -------------------------------- | -------------------------------- |
+| `<agent_name>` as text   | `<assigned_workloads>` as number | `<cpu_usage>` as load in percent | `<free_memory>` in bytes         |
 
 Tags:
 - CliCommands

ank/src/cli_commands/agent_table_row.rs

@@ -21,8 +21,8 @@ pub struct AgentTableRow {
     pub agent_name: String,
     #[tabled(rename = "WORKLOADS")]
     pub workloads: u32,
-    #[tabled(rename = "CPU LOAD")]
-    pub cpu_load: String,
+    #[tabled(rename = "CPU USAGE")]
+    pub cpu_usage: String,
     #[tabled(rename = "FREE MEMORY")]
     pub free_memory: String,
 }

ank/src/cli_commands/get_agents.rs

@@ -62,7 +62,7 @@ fn transform_into_table_rows(
             AgentTableRow {
                 agent_name,
                 workloads: workload_states_count,
-                cpu_load: agent_attributes.get_cpu_load_as_string(),
+                cpu_usage: agent_attributes.get_cpu_usage_as_string(),
                 free_memory: agent_attributes.get_free_memory_as_string(),
             }
         })
@@ -142,9 +142,9 @@ mod tests {
         let table_output_result = cmd.get_agents().await;
 
         let expected_table_output = [
-            "NAME      WORKLOADS   CPU LOAD   FREE MEMORY",
-            "agent_A   1           0.42 %     42 B       ",
-            "agent_B   1           0.42 %     42 B       ",
+            "NAME      WORKLOADS   CPU USAGE   FREE MEMORY",
+            "agent_A   1           42 %        42 B       ",
+            "agent_B   1           42 %        42 B       ",
         ]
         .join("\n");
 
@@ -179,7 +179,7 @@ mod tests {
 
         let table_output_result = cmd.get_agents().await;
 
-        let expected_table_output = "NAME   WORKLOADS   CPU LOAD   FREE MEMORY".to_string();
+        let expected_table_output = "NAME   WORKLOADS   CPU USAGE   FREE MEMORY".to_string();
 
         assert_eq!(Ok(expected_table_output), table_output_result);
     }
@@ -207,8 +207,8 @@ mod tests {
         let table_output_result = cmd.get_agents().await;
 
         let expected_table_output = [
-            "NAME      WORKLOADS   CPU LOAD   FREE MEMORY",
-            "agent_A   0           0.42 %     42 B       ",
+            "NAME      WORKLOADS   CPU USAGE   FREE MEMORY",
+            "agent_A   0           42 %        42 B       ",
         ]
         .join("\n");
 
@@ -273,8 +273,8 @@ mod tests {
         let table_output_result = cmd.get_agents().await;
 
         let expected_table_output = [
-            "NAME      WORKLOADS   CPU LOAD   FREE MEMORY",
-            "agent_A   1           0.42 %     42 B       ",
+            "NAME      WORKLOADS   CPU USAGE   FREE MEMORY",
+            "agent_A   1           42 %        42 B       ",
         ]
         .join("\n");
 
@@ -310,8 +310,8 @@ mod tests {
         let table_output_result = cmd.get_agents().await;
 
         let expected_table_output = [
-            "NAME      WORKLOADS   CPU LOAD   FREE MEMORY",
-            "agent_A   1           0.42 %     42 B       ",
+            "NAME      WORKLOADS   CPU USAGE   FREE MEMORY",
+            "agent_A   1           42 %        42 B       ",
         ]
         .join("\n");
 

ank/src/filtered_complete_state.rs

@@ -25,8 +25,6 @@ use serde::{Deserialize, Serialize, Serializer};
 
 use crate::{output_and_error, output_warn};
 
-const PERCENTAGE_BASE: u32 = 100;
-
 pub fn serialize_option_to_ordered_map<S, T: Serialize>(
     value: &Option<HashMap<String, T>>,
     serializer: S,
@@ -41,20 +39,6 @@ where
     }
 }
 
-pub fn serialize_percent_as_proportion<S>(
-    value: &Option<u32>,
-    serializer: S,
-) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-{
-    if let Some(value) = value {
-        serializer.serialize_f32((*value as f32) / (PERCENTAGE_BASE as f32))
-    } else {
-        serializer.serialize_none()
-    }
-}
-
 #[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct FilteredCompleteState {
@@ -92,9 +76,9 @@ pub struct FilteredAgentMap {
 
 #[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize, Default)]
 #[serde(rename_all = "camelCase")]
-pub struct FilteredCpuLoad {
-    #[serde(serialize_with = "serialize_percent_as_proportion")]
-    pub cpu_load: Option<u32>,
+pub struct FilteredCpuUsage {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cpu_usage: Option<u32>,
 }
 
 #[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize, Default)]
@@ -108,20 +92,16 @@ pub struct FilteredFreeMemory {
 #[serde(rename_all = "camelCase")]
 pub struct FilteredAgentAttributes {
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub cpu_load: Option<FilteredCpuLoad>,
+    pub cpu_usage: Option<FilteredCpuUsage>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub free_memory: Option<FilteredFreeMemory>,
 }
 
 impl FilteredAgentAttributes {
-    pub fn get_cpu_load_as_string(&mut self) -> String {
-        if let Some(cpu_load) = &self.cpu_load {
-            if let Some(cpu_load_value) = cpu_load.cpu_load {
-                format!(
-                    "{}.{} %",
-                    cpu_load_value / PERCENTAGE_BASE,
-                    cpu_load_value % PERCENTAGE_BASE
-                )
+    pub fn get_cpu_usage_as_string(&mut self) -> String {
+        if let Some(cpu_usage) = &self.cpu_usage {
+            if let Some(cpu_usage_value) = cpu_usage.cpu_usage {
+                format!("{} %", cpu_usage_value)
             } else {
                 "".to_string()
             }
@@ -258,16 +238,16 @@ impl From<ank_base::AgentMap> for FilteredAgentMap {
 impl From<ank_base::AgentAttributes> for FilteredAgentAttributes {
     fn from(value: ank_base::AgentAttributes) -> Self {
         FilteredAgentAttributes {
-            cpu_load: value.cpu_load.map(Into::into),
+            cpu_usage: value.cpu_usage.map(Into::into),
             free_memory: value.free_memory.map(Into::into),
         }
     }
 }
 
-impl From<ank_base::CpuLoad> for FilteredCpuLoad {
-    fn from(value: ank_base::CpuLoad) -> Self {
-        FilteredCpuLoad {
-            cpu_load: Some(value.cpu_load),
+impl From<ank_base::CpuUsage> for FilteredCpuUsage {
+    fn from(value: ank_base::CpuUsage) -> Self {
+        FilteredCpuUsage {
+            cpu_usage: Some(value.cpu_usage),
         }
     }
 }

api/proto/ank_base.proto

@@ -199,10 +199,10 @@ message AgentMap {
 }
 
 /**
-* A message containing the CPU load information of the agent.
+* A message containing the CPU usage information of the agent.
 */
-message CpuLoad {
-    uint32 cpu_load = 1; // expressed in percent, the formula for calculating: cpu_load = (new_work_time - old_work_time) / (new_total_time - old_total_time) * 100
+message CpuUsage {
+    uint32 cpu_usage = 1; // expressed in percent, the formula for calculating: cpu_usage = (new_work_time - old_work_time) / (new_total_time - old_total_time) * 100
 }
 
 /**
@@ -216,7 +216,7 @@ message FreeMemory {
 * A message that contains attributes of the agent.
 */
 message AgentAttributes {
-    CpuLoad cpu_load = 1; /// The cpu load of the agent.
+    CpuUsage cpu_usage = 1; /// The cpu usage of the agent.
     FreeMemory free_memory = 2; /// The amount of free memory of the agent.
 }
 

common/src/commands.rs

@@ -12,7 +12,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::objects::{CompleteState, CpuLoad, DeletedWorkload, FreeMemory, WorkloadSpec};
+use crate::objects::{CompleteState, CpuUsage, DeletedWorkload, FreeMemory, WorkloadSpec};
 use api::ank_base;
 use serde::{Deserialize, Serialize};
 
@@ -24,7 +24,7 @@ pub struct AgentHello {
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct AgentLoadStatus {
     pub agent_name: String,
-    pub cpu_load: CpuLoad,
+    pub cpu_usage: CpuUsage,
     pub free_memory: FreeMemory,
 }
 

common/src/objects/agent_map.rs

@@ -20,17 +20,15 @@ use crate::commands;
 
 type AgentName = String;
 
-pub const PERCENTAGE_BASE: f32 = 100.0;
-
 #[derive(Debug, Serialize, Deserialize, Clone, Default, PartialEq, Eq)]
-pub struct CpuLoad {
-    pub cpu_load: u32,
+pub struct CpuUsage {
+    pub cpu_usage: u32,
 }
 
-impl CpuLoad {
-    pub fn new(cpu_load: f32) -> Self {
+impl CpuUsage {
+    pub fn new(cpu_usage: f32) -> Self {
         Self {
-            cpu_load: (cpu_load * PERCENTAGE_BASE).trunc() as u32,
+            cpu_usage: cpu_usage.round() as u32,
         }
     }
 }
@@ -42,7 +40,7 @@ pub struct FreeMemory {
 
 #[derive(Debug, Serialize, Deserialize, Clone, Default, PartialEq, Eq)]
 pub struct AgentAttributes {
-    pub cpu_load: Option<CpuLoad>,
+    pub cpu_usage: Option<CpuUsage>,
     pub free_memory: Option<FreeMemory>,
 }
 
@@ -65,24 +63,24 @@ impl AgentMap {
 
     pub fn update_resource_availability(&mut self, agent_load_status: commands::AgentLoadStatus) {
         self.0.entry(agent_load_status.agent_name).and_modify(|e| {
-            e.cpu_load = Some(agent_load_status.cpu_load);
+            e.cpu_usage = Some(agent_load_status.cpu_usage);
             e.free_memory = Some(agent_load_status.free_memory);
         });
     }
 }
 
-impl From<CpuLoad> for ank_base::CpuLoad {
-    fn from(item: CpuLoad) -> ank_base::CpuLoad {
-        ank_base::CpuLoad {
-            cpu_load: item.cpu_load,
+impl From<CpuUsage> for ank_base::CpuUsage {
+    fn from(item: CpuUsage) -> ank_base::CpuUsage {
+        ank_base::CpuUsage {
+            cpu_usage: item.cpu_usage,
         }
     }
 }
 
-impl From<ank_base::CpuLoad> for CpuLoad {
-    fn from(item: ank_base::CpuLoad) -> Self {
-        CpuLoad {
-            cpu_load: item.cpu_load,
+impl From<ank_base::CpuUsage> for CpuUsage {
+    fn from(item: ank_base::CpuUsage) -> Self {
+        CpuUsage {
+            cpu_usage: item.cpu_usage,
         }
     }
 }
@@ -106,8 +104,8 @@ impl From<ank_base::FreeMemory> for FreeMemory {
 impl From<AgentAttributes> for ank_base::AgentAttributes {
     fn from(item: AgentAttributes) -> ank_base::AgentAttributes {
         ank_base::AgentAttributes {
-            cpu_load: Some(ank_base::CpuLoad {
-                cpu_load: item.cpu_load.unwrap_or_default().cpu_load,
+            cpu_usage: Some(ank_base::CpuUsage {
+                cpu_usage: item.cpu_usage.unwrap_or_default().cpu_usage,
             }),
             free_memory: Some(ank_base::FreeMemory {
                 free_memory: item.free_memory.unwrap_or_default().free_memory,
@@ -119,8 +117,8 @@ impl From<AgentAttributes> for ank_base::AgentAttributes {
 impl From<ank_base::AgentAttributes> for AgentAttributes {
     fn from(item: ank_base::AgentAttributes) -> Self {
         AgentAttributes {
-            cpu_load: Some(CpuLoad {
-                cpu_load: item.cpu_load.unwrap_or_default().cpu_load,
+            cpu_usage: Some(CpuUsage {
+                cpu_usage: item.cpu_usage.unwrap_or_default().cpu_usage,
             }),
             free_memory: Some(FreeMemory {
                 free_memory: item.free_memory.unwrap_or_default().free_memory,
@@ -170,7 +168,7 @@ pub fn generate_test_agent_map(agent_name: impl Into<String>) -> AgentMap {
     agent_map
         .entry(agent_name.into())
         .or_insert(AgentAttributes {
-            cpu_load: Some(CpuLoad { cpu_load: 42 }),
+            cpu_usage: Some(CpuUsage { cpu_usage: 42 }),
             free_memory: Some(FreeMemory { free_memory: 42 }),
         });
     agent_map
@@ -185,7 +183,7 @@ pub fn generate_test_agent_map_from_specs(workloads: &[crate::objects::WorkloadS
             agent_map
                 .entry(agent_name.to_owned())
                 .or_insert(AgentAttributes {
-                    cpu_load: Some(CpuLoad { cpu_load: 42 }),
+                    cpu_usage: Some(CpuUsage { cpu_usage: 42 }),
                     free_memory: Some(FreeMemory { free_memory: 42 }),
                 });
             agent_map

common/src/objects/mod.rs

@@ -26,7 +26,7 @@ pub use complete_state::CompleteState;
 mod agent_map;
 #[cfg(any(feature = "test_utils", test))]
 pub use agent_map::{generate_test_agent_map, generate_test_agent_map_from_specs};
-pub use agent_map::{AgentAttributes, AgentMap, CpuLoad, FreeMemory};
+pub use agent_map::{AgentAttributes, AgentMap, CpuUsage, FreeMemory};
 
 mod workload_states_map;
 pub use workload_states_map::WorkloadStatesMap;