glances-rs
6819ce4e18
- --fetch with a Jinja-subset renderer and the shipped templates - clippy clean, cargo fmt, all tests green - README status and differential testing instructions
943 lines
32 KiB
Rust
943 lines
32 KiB
Rust
//! Terminal user interface (port of the Glances curses interface).
|
|
|
|
use anyhow::Result;
|
|
use crossterm::event::{self, Event, KeyCode, KeyEvent, KeyEventKind};
|
|
use crossterm::execute;
|
|
use crossterm::terminal::{
|
|
EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode,
|
|
};
|
|
use glances_core::plugin::{Align, Decoration, StatLine};
|
|
use glances_core::processes::processes;
|
|
use glances_core::{Args, RenderContext};
|
|
use glances_plugins::engine::Engine;
|
|
use ratatui::Frame;
|
|
use ratatui::backend::CrosstermBackend;
|
|
use ratatui::layout::Rect;
|
|
use ratatui::style::{Color, Modifier, Style};
|
|
use ratatui::text::Line;
|
|
use ratatui::widgets::{Block, Borders, Clear, Paragraph, Wrap};
|
|
use std::io::Stdout;
|
|
use std::time::{Duration, Instant};
|
|
|
|
const LEFT_SIDEBAR: [&str; 11] = [
|
|
"network", "ports", "wifi", "diskio", "fs", "irq", "folders", "raid", "sensors", "ip", "now",
|
|
];
|
|
const TOP_PLUGINS: [&str; 6] = ["cpu", "percpu", "mem", "memswap", "load", "gpu"];
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
enum Popup {
|
|
None,
|
|
Help,
|
|
Filter,
|
|
Kill,
|
|
}
|
|
|
|
pub struct Tui {
|
|
popup: Popup,
|
|
input: String,
|
|
quit: bool,
|
|
}
|
|
|
|
/// Run the terminal interface until the user quits.
|
|
pub fn run(engine: &mut Engine) -> Result<()> {
|
|
enable_raw_mode()?;
|
|
let mut stdout = std::io::stdout();
|
|
execute!(stdout, EnterAlternateScreen)?;
|
|
let backend = CrosstermBackend::new(stdout);
|
|
let mut terminal = ratatui::Terminal::new(backend)?;
|
|
|
|
let mut tui = Tui {
|
|
popup: Popup::None,
|
|
input: String::new(),
|
|
quit: false,
|
|
};
|
|
let result = run_loop(&mut terminal, engine, &mut tui);
|
|
|
|
disable_raw_mode()?;
|
|
execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
|
|
terminal.show_cursor()?;
|
|
result
|
|
}
|
|
|
|
fn run_loop(
|
|
terminal: &mut ratatui::Terminal<CrosstermBackend<Stdout>>,
|
|
engine: &mut Engine,
|
|
tui: &mut Tui,
|
|
) -> Result<()> {
|
|
let refresh = engine.args.time.unwrap_or(2.0);
|
|
let mut count: i64 = 0;
|
|
while !tui.quit {
|
|
let start = Instant::now();
|
|
engine.update();
|
|
tui.draw(terminal, engine)?;
|
|
|
|
count += 1;
|
|
if let Some(max) = engine.args.stop_after
|
|
&& count >= max
|
|
{
|
|
break;
|
|
}
|
|
|
|
let elapsed = start.elapsed().as_secs_f64();
|
|
let timeout = Duration::from_secs_f64((refresh - elapsed).max(0.05));
|
|
let deadline = Instant::now() + timeout;
|
|
while Instant::now() < deadline {
|
|
let remaining = deadline.saturating_duration_since(Instant::now());
|
|
if !event::poll(remaining)? {
|
|
break;
|
|
}
|
|
match event::read()? {
|
|
Event::Key(key) if key.kind == KeyEventKind::Press => tui.handle_key(engine, key),
|
|
Event::Resize(_, _) => break,
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
impl Tui {
|
|
fn draw(
|
|
&self,
|
|
terminal: &mut ratatui::Terminal<CrosstermBackend<Stdout>>,
|
|
engine: &mut Engine,
|
|
) -> Result<()> {
|
|
terminal.draw(|frame| draw_frame(frame, engine, self))?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
fn draw_frame(frame: &mut Frame, engine: &mut Engine, tui: &Tui) {
|
|
let args = engine.args.clone();
|
|
let args = &args;
|
|
let area = frame.area();
|
|
if area.width < 40 || area.height < 10 {
|
|
return;
|
|
}
|
|
if tui.popup == Popup::Help {
|
|
tui.draw_help(frame, area);
|
|
return;
|
|
}
|
|
|
|
// Header.
|
|
let header_height = 1u16;
|
|
let top_height = tui.top_height(engine, args, area.width);
|
|
let footer_height = if tui.popup == Popup::Filter || tui.popup == Popup::Kill {
|
|
3
|
|
} else {
|
|
0
|
|
};
|
|
let main_height = area
|
|
.height
|
|
.saturating_sub(header_height + top_height + footer_height);
|
|
|
|
let header_area = Rect {
|
|
x: 0,
|
|
y: 0,
|
|
width: area.width,
|
|
height: header_height,
|
|
};
|
|
let top_area = Rect {
|
|
x: 0,
|
|
y: header_height,
|
|
width: area.width,
|
|
height: top_height,
|
|
};
|
|
let main_area = Rect {
|
|
x: 0,
|
|
y: header_height + top_height,
|
|
width: area.width,
|
|
height: main_height,
|
|
};
|
|
let footer_area = Rect {
|
|
x: 0,
|
|
y: area.height.saturating_sub(footer_height),
|
|
width: area.width,
|
|
height: footer_height,
|
|
};
|
|
|
|
tui.draw_header(frame, header_area, engine, args);
|
|
tui.draw_top(frame, top_area, engine, args);
|
|
tui.draw_main(frame, main_area, engine, args);
|
|
if footer_height > 0 {
|
|
tui.draw_popup(frame, footer_area);
|
|
}
|
|
}
|
|
|
|
impl Tui {
|
|
fn top_height(&self, engine: &mut Engine, args: &Args, width: u16) -> u16 {
|
|
if args.disable_top {
|
|
return 1;
|
|
}
|
|
let mut height = 1usize;
|
|
for name in TOP_PLUGINS {
|
|
if let Some(plugin) = engine.plugins.get_mut(name) {
|
|
if !plugin.is_enabled() {
|
|
continue;
|
|
}
|
|
let ctx = render_ctx(args, &engine.runtime, width as usize);
|
|
let lines = split_lines(plugin.render(&ctx));
|
|
height = height.max(lines.len());
|
|
}
|
|
}
|
|
// Quicklook.
|
|
if let Some(plugin) = engine.plugins.get_mut("quicklook")
|
|
&& plugin.is_enabled()
|
|
&& !args.disable_quicklook
|
|
{
|
|
let ql_width = quicklook_width(width);
|
|
let ctx = render_ctx(args, &engine.runtime, ql_width as usize);
|
|
let lines = split_lines(plugin.render(&ctx));
|
|
height = height.max(lines.len());
|
|
}
|
|
(height.min(20) as u16).max(1)
|
|
}
|
|
|
|
fn draw_header(&self, frame: &mut Frame, area: Rect, engine: &mut Engine, args: &Args) {
|
|
let x = area.x;
|
|
// System information.
|
|
if let Some(plugin) = engine.plugins.get_mut("system")
|
|
&& plugin.is_enabled()
|
|
{
|
|
let ctx = render_ctx(args, &engine.runtime, area.width as usize);
|
|
let lines = split_lines(plugin.render(&ctx));
|
|
let text: String = lines
|
|
.first()
|
|
.map(|l| l.iter().map(|s| s.msg.clone()).collect())
|
|
.unwrap_or_default();
|
|
let style = lines
|
|
.first()
|
|
.and_then(|l| l.first())
|
|
.map(|s| style_for(s.decoration, args))
|
|
.unwrap_or_default();
|
|
let width = text.chars().count() as u16;
|
|
frame.render_widget(
|
|
Paragraph::new(text).style(style),
|
|
Rect {
|
|
x,
|
|
y: area.y,
|
|
width: width.min(area.width),
|
|
height: 1,
|
|
},
|
|
);
|
|
}
|
|
// Uptime on the right.
|
|
if let Some(plugin) = engine.plugins.get_mut("uptime")
|
|
&& plugin.is_enabled()
|
|
{
|
|
let ctx = render_ctx(args, &engine.runtime, area.width as usize);
|
|
let lines = split_lines(plugin.render(&ctx));
|
|
let text: String = lines
|
|
.first()
|
|
.map(|l| l.iter().map(|s| s.msg.clone()).collect())
|
|
.unwrap_or_default();
|
|
let width = text.chars().count() as u16;
|
|
if width + 2 < area.width {
|
|
frame.render_widget(
|
|
Paragraph::new(text),
|
|
Rect {
|
|
x: area.width.saturating_sub(width),
|
|
y: area.y,
|
|
width,
|
|
height: 1,
|
|
},
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn draw_top(&self, frame: &mut Frame, area: Rect, engine: &mut Engine, args: &Args) {
|
|
let mut x = area.x;
|
|
// Collect the rendered blocks with their natural widths.
|
|
struct Block {
|
|
lines: Vec<Vec<StatLine>>,
|
|
natural_width: usize,
|
|
}
|
|
let mut blocks: Vec<Block> = Vec::new();
|
|
|
|
if !args.disable_quicklook
|
|
&& let Some(plugin) = engine.plugins.get_mut("quicklook")
|
|
&& plugin.is_enabled()
|
|
{
|
|
let width = quicklook_width(area.width) as usize;
|
|
let ctx = render_ctx(args, &engine.runtime, width);
|
|
let lines = split_lines(plugin.render(&ctx));
|
|
let natural = lines
|
|
.iter()
|
|
.map(|l| l.iter().map(|s| s.msg.chars().count()).sum::<usize>())
|
|
.max()
|
|
.unwrap_or(10);
|
|
blocks.push(Block {
|
|
lines,
|
|
natural_width: natural.max(10),
|
|
});
|
|
}
|
|
for name in TOP_PLUGINS {
|
|
if let Some(plugin) = engine.plugins.get_mut(name) {
|
|
if !plugin.is_enabled() {
|
|
continue;
|
|
}
|
|
let ctx = render_ctx(args, &engine.runtime, area.width as usize);
|
|
let lines = split_lines(plugin.render(&ctx));
|
|
let natural = lines
|
|
.iter()
|
|
.map(|l| l.iter().map(|s| s.msg.chars().count()).sum::<usize>())
|
|
.max()
|
|
.unwrap_or(10);
|
|
blocks.push(Block {
|
|
lines,
|
|
natural_width: natural.max(10),
|
|
});
|
|
}
|
|
}
|
|
if blocks.is_empty() {
|
|
return;
|
|
}
|
|
|
|
// Allocate the available width proportionally to the natural widths.
|
|
let total_natural: usize = blocks.iter().map(|b| b.natural_width).sum();
|
|
let spacing = 2usize * blocks.len().saturating_sub(1);
|
|
let available = (area.width as usize)
|
|
.saturating_sub(spacing)
|
|
.max(blocks.len() * 8);
|
|
let mut widths: Vec<u16> = Vec::new();
|
|
for block in &blocks {
|
|
let mut width = (available * block.natural_width / total_natural).max(8);
|
|
width = width.min(block.natural_width + 2);
|
|
widths.push(width as u16);
|
|
}
|
|
// Adjust the last block if the total exceeds the screen.
|
|
let total: usize = widths.iter().map(|w| *w as usize).sum::<usize>() + spacing;
|
|
if total > area.width as usize {
|
|
let excess = total - area.width as usize;
|
|
if let Some(last) = widths.last_mut() {
|
|
*last = last.saturating_sub(excess as u16).max(8);
|
|
}
|
|
}
|
|
|
|
for (block, width) in blocks.into_iter().zip(widths) {
|
|
if x + width > area.x + area.width {
|
|
break;
|
|
}
|
|
draw_lines(
|
|
frame,
|
|
Rect {
|
|
x,
|
|
y: area.y,
|
|
width,
|
|
height: area.height,
|
|
},
|
|
&block.lines,
|
|
args,
|
|
);
|
|
x += width + 2;
|
|
}
|
|
}
|
|
|
|
fn draw_main(&self, frame: &mut Frame, area: Rect, engine: &mut Engine, args: &Args) {
|
|
if area.height == 0 {
|
|
return;
|
|
}
|
|
let left_width = if args.disable_left_sidebar {
|
|
0
|
|
} else {
|
|
(area.width as i32 - 105).clamp(23, 34) as u16
|
|
};
|
|
if left_width > 0 && area.width > left_width + 20 {
|
|
let mut y = area.y;
|
|
for name in LEFT_SIDEBAR {
|
|
if y >= area.y + area.height {
|
|
break;
|
|
}
|
|
let Some(plugin) = engine.plugins.get_mut(name) else {
|
|
continue;
|
|
};
|
|
if !plugin.is_enabled() {
|
|
continue;
|
|
}
|
|
let ctx = render_ctx(args, &engine.runtime, left_width as usize);
|
|
let lines = split_lines(plugin.render(&ctx));
|
|
if lines.is_empty() {
|
|
continue;
|
|
}
|
|
let height = (lines.len() as u16).min(area.y + area.height - y);
|
|
y += 1; // separator/blank line
|
|
if y >= area.y + area.height {
|
|
break;
|
|
}
|
|
let height = height.min(area.y + area.height - y);
|
|
draw_lines(
|
|
frame,
|
|
Rect {
|
|
x: area.x,
|
|
y,
|
|
width: left_width,
|
|
height,
|
|
},
|
|
&lines,
|
|
args,
|
|
);
|
|
y += height;
|
|
}
|
|
}
|
|
|
|
// Right side: process count + processes + alert footer.
|
|
let right_x = area.x + left_width + if left_width > 0 { 1 } else { 0 };
|
|
let right_width = area.width.saturating_sub(right_x - area.x);
|
|
if right_width < 10 {
|
|
return;
|
|
}
|
|
let mut y = area.y;
|
|
|
|
// Process count.
|
|
if let Some(plugin) = engine.plugins.get_mut("processcount")
|
|
&& plugin.is_enabled()
|
|
{
|
|
let ctx = render_ctx(args, &engine.runtime, right_width as usize);
|
|
let lines = split_lines(plugin.render(&ctx));
|
|
let height = (lines.len() as u16).min(2);
|
|
draw_lines(
|
|
frame,
|
|
Rect {
|
|
x: right_x,
|
|
y,
|
|
width: right_width,
|
|
height,
|
|
},
|
|
&lines,
|
|
args,
|
|
);
|
|
y += height;
|
|
}
|
|
|
|
// Alerts footer (up to 4 lines).
|
|
let event_lines = self.event_lines(engine, right_width as usize);
|
|
let alert_height = event_lines.len().min(5) as u16;
|
|
let list_height = area.y + area.height - y;
|
|
let process_height = list_height.saturating_sub(alert_height);
|
|
|
|
let list_name = if args.programs {
|
|
"programlist"
|
|
} else {
|
|
"processlist"
|
|
};
|
|
if let Some(plugin) = engine.plugins.get_mut(list_name)
|
|
&& plugin.is_enabled()
|
|
&& process_height > 1
|
|
{
|
|
let ctx = render_ctx(args, &engine.runtime, right_width as usize);
|
|
let mut lines = split_lines(plugin.render(&ctx));
|
|
lines.truncate(process_height as usize);
|
|
draw_lines(
|
|
frame,
|
|
Rect {
|
|
x: right_x,
|
|
y,
|
|
width: right_width,
|
|
height: process_height,
|
|
},
|
|
&lines,
|
|
args,
|
|
);
|
|
}
|
|
y += process_height;
|
|
if alert_height > 0 {
|
|
draw_lines(
|
|
frame,
|
|
Rect {
|
|
x: right_x,
|
|
y,
|
|
width: right_width,
|
|
height: alert_height,
|
|
},
|
|
&event_lines,
|
|
args,
|
|
);
|
|
}
|
|
}
|
|
|
|
fn event_lines(&self, engine: &Engine, _width: usize) -> Vec<Vec<StatLine>> {
|
|
let events = glances_core::events::events().lock().unwrap();
|
|
let mut lines = Vec::new();
|
|
if events.is_empty() {
|
|
return lines;
|
|
}
|
|
lines.push(vec![
|
|
StatLine::new("EVENTS HISTORY").decoration(Decoration::Title),
|
|
]);
|
|
for event in events.events.iter().rev().take(4) {
|
|
let state = match event.state.as_str() {
|
|
"CRITICAL" => Decoration::CriticalLog,
|
|
"WARNING" => Decoration::WarningLog,
|
|
_ => Decoration::Default,
|
|
};
|
|
let end = if event.is_ongoing() {
|
|
String::new()
|
|
} else {
|
|
" (ended)".to_string()
|
|
};
|
|
lines.push(vec![
|
|
StatLine::new(format!("{} ", event.state)).decoration(state),
|
|
StatLine::new(format!("{} (avg {:.1}){}", event.r#type, event.avg, end)),
|
|
]);
|
|
}
|
|
let _ = engine;
|
|
lines
|
|
}
|
|
|
|
fn draw_popup(&self, frame: &mut Frame, area: Rect) {
|
|
let (title, prompt) = match self.popup {
|
|
Popup::Filter => ("Filter", format!("Process filter: {}_", self.input)),
|
|
Popup::Kill => ("Kill process", "Confirm ([y]es/[n]o): ".to_string()),
|
|
_ => return,
|
|
};
|
|
let block = Block::default().borders(Borders::ALL).title(title);
|
|
frame.render_widget(Clear, area);
|
|
frame.render_widget(Paragraph::new(prompt).block(block), area);
|
|
}
|
|
|
|
fn draw_help(&self, frame: &mut Frame, area: Rect) {
|
|
let lines = vec![
|
|
Line::from("Glances-rs help"),
|
|
Line::from(""),
|
|
Line::from("q / ESC Quit"),
|
|
Line::from("h Toggle this help"),
|
|
Line::from("0 Irix mode (disable-irix)"),
|
|
Line::from("1 Per CPU mode"),
|
|
Line::from("2 Disable left sidebar"),
|
|
Line::from("3 Disable quicklook"),
|
|
Line::from("4 Full quicklook"),
|
|
Line::from("5 Disable top menu"),
|
|
Line::from("6 Mean GPU mode"),
|
|
Line::from(
|
|
"a c m i o p t u Sort processes (auto/cpu/mem/io/cpu_time/name/time/user)",
|
|
),
|
|
Line::from("</> Cycle sort key"),
|
|
Line::from("UP/DOWN Select process"),
|
|
Line::from("+ / - Increase/decrease nice level"),
|
|
Line::from("k Kill selected process"),
|
|
Line::from("f / E Edit/erase process filter"),
|
|
Line::from("z Disable/enable processes"),
|
|
Line::from("e Extended stats for the selected process"),
|
|
Line::from("w / x Clean warning/critical events"),
|
|
Line::from("b Byte mode (network)"),
|
|
Line::from("T / U Network sum / cumulative"),
|
|
Line::from("B / L Disk IOPS / latency"),
|
|
Line::from("F FS free space"),
|
|
Line::from("S Sparkline"),
|
|
Line::from("M Reset min/max"),
|
|
Line::from("d n s l D C I V W P K Toggle plugins"),
|
|
];
|
|
let block = Block::default().borders(Borders::ALL).title("Help");
|
|
frame.render_widget(Clear, area);
|
|
frame.render_widget(
|
|
Paragraph::new(lines)
|
|
.block(block)
|
|
.wrap(Wrap { trim: false }),
|
|
area,
|
|
);
|
|
}
|
|
|
|
fn handle_key(&mut self, engine: &mut Engine, key: KeyEvent) {
|
|
let args = &mut engine.args;
|
|
// Popup handling first.
|
|
match self.popup {
|
|
Popup::Help => {
|
|
self.popup = Popup::None;
|
|
return;
|
|
}
|
|
Popup::Filter => match key.code {
|
|
KeyCode::Enter => {
|
|
let filter = self.input.clone();
|
|
let mut procs = processes().lock().unwrap();
|
|
procs.filter.set_filter(if filter.is_empty() {
|
|
None
|
|
} else {
|
|
Some(&filter)
|
|
});
|
|
self.popup = Popup::None;
|
|
}
|
|
KeyCode::Esc => self.popup = Popup::None,
|
|
KeyCode::Backspace => {
|
|
self.input.pop();
|
|
}
|
|
KeyCode::Char(c) => self.input.push(c),
|
|
_ => {}
|
|
},
|
|
Popup::Kill => match key.code {
|
|
KeyCode::Char('y') | KeyCode::Char('Y') => {
|
|
let cursor = engine.runtime.cursor_position.max(0) as usize;
|
|
let pid = processes()
|
|
.lock()
|
|
.unwrap()
|
|
.get_list(false)
|
|
.get(cursor)
|
|
.and_then(|p| p.get("pid"))
|
|
.and_then(serde_json::Value::as_i64);
|
|
if let Some(pid) = pid {
|
|
processes().lock().unwrap().kill(pid);
|
|
}
|
|
self.popup = Popup::None;
|
|
}
|
|
KeyCode::Char('n') | KeyCode::Char('N') | KeyCode::Esc => self.popup = Popup::None,
|
|
_ => {}
|
|
},
|
|
Popup::None => {}
|
|
}
|
|
if self.popup != Popup::None {
|
|
return;
|
|
}
|
|
|
|
match key.code {
|
|
KeyCode::Char('q') | KeyCode::Esc => self.quit = true,
|
|
KeyCode::Char('h') => self.popup = Popup::Help,
|
|
KeyCode::Char('0') => engine.runtime.disable_irix = !engine.runtime.disable_irix,
|
|
KeyCode::Char('1') => {
|
|
args.percpu = !args.percpu;
|
|
engine.runtime.percpu = args.percpu;
|
|
}
|
|
KeyCode::Char('2') => args.disable_left_sidebar = !args.disable_left_sidebar,
|
|
KeyCode::Char('3') => args.disable_quicklook = !args.disable_quicklook,
|
|
KeyCode::Char('4') => args.full_quicklook = !args.full_quicklook,
|
|
KeyCode::Char('5') => args.disable_top = !args.disable_top,
|
|
KeyCode::Char('6') => {
|
|
args.meangpu = !args.meangpu;
|
|
engine.runtime.meangpu = args.meangpu;
|
|
}
|
|
KeyCode::Char('/') => {
|
|
engine.runtime.process_short_name = !engine.runtime.process_short_name
|
|
}
|
|
KeyCode::Char('a') => set_sort(engine, "auto"),
|
|
KeyCode::Char('c') => set_sort(engine, "cpu_percent"),
|
|
KeyCode::Char('m') => set_sort(engine, "memory_percent"),
|
|
KeyCode::Char('i') => set_sort(engine, "io_counters"),
|
|
KeyCode::Char('o') => set_sort(engine, "cpu_num"),
|
|
KeyCode::Char('p') => set_sort(engine, "name"),
|
|
KeyCode::Char('t') => set_sort(engine, "cpu_times"),
|
|
KeyCode::Char('u') => set_sort(engine, "username"),
|
|
KeyCode::Char('<') => cycle_sort(engine, false),
|
|
KeyCode::Char('>') => cycle_sort(engine, true),
|
|
KeyCode::Up => move_cursor(engine, -1),
|
|
KeyCode::Down => move_cursor(engine, 1),
|
|
KeyCode::Char('+') => nice_change(engine, true),
|
|
KeyCode::Char('-') => nice_change(engine, false),
|
|
KeyCode::Char('k') => self.popup = Popup::Kill,
|
|
KeyCode::Char('f') => {
|
|
self.input = processes()
|
|
.lock()
|
|
.unwrap()
|
|
.filter
|
|
.filter_input()
|
|
.unwrap_or("")
|
|
.to_string();
|
|
self.popup = Popup::Filter;
|
|
}
|
|
KeyCode::Char('E') => processes().lock().unwrap().filter.set_filter(None),
|
|
KeyCode::Char('z') => toggle_processes(engine),
|
|
KeyCode::Char('e') => toggle_extended(engine),
|
|
KeyCode::Char('w') => {
|
|
glances_core::events::events().lock().unwrap().clean(false);
|
|
}
|
|
KeyCode::Char('x') => {
|
|
glances_core::events::events().lock().unwrap().clean(true);
|
|
}
|
|
KeyCode::Char('b') => args.byte = !args.byte,
|
|
KeyCode::Char('T') => engine.runtime.network_sum = !engine.runtime.network_sum,
|
|
KeyCode::Char('U') => engine.runtime.network_cumul = !engine.runtime.network_cumul,
|
|
KeyCode::Char('B') => args.diskio_iops = !args.diskio_iops,
|
|
KeyCode::Char('L') => args.diskio_latency = !args.diskio_latency,
|
|
KeyCode::Char('F') => engine.runtime.fs_free_space = !engine.runtime.fs_free_space,
|
|
KeyCode::Char('S') => engine.runtime.sparkline = !engine.runtime.sparkline,
|
|
KeyCode::Char('M') => {
|
|
engine.runtime.reset_minmax_tag = !engine.runtime.reset_minmax_tag
|
|
}
|
|
KeyCode::Char('j') => {
|
|
args.programs = !args.programs;
|
|
engine.runtime.programs = args.programs;
|
|
}
|
|
KeyCode::Char(
|
|
c @ ('d' | 'n' | 's' | 'l' | 'D' | 'C' | 'I' | 'V' | 'W' | 'P' | 'K' | 'R'),
|
|
) => {
|
|
toggle_plugin_by_key(engine, c);
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn render_ctx<'a>(
|
|
args: &'a Args,
|
|
runtime: &'a glances_core::Runtime,
|
|
max_width: usize,
|
|
) -> RenderContext<'a> {
|
|
RenderContext {
|
|
args,
|
|
runtime,
|
|
max_width,
|
|
}
|
|
}
|
|
|
|
fn quicklook_width(width: u16) -> u16 {
|
|
((width as f64 * 0.28) as u16).clamp(24, 48)
|
|
}
|
|
|
|
fn split_lines(lines: Vec<StatLine>) -> Vec<Vec<StatLine>> {
|
|
let mut result: Vec<Vec<StatLine>> = vec![Vec::new()];
|
|
for line in lines {
|
|
if line.msg == "\n" {
|
|
result.push(Vec::new());
|
|
} else {
|
|
result.last_mut().unwrap().push(line);
|
|
}
|
|
}
|
|
result
|
|
}
|
|
|
|
/// Draw a list of lines into a rect (a line group is a row).
|
|
fn draw_lines(frame: &mut Frame, area: Rect, lines: &[Vec<StatLine>], args: &Args) {
|
|
if area.width == 0 || area.height == 0 {
|
|
return;
|
|
}
|
|
let buffer = frame.buffer_mut();
|
|
for (row, line) in lines.iter().take(area.height as usize).enumerate() {
|
|
let y = area.y + row as u16;
|
|
let mut x = area.x;
|
|
let mut decoration = Decoration::Default;
|
|
for segment in line {
|
|
if segment.decoration != Decoration::Default {
|
|
decoration = segment.decoration;
|
|
}
|
|
let style = style_for(decoration, args);
|
|
for c in segment.msg.chars() {
|
|
if x >= area.x + area.width {
|
|
break;
|
|
}
|
|
if let Some(cell) = buffer.cell_mut((x, y)) {
|
|
cell.set_char(c);
|
|
cell.set_style(style);
|
|
}
|
|
x += 1;
|
|
}
|
|
if x >= area.x + area.width {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn style_for(decoration: Decoration, args: &Args) -> Style {
|
|
let bold = if args.disable_bold {
|
|
Modifier::empty()
|
|
} else {
|
|
Modifier::BOLD
|
|
};
|
|
let bg = args.disable_bg;
|
|
match decoration {
|
|
Decoration::Default | Decoration::Password => Style::default(),
|
|
Decoration::Underline => Style::default().add_modifier(Modifier::UNDERLINED),
|
|
Decoration::Bold | Decoration::Selected | Decoration::Sort | Decoration::Filter => {
|
|
Style::default().add_modifier(bold | Modifier::UNDERLINED)
|
|
}
|
|
Decoration::Title => Style::default().add_modifier(bold),
|
|
Decoration::Ok | Decoration::Process | Decoration::Status => {
|
|
Style::default().fg(Color::Green)
|
|
}
|
|
Decoration::Max => Style::default().fg(Color::Green).add_modifier(bold),
|
|
Decoration::Careful | Decoration::Info => Style::default().fg(Color::Blue),
|
|
Decoration::CarefulLog => {
|
|
if bg {
|
|
Style::default().fg(Color::Blue).add_modifier(bold)
|
|
} else {
|
|
Style::default().bg(Color::Blue).add_modifier(bold)
|
|
}
|
|
}
|
|
Decoration::Warning => Style::default().fg(Color::Magenta).add_modifier(bold),
|
|
Decoration::WarningLog => {
|
|
if bg {
|
|
Style::default().fg(Color::Magenta).add_modifier(bold)
|
|
} else {
|
|
Style::default().bg(Color::Magenta).add_modifier(bold)
|
|
}
|
|
}
|
|
Decoration::Critical => Style::default().fg(Color::Red).add_modifier(bold),
|
|
Decoration::CriticalLog => {
|
|
if bg {
|
|
Style::default().fg(Color::Red).add_modifier(bold)
|
|
} else {
|
|
Style::default().bg(Color::Red).add_modifier(bold)
|
|
}
|
|
}
|
|
Decoration::OkLog => {
|
|
if bg {
|
|
Style::default().fg(Color::Green).add_modifier(bold)
|
|
} else {
|
|
Style::default().bg(Color::Green).add_modifier(bold)
|
|
}
|
|
}
|
|
Decoration::CpuTime => Style::default().fg(Color::Magenta),
|
|
Decoration::ProcessSelected => Style::default()
|
|
.fg(Color::Green)
|
|
.add_modifier(bold | Modifier::UNDERLINED),
|
|
Decoration::Error => Style::default().fg(Color::Red),
|
|
Decoration::Separator => Style::default().fg(Color::DarkGray),
|
|
}
|
|
}
|
|
|
|
fn set_sort(_engine: &mut Engine, key: &str) {
|
|
let mut procs = processes().lock().unwrap();
|
|
procs.set_sort_key(key, key != "auto");
|
|
procs.auto_sort = key == "auto";
|
|
}
|
|
|
|
fn cycle_sort(engine: &mut Engine, forward: bool) {
|
|
const KEYS: [&str; 7] = [
|
|
"cpu_percent",
|
|
"memory_percent",
|
|
"username",
|
|
"cpu_times",
|
|
"io_counters",
|
|
"name",
|
|
"cpu_num",
|
|
];
|
|
let current = processes().lock().unwrap().sort_key.clone();
|
|
let index = KEYS.iter().position(|k| *k == current).unwrap_or(0);
|
|
let next = if forward {
|
|
(index + 1) % KEYS.len()
|
|
} else {
|
|
(index + KEYS.len() - 1) % KEYS.len()
|
|
};
|
|
set_sort(engine, KEYS[next]);
|
|
}
|
|
|
|
fn move_cursor(engine: &mut Engine, delta: i64) {
|
|
let len = processes().lock().unwrap().get_list(false).len() as i64;
|
|
let max = (len - 1).max(0);
|
|
engine.runtime.cursor_position = (engine.runtime.cursor_position + delta).clamp(0, max);
|
|
}
|
|
|
|
fn nice_change(engine: &mut Engine, increase: bool) {
|
|
let cursor = engine.runtime.cursor_position.max(0) as usize;
|
|
let pid = processes()
|
|
.lock()
|
|
.unwrap()
|
|
.get_list(false)
|
|
.get(cursor)
|
|
.and_then(|p| p.get("pid"))
|
|
.and_then(serde_json::Value::as_i64);
|
|
if let Some(pid) = pid {
|
|
let procs = processes().lock().unwrap();
|
|
if increase {
|
|
procs.nice_increase(pid);
|
|
} else {
|
|
procs.nice_decrease(pid);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn toggle_processes(engine: &mut Engine) {
|
|
let enabled = engine
|
|
.plugins
|
|
.get("processlist")
|
|
.map(|p| p.is_enabled())
|
|
.unwrap_or(false);
|
|
for name in ["processcount", "processlist", "programlist"] {
|
|
if let Some(plugin) = engine.plugins.get_mut(name) {
|
|
plugin.set_enabled(!enabled);
|
|
}
|
|
}
|
|
engine.sync_enabled();
|
|
}
|
|
|
|
fn toggle_extended(engine: &mut Engine) {
|
|
let procs = processes().lock().unwrap();
|
|
if procs.disable_extended_tag {
|
|
drop(procs);
|
|
processes().lock().unwrap().enable_extended();
|
|
engine.args.enable_process_extended = true;
|
|
} else {
|
|
drop(procs);
|
|
processes().lock().unwrap().disable_extended();
|
|
engine.args.enable_process_extended = false;
|
|
}
|
|
}
|
|
|
|
fn toggle_plugin_by_key(engine: &mut Engine, key: char) {
|
|
let name = match key {
|
|
'd' => "diskio",
|
|
'n' => "network",
|
|
's' => "sensors",
|
|
'l' => "alert",
|
|
'D' => "containers",
|
|
'C' => "cloud",
|
|
'I' => "ip",
|
|
'V' => "vms",
|
|
'W' => "wifi",
|
|
'P' => "ports",
|
|
'K' => "connections",
|
|
'R' => "raid",
|
|
_ => return,
|
|
};
|
|
if let Some(plugin) = engine.plugins.get_mut(name) {
|
|
let enabled = plugin.is_enabled();
|
|
plugin.set_enabled(!enabled);
|
|
engine.sync_enabled();
|
|
}
|
|
}
|
|
|
|
/// Keep the `Align` import alive for future use.
|
|
#[allow(dead_code)]
|
|
fn unused(_: Align) {}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use ratatui::backend::TestBackend;
|
|
|
|
fn buffer_to_string(buffer: &ratatui::buffer::Buffer) -> String {
|
|
let area = buffer.area();
|
|
let mut out = String::new();
|
|
for y in 0..area.height {
|
|
for x in 0..area.width {
|
|
if let Some(cell) = buffer.cell((x, y)) {
|
|
out.push_str(cell.symbol());
|
|
}
|
|
}
|
|
out.push('\n');
|
|
}
|
|
out
|
|
}
|
|
|
|
#[test]
|
|
fn test_tui_layout_renders() {
|
|
use clap::Parser;
|
|
use glances_core::Config;
|
|
let mut args = Args::parse_from([
|
|
"glances",
|
|
"--disable-plugin",
|
|
"all",
|
|
"--enable-plugin",
|
|
"cpu,mem,load,processlist,processcount,network,fs,diskio,now,system,uptime,quicklook",
|
|
]);
|
|
args.time = Some(1.0);
|
|
let config = Config::empty(false);
|
|
let mut engine = Engine::new(args.clone(), config);
|
|
engine.update();
|
|
engine.update();
|
|
let backend = TestBackend::new(140, 40);
|
|
let mut terminal = ratatui::Terminal::new(backend).unwrap();
|
|
let tui = Tui {
|
|
popup: Popup::None,
|
|
input: String::new(),
|
|
quit: false,
|
|
};
|
|
terminal
|
|
.draw(|frame| draw_frame(frame, &mut engine, &tui))
|
|
.unwrap();
|
|
let text = buffer_to_string(terminal.backend().buffer());
|
|
println!("{text}");
|
|
assert!(text.contains("CPU"));
|
|
assert!(text.contains("MEM"));
|
|
assert!(text.contains("Command") || text.contains("python") || text.contains("COMMAND"));
|
|
}
|
|
}
|