feat(fs-gen): stable version with agent insertion

src/fs-gen/Cargo.toml

@@ -19,3 +19,6 @@ signal-hook = "0.3.17"
 tar = "0.4.40"
 validator = { version = "0.17.0", features = ["derive"] }
 anyhow = "1.0.82"
+tracing = "0.1.40"
+tracing-subscriber = {  version = "0.3.18", features = ["env-filter"] }
+thiserror = "1.0.59"

src/fs-gen/resources/initfile

@@ -0,0 +1,21 @@
+#! /bin/sh
+#
+# Cloudlet initramfs generation
+#
+mount -t devtmpfs dev /dev
+mount -t proc proc /proc
+mount -t sysfs sysfs /sys
+
+ip link set up dev lo
+
+slattach -L /dev/ttyS1&
+
+while ! ifconfig sl0 &> /dev/null; do
+    sleep 1
+done
+
+ifconfig sl0 172.30.0.11 netmask 255.255.0.0 up
+
+/agent
+
+reboot

src/fs-gen/src/cli_args.rs

@@ -1,22 +1,25 @@
 use std::{env, path::PathBuf};
 
-use clap::{command, error::ErrorKind, CommandFactory, Parser};
+use clap::{command, error::ErrorKind, ArgAction, CommandFactory, Parser};
 use regex::Regex;
 
 use once_cell::sync::Lazy;
 
 // So, for any of you who may be scared, this is the regex from the OCI Distribution Sepcification for the image name + the tag
 static RE_IMAGE_NAME: Lazy<Regex> = Lazy::new(|| {
-    Regex::new(r"[a-z0-9]+((\.|_|__|-+)[a-z0-9]+)*(\/[a-z0-9]+((\.|_|__|-+)[a-z0-9]+)*)*:[a-zA-Z0-9_][a-zA-Z0-9._-]{0,127}").unwrap()
+    Regex::new(r"[a-z0-9]+((\.|_|__|-+)[a-z0-9]+)*(/[a-z0-9]+((\.|_|__|-+)[a-z0-9]+)*)*(?::[a-zA-Z0-9_][a-zA-Z0-9._-]{0,127})?").unwrap()
 });
 
 /// Convert an OCI image into a CPIO file
