uses a default list if no file is passed

peterborough.txt

@@ -0,0 +1,14 @@
+10.3.100.1,Belleville Router
+10.11.31.3,Belleville VPN 11-31
+10.12.32.1,Belleville VPN 12-32
+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
+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/pp.rs

@@ -20,63 +20,68 @@ fn get_default_targets() -> BTreeMap<String, TargetState> {
     working.insert("Localhost".to_string(),
                    TargetState {
                        name: "Localhost".to_string(),
-                     target: Ipv4Addr::new(127,0,0,1),
+                       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),
+                       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),
+                       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),
+                       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),
+                       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),
+                       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),
+                       target: Ipv4Addr::new(24, 143, 184, 98),
                        ..TargetState::default()
-                 }
+                   },
     );
     working
 }
 
-fn build_targets_from_file(filename: Option<PathBuf>) -> BTreeMap<String, TargetState>{
+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 {
-      println!("File is {:?}", file.to_str());
+        hosts = if !&file.exists() {
+            println!("Cant load hosts from {:?}.  Using default host list.", file.clone().as_os_str());
+            // use
+            get_default_targets()
+        } else {
+            println!("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() {
@@ -87,10 +92,13 @@ fn build_targets_from_file(filename: Option<PathBuf>) -> BTreeMap<String, Target
                                  target: Ipv4Addr::from_str(&record[0]).unwrap(),
                                  alive: false,
                                  last_alive_change: SystemTime::now(),
-                             last_rtt: 0
+                                 last_rtt: 0,
                              });
             }
-    };
+            hosts
+        }
+    }
+
     hosts
 }
 
@@ -115,13 +123,12 @@ fn main() {
     // Get App Settings
     let settings = AppSettings::parse();
 
+    print!("Prep to load targets...");
+    let mut targets = build_targets_from_file(settings.ping_host_file);
+
     // channel to send requests to ping
     let (ping_response_sender, ping_response_listener) = mpsc::channel::<PingResult>();
 
-   let file_to_read = settings.ping_host_file;
-
-    let mut targets = build_targets_from_file(file_to_read);
-
     println!("Setting up requests for {} hosts.", targets.len());
     Manager::spawn_manager_thread(ips_from_state(targets.clone()), ping_response_sender.clone());
 
@@ -129,7 +136,7 @@ fn main() {
     let mut duration_since_last_loop = SystemTime::now().duration_since(display_loop_start).unwrap();
     loop {
         if let Ok(response) = ping_response_listener.recv_timeout(Duration::from_millis(100)) {
-            for (index, (name, current_state)) in targets.clone().iter().enumerate() {
+            for (_, (name, current_state)) in targets.clone().iter().enumerate() {
                 if current_state.target == response.target {
                     let last_alive_change = if response.success == current_state.alive {
                         current_state.last_alive_change
@@ -144,7 +151,7 @@ fn main() {
                         last_rtt: response.rtt,
                         last_alive_change,
                     };
-                    targets.insert(current_state.name.clone(), new_state);
+                    targets.insert(name.clone(), new_state);
                 }
             }
         }
@@ -165,7 +172,7 @@ fn main() {
                 println!("{} \t | {} \t | {}\t | Changed {}s ago",
                          target_string,
                          current_result.alive,
-                         current_result.last_rtt,time_since_last_change.as_secs()
+                         current_result.last_rtt, time_since_last_change.as_secs()
                 );
             }
             display_loop_start = SystemTime::now();