Implement Container Service

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

Author: guvenc

Cargo.lock

@@ -5,6 +5,7 @@ members = [
     "feos/services/host-service",
     "feos/services/image-service",
     "feos/services/task-service",
+    "feos/services/container-service",
     "cli",
     "feos/proto",
     "feos/utils",

Cargo.toml

@@ -0,0 +1,233 @@
+// SPDX-FileCopyrightText: 2023 SAP SE or an SAP affiliate company and IronCore contributors
+// SPDX-License-Identifier: Apache-2.0
+
+use anyhow::{Context, Result};
+use clap::{Args, Subcommand};
+use feos_proto::container_service::{
+    container_service_client::ContainerServiceClient, ContainerConfig, ContainerState,
+    CreateContainerRequest, DeleteContainerRequest, GetContainerRequest, ListContainersRequest,
+    StartContainerRequest, StopContainerRequest,
+};
+use tonic::transport::Channel;
+
+#[derive(Args, Debug)]
+pub struct ContainerArgs {
+    #[arg(
+        short,
+        long,
+        global = true,
+        env = "FEOS_ADDRESS",
+        default_value = "http://[::1]:1337"
+    )]
+    pub address: String,
+
+    #[command(subcommand)]
+    command: ContainerCommand,
+}
+
+#[derive(Subcommand, Debug)]
+pub enum ContainerCommand {
+    /// Create a new container
+    Create {
+        #[arg(
+            long,
+            required = true,
+            help = "Container image reference (e.g., docker.io/library/alpine:latest)"
+        )]
+        image_ref: String,
+
+        #[arg(long, help = "Optional custom container identifier (UUID)")]
+        id: Option<String>,
+
+        #[arg(
+            long,
+            help = "Override the default command of the image",
+            num_args = 1..,
+            value_delimiter = ' '
+        )]
+        cmd: Vec<String>,
+
+        #[arg(
+            long,
+            help = "Set environment variables (e.g., --env KEY1=VALUE1 --env KEY2=VALUE2)",
+            value_parser = parse_key_val
+        )]
+        env: Vec<(String, String)>,
+    },
+    /// Start a created container
+    Start {
+        #[arg(required = true, help = "Container identifier")]
+        id: String,
+    },
+    /// Stop a running container
+    Stop {
+        #[arg(required = true, help = "Container identifier")]
+        id: String,
+    },
+    /// Get detailed information about a container
+    Info {
+        #[arg(required = true, help = "Container identifier")]
+        id: String,
+    },
+    /// List all containers
+    List,
+    /// Delete a container
+    Delete {
+        #[arg(required = true, help = "Container identifier")]
+        id: String,
+    },
+}
+
+fn parse_key_val(s: &str) -> Result<(String, String), String> {
+    s.split_once('=')
+        .map(|(key, value)| (key.to_string(), value.to_string()))
+        .ok_or_else(|| format!("invalid KEY=value format: {}", s))
+}
+
+pub async fn handle_container_command(args: ContainerArgs) -> Result<()> {
+    let mut client = ContainerServiceClient::connect(args.address)
+        .await
+        .context("Failed to connect to container service")?;
+
+    match args.command {
+        ContainerCommand::Create {
+            image_ref,
+            id,
+            cmd,
+            env,
+        } => create_container(&mut client, image_ref, id, cmd, env).await?,
+        ContainerCommand::Start { id } => start_container(&mut client, id).await?,
+        ContainerCommand::Stop { id } => stop_container(&mut client, id).await?,
+        ContainerCommand::Info { id } => get_container_info(&mut client, id).await?,
+        ContainerCommand::List => list_containers(&mut client).await?,
+        ContainerCommand::Delete { id } => delete_container(&mut client, id).await?,
+    }
+
+    Ok(())
+}
+
+async fn create_container(
+    client: &mut ContainerServiceClient<Channel>,
+    image_ref: String,
+    id: Option<String>,
+    cmd: Vec<String>,
+    env: Vec<(String, String)>,
+) -> Result<()> {
+    println!("Requesting container creation with image: {}...", image_ref);
+
+    let config = ContainerConfig {
+        image_ref,
+        command: cmd,
+        env: env.into_iter().collect(),
+    };
+
+    let request = CreateContainerRequest {
+        config: Some(config),
+        container_id: id,
+    };
+
+    let response = client.create_container(request).await?.into_inner();
+    println!(
+        "Container creation initiated. Container ID: {}",
+        response.container_id
+    );
+    println!(
+        "Use 'feos-cli container list' to check its status and 'feos-cli container start {}' to run it.",
+        response.container_id
+    );
+
+    Ok(())
+}
+
+async fn start_container(client: &mut ContainerServiceClient<Channel>, id: String) -> Result<()> {
+    println!("Requesting to start container: {}...", id);
+    let request = StartContainerRequest {
+        container_id: id.clone(),
+    };
+    client.start_container(request).await?;
+    println!("Start request sent for container: {}", id);
+    Ok(())
+}
+
+async fn stop_container(client: &mut ContainerServiceClient<Channel>, id: String) -> Result<()> {
+    println!("Requesting to stop container: {}...", id);
+    let request = StopContainerRequest {
+        container_id: id.clone(),
+        ..Default::default()
+    };
+    client.stop_container(request).await?;
+    println!("Stop request sent for container: {}", id);
+    Ok(())
+}
+
+async fn get_container_info(
+    client: &mut ContainerServiceClient<Channel>,
+    id: String,
+) -> Result<()> {
+    let request = GetContainerRequest {
+        container_id: id.clone(),
+    };
+    let response = client.get_container(request).await?.into_inner();
+
+    println!("Container Info for: {}", id);
+    println!(
+        "  State: {:?}",
+        ContainerState::try_from(response.state).unwrap_or(ContainerState::Unspecified)
+    );
+    if let Some(pid) = response.pid {
+        println!("  PID: {}", pid);
+    }
+    if let Some(exit_code) = response.exit_code {
+        println!("  Exit Code: {}", exit_code);
+    }
+    if let Some(config) = response.config {
+        println!("  Config:");
+        println!("    Image Ref: {}", config.image_ref);
+        if !config.command.is_empty() {
+            println!("    Command: {:?}", config.command);
+        }
+        if !config.env.is_empty() {
+            println!("    Env: {:?}", config.env);
+        }
+    }
+
+    Ok(())
+}
+
+async fn list_containers(client: &mut ContainerServiceClient<Channel>) -> Result<()> {
+    let request = ListContainersRequest {};
+    let response = client.list_containers(request).await?.into_inner();
+
+    if response.containers.is_empty() {
+        println!("No containers found.");
+        return Ok(());
+    }
+
+    println!("{:<38} {:<15} IMAGE_REF", "CONTAINER_ID", "STATE");
+    println!("{:-<38} {:-<15} {:-<40}", "", "", "");
+    for container in response.containers {
+        let state =
+            ContainerState::try_from(container.state).unwrap_or(ContainerState::Unspecified);
+        let image_ref = container
+            .config
+            .map(|c| c.image_ref)
+            .unwrap_or_else(|| "N/A".to_string());
+        println!(
+            "{:<38} {:<15} {}",
+            container.container_id,
+            format!("{:?}", state),
+            image_ref
+        );
+    }
+    Ok(())
+}
+
+async fn delete_container(client: &mut ContainerServiceClient<Channel>, id: String) -> Result<()> {
+    println!("Requesting to delete container: {}...", id);
+    let request = DeleteContainerRequest {
+        container_id: id.clone(),
+    };
+    client.delete_container(request).await?;
+    println!("Successfully deleted container: {}", id);
+    Ok(())
+}

