Add node resource availability

agent/Cargo.toml

@@ -39,6 +39,7 @@ serde_json = "1.0"
 uuid = { version = "1.3", features = ["v4", "fast-rng"] }
 sha256 = "1.5"
 umask = "2.1.0"
+sysinfo = "0.31"
 regex = "1.10"
 
 [dev-dependencies]

agent/doc/swdesign/README.md

@@ -2759,6 +2759,22 @@ Needs:
 - impl
 - utest
 
+#### AgentManager sends the node resource availability to the server
+`swdd~agent-sends-node-resource-availability-to-server~1`
+
+Status: approved
+
+When the AgentManager receives the workload states of the workload it manages, then the AgentManager shall send an `AgentLoadStatus` message to the Ankaios server, containing the available resources.
+
+Rationale: The Ankaios server workloads scheduler shall necessitate in the future the knowledge of available resources.
+
+Tags:
+- AgentManager
+
+Needs:
+- impl
+- utest
+
 ### Forwarding the Control Interface
 
 The Ankaios Agent is responsible to forward Control Interface requests from a Workload to the Ankaios Server and to forward Control Interface responses from the Ankaios Server to the Workload.

agent/src/agent_manager.rs

@@ -11,10 +11,12 @@
 // under the License.
 //
 // SPDX-License-Identifier: Apache-2.0
+use sysinfo::{CpuRefreshKind, MemoryRefreshKind, RefreshKind, System};
 
 use common::{
+    commands::AgentLoadStatus,
     from_server_interface::{FromServer, FromServerReceiver},
-    objects::WorkloadState,
+    objects::{AgentLoad, WorkloadState},
     std_extensions::{GracefulExitResult, IllegalStateResult},
     to_server_interface::{ToServerInterface, ToServerSender},
 };
@@ -25,6 +27,9 @@ use crate::workload_state::workload_state_store::WorkloadStateStore;
 #[cfg_attr(test, mockall_double::double)]
 use crate::runtime_manager::RuntimeManager;
 use crate::workload_state::WorkloadStateReceiver;
