From afe9349573fa784888314452c51e093e3634c049 Mon Sep 17 00:00:00 2001 From: ClementTsang Date: Wed, 11 Sep 2019 23:15:25 -0400 Subject: Changed layout again. --- src/app/data_collection/processes.rs | 8 +++--- src/canvas.rs | 53 +++++++++++++++++++++++------------- src/main.rs | 40 +++++++++++++++++---------- 3 files changed, 64 insertions(+), 37 deletions(-) diff --git a/src/app/data_collection/processes.rs b/src/app/data_collection/processes.rs index e4bb0bd4..7aed3b70 100644 --- a/src/app/data_collection/processes.rs +++ b/src/app/data_collection/processes.rs @@ -52,7 +52,7 @@ fn vangelis_cpu_usage_calculation(prev_idle : &mut f64, prev_non_idle : &mut f64 let total_delta : f64 = total - prev_total; let idle_delta : f64 = idle - *prev_idle; - debug!("Vangelis function: CPU PERCENT: {}", (total_delta - idle_delta) / total_delta * 100_f64); + //debug!("Vangelis function: CPU PERCENT: {}", (total_delta - idle_delta) / total_delta * 100_f64); *prev_idle = idle; *prev_non_idle = non_idle; @@ -103,7 +103,7 @@ fn get_process_cpu_stats(pid : u32) -> std::io::Result { let utime = val[13].parse::().unwrap_or(0_f64); let stime = val[14].parse::().unwrap_or(0_f64); - debug!("PID: {}, utime: {}, stime: {}", pid, utime, stime); + //debug!("PID: {}, utime: {}, stime: {}", pid, utime, stime); Ok(utime + stime) // This seems to match top... } @@ -118,14 +118,14 @@ fn linux_cpu_usage(pid : u32, cpu_usage : f64, previous_pid_stats : &mut HashMap }; let after_proc_val = get_process_cpu_stats(pid)?; - debug!( + /*debug!( "PID - {} - Before: {}, After: {}, CPU: {}, Percentage: {}", pid, before_proc_val, after_proc_val, cpu_usage, (after_proc_val - before_proc_val) / cpu_usage * 100_f64 - ); + );*/ let entry = previous_pid_stats.entry(pid.to_string()).or_insert(after_proc_val); *entry = after_proc_val; diff --git a/src/canvas.rs b/src/canvas.rs index 98744b25..5d5145ac 100644 --- a/src/canvas.rs +++ b/src/canvas.rs @@ -7,7 +7,7 @@ use tui::{ }; const COLOUR_LIST : [Color; 6] = [Color::LightRed, Color::LightGreen, Color::LightYellow, Color::LightBlue, Color::LightCyan, Color::LightMagenta]; -const TEXT_COLOUR : Color = Color::Green; +const TEXT_COLOUR : Color = Color::Gray; #[derive(Default)] pub struct CanvasData { @@ -22,49 +22,64 @@ pub struct CanvasData { // TODO: Change the error pub fn draw_data(terminal : &mut Terminal, canvas_data : &CanvasData) -> Result<(), io::Error> { let temperature_rows = canvas_data.temp_sensor_data.iter().map(|sensor| Row::StyledData(sensor.iter(), Style::default().fg(TEXT_COLOUR))); - let disk_rows = canvas_data.disk_data.iter().map(|disk| Row::StyledData(disk.iter(), Style::default().fg(TEXT_COLOUR))); - let process_rows = canvas_data.process_data.iter().map(|process| Row::StyledData(process.iter(), Style::default().fg(TEXT_COLOUR))); // TODO: Convert this into a separate func! terminal.draw(|mut f| { + debug!("Drawing!"); let vertical_chunks = Layout::default() .direction(Direction::Vertical) .margin(1) - .constraints([Constraint::Percentage(35), Constraint::Percentage(30), Constraint::Percentage(35)].as_ref()) + .constraints([Constraint::Percentage(34), Constraint::Percentage(34), Constraint::Percentage(32)].as_ref()) .split(f.size()); - let top_chunks = Layout::default() + let _top_chunks = Layout::default() .direction(Direction::Horizontal) .margin(0) .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref()) .split(vertical_chunks[0]); + let middle_chunks = Layout::default() .direction(Direction::Horizontal) .margin(0) - .constraints([Constraint::Percentage(40), Constraint::Percentage(60)].as_ref()) + .constraints([Constraint::Percentage(70), Constraint::Percentage(30)].as_ref()) .split(vertical_chunks[1]); - let middle_divided_chunk_1 = Layout::default() + let _middle_divided_chunk_1 = Layout::default() .direction(Direction::Vertical) .margin(0) .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref()) .split(middle_chunks[0]); - let middle_divided_chunk_2 = Layout::default() + let _middle_divided_chunk_2 = Layout::default() .direction(Direction::Vertical) .margin(0) .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref()) .split(middle_chunks[1]); + let bottom_chunks = Layout::default() .direction(Direction::Horizontal) .margin(0) .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref()) .split(vertical_chunks[2]); + let bottom_divided_chunk_1 = Layout::default() + .direction(Direction::Vertical) + .margin(0) + .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref()) + .split(bottom_chunks[0]); + let bottom_divided_chunk_1_1 = Layout::default() + .direction(Direction::Horizontal) + .margin(0) + .constraints([Constraint::Percentage(40), Constraint::Percentage(60)].as_ref()) + .split(bottom_divided_chunk_1[0]); + let bottom_divided_chunk_1_2 = Layout::default() + .direction(Direction::Horizontal) + .margin(0) + .constraints([Constraint::Percentage(40), Constraint::Percentage(60)].as_ref()) + .split(bottom_divided_chunk_1[1]); // Set up blocks and their components // CPU usage graph { - debug!("Drawing CPU..."); let x_axis : Axis = Axis::default().style(Style::default().fg(Color::White)).bounds([0.0, 60.0]); let y_axis = Axis::default().style(Style::default().fg(Color::White)).bounds([0.0, 100.0]).labels(&["0.0", "50.0", "100.0"]); @@ -84,7 +99,7 @@ pub fn draw_data(terminal : &mut Terminal, canvas_ .x_axis(x_axis) .y_axis(y_axis) .datasets(&dataset_vector) - .render(&mut f, top_chunks[0]); + .render(&mut f, vertical_chunks[0]); } //Memory usage graph @@ -99,7 +114,7 @@ pub fn draw_data(terminal : &mut Terminal, canvas_ Dataset::default() .name(&("MEM :".to_string() + &format!("{:3}%", (canvas_data.mem_data.last().unwrap_or(&(0_f64, 0_f64)).1.round() as u64)))) .marker(Marker::Braille) - .style(Style::default().fg(Color::Cyan)) + .style(Style::default().fg(Color::LightRed)) .data(&canvas_data.mem_data), Dataset::default() .name(&("SWAP:".to_string() + &format!("{:3}%", (canvas_data.swap_data.last().unwrap_or(&(0_f64, 0_f64)).1.round() as u64)))) @@ -107,31 +122,31 @@ pub fn draw_data(terminal : &mut Terminal, canvas_ .style(Style::default().fg(Color::LightGreen)) .data(&canvas_data.swap_data), ]) - .render(&mut f, top_chunks[1]); + .render(&mut f, middle_chunks[0]); } + // Network graph + Block::default().title("Network").borders(Borders::ALL).render(&mut f, middle_chunks[1]); + // Temperature table Table::new(["Sensor", "Temperature"].iter(), temperature_rows) .block(Block::default().title("Temperatures").borders(Borders::ALL)) .header_style(Style::default().fg(Color::LightBlue)) .widths(&[15, 5]) - .render(&mut f, middle_divided_chunk_1[0]); + .render(&mut f, bottom_divided_chunk_1_1[0]); // Disk usage table Table::new(["Disk", "Mount", "Used", "Total", "Free"].iter(), disk_rows) .block(Block::default().title("Disk Usage").borders(Borders::ALL)) .header_style(Style::default().fg(Color::LightBlue)) .widths(&[15, 10, 5, 5, 5]) - .render(&mut f, middle_divided_chunk_1[1]); + .render(&mut f, bottom_divided_chunk_1_2[0]); // Temp graph - Block::default().title("Temperatures").borders(Borders::ALL).render(&mut f, middle_divided_chunk_2[0]); + Block::default().title("Temperatures").borders(Borders::ALL).render(&mut f, bottom_divided_chunk_1_1[1]); // IO graph - Block::default().title("IO Usage").borders(Borders::ALL).render(&mut f, middle_divided_chunk_2[1]); - - // Network graph - Block::default().title("Network").borders(Borders::ALL).render(&mut f, bottom_chunks[0]); + Block::default().title("IO Usage").borders(Borders::ALL).render(&mut f, bottom_divided_chunk_1_2[1]); // Processes table Table::new(["PID", "Name", "CPU%", "Mem%"].iter(), process_rows) diff --git a/src/main.rs b/src/main.rs index b3d79851..1f08524b 100644 --- a/src/main.rs +++ b/src/main.rs @@ -88,17 +88,15 @@ async fn main() -> Result<(), io::Error> { if app.to_be_resorted { data_collection::processes::sort_processes(&mut app_data.list_of_processes, &app.process_sorting_type, app.process_sorting_reverse); + canvas_data.process_data = update_process_row(&app_data); app.to_be_resorted = false; } try_debug(&log, "Input event complete."); - - // Only update processes } Event::Update(data) => { try_debug(&log, "Update event fired!"); app_data = *data; data_collection::processes::sort_processes(&mut app_data.list_of_processes, &app.process_sorting_type, app.process_sorting_reverse); - try_debug(&log, "Update event complete."); // Convert all data into tui components canvas_data.disk_data = update_disk_row(&app_data); @@ -107,15 +105,15 @@ async fn main() -> Result<(), io::Error> { canvas_data.mem_data = update_mem_data_points(&app_data); canvas_data.swap_data = update_swap_data_points(&app_data); canvas_data.cpu_data = update_cpu_data_points(&app_data); + + try_debug(&log, "Update event complete."); } } if app.should_quit { break; } } - // Draw! - // TODO: We should change this btw! It should not redraw everything on every tick! canvas::draw_data(&mut terminal, &canvas_data)?; } @@ -187,30 +185,44 @@ fn update_process_row(app_data : &app::Data) -> Vec> { } fn update_cpu_data_points(app_data : &app::Data) -> Vec<(String, Vec<(f64, f64)>)> { - let mut cpu_vector : Vec<(String, Vec<(f64, f64)>)> = Vec::new(); - let mut data_vector : Vec> = Vec::new(); + let mut cpu_data_vector : Vec<(String, Vec<(f64, f64)>)> = Vec::new(); + let mut cpu_collection : Vec> = Vec::new(); if !app_data.list_of_cpu_packages.is_empty() { - for cpu_num in 0..app_data.list_of_cpu_packages.last().unwrap().cpu_vec.len() { + // Initially, populate the cpu_collection. We want to inject elements in between if possible. + let current_time = std::time::Instant::now(); + + for cpu_num in 1..app_data.list_of_cpu_packages.last().unwrap().cpu_vec.len() { + // 1 to skip total cpu let mut this_cpu_data : Vec<(f64, f64)> = Vec::new(); - let current_time = std::time::Instant::now(); for cpu in &app_data.list_of_cpu_packages { - this_cpu_data.push((STALE_MAX_SECONDS as f64 - current_time.duration_since(cpu.instant).as_secs_f64(), cpu.cpu_vec[cpu_num].cpu_usage)); + // To make it look better... + let current_cpu_usage = cpu.cpu_vec[cpu_num].cpu_usage; + + if !this_cpu_data.is_empty() { + let previous_entry_cpu_usage = this_cpu_data.last().unwrap().1; + let middling_cpu_usage = (previous_entry_cpu_usage + current_cpu_usage) / 2_f64; + + this_cpu_data.push((STALE_MAX_SECONDS as f64 - current_time.duration_since(cpu.instant).as_secs_f64().floor() - 0.5_f64, middling_cpu_usage)); + } + + this_cpu_data.push((STALE_MAX_SECONDS as f64 - current_time.duration_since(cpu.instant).as_secs_f64().floor(), current_cpu_usage)); } - data_vector.push(this_cpu_data); + cpu_collection.push(this_cpu_data); } - for (i, data) in data_vector.iter().enumerate() { - cpu_vector.push(( + // Finally, add it all onto the end + for (i, data) in cpu_collection.iter().enumerate() { + cpu_data_vector.push(( (&*(app_data.list_of_cpu_packages.last().unwrap().cpu_vec[i].cpu_name)).to_string() + " " + &format!("{:.2}", data.last().unwrap_or(&(0_f64, 0_f64)).1.to_string()), data.clone(), )) } } - cpu_vector + cpu_data_vector } fn update_mem_data_points(app_data : &app::Data) -> Vec<(f64, f64)> { -- cgit v1.2.3