2Shirt/deja-vu
1
0
Fork 0
Code Issues 1 Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: 2Shirt:de7520324b8b52f19949edb96b38653cd380b639
Branches Tags
2Shirt:dev
2Shirt:win-installer
2Shirt:boot-diags
2Shirt:move-core-logic-to-lib
..
compare: 2Shirt:83b01a12301416830fc42d120b589ee39bff5e31
Branches Tags
2Shirt:win-installer
2Shirt:dev
2Shirt:boot-diags
2Shirt:move-core-logic-to-lib

1 commit
de7520324b ... 83b01a1230

Author SHA1 Message Date
2Shirt
83b01a1230
WIP: Initial boot-diags outline 
Currently not working
 2025-01-24 23:58:15 -08:00
8 changed files with 92 additions and 313 deletions
Show stats Expand all files Collapse all files

249
boot_diags/src/app.rs
View file

@ -22,16 +22,11 @@ use core::{
config::Config,
line::{get_disk_description_right, get_part_description, DVLine},
state::{CloneSettings, Mode},
system::{
boot::{self, SafeMode},
cpu::get_cpu_name,
drivers,
},
system::{cpu::get_cpu_name, drivers},
tasks::{Task, Tasks},
tui::{Event, Tui},
};
use std::{
env,
iter::zip,
sync::{Arc, Mutex},
};
@ -61,9 +56,7 @@ pub struct App {
clone: CloneSettings,
cur_mode: Mode,
list: StatefulList<Mode>,
boot_modes: Vec<SafeMode>,
selections: Vec<Option<usize>>,
system32: String,
tasks: Tasks,
}
@ -77,7 +70,7 @@ impl App {
Mode::BootDiags,
Mode::BootSetup,
Mode::InjectDrivers,
Mode::SetBootMode,
Mode::ToggleSafeMode,
]);
Ok(Self {
// TUI
@ -101,32 +94,11 @@ impl App {
clone: CloneSettings::new(disk_list_arc),
cur_mode: Mode::Home,
list,
boot_modes: vec![SafeMode::Enable, SafeMode::Disable],
system32: String::new(),
selections: vec![None, None],
tasks,
})
}
pub fn inject_driver(&mut self, index: usize) {
if let Some(driver) = self.clone.driver_list.get(index) {
if let Some(disk_index) = self.clone.disk_index_dest {
let disk_list = self.clone.disk_list.lock().unwrap();
if let Some(disk) = disk_list.get(disk_index) {
if let Some(boot_index) = self.clone.part_index_boot {
if let Ok(task) = boot::inject_driver(
driver,
disk.get_part_letter(boot_index).as_str(),
&self.system32,
) {
self.tasks.add(task);
}
}
}
}
}
}
pub fn next_mode(&mut self) -> Mode {
match self.cur_mode {
Mode::Home => Mode::ScanDisks,
@ -134,8 +106,13 @@ impl App {
Mode::ScanDisks => Mode::SelectDisks,
Mode::SelectDisks => Mode::SelectParts,
Mode::SelectParts => Mode::DiagMenu,
Mode::BootDiags | Mode::BootSetup | Mode::InjectDrivers | Mode::SetBootMode => {
Mode::DiagMenu
Mode::DiagMenu => {
// Use highlighted entry
if let Some(new_mode) = self.list.get_selected() {
new_mode
} else {
self.cur_mode
}
}
Mode::Failed => Mode::Failed,
// Default to current mode
@ -143,34 +120,10 @@ impl App {
}
}
pub fn set_boot_mode(&mut self, boot_mode: SafeMode) {
info!("Setting boot mode to: {:?}", boot_mode);
let disk_list = self.clone.disk_list.lock().unwrap();
if let Some(disk_index) = self.clone.disk_index_dest {
if let Some(disk) = disk_list.get(disk_index) {
if let Some(boot_index) = self.clone.part_index_boot {
if let Ok(task) = boot::set_mode(
disk.get_part_letter(boot_index).as_str(),
boot_mode,
&self.system32,
&disk.part_type,
) {
self.tasks.add(task);
};
}
}
}
}
pub fn set_mode(&mut self, new_mode: Mode) -> Result<()> {
info!("Setting mode to {new_mode:?}");
self.cur_mode = new_mode;
match new_mode {
Mode::DiagMenu => {
self.selections[0] = None;
self.selections[1] = None;
self.list.select_first_item();
}
Mode::InjectDrivers | Mode::InstallDrivers => self.clone.scan_drivers(),
Mode::ScanDisks => {
if self.tasks.idle() {
@ -204,22 +157,7 @@ impl App {
}
let action_tx = self.action_tx.clone();
// Late init
self.system32 = if cfg!(windows) {
if let Ok(path) = env::var("SYSTEMROOT") {
format!("{path}/System32")
} else {
self.action_tx.send(Action::Error(String::from(
"ERROR\n\n\nFailed to find SYSTEMROOT",
)))?;
return Ok(());
}
} else {
String::from(".")
};
action_tx.send(Action::SetMode(Mode::ScanDisks))?;
loop {
self.handle_events(&mut tui).await?;
self.handle_actions(&mut tui)?;
@ -309,23 +247,8 @@ impl App {
.send(Action::DisplayPopup(popup::Type::Error, msg.clone()))?;
self.action_tx.send(Action::SetMode(Mode::Failed))?;
}
Action::InstallDriver => {
self.action_tx.send(Action::SetMode(Mode::InstallDrivers))?;
}
Action::NextScreen => {
let next_mode = self.next_mode();
self.cur_mode = next_mode;
self.action_tx.send(Action::DismissPopup)?;
self.action_tx.send(Action::SetMode(next_mode))?;
}
Action::Process => match self.cur_mode {
Mode::DiagMenu => {
// Use highlighted entry
if let Some(new_mode) = self.list.get_selected() {
self.action_tx.send(Action::SetMode(new_mode))?;
}
}
Mode::BootDiags | Mode::BootSetup => {
let new_mode = self.next_mode();
self.action_tx.send(Action::SetMode(new_mode))?;
}
@ -334,12 +257,8 @@ impl App {
Action::Resize(w, h) => self.handle_resize(tui, w, h)?,
Action::Render => self.render(tui)?,
Action::ScanDisks => self.action_tx.send(Action::SetMode(Mode::ScanDisks))?,
Action::Select(one, two) => match self.cur_mode {
Mode::InjectDrivers => {
if let Some(index) = one {
self.inject_driver(index);
}
}
Action::Select(one, two) => {
match self.cur_mode {
Mode::InstallDrivers => {
if let Some(index) = one {
if let Some(driver) = self.clone.driver_list.get(index).cloned() {
@ -355,16 +274,13 @@ impl App {
self.clone.part_index_boot = one;
self.clone.part_index_os = two;
}
Mode::SetBootMode => {
if let Some(index) = one {
if let Some(boot_mode) = self.boot_modes.get(index) {
self.set_boot_mode(boot_mode.to_owned());
}
}
}
_ => {}
},
}
self.selections[0] = one;
self.selections[1] = two;
}
Action::SetMode(new_mode) => {
self.cur_mode = new_mode;
self.set_mode(new_mode)?;
self.action_tx
.send(Action::UpdateFooter(build_footer_string(self.cur_mode)))?;
@ -466,28 +382,23 @@ fn get_chunks(r: Rect) -> Vec<Rect> {
fn build_footer_string(cur_mode: Mode) -> String {
match cur_mode {
Mode::BootDiags | Mode::BootSetup | Mode::Home | Mode::PEMenu | Mode::ScanDisks => {
String::from("(q) to quit")
}
Mode::InstallDrivers | Mode::InjectDrivers | Mode::SetBootMode => {
String::from("(Enter) to select / (q) to quit")
}
Mode::DiagMenu | Mode::SelectParts => {
String::from("(Enter) to select / (s) to start over / (q) to quit")
}
// Boot Diags
Mode::BootSetup
| Mode::DiagMenu
| Mode::InjectDrivers
| Mode::PEMenu
| Mode::ToggleSafeMode => String::from("(Enter) or (q) to quit"),
// Copied from Clone
Mode::Home | Mode::ScanDisks | Mode::BootDiags => String::from("(q) to quit"),
Mode::SelectParts => String::from("(Enter) to select / (s) to start over / (q) to quit"),
Mode::SelectDisks => String::from(
"(Enter) to select / / (i) to install driver / (r) to rescan / (q) to quit",
),
Mode::Failed => String::from("(Enter) or (q) to quit"),
Mode::SelectTableType => String::from("(Enter) to select / (b) to go back / (q) to quit"),
Mode::Confirm => String::from("(Enter) to confirm / (b) to go back / (q) to quit"),
Mode::Done | Mode::Failed | Mode::InstallDrivers => String::from("(Enter) or (q) to quit"),
// Invalid states
Mode::Confirm
| Mode::Clone
| Mode::PreClone
| Mode::PostClone
| Mode::Done
| Mode::SelectTableType => {
panic!("This shouldn't happen?")
}
Mode::Clone | Mode::PreClone | Mode::PostClone => panic!("This shouldn't happen?"),
}
}
@ -540,8 +451,8 @@ fn build_left_items(app: &App) -> Action {
Mode::SelectParts => {
select_num = 2;
title = String::from("Select Boot and OS Partitions");
labels[0] = String::from("boot");
labels[1] = String::from("os");
labels.push(String::from("boot"));
labels.push(String::from("os"));
let disk_list = app.clone.disk_list.lock().unwrap();
if let Some(index) = app.clone.disk_index_dest {
if let Some(disk) = disk_list.get(index) {
@ -551,18 +462,11 @@ fn build_left_items(app: &App) -> Action {
}
}
}
Mode::BootDiags | Mode::BootSetup => {
Mode::BootDiags | Mode::BootSetup | Mode::ToggleSafeMode => {
select_num = 0;
let (new_title, _) = get_mode_strings(app.cur_mode);
title = new_title;
}
Mode::SetBootMode => {
select_num = 1;
title = String::from("Set Boot Mode");
app.boot_modes.iter().for_each(|entry| {
items.push(format!("{:?} Safe Mode", entry));
});
}
Mode::Done | Mode::Failed => {
select_num = 0;
title = String::from("Done");
@ -581,72 +485,11 @@ fn build_left_items(app: &App) -> Action {
}
fn build_right_items(app: &App) -> Action {
let mut items: Vec<Vec<DVLine>> = Vec::new();
let mut items = Vec::new();
let mut labels: Vec<Vec<DVLine>> = Vec::new();
let mut start_index = 0;
// TODO: DELETE THIS SECTION
start_index = 1;
items.push(vec![
DVLine {
line_parts: vec![format!("Mode: {:?}", app.cur_mode)],
line_colors: vec![Color::Reset],
},
DVLine {
line_parts: vec![format!(
"Parts: {:?} // {:?}",
app.clone.part_index_boot, app.clone.part_index_os
)],
line_colors: vec![Color::Reset],
},
DVLine {
line_parts: vec![format!(
"Selected: {:?} // {:?}",
app.list.selected(),
app.list.get_selected(),
)],
line_colors: vec![Color::Reset],
},
DVLine {
line_parts: vec![String::from("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")],
line_colors: vec![Color::Reset],
},
]);
// TODO: DELETE THIS SECTION
match app.cur_mode {
Mode::DiagMenu => {
let mut header_lines: Vec<DVLine> = Vec::new();
if let Some(index) = app.clone.disk_index_dest {
let disk_list = app.clone.disk_list.lock().unwrap();
if let Some(disk) = disk_list.get(index) {
let mut parts: Vec<usize> = Vec::new();
if let Some(index) = app.clone.part_index_boot {
parts.push(index);
}
if let Some(index) = app.clone.part_index_os {
parts.push(index);
}
// Disk Details
header_lines.append(&mut vec![
DVLine {
line_parts: vec![String::from("Disk")],
line_colors: vec![Color::Cyan],
},
DVLine {
line_parts: vec![String::new()],
line_colors: vec![Color::Reset],
},
]);
header_lines.append(&mut get_disk_description_right(&disk, Some(parts)));
// Add header
if !header_lines.is_empty() {
items[0].append(&mut header_lines);
// TODO: Replace line above with lines below
// items.push(header_lines);
// start_index = 1;
}
}
}
app.list.items.iter().for_each(|mode| {
let (name, description) = get_mode_strings(*mode);
items.push(vec![
@ -679,13 +522,13 @@ fn build_right_items(app: &App) -> Action {
Mode::SelectDisks => {
let dest_dv_line = DVLine {
line_parts: vec![String::from("Disk")],
line_colors: vec![Color::Cyan],
line_colors: vec![Color::Cyan, Color::Red],
};
labels.push(vec![dest_dv_line]);
let disk_list = app.clone.disk_list.lock().unwrap();
disk_list
.iter()
.for_each(|disk| items.push(get_disk_description_right(&disk, None)));
.for_each(|disk| items.push(get_disk_description_right(&disk)));
}
Mode::SelectParts => {
vec!["Boot", "OS"].iter().for_each(|s| {
@ -699,7 +542,7 @@ fn build_right_items(app: &App) -> Action {
let disk_list = app.clone.disk_list.lock().unwrap();
if let Some(disk) = disk_list.get(index) {
// Disk Details
items.push(get_disk_description_right(&disk, None));
items.push(get_disk_description_right(&disk));
// Partition Details
disk.parts
@ -708,24 +551,6 @@ fn build_right_items(app: &App) -> Action {
}
}
}
Mode::SetBootMode => {
app.boot_modes.iter().for_each(|mode| {
match mode {
SafeMode::Disable => {
items.push(vec![DVLine {
line_parts: vec![String::from("Disable Safe Mode")],
line_colors: vec![Color::Reset],
}]);
}
SafeMode::Enable => {
items.push(vec![DVLine {
line_parts: vec![String::from("Enable Safe Mode (minimal)")],
line_colors: vec![Color::Reset],
}]);
}
};
});
}
_ => {}
}
Action::UpdateRight(labels, start_index, items)
@ -745,7 +570,7 @@ fn get_mode_strings(mode: Mode) -> (String, String) {
String::from("Inject Drivers"),
String::from("Inject drivers into existing Windows environment"),
),
Mode::SetBootMode => (
Mode::ToggleSafeMode => (
String::from("Toggle Safe Mode"),
String::from("Enable or disable safe mode"),
),

3
config/config.json5
View file

@ -99,7 +99,6 @@
"<Enter>": "Process",
"<Up>": "KeyUp",
"<Down>": "KeyDown",
"<s>": "ScanDisks",
"<q>": "Quit",
"<Ctrl-d>": "Quit",
"<Ctrl-c>": "Quit",
@ -132,7 +131,7 @@
"<Ctrl-c>": "Quit",
"<Ctrl-z>": "Suspend"
},
"SetBootMode": {
"ToggleSafeMode": {
"<Enter>": "Process",
"<Up>": "KeyUp",
"<Down>": "KeyDown",

10
core/src/components/left.rs
View file

@ -138,9 +138,13 @@ impl Component for Left {
.areas(area);
// Title
let title = Paragraph::new(
Line::from(Span::styled(self.title_text.as_str(), Style::default())).centered(),
)
let title_text = if self.selections[1].is_some() || self.select_num == 1 {
"Confirm Selections"
} else {
self.title_text.as_str()
};
let title =
Paragraph::new(Line::from(Span::styled(title_text, Style::default())).centered())
.block(Block::default().borders(Borders::NONE));
frame.render_widget(title, title_area);

2
core/src/components/state.rs
View file

@ -55,7 +55,7 @@ impl<T: Clone> StatefulList<T> {
self.state.selected()
}
pub fn select_first_item(&mut self) {
fn select_first_item(&mut self) {
if self.items.is_empty() {
self.state.select(None);
} else {

30
core/src/line.rs
View file

@ -45,10 +45,7 @@ impl DVLine {
}
}
pub fn get_disk_description_right(
disk: &Disk,
boot_os_indicies: Option<Vec<usize>>,
) -> Vec<DVLine> {
pub fn get_disk_description_right(disk: &Disk) -> Vec<DVLine> {
let mut description: Vec<DVLine> = vec![
DVLine {
line_parts: vec![format!(
@ -70,29 +67,12 @@ pub fn get_disk_description_right(
line_colors: vec![Color::Blue],
},
];
disk.parts_description
.iter()
.enumerate()
.for_each(|(index, line)| {
let mut line_parts = vec![line.clone()];
let mut line_colors = vec![Color::Reset];
if let Some(indicies) = &boot_os_indicies {
let boot_index = indicies.get(0);
if boot_index.is_some_and(|i| i == &index) {
line_parts.push(String::from(" <-- Boot Partition"));
line_colors.push(Color::Cyan);
}
let boot_index = indicies.get(1);
if boot_index.is_some_and(|i| i == &index) {
line_parts.push(String::from(" <-- OS Partition"));
line_colors.push(Color::Cyan);
}
}
for line in &disk.parts_description {
description.push(DVLine {
line_parts,
line_colors,
});
line_parts: vec![line.clone()],
line_colors: vec![Color::Reset],
});
}
description
}

2
core/src/state.rs
View file

@ -35,7 +35,7 @@ pub enum Mode {
BootDiags,
BootSetup,
InjectDrivers,
SetBootMode,
ToggleSafeMode,
// Clone
ScanDisks,
InstallDrivers,

66
core/src/system/boot.rs
View file

@ -18,13 +18,6 @@ use crate::tasks::Task;
use color_eyre::Result;
use std::path::PathBuf;
#[derive(Clone, Debug, Default)]
pub enum SafeMode {
#[default]
Disable,
Enable,
}
pub fn configure_disk(
letter_boot: &str,
letter_os: &str,
@ -62,10 +55,25 @@ pub fn configure_disk(
}
// Lock in safe mode
tasks.push(
set_mode(letter_boot, SafeMode::Enable, system32, &table_type)
.expect("Failed to create set_mode task."),
);
let bcd_path = match table_type {
PartitionTableType::Guid => {
format!("{letter_boot}:\\EFI\\Microsoft\\Boot\\BCD")
}
PartitionTableType::Legacy => {
format!("{letter_boot}:\\Boot\\BCD")
}
};
tasks.push(Task::Command(
PathBuf::from(format!("{system32}/bcdedit.exe")),
vec![
String::from("/store"),
bcd_path,
String::from("/set"),
String::from("{default}"),
String::from("safeboot"),
String::from("minimal"),
],
));
// Done
tasks
@ -84,39 +92,3 @@ pub fn inject_driver(driver: &Driver, letter_os: &str, system32: &str) -> Result
],
))
}
pub fn set_mode(
letter_boot: &str,
mode: SafeMode,
system32: &str,
table_type: &PartitionTableType,
) -> Result<Task> {
let bcd_path = match table_type {
PartitionTableType::Guid => {
format!("{letter_boot}:\\EFI\\Microsoft\\Boot\\BCD")
}
PartitionTableType::Legacy => {
format!("{letter_boot}:\\Boot\\BCD")
}
};
// Build Command
let mut cmd_args = vec![String::from("/store"), bcd_path];
match mode {
SafeMode::Disable => {
cmd_args.push(String::from("/deletevalue"));
cmd_args.push(String::from("{default}"));
cmd_args.push(String::from("safeboot"));
}
SafeMode::Enable => {
cmd_args.push(String::from("/set"));
cmd_args.push(String::from("{default}"));
cmd_args.push(String::from("safeboot"));
cmd_args.push(String::from("minimal"));
}
}
Ok(Task::Command(
PathBuf::from(format!("{system32}/bcdedit.exe")),
cmd_args,
))
}

15
deja_vu/src/app.rs
View file

@ -120,7 +120,7 @@ impl App {
| Mode::DiagMenu
| Mode::InjectDrivers
| Mode::PEMenu
| Mode::SetBootMode => panic!("This shouldn't happen?"),
| Mode::ToggleSafeMode => panic!("This shouldn't happen?"),
};
new_mode
}
@ -144,7 +144,7 @@ impl App {
| Mode::DiagMenu
| Mode::InjectDrivers
| Mode::PEMenu
| Mode::SetBootMode => panic!("This shouldn't happen?"),
| Mode::ToggleSafeMode => panic!("This shouldn't happen?"),
};
if new_mode == self.cur_mode {
@ -576,20 +576,19 @@ fn build_footer_string(cur_mode: Mode) -> String {
String::from("(q) to quit")
}
Mode::SelectParts => String::from("(Enter) to select / (s) to start over / (q) to quit"),
Mode::InstallDrivers => String::from("(Enter) to select / (q) to quit"),
Mode::SelectDisks => String::from(
"(Enter) to select / / (i) to install driver / (r) to rescan / (q) to quit",
),
Mode::SelectTableType => String::from("(Enter) to select / (b) to go back / (q) to quit"),
Mode::Confirm => String::from("(Enter) to confirm / (b) to go back / (q) to quit"),
Mode::Done | Mode::Failed => String::from("(Enter) or (q) to quit"),
Mode::Done | Mode::Failed | Mode::InstallDrivers => String::from("(Enter) or (q) to quit"),
// Invalid states
Mode::BootDiags
| Mode::BootSetup
| Mode::DiagMenu
| Mode::InjectDrivers
| Mode::PEMenu
| Mode::SetBootMode => panic!("This shouldn't happen?"),
| Mode::ToggleSafeMode => panic!("This shouldn't happen?"),
}
}
@ -659,7 +658,7 @@ fn build_left_items(app: &App, cur_mode: Mode) -> Action {
| Mode::DiagMenu
| Mode::InjectDrivers
| Mode::PEMenu
| Mode::SetBootMode => panic!("This shouldn't happen?"),
| Mode::ToggleSafeMode => panic!("This shouldn't happen?"),
};
Action::UpdateLeft(title, labels, items, select_num)
}
@ -712,7 +711,7 @@ fn build_right_items(app: &App, cur_mode: Mode) -> Action {
let disk_list = app.clone.disk_list.lock().unwrap();
disk_list
.iter()
.for_each(|disk| items.push(get_disk_description_right(&disk, None)));
.for_each(|disk| items.push(get_disk_description_right(&disk)));
}
Mode::SelectParts => {
vec!["Boot", "OS"].iter().for_each(|s| {
@ -726,7 +725,7 @@ fn build_right_items(app: &App, cur_mode: Mode) -> Action {
let disk_list = app.clone.disk_list.lock().unwrap();
if let Some(disk) = disk_list.get(index) {
// Disk Details
items.push(get_disk_description_right(&disk, None));
items.push(get_disk_description_right(&disk));
// Partition Details
disk.parts