-#[derive(Parser, Debug)]
+#[derive(Parser, Debug, Clone)]
 #[command(version, about, long_about = None)]
 pub struct CliArgs {
     /// The name of the image to download
     pub image_name: String,
 
+    /// The host path to the guest agent binary
+    pub agent_host_path: PathBuf,
+
     /// The path to the output file
     #[arg(short='o', long="output", default_value=get_default_output_file().into_os_string())]
     pub output_file: PathBuf,
@@ -25,8 +28,14 @@ pub struct CliArgs {
     #[arg(short='t', long="tempdir", default_value=get_default_temp_directory().into_os_string())]
     pub temp_directory: PathBuf,
 
-    /// The host path to the guest agent binary
-    pub agent_host_path: PathBuf,
+    #[arg(short='i', long="init", default_value=None)]
+    pub initfile_path: Option<PathBuf>,
+
+    #[arg(long = "arch", default_value = "amd64")]
+    pub architecture: String,
+
+    #[arg(short='d', long="debug", action=ArgAction::SetTrue)]
+    pub debug: bool,
 }
 
 impl CliArgs {
@@ -66,13 +75,12 @@ impl CliArgs {
     }
 }
 
-/// Get the default output path for the cpio file.
+/// Get the default temporary directory for the current execution.
 fn get_default_temp_directory() -> PathBuf {
-    let mut path = env::current_dir().unwrap();
-    path.push(".cloudlet_temp/");
-    path
+    PathBuf::from("/tmp/cloudlet-fs-gen")
 }
 
+/// Get the default output file path for the generated initramfs.
 fn get_default_output_file() -> PathBuf {
     let mut path = env::current_dir().unwrap();
     path.push("initramfs.img");

src/fs-gen/src/image_builder.rs

@@ -13,6 +13,7 @@ use fuse_backend_rs::{
     passthrough::{self, PassthroughFs},
     transport::{FuseChannel, FuseSession},
 };
+use tracing::{debug, info, warn};
 
 static FILE_EXISTS_ERROR: i32 = 17;
 
@@ -44,16 +45,21 @@ fn new_passthroughfs_layer(rootdir: &str) -> Result<BoxedLayer> {
 
 /// Ensure a destination folder is created
 fn ensure_folder_created(output_folder: &Path) -> Result<()> {
-    let result = fs::create_dir(output_folder);
+    let result = fs::create_dir_all(output_folder);
 
     // If the file already exists, we're fine
-    if result.is_err()
-        && result
-            .unwrap_err()
+    if result.is_err() {
+        let err = result.unwrap_err();
+
+        if err
             .raw_os_error()
             .is_some_and(|err_val| err_val != FILE_EXISTS_ERROR)
-    {
-        return Err(anyhow!("Failed to create folder"));
+        {
+            return Err(anyhow!(err)).context(format!(
+                "Failed to create folder: {}",
+                output_folder.to_string_lossy()
+            ));
+        }
     }
 
     Ok(())
@@ -63,24 +69,27 @@ fn ensure_folder_created(output_folder: &Path) -> Result<()> {
 /// It works by instantiating an overlay fs via FUSE then copying the files to the desired target
 /// # Usage
 /// ```
-/// merge_layer(vec!["source/layer_1", "source/layer_2"], "/tmp/fused_layers")
+/// merge_layer(vec!["source/layer_1", "source/layer_2"], "/tmp/fused_layers", "/tmp")
 /// ```
-pub fn merge_layer(blob_paths: &[PathBuf], output_folder: &Path) -> Result<()> {
+pub fn merge_layer(blob_paths: &[PathBuf], output_folder: &Path, tmp_folder: &Path) -> Result<()> {
+    info!("Starting to merge layers...");
+
     // Stack all lower layers
     let mut lower_layers = Vec::new();
     for lower in blob_paths {
         lower_layers.push(Arc::new(new_passthroughfs_layer(&lower.to_string_lossy())?));
     }
 
-    let mountpoint = Path::new("/tmp/cloudlet_internal");
+    let binding = tmp_folder.join("overlayfs_mountpoint");
+    let mountpoint = binding.as_path();
     let fs_name = "cloudlet_overlay";
 
     ensure_folder_created(mountpoint)?;
     ensure_folder_created(output_folder)?;
 
     // Setup the overlay fs config
     let config = Config {
-        work: "/work".into(),
+        work: tmp_folder.join("work").to_string_lossy().into(),
         mountpoint: output_folder.to_string_lossy().into(),
         do_import: true,
         ..Default::default()
@@ -110,15 +119,15 @@ pub fn merge_layer(blob_paths: &[PathBuf], output_folder: &Path) -> Result<()> {
         let _ = server.svc_loop();
     });
 
-    println!("copy starting !");
+    debug!("Starting copy...");
     //So now we need to copy the files
     dircpy::copy_dir(mountpoint, output_folder).with_context(|| {
         format!(
             "Failed to copy directories into the output folder: {}",
             output_folder.to_string_lossy()
         )
     })?;
-    println!("copy finished");
+    debug!("Copy finished!");
 
     // Unmount sessions so it can be re-used in later executions of the program
     se.wake()
@@ -127,22 +136,23 @@ pub fn merge_layer(blob_paths: &[PathBuf], output_folder: &Path) -> Result<()> {
         .with_context(|| "Failed to unmount the fuse session".to_string())?;
 
     let _ = handle.join();
+
+    info!("Finished merging layers!");
     Ok(())
 }
 
 impl FuseServer {
     /// Run a loop to execute requests from the FUSE session
-    ///
     pub fn svc_loop(&mut self) -> Result<()> {
-        println!("entering server loop");
+        debug!("entering server loop");
         loop {
             let value = self
                 .ch
                 .get_request()
                 .with_context(|| "Failed to get message from fuse session".to_string())?;
 
             if value.is_none() {
-                println!("fuse server exits");
+                debug!("fuse server exits");
                 break;
             }
 
@@ -158,7 +168,7 @@ impl FuseServer {
                         break;
                     }
                     _ => {
-                        print!("Handling fuse message failed");
+                        warn!("Handling fuse message failed");
                         continue;
                     }
                 }