437 lines
17 KiB
Rust
437 lines
17 KiB
Rust
// src/tui/disk_manager.rs
|
|
use std::{
|
|
fs::{File, read_dir},
|
|
io::{self, Seek, SeekFrom},
|
|
path::PathBuf,
|
|
};
|
|
|
|
use crossterm::event::{self, Event, KeyCode};
|
|
use crossterm::execute;
|
|
use crossterm::terminal::{EnterAlternateScreen, LeaveAlternateScreen};
|
|
use gptman::{GPT, GPTPartitionEntry, PartitionName};
|
|
use tracing::{info, warn};
|
|
use tui::{
|
|
Terminal,
|
|
backend::CrosstermBackend,
|
|
layout::{Constraint, Direction, Layout},
|
|
style::{Color, Modifier, Style},
|
|
text::Span,
|
|
widgets::{Block, Borders, List, ListItem, Paragraph},
|
|
};
|
|
use uuid::Uuid;
|
|
|
|
/// DiskManager: interactive TUI to view and create GPT partitions on Linux.
|
|
///
|
|
/// Requirements (add to Cargo.toml):
|
|
/// tui = "0.19"
|
|
/// crossterm = "0.26"
|
|
/// gptman = "2.0"
|
|
/// uuid = { version = "1", features = ["v4"] }
|
|
/// tracing = "0.1"
|
|
pub struct DiskManager;
|
|
|
|
impl DiskManager {
|
|
/// Entrypoint: run the disk manager UI. This initializes the terminal and starts the loop.
|
|
pub fn run_tui() -> Result<(), Box<dyn std::error::Error>> {
|
|
// init terminal
|
|
let mut stdout = std::io::stdout();
|
|
execute!(stdout, EnterAlternateScreen)?;
|
|
let backend = CrosstermBackend::new(stdout);
|
|
let mut term = Terminal::new(backend)?;
|
|
term.clear()?;
|
|
|
|
// collect devices (linux-focused: sd*, nvme*, vd*)
|
|
let mut devices: Vec<PathBuf> = Vec::new();
|
|
if let Ok(entries) = read_dir("/dev/") {
|
|
for e in entries.flatten() {
|
|
let path = e.path();
|
|
if let Some(name) = path.file_name().and_then(|s| s.to_str()) {
|
|
if name.starts_with("sd")
|
|
|| name.starts_with("nvme")
|
|
|| name.starts_with("vd")
|
|
|| name.starts_with("mmcblk")
|
|
{
|
|
devices.push(path);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if devices.is_empty() {
|
|
// restore terminal before printing
|
|
execute!(term.backend_mut(), LeaveAlternateScreen)?;
|
|
println!("No block devices found under /dev (sd*, nvme*, vd*, mmcblk*).");
|
|
return Ok(());
|
|
}
|
|
|
|
let mut selected_idx = 0usize;
|
|
let mut status_msg =
|
|
String::from("Select disk. ↑/↓ to navigate, Enter=view, C=create, Q=quit.");
|
|
|
|
loop {
|
|
term.draw(|f| {
|
|
let size = f.size();
|
|
|
|
let chunks = Layout::default()
|
|
.direction(Direction::Vertical)
|
|
.margin(1)
|
|
.constraints(
|
|
[
|
|
Constraint::Length(3),
|
|
Constraint::Min(6),
|
|
Constraint::Length(3),
|
|
]
|
|
.as_ref(),
|
|
)
|
|
.split(size);
|
|
|
|
// header
|
|
let header = Paragraph::new(Span::styled(
|
|
"🔧 Disk Manager — Linux GPT (use carefully!)",
|
|
Style::default().add_modifier(Modifier::BOLD),
|
|
))
|
|
.block(Block::default().borders(Borders::ALL));
|
|
f.render_widget(header, chunks[0]);
|
|
|
|
// device list + selection
|
|
let items: Vec<ListItem> = devices
|
|
.iter()
|
|
.enumerate()
|
|
.map(|(i, d)| {
|
|
let label = format!(
|
|
"{} {}",
|
|
if i == selected_idx { "▶" } else { " " },
|
|
d.display()
|
|
);
|
|
let mut li = ListItem::new(label);
|
|
if i == selected_idx {
|
|
li = li.style(Style::default().fg(Color::Yellow));
|
|
}
|
|
li
|
|
})
|
|
.collect();
|
|
|
|
let list =
|
|
List::new(items).block(Block::default().borders(Borders::ALL).title("Disks"));
|
|
f.render_widget(list, chunks[1]);
|
|
|
|
// status/footer
|
|
let footer = Paragraph::new(status_msg.as_str())
|
|
.style(Style::default().fg(Color::Green))
|
|
.block(Block::default().borders(Borders::ALL).title("Status"));
|
|
f.render_widget(footer, chunks[2]);
|
|
})?;
|
|
|
|
// Input handling
|
|
if event::poll(std::time::Duration::from_millis(100))? {
|
|
if let Event::Key(key) = event::read()? {
|
|
match key.code {
|
|
KeyCode::Char('q') | KeyCode::Char('Q') => break,
|
|
KeyCode::Up => {
|
|
if selected_idx > 0 {
|
|
selected_idx -= 1;
|
|
}
|
|
}
|
|
KeyCode::Down => {
|
|
if selected_idx + 1 < devices.len() {
|
|
selected_idx += 1;
|
|
}
|
|
}
|
|
KeyCode::Enter => {
|
|
let path = devices[selected_idx].clone();
|
|
match Self::view_partitions_tui(&path, &mut term) {
|
|
Ok(m) => status_msg = m,
|
|
Err(e) => status_msg = format!("Error reading partitions: {}", e),
|
|
}
|
|
}
|
|
KeyCode::Char('c') | KeyCode::Char('C') => {
|
|
let path = devices[selected_idx].clone();
|
|
match Self::create_partition_tui(&path, &mut term) {
|
|
Ok(m) => {
|
|
info!(target: "disk_manager", "{}", m);
|
|
status_msg = m;
|
|
}
|
|
Err(e) => {
|
|
warn!(target: "disk_manager", "create partition error: {:?}", e);
|
|
status_msg = format!("Create failed: {}", e);
|
|
}
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// restore terminal
|
|
execute!(term.backend_mut(), LeaveAlternateScreen)?;
|
|
term.show_cursor()?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Show GPT partitions for the chosen disk in a paged TUI view.
|
|
fn view_partitions_tui(
|
|
disk: &PathBuf,
|
|
term: &mut Terminal<CrosstermBackend<std::io::Stdout>>,
|
|
) -> Result<String, Box<dyn std::error::Error>> {
|
|
// try to open & read GPT (512 sector size)
|
|
let mut file = File::open(disk)?;
|
|
let gpt = match GPT::read_from(&mut file, 512) {
|
|
Ok(g) => g,
|
|
Err(_) => match GPT::find_from(&mut file) {
|
|
Ok(g) => g,
|
|
Err(_) => {
|
|
return Ok(format!("No GPT found on {}", disk.display()));
|
|
}
|
|
},
|
|
};
|
|
|
|
// Create list of lines to display using public GPT API:
|
|
let mut lines: Vec<String> = Vec::new();
|
|
lines.push(format!("Partitions on {}:", disk.display()));
|
|
for (i, entry) in gpt.iter() {
|
|
if entry.is_used() {
|
|
let name = entry.partition_name.as_str();
|
|
lines.push(format!(
|
|
"{}: {} -> {} (type: {})",
|
|
i,
|
|
entry.starting_lba,
|
|
entry.ending_lba,
|
|
// show a short GUID hex for partition type
|
|
hex::encode_upper(&entry.partition_type_guid)
|
|
));
|
|
lines.push(format!(" name: {}", name));
|
|
}
|
|
}
|
|
if lines.len() == 1 {
|
|
lines.push("No partitions found.".into());
|
|
}
|
|
// paged view loop
|
|
let mut top = 0usize;
|
|
loop {
|
|
term.draw(|f| {
|
|
let size = f.size();
|
|
let chunks = Layout::default()
|
|
.direction(Direction::Vertical)
|
|
.margin(1)
|
|
.constraints([Constraint::Min(1), Constraint::Length(1)].as_ref())
|
|
.split(size);
|
|
|
|
let page_lines: Vec<ListItem> = lines
|
|
.iter()
|
|
.skip(top)
|
|
.take((chunks[0].height as usize).saturating_sub(2))
|
|
.map(|l| ListItem::new(l.clone()))
|
|
.collect();
|
|
|
|
let list = List::new(page_lines).block(
|
|
Block::default()
|
|
.borders(Borders::ALL)
|
|
.title(format!("Partitions: {}", disk.display())),
|
|
);
|
|
f.render_widget(list, chunks[0]);
|
|
|
|
let footer = Paragraph::new("↑/↓ scroll • q to go back")
|
|
.block(Block::default().borders(Borders::ALL));
|
|
f.render_widget(footer, chunks[1]);
|
|
})?;
|
|
|
|
if event::poll(std::time::Duration::from_millis(100))? {
|
|
if let Event::Key(k) = event::read()? {
|
|
match k.code {
|
|
KeyCode::Char('q') | KeyCode::Esc => break,
|
|
KeyCode::Up => {
|
|
if top > 0 {
|
|
top = top.saturating_sub(1);
|
|
}
|
|
}
|
|
KeyCode::Down => {
|
|
if top + 1 < lines.len() {
|
|
top = top.saturating_add(1);
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(format!("Viewed partitions on {}", disk.display()))
|
|
}
|
|
|
|
/// Fully-TUI flow to enter partition name, size (MB), and choose partition type.
|
|
/// Writes GPT changes to disk.
|
|
fn create_partition_tui(
|
|
disk: &PathBuf,
|
|
term: &mut Terminal<CrosstermBackend<std::io::Stdout>>,
|
|
) -> Result<String, Box<dyn std::error::Error>> {
|
|
// open file read+write
|
|
let mut file = File::options().read(true).write(true).open(disk)?;
|
|
|
|
// Read or create GPT
|
|
let mut gpt = match GPT::read_from(&mut file, 512) {
|
|
Ok(g) => g,
|
|
Err(_) => match GPT::find_from(&mut file) {
|
|
Ok(g) => g,
|
|
Err(_) => {
|
|
// If there's no GPT, create one with a random disk GUID
|
|
let disk_guid_raw: [u8; 16] = *Uuid::new_v4().as_bytes();
|
|
// new_from requires a Seek+Read; create new GPT structure on-disk
|
|
GPT::new_from(&mut file, 512, disk_guid_raw)?
|
|
}
|
|
},
|
|
};
|
|
|
|
// interactive fields
|
|
let mut name = String::from("new_partition");
|
|
let mut size_mb: u64 = 100; // default 100 MB
|
|
let mut type_choice = 1usize; // 0 = EFI, 1 = Linux filesystem
|
|
|
|
// known GUIDs (string repr) -> will be parsed to raw bytes as required
|
|
let efi_guid = Uuid::parse_str("C12A7328-F81F-11D2-BA4B-00A0C93EC93B")?; // EFI System
|
|
let linux_fs_guid = Uuid::parse_str("0FC63DAF-8483-4772-8E79-3D69D8477DE4")?; // Linux filesystem
|
|
|
|
loop {
|
|
// Render UI
|
|
term.draw(|f| {
|
|
let size = f.size();
|
|
let chunks = Layout::default()
|
|
.direction(Direction::Vertical)
|
|
.margin(1)
|
|
.constraints(
|
|
[
|
|
Constraint::Length(3),
|
|
Constraint::Length(3),
|
|
Constraint::Length(3),
|
|
Constraint::Min(3),
|
|
]
|
|
.as_ref(),
|
|
)
|
|
.split(size);
|
|
|
|
let title = Paragraph::new(Span::styled(
|
|
format!("Create partition on {}", disk.display()),
|
|
Style::default().add_modifier(Modifier::BOLD),
|
|
))
|
|
.block(Block::default().borders(Borders::ALL));
|
|
f.render_widget(title, chunks[0]);
|
|
|
|
let name_widget = Paragraph::new(format!("Name: {}", name)).block(
|
|
Block::default()
|
|
.borders(Borders::ALL)
|
|
.title("Partition Name"),
|
|
);
|
|
f.render_widget(name_widget, chunks[1]);
|
|
|
|
let size_widget = Paragraph::new(format!("Size (MB): {}", size_mb))
|
|
.block(Block::default().borders(Borders::ALL).title("Size"));
|
|
f.render_widget(size_widget, chunks[2]);
|
|
|
|
let types = vec![
|
|
format!(
|
|
"{} EFI System Partition",
|
|
if type_choice == 0 { "▶" } else { " " }
|
|
),
|
|
format!(
|
|
"{} Linux filesystem",
|
|
if type_choice == 1 { "▶" } else { " " }
|
|
),
|
|
];
|
|
let type_items: Vec<ListItem> = types.into_iter().map(ListItem::new).collect();
|
|
let type_list = List::new(type_items).block(
|
|
Block::default()
|
|
.borders(Borders::ALL)
|
|
.title("Partition Type (use ←/→)"),
|
|
);
|
|
f.render_widget(type_list, chunks[3]);
|
|
})?;
|
|
|
|
// Input
|
|
if event::poll(std::time::Duration::from_millis(100))? {
|
|
if let Event::Key(k) = event::read()? {
|
|
match k.code {
|
|
KeyCode::Char('q') | KeyCode::Esc => {
|
|
return Ok("Creation cancelled".to_string());
|
|
}
|
|
KeyCode::Left => {
|
|
type_choice = type_choice.saturating_sub(1);
|
|
}
|
|
KeyCode::Right => {
|
|
type_choice = (type_choice + 1) % 2;
|
|
}
|
|
KeyCode::Char(c) => {
|
|
// typing to name: accept visible characters; digits typed also append
|
|
if !c.is_control() {
|
|
name.push(c);
|
|
}
|
|
}
|
|
KeyCode::Backspace => {
|
|
name.pop();
|
|
}
|
|
KeyCode::Up => {
|
|
// increase size by 10MB
|
|
size_mb = size_mb.saturating_add(10);
|
|
}
|
|
KeyCode::Down => {
|
|
size_mb = size_mb.saturating_sub(10);
|
|
}
|
|
KeyCode::Enter => {
|
|
break;
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// convert MB -> sectors (512 bytes per sector)
|
|
let sectors = (size_mb as u128 * 1024 * 1024 / 512) as u64;
|
|
// choose starting LBA: find max ending_lba among existing partitions; align to 2048
|
|
let last_end = gpt
|
|
.iter()
|
|
.filter(|(_, e)| e.is_used())
|
|
.map(|(_, e)| e.ending_lba)
|
|
.max()
|
|
.unwrap_or(2048);
|
|
let start = ((last_end + 2048) / 2048) * 2048 + 1;
|
|
let end = start + sectors.saturating_sub(1);
|
|
|
|
// build partition entry
|
|
let mut new_entry = GPTPartitionEntry::empty();
|
|
new_entry.starting_lba = start;
|
|
new_entry.ending_lba = end;
|
|
new_entry.partition_name = PartitionName::from(name.as_str());
|
|
|
|
// set partition type GUID
|
|
let type_guid = if type_choice == 0 {
|
|
*efi_guid.as_bytes()
|
|
} else {
|
|
*linux_fs_guid.as_bytes()
|
|
};
|
|
new_entry.partition_type_guid = type_guid;
|
|
|
|
// find first empty partition slot (indexing is 1-based for gptman::GPT)
|
|
let idx_opt = gpt.iter().find(|(_, e)| e.is_unused()).map(|(i, _)| i);
|
|
let idx = match idx_opt {
|
|
Some(i) => i,
|
|
None => return Err("No free GPT partition entries (maxed out)".into()),
|
|
};
|
|
|
|
// assign and write
|
|
gpt[idx] = new_entry;
|
|
|
|
// Seek to start (important)
|
|
file.seek(SeekFrom::Start(0))?;
|
|
gpt.write_into(&mut file)
|
|
.map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
|
|
|
|
Ok(format!(
|
|
"Created partition '{}' on {} ({} MB, sectors {}..{})",
|
|
name,
|
|
disk.display(),
|
|
size_mb,
|
|
start,
|
|
end
|
|
))
|
|
}
|
|
}
|