+
+const RESOURCE_MEASUREMENT_INTERVAL_TICK: std::time::Duration = tokio::time::Duration::from_secs(2);
+
 // [impl->swdd~agent-shall-use-interfaces-to-server~1]
 pub struct AgentManager {
     agent_name: String,
@@ -56,6 +61,9 @@ impl AgentManager {
 
     pub async fn start(&mut self) {
         log::info!("Awaiting commands from the server ...");
+
+        let mut interval = tokio::time::interval(RESOURCE_MEASUREMENT_INTERVAL_TICK);
+
         loop {
             tokio::select! {
                 // [impl->swdd~agent-manager-listens-requests-from-server~1]
@@ -67,15 +75,18 @@ impl AgentManager {
                     if self.execute_from_server_command(from_server).await.is_none() {
                         break;
                     }
-                }
+                },
                 // [impl->swdd~agent-manager-receives-workload-states-of-its-workloads~1]
                 workload_state = self.workload_state_receiver.recv() => {
                     let workload_state = workload_state
                         .ok_or("Channel to listen to own workload states closed.".to_string())
                         .unwrap_or_exit("Abort");
-
                     self.store_and_forward_own_workload_states(workload_state).await;
                 }
+                // [impl->swdd~agent-sends-node-resource-availability-to-server~1]
+                _ = interval.tick() => {
+                    self.measure_and_forward_resource_availability().await;
+                }
             }
         }
     }
@@ -192,6 +203,38 @@ impl AgentManager {
             .await
             .unwrap_or_illegal_state();
     }
+
+    // [impl->swdd~agent-sends-node-resource-availability-to-server~1]
+    async fn measure_and_forward_resource_availability(&mut self) {
+        let mut sys = System::new_with_specifics(
+            RefreshKind::new()
+                .with_cpu(CpuRefreshKind::everything())
+                .with_memory(MemoryRefreshKind::everything()),
+        );
+
+        sys.refresh_all();
+
+        let cpu_usage: u32 = (sys.global_cpu_usage() * 100.0) as u32;
+        let free_memory = sys.free_memory();
+
+        log::trace!(
+            "Agent '{}' reports resource usage: CPU: {:.2}%, Free Memory: {} MB",
+            self.agent_name,
+            cpu_usage,
+            free_memory,
+        );
+
+        self.to_server
+            .agent_load_status(AgentLoadStatus {
+                agent_name: self.agent_name.clone(),
+                agent_resources: AgentLoad {
+                    cpu_usage,
+                    free_memory,
+                },
+            })
+            .await
+            .unwrap_or_illegal_state();
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -501,4 +544,36 @@ mod tests {
         to_manager.stop().await.unwrap();
         assert!(join!(handle).0.is_ok());
     }
+
+    // [utest->swdd~agent-sends-node-resource-availability-to-server~1]
+    #[tokio::test]
+    async fn utest_agent_manager_sends_available_resources() {
+        let _guard = crate::test_helper::MOCKALL_CONTEXT_SYNC
+            .get_lock_async()
+            .await;
+
+        let mock_wl_state_store = MockWorkloadStateStore::default();
+        mock_parameter_storage_new_returns(mock_wl_state_store);
+
+        let (to_manager, manager_receiver) = channel(BUFFER_SIZE);
+        let (to_server, mut server_receiver) = channel(BUFFER_SIZE);
+        let (_workload_state_sender, workload_state_receiver) = channel(BUFFER_SIZE);
+        let mut mock_runtime_manager = RuntimeManager::default();
+        mock_runtime_manager.expect_handle_update_workload().never();
+
+        let mut agent_manager = AgentManager::new(
+            AGENT_NAME.to_string(),
+            manager_receiver,
+            mock_runtime_manager,
+            to_server,
+            workload_state_receiver,
+        );
+
+        let handle = tokio::spawn(async move { agent_manager.start().await });
+
+        assert!(server_receiver.recv().await.is_some());
+
+        to_manager.stop().await.unwrap();
+        assert!(join!(handle).0.is_ok());
+    }
 }

agent/src/runtime_manager.rs

@@ -538,7 +538,7 @@ mod tests {
         generate_test_control_interface_access,
         generate_test_workload_spec_with_control_interface_access,
         generate_test_workload_spec_with_dependencies, generate_test_workload_spec_with_param,
-        AddCondition, WorkloadInstanceNameBuilder, WorkloadState,
+        AddCondition, AgentAttributes, WorkloadInstanceNameBuilder, WorkloadState,
     };
     use common::test_utils::{
         self, generate_test_complete_state, generate_test_deleted_workload,
@@ -1947,9 +1947,8 @@ mod tests {
         });
 
         complete_state.agents = Some(ank_base::AgentMap {
-            agents: HashMap::from([(AGENT_NAME.to_owned(), Default::default())]),
+            agents: HashMap::from([(AGENT_NAME.to_owned(), AgentAttributes::default().into())]),
         });
-
         let expected_response = ank_base::Response {
             request_id,
             response_content: Some(ResponseContent::CompleteState(complete_state)),

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                        |
-| ------------------------ | -------------------------------- |
-| `<agent_name>` as text   | `<assigned_workloads>` as number |
+| NAME                     | WORKLOADS                        | CPU USAGE                | FREE MEMORY                      |
+| ------------------------ | -------------------------------- | ------------------------ | -------------------------------- |
+| `<agent_name>` as text   | `<assigned_workloads>` as number | `<cpu_usage>` as percent | `<assigned_workloads>` as number |
 
 Tags:
 - CliCommands
@@ -921,7 +921,7 @@ Status: approved
 
 When the user invokes the CLI with a request to provide the list of connected Ankaios agents, the Ankaios CLI shall:
 * request the whole CompleteState of Ankaios server
-* create a table row for each Ankaios agent listed inside the CompleteState's `agents` field with the agent name and the amount of workload states of its managed workloads
+* create a table row for each Ankaios agent listed inside the CompleteState's `agents` field with the agent name and the amount of workload states of its managed workloads as well as the agent resource availability
 
 Rationale:
 Counting the workload states, rather than the assigned workloads in the desired state for each agent, ensures the correct number of workloads, even if a workload has been deleted from the desired state, but the actual deletion has not yet been scheduled.

ank/src/cli_commands/agent_table_row.rs

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