Implement container service test cases

Signed-off-by: Guvenc Gulce <[email protected]>

Author: guvenc

feos/services/container-service/src/persistence/repository.rs

@@ -33,6 +33,16 @@ fn string_to_container_state(s: &str) -> Result<ContainerState, PersistenceError
     }
 }
 
+fn container_state_to_string(state: ContainerState) -> &'static str {
+    match state {
+        ContainerState::PullingImage => "PULLING_IMAGE",
+        ContainerState::Created => "CREATED",
+        ContainerState::Running => "RUNNING",
+        ContainerState::Stopped => "STOPPED",
+        ContainerState::Unspecified => "CONTAINER_STATE_UNSPECIFIED",
+    }
+}
+
 impl ContainerRepository {
     pub async fn connect(db_url: &str) -> Result<Self, PersistenceError> {
         let pool = SqlitePoolOptions::new()
@@ -111,7 +121,7 @@ impl ContainerRepository {
         let mut config_blob = Vec::new();
         container.config.encode(&mut config_blob)?;
 
-        let state_str = format!("{:?}", container.status.state).to_uppercase();
+        let state_str = container_state_to_string(container.status.state);
 
         sqlx::query(
             r#"
@@ -135,7 +145,7 @@ impl ContainerRepository {
         container_id: Uuid,
         new_state: ContainerState,
     ) -> Result<bool, PersistenceError> {
-        let state_str = format!("{new_state:?}").to_uppercase();
+        let state_str = container_state_to_string(new_state);
 
         let result = sqlx::query(
             r#"

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

@@ -24,6 +24,7 @@ pub mod worker;
 pub const DEFAULT_VM_DB_URL: &str = "sqlite:/var/lib/feos/vms.db";
 pub const VM_API_SOCKET_DIR: &str = "/tmp/feos/vm_api_sockets";
 pub const VM_CH_BIN: &str = "cloud-hypervisor";
+pub const CONT_YOUKI_BIN: &str = "youki";
 pub const IMAGE_DIR: &str = "/var/lib/feos/images";
 pub const VM_CONSOLE_DIR: &str = "/tmp/feos/consoles";
 

feos/tests/integration/container_tests.rs

@@ -0,0 +1,147 @@
+// SPDX-FileCopyrightText: 2023 SAP SE or an SAP affiliate company and IronCore contributors
+// SPDX-License-Identifier: Apache-2.0
+
+use super::{
+    ensure_server, get_public_clients, skip_if_youki_binary_missing, TEST_CONTAINER_IMAGE_REF,
+};
+use anyhow::Result;
+use feos_proto::container_service::{
+    ContainerConfig, ContainerState, CreateContainerRequest, DeleteContainerRequest,
+    GetContainerRequest, StartContainerRequest, StopContainerRequest,
+};
+use log::info;
+use std::time::Duration;
+use tokio::time::timeout;
+
+async fn wait_for_container_state(
+    client: &mut feos_proto::container_service::container_service_client::ContainerServiceClient<
+        tonic::transport::Channel,
+    >,
+    container_id: &str,
+    target_state: ContainerState,
+) -> Result<()> {
+    info!(
+        "Waiting for container {} to reach state {:?}",
+        container_id, target_state
+    );
+    for _ in 0..180 {
+        let response = client
+            .get_container(GetContainerRequest {
+                container_id: container_id.to_string(),
+            })
+            .await?
+            .into_inner();
+
+        let current_state = ContainerState::try_from(response.state).unwrap_or_default();
+        info!("Container {} is in state {:?}", container_id, current_state);
+
+        if current_state == target_state {
+            return Ok(());
+        }
+
+        tokio::time::sleep(Duration::from_secs(1)).await;
+    }
+    anyhow::bail!(
+        "Timeout waiting for container {} to reach state {:?}",
+        container_id,
+        target_state
+    );
+}
+
+#[tokio::test]
+async fn test_create_and_start_container() -> Result<()> {
+    if skip_if_youki_binary_missing() {
+        return Ok(());
+    }
+    ensure_server().await;
+    let (_, _, mut container_client) = get_public_clients().await?;
+
+    let image_ref = TEST_CONTAINER_IMAGE_REF.clone();
+    let container_config = ContainerConfig {
+        image_ref,
+        command: vec![],
+        env: Default::default(),
+    };
+
+    let create_req = CreateContainerRequest {
+        config: Some(container_config),
+        container_id: None,
+    };
+
+    info!("Sending CreateContainer request");
+    let create_res = container_client
+        .create_container(create_req)
+        .await?
+        .into_inner();
+    let container_id = create_res.container_id;
+    info!("Container creation initiated with ID: {}", container_id);
+
+    timeout(
+        Duration::from_secs(180),
+        wait_for_container_state(
+            &mut container_client,
+            &container_id,
+            ContainerState::Created,
+        ),
+    )
+    .await
+    .expect("Timed out waiting for container to become created")?;
+    info!("Container is in CREATED state");
+
+    let start_req = StartContainerRequest {
+        container_id: container_id.clone(),
+    };
+    info!("Sending StartContainer request for ID: {}", container_id);
+    container_client.start_container(start_req).await?;
+
+    timeout(
+        Duration::from_secs(30),
+        wait_for_container_state(
+            &mut container_client,
+            &container_id,
+            ContainerState::Running,
+        ),
+    )
+    .await
+    .expect("Timed out waiting for container to become running")?;
+    info!("Container is in RUNNING state");
+
+    let stop_req = StopContainerRequest {
+        container_id: container_id.clone(),
+        signal: None,
+        timeout_seconds: None,
+    };
+    info!("Sending StopContainer request for ID: {}", container_id);
+    container_client.stop_container(stop_req).await?;
+
+    timeout(
+        Duration::from_secs(30),
+        wait_for_container_state(
+            &mut container_client,
+            &container_id,
+            ContainerState::Stopped,
+        ),
+    )
+    .await
+    .expect("Timed out waiting for container to become stopped")?;
+    info!("Container is in STOPPED state");
+
+    let delete_req = DeleteContainerRequest {
+        container_id: container_id.clone(),
+    };
+    info!("Sending DeleteContainer request for ID: {}", container_id);
+    container_client.delete_container(delete_req).await?;
+    info!("DeleteContainer call successful");
+
+    let get_req = GetContainerRequest {
+        container_id: container_id.clone(),
+    };
+    let result = container_client.get_container(get_req).await;
+    assert!(result.is_err(), "GetContainer should fail after deletion");
+    info!(
+        "Verified that container {} is no longer found.",
+        container_id
+    );
+
+    Ok(())
+}

feos/tests/integration/host_tests.rs

@@ -14,7 +14,7 @@ use std::io::{BufRead, BufReader};
 #[tokio::test]
 async fn test_hostname_retrieval() -> Result<()> {
     ensure_server().await;
-    let (_, mut host_client) = get_public_clients().await?;
+    let (_, mut host_client, _) = get_public_clients().await?;
 
     let response = host_client.hostname(HostnameRequest {}).await?;
     let remote_hostname = response.into_inner().hostname;
@@ -37,7 +37,7 @@ async fn test_hostname_retrieval() -> Result<()> {
 #[tokio::test]
 async fn test_get_memory_info() -> Result<()> {
     ensure_server().await;
-    let (_, mut host_client) = get_public_clients().await?;
+    let (_, mut host_client, _) = get_public_clients().await?;
 
     let file = File::open("/proc/meminfo")?;
     let reader = BufReader::new(file);
@@ -85,7 +85,7 @@ async fn test_get_memory_info() -> Result<()> {
 #[tokio::test]
 async fn test_get_cpu_info() -> Result<()> {
     ensure_server().await;
-    let (_, mut host_client) = get_public_clients().await?;
+    let (_, mut host_client, _) = get_public_clients().await?;
 
     let file = File::open("/proc/cpuinfo")?;
     let reader = BufReader::new(file);
@@ -155,7 +155,7 @@ async fn test_get_cpu_info() -> Result<()> {
 #[tokio::test]
 async fn test_get_network_info() -> Result<()> {
     ensure_server().await;
-    let (_, mut host_client) = get_public_clients().await?;
+    let (_, mut host_client, _) = get_public_clients().await?;
 
     info!("Sending GetNetworkInfo request");
     let response = host_client

feos/tests/integration/mod.rs

@@ -3,13 +3,15 @@
 
 use anyhow::Result;
 use feos_proto::{
+    container_service::container_service_client::ContainerServiceClient,
     host_service::host_service_client::HostServiceClient,
     image_service::image_service_client::ImageServiceClient,
     vm_service::vm_service_client::VmServiceClient,
 };
 use hyper_util::rt::TokioIo;
 use image_service::IMAGE_SERVICE_SOCKET;
 use log::{error, info};
+use nix::sys::prctl;
 use once_cell::sync::{Lazy, OnceCell as SyncOnceCell};
 use std::env;
 use std::process::Command;
@@ -19,18 +21,24 @@ use tokio::net::UnixStream;
 use tokio::sync::OnceCell as TokioOnceCell;
 use tonic::transport::{Channel, Endpoint, Uri};
 use tower::service_fn;
-use vm_service::VM_CH_BIN;
+use vm_service::{CONT_YOUKI_BIN, VM_CH_BIN};
 
+pub mod container_tests;
 pub mod fixtures;
 pub mod host_tests;
 pub mod image_tests;
 pub mod vm_tests;
 
 pub const PUBLIC_SERVER_ADDRESS: &str = "http://[::1]:1337";
 pub const DEFAULT_TEST_IMAGE_REF: &str = "ghcr.io/ironcore-dev/os-images/gardenlinux-ch-dev";
+pub const DEFAULT_TEST_CONTAINER_IMAGE_REF: &str = "ghcr.io/appvia/hello-world/hello-world";
 
 pub static TEST_IMAGE_REF: Lazy<String> =
     Lazy::new(|| env::var("TEST_IMAGE_REF").unwrap_or_else(|_| DEFAULT_TEST_IMAGE_REF.to_string()));
+pub static TEST_CONTAINER_IMAGE_REF: Lazy<String> = Lazy::new(|| {
+    env::var("TEST_CONTAINER_IMAGE_REF")
+        .unwrap_or_else(|_| DEFAULT_TEST_CONTAINER_IMAGE_REF.to_string())
+});
 
 static SERVER_RUNTIME: TokioOnceCell<Arc<tokio::runtime::Runtime>> = TokioOnceCell::const_new();
 static TEMP_DIR_GUARD: SyncOnceCell<tempfile::TempDir> = SyncOnceCell::new();
@@ -51,9 +59,23 @@ async fn setup_server() -> Arc<tokio::runtime::Runtime> {
 
     let db_path = temp_dir.path().join("vms.db");
     let db_url = format!("sqlite:{}", db_path.to_str().unwrap());
+    let container_db_path = temp_dir.path().join("containers.db");
+    let container_db_url = format!("sqlite:{}", container_db_path.to_str().unwrap());
 
     env::set_var("DATABASE_URL", &db_url);
+    env::set_var("CONTAINER_DATABASE_URL", &container_db_url);
     info!("Using temporary database for tests: {}", db_url);
+    info!(
+        "Using temporary container database for tests: {}",
+        container_db_url
+    );
+
+    if let Err(e) = prctl::set_child_subreaper(true) {
+        log::error!(
+            "Failed to set as child subreaper, container tests will fail: {}",
+            e
+        );
+    }
 
     let runtime = tokio::runtime::Builder::new_multi_thread()
         .enable_all()
@@ -82,11 +104,15 @@ async fn setup_server() -> Arc<tokio::runtime::Runtime> {
     panic!("Server did not start in time.");
 }
 
-pub async fn get_public_clients() -> Result<(VmServiceClient<Channel>, HostServiceClient<Channel>)>
-{
+pub async fn get_public_clients() -> Result<(
+    VmServiceClient<Channel>,
+    HostServiceClient<Channel>,
+    ContainerServiceClient<Channel>,
+)> {
     let vm_client = VmServiceClient::connect(PUBLIC_SERVER_ADDRESS).await?;
     let host_client = HostServiceClient::connect(PUBLIC_SERVER_ADDRESS).await?;
-    Ok((vm_client, host_client))
+    let container_client = ContainerServiceClient::connect(PUBLIC_SERVER_ADDRESS).await?;
+    Ok((vm_client, host_client, container_client))
 }
 
 pub async fn get_image_service_client() -> Result<ImageServiceClient<Channel>> {
@@ -119,3 +145,22 @@ pub fn skip_if_ch_binary_missing() -> bool {
     }
     false
 }
+
+pub fn check_youki_binary() -> bool {
+    Command::new("which")
+        .arg(CONT_YOUKI_BIN)
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false)
+}
+
+pub fn skip_if_youki_binary_missing() -> bool {
+    if !check_youki_binary() {
+        log::warn!(
+            "Skipping test because '{}' binary was not found in PATH.",
+            VM_CH_BIN
+        );
+        return true;
+    }
+    false
+}

feos/tests/integration/vm_tests.rs

@@ -24,7 +24,7 @@ async fn test_create_and_start_vm() -> Result<()> {
     }
 
     ensure_server().await;
-    let (mut vm_client, _) = get_public_clients().await?;
+    let (mut vm_client, _, _) = get_public_clients().await?;
 
     let image_ref = TEST_IMAGE_REF.clone();
     let vm_config = VmConfig {
@@ -305,7 +305,7 @@ async fn test_vm_healthcheck_and_crash_recovery() -> Result<()> {
     }
 
     ensure_server().await;
-    let (mut vm_client, _) = get_public_clients().await?;
+    let (mut vm_client, _, _) = get_public_clients().await?;
 
     let image_ref = TEST_IMAGE_REF.clone();
     let vm_config = VmConfig {