permission issues. putting on hold.

compiles but doesnt actually ping the targets.  all come back as failure.

Cargo.toml

@@ -10,8 +10,13 @@ ansi_term = "0.12"
 clap = { version = "4.5", features = ["derive"] }
 csv = "1.3"
 
-[[bin]]
+# Ratatui
-name = "duration_to_string"
+color-eyre = "0.6.3"
+crossterm = "0.28.1"
+ratatui = "0.29.0"
+
+# Internal Ping
+ping-rs = "0.1"
 
 [[bin]]
 name = "pp"

belleville.txt

@@ -1,3 +1,4 @@
+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,3 +1,4 @@
+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,14 +1,15 @@
-10.3.100.1,Belleville Router
+10.3.100.1,Belleville Gateway
 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

@@ -1,41 +0,0 @@
-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

@@ -14,168 +14,231 @@ use pp::manager::Manager;
 use pp::SECONDS_BETWEEN_DISPLAY;
 use pp::target_state::TargetState;
 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;
+const SECONDS_IN_HOUR: u32 = SECONDS_IN_MINUTE * 60;
+const SECONDS_IN_DAY: u32 = SECONDS_IN_HOUR * 24;
 
-fn get_default_targets() -> BTreeMap<String, TargetState> {
+pub fn duration_to_string(to_convert: Duration) -> String {
-    let mut working = BTreeMap::new();
+    let mut total_seconds = to_convert.as_secs() as u32;
-    working.insert("Localhost".to_string(),
+    let mut working_string = String::new();
-                   TargetState {
-                       name: "Localhost".to_string(),
-                       target: Ipv4Addr::new(127, 0, 0, 1),
-                       ..TargetState::default()
-                   },
-    );
 
-    working.insert("Home Gateway".to_string(),
+    if total_seconds > 86400 {
-                   TargetState {
+        // days
-                       name: "Home Gateway".to_string(),
+        let num_days = (total_seconds / SECONDS_IN_DAY) as u32;
-                       target: Ipv4Addr::new(172, 24, 0, 1),
+        working_string = format!("{} days", num_days);
-                       ..TargetState::default()
+        total_seconds = total_seconds - (num_days * SECONDS_IN_DAY);
-                   },
+    }
-    );
 
-    working.insert("1111 DNS".to_string(),
+    if total_seconds > 3600 {
-                   TargetState {
+        // hours
-                       name: "1111 DNS".to_string(),
+        let num_hours = (total_seconds / SECONDS_IN_HOUR) as u32;
-                       target: Ipv4Addr::new(1, 1, 1, 1),
+        if num_hours > 0 {
-                       ..TargetState::default()
+            working_string = format!("{} {} hours", working_string, num_hours);
-                   },
+            total_seconds = total_seconds - (num_hours * SECONDS_IN_HOUR);
-    );
+        }
-    working.insert("Google DNS".to_string(),
+    }
-                   TargetState {
+    if total_seconds > 60 {
-                       name: "Google DNS".to_string(),
+        let num_minutes = (total_seconds / SECONDS_IN_MINUTE) as u32;
-                       target: Ipv4Addr::new(8, 8, 8, 8),
+        if num_minutes > 0 {
-                       ..TargetState::default()
+            working_string = format!("{} {} minutes", working_string, num_minutes);
-                   },
+            total_seconds = total_seconds - (num_minutes * SECONDS_IN_MINUTE);
-    );
+        }
+        // minutes
+    }
 
-    working.insert("Site IP 1".to_string(),
+
-                   TargetState {
+    working_string = format!("{} {} seconds", working_string, total_seconds);
-                       name: "Site IP 1".to_string(),
+
-                       target: Ipv4Addr::new(216, 121, 247, 231),
+    working_string
-                       ..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
 }
 
-fn build_targets_from_file(filename: Option<PathBuf>) -> BTreeMap<String, TargetState> {
-    let mut hosts: BTreeMap<String, TargetState> = get_default_targets();
 
-    if let Some(file) = filename {
+struct PPState {}
-        hosts = if !&file.exists() {
+
-            println!("Cant load hosts from {:?}.  Using default host list.", file.clone().as_os_str());
+impl PPState {
-            // use
+    pub fn get_default_targets() -> BTreeMap<String, TargetState> {
-            get_default_targets()
+        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 {
-            println!("LOADING HOSTS FROM  {:?}", file.to_str());
+            PPState::get_default_targets()
-            let file = File::open(file);
-            let mut rdr = csv::Reader::from_reader(file.unwrap());
-            for result in rdr.records() {
-                let record = result.unwrap();
-                hosts.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,
-                             });
-            }
-            hosts
         }
     }
-
-    hosts
 }
-
+    fn ips_from_state(to_read_from: BTreeMap<String, TargetState>) -> Vec<Ipv4Addr> {
-fn ips_from_state(to_read_from: BTreeMap<String, TargetState>) -> Vec<Ipv4Addr> {
+        let mut working: Vec<Ipv4Addr> = vec![];
-    let mut working: Vec<Ipv4Addr> = vec![];
+        for current in to_read_from {
-    for current in to_read_from {
+            working.push(current.1.target);
-        working.push(current.1.target);
+        }
+        working
     }
-    working
-}
 
-/// Simple program to greet a person
+    /// Simple program to greet a person
-#[derive(Parser, Debug)]
+    #[derive(Parser, Debug)]
-#[command(version, about, long_about = None)]
+    #[command(version, about, long_about = None)]
-pub struct AppSettings {
+    pub struct AppSettings {
-    /// File of list of hosts
+        /// File of list of hosts
-    #[arg(short, long)]
+        #[arg(short, long)]
-    ping_host_file: Option<PathBuf>,
+        ping_host_file: Option<PathBuf>,
-}
+    }
 
-fn main() {
+    fn main() {
-    // Get App Settings
+        // Get App Settings
-    let settings = AppSettings::parse();
+        let settings = AppSettings::parse();
 
-    print!("Prep to load targets...");
+        print!("Prep to load targets...");
-    let mut targets = build_targets_from_file(settings.ping_host_file);
+        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
+        // channel to send requests to ping
-    let (ping_response_sender, ping_response_listener) = mpsc::channel::<PingResult>();
+        let (ping_response_sender, ping_response_listener) = mpsc::channel::<PingResult>();
 
-    println!("Setting up requests for {} hosts.", targets.len());
+        println!("Setting up requests for {} hosts.", targets.len());
-    Manager::spawn_manager_thread(ips_from_state(targets.clone()), ping_response_sender.clone());
+        Manager::spawn_manager_thread(ips_from_state(targets.clone()), ping_response_sender.clone());
 
-    let mut display_loop_start = SystemTime::now();
+        let mut display_loop_start = SystemTime::now();
-    let mut duration_since_last_loop = SystemTime::now().duration_since(display_loop_start).unwrap();
+        let mut duration_since_last_loop = SystemTime::now().duration_since(display_loop_start).unwrap();
-    loop {
+        loop {
-        if let Ok(response) = ping_response_listener.recv_timeout(Duration::from_millis(100)) {
+            let now = SystemTime::now();
-            for (_, (name, current_state)) in targets.clone().iter().enumerate() {
+            if let Ok(response) = ping_response_listener.recv_timeout(Duration::from_millis(100)) {
-                if current_state.target == response.target {
+                let local_targets = targets.clone();
-                    let last_alive_change = if response.success == current_state.alive {
+                for (_, (name, current_state)) in local_targets.iter().enumerate() {
-                        current_state.last_alive_change
+                    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 {
-                        SystemTime::now()
+                        target_string.red().to_string()
                     };
 
-                    let new_state = TargetState {
+                    println!("{} \t | {} \t | {}\t | Changed {} ago",
-                        name: current_state.name.clone(),
+                             target_string,
-                        target: current_state.target,
+                             current_result.alive,
-                        alive: response.success,
+                             current_result.last_rtt,
-                        last_rtt: response.rtt,
+                             duration_to_string(time_since_last_change)
-                        last_alive_change,
+                    );
-                    };
-                    targets.insert(name.clone(), new_state);
                 }
+                display_loop_start = now;
             }
         }
-        duration_since_last_loop = SystemTime::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 mut target_string = String::new();
-                let time_since_last_change = SystemTime::now().duration_since(current_result.last_alive_change).unwrap();
-                target_string = format!("{} ({})", name, current_result.target);
-                while target_string.len() < 34 {
-                    target_string = format!("{}     ", target_string);
-                }
-
-                println!("{} \t | {} \t | {}\t | Changed {}s ago",
-                         target_string,
-                         current_result.alive,
-                         current_result.last_rtt, time_since_last_change.as_secs()
-                );
-            }
-            display_loop_start = SystemTime::now();
-        }
     }
-}

src/lib.rs

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

src/manager.rs

@@ -1,17 +1,15 @@
-use std::net::Ipv4Addr;
+use std::net::{IpAddr, Ipv4Addr};
 use std::process::Command;
 use std::sync::mpsc::Sender;
 use std::thread;
 use std::time::{Duration, SystemTime};
+use ping_rs::send_ping;
 use crate::ping_request::PingRequest;
 use crate::ping_result::PingResult;
 use crate::SECONDS_BETWEEN_PING;
 
 pub struct Manager;
 
-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>) {
         let local_targets = targets.clone();
@@ -34,27 +32,25 @@ impl Manager {
             let mut result = 0;
             let mut success = true;
             let start_time = SystemTime::now();
-            #[cfg(any(target_os="windows"))] {
+
-                result = Command::new("c:/windows/system32/ping.exe").arg(request.target.to_string())
+            let target_address = IpAddr::from(request.target);
-                    .arg("-n 1")
+
-                    .arg(format!("-w {}", crate::SECONDS_BETWEEN_PING))
+            let options = ping_rs::PingOptions { ttl: 128, dont_fragment: false };
-                    .arg("-4")
+            let data = [1,2,3,4];
-                    .output().unwrap().status.code().unwrap_or(255);
+            let result = send_ping(&target_address, Duration::from_secs(10), &data, Some(&options));
-                success = result == WIN_PING_SUCCESS as i32;;
+
-            }
-            #[cfg(any(target_os="linux"))] {
-                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);
-                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;
+
+            let success = match &result {
+                Ok(reply) => {
+                    println!("Good reply -> {}/{}/{}", reply.address, data.len(), reply.rtt);
+                    true
+                },
+                Err(e) => { println!("ERROR {:?}", e); false }
+            };
+
             sender.send(PingResult {
                 target: local_request.target,
                 success,

src/target_state.rs

@@ -1,5 +1,10 @@
 use std::net::Ipv4Addr;
 use std::time::SystemTime;
+use ratatui::buffer::Buffer;
+use ratatui::layout::Rect;
+use ratatui::prelude::{StatefulWidget, Style};
+use ratatui::style::Color;
+use ratatui::widgets::Widget;
 
 #[derive(Clone, Debug)]
 pub struct TargetState {
@@ -21,3 +26,11 @@ impl Default for TargetState {
         }
     }
 }
+struct TargetStateWidget;
+
+impl StatefulWidget for TargetStateWidget {
+    type State = TargetStateWidget;
+    fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
+        buf.set_string(area.left(),area.top(),"This is the string set ", Style::default().fg(Color::Red));
+    }
+}