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

* feat: implement kernel / initrd oci image support

* fix: implement image urls more faithfully

crates/runtime/src/launch.rs

@@ -23,6 +23,8 @@ use super::{GuestInfo, GuestState};
 
 pub struct GuestLaunchRequest {
     pub format: LaunchPackedFormat,
+    pub kernel: Vec<u8>,
+    pub initrd: Vec<u8>,
     pub uuid: Option<Uuid>,
     pub name: Option<String>,
     pub vcpus: u32,
@@ -173,22 +175,22 @@ impl GuestLauncher {
 
         let config = DomainConfig {
             backend_domid: 0,
-            name: &xen_name,
+            name: xen_name,
             max_vcpus: request.vcpus,
             mem_mb: request.mem,
-            kernel_path: &context.kernel,
-            initrd_path: &context.initrd,
-            cmdline: &cmdline,
-            use_console_backend: Some("krata-console"),
+            kernel: request.kernel,
+            initrd: request.initrd,
+            cmdline,
+            use_console_backend: Some("krata-console".to_string()),
             disks: vec![
                 DomainDisk {
-                    vdev: "xvda",
-                    block: &image_squashfs_loop,
+                    vdev: "xvda".to_string(),
+                    block: image_squashfs_loop.clone(),
                     writable: false,
                 },
                 DomainDisk {
-                    vdev: "xvdb",
-                    block: &cfgblk_squashfs_loop,
+                    vdev: "xvdb".to_string(),
+                    block: cfgblk_squashfs_loop.clone(),
                     writable: false,
                 },
             ],
@@ -197,7 +199,7 @@ impl GuestLauncher {
                 initialized: false,
             }],
             vifs: vec![DomainNetworkInterface {
-                mac: &guest_mac_string,
+                mac: guest_mac_string.clone(),
                 mtu: 1500,
                 bridge: None,
                 script: None,

crates/runtime/src/lib.rs

@@ -1,9 +1,4 @@
-use std::{
-    fs,
-    path::{Path, PathBuf},
-    str::FromStr,
-    sync::Arc,
-};
+use std::{fs, path::PathBuf, str::FromStr, sync::Arc};
 
 use anyhow::{anyhow, Result};
 use ipnetwork::IpNetwork;
@@ -52,43 +47,17 @@ pub struct GuestInfo {
 pub struct RuntimeContext {
     pub autoloop: AutoLoop,
     pub xen: XenClient,
-    pub kernel: String,
-    pub initrd: String,
 }
 
 impl RuntimeContext {
-    pub async fn new(store: String) -> Result<Self> {
-        let mut image_cache_path = PathBuf::from(&store);
-        image_cache_path.push("cache");
-        fs::create_dir_all(&image_cache_path)?;
-
+    pub async fn new() -> Result<Self> {
         let xen = XenClient::open(0).await?;
-        image_cache_path.push("image");
-        fs::create_dir_all(&image_cache_path)?;
-        let kernel = RuntimeContext::detect_guest_file(&store, "kernel")?;
-        let initrd = RuntimeContext::detect_guest_file(&store, "initrd")?;
-
         Ok(RuntimeContext {
             autoloop: AutoLoop::new(LoopControl::open()?),
             xen,
-            kernel,
-            initrd,
         })
     }
 
-    fn detect_guest_file(store: &str, name: &str) -> Result<String> {
-        let mut path = PathBuf::from(format!("{}/guest/{}", store, name));
-        if path.is_file() {
-            return path_as_string(&path);
-        }
-
-        path = PathBuf::from(format!("/usr/share/krata/guest/{}", name));
-        if path.is_file() {
-            return path_as_string(&path);
-        }
-        Err(anyhow!("unable to find required guest file: {}", name))
-    }
-
     pub async fn list(&self) -> Result<Vec<GuestInfo>> {
         let mut guests: Vec<GuestInfo> = Vec::new();
         for domid_candidate in self.xen.store.list("/local/domain").await? {
@@ -248,16 +217,14 @@ impl RuntimeContext {
 
 #[derive(Clone)]
 pub struct Runtime {
-    store: Arc<String>,
     context: RuntimeContext,
     launch_semaphore: Arc<Semaphore>,
 }
 
 impl Runtime {
-    pub async fn new(store: String) -> Result<Self> {
-        let context = RuntimeContext::new(store.clone()).await?;
+    pub async fn new() -> Result<Self> {
+        let context = RuntimeContext::new().await?;
         Ok(Self {
-            store: Arc::new(store),
             context,
             launch_semaphore: Arc::new(Semaphore::new(1)),
         })
@@ -320,12 +287,6 @@ impl Runtime {
     }
 
     pub async fn dupe(&self) -> Result<Runtime> {
-        Runtime::new((*self.store).clone()).await
+        Runtime::new().await
     }
 }
-
-fn path_as_string(path: &Path) -> Result<String> {
-    path.to_str()
-        .ok_or_else(|| anyhow!("unable to convert path to string"))
-        .map(|x| x.to_string())
-}