bottom/src/lib.rs
2025-02-07 01:54:03 +00:00

463 lines
16 KiB
Rust

//! A customizable cross-platform graphical process/system monitor for the
//! terminal. Supports Linux, macOS, and Windows. Inspired by gtop, gotop, and
//! htop.
//!
//! **Note:** The following documentation is primarily intended for people to
//! refer to for development purposes rather than the actual usage of the
//! application. If you are instead looking for documentation regarding the
//! *usage* of bottom, refer to [here](https://clementtsang.github.io/bottom/stable/).
pub(crate) mod app;
mod utils {
pub(crate) mod cancellation_token;
pub(crate) mod conversion;
pub(crate) mod data_units;
pub(crate) mod general;
pub(crate) mod logging;
pub(crate) mod strings;
}
pub(crate) mod canvas;
pub(crate) mod collection;
pub(crate) mod constants;
pub(crate) mod event;
pub mod options;
pub mod widgets;
use std::{
boxed::Box,
io::{stderr, stdout, Stdout, Write},
panic::{self, PanicHookInfo},
sync::{
mpsc::{self, Receiver, Sender},
Arc,
},
thread::{self, JoinHandle},
time::{Duration, Instant},
};
use app::{layout_manager::UsedWidgets, App, AppConfigFields, DataFilters};
use crossterm::{
cursor::{Hide, Show},
event::{
poll, read, DisableBracketedPaste, DisableMouseCapture, EnableBracketedPaste,
EnableMouseCapture, Event, KeyEventKind, MouseEventKind,
},
execute,
terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
};
use event::{handle_key_event_or_break, handle_mouse_event, BottomEvent, CollectionThreadEvent};
use options::{args, get_or_create_config, init_app};
use tui::{backend::CrosstermBackend, Terminal};
use utils::cancellation_token::CancellationToken;
use utils::conversion::*;
#[allow(unused_imports, reason = "this is needed if logging is enabled")]
use utils::logging::*;
// Used for heap allocation debugging purposes.
// #[global_allocator]
// static ALLOC: dhat::Alloc = dhat::Alloc;
/// Try drawing. If not, clean up the terminal and return an error.
fn try_drawing(
terminal: &mut Terminal<CrosstermBackend<std::io::Stdout>>, app: &mut App,
painter: &mut canvas::Painter,
) -> anyhow::Result<()> {
if let Err(err) = painter.draw_data(terminal, app) {
cleanup_terminal(terminal)?;
Err(err.into())
} else {
Ok(())
}
}
/// Clean up the terminal before returning it to the user.
fn cleanup_terminal(
terminal: &mut Terminal<CrosstermBackend<std::io::Stdout>>,
) -> anyhow::Result<()> {
disable_raw_mode()?;
execute!(
terminal.backend_mut(),
DisableBracketedPaste,
DisableMouseCapture,
LeaveAlternateScreen,
Show,
)?;
terminal.show_cursor()?;
Ok(())
}
/// Check and report to the user if the current environment is not a terminal.
fn check_if_terminal() {
use crossterm::tty::IsTty;
if !stdout().is_tty() {
eprintln!(
"Warning: bottom is not being output to a terminal. Things might not work properly."
);
eprintln!("If you're stuck, press 'q' or 'Ctrl-c' to quit the program.");
stderr().flush().unwrap();
thread::sleep(Duration::from_secs(1));
}
}
/// This manually resets stdout back to normal state.
pub fn reset_stdout() -> Stdout {
let mut stdout = stdout();
let _ = disable_raw_mode();
let _ = execute!(
stdout,
DisableBracketedPaste,
DisableMouseCapture,
LeaveAlternateScreen,
Show,
);
stdout
}
/// A panic hook to properly restore the terminal in the case of a panic.
/// Originally based on [spotify-tui's implementation](https://github.com/Rigellute/spotify-tui/blob/master/src/main.rs).
fn panic_hook(panic_info: &PanicHookInfo<'_>) {
let msg = match panic_info.payload().downcast_ref::<&'static str>() {
Some(s) => *s,
None => match panic_info.payload().downcast_ref::<String>() {
Some(s) => &s[..],
None => "Box<Any>",
},
};
let backtrace = format!("{:?}", backtrace::Backtrace::new());
reset_stdout();
// Print stack trace. Must be done after!
if let Some(panic_info) = panic_info.location() {
println!("thread '<unnamed>' panicked at '{msg}', {panic_info}\n\r{backtrace}")
}
// TODO: Might be cleaner in the future to use a cancellation token, but that causes some fun issues with
// lifetimes; for now if it panics then shut down the main program entirely ASAP.
std::process::exit(1);
}
/// Create a thread to poll for user inputs and forward them to the main thread.
fn create_input_thread(
sender: Sender<BottomEvent>, cancellation_token: Arc<CancellationToken>,
) -> JoinHandle<()> {
thread::spawn(move || {
let mut mouse_timer = Instant::now();
loop {
// We don't block.
if let Some(is_terminated) = cancellation_token.try_check() {
if is_terminated {
break;
}
}
if let Ok(poll) = poll(Duration::from_millis(20)) {
if poll {
if let Ok(event) = read() {
match event {
Event::Resize(_, _) => {
// TODO: Might want to debounce this in the future, or take into
// account the actual resize values.
// Maybe we want to keep the current implementation in case the
// resize event might not fire...
// not sure.
if sender.send(BottomEvent::Resize).is_err() {
break;
}
}
Event::Paste(paste) => {
if sender.send(BottomEvent::PasteEvent(paste)).is_err() {
break;
}
}
Event::Key(key) if key.kind == KeyEventKind::Press => {
// For now, we only care about key down events. This may change in
// the future.
if sender.send(BottomEvent::KeyInput(key)).is_err() {
break;
}
}
Event::Mouse(mouse) => match mouse.kind {
MouseEventKind::Moved | MouseEventKind::Drag(..) => {}
MouseEventKind::ScrollDown | MouseEventKind::ScrollUp => {
if Instant::now().duration_since(mouse_timer).as_millis() >= 20
{
if sender.send(BottomEvent::MouseInput(mouse)).is_err() {
break;
}
mouse_timer = Instant::now();
}
}
_ => {
if sender.send(BottomEvent::MouseInput(mouse)).is_err() {
break;
}
}
},
Event::Key(_) => {}
Event::FocusGained => {}
Event::FocusLost => {}
}
}
}
}
}
})
}
/// Create a thread to handle data collection.
fn create_collection_thread(
sender: Sender<BottomEvent>, control_receiver: Receiver<CollectionThreadEvent>,
cancellation_token: Arc<CancellationToken>, app_config_fields: &AppConfigFields,
filters: DataFilters, used_widget_set: UsedWidgets,
) -> JoinHandle<()> {
let use_current_cpu_total = app_config_fields.use_current_cpu_total;
let unnormalized_cpu = app_config_fields.unnormalized_cpu;
let show_average_cpu = app_config_fields.show_average_cpu;
let update_time = app_config_fields.update_rate;
thread::spawn(move || {
let mut data_state = collection::DataCollector::new(filters);
data_state.set_collection(used_widget_set);
data_state.set_use_current_cpu_total(use_current_cpu_total);
data_state.set_unnormalized_cpu(unnormalized_cpu);
data_state.set_show_average_cpu(show_average_cpu);
data_state.init();
loop {
// Check once at the very top... don't block though.
if let Some(is_terminated) = cancellation_token.try_check() {
if is_terminated {
break;
}
}
if let Ok(message) = control_receiver.try_recv() {
// trace!("Received message in collection thread: {message:?}");
match message {
CollectionThreadEvent::Reset => {
data_state.data.cleanup();
}
}
}
data_state.update_data();
// Yet another check to bail if needed... do not block!
if let Some(is_terminated) = cancellation_token.try_check() {
if is_terminated {
break;
}
}
let event = BottomEvent::Update(Box::from(data_state.data));
data_state.data = collection::Data::default();
if sender.send(event).is_err() {
break;
}
// Sleep while allowing for interruptions...
if cancellation_token.sleep_with_cancellation(Duration::from_millis(update_time)) {
break;
}
}
})
}
/// Main code to call.
#[inline]
pub fn start_bottom() -> anyhow::Result<()> {
// let _profiler = dhat::Profiler::new_heap();
let args = args::get_args();
#[cfg(feature = "logging")]
{
if let Err(err) = init_logger(
log::LevelFilter::Debug,
Some(std::ffi::OsStr::new("debug.log")),
) {
println!("Issue initializing logger: {err}");
}
}
// Read from config file.
let config = get_or_create_config(args.general.config_location.as_deref())?;
// Create the "app" and initialize a bunch of stuff.
let (mut app, widget_layout, styling) = init_app(args, config)?;
// Create painter and set colours.
let mut painter = canvas::Painter::init(widget_layout, styling)?;
// Check if the current environment is in a terminal.
check_if_terminal();
let cancellation_token = Arc::new(CancellationToken::default());
let (sender, receiver) = mpsc::channel();
// Set up the event loop thread; we set this up early to speed up
// first-time-to-data.
let (collection_thread_ctrl_sender, collection_thread_ctrl_receiver) = mpsc::channel();
let _collection_thread = create_collection_thread(
sender.clone(),
collection_thread_ctrl_receiver,
cancellation_token.clone(),
&app.app_config_fields,
app.filters.clone(),
app.used_widgets,
);
// Set up the input handling loop thread.
let _input_thread = create_input_thread(sender.clone(), cancellation_token.clone());
// Set up the cleaning loop thread.
let _cleaning_thread = {
let cancellation_token = cancellation_token.clone();
let cleaning_sender = sender.clone();
let offset_wait = Duration::from_millis(app.app_config_fields.retention_ms + 60000);
thread::spawn(move || loop {
if cancellation_token.sleep_with_cancellation(offset_wait) {
break;
}
if cleaning_sender.send(BottomEvent::Clean).is_err() {
break;
}
})
};
// Set up tui and crossterm
let mut stdout_val = stdout();
execute!(
stdout_val,
Hide,
EnterAlternateScreen,
EnableMouseCapture,
EnableBracketedPaste
)?;
enable_raw_mode()?;
let mut terminal = Terminal::new(CrosstermBackend::new(stdout_val))?;
terminal.clear()?;
terminal.hide_cursor()?;
#[cfg(target_os = "freebsd")]
let _stderr_fd = {
// A really ugly band-aid to suppress stderr warnings on FreeBSD due to sysinfo.
// For more information, see https://github.com/ClementTsang/bottom/issues/798.
use std::fs::OpenOptions;
use filedescriptor::{FileDescriptor, StdioDescriptor};
let path = OpenOptions::new().write(true).open("/dev/null")?;
FileDescriptor::redirect_stdio(&path, StdioDescriptor::Stderr)?
};
// Set panic hook
panic::set_hook(Box::new(panic_hook));
// Set termination hook
// TODO: On UNIX, use signal-hook to handle cleanup as well.
ctrlc::set_handler(move || {
let _ = sender.send(BottomEvent::Terminate);
})?;
let mut first_run = true;
// Draw once first to initialize the canvas, so it doesn't feel like it's
// frozen.
try_drawing(&mut terminal, &mut app, &mut painter)?;
loop {
if let Ok(recv) = receiver.recv() {
match recv {
BottomEvent::Terminate => {
break;
}
BottomEvent::Resize => {
try_drawing(&mut terminal, &mut app, &mut painter)?;
}
BottomEvent::KeyInput(event) => {
if handle_key_event_or_break(event, &mut app, &collection_thread_ctrl_sender) {
break;
}
app.update_data();
try_drawing(&mut terminal, &mut app, &mut painter)?;
}
BottomEvent::MouseInput(event) => {
handle_mouse_event(event, &mut app);
app.update_data();
try_drawing(&mut terminal, &mut app, &mut painter)?;
}
BottomEvent::PasteEvent(paste) => {
app.handle_paste(paste);
app.update_data();
try_drawing(&mut terminal, &mut app, &mut painter)?;
}
BottomEvent::Update(data) => {
app.data_store.eat_data(data, &app.app_config_fields);
// This thing is required as otherwise, some widgets can't draw correctly w/o
// some data (or they need to be re-drawn).
if first_run {
first_run = false;
app.is_force_redraw = true;
}
if !app.data_store.is_frozen() {
// Convert all data into data for the displayed widgets.
if app.used_widgets.use_disk {
for disk in app.states.disk_state.widget_states.values_mut() {
disk.force_data_update();
}
}
if app.used_widgets.use_temp {
for temp in app.states.temp_state.widget_states.values_mut() {
temp.force_data_update();
}
}
if app.used_widgets.use_proc {
for proc in app.states.proc_state.widget_states.values_mut() {
proc.force_data_update();
}
}
if app.used_widgets.use_cpu {
for cpu in app.states.cpu_state.widget_states.values_mut() {
cpu.force_data_update();
}
}
app.update_data();
try_drawing(&mut terminal, &mut app, &mut painter)?;
}
}
BottomEvent::Clean => {
app.data_store
.clean_data(Duration::from_millis(app.app_config_fields.retention_ms));
}
}
}
}
// I think doing it in this order is safe...
// TODO: maybe move the cancellation token to the ctrl-c handler?
cancellation_token.cancel();
cleanup_terminal(&mut terminal)?;
Ok(())
}