cli/src/container_commands.rs

@@ -4,6 +4,7 @@
 use anyhow::Result;
 use clap::{Parser, Subcommand};
 
+mod container_commands;
 mod host_commands;
 mod image_commands;
 mod vm_commands;
@@ -20,6 +21,7 @@ enum Service {
     Vm(vm_commands::VmArgs),
     Host(host_commands::HostArgs),
     Image(image_commands::ImageArgs),
+    Container(container_commands::ContainerArgs),
 }
 
 #[tokio::main]
@@ -35,6 +37,7 @@ async fn main() -> Result<()> {
         Service::Vm(args) => vm_commands::handle_vm_command(args).await?,
         Service::Host(args) => host_commands::handle_host_command(args).await?,
         Service::Image(args) => image_commands::handle_image_command(args).await?,
+        Service::Container(args) => container_commands::handle_container_command(args).await?,
     }
 
     Ok(())

cli/src/main.rs

@@ -17,6 +17,7 @@ vm-service = { path = "services/vm-service" }
 host-service = { path = "services/host-service" }
 image-service = { path = "services/image-service" }
 task-service = { path = "services/task-service" }
+container-service = { path = "services/container-service" }
 feos-proto = { workspace = true }
 
 # Workspace dependencies

feos/Cargo.toml

@@ -13,3 +13,6 @@ pub mod image_service {
 pub mod task_service {
     tonic::include_proto!("feos.task.v1");
 }
+pub mod container_service {
+    tonic::include_proto!("feos.container.v1");
+}

feos/proto/src/lib.rs

@@ -0,0 +1,30 @@
+[package]
+name = "container-service"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+feos-proto = { workspace = true }
+image-service = { path = "../image-service" }
+task-service = { path = "../task-service" }
+sqlx = { version = "0.7", features = ["runtime-tokio-rustls", "sqlite", "macros", "uuid"] }
+serde = { workspace = true }
+serde_json = { workspace = true }
+hyper-util = { workspace = true }
+tower = { workspace = true }
+
+# Workspace dependencies
+tokio = { workspace = true }
+tokio-stream = { workspace = true }
+tonic = { workspace = true }
+anyhow = { workspace = true }
+prost = { workspace = true }
+prost-types = { workspace = true }
+nix = { workspace = true }
+uuid = { workspace = true }
+log = { workspace = true }
+thiserror = { workspace = true }
+hyper = { workspace = true }
+
+[build-dependencies]
+sqlx = { version = "0.7", features = ["runtime-tokio-rustls", "sqlite", "macros", "uuid"] }

feos/services/container-service/Cargo.toml

@@ -0,0 +1,7 @@
+// SPDX-FileCopyrightText: 2023 SAP SE or an SAP affiliate company and IronCore contributors
+// SPDX-License-Identifier: Apache-2.0
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("cargo:rustc-env=SQLX_OFFLINE=true");
+    Ok(())
+}

feos/services/container-service/build.rs

@@ -0,0 +1,19 @@
+-- SPDX-FileCopyrightText: 2023 SAP SE or an SAP affiliate company and IronCore contributors
+-- SPDX-License-Identifier: Apache-2.0
+
+CREATE TABLE IF NOT EXISTS containers (
+    container_id TEXT PRIMARY KEY NOT NULL,
+    image_uuid TEXT NOT NULL,
+    state TEXT NOT NULL,
+    pid INTEGER,
+    config_blob BLOB NOT NULL,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL
+);
+
+CREATE TRIGGER IF NOT EXISTS trigger_containers_updated_at
+AFTER UPDATE ON containers
+FOR EACH ROW
+BEGIN
+    UPDATE containers SET updated_at = CURRENT_TIMESTAMP WHERE container_id = OLD.container_id;
+END;