Adds colour to the text display

optimized main loop
splits code into structs to better structure
tui shows hosts from the app state
single display shows the stats for a passed TargetState
multi display is woefully incomplete

Cargo.lock

@@ -150,9 +150,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "clap"
-version = "4.5.37"
+version = "4.5.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eccb054f56cbd38340b380d4a8e69ef1f02f1af43db2f0cc817a4774d80ae071"
+checksum = "2df961d8c8a0d08aa9945718ccf584145eee3f3aa06cddbeac12933781102e04"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -160,9 +160,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.37"
+version = "4.5.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "efd9466fac8543255d3b1fcad4762c5e116ffe808c8a3043d4263cd4fd4862a2"
+checksum = "132dbda40fb6753878316a489d5a1242a8ef2f0d9e47ba01c951ea8aa7d013a5"
 dependencies = [
  "anstream",
  "anstyle",
@@ -460,9 +460,9 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "jiff"
-version = "0.2.10"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a064218214dc6a10fbae5ec5fa888d80c45d611aba169222fc272072bf7aef6"
+checksum = "1f33145a5cbea837164362c7bd596106eb7c5198f97d1ba6f6ebb3223952e488"
 dependencies = [
  "jiff-static",
  "log",
@@ -473,9 +473,9 @@ dependencies = [
 
 [[package]]
 name = "jiff-static"
-version = "0.2.10"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "199b7932d97e325aff3a7030e141eafe7f2c6268e1d1b24859b753a627f45254"
+checksum = "43ce13c40ec6956157a3635d97a1ee2df323b263f09ea14165131289cb0f5c19"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -639,9 +639,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.95"
+version = "1.0.94"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84"
 dependencies = [
  "unicode-ident",
 ]

Cargo.toml

@@ -15,5 +15,8 @@ color-eyre = "0.6.3"
 crossterm = "0.28.1"
 ratatui = "0.29.0"
 
+[[bin]]
+name = "duration_to_string"
+
 [[bin]]
 name = "pp"

belleville.txt

@@ -1,4 +1,3 @@
-address,name
 10.3.100.1,Belleville Router
 10.11.31.3,Belleville VPN 11-31
 10.12.32.1,Belleville VPN 12-32

lindsay.txt

@@ -1,4 +1,3 @@
-address,name
 10.3.100.1,Belleville Router
 10.11.31.3,Belleville VPN 11-31
 10.12.32.1,Belleville VPN 12-32

peterborough.txt

@@ -1,15 +1,14 @@
-10.3.100.1,Belleville Gateway
+10.3.100.1,Belleville Router
 10.11.31.3,Belleville VPN 11-31
 10.12.32.1,Belleville VPN 12-32
-192.186.110.6,Belleville Cogeco
-129.222.197.36,Belleville Starlink
-10.2.100.1,Lindsay Gateway
-24.143.184.98,Lindsay Cogeco
-192.168.1.50,Lindsay Sign
 10.11.21.1,Lindsay VPN 11-21
 10.12.22.1,Lindsay VPN 11-22
 8.8.8.8,Google DNS
 1.1.1.1,1111 DNS
-192.168.0.1,Peterborough Gateway
 24.51.235.162,Peterborough Cogeco
 99.214.0.92,Peterborough Rogers
+216.234.202.122,Lindsay Starlink
+24.143.184.98,Lindsay Cogeco
+192.186.110.6,Belleville Cogeco
+129.222.197.36,Belleville Starlink
+192.168.0.50,Sign

src/bin/duration_to_string.rs

@@ -0,0 +1,41 @@
+use std::time::Duration;
+
+pub fn duration_to_string(to_convert: Duration) -> String {
+    let mut total_seconds = to_convert.as_secs();
+    let mut working_string = String::new();
+
+    if total_seconds > 86400 {
+        // days
+        let num_days = total_seconds / 86400;
+        working_string = format!("{} days", num_days);
+        total_seconds = total_seconds - (num_days * 86400);
+    }
+
+    if total_seconds > 3600 {
+        // hours
+        let num_hours = total_seconds / 3600;
+        if num_hours > 0 {
+            working_string = format!("{} {} hours", working_string, num_hours);
+            total_seconds = total_seconds - (num_hours * 3600);
+        }
+    }
+    if total_seconds > 60 {
+        let num_minutes = total_seconds / 60;
+        if num_minutes > 0 {
+            working_string = format!("{} {} minutes", working_string, num_minutes);
+            total_seconds = total_seconds - (num_minutes * 60);
+        }
+        // minutes
+    }
+
+
+    working_string = format!("{} {} seconds.", working_string, total_seconds);
+
+    working_string
+}
+fn main() {
+    println!("1m 12s => {}", duration_to_string(Duration::from_secs(72)));
+    println!("1h 1m 12s => {}", duration_to_string(Duration::from_secs(3672)));
+    println!("1d 1h 1m 12s => {}", duration_to_string(Duration::from_secs(90072)));
+    println!("30d 1h 1m 12s => {}", duration_to_string(Duration::from_secs(2595672)));
+}

src/bin/pp.rs

@@ -17,228 +17,67 @@ use std::{env, error::Error, ffi::OsString, process};
 use color_eyre::owo_colors::OwoColorize;
 use crossterm::style::Stylize;
 use log::debug;
-const SECONDS_IN_MINUTE: u32 = 60;
+use pp::ppstate::PPState;
-const SECONDS_IN_HOUR: u32 = SECONDS_IN_MINUTE * 60;
-const SECONDS_IN_DAY: u32 = SECONDS_IN_HOUR * 24;
 
-pub fn duration_to_string(to_convert: Duration) -> String {
+/// Simple program to greet a person
-    let mut total_seconds = to_convert.as_secs() as u32;
+#[derive(Parser, Debug)]
-    let mut working_string = String::new();
+#[command(version, about, long_about = None)]
-
+pub struct AppSettings {
-    if total_seconds > 86400 {
+    /// File of list of hosts
-        // days
+    #[arg(short, long)]
-        let num_days = (total_seconds / SECONDS_IN_DAY) as u32;
+    ping_host_file: Option<PathBuf>,
-        working_string = format!("{} days", num_days);
-        total_seconds = total_seconds - (num_days * SECONDS_IN_DAY);
-    }
-
-    if total_seconds > 3600 {
-        // hours
-        let num_hours = (total_seconds / SECONDS_IN_HOUR) as u32;
-        if num_hours > 0 {
-            working_string = format!("{} {} hours", working_string, num_hours);
-            total_seconds = total_seconds - (num_hours * SECONDS_IN_HOUR);
-        }
-    }
-    if total_seconds > 60 {
-        let num_minutes = (total_seconds / SECONDS_IN_MINUTE) as u32;
-        if num_minutes > 0 {
-            working_string = format!("{} {} minutes", working_string, num_minutes);
-            total_seconds = total_seconds - (num_minutes * SECONDS_IN_MINUTE);
-        }
-        // minutes
-    }
-
-
-    working_string = format!("{} {} seconds", working_string, total_seconds);
-
-    working_string
 }
 
+fn main() {
+    // Get App Settings
+    let settings = AppSettings::parse();
 
-struct PPState {}
+    print!("Creating new State...");
+    let mut state = PPState::new_from_file(settings.ping_host_file.unwrap_or(PathBuf::from("INVALID FILE")));
 
-impl PPState {
+    // channel to send requests to ping
-    pub fn get_default_targets() -> BTreeMap<String, TargetState> {
+    let (ping_response_sender, ping_response_listener) = mpsc::channel::<PingResult>();
-        let mut working = BTreeMap::new();
-        working.insert("Localhost".to_string(),
-                       TargetState {
-                           name: "Localhost".to_string(),
-                           target: Ipv4Addr::new(127, 0, 0, 1),
-                           ..TargetState::default()
-                       },
-        );
 
-        working.insert("Home Gateway".to_string(),
+    println!("Setting up requests for {} hosts.", state.ips_from_state().len());
-                       TargetState {
+    Manager::spawn_manager_thread(PPState::targets_states_from_state(&state), ping_response_sender.clone());
-                           name: "Home Gateway".to_string(),
-                           target: Ipv4Addr::new(172, 24, 0, 1),
-                           ..TargetState::default()
-                       },
-        );
 
-        working.insert("1111 DNS".to_string(),
+    let mut display_loop_start = SystemTime::now();
-                       TargetState {
+    let mut duration_since_last_loop = SystemTime::now().duration_since(display_loop_start).unwrap();
-                           name: "1111 DNS".to_string(),
+    loop {
-                           target: Ipv4Addr::new(1, 1, 1, 1),
+        state.check_for_ping(&ping_response_listener);
-                           ..TargetState::default()
-                       },
-        );
-        working.insert("Google DNS".to_string(),
-                       TargetState {
-                           name: "Google DNS".to_string(),
-                           target: Ipv4Addr::new(8, 8, 8, 8),
-                           ..TargetState::default()
-                       },
-        );
 
-        working.insert("Site IP 1".to_string(),
+        let now = SystemTime::now();
-                       TargetState {
-                           name: "Site IP 1".to_string(),
-                           target: Ipv4Addr::new(216, 121, 247, 231),
-                           ..TargetState::default()
-                       },
-        );
-        working.insert("Site IP 2".to_string(),
-                       TargetState {
-                           name: "Site IP 2".to_string(),
-                           target: Ipv4Addr::new(216, 234, 202, 122),
-                           ..TargetState::default()
-                       },
-        );
-        working.insert("Site IP 3".to_string(),
-                       TargetState {
-                           name: "Site IP 3".to_string(),
-                           target: Ipv4Addr::new(24, 143, 184, 98),
-                           ..TargetState::default()
-                       },
-        );
-        working
-    }
 
-    pub fn build_targets_from_file(filename: Option<PathBuf>) -> BTreeMap<String, TargetState> {
+
-        PPState::get_default_targets();
+        duration_since_last_loop = now
-        if let Some(file) = filename {
+            .duration_since(display_loop_start)
-            let mut working = BTreeMap::new();
+            .expect("unable to figure out how long ago we displayed stuff");
-            if !&file.exists() {
+        if duration_since_last_loop.as_secs() > SECONDS_BETWEEN_DISPLAY as u64 {
-                debug!("Cant load hosts from {:?}.  Using default host list.", file.clone().as_os_str());
+            println!("DISPLAY LOOP");
-                // use
+            println!("Host \t\t\t\t\t | Alive \t | RTT \t\t");
-                PPState::get_default_targets()
+            for current_result in state.targets_states_from_state() {
-            } else {
+                let time_since_last_change = now
-                debug!("LOADING HOSTS FROM  {:?}", file.to_str());
+                    .duration_since(current_result.last_alive_change)
-                let file = File::open(file);
+                    .unwrap_or(Duration::from_secs(0));
-                let mut rdr = csv::Reader::from_reader(file.unwrap());
+                let mut target_string = format!("{} ({})", current_result.name, current_result.target);
-                for result in rdr.records() {
+                while target_string.len() < 34 {
-                    let record = result.unwrap();
+                    target_string.push(' ');
-                    working.insert(record[1].to_string(),
+                    // target_string = format!("{} ", target_string);
-                                   TargetState {
-                                       name: record[1].to_string(),
-                                       target: Ipv4Addr::from_str(&record[0]).unwrap(),
-                                       alive: false,
-                                       last_alive_change: SystemTime::now(),
-                                       last_rtt: 0,
-                                   });
                 }
-                working
+
+                target_string = if current_result.alive {
+                    target_string.green().to_string()
+                } else {
+                    target_string.red().to_string()
+                };
+
+                println!("{} \t | {} \t | {}\t | Changed {}s ago",
+                         target_string,
+                         current_result.alive,
+                         current_result.last_rtt, time_since_last_change.as_secs()
+                );
             }
-        } else {
+            display_loop_start = now;
-            PPState::get_default_targets()
         }
     }
 }
-    fn ips_from_state(to_read_from: BTreeMap<String, TargetState>) -> Vec<Ipv4Addr> {
-        let mut working: Vec<Ipv4Addr> = vec![];
-        for current in to_read_from {
-            working.push(current.1.target);
-        }
-        working
-    }
-
-    /// Simple program to greet a person
-    #[derive(Parser, Debug)]
-    #[command(version, about, long_about = None)]
-    pub struct AppSettings {
-        /// File of list of hosts
-        #[arg(short, long)]
-        ping_host_file: Option<PathBuf>,
-    }
-
-    fn main() {
-        // Get App Settings
-        let settings = AppSettings::parse();
-
-        print!("Prep to load targets...");
-        let file_to_check = match settings.ping_host_file {
-            None => {
-                PathBuf::from("./hosts.txt")
-            }
-            Some(actual) => {
-                actual
-            }
-        };
-        let mut targets = PPState::build_targets_from_file(Some(file_to_check));
-
-        // channel to send requests to ping
-        let (ping_response_sender, ping_response_listener) = mpsc::channel::<PingResult>();
-
-        println!("Setting up requests for {} hosts.", targets.len());
-        Manager::spawn_manager_thread(ips_from_state(targets.clone()), ping_response_sender.clone());
-
-        let mut display_loop_start = SystemTime::now();
-        let mut duration_since_last_loop = SystemTime::now().duration_since(display_loop_start).unwrap();
-        loop {
-            let now = SystemTime::now();
-            if let Ok(response) = ping_response_listener.recv_timeout(Duration::from_millis(100)) {
-                let local_targets = targets.clone();
-                for (_, (name, current_state)) in local_targets.iter().enumerate() {
-                    if current_state.target == response.target {
-                        let last_alive_change = if response.success == current_state.alive {
-                            current_state.last_alive_change
-                        } else {
-                            SystemTime::now()
-                        };
-
-                        let new_state = TargetState {
-                            name: current_state.name.clone(),
-                            target: current_state.target,
-                            alive: response.success,
-                            last_rtt: response.rtt,
-                            last_alive_change,
-                        };
-                        targets.insert(name.clone(), new_state);
-                    }
-                }
-            }
-            duration_since_last_loop = now
-                .duration_since(display_loop_start)
-                .expect("unable to figure out how long ago we displayed stuff");
-            if duration_since_last_loop.as_secs() > SECONDS_BETWEEN_DISPLAY as u64 {
-                println!("DISPLAY LOOP");
-                println!("Host \t\t\t\t\t | Alive \t | RTT \t\t");
-                for (name, current_result) in targets.clone() {
-                    let time_since_last_change = now
-                        .duration_since(current_result.last_alive_change)
-                        .unwrap_or(Duration::from_secs(0));
-                    let mut target_string = format!("{} ({})", name, current_result.target);
-                    while target_string.len() < 34 {
-                        target_string.push(' ');
-                        // target_string = format!("{} ", target_string);
-                    }
-
-                    target_string = if current_result.alive {
-                        target_string.green().to_string()
-                    } else {
-                        target_string.red().to_string()
-                    };
-
-                    println!("{} \t | {} \t | {}\t | Changed {} ago",
-                             target_string,
-                             current_result.alive,
-                             current_result.last_rtt,
-                             duration_to_string(time_since_last_change)
-                    );
-                }
-                display_loop_start = now;
-            }
-        }
-    }

src/bin/rat.rs

@@ -0,0 +1,139 @@
+use pp::tui::target_display::TargetDisplay;
+use std::net::Ipv4Addr;
+use std::sync::mpsc;
+use std::sync::mpsc::Receiver;
+use std::sync::mpsc::Sender;
+use std::time::Duration;
+
+use color_eyre::Result;
+use crossterm::event;
+use crossterm::event::{Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers};
+use pp::ping_result::PingResult;
+use pp::target_state::TargetState;
+use ratatui::style::Stylize;
+use ratatui::text::Line;
+use ratatui::widgets::Paragraph;
+use ratatui::{DefaultTerminal, Frame};
+use std::collections::BTreeMap;
+use std::time::SystemTime;
+
+#[derive(Default)]
+pub struct App {
+    running: bool,
+    counter: u32,
+    known_hosts: Vec<Ipv4Addr>,
+    targets: BTreeMap<String, TargetState>,
+    result_tx: Option<Sender<PingResult>>,
+    result_rx: Option<Receiver<PingResult>>,
+    log_events: Vec<String>,
+}
+
+impl App {
+    pub fn new() -> Self {
+        let mut working = Self::default();
+        working.known_hosts.push(Ipv4Addr::new(127, 0, 0, 1));
+        working.known_hosts.push(Ipv4Addr::new(8, 8, 8, 8));
+        working.known_hosts.push(Ipv4Addr::new(1, 1, 1, 1));
+
+        working
+            .targets
+            .insert("Test Host 1".to_string(), TargetState {
+                name: "Test Host 1".to_string(),
+                target: Ipv4Addr::new(127, 0, 0, 1),
+                ..Default::default()
+            });
+
+        working
+            .targets
+            .insert("Test Host 2".to_string(), TargetState {
+                target: Ipv4Addr::new(1, 1, 1, 1),
+                name: "Test Host 2".to_string(),
+                ..Default::default()
+            });
+
+        let (sender, receiver) = mpsc::channel::<PingResult>();
+        working.result_tx = Some(sender);
+        working.result_rx = Some(receiver);
+        working
+    }
+
+    pub fn run(mut self, mut terminal: DefaultTerminal) -> Result<()> {
+        self.running = true;
+        while self.running {
+            // check if we have any waiting ping responses
+            if let Ok(response) = self
+                .result_rx
+                .as_mut()
+                .unwrap()
+                .recv_timeout(Duration::from_millis(50))
+            {
+                let local_targets = self.targets.clone();
+                for (name, current_state) in local_targets {
+                    if current_state.target == response.target {
+                        let last_alive_change = if response.success == current_state.alive {
+                            current_state.last_alive_change
+                        } else {
+                            SystemTime::now()
+                        };
+
+                        let new_state = TargetState {
+                            name: name.clone(),
+                            target: current_state.target,
+                            alive: response.success,
+                            last_rtt: response.rtt,
+                            last_alive_change,
+                        };
+                        self.targets.insert(name.clone(), new_state);
+                        //self.set_target_state(current_state.name.clone(), new_state);
+                    }
+                }
+            }
+            terminal.draw(|frame| self.render(frame))?;
+            self.handle_crossterm_events()?;
+        }
+        Ok(())
+    }
+
+    fn render(&mut self, frame: &mut Frame) {
+        let title = Line::from("PP Status").bold().centered().blue();
+
+        let mut body_string = String::new();
+        for (name, target) in &self.targets {
+            frame.render_widget(TargetDisplay::new(target.clone()), frame.area());
+            body_string = format!("{}\n{} = {}", body_string, target.name, target.target);
+        }
+
+        frame.render_widget(Paragraph::new(body_string), frame.area());
+    }
+
+    fn handle_crossterm_events(&mut self) -> Result<()> {
+        match event::read()? {
+            Event::Key(key) if key.kind == KeyEventKind::Press => self.on_key_event(key),
+            Event::Mouse(_) => {}
+            Event::Resize(_, _) => {}
+            _ => {}
+        }
+        Ok(())
+    }
+
+    fn on_key_event(&mut self, key: KeyEvent) {
+        match (key.modifiers, key.code) {
+            (_, KeyCode::Esc | KeyCode::Char('q'))
+            | (KeyModifiers::CONTROL, KeyCode::Char('c') | KeyCode::Char('C')) => self.quit(),
+            _ => {}
+        }
+    }
+
+    fn quit(&mut self) {
+        self.running = false;
+    }
+}
+
+fn main() -> Result<()> {
+    color_eyre::install()?;
+    let terminal = ratatui::init();
+    let result = App::new().run(terminal);
+    ratatui::restore();
+    println!("Exited.");
+    result
+}

src/lib.rs

@@ -1,8 +1,9 @@
 pub mod manager;
 pub mod ping_request;
 pub mod ping_result;
+pub mod ppstate;
 pub mod target_state;
-mod tui;
+pub mod tui;
 
 pub const SECONDS_BETWEEN_DISPLAY: u32 = 1;
 pub const SECONDS_BETWEEN_PING: u32 = 2;

src/manager.rs

@@ -1,11 +1,12 @@
+use crate::SECONDS_BETWEEN_PING;
+use crate::ping_request::PingRequest;
+use crate::ping_result::PingResult;
+use crate::target_state::TargetState;
 use std::net::Ipv4Addr;
 use std::process::Command;
 use std::sync::mpsc::Sender;
 use std::thread;
 use std::time::{Duration, SystemTime};
-use crate::ping_request::PingRequest;
-use crate::ping_result::PingResult;
-use crate::SECONDS_BETWEEN_PING;
 
 pub struct Manager;
 
@@ -13,12 +14,17 @@ const WIN_PING_SUCCESS: i32 = 1;
 const LIN_PING_SUCCESS: i32 = 0;
 
 impl Manager {
-    pub fn spawn_manager_thread(targets: Vec<Ipv4Addr>, sender: Sender<PingResult>) {
+    pub fn spawn_manager_thread(targets: Vec<TargetState>, sender: Sender<PingResult>) {
         let local_targets = targets.clone();
         thread::spawn(move || {
             loop {
                 for target in &local_targets {
-                    Manager::spawn_single_ping(PingRequest { target: *target }, sender.clone());
+                    Manager::spawn_single_ping(
+                        PingRequest {
+                            target: target.target,
+                        },
+                        sender.clone(),
+                    );
                 }
                 thread::sleep(Duration::from_secs(SECONDS_BETWEEN_PING as u64));
             }
@@ -26,40 +32,53 @@ impl Manager {
     }
 
     // Spawns a thread that pings a target and sends the response back to the main thread
-// via the sender
+    // via the sender
     fn spawn_single_ping(request: PingRequest, sender: Sender<PingResult>) {
         let local_request = request.clone();
         thread::spawn(move || {
-
             let mut result = 0;
             let mut success = true;
             let start_time = SystemTime::now();
-            #[cfg(any(target_os="windows"))] {
+            #[cfg(any(target_os = "windows"))]
-                result = Command::new("c:/windows/system32/ping.exe").arg(request.target.to_string())
+            {
+                result = Command::new("c:/windows/system32/ping.exe")
+                    .arg(request.target.to_string())
                     .arg("-n 1")
                     .arg(format!("-w {}", crate::SECONDS_BETWEEN_PING))
                     .arg("-4")
-                    .output().unwrap().status.code().unwrap_or(255);
+                    .output()
-                success = result == WIN_PING_SUCCESS as i32;;
+                    .unwrap()
+                    .status
+                    .code()
+                    .unwrap_or(255);
+                success = result == WIN_PING_SUCCESS as i32;
             }
-            #[cfg(any(target_os="linux"))] {
+            #[cfg(any(target_os = "linux"))]
-                result = Command::new("/usr/bin/ping").arg(request.target.to_string())
+            {
+                result = Command::new("/usr/bin/ping")
+                    .arg(request.target.to_string())
                     .arg("-c 1")
                     .arg("-4")
                     .arg(format!("-w {}", SECONDS_BETWEEN_PING))
                     .arg("-W 1")
-                    .output().unwrap().status.code().unwrap_or(255);
+                    .output()
+                    .unwrap()
+                    .status
+                    .code()
+                    .unwrap_or(255);
                 success = result == LIN_PING_SUCCESS as i32;
             }
             let ping_duration = SystemTime::now()
                 .duration_since(start_time)
                 .unwrap_or(Duration::from_secs(600));
             let success = ping_duration.as_millis() >= SECONDS_BETWEEN_PING as u128 && success;
-            sender.send(PingResult {
+            sender
-                target: local_request.target,
+                .send(PingResult {
-                success,
+                    target: local_request.target,
-                rtt: ping_duration.as_millis() as u32
+                    success,
-            }).expect("Unable to send response");
+                    rtt: ping_duration.as_millis() as u32,
+                })
+                .expect("Unable to send response");
 
             // println!("Attempt for for {}", local_request.target);
         });

src/ppstate.rs

@@ -0,0 +1,145 @@
+use crate::ping_result::PingResult;
+use crate::target_state::TargetState;
+use log::debug;
+use std::collections::BTreeMap;
+use std::fs::File;
+use std::net::Ipv4Addr;
+use std::path::PathBuf;
+use std::str::FromStr;
+use std::sync::mpsc::Receiver;
+use std::time::{Duration, SystemTime};
+
+#[derive(Default)]
+pub struct PPState {
+    targets: BTreeMap<String, TargetState>,
+}
+
+impl PPState {
+    pub fn check_for_ping(&mut self, channel: &Receiver<PingResult>) {
+        if let Ok(response) = channel.recv_timeout(Duration::from_millis(100)) {
+            let local_targets = self.targets_states_from_state().clone();
+            for current_state in local_targets {
+                if current_state.target == response.target {
+                    let last_alive_change = if response.success == current_state.alive {
+                        current_state.last_alive_change
+                    } else {
+                        SystemTime::now()
+                    };
+
+                    let new_state = TargetState {
+                        name: current_state.name.clone(),
+                        target: current_state.target,
+                        alive: response.success,
+                        last_rtt: response.rtt,
+                        last_alive_change,
+                    };
+                    self.set_target_state(current_state.name.clone(), new_state);
+                }
+            }
+        }
+    }
+
+    pub fn new_from_file(file_to_load_from: PathBuf) -> Self {
+        let mut working = Self::new();
+        working.targets = PPState::build_targets_from_file(Some(file_to_load_from));
+        working
+    }
+    pub fn new() -> Self {
+        Self::default()
+    }
+    pub fn get_default_targets() -> BTreeMap<String, TargetState> {
+        let mut working = BTreeMap::new();
+        working.insert("Localhost".to_string(), TargetState {
+            name: "Localhost".to_string(),
+            target: Ipv4Addr::new(127, 0, 0, 1),
+            ..TargetState::default()
+        });
+
+        working.insert("Home Gateway".to_string(), TargetState {
+            name: "Home Gateway".to_string(),
+            target: Ipv4Addr::new(172, 24, 0, 1),
+            ..TargetState::default()
+        });
+
+        working.insert("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 {
+            name: "Google DNS".to_string(),
+            target: Ipv4Addr::new(8, 8, 8, 8),
+            ..TargetState::default()
+        });
+
+        working.insert("Site IP 1".to_string(), TargetState {
+            name: "Site IP 1".to_string(),
+            target: Ipv4Addr::new(216, 121, 247, 231),
+            ..TargetState::default()
+        });
+        working.insert("Site IP 2".to_string(), TargetState {
+            name: "Site IP 2".to_string(),
+            target: Ipv4Addr::new(216, 234, 202, 122),
+            ..TargetState::default()
+        });
+        working.insert("Site IP 3".to_string(), TargetState {
+            name: "Site IP 3".to_string(),
+            target: Ipv4Addr::new(24, 143, 184, 98),
+            ..TargetState::default()
+        });
+        working
+    }
+
+    pub fn build_targets_from_file(filename: Option<PathBuf>) -> BTreeMap<String, TargetState> {
+        PPState::get_default_targets();
+        if let Some(file) = filename {
+            let mut working = BTreeMap::new();
+            if !&file.exists() {
+                debug!(
+                    "Cant load hosts from {:?}.  Using default host list.",
+                    file.clone().as_os_str()
+                );
+                // use
+                PPState::get_default_targets()
+            } else {
+                debug!("LOADING HOSTS FROM  {:?}", file.to_str());
+                let file = File::open(file);
+                let mut rdr = csv::Reader::from_reader(file.unwrap());
+                for result in rdr.records() {
+                    let record = result.unwrap();
+                    working.insert(record[1].to_string(), TargetState {
+                        name: record[1].to_string(),
+                        target: Ipv4Addr::from_str(&record[0]).unwrap(),
+                        alive: false,
+                        last_alive_change: SystemTime::now(),
+                        last_rtt: 0,
+                    });
+                }
+                working
+            }
+        } else {
+            PPState::get_default_targets()
+        }
+    }
+
+    pub fn ips_from_state(&self) -> Vec<Ipv4Addr> {
+        let mut working: Vec<Ipv4Addr> = vec![];
+        for (name, current) in &self.targets {
+            working.push(current.target);
+        }
+        working
+    }
+
+    pub fn targets_states_from_state(&self) -> Vec<TargetState> {
+        let mut working: Vec<TargetState> = vec![];
+        for (_, target) in &self.targets {
+            working.push(target.clone());
+        }
+
+        working
+    }
+
+    pub fn set_target_state(&mut self, key: String, value: TargetState) {
+        self.targets.insert(key, value);
+    }
+}

src/tui/mod.rs

@@ -0,0 +1,2 @@
+pub mod target_display;
+mod multi_target_display;

src/tui/multi_target_display.rs

@@ -0,0 +1,15 @@
+use ratatui::buffer::{Buffer, Cell};
+use ratatui::layout::Rect;
+use ratatui::text::Line;
+use ratatui::widgets::{Widget};
+
+pub struct MultiTargetDisplay {
+
+}
+
+impl Widget for MultiTargetDisplay {
+    fn render(self, area: Rect, buf: &mut Buffer)
+    {
+        buf.content.push(Cell::from("Widgets go here"));
+    }
+}

src/tui/target_display.rs

@@ -0,0 +1,29 @@
+use crate::target_state::TargetState;
+use ratatui::prelude::Buffer;
+use ratatui::prelude::Rect;
+use ratatui::style::Style;
+use ratatui::widgets::Widget;
+
+#[derive(Default)]
+pub struct TargetDisplay {
+    target: TargetState,
+}
+
+impl TargetDisplay {
+    pub fn new(state: TargetState) -> Self {
+        let mut working = TargetDisplay::default();
+        working.target = state;
+        working
+    }
+}
+
+impl Widget for TargetDisplay {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        let row = format!(
+            "{} -> {} / {} / {}",
+            self.target.name, self.target.target, self.target.alive, self.target.last_rtt
+        );
+
+        buf.set_string(area.x, area.y, row, Style::default());
+    }
+}