From 9c959fef9d47c9c315899b443a90d15a2af220eb Mon Sep 17 00:00:00 2001 From: Badr Date: Sun, 25 Oct 2026 16:07:50 +0100 Subject: [PATCH 1/4] add linux direct boot option --- src/lib.rs | 14 +- src/vm.rs | 14 +- src/vmbuilder.rs | 2 - src/vmbuilder/advanced.rs | 15 +- src/vmbuilder/overview.rs | 421 ++++++++++++++++++++++++++++++++------ src/vmbuilder/quick.rs | 3 +- 6 files changed, 385 insertions(+), 84 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 60762d0..f032b49 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -2,6 +2,8 @@ use std::{env, path::PathBuf}; use serde::{Deserialize, Serialize}; +use crate::{BootOption::CloudImage, os::Os}; + pub mod access; pub mod app; pub mod cloudinit; @@ -66,9 +68,15 @@ impl TryFrom<&str> for Arch { } } -#[derive(Debug, Default, Clone, Copy, PartialEq, Serialize, Deserialize)] +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] pub enum BootOption { - #[default] - CloudImage, + CloudImage(Os), LocalFile, + DirectLinuxBoot((PathBuf, PathBuf, String)), +} + +impl Default for BootOption { + fn default() -> Self { + CloudImage(Os::default()) + } } diff --git a/src/vm.rs b/src/vm.rs index ca8a351..88a0caf 100644 --- a/src/vm.rs +++ b/src/vm.rs @@ -53,7 +53,6 @@ pub struct VM { pub id: VmId, pub name: String, pub boot_option: BootOption, - pub os: Option, pub arch: Arch, pub vcpu: u16, pub memory: u32, @@ -273,7 +272,6 @@ impl VM { id, name: data.name, boot_option: data.boot_option, - os: data.os, arch: data.arch, vcpu: data.vcpu, memory: data.memory, @@ -434,9 +432,8 @@ impl VM { } pub fn start(&mut self, sender: Sender) -> Result<()> { - if self.boot_option == BootOption::CloudImage { - let distro = self.os.unwrap(); - if !distro.is_available(self.arch) { + if let BootOption::CloudImage(os) = self.boot_option { + if !os.is_available(self.arch) { thread::spawn({ let vm = self.clone(); let sender = sender.clone(); @@ -447,7 +444,7 @@ impl VM { vm.downloading .store(true, std::sync::atomic::Ordering::Relaxed); } - if let Err(error) = distro.download(vm.arch, sender.clone(), vm.id) { + if let Err(error) = os.download(vm.arch, sender.clone(), vm.id) { vm.downloading .store(false, std::sync::atomic::Ordering::Relaxed); let _ = sender @@ -461,7 +458,7 @@ impl VM { return Ok(()); } else { if !self.get_boot_file().exists() - && let Err(e) = fs::copy(distro.get_file_path(self.arch), self.get_boot_file()) + && let Err(e) = fs::copy(os.get_file_path(self.arch), self.get_boot_file()) { let _ = sender.send(Event::Notification(Notification::error(e))); } @@ -650,8 +647,7 @@ impl VM { ]), ]; - if self.boot_option == BootOption::CloudImage { - let os = self.os.unwrap(); + if let BootOption::CloudImage(os) = self.boot_option { items.push(ListItem::from(vec![ Line::from(vec![ Span::from("OS").bold().fg(Color::Yellow), diff --git a/src/vmbuilder.rs b/src/vmbuilder.rs index 04cd66c..832d366 100644 --- a/src/vmbuilder.rs +++ b/src/vmbuilder.rs @@ -28,7 +28,6 @@ use crate::{ fs::Filesystem, graphics::Graphics, network::Network, - os::Os::{self}, storage::{Disk, Interface}, vmbuilder::{advanced::Advanced, quick::Quick}, }; @@ -60,7 +59,6 @@ pub struct VMBuildData { pub name: String, pub cloudinit: Option, pub boot_file: Option<(PathBuf, Interface)>, - pub os: Option, pub vcpu: u16, pub memory: u32, pub networks: Vec, diff --git a/src/vmbuilder/advanced.rs b/src/vmbuilder/advanced.rs index 030f546..ce2799e 100644 --- a/src/vmbuilder/advanced.rs +++ b/src/vmbuilder/advanced.rs @@ -12,10 +12,10 @@ use ratatui::{ }; use crate::{ - Arch, + Arch, BootOption, event::Event, graphics, network, - os::Os::ArchLinux, + os::Os::{self}, vmbuilder::{VMBuildData, access, fs, hardware, overview, port, storage}, }; @@ -77,7 +77,6 @@ impl Advanced { name: self.overview.name(), cloudinit: self.overview.cloudinit(), boot_file: self.overview.boot_file(), - os: self.overview.os(), vcpu: self.hardware.vcpu(), memory: self.hardware.memory(), arch: self.hardware.arch(), @@ -163,9 +162,10 @@ impl Advanced { KeyCode::BackTab => match self.focused_section { Section::Overview => { if self.validate_overview_section() { - if self.overview.os() == Some(ArchLinux) { + if self.overview.boot_option() == BootOption::CloudImage(Os::ArchLinux) { self.hardware.set_arch(Arch::X86_64); } + self.focused_section = Section::Summary; } } @@ -200,8 +200,11 @@ impl Advanced { self.overview.handle_key_events(key_event); } Section::Hardware => { - self.hardware - .handle_key_events(key_event, self.overview.os()); + let os = match self.overview.boot_option() { + BootOption::CloudImage(v) => Some(v), + _ => None, + }; + self.hardware.handle_key_events(key_event, os); } Section::Storage => { self.storage diff --git a/src/vmbuilder/overview.rs b/src/vmbuilder/overview.rs index 0d93812..a4db5f8 100644 --- a/src/vmbuilder/overview.rs +++ b/src/vmbuilder/overview.rs @@ -4,7 +4,7 @@ use crossterm::event::{KeyCode, KeyEvent}; use ratatui::{ Frame, - layout::{Constraint, Direction, Layout, Rect}, + layout::{Constraint, Direction, Layout, Margin, Rect}, style::Stylize, text::{Line, Span, Text}, widgets::ListItem, @@ -26,6 +26,9 @@ enum Section { StorageInterface, OS, Release, + Kernel, + Initramfs, + AppendOptions, Cloudinit, } @@ -35,11 +38,19 @@ pub struct UserInputField { error: Option, } +#[derive(Debug, Default, Clone, PartialEq)] +enum BootOptionChoice { + #[default] + CloudImage, + LocalFile, + DirectLinuxBoot, +} + #[derive(Debug, Default, Clone)] pub struct Overview { section: Section, name: UserInputField, - boot_option: BootOption, + boot_option_choice: BootOptionChoice, cloudinit: UserInputField, boot_file: UserInputField, local_file_interface: storage::Interface, @@ -47,6 +58,9 @@ pub struct Overview { ubuntu_release: UbuntuRelease, debian_release: DebianRelease, freebsd_release: FreebsdRelease, + kernel: UserInputField, + initramfs: UserInputField, + appendoptions: UserInputField, } impl Overview { @@ -54,9 +68,16 @@ impl Overview { Overview::default() } - //TODO: maybe a bool is enough pub fn boot_option(&self) -> BootOption { - self.boot_option + match self.boot_option_choice { + BootOptionChoice::CloudImage => BootOption::CloudImage(self.os()), + BootOptionChoice::LocalFile => BootOption::LocalFile, + BootOptionChoice::DirectLinuxBoot => BootOption::DirectLinuxBoot(( + self.kernel.field.value().into(), + self.initramfs.field.value().into(), + self.appendoptions.field.value().into(), + )), + } } pub fn name(&self) -> String { @@ -81,15 +102,12 @@ impl Overview { } } - pub fn os(&self) -> Option { - match self.boot_option { - BootOption::CloudImage => match self.os { - Os::Debian(_) => Some(Os::Debian(self.debian_release)), - Os::Ubuntu(_) => Some(Os::Ubuntu(self.ubuntu_release)), - Os::ArchLinux => Some(Os::ArchLinux), - Os::Freebsd(_) => Some(Os::Freebsd(self.freebsd_release)), - }, - BootOption::LocalFile => None, + pub fn os(&self) -> Os { + match self.os { + Os::Debian(_) => Os::Debian(self.debian_release), + Os::Ubuntu(_) => Os::Ubuntu(self.ubuntu_release), + Os::ArchLinux => Os::ArchLinux, + Os::Freebsd(_) => Os::Freebsd(self.freebsd_release), } } @@ -112,24 +130,39 @@ impl Overview { KeyCode::Up | KeyCode::Char('k') => { self.section = Section::Name; } - KeyCode::Down | KeyCode::Char('j') => match self.boot_option { - BootOption::CloudImage => { + KeyCode::Down | KeyCode::Char('j') => match self.boot_option_choice { + BootOptionChoice::CloudImage => { self.section = Section::OS; } - BootOption::LocalFile => { + BootOptionChoice::LocalFile => { self.section = Section::LocalFile; } + BootOptionChoice::DirectLinuxBoot => { + self.section = Section::Kernel; + } }, - KeyCode::Left | KeyCode::Char('h') | KeyCode::Right | KeyCode::Char('l') => { - match self.boot_option { - BootOption::CloudImage => { - self.boot_option = BootOption::LocalFile; - } - BootOption::LocalFile => { - self.boot_option = BootOption::CloudImage; - } + KeyCode::Right | KeyCode::Char('l') => match self.boot_option_choice { + BootOptionChoice::CloudImage => { + self.boot_option_choice = BootOptionChoice::LocalFile; } - } + BootOptionChoice::LocalFile => { + self.boot_option_choice = BootOptionChoice::DirectLinuxBoot; + } + BootOptionChoice::DirectLinuxBoot => { + self.boot_option_choice = BootOptionChoice::CloudImage; + } + }, + KeyCode::Left | KeyCode::Char('h') => match self.boot_option_choice { + BootOptionChoice::CloudImage => { + self.boot_option_choice = BootOptionChoice::DirectLinuxBoot; + } + BootOptionChoice::LocalFile => { + self.boot_option_choice = BootOptionChoice::CloudImage; + } + BootOptionChoice::DirectLinuxBoot => { + self.boot_option_choice = BootOptionChoice::LocalFile; + } + }, _ => {} }, Section::LocalFile => match key_event.code { @@ -279,14 +312,56 @@ impl Overview { }, _ => {} }, + Section::Kernel => match key_event.code { + KeyCode::Up => { + self.section = Section::BootOption; + } + KeyCode::Down => { + self.section = Section::Initramfs; + } + _ => { + self.kernel + .field + .handle_event(&crossterm::event::Event::Key(key_event)); + } + }, + Section::Initramfs => match key_event.code { + KeyCode::Up => { + self.section = Section::Kernel; + } + KeyCode::Down => { + self.section = Section::AppendOptions; + } + _ => { + self.initramfs + .field + .handle_event(&crossterm::event::Event::Key(key_event)); + } + }, + Section::AppendOptions => match key_event.code { + KeyCode::Up => { + self.section = Section::Initramfs; + } + KeyCode::Down => { + self.section = Section::Cloudinit; + } + _ => { + self.appendoptions + .field + .handle_event(&crossterm::event::Event::Key(key_event)); + } + }, Section::Cloudinit => match key_event.code { - KeyCode::Up => match self.boot_option { - BootOption::CloudImage => { + KeyCode::Up => match self.boot_option_choice { + BootOptionChoice::CloudImage => { self.section = Section::Release; } - BootOption::LocalFile => { + BootOptionChoice::LocalFile => { self.section = Section::StorageInterface; } + BootOptionChoice::DirectLinuxBoot => { + self.section = Section::AppendOptions; + } }, KeyCode::Down => { self.section = Section::Name; @@ -300,12 +375,16 @@ impl Overview { } } + //TODO: add validate by field pub fn validate(&mut self) -> bool { let mut valid = true; self.name.error = None; self.cloudinit.error = None; self.boot_file.error = None; + self.kernel.error = None; + self.initramfs.error = None; + self.appendoptions.error = None; if self.name.field.value().is_empty() { self.name.error = Some("Field required".into()); @@ -319,16 +398,42 @@ impl Overview { valid = false; } - if self.boot_option == BootOption::LocalFile { - if self.boot_file.field.value().is_empty() { - self.boot_file.error = Some("Field required".into()); - return false; + match self.boot_option_choice { + BootOptionChoice::LocalFile => { + if self.boot_file.field.value().is_empty() { + self.boot_file.error = Some("Field required".into()); + return false; + } + + if !PathBuf::from(self.boot_file.field.value()).exists() { + self.boot_file.error = Some("Boot file does not exists".into()); + valid = false; + } } + BootOptionChoice::DirectLinuxBoot => { + let kernel = self.kernel.field.value(); + let initramfs = self.initramfs.field.value(); - if !PathBuf::from(self.boot_file.field.value()).exists() { - self.boot_file.error = Some("Boot file does not exists".into()); - valid = false; + if kernel.is_empty() { + self.kernel.error = Some("Field required".into()); + valid = false; + } else { + if !PathBuf::from(kernel).exists() { + self.kernel.error = Some("Unvalid path".into()); + valid = false; + } + } + if initramfs.is_empty() { + self.initramfs.error = Some("Field required".into()); + valid = false; + } else { + if !PathBuf::from(initramfs).exists() { + self.initramfs.error = Some("Unvalid path".into()); + valid = false; + } + } } + _ => {} } valid @@ -344,8 +449,8 @@ impl Overview { Line::from(""), ])]; - match self.boot_option { - BootOption::CloudImage => { + match self.boot_option_choice { + BootOptionChoice::CloudImage => { items.push(ListItem::from(vec![ Line::from(vec![ Span::from("OS").bold(), @@ -355,7 +460,7 @@ impl Overview { Line::from(""), ])); } - BootOption::LocalFile => { + BootOptionChoice::LocalFile => { items.push(ListItem::from(vec![ Line::from(vec![ Span::from("Boot file").bold(), @@ -365,6 +470,9 @@ impl Overview { Line::from(""), ])); } + BootOptionChoice::DirectLinuxBoot => { + //TODO: + } }; items.push(ListItem::from(vec![ @@ -384,20 +492,81 @@ impl Overview { } pub fn render(&self, frame: &mut Frame, area: Rect, cancel_confirmation_popup: bool) { - let (name_block, boot_block, os_block, release_block, cloudinit_block) = { + let area = area.inner(Margin { + horizontal: 0, + vertical: 1, + }); + + let ( + name_block, + boot_block, + os_block, + release_block, + file_path_block, + storage_interface_block, + kernel_block, + initramfs_block, + append_options_block, + cloudinit_block, + ) = { let chunks = Layout::default() .direction(Direction::Vertical) .constraints([ - Constraint::Length(4), - Constraint::Length(4), - Constraint::Length(4), - Constraint::Length(4), - Constraint::Length(4), + Constraint::Length(4), // Name + Constraint::Length(4), // Boot Option + Constraint::Length( + if self.boot_option_choice == BootOptionChoice::CloudImage { + 4 + } else { + 0 + }, + ), // os + Constraint::Length( + if self.boot_option_choice == BootOptionChoice::CloudImage { + 4 + } else { + 0 + }, + ), // release + Constraint::Length(if self.boot_option_choice == BootOptionChoice::LocalFile { + 4 + } else { + 0 + }), // File + Constraint::Length(if self.boot_option_choice == BootOptionChoice::LocalFile { + 4 + } else { + 0 + }), // Interface + Constraint::Length( + if self.boot_option_choice == BootOptionChoice::DirectLinuxBoot { + 4 + } else { + 0 + }, + ), // Kernel + Constraint::Length( + if self.boot_option_choice == BootOptionChoice::DirectLinuxBoot { + 4 + } else { + 0 + }, + ), // Initramfs + Constraint::Length( + if self.boot_option_choice == BootOptionChoice::DirectLinuxBoot { + 4 + } else { + 0 + }, + ), // Append + Constraint::Length(4), // Cloudinit ]) - .margin(1) .split(area); - (chunks[0], chunks[1], chunks[2], chunks[3], chunks[4]) + ( + chunks[0], chunks[1], chunks[2], chunks[3], chunks[4], chunks[5], chunks[6], + chunks[7], chunks[8], chunks[9], + ) }; let name = vec![ @@ -442,10 +611,16 @@ impl Overview { }, Span::from(" ".repeat(5)), Span::from({ - if self.boot_option == BootOption::CloudImage { - "[x] CloudImage [ ] Local File" - } else { - "[ ] CloudImage [x] Local File" + match self.boot_option_choice { + BootOptionChoice::CloudImage => { + "[x] CloudImage [ ] Local File [ ] Direct Boot " + } + BootOptionChoice::LocalFile => { + "[ ] CloudImage [x] Local File [ ] Direct Boot " + } + BootOptionChoice::DirectLinuxBoot => { + "[ ] CloudImage [ ] Local File [x] Direct Boot " + } } }), ]); @@ -537,6 +712,102 @@ impl Overview { Span::from(format!("< {} >", self.local_file_interface)), ]); + let kernel = vec![ + Line::from(vec![ + { + if self.section == Section::Kernel { + Span::from("> Kernel ").bold() + } else { + Span::from(" Kernel ") + } + }, + Span::from(" "), + Span::from({ + let original_length = self.kernel.field.to_string().len(); + let target_length = 65_usize; + + self.kernel + .field + .to_string() + .chars() + .chain(std::iter::repeat_n( + ' ', + target_length.saturating_sub(original_length), + )) + .collect::() + }) + .on_dark_gray(), + ]), + Line::from(vec![ + Span::from(" ".repeat(14)), + Span::from(self.kernel.clone().error.unwrap_or("".to_string())).red(), + ]), + ]; + + let initramfs = vec![ + Line::from(vec![ + { + if self.section == Section::Initramfs { + Span::from("> Initramfs ").bold() + } else { + Span::from(" Initramfs ") + } + }, + Span::from(" "), + Span::from({ + let original_length = self.initramfs.field.to_string().len(); + let target_length = 65_usize; + + self.initramfs + .field + .to_string() + .chars() + .chain(std::iter::repeat_n( + ' ', + target_length.saturating_sub(original_length), + )) + .collect::() + }) + .on_dark_gray(), + ]), + Line::from(vec![ + Span::from(" ".repeat(14)), + Span::from(self.initramfs.clone().error.unwrap_or("".to_string())).red(), + ]), + ]; + + let append_options = vec![ + Line::from(vec![ + { + if self.section == Section::AppendOptions { + Span::from("> Append ").bold() + } else { + Span::from(" Append ") + } + }, + Span::from(" "), + Span::from({ + let original_length = self.appendoptions.field.to_string().len(); + let target_length = 65_usize; + + self.appendoptions + .field + .to_string() + .chars() + .chain(std::iter::repeat_n( + ' ', + target_length.saturating_sub(original_length), + )) + .collect::() + }) + .on_dark_gray(), + ]), + Line::from(vec![ + Span::from(" ".repeat(14)), + Span::from(self.appendoptions.clone().error.unwrap_or("".to_string())).red(), + ]), + ]; + let cloudinit = vec![ Line::from(vec![ { @@ -578,14 +849,19 @@ impl Overview { frame.render_widget(Text::from(name), name_block); frame.render_widget(Text::from(boot_option), boot_block); - match self.boot_option { - BootOption::CloudImage => { + match self.boot_option_choice { + BootOptionChoice::CloudImage => { frame.render_widget(os, os_block); frame.render_widget(release, release_block); } - BootOption::LocalFile => { - frame.render_widget(Text::from(boot_file), os_block); - frame.render_widget(Text::from(local_file_interface), release_block); + BootOptionChoice::LocalFile => { + frame.render_widget(Text::from(boot_file), file_path_block); + frame.render_widget(Text::from(local_file_interface), storage_interface_block); + } + BootOptionChoice::DirectLinuxBoot => { + frame.render_widget(Text::from(kernel), kernel_block); + frame.render_widget(Text::from(initramfs), initramfs_block); + frame.render_widget(Text::from(append_options), append_options_block); } } frame.render_widget(Text::from(cloudinit), cloudinit_block); @@ -594,20 +870,41 @@ impl Overview { if !cancel_confirmation_popup { match self.section { Section::Name if self.name.field.visual_cursor() < 61 => { - let x = area.x + self.name.field.visual_cursor() as u16 + 15; - let y = area.y + 1; + let x = area.x + self.name.field.visual_cursor() as u16 + 14; + let y = area.y; frame.set_cursor_position((x, y)); } Section::LocalFile if self.boot_file.field.visual_cursor() <= 61 => { - let x = area.x + self.boot_file.field.visual_cursor() as u16 + 15; - let y = area.y + 9; + let x = area.x + self.boot_file.field.visual_cursor() as u16 + 14; + let y = area.y + 8; frame.set_cursor_position((x, y)); } - Section::Cloudinit if self.cloudinit.field.visual_cursor() <= 61 => { - let x = area.x + self.cloudinit.field.visual_cursor() as u16 + 15; - let y = area.y + 17; + Section::Kernel if self.kernel.field.visual_cursor() <= 61 => { + let x = area.x + self.kernel.field.visual_cursor() as u16 + 14; + let y = area.y + 8; + frame.set_cursor_position((x, y)); + } + Section::Initramfs if self.initramfs.field.visual_cursor() <= 61 => { + let x = area.x + self.initramfs.field.visual_cursor() as u16 + 14; + let y = area.y + 12; + frame.set_cursor_position((x, y)); + } + Section::AppendOptions if self.appendoptions.field.visual_cursor() <= 61 => { + let x = area.x + self.appendoptions.field.visual_cursor() as u16 + 14; + let y = area.y + 16; frame.set_cursor_position((x, y)); } + Section::Cloudinit if self.cloudinit.field.visual_cursor() <= 61 => { + if self.boot_option_choice == BootOptionChoice::DirectLinuxBoot { + let x = area.x + self.cloudinit.field.visual_cursor() as u16 + 14; + let y = area.y + 20; + frame.set_cursor_position((x, y)); + } else { + let x = area.x + self.cloudinit.field.visual_cursor() as u16 + 14; + let y = area.y + 16; + frame.set_cursor_position((x, y)); + } + } _ => {} } } diff --git a/src/vmbuilder/quick.rs b/src/vmbuilder/quick.rs index d04a034..6ca3569 100644 --- a/src/vmbuilder/quick.rs +++ b/src/vmbuilder/quick.rs @@ -321,10 +321,9 @@ impl Quick { })); VMBuildData { - boot_option: BootOption::CloudImage, + boot_option: BootOption::CloudImage(self.os()), name: self.name(), boot_file: None, - os: Some(self.os()), vcpu: self.vcpu(), memory: self.memory(), arch: self.arch(), From 6f0cc7fa91bd0bec77e03322dd66a9d8441de5b9 Mon Sep 17 00:00:00 2001 From: Badr Date: Sun, 25 Oct 2026 16:29:04 +0100 Subject: [PATCH 2/4] add qemu args --- src/qemu.rs | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/src/qemu.rs b/src/qemu.rs index b0a8986..d58b891 100644 --- a/src/qemu.rs +++ b/src/qemu.rs @@ -12,7 +12,7 @@ use std::{ }; use crate::{ - Arch, KVM_ENABLED, + Arch, BootOption, KVM_ENABLED, event::Event, vm::{VM, VmId}, }; @@ -109,6 +109,16 @@ impl Qemu { command.arg("-drive").arg(drive.to_qemu_arg()); } + if let BootOption::DirectLinuxBoot((kernel, intiramfs, append)) = &vm.boot_option { + command + .arg("-kernel") + .arg(kernel) + .arg("-initrd") + .arg(intiramfs) + .arg("-append") + .arg(append); + } + command.stdout(Stdio::null()); command.stderr(Stdio::piped()); From d2c4e79dcd882e57610d9fff2d65de2dc98b37cd Mon Sep 17 00:00:00 2001 From: Badr Date: Fri, 30 Oct 2026 21:12:03 +0100 Subject: [PATCH 3/4] update --- src/qemu.rs | 8 +- src/vm.rs | 10 ++- src/vmbuilder.rs | 3 +- src/vmbuilder/advanced.rs | 32 ++++--- src/vmbuilder/hardware.rs | 177 +++++++++++++++++++++++++------------- src/vmbuilder/quick.rs | 3 +- 6 files changed, 152 insertions(+), 81 deletions(-) diff --git a/src/qemu.rs b/src/qemu.rs index d58b891..88aa897 100644 --- a/src/qemu.rs +++ b/src/qemu.rs @@ -114,9 +114,11 @@ impl Qemu { .arg("-kernel") .arg(kernel) .arg("-initrd") - .arg(intiramfs) - .arg("-append") - .arg(append); + .arg(intiramfs); + + if !append.is_empty() { + command.arg("-append").arg(append); + } } command.stdout(Stdio::null()); diff --git a/src/vm.rs b/src/vm.rs index 88a0caf..8e299f7 100644 --- a/src/vm.rs +++ b/src/vm.rs @@ -48,6 +48,13 @@ use crate::{ pub type VmId = uuid::Uuid; +#[derive(Debug, Clone, Copy, PartialEq)] +pub enum Firmware { + Bios, + Uefi, + None, +} + #[derive(Debug, Clone, Serialize, Deserialize)] pub struct VM { pub id: VmId, @@ -195,7 +202,8 @@ impl VM { path.pop(); } - if data.enable_uefi + if let BootOption::LocalFile | BootOption::CloudImage(_) = data.boot_option + && data.firmware == Firmware::Uefi && let Ok((code, vars)) = firmware::get_uefi_file_path(data.arch) { path.push("uefi_vars.fd"); diff --git a/src/vmbuilder.rs b/src/vmbuilder.rs index 832d366..1cd47f0 100644 --- a/src/vmbuilder.rs +++ b/src/vmbuilder.rs @@ -29,6 +29,7 @@ use crate::{ graphics::Graphics, network::Network, storage::{Disk, Interface}, + vm::Firmware, vmbuilder::{advanced::Advanced, quick::Quick}, }; @@ -62,7 +63,7 @@ pub struct VMBuildData { pub vcpu: u16, pub memory: u32, pub networks: Vec, - pub enable_uefi: bool, + pub firmware: Firmware, pub disks: Vec, pub fs: Vec, pub remote_access: Option, diff --git a/src/vmbuilder/advanced.rs b/src/vmbuilder/advanced.rs index ce2799e..bdcd30b 100644 --- a/src/vmbuilder/advanced.rs +++ b/src/vmbuilder/advanced.rs @@ -12,10 +12,8 @@ use ratatui::{ }; use crate::{ - Arch, BootOption, event::Event, graphics, network, - os::Os::{self}, vmbuilder::{VMBuildData, access, fs, hardware, overview, port, storage}, }; @@ -80,7 +78,7 @@ impl Advanced { vcpu: self.hardware.vcpu(), memory: self.hardware.memory(), arch: self.hardware.arch(), - enable_uefi: self.hardware.enable_uefi(), + firmware: self.hardware.firmware(), networks: self.network.networks().take(), disks: self.storage.disks(), fs: self.fs.filesystems(), @@ -127,6 +125,7 @@ impl Advanced { Section::Overview => { if self.validate_overview_section() { self.focused_section = Section::Hardware; + self.hardware.refresh(self.overview.boot_option()); } } Section::Hardware => { @@ -162,10 +161,6 @@ impl Advanced { KeyCode::BackTab => match self.focused_section { Section::Overview => { if self.validate_overview_section() { - if self.overview.boot_option() == BootOption::CloudImage(Os::ArchLinux) { - self.hardware.set_arch(Arch::X86_64); - } - self.focused_section = Section::Summary; } } @@ -174,18 +169,23 @@ impl Advanced { self.focused_section = Section::Overview; } } - Section::Storage => self.focused_section = Section::Hardware, + Section::Storage => { + self.focused_section = Section::Hardware; + self.hardware.refresh(self.overview.boot_option()); + } Section::Filesystem => { self.focused_section = Section::Storage; } Section::Network => { self.port_fowrwaring.refresh(); - self.focused_section = Section::Filesystem + self.focused_section = Section::Filesystem; + } + Section::PortForwarding => { + self.focused_section = Section::Network; } - Section::PortForwarding => self.focused_section = Section::Network, Section::RemoteAccess => { if self.validate_remote_access() { - self.focused_section = Section::PortForwarding + self.focused_section = Section::PortForwarding; } } Section::Graphics => { @@ -193,18 +193,16 @@ impl Advanced { self.focused_section = Section::RemoteAccess; } } - Section::Summary => self.focused_section = Section::Graphics, + Section::Summary => { + self.focused_section = Section::Graphics; + } }, _ => match &self.focused_section { Section::Overview => { self.overview.handle_key_events(key_event); } Section::Hardware => { - let os = match self.overview.boot_option() { - BootOption::CloudImage(v) => Some(v), - _ => None, - }; - self.hardware.handle_key_events(key_event, os); + self.hardware.handle_key_events(key_event); } Section::Storage => { self.storage diff --git a/src/vmbuilder/hardware.rs b/src/vmbuilder/hardware.rs index 1373eb1..a635de4 100644 --- a/src/vmbuilder/hardware.rs +++ b/src/vmbuilder/hardware.rs @@ -11,8 +11,9 @@ use tui_input::{Input, backend::crossterm::EventHandler}; use crate::{ Arch::{self}, + BootOption, app::{INSTALLED_ARCHS, INSTALLED_UEFI}, - os::Os, + vm::Firmware, }; #[derive(Debug, Clone, Default)] @@ -26,7 +27,7 @@ pub enum Section { Cpu, Arch, Memory, - Uefi, + Firmware, } #[derive(Debug, Clone)] @@ -35,27 +36,28 @@ pub struct Hardware { arch: Arch, vcpu: UserInputField, memory: UserInputField, - enable_uefi: bool, + firmware: Firmware, + boot_option: BootOption, } impl Hardware { pub fn new() -> Self { - let (arch, enable_uefi) = { + let (arch, firmware) = { match Arch::try_from(std::env::consts::ARCH).unwrap_or_default() { Arch::X86_64 => { if INSTALLED_ARCHS.contains(&Arch::X86_64) { if INSTALLED_UEFI.contains(&Arch::X86_64) { - (Arch::X86_64, true) + (Arch::X86_64, Firmware::Uefi) } else { - (Arch::X86_64, false) + (Arch::X86_64, Firmware::Bios) } } else { if INSTALLED_ARCHS.contains(&Arch::Aarch64) && INSTALLED_UEFI.contains(&Arch::Aarch64) { - (Arch::Aarch64, true) + (Arch::Aarch64, Firmware::Uefi) } else { - (Arch::Riscv64, true) + (Arch::Riscv64, Firmware::Uefi) } } } @@ -63,16 +65,16 @@ impl Hardware { if INSTALLED_ARCHS.contains(&Arch::Aarch64) && INSTALLED_UEFI.contains(&Arch::Aarch64) { - (Arch::Aarch64, true) + (Arch::Aarch64, Firmware::Uefi) } else { if INSTALLED_ARCHS.contains(&Arch::X86_64) { if INSTALLED_UEFI.contains(&Arch::X86_64) { - (Arch::X86_64, true) + (Arch::X86_64, Firmware::Uefi) } else { - (Arch::X86_64, false) + (Arch::X86_64, Firmware::Bios) } } else { - (Arch::Riscv64, true) + (Arch::Riscv64, Firmware::Uefi) } } } @@ -80,21 +82,22 @@ impl Hardware { if INSTALLED_ARCHS.contains(&Arch::Riscv64) && INSTALLED_UEFI.contains(&Arch::Riscv64) { - (Arch::Riscv64, true) + (Arch::Riscv64, Firmware::Uefi) } else { if INSTALLED_ARCHS.contains(&Arch::X86_64) { if INSTALLED_UEFI.contains(&Arch::X86_64) { - (Arch::X86_64, true) + (Arch::X86_64, Firmware::Uefi) } else { - (Arch::X86_64, false) + (Arch::X86_64, Firmware::Bios) } } else { - (Arch::Aarch64, true) + (Arch::Aarch64, Firmware::Uefi) } } } } }; + Self { section: Section::Cpu, arch, @@ -106,16 +109,21 @@ impl Hardware { field: Input::from("512"), error: None, }, - enable_uefi, + firmware, + boot_option: BootOption::default(), } } + pub fn firmware(&self) -> Firmware { + self.firmware + } + pub fn set_arch(&mut self, arch: Arch) { self.arch = arch; } - pub fn set_uefi(&mut self, enable: bool) { - self.enable_uefi = enable; + pub fn bypass_firmware(&mut self) { + self.firmware = Firmware::None; } pub fn vcpu(&self) -> u16 { @@ -130,10 +138,6 @@ impl Hardware { self.arch } - pub fn enable_uefi(&self) -> bool { - self.enable_uefi - } - pub fn validate(&mut self) -> bool { let mut valid = true; @@ -178,11 +182,19 @@ impl Hardware { valid } - pub fn handle_key_events(&mut self, key_event: KeyEvent, os: Option) { + pub fn refresh(&mut self, boot_option: BootOption) { + self.boot_option = boot_option; + } + + pub fn handle_key_events(&mut self, key_event: KeyEvent) { match self.section { Section::Cpu => match key_event.code { KeyCode::Up if self.validate() => { - self.section = Section::Uefi; + if let BootOption::DirectLinuxBoot(_) = self.boot_option { + self.section = Section::Arch; + } else { + self.section = Section::Firmware; + } } KeyCode::Down if self.validate() => { self.section = Section::Memory; @@ -206,29 +218,40 @@ impl Hardware { .handle_event(&crossterm::event::Event::Key(key_event)); } }, - Section::Arch => match os { - Some(Os::ArchLinux) => match key_event.code { - KeyCode::Up | KeyCode::Char('k') => { - self.section = Section::Memory; - } - KeyCode::Down | KeyCode::Char('j') => { - self.section = Section::Uefi; - } - _ => {} - }, - _ => match key_event.code { + + Section::Arch => + // match os { + // Some(Os::ArchLinux) => match key_event.code { + // KeyCode::Up | KeyCode::Char('k') => { + // self.section = Section::Memory; + // } + // KeyCode::Down | KeyCode::Char('j') => { + // if self.firmware != Firmware::None { + // self.section = Section::Uefi; + // } else { + // self.section = Section::Cpu; + // } + // } + // _ => {} + // }, + { + match key_event.code { KeyCode::Right | KeyCode::Char('l') => match self.arch { Arch::X86_64 => { if INSTALLED_ARCHS.contains(&Arch::Riscv64) { if INSTALLED_UEFI.contains(&Arch::Riscv64) { self.arch = Arch::Riscv64; - self.enable_uefi = true; } } else if INSTALLED_ARCHS.contains(&Arch::Aarch64) && INSTALLED_UEFI.contains(&Arch::Aarch64) { self.arch = Arch::Aarch64; - self.enable_uefi = true; + } + + if let BootOption::LocalFile | BootOption::CloudImage(_) = + self.boot_option + { + self.firmware = Firmware::Uefi; } } Arch::Aarch64 => { @@ -238,14 +261,22 @@ impl Hardware { && INSTALLED_UEFI.contains(&Arch::Riscv64) { self.arch = Arch::Riscv64; - self.enable_uefi = true; + if let BootOption::LocalFile | BootOption::CloudImage(_) = + self.boot_option + { + self.firmware = Firmware::Uefi; + } } } Arch::Riscv64 => { if INSTALLED_ARCHS.contains(&Arch::Aarch64) { if INSTALLED_UEFI.contains(&Arch::Aarch64) { self.arch = Arch::Aarch64; - self.enable_uefi = true; + if let BootOption::LocalFile | BootOption::CloudImage(_) = + self.boot_option + { + self.firmware = Firmware::Uefi; + } } } else if INSTALLED_ARCHS.contains(&Arch::X86_64) { self.arch = Arch::X86_64; @@ -257,20 +288,27 @@ impl Hardware { if INSTALLED_ARCHS.contains(&Arch::Aarch64) { if INSTALLED_UEFI.contains(&Arch::Aarch64) { self.arch = Arch::Aarch64; - self.enable_uefi = true; } } else if INSTALLED_ARCHS.contains(&Arch::Riscv64) && INSTALLED_UEFI.contains(&Arch::Riscv64) { self.arch = Arch::Riscv64; - self.enable_uefi = true; + } + if let BootOption::LocalFile | BootOption::CloudImage(_) = + self.boot_option + { + self.firmware = Firmware::Uefi; } } Arch::Aarch64 => { if INSTALLED_ARCHS.contains(&Arch::Riscv64) { if INSTALLED_UEFI.contains(&Arch::Riscv64) { self.arch = Arch::Riscv64; - self.enable_uefi = true; + if let BootOption::LocalFile | BootOption::CloudImage(_) = + self.boot_option + { + self.firmware = Firmware::Uefi; + } } } else if INSTALLED_ARCHS.contains(&Arch::X86_64) { self.arch = Arch::X86_64; @@ -283,7 +321,11 @@ impl Hardware { && INSTALLED_UEFI.contains(&Arch::Aarch64) { self.arch = Arch::Aarch64; - self.enable_uefi = true; + if let BootOption::LocalFile | BootOption::CloudImage(_) = + self.boot_option + { + self.firmware = Firmware::Uefi; + } } } }, @@ -291,17 +333,29 @@ impl Hardware { self.section = Section::Memory; } KeyCode::Down | KeyCode::Char('j') => { - self.section = Section::Uefi; + if let BootOption::DirectLinuxBoot(_) = self.boot_option { + self.section = Section::Cpu; + } else { + self.section = Section::Firmware; + } } _ => {} - }, - }, - Section::Uefi => match key_event.code { + } + } + Section::Firmware => match key_event.code { KeyCode::Right | KeyCode::Char('l') | KeyCode::Left | KeyCode::Char('h') if self.arch == Arch::X86_64 => { if INSTALLED_UEFI.contains(&Arch::X86_64) { - self.enable_uefi = !self.enable_uefi; + match self.firmware { + Firmware::Bios => { + self.firmware = Firmware::Uefi; + } + Firmware::Uefi => { + self.firmware = Firmware::Bios; + } + _ => {} + } } } KeyCode::Up | KeyCode::Char('k') => { @@ -316,7 +370,7 @@ impl Hardware { } pub fn render(&self, frame: &mut Frame, area: Rect, cancel_confirmation_popup: bool) { - let (cpu_block, memory_block, arch_block, uefi_block) = { + let (cpu_block, memory_block, arch_block, firmware_block) = { let chunks = Layout::default() .direction(Direction::Vertical) .constraints([ @@ -406,20 +460,20 @@ impl Hardware { Span::from(format!("< {} >", self.arch).to_lowercase()), ]); - let uefi = Line::from(vec![ + let firmware = Line::from(vec![ { - if self.section == Section::Uefi { - Span::from("> Uefi ").bold() + if self.section == Section::Firmware { + Span::from("> Firmware ").bold() } else { - Span::from(" Uefi ") + Span::from(" Firmware ") } }, - Span::from(" ".repeat(6)), + Span::from(" ".repeat(2)), Span::from({ if self.arch == Arch::X86_64 { if !INSTALLED_UEFI.contains(&Arch::X86_64) { "[x] BIOS" - } else if self.enable_uefi { + } else if self.firmware == Firmware::Uefi { "[x] UEFI [ ] BIOS" } else { "[ ] UEFI [x] BIOS" @@ -433,7 +487,10 @@ impl Hardware { frame.render_widget(Text::from(cpu), cpu_block); frame.render_widget(Text::from(memory), memory_block); frame.render_widget(Text::from(arch), arch_block); - frame.render_widget(Text::from(uefi), uefi_block); + + if let BootOption::LocalFile | BootOption::CloudImage(_) = self.boot_option { + frame.render_widget(Text::from(firmware), firmware_block); + } // FIX: cursor shows on the confirmation popup if !cancel_confirmation_popup { match self.section { @@ -482,7 +539,11 @@ impl Hardware { Line::from(vec![ Span::from("Firmware").bold(), Span::from(" ".repeat(12)), - Span::from(if self.enable_uefi { "UEFI" } else { "BIOS" }), + Span::from(if self.firmware == Firmware::Uefi { + "UEFI" + } else { + "BIOS" + }), ]), Line::from(""), ]), diff --git a/src/vmbuilder/quick.rs b/src/vmbuilder/quick.rs index 6ca3569..3ad1450 100644 --- a/src/vmbuilder/quick.rs +++ b/src/vmbuilder/quick.rs @@ -11,6 +11,7 @@ use crate::{ graphics::Graphics, network, os::{Os, debian::DebianRelease, freebsd::FreebsdRelease, ubuntu::UbuntuRelease}, + vm::Firmware, vmbuilder::VMBuildData, }; use crossterm::event::{KeyCode, KeyEvent}; @@ -327,7 +328,7 @@ impl Quick { vcpu: self.vcpu(), memory: self.memory(), arch: self.arch(), - enable_uefi: true, + firmware: Firmware::Uefi, networks: vec![network::Network::default()], disks: Vec::new(), fs: Vec::new(), From 759dd539e7654ccdc208632a10b9d6bb9e559de2 Mon Sep 17 00:00:00 2001 From: Badr Date: Sat, 31 Oct 2026 18:44:50 +0100 Subject: [PATCH 4/4] rename initramfs to initrd --- src/lib.rs | 2 +- src/qemu.rs | 16 +++++------ src/vmbuilder/overview.rs | 59 ++++++++++++++++++++------------------- 3 files changed, 39 insertions(+), 38 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index f032b49..32a54b6 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -72,7 +72,7 @@ impl TryFrom<&str> for Arch { pub enum BootOption { CloudImage(Os), LocalFile, - DirectLinuxBoot((PathBuf, PathBuf, String)), + DirectLinuxBoot((PathBuf, Option, Option)), } impl Default for BootOption { diff --git a/src/qemu.rs b/src/qemu.rs index 88aa897..7498c56 100644 --- a/src/qemu.rs +++ b/src/qemu.rs @@ -109,14 +109,14 @@ impl Qemu { command.arg("-drive").arg(drive.to_qemu_arg()); } - if let BootOption::DirectLinuxBoot((kernel, intiramfs, append)) = &vm.boot_option { - command - .arg("-kernel") - .arg(kernel) - .arg("-initrd") - .arg(intiramfs); - - if !append.is_empty() { + if let BootOption::DirectLinuxBoot((kernel, initrd, append)) = &vm.boot_option { + command.arg("-kernel").arg(kernel); + + if let Some(initrd) = initrd { + command.arg("-initrd").arg(initrd); + } + + if let Some(append) = append { command.arg("-append").arg(append); } } diff --git a/src/vmbuilder/overview.rs b/src/vmbuilder/overview.rs index a4db5f8..bca7803 100644 --- a/src/vmbuilder/overview.rs +++ b/src/vmbuilder/overview.rs @@ -27,7 +27,7 @@ enum Section { OS, Release, Kernel, - Initramfs, + Initrd, AppendOptions, Cloudinit, } @@ -59,7 +59,7 @@ pub struct Overview { debian_release: DebianRelease, freebsd_release: FreebsdRelease, kernel: UserInputField, - initramfs: UserInputField, + initrd: UserInputField, appendoptions: UserInputField, } @@ -74,8 +74,14 @@ impl Overview { BootOptionChoice::LocalFile => BootOption::LocalFile, BootOptionChoice::DirectLinuxBoot => BootOption::DirectLinuxBoot(( self.kernel.field.value().into(), - self.initramfs.field.value().into(), - self.appendoptions.field.value().into(), + { + let v = self.initrd.field.value(); + if v.is_empty() { None } else { Some(v.into()) } + }, + { + let v = self.appendoptions.field.value(); + if v.is_empty() { None } else { Some(v.into()) } + }, )), } } @@ -317,7 +323,7 @@ impl Overview { self.section = Section::BootOption; } KeyCode::Down => { - self.section = Section::Initramfs; + self.section = Section::Initrd; } _ => { self.kernel @@ -325,7 +331,7 @@ impl Overview { .handle_event(&crossterm::event::Event::Key(key_event)); } }, - Section::Initramfs => match key_event.code { + Section::Initrd => match key_event.code { KeyCode::Up => { self.section = Section::Kernel; } @@ -333,14 +339,14 @@ impl Overview { self.section = Section::AppendOptions; } _ => { - self.initramfs + self.initrd .field .handle_event(&crossterm::event::Event::Key(key_event)); } }, Section::AppendOptions => match key_event.code { KeyCode::Up => { - self.section = Section::Initramfs; + self.section = Section::Initrd; } KeyCode::Down => { self.section = Section::Cloudinit; @@ -383,7 +389,7 @@ impl Overview { self.cloudinit.error = None; self.boot_file.error = None; self.kernel.error = None; - self.initramfs.error = None; + self.initrd.error = None; self.appendoptions.error = None; if self.name.field.value().is_empty() { @@ -412,7 +418,7 @@ impl Overview { } BootOptionChoice::DirectLinuxBoot => { let kernel = self.kernel.field.value(); - let initramfs = self.initramfs.field.value(); + let initrd = self.initrd.field.value(); if kernel.is_empty() { self.kernel.error = Some("Field required".into()); @@ -423,14 +429,9 @@ impl Overview { valid = false; } } - if initramfs.is_empty() { - self.initramfs.error = Some("Field required".into()); + if !initrd.is_empty() && !PathBuf::from(initrd).exists() { + self.initrd.error = Some("Unvalid path".into()); valid = false; - } else { - if !PathBuf::from(initramfs).exists() { - self.initramfs.error = Some("Unvalid path".into()); - valid = false; - } } } _ => {} @@ -505,7 +506,7 @@ impl Overview { file_path_block, storage_interface_block, kernel_block, - initramfs_block, + initrd_block, append_options_block, cloudinit_block, ) = { @@ -744,21 +745,21 @@ impl Overview { ]), ]; - let initramfs = vec![ + let initrd = vec![ Line::from(vec![ { - if self.section == Section::Initramfs { - Span::from("> Initramfs ").bold() + if self.section == Section::Initrd { + Span::from("> Initrd ").bold() } else { - Span::from(" Initramfs ") + Span::from(" Initrd ") } }, - Span::from(" "), + Span::from(" ".repeat(4)), Span::from({ - let original_length = self.initramfs.field.to_string().len(); + let original_length = self.initrd.field.to_string().len(); let target_length = 65_usize; - self.initramfs + self.initrd .field .to_string() .chars() @@ -772,7 +773,7 @@ impl Overview { ]), Line::from(vec![ Span::from(" ".repeat(14)), - Span::from(self.initramfs.clone().error.unwrap_or("".to_string())).red(), + Span::from(self.initrd.clone().error.unwrap_or("".to_string())).red(), ]), ]; @@ -860,7 +861,7 @@ impl Overview { } BootOptionChoice::DirectLinuxBoot => { frame.render_widget(Text::from(kernel), kernel_block); - frame.render_widget(Text::from(initramfs), initramfs_block); + frame.render_widget(Text::from(initrd), initrd_block); frame.render_widget(Text::from(append_options), append_options_block); } } @@ -884,8 +885,8 @@ impl Overview { let y = area.y + 8; frame.set_cursor_position((x, y)); } - Section::Initramfs if self.initramfs.field.visual_cursor() <= 61 => { - let x = area.x + self.initramfs.field.visual_cursor() as u16 + 14; + Section::Initrd if self.initrd.field.visual_cursor() <= 61 => { + let x = area.x + self.initrd.field.visual_cursor() as u16 + 14; let y = area.y + 12; frame.set_cursor_position((x, y)); }