Cargo.lock

@@ -709,7 +709,7 @@ dependencies = [
 
 [[package]]
 name = "pp"
-version = "0.2.2-PREVIEW"
+version = "0.2.1"
 dependencies = [
  "ansi_term",
  "chrono",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pp"
-version = "0.2.2-PREVIEW"
+version = "0.2.1"
 edition = "2024"
 
 [dependencies]

src/tui/mod.rs

@@ -1,4 +1,5 @@
 pub mod mode_editing;
+pub mod mode_exiting;
 pub mod mode_monitoring;
 pub mod ratatui_app;
 pub mod target_state_widget;

src/tui/mode_adding.rs

@@ -8,6 +8,7 @@ use ratatui::widgets::{Block, Paragraph};
 use crate::tui::ratatui_screens::RatatuiScreens::Monitoring;
 
 pub struct RatatuiAddingMode {}
+
 impl RatatuiAddingMode {
     pub fn render(frame: &mut Frame, state: &mut RatatuiApp) {
         frame.render_widget(
@@ -16,6 +17,7 @@ impl RatatuiAddingMode {
                 .centered(),
             frame.area()
         );
+
     }
 
     pub fn handle_crossterm_events(app: &mut RatatuiApp) -> Result<()> {

src/tui/mode_deleting.rs

@@ -14,14 +14,7 @@ pub struct RatatuiDeletingMode {}
 impl RatatuiDeletingMode {
     pub fn render(frame: &mut Frame, state: &mut RatatuiApp) {
         let title = Line::from("Delete Host").bold().red().centered();
-        let as_list = state.state.clone();
+        let mut body = format!("Do you really want to delete {} (Y/N)", state.selected_host);
-        let mut nice_status = None;
-        for (index, (label, data)) in as_list.iter().enumerate() {
-            if index == state.selected_host {
-                nice_status = Some(data);
-            }
-        }
-        let mut body = format!("Do you really want to delete {} (Y/N)", nice_status.unwrap().name);
 
         frame.render_widget(
             Paragraph::new(body)
@@ -36,13 +29,7 @@ impl RatatuiDeletingMode {
             match event::read()? {
                 Event::Key(key) if key.kind == KeyEventKind::Press => match key.code {
                     KeyCode::Enter | KeyCode::Char('y') | KeyCode::Char('Y') => {
-                        let as_list = &app.state.clone();
+
-                        for (index, (label, _)) in as_list.iter().enumerate() {
-                            if index == app.selected_host {
-                                app.state.remove(label).unwrap();
-                                app.set_screen(Monitoring)
-                            }
-                        }
                     }
                     KeyCode::Esc | KeyCode::Char('n') | KeyCode::Char('N') => {
                         app.set_screen(Monitoring)

src/tui/mode_exiting.rs

@@ -0,0 +1,43 @@
+use std::time::Duration;
+use crossterm::event;
+use crossterm::event::{Event, KeyCode, KeyEventKind};
+use ratatui::Frame;
+use ratatui::style::Stylize;
+use ratatui::text::Line;
+use ratatui::widgets::{Block, Paragraph};
+use crate::tui::ratatui_app::RatatuiApp;
+use color_eyre::Result;
+use crate::tui::ratatui_screens::RatatuiScreens::Monitoring;
+
+pub struct RatatuiExitingMode {}
+
+impl RatatuiExitingMode {
+    pub fn render(frame: &mut Frame) {
+        let title = Line::from("Exit?").bold().red().centered();
+        let mut body = "Do you want to exit? (Y/N)";
+        frame.render_widget(
+            Paragraph::new(body)
+                .block(Block::bordered().title(title))
+                .centered(),
+            frame.area(),
+        );
+    }
+
+    pub fn handle_crossterm_events(app: &mut RatatuiApp) -> Result<()>{
+        if event::poll(Duration::from_millis(100))? {
+            match event::read()? {
+                Event::Key(key) if key.kind == KeyEventKind::Press => match key.code {
+                    KeyCode::Enter  | KeyCode::Char('y') | KeyCode::Char('Y') => {
+                        app.set_running(false);
+                    }
+                    KeyCode::Char('n') | KeyCode::Char('N') => {
+                        app.set_screen(Monitoring);
+                    }
+                    _ => {}
+                },
+                _ => {}
+            }
+        }
+        Ok(())
+    }
+}

src/tui/mode_monitoring.rs

@@ -1,37 +1,57 @@
 use crate::duration_to_string;
-use crate::target_state::TargetState;
-use crate::tui::ratatui_app::RatatuiApp;
 use color_eyre::Result;
 use crossterm::event;
 use crossterm::event::{Event, KeyCode, KeyEventKind};
-use ratatui::Frame;
-use ratatui::layout::Flex;
 use ratatui::prelude::*;
-use ratatui::widgets::{
+use ratatui::widgets::{Block, Borders, Cell, List, ListItem, ListState, Paragraph, Row, Table, TableState};
-    Block, Borders, Cell, Clear, List, ListItem, Paragraph, Row, Table, TableState,
+use ratatui::Frame;
-};
 use std::time::{Duration, SystemTime};
+use crate::tui::ratatui_app::RatatuiApp;
+use crate::tui::ratatui_screens::RatatuiScreens::{Deleting, Editing, Exiting};
 
 pub struct RatatuiMonitoringMode {}
 
 impl RatatuiMonitoringMode {
-    fn render_hosts_list(frame: &mut Frame, state: &mut RatatuiApp, area: Rect) {
+    pub fn render(frame: &mut Frame, state: &mut RatatuiApp) {
-        // Headers
+        let layouts = Layout::default()
-        let headers = ["Host", "RTT", "Last Change"]
+            .direction(Direction::Vertical)
+            .constraints([
+                Constraint::Fill(1),
+                Constraint::Length(10),
+                Constraint::Length(3),
+            ])
+            .split(frame.area());
+
+        let body_layout = layouts[0];
+        let logs_layout = layouts[1];
+        let footer_layout = layouts[2];
+        //
+        // let title = Line::from(format!("PP v{}", env!("CARGO_PKG_VERSION")))
+        //     .bold()
+        //     .blue()
+        //     .centered();
+        // let table_size = layouts[0].area();
+        // let columns = Layout::default()
+        //     .direction(Vertical)
+        //     .constraints([Constraint::Min(30),
+        //         Constraint::Min(6),
+        //         Constraint::Min(4),
+        //         Constraint::Min(30)]);
+
+        let headers = ["Host", "Alive", "RTT", "Last Change"]
             .iter()
             .map(|h| Cell::from(*h));
         let header = Row::new(headers)
-            .style(Style::default().fg(Color::Yellow).bold())
+            .style(Style::default().fg(Color::Yellow))
             .bottom_margin(1);
-
-        // Rows
         let mut rows = vec![];
 
         for (_, current) in state.state.iter() {
-            let name_field = format!(
+            let mut name_field = format!("{} ({})", current.name.clone(), current.target.clone());
-                "{:<40}",
+
-                format!("{} ({})", current.name.clone(), current.target.clone())
+            while name_field.len() < 40 {
-            );
+                name_field.push(' ');
+            }
 
             let name_style = if current.alive {
                 Style::default().fg(Color::Green)
@@ -39,39 +59,36 @@ impl RatatuiMonitoringMode {
                 Style::default().fg(Color::Red)
             };
 
-            rows.push(Row::new(vec![
+            let to_push = vec![
                 Cell::from(name_field).style(name_style),
+                Cell::from(current.alive.to_string()),
                 Cell::from(current.last_rtt.to_string()),
-                Cell::from(format!(
+                Cell::from(
-                    "{} ago.",
+                    format!("{} ago.",
                             duration_to_string(
                                 SystemTime::now()
                                     .duration_since(current.last_alive_change)
                                     .unwrap()
                             )
-                )),
+                    )
-            ]));
+                )
+            ];
+
+            rows.push(Row::new(to_push));
         }
 
-        // Table Builder
+        let table = Table::new(rows, vec![Constraint::Min(30), Constraint::Min(6), Constraint::Min(5), Constraint::Min(30)])
-        let table = Table::new(rows, vec![
+            .header(header)
+            .block(Block::default()
+                .title(Line::from(format!("PP v{}", env!("CARGO_PKG_VERSION"))))
+                .borders(Borders::ALL))
+            .widths(&[
                 Constraint::Min(30),
                 Constraint::Min(6),
-            Constraint::Min(5),
+                Constraint::Min(4),
-            Constraint::Min(30),
+                Constraint::Min(30)
             ])
-        .header(header)
+            .highlight_style(
-        .block(
-            Block::default()
-                .title(Line::from(format!("PP v{}", env!("CARGO_PKG_VERSION"))))
-                .borders(Borders::ALL),
-        )
-        .widths(&[
-            Constraint::Fill(2), // Host
-            Constraint::Min(4),  // RTT
-            Constraint::Min(30), // TIme Since
-        ])
-        .row_highlight_style(
                 Style::default()
                     .bg(Color::Blue)
                     .fg(Color::White)
@@ -80,205 +97,67 @@ impl RatatuiMonitoringMode {
             .highlight_symbol(">> ");
 
         // frame.render_widget(table, layouts[0]);
-        frame.render_stateful_widget(table, area, &mut make_hosts_list_state(state.selected_host));
+        frame.render_stateful_widget(table, layouts[0], &mut make_state(state.selected_host));
+
+        // let footer_text = "Press <ESC> or q to exit";
+        let footer_text = format!("Press <ESC> or q to exit | Press d to delete host | Press a to add host - ({:?})", state.filename);
+
+        let mut list_items = vec![];
+        for entry in state.get_log_entries(10) {
+            list_items.push(ListItem::new(entry));
         }
 
-    fn render_logs(frame: &mut Frame, state: &mut RatatuiApp, logs_layout: Rect) {
+        let list = List::new(list_items)
-        let list_items: Vec<ListItem> = state
-            .get_log_entries(10)
-            .iter()
-            .map(|entry| ListItem::new(entry.clone()))
-            .collect();
-
-        // Log
-        frame.render_widget(
-            List::new(list_items)
             .block(Block::default().title("Logs").borders(Borders::ALL))
             .highlight_style(
                 Style::default()
                     .fg(Color::Yellow)
                     .add_modifier(Modifier::BOLD),
-                ),
-            logs_layout,
             );
-    }
+       //     .highlight_symbol(">> ");
+
+        let mut list_state = ListState::default();
+        list_state.select(Some(0));
+
+        frame.render_stateful_widget(list, logs_layout, &mut list_state);
 
-    fn render_footer_block(frame: &mut Frame, footer_layout: Rect) {
         frame.render_widget(
-            Paragraph::new(
+            Paragraph::new(footer_text)
-                "Press <ESC> or q to exit | Press d to delete host | Press a to add host",
-            )
                 .block(Block::bordered())
                 .centered(),
             footer_layout,
         );
     }
-    pub fn render(frame: &mut Frame, state: &mut RatatuiApp) {
-        let layouts = Layout::default()
-            .direction(Direction::Vertical)
-            .constraints([
-                Constraint::Fill(1),    // Top Bar
-                Constraint::Length(10), // Hosts
-                Constraint::Length(3),  // Logs
-            ])
-            .split(frame.area());
-
-        Self::render_hosts_list(frame, state, layouts[0]);
-        Self::render_logs(frame, state, layouts[1]);
-        Self::render_footer_block(frame, layouts[2]);
-
-        Self::add_popup(frame, state);
-        Self::exit_popup(frame, state);
-        Self::delete_popup(frame, state);
-    }
-
-    fn add_popup(frame: &mut Frame, state: &RatatuiApp) {
-        if state.showing_add_popup {
-            let area = RatatuiMonitoringMode::popup_area(frame.area(), 10, 40);
-
-            frame.render_widget(Clear, area);
-
-            frame.render_widget(
-                Paragraph::new(format!("Host Address : {}", state.add_host_name))
-                    .block(Block::bordered().title("Label")),
-                area,
-            );
-        }
-    }
-
-    fn exit_popup(frame: &mut Frame, state: &RatatuiApp) {
-        if state.trying_to_exit {
-            let area = RatatuiMonitoringMode::popup_area(frame.area(), 5, 20);
-
-            frame.render_widget(Clear, area);
-            frame.render_widget(
-                Paragraph::new("Are you sure? (Y/N)").block(Block::bordered().title("Exit")),
-                area,
-            );
-        }
-    }
-
-    fn delete_popup(frame: &mut Frame, state: &RatatuiApp) {
-        if state.trying_to_delete {
-            let as_list = state.state.clone();
-            let mut host_name = String::new();
-            for (index, (label, _)) in as_list.iter().enumerate() {
-                if index == state.selected_host {
-                    host_name = label.clone();
-                }
-            }
-            let block = Paragraph::new(format!("Delete {}", host_name))
-                .centered()
-                .block(Block::bordered());
-
-            frame.render_widget(block, frame.area());
-        }
-    }
-
-    fn popup_area(area: Rect, percent_x: u16, percent_y: u16) -> Rect {
-        let vertical = Layout::vertical([Constraint::Percentage(percent_x)]).flex(Flex::Center);
-        let horizontal = Layout::horizontal([Constraint::Percentage(percent_y)]).flex(Flex::Center);
-        let [area] = vertical.areas(area);
-        let [area] = horizontal.areas(area);
-        area
-    }
-
-    fn handle_add_popup_inputs(app: &mut RatatuiApp, key: KeyCode) {
-        match key {
-            KeyCode::Esc => {
-                app.showing_add_popup = false;
-            }
-            KeyCode::Backspace => {
-                app.add_host_name.remove(app.add_host_name.len() - 1);
-            }
-            KeyCode::Enter => {
-                app.state.insert(app.add_host_name.clone(), TargetState {
-                    name: app.add_host_name.clone(),
-                    ..Default::default()
-                });
-            }
-            KeyCode::Down => {
-                dbg!("Move down to next field");
-            }
-            KeyCode::Up => {
-                dbg!("Move up to previous field");
-            }
-            _ => {
-                app.add_host_name = format!("{}{}", app.add_host_name, key);
-                //dbg!(format!("ADD_HOST_NAME: {}", app.add_host_name.clone()));
-            }
-        }
-    }
-
-    fn handle_exit_popup_inputs(app: &mut RatatuiApp, key: KeyCode) {
-        match key {
-            KeyCode::Char('y') | KeyCode::Char('Y') => {
-                app.set_running(false);
-            }
-            KeyCode::Char('n') | KeyCode::Char('N') => {
-                app.trying_to_exit = false;
-            }
-            _ => {}
-        }
-    }
-
-    fn handle_monitoring_screen_inputs(app: &mut RatatuiApp, key: KeyCode) {
-        // Default monitoring Screen
-        match key {
-            KeyCode::Down => {
-                if app.selected_host + 1 == app.state.len() {
-                    app.selected_host = 0;
-                } else {
-                    app.selected_host += 1;
-                }
-            }
-            KeyCode::Up => {
-                if app.selected_host == 0 {
-                    app.selected_host = app.state.len() - 1;
-                } else {
-                    app.selected_host -= 1;
-                }
-            }
-            KeyCode::Esc | KeyCode::Char('q') | KeyCode::Char('Q') => {
-                app.trying_to_exit = true;
-            }
-            KeyCode::Char('a') | KeyCode::Char('A') => {
-                app.showing_add_popup = true;
-            }
-            KeyCode::Char('d') | KeyCode::Char('D') => {
-                app.trying_to_delete = true;
-            }
-            _ => {}
-        }
-    }
-
-    fn handle_delete_popup_inputs(app: &mut RatatuiApp, key: KeyCode) {
-        match key {
-            KeyCode::Char('y') | KeyCode::Char('Y') => {
-                app.remove_selected_host();
-                app.trying_to_delete = false;
-            }
-            KeyCode::Char('n') | KeyCode::Char('N') => {
-                dbg!("Do not delete this item.");
-                app.trying_to_delete = false;
-            }
-            _ => {}
-        }
-    }
 
     pub fn handle_crossterm_events(app: &mut RatatuiApp) -> Result<()> {
         if event::poll(Duration::from_millis(100))? {
             match event::read()? {
                 Event::Key(key) if key.kind == KeyEventKind::Press => {
-                    // adding mode
+                    match (key.modifiers, key.code) {
-                    if app.showing_add_popup {
+                        (_, KeyCode::Down) => {
-                        Self::handle_add_popup_inputs(app, key.code);
+                            if app.selected_host + 1 == app.state.len() {
-                    } else if app.trying_to_exit {
+                                app.selected_host = 0;
-                        Self::handle_exit_popup_inputs(app, key.code);
-                    } else if app.trying_to_delete {
-                        Self::handle_delete_popup_inputs(app, key.code);
                             } else {
-                        Self::handle_monitoring_screen_inputs(app, key.code);
+                                app.selected_host += 1;
+                            }
+                        }
+                        (_, KeyCode::Up) => {
+                            if app.selected_host == 0 {
+                                app.selected_host = app.state.len() - 1;
+                            } else {
+                                app.selected_host -= 1;
+                            }
+                        }
+                        (_, KeyCode::Esc) | (_, KeyCode::Char('q')) | (_, KeyCode::Char('Q')) => {
+                            app.set_screen(Exiting);
+                        }
+                        (_, KeyCode::Char('e')) | (_, KeyCode::Char('E')) => {
+                            app.set_screen(Editing);
+                        }
+                        (_, KeyCode::Char('d')) | (_, KeyCode::Char('D')) => {
+                            app.set_screen(Deleting);
+                        }
+                        _ => {}
                     }
                 }
                 _ => {}
@@ -288,7 +167,7 @@ impl RatatuiMonitoringMode {
     }
 }
 
-pub fn make_hosts_list_state(selected: usize) -> TableState {
+pub fn make_state(selected: usize) -> TableState {
     let mut state = TableState::default();
     state.select(Some(selected));
     state

src/tui/ratatui_app.rs

@@ -1,14 +1,9 @@
+use crate::tui::ratatui_screens::RatatuiScreens;
 use crate::manager::Manager;
 use crate::ping_result::PingResult;
 use crate::target_state::TargetState;
-use crate::tui::mode_adding::RatatuiAddingMode;
-use crate::tui::mode_deleting::RatatuiDeletingMode;
-use crate::tui::mode_editing::RatatuiEditingMode;
-use crate::tui::mode_monitoring::RatatuiMonitoringMode;
-use crate::tui::ratatui_screens::RatatuiScreens;
 use chrono::{DateTime, Local};
 use color_eyre::Result;
-use log::debug;
 use ratatui::prelude::*;
 use ratatui::{DefaultTerminal, Frame};
 use std::collections::BTreeMap;
@@ -20,8 +15,14 @@ use std::sync::mpsc;
 use std::sync::mpsc::Receiver;
 use std::thread;
 use std::time::{Duration, SystemTime};
+use log::debug;
+use crate::tui::mode_adding::RatatuiAddingMode;
+use crate::tui::mode_deleting::RatatuiDeletingMode;
+use crate::tui::mode_editing::RatatuiEditingMode;
+use crate::tui::mode_exiting::RatatuiExitingMode;
+use crate::tui::mode_monitoring::RatatuiMonitoringMode;
+
 
-const LOG_ENTRIES_DEFAULT_COUNT: u32 = 10;
 
 #[derive(Default)]
 pub struct RatatuiApp {
@@ -29,39 +30,12 @@ pub struct RatatuiApp {
     pub state: BTreeMap<String, TargetState>,
     current_screen: RatatuiScreens,
     log_entries: Vec<String>,
-    filename: Option<String>,
+    pub(crate) filename: Option<String>,
-    pub selected_host: usize,
+    pub selected_host: usize
-    pub showing_add_popup: bool,
-    pub trying_to_exit: bool,
-    pub trying_to_delete: bool,
-    pub add_host_cursor_position: usize,
-    pub add_host_name: String,
-    pub num_log_entries: u32
 }
 
 /// Private Methods
 impl RatatuiApp {
-    pub fn remove_selected_host(self: &mut RatatuiApp) {
-        for (index, (name, data)) in self.state.clone().iter().enumerate() {
-            if index == self.selected_host {
-                self.state.remove(name).unwrap();
-            }
-        }
-    }
-
-    pub fn set_filename(mut self, new_filename: String) {
-        self.filename = Some(new_filename)
-    }
-
-    pub fn get_filename(self) -> String {
-        self.filename.unwrap_or(String::new())
-    }
-
-    pub fn add_new_host(mut self, new_target: TargetState) -> Result<()> {
-        self.state.insert(new_target.name.clone(), new_target);
-        Ok(())
-    }
-
     pub fn run(mut self, mut terminal: DefaultTerminal) -> Result<()> {
         self.running = true;
         // start the 'manager' thread that spawns its ping threads as needed
@@ -71,9 +45,32 @@ impl RatatuiApp {
             // check for any waiting ping results...
             self.consume_waiting_results(&receiver);
 
-            terminal.draw(|frame| RatatuiMonitoringMode::render(frame, &mut self))?;
+            match self.current_screen {
+                RatatuiScreens::Deleting => {
+                    terminal
+                        .draw(|frame| RatatuiDeletingMode::render(frame, &mut self))?;
+                    RatatuiDeletingMode::handle_crossterm_events(&mut self)?
+
+                }
+                RatatuiScreens::Monitoring => {
+                    terminal
+                        .draw(|frame| RatatuiMonitoringMode::render(frame, &mut self))?;
                     RatatuiMonitoringMode::handle_crossterm_events(&mut self)?;
                 }
+                RatatuiScreens::Exiting => {
+                    terminal.draw(|frame| RatatuiExitingMode::render(frame))?;
+                    RatatuiExitingMode::handle_crossterm_events(&mut self)?;
+                }
+                RatatuiScreens::Editing => {
+                    terminal.draw(|frame| RatatuiEditingMode::render(frame, &mut self.state))?;
+                    RatatuiEditingMode::handle_crossterm_events(&mut self)?;
+                }
+                RatatuiScreens::Adding => {
+                    terminal.draw(|frame| RatatuiAddingMode::render(frame, &mut self))?;
+                    RatatuiAddingMode::handle_crossterm_events(&mut self)?
+                }
+            }
+        }
         Ok(())
     }
 
@@ -97,7 +94,6 @@ impl RatatuiApp {
                         alive: new_message.success,
                         last_rtt: new_message.rtt,
                         last_alive_change,
-                        ..TargetState::default()
                     };
                     local_state.insert(name.clone(), new_state.clone());
                     let success_message = if new_state.alive {
@@ -110,7 +106,7 @@ impl RatatuiApp {
 
                     if did_change {
                         self.log_entries.push(format!(
-                            "{} {} for {}",
+                            "{:?} {} for {}",
                             current_time.format("%Y-%m-%d %H:%M:%S: ").to_string(),
                             success_message,
                             new_state.name.clone()
@@ -131,7 +127,13 @@ impl RatatuiApp {
     }
 
     fn render(&mut self, frame: &mut Frame) {
-        RatatuiMonitoringMode::render(frame, self)
+        match self.current_screen {
+            RatatuiScreens::Monitoring => RatatuiMonitoringMode::render(frame, self),
+            RatatuiScreens::Exiting => RatatuiExitingMode::render(frame),
+            RatatuiScreens::Editing => RatatuiEditingMode::render(frame, &mut self.state),
+            RatatuiScreens::Deleting => RatatuiDeletingMode::render(frame,self),
+            RatatuiScreens::Adding => RatatuiAddingMode::render(frame, self)
+        }
     }
 
     fn quit(&mut self) {
@@ -141,36 +143,29 @@ impl RatatuiApp {
     fn get_default_targets() -> BTreeMap<String, TargetState> {
         let mut working = BTreeMap::new();
 
-        working.insert(
+        working.insert("1111 DNS".to_string(), TargetState {
-            "1111 DNS".to_string(),
-            TargetState {
             name: "1111 DNS".to_string(),
             target: Ipv4Addr::new(1, 1, 1, 1),
             ..TargetState::default()
-            },
+        });
-        );
+        working.insert("Google DNS".to_string(), TargetState {
-        working.insert(
-            "Google DNS".to_string(),
-            TargetState {
             name: "Google DNS".to_string(),
             target: Ipv4Addr::new(8, 8, 8, 8),
             ..TargetState::default()
-            },
+        });
-        );
+        working.insert("Test Site 1".to_string(), TargetState {
-        working.insert(
-            "Test Site 1".to_string(),
-            TargetState {
             name: "Test Site 1".to_string(),
             target: Ipv4Addr::new(216, 234, 202, 122),
             ..TargetState::default()
-            },
+        });
-        );
         working
     }
 }
 
+
 /// Public Methods
 impl RatatuiApp {
+
     fn load_hosts_from_file(file_to_load_from: PathBuf) -> BTreeMap<String, TargetState> {
         let mut working = BTreeMap::new();
 
@@ -178,14 +173,13 @@ impl RatatuiApp {
         let mut rdr = csv::Reader::from_reader(the_file.unwrap());
         for result in rdr.records() {
             let record = result.unwrap();
-            working.insert(
+            working.insert(record[1].to_string(), TargetState {
-                record[1].to_string(),
-                TargetState {
                 name: record[1].to_string(),
                 target: Ipv4Addr::from_str(&record[0]).unwrap(),
-                    ..TargetState::default()
+                alive: false,
-                },
+                last_alive_change: SystemTime::now(),
-            );
+                last_rtt: 0
+            });
         }
 
         working
@@ -198,17 +192,17 @@ impl RatatuiApp {
                 working.filename = Some(file.as_os_str().to_string_lossy().parse().unwrap());
             } else {
                 // working.log_event("Passed file doesnt exist looking for hosts.txt".to_string());
-                if PathBuf::from_str("hosts.txt").unwrap().exists() {
+                if !&PathBuf::from_str("hosts.txt").unwrap().exists() {
-                    // working.log_event("Found hosts.txt.  using it as the default".to_string());
-                    working.filename = Some("hosts.txt".to_string());
-                } else {
                     // working.log_event("Didnt find hosts.txt".to_string());
                     working.filename = None;
+                } else {
+                    // working.log_event("Found hosts.txt.  using it as the default".to_string());
+                    working.filename = Some("hosts.txt".to_string());
                 }
             }
 
             if let Some(file) = working.filename.clone() {
-                RatatuiApp::load_hosts_from_file(PathBuf::from_str(file.as_str()).unwrap())
+                RatatuiApp::load_hosts_from_file(PathBuf::from_str(&*working.filename.clone().unwrap()).unwrap())
             } else {
                 RatatuiApp::get_default_targets()
             }
@@ -217,9 +211,7 @@ impl RatatuiApp {
             working.filename = Some("hosts.txt".to_string());
             if let Some(ref hosts_file) = working.filename {
                 if PathBuf::from_str(hosts_file).unwrap().exists() {
-                    RatatuiApp::load_hosts_from_file(
+                    RatatuiApp::load_hosts_from_file(PathBuf::from_str(&*hosts_file.clone()).unwrap())
-                        PathBuf::from_str(&*hosts_file.clone()).unwrap(),
-                    )
                 } else {
                     working.filename = None;
                     RatatuiApp::get_default_targets()
@@ -229,7 +221,6 @@ impl RatatuiApp {
             }
         };
         working.state = targets.clone();
-        working.num_log_entries = LOG_ENTRIES_DEFAULT_COUNT;
         working
     }
 
@@ -249,11 +240,11 @@ impl RatatuiApp {
     }
 
     pub fn get_log_entries(&self, how_many: u32) -> Vec<String> {
-        self.log_entries
+        let mut return_value = vec![];
-            .iter()
+        for current in self.log_entries.clone().into_iter().rev() {
-            .rev()
+            return_value.push(current);
-            .take(how_many as usize)
+        }
-            .cloned()
+        return_value
-            .collect()
+
     }
 }

src/tui/ratatui_screens.rs

@@ -3,6 +3,7 @@
 pub enum RatatuiScreens {
     #[default]
     Monitoring,
+    Exiting,
     Editing,
     Deleting,
     Adding