UDP seems to work now

src/main.rs

@@ -3,6 +3,7 @@ mod shutdown;
 mod tcp;
 mod udp;
 
+use log::{debug, error, info, warn};
 use serde::Deserialize;
 use simple_error::bail;
 use std::collections::{HashMap, HashSet};
@@ -13,6 +14,8 @@ use std::sync::Arc;
 use tokio::signal::unix::{signal, SignalKind};
 use tokio::sync::{broadcast, RwLock};
 
+pub type Result<T> = std::result::Result<T, Box<dyn Error>>;
+
 #[derive(Debug, Deserialize)]
 struct Target {
     udp: Option<bool>,
@@ -25,21 +28,21 @@ struct Config {
     mappings: Vec<Target>,
 }
 
-fn load_yaml(path: &Path) -> Result<Config, Box<dyn Error>> {
+fn load_yaml(path: &Path) -> Result<Config> {
     let file = File::open(path)?;
     let config: Config = serde_yaml::from_reader(file).expect("Failed to parse!"); //TODO: Print path
 
     return Ok(config);
 }
 
-fn load_json(path: &Path) -> Result<Config, Box<dyn Error>> {
+fn load_json(path: &Path) -> Result<Config> {
     let file = File::open(path)?;
     let config: Config = serde_json::from_reader(file).expect("Failed to parse!"); //TODO: Print path
 
     return Ok(config);
 }
 
-fn load_config() -> Result<Config, Box<dyn Error>> {
+fn load_config() -> Result<Config> {
     for path in [
         "config.yaml",
         "config.json",
@@ -63,13 +66,28 @@ fn load_config() -> Result<Config, Box<dyn Error>> {
 
 // #[derive(Debug)]
 struct ActiveListener {
-    udp: bool,
     notify_shutdown: broadcast::Sender<()>,
     targets: Arc<RwLock<Vec<String>>>,
 }
 
 #[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
+async fn main() -> Result<()> {
+    fern::Dispatch::new()
+        .format(|out, message, record| {
+            out.finish(format_args!(
+                "{}[{}][{}] {}",
+                chrono::Local::now().format("[%Y-%m-%d][%H:%M:%S]"),
+                record.target(),
+                record.level(),
+                message
+            ))
+        })
+        // Add blanket level filter -
+        .level(log::LevelFilter::Info)
+        .level_for("rustocat", log::LevelFilter::Trace)
+        .chain(std::io::stdout())
+        .apply()?;
+
     let mut listeners: HashMap<String, ActiveListener> = HashMap::new();
     let mut sighup_stream = signal(SignalKind::hangup())?;
 
@@ -108,7 +126,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 }
 
                 if invalid {
-                    println!("Found invalid targets! Adjusting!");
+                    warn!("Found invalid targets! Adjusting!");
                     let mut w = listener.targets.write().await;
                     *w = target.targets;
                 }
@@ -118,11 +136,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 let listener = ActiveListener {
                     notify_shutdown: notify_shutdown,
                     targets: Arc::new(RwLock::new(target.targets)),
-                    udp: target.udp == None || target.udp == Some(false),
                 };
 
                 let l = listener::Listener {
-                    shutdown: shutdown::Shutdown::new(listener.notify_shutdown.subscribe()),
+                    shutdown: shutdown::ShutdownReceiver::new(listener.notify_shutdown.subscribe()),
                     source: target.source.clone(),
                     targets: listener.targets.clone(),
                 };
@@ -130,11 +147,11 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 tokio::spawn(async move {
                     if target.udp == None || target.udp == Some(false) {
                         if let Err(err) = tcp::start_tcp_listener(l).await {
-                            println!("tcp listener error: {}", err);
+                            error!("tcp listener error: {}", err);
                         }
                     } else {
                         if let Err(err) = udp::start_udp_listener(l).await {
-                            println!("udp listener error: {}", err);
+                            error!("udp listener error: {}", err);
                         }
                     }
                 });
@@ -151,13 +168,22 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
         for del_key in to_delete {
             if let Some(listener) = listeners.get(&del_key) {
-                let _ = listener.notify_shutdown.send(()); //Errors are irrelevant here. I guess....
-                println!("Removing listener!");
+                let res = listener.notify_shutdown.send(()); //Errors are irrelevant here. I guess....
+                match res {
+                    Ok(_) => {
+                        info!("Sent shutdown signal!");
+                    }
+                    Err(_) => {
+                        warn!("Failed to send shutdown signal!");
+                    }
+                }
+
+                debug!("Removing listener!");
                 listeners.remove(&del_key);
             }
         }
 
         sighup_stream.recv().await;
-        println!("Recevied SIGHUP!");
+        info!("Recevied SIGHUP, reloading config!");
     }
 }