wip

Author: leofvo

src/quardle/mod.rs

@@ -1,24 +1,21 @@
-use std::fs::{File, create_dir_all, remove_dir_all, metadata};
+use std::fs::{File, create_dir_all, remove_dir_all};
 use flate2::Compression;
 use flate2::write::GzEncoder;
 use serde::{Deserialize, Serialize};
 use serde_json;
+use std::process::Command;
 
 /// Constances declarations
-const QUARDLE_BUILD_DIR: &str = "/tmp/quark/builds/";
-const QUARDLE_KERNEL: &str = "linux-config-x86_64";
-const QUARDLE_INITRD: &str = "quarkfs/";
+const QUARK_BUILD_DIR: &str = "/tmp/quark/builds/";
+const QUARK_CONFIG_DIR: &str = "/opt/quark/";
+
+const QUARDLE_KERNEL: &str = "bzImage";
+const QUARDLE_INITRD: &str = "rootfs/";
 const QUARDLE_KERNEL_CMDLINE: &str = "/proc/cmdline";
 
 /// Containers related errors
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
-    #[error("Error when building quardle")]
-    Build(String),
-    #[error("Unable to instanciate quardle")]
-    New(String),
-    #[error("Error when deleting quardle")]
-    Delete(String),
 }
 
 /// A common result type for our module.
