feat: implement kernel / initrd oci image support (#103)

* feat: implement kernel / initrd oci image support

* fix: implement image urls more faithfully

crates/ctl/src/cli/launch.rs

@@ -64,6 +64,10 @@ pub struct LauchCommand {
         help = "Wait for the guest to start, implied by --attach"
     )]
     wait: bool,
+    #[arg(short = 'k', long, help = "OCI kernel image for guest to use")]
+    kernel: Option<String>,
+    #[arg(short = 'I', long, help = "OCI initrd image for guest to use")]
+    initrd: Option<String>,
     #[arg(help = "Container image for guest to use")]
     oci: String,
     #[arg(
@@ -80,27 +84,41 @@ impl LauchCommand {
         mut client: ControlServiceClient<Channel>,
         events: EventStream,
     ) -> Result<()> {
-        let response = client
-            .pull_image(PullImageRequest {
-                image: self.oci.clone(),
-                format: match self.image_format {
-                    LaunchImageFormat::Squashfs => OciImageFormat::Squashfs.into(),
-                    LaunchImageFormat::Erofs => OciImageFormat::Erofs.into(),
+        let image = self
+            .pull_image(
+                &mut client,
+                &self.oci,
+                match self.image_format {
+                    LaunchImageFormat::Squashfs => OciImageFormat::Squashfs,
+                    LaunchImageFormat::Erofs => OciImageFormat::Erofs,
                 },
-                overwrite_cache: self.pull_overwrite_cache,
-            })
+            )
             .await?;
-        let reply = pull_interactive_progress(response.into_inner()).await?;
+
+        let kernel = if let Some(ref kernel) = self.kernel {
+            let kernel_image = self
+                .pull_image(&mut client, kernel, OciImageFormat::Tar)
+                .await?;
+            Some(kernel_image)
+        } else {
+            None
+        };
+
+        let initrd = if let Some(ref initrd) = self.initrd {
+            let kernel_image = self
+                .pull_image(&mut client, initrd, OciImageFormat::Tar)
+                .await?;
+            Some(kernel_image)
+        } else {
+            None
+        };
 
         let request = CreateGuestRequest {
             spec: Some(GuestSpec {
                 name: self.name.unwrap_or_default(),
-                image: Some(GuestImageSpec {
-                    image: Some(Image::Oci(GuestOciImageSpec {
-                        digest: reply.digest,
-                        format: reply.format,
-                    })),
-                }),
+                image: Some(image),
+                kernel,
+                initrd,
                 vcpus: self.cpus,
                 mem: self.mem,
                 task: Some(GuestTaskSpec {
@@ -146,6 +164,28 @@ impl LauchCommand {
         StdioConsoleStream::restore_terminal_mode();
         std::process::exit(code.unwrap_or(0));
     }
+
+    async fn pull_image(
+        &self,
+        client: &mut ControlServiceClient<Channel>,
+        image: &str,
+        format: OciImageFormat,
+    ) -> Result<GuestImageSpec> {
+        let response = client
+            .pull_image(PullImageRequest {
+                image: image.to_string(),
+                format: format.into(),
+                overwrite_cache: self.pull_overwrite_cache,
+            })
+            .await?;
+        let reply = pull_interactive_progress(response.into_inner()).await?;
+        Ok(GuestImageSpec {
+            image: Some(Image::Oci(GuestOciImageSpec {
+                digest: reply.digest,
+                format: reply.format,
+            })),
+        })
+    }
 }
 
 async fn wait_guest_started(id: &str, events: EventStream) -> Result<()> {

crates/daemon/Cargo.toml

@@ -27,6 +27,7 @@ scopeguard = { workspace = true }
 signal-hook = { workspace = true }
 tokio = { workspace = true }
 tokio-stream = { workspace = true }
+krata-tokio-tar = { workspace = true }
 tonic = { workspace = true, features = ["tls"] }
 uuid = { workspace = true }
 

crates/daemon/src/control.rs

@@ -378,7 +378,7 @@ impl ControlService for DaemonControlService {
                             format: match packed.format {
                                 OciPackedFormat::Squashfs => OciImageFormat::Squashfs.into(),
                                 OciPackedFormat::Erofs => OciImageFormat::Erofs.into(),
-                                _ => OciImageFormat::Unknown.into(),
+                                OciPackedFormat::Tar => OciImageFormat::Tar.into(),
                             },
                         };
                         yield reply;

crates/daemon/src/lib.rs

@@ -1,6 +1,6 @@
 use std::{net::SocketAddr, path::PathBuf, str::FromStr};
 
-use anyhow::Result;
+use anyhow::{anyhow, Result};
 use console::{DaemonConsole, DaemonConsoleHandle};
 use control::DaemonControlService;
 use db::GuestStore;
@@ -74,9 +74,11 @@ impl Daemon {
             generated
         };
 
-        let packer = OciPackerService::new(None, &image_cache_dir, OciPlatform::current()).await?;
+        let initrd_path = detect_guest_file(&store, "initrd")?;
+        let kernel_path = detect_guest_file(&store, "kernel")?;
 
-        let runtime = Runtime::new(store.clone()).await?;
+        let packer = OciPackerService::new(None, &image_cache_dir, OciPlatform::current()).await?;
+        let runtime = Runtime::new().await?;
         let glt = GuestLookupTable::new(0, host_uuid);
         let guests_db_path = format!("{}/guests.db", store);
         let guests = GuestStore::open(&PathBuf::from(guests_db_path))?;
@@ -97,6 +99,8 @@ impl Daemon {
             runtime_for_reconciler,
             packer.clone(),
             guest_reconciler_notify.clone(),
+            kernel_path,
+            initrd_path,
         )?;
 
         let guest_reconciler_task = guest_reconciler.launch(guest_reconciler_receiver).await?;
@@ -181,3 +185,16 @@ impl Drop for Daemon {
         self.generator_task.abort();
     }
 }
+
+fn detect_guest_file(store: &str, name: &str) -> Result<PathBuf> {
+    let mut path = PathBuf::from(format!("{}/guest/{}", store, name));
+    if path.is_file() {
+        return Ok(path);
+    }
+
+    path = PathBuf::from(format!("/usr/share/krata/guest/{}", name));
+    if path.is_file() {
+        return Ok(path);
+    }
+    Err(anyhow!("unable to find required guest file: {}", name))
+}

crates/daemon/src/reconcile/guest.rs → crates/daemon/src/reconcile/guest/mod.rs

@@ -1,20 +1,17 @@
 use std::{
     collections::{hash_map::Entry, HashMap},
+    path::PathBuf,
     sync::Arc,
     time::Duration,
 };
 
-use anyhow::{anyhow, Result};
-use krata::launchcfg::LaunchPackedFormat;
+use anyhow::Result;
 use krata::v1::{
-    common::{
-        guest_image_spec::Image, Guest, GuestErrorInfo, GuestExitInfo, GuestNetworkState,
-        GuestState, GuestStatus, OciImageFormat,
-    },
+    common::{Guest, GuestErrorInfo, GuestExitInfo, GuestNetworkState, GuestState, GuestStatus},
     control::GuestChangedEvent,
 };
-use krataoci::packer::{service::OciPackerService, OciPackedFormat};
-use kratart::{launch::GuestLaunchRequest, GuestInfo, Runtime};
+use krataoci::packer::service::OciPackerService;
+use kratart::{GuestInfo, Runtime};
 use log::{error, info, trace, warn};
 use tokio::{
     select,
@@ -33,6 +30,10 @@ use crate::{
     glt::GuestLookupTable,
 };
 
+use self::start::GuestStarter;
+
+mod start;
+
 const PARALLEL_LIMIT: u32 = 5;
 
 #[derive(Debug)]
@@ -59,26 +60,33 @@ pub struct GuestReconciler {
     events: DaemonEventContext,
     runtime: Runtime,
     packer: OciPackerService,
+    kernel_path: PathBuf,
+    initrd_path: PathBuf,
     tasks: Arc<Mutex<HashMap<Uuid, GuestReconcilerEntry>>>,
     guest_reconciler_notify: Sender<Uuid>,
     reconcile_lock: Arc<RwLock<()>>,
 }
 
 impl GuestReconciler {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         glt: GuestLookupTable,
         guests: GuestStore,
         events: DaemonEventContext,
         runtime: Runtime,
         packer: OciPackerService,
         guest_reconciler_notify: Sender<Uuid>,
+        kernel_path: PathBuf,
+        initrd_path: PathBuf,
     ) -> Result<Self> {
         Ok(Self {
             glt,
             guests,
             events,
             runtime,
             packer,
+            kernel_path,
+            initrd_path,
             tasks: Arc::new(Mutex::new(HashMap::new())),
             guest_reconciler_notify,
             reconcile_lock: Arc::new(RwLock::with_max_readers((), PARALLEL_LIMIT)),
@@ -246,76 +254,14 @@ impl GuestReconciler {
     }
 
     async fn start(&self, uuid: Uuid, guest: &mut Guest) -> Result<GuestReconcilerResult> {
-        let Some(ref spec) = guest.spec else {
-            return Err(anyhow!("guest spec not specified"));
-        };
-
-        let Some(ref image) = spec.image else {
-            return Err(anyhow!("image spec not provided"));
+        let starter = GuestStarter {
+            kernel_path: &self.kernel_path,
+            initrd_path: &self.initrd_path,
+            packer: &self.packer,
+            glt: &self.glt,
+            runtime: &self.runtime,
         };
-        let oci = match image.image {
-            Some(Image::Oci(ref oci)) => oci,
-            None => {
-                return Err(anyhow!("oci spec not specified"));
-            }
-        };
-        let task = spec.task.as_ref().cloned().unwrap_or_default();
-
-        let image = self
-            .packer
-            .recall(
-                &oci.digest,
-                match oci.format() {
-                    OciImageFormat::Unknown => OciPackedFormat::Squashfs,
-                    OciImageFormat::Squashfs => OciPackedFormat::Squashfs,
-                    OciImageFormat::Erofs => OciPackedFormat::Erofs,
-                    OciImageFormat::Tar => {
-                        return Err(anyhow!("tar image format is not supported for guests"));
-                    }
-                },
-            )
-            .await?;
-
-        let Some(image) = image else {
-            return Err(anyhow!(
-                "image {} in the requested format did not exist",
-                oci.digest
-            ));
-        };
-
-        let info = self
-            .runtime
-            .launch(GuestLaunchRequest {
-                format: LaunchPackedFormat::Squashfs,
-                uuid: Some(uuid),
-                name: if spec.name.is_empty() {
-                    None
-                } else {
-                    Some(spec.name.clone())
-                },
-                image,
-                vcpus: spec.vcpus,
-                mem: spec.mem,
-                env: task
-                    .environment
-                    .iter()
-                    .map(|x| (x.key.clone(), x.value.clone()))
-                    .collect::<HashMap<_, _>>(),
-                run: empty_vec_optional(task.command.clone()),
-                debug: false,
-            })
-            .await?;
-        self.glt.associate(uuid, info.domid).await;
-        info!("started guest {}", uuid);
-        guest.state = Some(GuestState {
-            status: GuestStatus::Started.into(),
-            network: Some(guestinfo_to_networkstate(&info)),
-            exit_info: None,
-            error_info: None,
-            host: self.glt.host_uuid().to_string(),
-            domid: info.domid,
-        });
-        Ok(GuestReconcilerResult::Changed { rerun: false })
+        starter.start(uuid, guest).await
     }
 
     async fn exited(&self, guest: &mut Guest) -> Result<GuestReconcilerResult> {
@@ -390,15 +336,7 @@ impl GuestReconciler {
     }
 }
 
-fn empty_vec_optional<T>(value: Vec<T>) -> Option<Vec<T>> {
-    if value.is_empty() {
-        None
-    } else {
-        Some(value)
-    }
-}
-
-fn guestinfo_to_networkstate(info: &GuestInfo) -> GuestNetworkState {
+pub fn guestinfo_to_networkstate(info: &GuestInfo) -> GuestNetworkState {
     GuestNetworkState {
         guest_ipv4: info.guest_ipv4.map(|x| x.to_string()).unwrap_or_default(),
         guest_ipv6: info.guest_ipv6.map(|x| x.to_string()).unwrap_or_default(),