pub mod app;
pub mod collect;
pub mod config;
pub mod lansetup;
pub mod log;
pub mod replay;
pub mod report;
pub mod snapshot;
pub mod theme;
pub mod theme_data;
pub mod ui;
pub mod watch;
use std::io::{self, stdout, Write};
use std::path::PathBuf;
use std::time::{Duration, Instant};
use anyhow::Result;
use crossterm::{
event::{
self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEventKind, KeyModifiers,
KeyboardEnhancementFlags, MouseEventKind, PopKeyboardEnhancementFlags,
PushKeyboardEnhancementFlags,
},
execute,
terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
};
use ratatui::{backend::CrosstermBackend, Terminal};
use app::{App, MenuState};
type Tui = Terminal<CrosstermBackend<io::Stdout>>;
fn early_exit(args: &[String]) -> Option<Result<()>> {
if args.iter().any(|a| a == "--help" || a == "-h") {
let prog = args
.first()
.and_then(|a| std::path::Path::new(a).file_name())
.and_then(|n| n.to_str())
.unwrap_or("ltop");
println!("{}", usage_text(prog));
return Some(Ok(()));
}
if args.iter().any(|a| a == "--version" || a == "-V") {
println!("ltop {}", env!("CARGO_PKG_VERSION"));
return Some(Ok(()));
}
let known = [
"--json",
"--schema",
"--dump",
"--log",
"--log-interval",
"--follow-theme",
"--theme",
"--replay",
"--top",
"--csv",
"--help",
"-h",
"--version",
"-V",
];
if let Some(bad) = args
.iter()
.skip(1)
.find(|a| a.starts_with("--") && !known.contains(&a.as_str()))
{
usage_warn(
&format!("ltop: unknown option {bad} (try --help)"),
&format!("ltop: 未知选项 {bad}(试 --help)"),
);
return Some(Err(anyhow::anyhow!("unknown option")));
}
None
}
pub(crate) fn usage_warn(en: &str, zh: &str) {
eprintln!("{}", crate::pick_s(cli_lang_zh(), en, zh));
}
fn usage_text(prog: &str) -> String {
format!(
"ltop v{} — btop-styled TUI monitoring for local network, LAN neighbours and disk I/O
USAGE:
{prog} [OPTIONS]
(no options) run the TUI
watch [OPTIONS] headless capture to a schema-v1 JSONL file
report <FILE> [OPTIONS] window summary of a watch/monlog JSONL (--json for AI)
lan-setup [--remove] macOS: install/remove the snapshot agent (real MACs
behind the macOS 27 privacy gate; see docs)
--json AI-friendly structured snapshot (JSON, schema v1)
--schema field reference for --json (machine-readable)
--dump one-shot diagnostic dump to stdout, then exit
--log start the TUI with the monitoring log enabled
--log-interval <MS> monitoring log interval in ms (with --log; default from settings)
--follow-theme live-follow Omarchy theme changes while running (default off)
--theme <FILE> load a btop/Omarchy theme file for this session (fixed, not followed)
--replay [FILE] replay/analyse the latest session log (or a given JSONL file)
--top <N> replay: report the top N processes (default 15)
--csv <OUT> replay: also export per-process deltas as CSV
-h, --help print this help
-V, --version print version
eBPF per-process/per-connection accounting needs the privileged helper:
sudo systemctl enable --now ltop-bpf
Data scopes differ by design (PROCS = payload, NET box = NIC bytes) — see in-app help (m → help).",
env!("CARGO_PKG_VERSION")
)
}
#[cfg(target_os = "macos")]
fn disable_app_nap() {
use std::ffi::c_void;
use std::os::raw::c_char;
#[link(name = "objc", kind = "dylib")]
extern "C" {
fn objc_getClass(name: *const c_char) -> *mut c_void;
fn sel_registerName(name: *const c_char) -> *mut c_void;
fn objc_msgSend();
}
type Id = *mut c_void;
unsafe {
libc::dlopen(
c"/System/Library/Frameworks/Foundation.framework/Foundation".as_ptr() as *const c_char,
libc::RTLD_LAZY,
);
let cls = objc_getClass(c"NSProcessInfo".as_ptr());
if cls.is_null() {
return;
}
let msg2: unsafe extern "C" fn(Id, Id) -> Id =
std::mem::transmute(objc_msgSend as *const ());
let msg3: unsafe extern "C" fn(Id, Id, *const c_char) -> Id =
std::mem::transmute(objc_msgSend as *const ());
let msg4: unsafe extern "C" fn(Id, Id, u64, Id) -> u64 =
std::mem::transmute(objc_msgSend as *const ());
let pi = msg2(cls, sel_registerName(c"processInfo".as_ptr()));
if pi.is_null() {
return;
}
let nsstr = objc_getClass(c"NSString".as_ptr());
if nsstr.is_null() {
return;
}
let reason = msg3(
nsstr,
sel_registerName(c"stringWithUTF8String:".as_ptr()),
c"ltop monitoring tick".as_ptr(),
);
if reason.is_null() {
return;
}
let _token = msg4(
pi,
sel_registerName(c"beginActivityWithOptions:reason:".as_ptr()),
1 << 21,
reason,
);
}
}
pub fn arch_guard() -> Result<()> {
let ok = match std::env::consts::OS {
"linux" => matches!(std::env::consts::ARCH, "x86_64" | "aarch64"),
"macos" => matches!(std::env::consts::ARCH, "x86_64" | "aarch64"),
_ => false,
};
if !ok {
anyhow::bail!(
"ltop v{} supports Linux and macOS on x86_64/aarch64 (running on {} {}); \
see README",
env!("CARGO_PKG_VERSION"),
std::env::consts::OS,
std::env::consts::ARCH
);
}
Ok(())
}
pub fn cli_main() -> Result<()> {
unsafe {
libc::signal(libc::SIGPIPE, libc::SIG_DFL);
}
#[cfg(target_os = "macos")]
disable_app_nap();
let args: Vec<String> = std::env::args().collect();
match args.get(1).map(String::as_str) {
Some("watch") => return watch::run(&args[2..]),
Some("lan-setup") => return lansetup::run(&args[2..]),
Some("report") => return report::run(&args[2..]),
Some(cmd) if !cmd.starts_with('-') => {
usage_warn(
&format!(
"ltop: unknown command {cmd:?} (subcommands: watch, report, lan-setup; try --help)"
),
&format!(
"ltop: 未知命令 {cmd:?}(可用:watch、report、lan-setup;试 --help)"
),
);
return Err(anyhow::anyhow!("unknown command"));
}
_ => {}
}
if let Some(res) = early_exit(&args) {
return res;
}
arch_guard()?;
config::Config::migrate_legacy_dirs();
if args.iter().any(|a| a == "--replay") {
return replay::run_replay(&args);
}
let theme_src = theme::init();
let boot_cfg = config::Config::load();
let theme_fixed_by_cli = args.iter().any(|a| a == "--theme");
if !theme_fixed_by_cli && boot_cfg.theme != "omarchy" {
let _ = theme::apply_by_name(&boot_cfg.theme);
}
if args.iter().any(|a| a == "--json") {
return json_snapshot();
}
if args.iter().any(|a| a == "--schema") {
return print_schema();
}
if args.iter().any(|a| a == "--dump") {
return dump(&theme_src);
}
let auto_log = args.iter().any(|a| a == "--log");
let follow_theme = args.iter().any(|a| a == "--follow-theme") || boot_cfg.theme_live_follow;
let log_interval: Option<Duration> = args
.iter()
.position(|a| a == "--log-interval")
.and_then(|i| args.get(i + 1))
.and_then(|v| v.parse::<u64>().ok())
.map(Duration::from_millis);
let mut terminal = setup()?;
let default_hook = std::panic::take_hook();
std::panic::set_hook(Box::new(move |info| {
let _ = restore();
default_hook(info);
}));
let res = run(&mut terminal, log_interval, auto_log, follow_theme);
restore()?;
if let Ok(Some(path)) = &res {
eprintln!(
"{}",
pick_s(
cli_lang_zh(),
&format!("ltop: monitoring log saved to {}", path.display()),
&format!("ltop: 监控日志已保存到 {}", path.display())
)
);
}
res.map(|_| ())
}
fn setup() -> Result<Tui> {
enable_raw_mode()?;
execute!(
stdout(),
EnterAlternateScreen,
EnableMouseCapture,
PushKeyboardEnhancementFlags(KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES)
)?;
Ok(Terminal::new(CrosstermBackend::new(stdout()))?)
}
fn restore() -> Result<()> {
disable_raw_mode()?;
execute!(
stdout(),
PopKeyboardEnhancementFlags,
LeaveAlternateScreen,
DisableMouseCapture
)?;
Ok(())
}
fn run(
terminal: &mut Tui,
log_interval: Option<Duration>,
auto_log: bool,
follow_theme: bool,
) -> Result<Option<PathBuf>> {
let mut app = App::new(log_interval);
app.theme_live_follow = app.theme_live_follow || follow_theme;
if auto_log {
app.log.toggle();
}
app.update();
std::thread::sleep(Duration::from_millis(350));
app.update();
let mut last_tick = Instant::now();
while !app.quit {
terminal.draw(|f| ui::draw(f, &app))?;
let timeout = app.tick.saturating_sub(last_tick.elapsed());
if event::poll(timeout)? {
match event::read()? {
Event::Key(key) if key.kind == KeyEventKind::Press => {
handle_key(&mut app, key.code, key.modifiers);
}
Event::Mouse(m) => handle_mouse(&mut app, &m),
_ => {}
}
}
if last_tick.elapsed() >= app.tick {
if app.theme_live_follow {
theme::poll_omarchy_follow();
}
app.update();
last_tick = Instant::now();
}
}
let log_path = app.log.finalize();
Ok(log_path)
}
fn osc52_copy(text: &str) {
const T: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
let mut b64 = String::new();
for chunk in text.as_bytes().chunks(3) {
let b = [
chunk[0],
*chunk.get(1).unwrap_or(&0),
*chunk.get(2).unwrap_or(&0),
];
let n = (u32::from(b[0]) << 16) | (u32::from(b[1]) << 8) | u32::from(b[2]);
b64.push(T[(n >> 18) as usize & 63] as char);
b64.push(T[(n >> 12) as usize & 63] as char);
b64.push(if chunk.len() > 1 {
T[(n >> 6) as usize & 63] as char
} else {
'='
});
b64.push(if chunk.len() > 2 {
T[n as usize & 63] as char
} else {
'='
});
}
let _ = write!(stdout(), "\x1b]52;c;{b64}\x07");
let _ = stdout().flush();
}
pub(crate) fn sanitize_text(s: &str) -> String {
s.chars().filter(|c| !c.is_control()).collect()
}
fn cycle_setting(app: &mut App, sel: usize, forward: bool) -> bool {
const TICKS: [u64; 5] = [250, 500, 1000, 2000, 5000];
const LOGS: [u64; 5] = [10_000, 30_000, 60_000, 300_000, 600_000];
const RETENTION: [u32; 3] = [7, 30, 0];
const SWEEPS: [u64; 4] = [30, 60, 120, 300];
const TOMBS: [u64; 4] = [0, 3000, 5000, 8000];
fn step_in(list: &[u64], cur: u64, forward: bool) -> u64 {
let i = list.iter().position(|&v| v == cur).unwrap_or(0);
let n = list.len();
list[if forward {
(i + 1) % n
} else {
(i + n - 1) % n
}]
}
fn step_u32(list: &[u32], cur: u32, forward: bool) -> u32 {
let i = list.iter().position(|&v| v == cur).unwrap_or(0);
let n = list.len();
list[if forward {
(i + 1) % n
} else {
(i + n - 1) % n
}]
}
match sel {
0 => {
app.lang = app.lang.next();
true
}
1 => {
let ms = step_in(&TICKS, app.tick.as_millis() as u64, forward);
app.tick = Duration::from_millis(ms);
true
}
2 => {
app.layout = if forward {
app.layout.next()
} else {
app.layout.prev()
};
true
}
3 => {
app.graph_net = if forward {
app.graph_net.next_with_block()
} else {
app.graph_net.prev_with_block()
};
true
}
4 => {
app.graph_disk = if forward {
app.graph_disk.next_with_block()
} else {
app.graph_disk.prev_with_block()
};
true
}
5 => {
app.log.toggle();
true
}
6 => {
app.allow_global_log = !app.allow_global_log;
true
}
7 => {
let ms = step_in(&LOGS, app.log.interval.as_millis() as u64, forward);
app.log.interval = Duration::from_millis(ms);
true
}
8 => {
let d = step_u32(&RETENTION, app.log.retention_days, forward);
app.log.retention_days = d;
let _ = app.log.purge_old();
true
}
9 => {
app.log_tracked_only = !app.log_tracked_only;
true
}
10 => {
let s = step_in(&SWEEPS, app.lan.sweep_interval.as_secs(), forward);
app.lan.sweep_interval = Duration::from_secs(s);
true
}
11 => {
app.lan.sweep_enabled = !app.lan.sweep_enabled;
true
}
12 => {
let cur = app.conn.tombstone_ttl.as_millis() as u64;
let i = TOMBS.iter().position(|&v| v == cur).map_or(0, |i| {
if forward {
(i + 1) % TOMBS.len()
} else {
(i + TOMBS.len() - 1) % TOMBS.len()
}
});
app.conn.tombstone_ttl = std::time::Duration::from_millis(TOMBS[i]);
true
}
13 => {
app.proc_expand_default = !app.proc_expand_default;
true
}
14 => {
app.allow_global_kill = !app.allow_global_kill;
true
}
_ => false,
}
}
fn handle_key(app: &mut App, code: KeyCode, modifiers: KeyModifiers) {
if let Ok(path) = std::env::var("LTOP_KEY_LOG") {
use std::io::Write;
if let Ok(mut f) = std::fs::OpenOptions::new()
.create(true)
.append(true)
.open(path)
{
let _ = writeln!(f, "{code:?} {modifiers:?}");
}
}
if modifiers.contains(KeyModifiers::CONTROL) && code == KeyCode::Char('c') {
app.quit = true;
return;
}
match app.menu {
MenuState::None => match code {
KeyCode::Char('q') => app.quit = true,
KeyCode::Char('z') => {
if app.zoom.is_some() {
app.zoom = None;
} else if matches!(
app.last_focus,
crate::app::BOX_LAN | crate::app::BOX_CONNS | crate::app::BOX_PROCS
) && app.visible[app.last_focus]
{
app.zoom = Some(app.last_focus);
}
}
KeyCode::Esc if app.zoom.is_some() => {
for f in app.focus.iter_mut() {
*f = false;
}
}
KeyCode::Char(' ') => app.paused = !app.paused,
KeyCode::Char('/') => {
app.search_buf = app.search.clone();
app.menu = MenuState::Search;
}
KeyCode::Esc => {
app.conn.peer_filter = None; for f in app.focus.iter_mut() {
*f = false;
}
for s in app.sel.iter_mut() {
*s = None;
}
}
KeyCode::Char('m') => app.menu = MenuState::Main(0),
KeyCode::Char(c @ '1'..='6')
if !modifiers.intersects(KeyModifiers::ALT | KeyModifiers::CONTROL) =>
{
let idx = (c as usize - '1' as usize).min(app::BOX_COUNT - 1);
let shown = app.visible.iter().filter(|&&v| v).count();
if !(app.visible[idx] && shown <= 1) {
app.visible[idx] = !app.visible[idx];
}
}
KeyCode::Tab => app.layout = app.layout.next(),
KeyCode::Char('n') => {
app.net.cycle_selected();
app.last_focus = app::BOX_NET;
}
KeyCode::Char('p') => {
let on = !app.focus[app::BOX_PROCS];
app.focus[app::BOX_PROCS] = on;
app.focus[app::BOX_CONNS] = false;
app.focus[app::BOX_LAN] = false;
app.last_focus = app::BOX_PROCS;
}
KeyCode::Char('c') => {
let on = !app.focus[app::BOX_CONNS];
app.focus[app::BOX_CONNS] = on;
app.focus[app::BOX_PROCS] = false;
app.focus[app::BOX_LAN] = false;
app.last_focus = app::BOX_CONNS;
}
KeyCode::Char('l') => {
let on = !app.focus[app::BOX_LAN];
app.focus[app::BOX_LAN] = on;
app.focus[app::BOX_PROCS] = false;
app.focus[app::BOX_CONNS] = false;
app.last_focus = app::BOX_LAN;
}
KeyCode::Char('e') => app.lan.sort = app.lan.sort.next(),
KeyCode::Char('i') => {
app.io_graph = app.io_graph.next();
app.last_focus = app::BOX_DISKIO;
}
KeyCode::Char('r') => app.proc.sort = app.proc.sort.next(),
KeyCode::Char('d') => {
app.disks_expanded = !app.disks_expanded;
app.last_focus = app::BOX_DISKS;
}
KeyCode::Char('f') => {
app.conn.filter = app.conn.filter.next();
app.conn.peer_filter = None; }
KeyCode::Char('o') => app.conn.sort = app.conn.sort.next(),
KeyCode::Left | KeyCode::Right => {
let b = app.last_focus;
if b == app::BOX_CONNS && app.focus[b] && ui::selected_is_agg(app, b) {
if let Some(key) = ui::selected_agg_key(app, b) {
let open = code == KeyCode::Right;
ui::set_group_open(app, &key, open);
}
}
}
KeyCode::Char('k') => {
if app.allow_global_kill {
let b = app.last_focus;
if app.focus[b] {
if let Some(pid) = ui::selected_pid(app, b) {
kill_pid(pid);
}
}
}
}
KeyCode::Char('L') => {
if app.allow_global_log {
app.log.toggle();
}
}
KeyCode::Enter => {
let b = app.last_focus;
if app.focus[b] {
if b == app::BOX_LAN {
if let Some(id) = ui::selected_id(app, b) {
let ip = std::net::Ipv4Addr::from(id as u32);
if app.lan.tracked.contains(&ip) {
app.lan.tracked.remove(&ip);
app.conn.peer_filter = None;
} else {
app.lan.tracked.clear();
app.lan.tracked.insert(ip);
app.conn.peer_filter = Some(ip);
}
ui::reselect(app, app::BOX_LAN, id);
}
} else if b == app::BOX_CONNS && ui::selected_is_agg(app, b) {
if let Some(key) = ui::selected_agg_key(app, b) {
ui::toggle_group(app, &key);
}
} else if let Some(id) = ui::selected_id(app, b) {
app.detail_sel = 0;
app.menu = MenuState::Detail(b, id);
}
}
}
KeyCode::Up => {
let b = app.last_focus;
if app.focus[b] {
ui::move_selection(app, b, -1);
} else {
app.scroll[b] = app.scroll[b].saturating_sub(3);
}
}
KeyCode::Home | KeyCode::Char('g')
if !modifiers.intersects(KeyModifiers::ALT | KeyModifiers::CONTROL) =>
{
let b = app.last_focus;
if app.focus[b] {
ui::jump_selection(app, b, true);
} else {
app.scroll[b] = 0;
}
}
KeyCode::End | KeyCode::Char('G')
if !modifiers.intersects(KeyModifiers::ALT | KeyModifiers::CONTROL) =>
{
let b = app.last_focus;
if app.focus[b] {
ui::jump_selection(app, b, false);
} else {
app.scroll[b] = usize::MAX;
}
}
KeyCode::Down => {
let b = app.last_focus;
if app.focus[b] {
ui::move_selection(app, b, 1);
} else {
app.scroll[b] = app.scroll[b].saturating_add(3);
}
}
KeyCode::PageUp => {
let page = ui::box_capacity(app.last_focus).max(1);
app.scroll[app.last_focus] = app.scroll[app.last_focus].saturating_sub(page);
}
KeyCode::PageDown => {
let page = ui::box_capacity(app.last_focus).max(1);
app.scroll[app.last_focus] = app.scroll[app.last_focus].saturating_add(page);
}
KeyCode::Char('s') => {
app.lan.sweep_enabled = !app.lan.sweep_enabled;
if app.lan.sweep_enabled {
app.lan.sweep_now();
}
}
KeyCode::Char('+') | KeyCode::Char('=') => {
app.tick = (app.tick + Duration::from_millis(250)).min(Duration::from_secs(5));
}
KeyCode::Char('-') => {
app.tick = app
.tick
.saturating_sub(Duration::from_millis(250))
.max(Duration::from_millis(250));
}
_ => {}
},
MenuState::Main(sel) => {
const BUTTONS: usize = 7;
match code {
KeyCode::Left | KeyCode::Char('h') => {
app.menu = MenuState::Main((sel + BUTTONS - 1) % BUTTONS)
}
KeyCode::Right | KeyCode::Char('l') => {
app.menu = MenuState::Main((sel + 1) % BUTTONS)
}
KeyCode::Enter => match sel {
0 => app.menu = MenuState::Theme(0, 0),
1 => app.menu = MenuState::Settings(0),
2 => app.menu = MenuState::Reset(0),
3 => app.menu = MenuState::Graphs(0),
4 => app.menu = MenuState::Help,
5 => app.quit = true,
_ => app.menu = MenuState::None,
},
KeyCode::Esc | KeyCode::Char('q') | KeyCode::Char('m') => {
app.menu = MenuState::None
}
_ => {}
}
}
MenuState::Settings(sel) => {
const ROWS: usize = 15;
let changed = match code {
KeyCode::Up | KeyCode::Char('k') => {
app.menu = MenuState::Settings(sel.saturating_sub(1));
false
}
KeyCode::Down | KeyCode::Char('j') => {
app.menu = MenuState::Settings((sel + 1).min(ROWS - 1));
false
}
KeyCode::Enter | KeyCode::Right | KeyCode::Char('l') => {
cycle_setting(app, sel, true)
}
KeyCode::Left | KeyCode::Char('h') => cycle_setting(app, sel, false),
KeyCode::Esc | KeyCode::Char('q') | KeyCode::Char('m') => {
app.menu = MenuState::None;
false
}
_ => false,
};
if changed {
app.save_config();
}
}
MenuState::Theme(sel, scroll) => match code {
KeyCode::Up | KeyCode::Char('k') => {
if sel > 0 {
let scroll = if sel - 1 < scroll { scroll - 1 } else { scroll };
app.menu = MenuState::Theme(sel - 1, scroll);
}
}
KeyCode::Down | KeyCode::Char('j') => {
let count = theme::builtin_count() + 1;
if sel + 1 < count {
let scroll = if sel + 1 >= scroll + ui::THEME_VISIBLE {
scroll + 1
} else {
scroll
};
app.menu = MenuState::Theme(sel + 1, scroll);
}
}
KeyCode::Enter => {
let ok = if sel == 0 {
theme::apply_omarchy()
} else {
theme::apply_builtin(sel - 1)
};
if ok {
app.save_config();
}
}
KeyCode::Esc | KeyCode::Char('q') | KeyCode::Char('m') => app.menu = MenuState::None,
_ => {}
},
MenuState::Reset(sel) => match code {
KeyCode::Up | KeyCode::Char('k') => app.menu = MenuState::Reset(sel.saturating_sub(1)),
KeyCode::Down | KeyCode::Char('j') => app.menu = MenuState::Reset((sel + 1).min(2)),
KeyCode::Enter => {
match sel {
0 => app.reset_net(),
1 => app.reset_disk(),
_ => app.reset_all(),
}
app.menu = MenuState::None;
}
KeyCode::Char('n') => {
app.reset_net();
app.menu = MenuState::None;
}
KeyCode::Char('d') => {
app.reset_disk();
app.menu = MenuState::None;
}
KeyCode::Char('a') => {
app.reset_all();
app.menu = MenuState::None;
}
KeyCode::Esc | KeyCode::Char('q') | KeyCode::Char('m') => app.menu = MenuState::None,
_ => {}
},
MenuState::Graphs(sel) => match code {
KeyCode::Up | KeyCode::Char('k') => app.menu = MenuState::Graphs(sel.saturating_sub(1)),
KeyCode::Down | KeyCode::Char('j') => app.menu = MenuState::Graphs((sel + 1).min(4)),
KeyCode::Right | KeyCode::Char('l') => match sel {
0 => app.graph_net = app.graph_net.next_with_block(),
1 => app.graph_disk = app.graph_disk.next_with_block(),
2 => {
let s = app.graph_net.next_with_block();
app.graph_net = s;
app.graph_disk = s;
}
3 => app.net_graph_coupled = !app.net_graph_coupled,
4 => app.net_graph_scale_ratio = next_scale_ratio(app.net_graph_scale_ratio),
_ => {}
},
KeyCode::Left | KeyCode::Char('h') => match sel {
0 => app.graph_net = app.graph_net.prev_with_block(),
1 => app.graph_disk = app.graph_disk.prev_with_block(),
2 => {
let s = app.graph_net.prev_with_block();
app.graph_net = s;
app.graph_disk = s;
}
3 => app.net_graph_coupled = !app.net_graph_coupled,
4 => app.net_graph_scale_ratio = prev_scale_ratio(app.net_graph_scale_ratio),
_ => {}
},
KeyCode::Enter => match sel {
0 => app.graph_net = app.graph_net.next_with_block(),
1 => app.graph_disk = app.graph_disk.next_with_block(),
2 => {
let s = app.graph_net.next_with_block();
app.graph_net = s;
app.graph_disk = s;
}
3 => app.net_graph_coupled = !app.net_graph_coupled,
4 => app.net_graph_scale_ratio = next_scale_ratio(app.net_graph_scale_ratio),
_ => {}
},
KeyCode::Char('n') => app.graph_net = app.graph_net.next_with_block(),
KeyCode::Char('d') => app.graph_disk = app.graph_disk.next_with_block(),
KeyCode::Char('a') => {
let s = app.graph_net.next_with_block();
app.graph_net = s;
app.graph_disk = s;
}
KeyCode::Char('c') => app.net_graph_coupled = !app.net_graph_coupled,
KeyCode::Char('r') => {
app.net_graph_scale_ratio = next_scale_ratio(app.net_graph_scale_ratio)
}
KeyCode::Esc | KeyCode::Char('q') | KeyCode::Char('m') => app.menu = MenuState::None,
_ => {}
},
MenuState::Search => match code {
KeyCode::Tab => {
app.search_box = if app.search_box == app::BOX_CONNS {
app::BOX_PROCS
} else {
app::BOX_CONNS
};
}
KeyCode::Char(c) => app.search_buf.push(c),
KeyCode::Backspace => {
app.search_buf.pop();
}
KeyCode::Enter => {
app.search = std::mem::take(&mut app.search_buf);
app.menu = MenuState::None;
}
KeyCode::Esc => {
app.search.clear();
app.search_buf.clear();
app.menu = MenuState::None;
}
_ => {}
},
MenuState::Help => app.menu = MenuState::None,
MenuState::Detail(b, id) => match code {
KeyCode::Up => {
if app.detail_sel > 0 {
app.detail_sel -= 1;
}
}
KeyCode::Down | KeyCode::Char('j') => {
if app.detail_sel + 1 < ui::detail_field_count(app, b, id) {
app.detail_sel += 1;
}
}
KeyCode::Char('y') => {
if let Some(text) = ui::detail_selected_value(app, b, id) {
osc52_copy(&text);
}
}
KeyCode::Char(' ') | KeyCode::Char('t') => ui::toggle_track(app, b, id),
KeyCode::Char('s') => {
if b == app::BOX_PROCS {
if let Some(p) = app.proc.procs.iter().find(|p| p.pid as u64 == id) {
if let Some(cmd) = &p.cmdline {
if p.alive {
app.confirm_cmd = Some(cmd.clone());
app.menu = MenuState::ConfirmRestart(p.pid);
} else {
let _ = start_cmd(cmd);
}
}
}
}
}
KeyCode::Char('k') => {
let pid = match b {
app::BOX_PROCS => Some(id as u32),
app::BOX_CONNS => app
.conn
.conns
.iter()
.find(|c| c.inode == id)
.and_then(|c| c.pid),
_ => None,
};
if let Some(pid) = pid {
app.confirm_cmd = app
.proc
.procs
.iter()
.find(|p| p.pid == pid)
.and_then(|p| p.cmdline.clone());
app.menu = MenuState::ConfirmKill(pid);
}
}
KeyCode::Esc | KeyCode::Char('q') | KeyCode::Char('m') => app.menu = MenuState::None,
_ => {}
},
MenuState::ConfirmKill(pid) => match code {
KeyCode::Char('y') | KeyCode::Char('Y') | KeyCode::Enter => {
app.menu = MenuState::None;
let anchor = app.confirm_cmd.take();
let verified = match anchor {
None => true,
Some(cmd) => {
matches!(
confirm_verify(&app.proc.procs, pid, &cmd),
ConfirmAction::Signal
)
}
};
if verified {
kill_pid(pid);
}
}
KeyCode::Char('n') | KeyCode::Char('N') | KeyCode::Esc | KeyCode::Char('q') => {
app.confirm_cmd = None;
app.menu = MenuState::None;
}
_ => {}
},
MenuState::ConfirmRestart(pid) => match code {
KeyCode::Char('y') | KeyCode::Char('Y') | KeyCode::Enter => {
app.menu = MenuState::None;
if let Some(cmd) = app.confirm_cmd.take() {
match confirm_verify(&app.proc.procs, pid, &cmd) {
ConfirmAction::Signal => {
kill_pid(pid);
relaunch_when_gone(pid, cmd);
}
ConfirmAction::Exited => {
let _ = start_cmd(&cmd);
}
ConfirmAction::Mismatch => {}
}
}
}
KeyCode::Char('n') | KeyCode::Char('N') | KeyCode::Esc | KeyCode::Char('q') => {
app.confirm_cmd = None;
app.menu = MenuState::None;
}
_ => {}
},
}
}
const SCALE_STEPS: [u32; 4] = [2, 5, 10, 20];
fn next_scale_ratio(cur: u32) -> u32 {
SCALE_STEPS
.iter()
.find(|&&s| s > cur)
.copied()
.unwrap_or(SCALE_STEPS[0])
}
fn prev_scale_ratio(cur: u32) -> u32 {
SCALE_STEPS
.iter()
.rev()
.find(|&&s| s < cur)
.copied()
.unwrap_or(*SCALE_STEPS.last().unwrap())
}
fn handle_mouse(app: &mut App, m: &crossterm::event::MouseEvent) {
use crossterm::event::MouseButton;
if let crate::app::MenuState::Detail(b, id) = app.menu {
let dbl = app.last_click.is_some_and(|(t0, c0, r0)| {
t0.elapsed() < std::time::Duration::from_millis(400) && c0 == m.column && r0 == m.row
});
app.last_click = Some((std::time::Instant::now(), m.column, m.row));
match m.kind {
MouseEventKind::ScrollUp => {
app.detail_sel = app.detail_sel.saturating_sub(1);
}
MouseEventKind::ScrollDown => {
let n = ui::detail_field_count(app, b, id);
app.detail_sel = (app.detail_sel + 1).min(n.saturating_sub(1));
}
MouseEventKind::Down(MouseButton::Left) => {
match ui::detail_hit_test(app, b, id, m.row) {
ui::DetailHit::Field(idx, value) => {
app.detail_sel = idx;
if dbl {
osc52_copy(&value);
app.last_click = None;
}
}
ui::DetailHit::Heading => {}
ui::DetailHit::Outside => {
app.menu = crate::app::MenuState::None;
app.last_click = None;
}
}
}
_ => {}
}
return;
}
match m.kind {
MouseEventKind::Drag(MouseButton::Left) => {
if let Some(grab) = app.sb_drag {
ui::scrollbar_drag(app, m.row, grab);
}
}
MouseEventKind::Up(MouseButton::Left) => {
app.sb_drag = None;
}
MouseEventKind::ScrollUp | MouseEventKind::ScrollDown => {
if let Some(idx) = ui::hit_box(m.column, m.row) {
if m.kind == MouseEventKind::ScrollUp {
app.scroll[idx] = app.scroll[idx].saturating_sub(3);
} else {
app.scroll[idx] = app.scroll[idx].saturating_add(3);
}
}
}
MouseEventKind::Down(MouseButton::Left) => {
if ui::box_rect(app::BOX_DISKS).is_some() {
let (sb_len, sb_visible, sb_off) = ui::disks_scroll_state(app);
match ui::scrollbar_hit(m.column, m.row, sb_len, sb_visible, sb_off) {
Some(ui::SbHit::Thumb { grab }) => {
app.sb_drag = Some(grab);
app.last_click = None;
return;
}
Some(ui::SbHit::PageUp) => {
app.scroll[app::BOX_DISKS] =
app.scroll[app::BOX_DISKS].saturating_sub(sb_visible.max(1));
app.last_click = None;
return;
}
Some(ui::SbHit::PageDown) => {
app.scroll[app::BOX_DISKS] =
app.scroll[app::BOX_DISKS].saturating_add(sb_visible.max(1));
app.last_click = None;
return;
}
None => {}
}
}
if let Some((t0, c0, r0)) = app.last_click {
if t0.elapsed() < std::time::Duration::from_millis(400)
&& c0 == m.column
&& r0 == m.row
{
app.last_click = None;
let idx = ui::hit_box(m.column, m.row);
if let Some(b) = idx {
if matches!(b, app::BOX_PROCS | app::BOX_CONNS)
&& !ui::selected_is_agg(app, b)
{
app.detail_sel = 0;
if let Some(id) = ui::selected_id(app, b) {
app.menu = crate::app::MenuState::Detail(b, id);
}
}
}
return;
}
}
app.last_click = Some((std::time::Instant::now(), m.column, m.row));
let hit = ui::hit_box(m.column, m.row)
.filter(|&idx| matches!(idx, app::BOX_PROCS | app::BOX_CONNS | app::BOX_LAN))
.and_then(|idx| ui::box_rect(idx).map(|r| (idx, r)));
let mut on_row = false;
if let Some((idx, rect)) = hit {
let row = m.row as i32 - (rect.y as i32 + 2); if row >= 0 {
let visible = (rect.height as usize).saturating_sub(3).max(1);
let abs = ui::clamped_offset(app, idx, visible) + row as usize;
if abs < ui::list_len(app, idx) {
app.sel[idx] = Some(abs);
for (b, f) in app.focus.iter_mut().enumerate() {
*f = b == idx;
}
app.last_focus = idx;
on_row = true;
if idx == app::BOX_CONNS && ui::selected_is_agg(app, idx) {
if let Some(key) = ui::selected_agg_key(app, idx) {
ui::toggle_group(app, &key);
}
}
}
}
}
if !on_row {
for f in app.focus.iter_mut() {
*f = false;
}
for s in app.sel.iter_mut() {
*s = None;
}
}
}
_ => {}
}
}
pub(crate) fn kill_pid(pid: u32) {
unsafe {
libc::kill(pid as i32, libc::SIGTERM);
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
enum ConfirmAction {
Signal,
Exited,
Mismatch,
}
fn confirm_verify(
procs: &[crate::collect::proc::ProcRow],
pid: u32,
cmd: &[String],
) -> ConfirmAction {
match procs.iter().find(|p| p.pid == pid) {
Some(p) if p.cmdline.as_deref() == Some(cmd) => {
if p.alive {
ConfirmAction::Signal
} else {
ConfirmAction::Exited
}
}
_ => ConfirmAction::Mismatch,
}
}
fn relaunch_when_gone(pid: u32, cmd: Vec<String>) {
std::thread::spawn(move || {
for _ in 0..40 {
let alive = unsafe { libc::kill(pid as libc::pid_t, 0) } == 0
|| std::io::Error::last_os_error().raw_os_error() == Some(libc::EPERM);
if !alive {
break;
}
std::thread::sleep(std::time::Duration::from_millis(50));
}
let _ = start_cmd(&cmd);
});
}
pub(crate) fn start_cmd(cmd: &[String]) -> std::io::Result<u32> {
use std::os::unix::process::CommandExt;
use std::process::{Command, Stdio};
let (prog, args) = cmd
.split_first()
.ok_or_else(|| std::io::Error::new(std::io::ErrorKind::InvalidInput, "empty command"))?;
unsafe {
Command::new(prog)
.args(args)
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
.pre_exec(|| {
libc::setsid();
Ok(())
})
.spawn()
.map(|child| child.id())
}
}
pub fn json_snapshot() -> Result<()> {
let mut app = App::new(None);
app.update();
std::thread::sleep(Duration::from_millis(1200));
app.update();
let snap = snapshot::from_app(&app);
println!("{}", serde_json::to_string_pretty(&snap)?);
Ok(())
}
pub fn print_schema() -> Result<()> {
let fields: &[(&str, &str, &str)] = &[
(
"schema",
"u32",
"snapshot schema version (additive-only within a version)",
),
("meta.hostname", "string", "host name"),
("meta.ts", "u64", "unix timestamp (seconds)"),
("meta.version", "string", "ltop version"),
("meta.os / meta.arch", "string", "platform"),
(
"meta.udp_helper",
"bool",
"eBPF helper snapshot fresh (Linux only)",
),
("net.selected", "string", "interface shown in the TUI"),
(
"net.interfaces[].name/operstate/mac",
"string",
"interface identity",
),
(
"net.interfaces[].speed_mbps",
"u64?",
"link speed (None on Wi-Fi)",
),
("net.interfaces[].addresses[]", "string", "CIDR addresses"),
(
"net.interfaces[].rx_bps/tx_bps",
"f64",
"instantaneous bytes/s",
),
(
"net.interfaces[].session_rx/session_tx",
"u64",
"bytes since ltop start",
),
(
"net.interfaces[].alive_rx/alive_tx",
"u64",
"bytes since interface up",
),
("lan.subnets[]", "string", "observed subnets (CIDR)"),
("lan.gateways[]", "string", "default gateways"),
(
"lan.neighbours[].ip/mac/hostname/iface",
"string",
"neighbour identity; mac is null on macOS (system sanitizes)",
),
(
"lan.neighbours[].is_gateway/is_self/tracked",
"bool",
"role flags",
),
(
"disk.devices[].name/mounts[]/fstype",
"string",
"device identity",
),
("disk.devices[].total/used", "u64", "capacity (bytes)"),
(
"disk.devices[].read_bps/write_bps/iops",
"f64",
"throughput",
),
(
"disk.session_read/session_write",
"u64",
"bytes since ltop start",
),
(
"conns[].proto/local/remote/state",
"string",
"connection identity (state: LISTEN/ESTAB/UDP)",
),
(
"conns[].process/pid/user",
"string|u32|null",
"owner (null when not owned by you)",
),
("conns[].inode", "u64", "stable row key"),
(
"conns[].bytes_recv/bytes_sent",
"u64",
"cumulative per-socket bytes",
),
("conns[].bps_recv/bps_sent", "f64", "instantaneous bytes/s"),
(
"procs[].pid/name/alive",
"u32|string|bool",
"process identity",
),
(
"procs[].net_recv/net_sent/udp_recv/udp_sent",
"u64",
"session Σ bytes",
),
(
"procs[].net_bps_recv/net_bps_sent",
"f64",
"network bytes/s",
),
(
"procs[].disk_read/disk_written/disk_bps_read/disk_bps_written",
"u64|f64",
"disk I/O (own-uid processes)",
),
];
let out = serde_json::json!({
"schema": snapshot::SCHEMA,
"command": "ltop --json",
"fields": fields.iter().map(|(p, t, d)| serde_json::json!({
"path": p, "type": t, "description": d,
})).collect::<Vec<_>>(),
});
println!("{}", serde_json::to_string_pretty(&out)?);
Ok(())
}
pub fn dump(theme_src: &str) -> Result<()> {
let mut app = App::new(None);
app.update();
std::thread::sleep(Duration::from_millis(2600));
app.update();
println!("== THEME ==\n{theme_src}");
println!("== NET ==");
println!("selected: {:?}", app.net.selected);
for (name, info) in &app.net.ifaces {
let (rx, tx) = match app.net.rates.get(name) {
Some(r) => (format!("{:.0} B/s", r.rx), format!("{:.0} B/s", r.tx)),
None => ("-".into(), "-".into()),
};
println!(
"{:<12} {:<8} speed {:<8} mac {:<18} rx {:<12} tx {:<12} addrs {:?}",
name,
info.operstate,
info.speed_mbps.unwrap_or(0),
info.mac,
rx,
tx,
info.addrs
);
}
println!("== LAN ==");
println!(
"subnets: {:?} gateways: {:?} sweep: {}",
app.lan.subnets, app.lan.gateways, app.lan.sweeping
);
for n in app.lan.sorted_neighbors() {
println!(
"{:<16} {:<18} {:<10} host {:<24} {}{}",
n.ip.to_string(),
n.mac.clone().unwrap_or_default(),
n.iface,
sanitize_text(n.hostname.as_deref().unwrap_or_default()),
if n.is_gateway { "gw " } else { "" },
if n.is_self { "self" } else { "" },
);
}
println!("== CONNS == total {}", app.conn.conns.len());
for c in app.conn.conns.iter().take(12) {
let proc_str = match (&c.proc, c.pid) {
(Some(n), Some(p)) => format!("{}({p})", sanitize_text(n)),
_ => app.conn.user_name(c.uid),
};
println!(
"{:<20} {:<24} -> {:<24} {} r {:.0} w {:.0}",
proc_str,
collect::conn::sock_str(&c.local),
collect::conn::sock_str(&c.remote),
if c.is_listen() {
"LISTEN"
} else if c.is_tcp() {
"EST"
} else {
"UDP"
},
c.rate_recv,
c.rate_sent
);
}
println!("== PROCS ==");
for p in app.proc.procs.iter().take(12) {
println!(
"{:<20} net SUM={}/{} r {}/{} disk SUM={}/{} r {}/{}",
format!("{}({})", sanitize_text(&p.name), p.pid),
fmt_human(p.net_recv as f64),
fmt_human(p.net_sent as f64),
fmt_human(p.net_rr),
fmt_human(p.net_sr),
fmt_human(p.disk_r as f64),
fmt_human(p.disk_w as f64),
fmt_human(p.disk_rr),
fmt_human(p.disk_wr),
);
}
println!("== UDP (eBPF) ==");
println!(
"snapshot {} fresh {} pids {} sockets {} daemon schema {}",
app.udp.path.display(),
app.udp.fresh,
app.udp.pids_seen,
app.udp.sks_seen,
app.udp
.remote_ver
.map_or("pre-versioning (<0.2.12)".to_string(), |v| v.to_string())
);
for d in app.udp.last_inodes.iter().take(8) {
let conn = app
.conn
.conns
.iter()
.find(|c| c.inode == d.inode)
.map(|c| {
format!(
"{} -> {}",
collect::conn::sock_str(&c.local),
collect::conn::sock_str(&c.remote)
)
})
.unwrap_or_else(|| "(socket 已关闭)".into());
println!(
" inode {:<8} {} delta r {}/ w {}",
d.inode,
conn,
fmt_human(d.recv as f64),
fmt_human(d.sent as f64),
);
}
for p in app
.proc
.procs
.iter()
.filter(|p| p.udp_recv + p.udp_sent > 0)
.take(12)
{
println!(
"{:<20} udp SUM={}/{} r {}/{}",
format!("{}({})", p.name, p.pid),
fmt_human(p.udp_recv as f64),
fmt_human(p.udp_sent as f64),
fmt_human(p.udp_rr),
fmt_human(p.udp_sr),
);
}
println!("== DISK ==");
let mut tree_lines: Vec<String> = Vec::new();
fn emit(
nodes: &[collect::disk::TreeNode],
prefix: String,
depth: usize,
out: &mut Vec<String>,
) {
let n = nodes.len();
for (i, node) in nodes.iter().enumerate() {
let last = i + 1 == n;
let glyph = if depth == 0 {
String::new()
} else if last {
"+- ".into()
} else {
"|- ".into()
};
let child_prefix = if depth == 0 {
String::new()
} else {
format!("{prefix}{}", if last { " " } else { "| " })
};
out.push(format!("{prefix}{glyph}{}", node.name));
emit(&node.children, child_prefix, depth + 1, out);
}
}
emit(&app.disk.tree, String::new(), 0, &mut tree_lines);
for l in &tree_lines {
println!(" {l}");
}
for d in &app.disk.devices {
println!(
"{:<14} {:<6} mounts {:?} used {}/{} r {:.0} w {:.0}",
d.name,
d.fstype,
d.mounts,
fmt_human(d.used as f64),
fmt_human(d.total as f64),
d.rate_r,
d.rate_w
);
}
Ok(())
}
pub(crate) fn fmt_human(v: f64) -> String {
const UNITS: [&str; 5] = ["B", "KiB", "MiB", "GiB", "TiB"];
let mut v = v;
let mut u = 0;
while v >= 1024.0 && u < 4 {
v /= 1024.0;
u += 1;
}
format!("{v:.1}{}", UNITS[u])
}
pub fn cli_lang_zh() -> bool {
matches!(config::Config::load().lang, config::Lang::Zh)
}
pub fn pick<'a>(zh: bool, en: &'a str, c: &'a str) -> &'a str {
if zh {
c
} else {
en
}
}
pub fn pick_s(zh: bool, en: &str, c: &str) -> String {
pick(zh, en, c).to_string()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn detail_popup_smoke_and_hit_test_outside_on_empty_data() {
use ratatui::backend::TestBackend;
use ratatui::Terminal;
let mut app = App::new(None);
app.menu = crate::app::MenuState::Detail(app::BOX_PROCS, 0);
let mut term = Terminal::new(TestBackend::new(120, 40)).unwrap();
term.draw(|f| ui::draw(f, &app)).unwrap(); assert!(matches!(
ui::detail_hit_test(&app, app::BOX_PROCS, 0, 39),
ui::DetailHit::Outside
));
}
#[cfg(target_os = "linux")]
#[test]
fn bpf_object_parses_with_probes_and_map() {
let path = std::path::Path::new(env!("OUT_DIR")).join("ltop_udp_bpf.o");
let Ok(bytes) = std::fs::read(&path) else {
eprintln!("skipped: 没有 eBPF 对象(构建机缺 clang)");
return;
};
let obj = aya_obj::Object::parse(&bytes).expect("parse eBPF object");
for name in [
"udp_send",
"udp_recv_entry",
"udp_recv",
"udp6_send",
"udp6_recv_entry",
"udp6_recv",
"tcp_send_entry",
"tcp_send",
"tcp_recv_entry",
"tcp_recv",
] {
assert!(obj.programs.contains_key(name), "缺程序 {name}");
}
for (name, ksize) in [("net_bytes", 4u32), ("udp_bytes", 4)] {
let m = obj.maps.get(name).expect("缺 pid 账本 map");
let aya_obj::maps::Map::Legacy(m) = m else {
panic!("{name} 应是 legacy map 定义");
};
assert_eq!(m.def.map_type, 9, "BPF_MAP_TYPE_LRU_HASH");
assert_eq!(m.def.key_size, ksize);
assert_eq!(m.def.value_size, 16);
assert_eq!(m.def.max_entries, 16384);
}
let sk = obj.maps.get("udp_sk").expect("缺 udp_sk map");
let aya_obj::maps::Map::Legacy(sk) = sk else {
panic!("udp_sk 应是 legacy map 定义");
};
assert_eq!(sk.def.map_type, 9);
assert_eq!(sk.def.key_size, 8); assert_eq!(sk.def.value_size, 16);
let stash = obj.maps.get("recv_sk").expect("缺 recv_sk map");
let aya_obj::maps::Map::Legacy(stash) = stash else {
panic!("recv_sk 应是 legacy map 定义");
};
assert_eq!(stash.def.key_size, 8); assert_eq!(stash.def.value_size, 8); let cache = obj.maps.get("sk_ino").expect("缺 sk_ino map");
let aya_obj::maps::Map::Legacy(cache) = cache else {
panic!("sk_ino 应是 legacy map 定义");
};
assert_eq!(cache.def.key_size, 8); assert_eq!(cache.def.value_size, 8); }
#[test]
fn enter_on_aggregate_toggles_collapse() {
use crossterm::event::{KeyCode, KeyModifiers};
let mut app = App::new(None);
app.conn.sort = crate::collect::conn::ConnSort::Proc;
let mk = |inode: u64| crate::collect::conn::Conn {
proto: crate::collect::conn::IPPROTO_TCP,
local: ("127.0.0.1".parse().unwrap(), 1000 + inode as u16),
remote: ("127.0.0.1".parse().unwrap(), 443),
state: 1,
uid: 0,
inode,
bytes_recv: 100,
bytes_sent: 0,
rate_recv: 0.0,
rate_sent: 0.0,
pid: Some(1000 + inode as u32),
proc: Some("web".into()),
dead: false,
first_seen: None,
dead_at: None,
};
app.conn.conns = vec![mk(1), mk(2)];
app.sel[app::BOX_CONNS] = Some(0); app.focus[app::BOX_CONNS] = true;
handle_key(&mut app, KeyCode::Enter, KeyModifiers::empty());
assert!(app.expanded.contains("web"), "聚合行 enter 应展开组");
handle_key(&mut app, KeyCode::Enter, KeyModifiers::empty());
assert!(!app.expanded.contains("web"), "再按应折叠");
app.expanded.insert("web".into());
handle_key(&mut app, KeyCode::Left, KeyModifiers::empty());
assert!(!app.expanded.contains("web"));
handle_key(&mut app, KeyCode::Right, KeyModifiers::empty());
assert!(app.expanded.contains("web"));
}
#[test]
fn enter_on_lan_pins_single_and_filters_conns() {
use crossterm::event::{KeyCode, KeyModifiers};
use std::net::Ipv4Addr;
let mut app = App::new(None);
for k in 1..=3u32 {
let ip = Ipv4Addr::new(10, 0, 0, k as u8);
app.lan.neighbors.insert(
ip,
crate::collect::lan::Neighbor {
ip,
mac: None,
mac_hidden: false,
iface: "eth0".into(),
complete: true,
hostname: None,
is_gateway: false,
is_self: false,
last_seen: std::time::Instant::now(),
},
);
}
app.conn.sort = crate::collect::conn::ConnSort::Name;
app.focus[app::BOX_LAN] = true;
app.last_focus = app::BOX_LAN;
app.sel[app::BOX_LAN] = Some(1);
let ip2 = Ipv4Addr::new(10, 0, 0, 2);
handle_key(&mut app, KeyCode::Enter, KeyModifiers::empty());
assert!(app.lan.tracked.contains(&ip2), "enter 应置顶");
assert_eq!(app.lan.tracked.len(), 1, "置顶应只有一个");
assert_eq!(app.conn.peer_filter, Some(ip2), "应联动 conns 对端过滤");
assert_eq!(app.lan.sorted_neighbors()[0].ip, ip2, "置顶后应排第一");
handle_key(&mut app, KeyCode::Enter, KeyModifiers::empty());
assert!(app.lan.tracked.is_empty(), "再按应取消置顶");
assert!(app.conn.peer_filter.is_none(), "联动应解除");
}
#[test]
fn lan_focus_excludes_other_boxes() {
use crossterm::event::{KeyCode, KeyModifiers};
let mut app = App::new(None);
handle_key(&mut app, KeyCode::Char('p'), KeyModifiers::empty());
handle_key(&mut app, KeyCode::Char('l'), KeyModifiers::empty());
assert!(app.focus[app::BOX_LAN] && !app.focus[app::BOX_PROCS]);
handle_key(&mut app, KeyCode::Char('c'), KeyModifiers::empty());
assert!(app.focus[app::BOX_CONNS] && !app.focus[app::BOX_LAN]);
}
#[test]
fn e_key_cycles_lan_sort() {
use crossterm::event::{KeyCode, KeyModifiers};
let mut app = App::new(None);
let s0 = app.lan.sort;
handle_key(&mut app, KeyCode::Char('e'), KeyModifiers::empty());
assert_ne!(app.lan.sort, s0, "e 应循环 lan 排序");
}
#[test]
fn esc_resets_the_applied_search() {
use crossterm::event::{KeyCode, KeyModifiers};
let mut app = App::new(None);
app.search = "fire".into();
app.search_buf = "fire".into();
app.menu = MenuState::Search;
handle_key(&mut app, KeyCode::Char('x'), KeyModifiers::NONE);
assert_eq!(app.search_buf, "firex");
assert_eq!(app.search, "fire", "输入中不影响已应用过滤");
handle_key(&mut app, KeyCode::Enter, KeyModifiers::NONE);
assert_eq!(app.search, "firex", "enter 应用");
assert!(app.menu == MenuState::None);
handle_key(&mut app, KeyCode::Char('/'), KeyModifiers::NONE);
assert_eq!(app.search_buf, "firex");
handle_key(&mut app, KeyCode::Esc, KeyModifiers::NONE);
assert!(app.search.is_empty(), "esc 应清除已应用过滤");
assert!(app.search_buf.is_empty());
assert!(app.menu == MenuState::None);
}
#[test]
fn kill_pid_terminates_the_process() {
let mut child = std::process::Command::new("sleep")
.arg("30")
.spawn()
.expect("spawn sleep");
let pid = child.id();
kill_pid(pid);
std::thread::sleep(std::time::Duration::from_millis(300));
assert!(
child.try_wait().expect("wait").is_some(),
"child {pid} survived SIGTERM"
);
}
fn all_pids() -> Vec<u32> {
#[cfg(target_os = "linux")]
{
std::fs::read_dir("/proc")
.expect("read /proc")
.flatten()
.filter_map(|e| e.file_name().to_string_lossy().parse::<u32>().ok())
.collect()
}
#[cfg(target_os = "macos")]
{
crate::collect::macproc::list_pids()
.into_iter()
.map(|m| m.pid)
.collect()
}
}
fn pid_runs(pid: u32, name: &str) -> bool {
#[cfg(target_os = "linux")]
{
std::fs::read_to_string(format!("/proc/{pid}/comm"))
.map(|c| c.trim() == name)
.unwrap_or(false)
}
#[cfg(target_os = "macos")]
{
crate::collect::macproc::list_pids()
.iter()
.any(|m| m.pid == pid && m.comm == name)
}
}
fn find_running(name: &str, exclude: u32) -> Option<u32> {
all_pids()
.into_iter()
.find(|&p| p != exclude && pid_runs(p, name))
}
#[test]
fn start_cmd_launches_detached() {
let before = all_pids();
let new_pid =
start_cmd(&["sleep".to_string(), "30".to_string()]).expect("spawn detached sleep");
std::thread::sleep(std::time::Duration::from_millis(150));
assert!(
pid_runs(new_pid, "sleep"),
"detached child must be alive and running sleep"
);
kill_pid(new_pid);
std::thread::sleep(std::time::Duration::from_millis(300));
assert!(!before.contains(&new_pid));
}
#[test]
fn d_key_aims_keys_at_disks_and_toggles_mounts() {
use crossterm::event::KeyCode;
let mut app = App::new(None);
let before = app.disks_expanded;
handle_key(&mut app, KeyCode::Char('d'), KeyModifiers::empty());
assert_eq!(app.last_focus, app::BOX_DISKS);
assert_ne!(app.disks_expanded, before);
assert!(!app.focus[app::BOX_DISKS]);
handle_key(&mut app, KeyCode::Char('d'), KeyModifiers::empty());
assert_eq!(app.disks_expanded, before);
assert_eq!(app.last_focus, app::BOX_DISKS, "方向键目标不随展开切换改变");
}
#[test]
fn jump_keys_reach_disks_once_it_is_last_focus() {
use crossterm::event::KeyCode;
let mut app = App::new(None);
handle_key(&mut app, KeyCode::Char('d'), KeyModifiers::empty());
handle_key(&mut app, KeyCode::Char('G'), KeyModifiers::empty());
assert_eq!(app.scroll[app::BOX_DISKS], usize::MAX);
handle_key(&mut app, KeyCode::Char('g'), KeyModifiers::empty());
assert_eq!(app.scroll[app::BOX_DISKS], 0);
}
#[test]
fn page_keys_step_by_box_capacity() {
use crossterm::event::KeyCode;
use ratatui::backend::TestBackend;
use ratatui::Terminal;
let mut app = App::new(None);
for i in 0..app::BOX_COUNT {
app.visible[i] = i == app::BOX_DISKS;
}
let mut term = Terminal::new(TestBackend::new(120, 40)).unwrap();
term.draw(|f| ui::draw(f, &app)).unwrap(); let cap = ui::box_capacity(app.last_focus).max(1);
handle_key(&mut app, KeyCode::PageDown, KeyModifiers::empty());
assert_eq!(app.scroll[app.last_focus], cap);
handle_key(&mut app, KeyCode::PageUp, KeyModifiers::empty());
assert_eq!(app.scroll[app.last_focus], 0);
}
#[test]
fn confirm_verify_blocks_recycled_pids() {
let cmd = vec!["sleep".to_string(), "30".to_string()];
let mk =
|pid: u32, alive: bool, cmdline: Option<Vec<String>>| crate::collect::proc::ProcRow {
pid,
name: "x".into(),
net_recv: 0,
net_sent: 0,
net_rr: 0.0,
net_sr: 0.0,
udp_recv: 0,
udp_sent: 0,
udp_rr: 0.0,
udp_sr: 0.0,
disk_r: 0,
disk_w: 0,
disk_rr: 0.0,
disk_wr: 0.0,
uptime_s: None,
alive,
cmdline,
};
let procs = vec![
mk(7, true, Some(cmd.clone())),
mk(8, false, Some(cmd.clone())),
mk(9, true, Some(vec!["other".into()])),
];
assert_eq!(confirm_verify(&procs, 7, &cmd), ConfirmAction::Signal);
assert_eq!(confirm_verify(&procs, 8, &cmd), ConfirmAction::Exited);
assert_eq!(confirm_verify(&procs, 9, &cmd), ConfirmAction::Mismatch);
assert_eq!(confirm_verify(&procs, 42, &cmd), ConfirmAction::Mismatch);
}
#[test]
fn p_and_c_second_press_cancels_focus() {
use crossterm::event::KeyCode;
use ratatui::backend::TestBackend;
use ratatui::Terminal;
let mut app = App::new(None);
app.update();
for (key, idx, other) in [
(KeyCode::Char('p'), app::BOX_PROCS, app::BOX_CONNS),
(KeyCode::Char('c'), app::BOX_CONNS, app::BOX_PROCS),
] {
assert!(!app.focus[idx], "starts unfocused");
handle_key(&mut app, key, KeyModifiers::empty());
assert!(app.focus[idx], "first press focuses");
assert!(!app.focus[other], "单焦点:另一盒熄灭");
handle_key(&mut app, key, KeyModifiers::empty());
assert!(!app.focus[idx], "second press cancels focus");
}
handle_key(&mut app, KeyCode::Char('p'), KeyModifiers::empty());
handle_key(&mut app, KeyCode::Char('c'), KeyModifiers::empty());
assert!(app.focus[app::BOX_CONNS] && !app.focus[app::BOX_PROCS]);
handle_key(&mut app, KeyCode::Char('p'), KeyModifiers::empty());
app.proc.procs.push(crate::collect::proc::ProcRow {
pid: 4242,
name: "probe".into(),
net_recv: 10,
net_sent: 0,
net_rr: 0.0,
net_sr: 0.0,
udp_recv: 0,
udp_sent: 0,
udp_rr: 0.0,
udp_sr: 0.0,
disk_r: 0,
disk_w: 0,
disk_rr: 0.0,
disk_wr: 0.0,
uptime_s: None,
alive: true,
cmdline: None,
});
app.proc.procs.shrink_to_fit();
app.sel[app::BOX_PROCS] = Some(0);
let buf_text = |term: &Terminal<TestBackend>| {
let buf = term.backend().buffer();
(0..buf.area().height)
.map(|y| {
(0..buf.area().width)
.map(|x| buf[(x, y)].symbol().to_string())
.collect::<String>()
})
.collect::<String>()
};
app.focus[app::BOX_PROCS] = true;
let mut term = Terminal::new(TestBackend::new(120, 40)).unwrap();
term.draw(|f| ui::draw(f, &app)).unwrap();
assert!(
buf_text(&term).contains("(pid "),
"overlay renders while focused"
);
app.focus[app::BOX_PROCS] = false;
let mut term = Terminal::new(TestBackend::new(120, 40)).unwrap();
term.draw(|f| ui::draw(f, &app)).unwrap();
assert!(
!buf_text(&term).contains("(pid "),
"overlay gone after unfocus"
);
}
#[test]
fn esc_clears_focus_and_m_opens_menu() {
use crossterm::event::KeyCode;
let mut app = App::new(None);
app.focus[app::BOX_PROCS] = true;
app.focus[app::BOX_CONNS] = true;
app.sel[app::BOX_PROCS] = Some(2);
handle_key(&mut app, KeyCode::Esc, KeyModifiers::empty());
assert!(app.focus.iter().all(|&f| !f), "esc clears all focus");
assert!(app.sel.iter().all(|&s| s.is_none()), "esc clears selection");
assert!(app.menu == MenuState::None, "esc does not open the menu");
handle_key(&mut app, KeyCode::Char('m'), KeyModifiers::empty());
assert!(matches!(app.menu, MenuState::Main(_)), "m opens the menu");
}
#[test]
fn mouse_click_enforces_single_focus() {
use crate::collect::proc::ProcRow;
use crossterm::event::{KeyCode, MouseButton, MouseEvent, MouseEventKind};
use ratatui::backend::TestBackend;
use ratatui::Terminal;
let mut app = App::new(None);
app.proc.procs.push(ProcRow {
pid: 4242,
name: "probe".into(),
net_recv: 10,
net_sent: 0,
net_rr: 0.0,
net_sr: 0.0,
udp_recv: 0,
udp_sent: 0,
udp_rr: 0.0,
udp_sr: 0.0,
disk_r: 0,
disk_w: 0,
disk_rr: 0.0,
disk_wr: 0.0,
uptime_s: None,
alive: true,
cmdline: None,
});
let mut term = Terminal::new(TestBackend::new(120, 40)).unwrap();
term.draw(|f| ui::draw(f, &app)).unwrap();
handle_key(&mut app, KeyCode::Char('l'), KeyModifiers::empty());
assert!(app.focus[app::BOX_LAN], "l 点亮 lan");
let buf = term.backend().buffer();
let procs_title = (0..buf.area().height)
.flat_map(|y| (0..buf.area().width).map(move |x| (x, y)))
.find(|(x, y)| buf[(*x, *y)].symbol() == "\u{2076}")
.expect("⁶procs 标题");
let m = MouseEvent {
kind: MouseEventKind::Down(MouseButton::Left),
column: procs_title.0 + 2,
row: procs_title.1 + 2,
modifiers: KeyModifiers::empty(),
};
for _ in 0..20 {
term.draw(|f| ui::draw(f, &app)).unwrap();
handle_mouse(&mut app, &m);
if app.focus[app::BOX_PROCS] {
break;
}
}
assert!(app.focus[app::BOX_PROCS], "点击 procs 行点亮 procs");
assert!(!app.focus[app::BOX_LAN], "单焦点:lan 熄灭");
assert!(!app.focus[app::BOX_CONNS], "单焦点:conns 熄灭");
}
#[test]
fn arch_guard_passes_on_x86_64() {
assert!(arch_guard().is_ok());
}
#[test]
fn poll_is_noop_when_not_following() {
assert!(!theme::poll_omarchy_follow());
}
#[test]
fn usage_covers_all_flags() {
let u = usage_text("ltop");
for flag in [
"--dump",
"--log",
"--log-interval",
"--follow-theme",
"--theme",
"--replay",
"--top",
"--csv",
"-h, --help",
"-V, --version",
"ltop-bpf",
"watch",
"report",
] {
assert!(u.contains(flag), "usage 缺 {flag}");
}
assert!(u.contains("ltop [OPTIONS]"), "USAGE 用调用名");
assert!(
usage_text("myalias").contains("myalias [OPTIONS]"),
"自建软链别名同版帮助(调用名跟随机制保留)"
);
}
#[test]
fn zoom_esc_clears_focus_only() {
let mut app = App::new(None);
app.focus[app::BOX_PROCS] = true;
app.last_focus = app::BOX_PROCS;
app.visible[app::BOX_PROCS] = true;
handle_key(&mut app, KeyCode::Char('z'), KeyModifiers::NONE);
assert_eq!(app.zoom, Some(app::BOX_PROCS), "z 进入 zoom");
handle_key(&mut app, KeyCode::Esc, KeyModifiers::NONE);
assert!(!app.focus[app::BOX_PROCS], "esc 只取消聚焦");
assert_eq!(app.zoom, Some(app::BOX_PROCS), "esc 不得退出 zoom");
handle_key(&mut app, KeyCode::Char('z'), KeyModifiers::NONE);
assert!(app.zoom.is_none(), "z 退出 zoom");
}
#[test]
fn theme_flag_passes_early_exit() {
assert!(early_exit(&[
"ltop".to_string(),
"--theme".to_string(),
"/tmp/x.theme".to_string()
])
.is_none());
assert!(early_exit(&["ltop".to_string(), "--typo".to_string()]).is_some());
}
#[test]
fn settings_rows_map_to_their_values() {
let dir = std::env::temp_dir().join(format!("ltop-settings-{}", std::process::id()));
std::env::set_var("XDG_STATE_HOME", &dir);
for sel in 0..15 {
let mut probe = App::new(None);
assert!(cycle_setting(&mut probe, sel, true), "第 {sel} 行无分支");
}
let mut a = App::new(None);
let iv = a.log.interval;
assert!(cycle_setting(&mut a, 5, true));
assert!(a.log.enabled, "5 号行必须开启录制");
assert_eq!(a.log.interval, iv, "5 号行不得改动日志间隔(错位)");
let mut b = App::new(None);
assert!(cycle_setting(&mut b, 6, true));
assert!(b.allow_global_log, "6 号行必须开全局录制键");
let mut c = App::new(None);
let tomb = c.conn.tombstone_ttl;
assert!(cycle_setting(&mut c, 14, true));
assert!(c.allow_global_kill, "14 号行必须开 global kill");
assert_eq!(c.conn.tombstone_ttl, tomb, "14 号行不得改动墓碑时长(错位)");
std::env::remove_var("XDG_STATE_HOME");
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn update_anchors_lan_selection() {
use crate::collect::lan::{LanSort, Neighbor};
use std::net::Ipv4Addr;
use std::time::Instant;
let mut app = App::new(None);
let mk = |ip: Ipv4Addr, host: &str| Neighbor {
ip,
mac: None,
mac_hidden: false,
iface: "eth0".into(),
complete: true,
hostname: Some(host.into()),
is_gateway: false,
is_self: false,
last_seen: Instant::now(),
};
let a = Ipv4Addr::new(10, 0, 0, 2);
let b = Ipv4Addr::new(10, 0, 0, 3);
app.lan.neighbors.insert(a, mk(a, "zzz"));
app.lan.neighbors.insert(b, mk(b, "aaa"));
app.lan.sort = LanSort::Ip;
app.sel[app::BOX_LAN] = Some(0);
assert_eq!(
ui::selected_id(&app, app::BOX_LAN),
Some(u32::from(a) as u64)
);
app.update();
assert_eq!(
app.sel_anchor[app::BOX_LAN],
Some(u32::from(a) as u64),
"update 锚定 LAN 选中(旧版恒为 None)"
);
assert_eq!(
ui::selected_id(&app, app::BOX_LAN),
Some(u32::from(a) as u64),
"采样后仍是同一主机"
);
}
#[test]
fn s_restarts_a_running_process_after_confirmation() {
use crate::collect::proc::ProcRow;
use crossterm::event::KeyCode;
let mut child = std::process::Command::new("sleep")
.arg("31")
.spawn()
.expect("spawn sleep 31");
let pid = child.id();
let mut app = App::new(None);
app.proc.procs.push(ProcRow {
pid,
name: "sleep".into(),
net_recv: 0,
net_sent: 0,
net_rr: 0.0,
net_sr: 0.0,
udp_recv: 0,
udp_sent: 0,
udp_rr: 0.0,
udp_sr: 0.0,
disk_r: 0,
disk_w: 0,
disk_rr: 0.0,
disk_wr: 0.0,
uptime_s: None,
alive: true,
cmdline: Some(vec!["sleep".into(), "31".into()]),
});
app.menu = MenuState::Detail(app::BOX_PROCS, u64::from(pid));
handle_key(&mut app, KeyCode::Char('s'), KeyModifiers::empty());
assert!(
matches!(app.menu, MenuState::ConfirmRestart(_)),
"s on a running process asks for confirmation"
);
handle_key(&mut app, KeyCode::Char('n'), KeyModifiers::empty());
assert!(app.menu == MenuState::None);
std::thread::sleep(std::time::Duration::from_millis(150));
assert!(child.try_wait().expect("poll").is_none(), "n must not kill");
app.menu = MenuState::Detail(app::BOX_PROCS, u64::from(pid));
handle_key(&mut app, KeyCode::Char('s'), KeyModifiers::empty());
handle_key(&mut app, KeyCode::Char('y'), KeyModifiers::empty());
assert!(app.menu == MenuState::None);
let _ = child.wait();
std::thread::sleep(std::time::Duration::from_millis(500));
assert!(
child.try_wait().expect("poll").is_some(),
"old instance terminated"
);
let new_pid = find_running("sleep", pid).expect("relaunched sleep must be running");
kill_pid(new_pid);
}
}