@@ -47,11 +44,20 @@ impl Quardle {
     /// Build a quardle from instance variables
     /// If delete is true, delete the quardle after building
     pub fn build(&self, delete_after: Option<bool>) -> Result<()> {
-      
+        // creating working directory
+        create_dir_all(self.clone().get_work_dir()).unwrap();
+
+        self
+            .setup()
+            .add_kernel()
+            .add_init_rd()
+            .add_kaps();
+        self.generate_config_file()?;
+
         self.generate_archive()?;
 
         if delete_after.unwrap_or(false) {
-            self.delete()?;
+            self.delete();
         }
 
         Ok(())
@@ -61,28 +67,155 @@ impl Quardle {
     /// Temp files used to create quardle are created at /tmp/quark/builds/<quardle_name>/
     pub fn new(name: String, container_image_url: String, offline: bool) -> Option<Self> {
         let quardle = Quardle {name, container_image_url, offline};
-        create_dir_all(quardle.clone().get_work_dir()).unwrap();
         Some(quardle)
     }
 
     /// Delete all temporary files used to create quardle are created at /tmp/quark/builds/<quardle_name>/
-    pub fn delete(&self) -> Result<()> {
+    pub fn delete(&self) -> &Quardle {
         remove_dir_all(self.clone().get_work_dir()).unwrap();
-        Ok(())
+        self
     }
 
     /// Return the path to the quardle working directory
     /// /tmp/quark/builds/<quardle_name>/
     /// Used to create temporary files
     fn get_work_dir(self) -> String {
-        format!("{}{}/", QUARDLE_BUILD_DIR, self.name)
+        format!("{}{}/", QUARK_BUILD_DIR, self.name)
+    }
+
+    /// Setup default quark configuration 
+    /// Create a `quark` directory in /opt
+    fn setup(&self) -> &Quardle {
+        // Create the quark configuration directory
+        if !std::path::Path::new(&format!("{}", QUARK_CONFIG_DIR)).exists() {
+            println!("Quark configuration directory does not exist, creating it !");
+            Command::new("mkdir")
+                .arg("/opt/quark")
+                .output()
+                .expect("failed to setup quark");
+        }
+
+        // Install kaps sources
+        if !std::path::Path::new(&format!("{}kaps", QUARK_CONFIG_DIR)).exists() {
+            println!("Kaps not found, installing it !");
+            Command::new("git")
+                .args(["clone", "https://github.com/virt-do/kaps.git"]) // Using https protocol because it seems not supporting ssh
+                .current_dir(format!("{}", QUARK_CONFIG_DIR))
+                .output()
+                .expect("failed to fetch kaps");
+        }
+
+        // Install a default kernel configuration file
+        if !std::path::Path::new(&format!("{}linux-config-x86_64", QUARK_CONFIG_DIR)).exists() {
+            println!("Kernel config file not found, installing it !");
+            Command::new("curl")
+                .arg("https://raw.githubusercontent.com/virt-do/lab/main/do-vmm/kernel/linux-config-x86_64")
+                .arg("-O") 
+                .current_dir(format!("{}", QUARK_CONFIG_DIR))
+                .output()
+                .expect("failed to fetch kernel config file");
+        }
+
+        // Install a script to build kernel
+        if !std::path::Path::new(&format!("{}kernel", QUARK_CONFIG_DIR)).exists() {
+            println!("Kernel not found, installing and building it !");
+            Command::new("git")
+                .arg("clone")
+                .args(["--depth", "1"]) 
+                .arg("https://github.com/cloud-hypervisor/linux.git") // Using https protocol because it seems not supporting ssh
+                .args(["-b", "ch-5.14"])
+                .arg("kernel") 
+                .current_dir(format!("{}", QUARK_CONFIG_DIR))
+                .output()
+                .expect("failed to download kernel builder");
+            // Use our config file
+            Command::new("cp")
+                .arg(format!("{}linux-config-x86_64", QUARK_CONFIG_DIR))
+                .arg(format!("{}kernel/.config", QUARK_CONFIG_DIR))
+                .output()
+                .expect("failed to copy kernel config");
+
+            // Building kernel binary
+            // FIXME: It seems that the build process is not working properly, command is stopped during build process
+            Command::new("make")
+                .arg("bzImage")
+                .args(["-j", "nproc"])
+                .current_dir(format!("{}kernel", QUARK_CONFIG_DIR))
+                .status() // Here we are using status because we have to wait the command to finish
+                .expect("failed to build kernel binary");
+        }
+
+        self
+    }
+
+    /// Append kernel configuration
+    /// Fetch automated script if isn't already installed, and use some bash script to build it
+    fn add_kernel(&self) -> &Quardle {
+        println!("Installing kernel binary !");
+        Command::new("cp")
+            .arg(format!("{}arch/x86/boot/bzImage", QUARK_CONFIG_DIR))
+            .arg(format!("{}/", self.clone().get_work_dir()))
+            .spawn()
+            .expect("failed to copy kernel");
+        self
+    }
+
+    /// Append basic rootfs
+    /// Fetch automated script if isn't already installed, and use some bash script to build it
+    fn add_init_rd(&self) -> &Quardle {
+        println!("Installing initRamFS");
+        Command::new("curl")
+            .arg("https://dl-cdn.alpinelinux.org/alpine/v3.14/releases/x86_64/alpine-minirootfs-3.14.2-x86_64.tar.gz")
+            .arg("-O") 
+            .current_dir(self.clone().get_work_dir())
+            .output()
+            .expect("failed to download alpine image");
+         Command::new("mkdir")
+            .arg(QUARDLE_INITRD) 
+            .current_dir(self.clone().get_work_dir())
+            .output()
+            .expect("failed to create rootfs folder");
+        Command::new("tar")
+            .arg("-xf") 
+            .arg("alpine-minirootfs-3.14.2-x86_64.tar.gz")
+            .args(["-C", QUARDLE_INITRD])
+            .current_dir(self.clone().get_work_dir())
+            .output()
+            .expect("failed to untar alpine image");
+        Command::new("rm")
+            .arg("-f") 
+            .arg("alpine-minirootfs-3.14.2-x86_64.tar.gz")
+            .current_dir(self.clone().get_work_dir())
+            .output()
+            .expect("failed to delete downloaded archive");
+        Command::new("runc")
+            .arg("spec") 
+            .arg("--rootless")
+            .current_dir(self.clone().get_work_dir())
+            .output()
+            .expect("failed to generate runtime spec");
+        self
     }
 
     /// Append kaps binary to builded image
     /// Fetch kaps source code if isn't already installed, build it from source and copy it to the working directory
-    // TODO: appends kaps binary at /opt/kaps/bin/kaps and set a ln -s /opt/kaps/bin/kaps /usr/bin/kaps
-    fn append_kaps(&self) -> Result<()> {
-        Ok(())
+    fn add_kaps(&self) -> &Quardle {
+        Command::new("cargo")
+            .current_dir(format!("{}kaps", QUARK_CONFIG_DIR))
+            .arg("build")
+            .arg("--release")
+            // .arg("--out-dir") //TODO: outdir is only available on nightly for now, should be used later
+            // .arg(format!("{}/rootfs/usr/bin/kaps",self.clone().get_work_dir()))
+                .output()
+                .expect("failed to build kaps");
+
+        Command::new("cp")
+            .arg(format!("{}kaps/target/release/kaps", QUARK_CONFIG_DIR))
+            .arg(format!("{}/rootfs/usr/bin/kaps",self.clone().get_work_dir()))
+            .output()
+            .expect("failed to copy kaps");
+
+        self
     }
 
     /// Generate the config file of the quardle
@@ -106,12 +239,13 @@ impl Quardle {
 
     /// Create compressed archive from quardle files and result it at /out/<quardle_name>.qrk
     fn generate_archive(&self) -> Result<()> {
-      let tar_gz = File::create(format!("out/{}.qrk",self.name)).unwrap();
-      let enc = GzEncoder::new(tar_gz, Compression::default());
-      let mut tar = tar::Builder::new(enc);
-      self.generate_config_file()?;
-      tar.append_dir_all(".", self.clone().get_work_dir()).unwrap();
-      Ok(())
+        let tar_gz = File::create(format!("out/{}.qrk",self.name)).unwrap();
+        let enc = GzEncoder::new(tar_gz, Compression::default());
+        let mut tar = tar::Builder::new(enc);
+        
+        // tar.append_dir_all("./", self.clone().get_work_dir()).unwrap();
+        tar.finish().unwrap();
+        Ok(())
     }
 }
 
@@ -126,12 +260,6 @@ mod tests {
     assert_eq!(quardle.as_ref().unwrap().container_image_url, "container1");
   }
 
-  #[test]
-  fn quardle_delete() {
-    let quardle = Quardle::new("test".to_string(), "test".to_string(), false);
-    assert_eq!(quardle.unwrap().delete().unwrap(), ());
-  }
-
   #[test]
   fn quardle_get_work_dir() {
     let quardle = Quardle::new("this-should-be-a-directory".to_string(), "my-container".to_string(), false);