feat: Add functionality to download Ubuntu cloud image and initialize VM

- Updated Cargo.toml to include reqwest for HTTP requests and added net feature to tokio.
- Implemented download_ubuntu_cloud_image function in src/helpers/init.rs to download the Ubuntu cloud image if it doesn't already exist.
- Created a new init module in src/helpers/mod.rs to encapsulate the initialization logic.
- Modified main.rs to add an Init command that triggers the image download.
- Introduced qmp module in src/vm/mod.rs for QEMU Machine Protocol interactions.
- Added functions in src/vm/qmp.rs to start a VM and connect to its QMP socket.
- Updated create_seed_iso function in src/vm/utils.rs to change the seed file extension from .iso to .img.

Author: jim-junior

Cargo.lock

@@ -11,7 +11,8 @@ virt-sys = "0.3.1"
 # For file system operations and error handling
 anyhow = "1.0"
 # For running asynchronous operations
-tokio = { version = "1.0", features = ["full"] }
+reqwest = { version = "0.13", features = ["json"] }
+tokio = { version = "1.0", features = ["full", "net"] }
 clap = { version = "4.0", features = ["derive"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"

Cargo.toml

@@ -0,0 +1,52 @@
+use reqwest::get;
+use std::fs::{self, File};
+use std::path::Path;
+
+async fn download_ubuntu_cloud_image() -> Result<String, Box<dyn std::error::Error>> {
+    let url = "https://cloud-images.ubuntu.com/releases/noble/release/ubuntu-24.04-server-cloudimg-amd64.img";
+
+    let dir = Path::new("./vm-data");
+    let file_path = dir.join("ubuntu-24.04-server-cloudimg-amd64.img");
+
+    // 1. Create directory if it doesn't exist
+    if !dir.exists() {
+        fs::create_dir_all(dir)?;
+        println!("Created directory: {:?}", dir);
+    }
+
+    // 2. Skip if file already exists
+    if file_path.exists() {
+        println!("Image already exists at {:?}", file_path);
+        return Ok(file_path.to_string_lossy().to_string());
+    }
+
+    println!("Downloading Ubuntu cloud image...");
+
+    // 3. Download the file
+    let mut response = get(url).await?;
+
+    if !response.status().is_success() {
+        return Err(format!("Download failed: {}", response.status()).into());
+    }
+
+    // 4. Create file
+    let mut file = File::create(&file_path)?;
+
+    // 5. Write response to file
+    while let Some(chunk) = response.chunk().await? {
+        std::io::copy(&mut chunk.as_ref(), &mut file)?;
+    }
+
+    println!("Downloaded to {:?}", file_path);
+
+    Ok(file_path.to_string_lossy().to_string())
+}
+
+pub fn initialize() {
+    // download image
+    let rt = tokio::runtime::Runtime::new().unwrap();
+    match rt.block_on(download_ubuntu_cloud_image()) {
+        Ok(path) => println!("Image ready at: {}", path),
+        Err(e) => eprintln!("Failed to download image: {}", e),
+    }
+}

src/helpers/init.rs

@@ -1,6 +1,7 @@
 use serde::{Serialize, de::DeserializeOwned};
 use serde_json::Value;
 use xmltree::{Element, XMLNode};
+pub mod init;
 
 /// Recursively convert JSON value into XML element
 fn value_to_xml(value: &Value, tag: &str) -> Element {

src/helpers/mod.rs

@@ -12,6 +12,7 @@ struct Cli {
 
 #[derive(Subcommand)]
 enum Commands {
+    Init,
     Create {
         /// Name of the VM
         #[arg(short, long)]
@@ -69,6 +70,9 @@ fn main() {
     let cli = Cli::parse();
 
     match cli.command {
+        Commands::Init => {
+            helpers::init::initialize();
+        }
         Commands::Boot { name } => {
             boot_vm(&name);
         }

src/main.rs

@@ -3,6 +3,7 @@ use virt::domain::Domain;
 
 //use crate::helpers;
 
+pub mod qmp;
 pub mod types;
 pub mod utils;
 

src/vm/mod.rs

@@ -0,0 +1,67 @@
+use std::io::{Read, Write};
+use std::os::unix::net::UnixStream;
+use std::process::{Command, Stdio};
+
+pub fn start_vm(disk: &str, seed: &str, qmp_socket: &str) {
+    let child = Command::new("qemu-system-x86_64")
+        .args([
+            "-m",
+            "2048",
+            "-smp",
+            "2",
+            "-enable-kvm",
+            "-cpu",
+            "host",
+            "-nographic",
+            // OS disk
+            "-drive",
+            &format!("file={},format=qcow2,if=virtio", disk),
+            // cloud-init seed
+            "-drive",
+            &format!("file={},format=raw,media=cdrom", seed),
+            // networking
+            "-netdev",
+            "user,id=net0,hostfwd=tcp::2222-:22",
+            "-device",
+            "virtio-net-pci,netdev=net0",
+            // QMP socket
+            "-qmp",
+            &format!("unix:{},server,nowait", qmp_socket),
+        ])
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .spawn()
+        .expect("Failed to start QEMU");
+
+    println!("Started VM with PID: {}", child.id());
+}
+
+pub fn connect_qmp(path: &str) -> UnixStream {
+    let mut stream: UnixStream;
+
+    loop {
+        match UnixStream::connect(path) {
+            Ok(s) => {
+                stream = s;
+                break;
+            }
+            Err(_) => {
+                std::thread::sleep(std::time::Duration::from_millis(200));
+            }
+        }
+    }
+
+    println!("Connected to QMP");
+    stream
+}
+
+pub fn init_qmp(stream: &mut UnixStream) {
+    let mut buffer = [0; 1024];
+
+    // Read greeting
+    let _ = stream.read(&mut buffer);
+
+    // Send capabilities command
+    let cmd = r#"{ "execute": "qmp_capabilities" }"#;
+    stream.write_all(cmd.as_bytes()).unwrap();
+}

src/vm/qmp.rs

@@ -238,7 +238,7 @@ pub fn create_seed_iso(name: &str, username: &str, password: &str) -> String {
     println!("User Data YAML:\n{}", user_data_yaml);
     println!("Meta Data YAML:\n{}", meta_data_yaml);
 
-    let iso_path = format!("/var/lib/libvirt/images/{}-seed.iso", name);
+    let iso_path = format!("/var/lib/libvirt/images/{}-seed.img", name);
     let iso_path_obj = Path::new(&iso_path);
     if let Some(parent) = iso_path_obj.parent() {
         if !parent.exists() {