add cpus and border info

src/app.rs

@@ -23,26 +23,58 @@ impl App {
     }
 
     pub fn draw(&self, frame: &mut Frame) {
+        let block = Block::default()
+            .title_top(Line::from("Server").centered().bold())
+            .title_bottom(Line::from("press 'q' to exit").right_aligned().italic());
+
+        frame.render_widget(block, frame.area());
+
         let layout = Layout::default()
             .direction(Direction::Horizontal)
+            .margin(1)
             .constraints(vec![Constraint::Percentage(50), Constraint::Percentage(50)])
             .split(frame.area());
 
-        let style = Style::default().fg(Color::Red);
         let block = Block::default().title("Services").borders(Borders::ALL);
 
         frame.render_widget(block, layout[0]);
 
         let disks_gauges = self.disks();
+        let memory_gauges = self.memory();
+        let cpus_gauges = self.cpus();
 
         let layout_system = Layout::vertical([
-            Constraint::Length(6),
+            Constraint::Length((memory_gauges.len() * 2 + 2) as u16),
             Constraint::Length((disks_gauges.len() * 2 + 2) as u16),
+            Constraint::Length((cpus_gauges.len() + 2) as u16),
         ])
         .split(layout[1]);
 
-        self.draw_memory(frame, layout_system[0]);
+        self.draw_gauges(frame, layout_system[0], memory_gauges, "Memory");
-        self.draw_disks(frame, layout_system[1], disks_gauges);
+        self.draw_gauges(frame, layout_system[1], disks_gauges, "Disks");
+        self.draw_gauges(frame, layout_system[2], cpus_gauges, "CPU");
+    }
+
+    fn memory(&self) -> Vec<Gauge> {
+        let mem_total: f64 = ((self.sys.total_memory() >> 20) as f64) / 1024.0;
+        let mem_used: f64 = ((self.sys.used_memory() >> 20) as f64) / 1024.0;
+
+        let mem = Gauge::default()
+            .block(Block::default().title("RAM usage:"))
+            .gauge_style(Style::new().white().on_black().italic())
+            .label(format!("{mem_used:.2}/{mem_total:.2}Go"))
+            .ratio(mem_used / mem_total);
+
+        let swap_total: f64 = ((self.sys.total_swap() >> 20) as f64) / 1024.0;
+        let swap_used: f64 = ((self.sys.used_swap() >> 20) as f64) / 1024.0;
+
+        let swap = Gauge::default()
+            .block(Block::default().title("SWAP usage:"))
+            .gauge_style(Style::new().white().on_black().italic())
+            .label(format!("{swap_used:.2}/{swap_total:.2}Go"))
+            .ratio(swap_used / swap_total);
+
+        vec![mem, swap]
     }
 
     fn disks(&self) -> Vec<Gauge> {
@@ -71,8 +103,24 @@ impl App {
         gauges
     }
 
-    fn draw_disks(&self, frame: &mut Frame, area: Rect, gauges: Vec<Gauge>) {
+    fn cpus(&self) -> Vec<Gauge> {
-        let block = Block::default().title("Disks").borders(Borders::ALL);
+        let mut gauges: Vec<Gauge> = Default::default();
+
+        for (idx, cpu) in self.sys.cpus().into_iter().enumerate() {
+            let usage = cpu.cpu_usage() as f64;
+            let gauge = Gauge::default()
+                .gauge_style(Style::new().white().on_black().italic())
+                .label(format!("{usage:>4.1} %"))
+                .ratio(usage / 100.0);
+
+            gauges.push(gauge);
+        }
+
+        gauges
+    }
+
+    fn draw_gauges(&self, frame: &mut Frame, area: Rect, gauges: Vec<Gauge>, name: &str) {
+        let block = Block::default().title(name).borders(Borders::ALL);
 
         frame.render_widget(block, area);
 
@@ -84,36 +132,4 @@ impl App {
             frame.render_widget(gauge, layout[idx]);
         }
     }
-
-    fn draw_memory(&self, frame: &mut Frame, area: Rect) {
-        let block = Block::default().title("Memory").borders(Borders::ALL);
-
-        frame.render_widget(block, area);
-
-        let layout = Layout::vertical([Constraint::Length(2), Constraint::Length(2)])
-            .margin(1)
-            .split(area);
-
-        let mem_total: f64 = ((self.sys.total_memory() >> 20) as f64) / 1024.0;
-        let mem_used: f64 = ((self.sys.used_memory() >> 20) as f64) / 1024.0;
-
-        let mem_gauge = Gauge::default()
-            .block(Block::default().title("RAM usage:"))
-            .gauge_style(Style::new().white().on_black().italic())
-            .label(format!("{mem_used:.2}/{mem_total:.2}Go"))
-            .ratio(mem_used / mem_total);
-
-        frame.render_widget(mem_gauge, layout[0]);
-
-        let swap_total: f64 = ((self.sys.total_swap() >> 20) as f64) / 1024.0;
-        let swap_used: f64 = ((self.sys.used_swap() >> 20) as f64) / 1024.0;
-
-        let swap_gauge = Gauge::default()
-            .block(Block::default().title("SWAP usage:"))
-            .gauge_style(Style::new().white().on_black().italic())
-            .label(format!("{swap_used:.2}/{swap_total:.2}Go"))
-            .ratio(swap_used / swap_total);
-
-        frame.render_widget(swap_gauge, layout[1]);
-    }
 }