From 6fdce7e8d2db28de83eb0997cb6355e90be5ad58 Mon Sep 17 00:00:00 2001
From: Jeremy Wall <jeremy@marzhillstudios.com>
Date: Fri, 31 Jul 2020 15:06:27 -0400
Subject: [PATCH] Some more ergonomics

---
 src/main.rs | 85 ++++++++++++++++++++++++++++++-----------------------
 1 file changed, 48 insertions(+), 37 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index e2f28d7..007a108 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -123,7 +123,12 @@ fn main() -> anyhow::Result<()> {
         gflags::print_help_and_exit(0);
     }
 
-    let level = if DEBUG.flag { 3 } else { 2 };
+    let level = if DEBUG.flag || cfg!(debug_assertions) {
+        3
+    } else {
+        2
+    };
+
     stderrlog::new()
         .verbosity(level)
         .timestamp(stderrlog::Timestamp::Millisecond)
@@ -154,8 +159,49 @@ fn main() -> anyhow::Result<()> {
     let socket_addrs = resolve_addrs(&stun_servers).unwrap();
     let stun_servers = Arc::new(stun_servers);
 
-    // first we attempt connections to each server.
     let mut parent = Nursery::new();
+    // First we start the render thread.
+    {
+        // Introduce a new scope for our Arc to clone before moving it into the thread.
+        let stop_signal = stop_signal.clone();
+        // thread::Handle starts the thread immediately so the render thread will usually start first.
+        let render_thread = thread::Handle::new(move || {
+            debug!("attempting to start server on {}", LISTENHOST.flag);
+            let server = match tiny_http::Server::http(LISTENHOST.flag) {
+                Ok(server) => server,
+                Err(err) => {
+                    let mut signal = stop_signal.write().unwrap();
+                    *signal = true;
+                    error!("Error starting render thread {}", err);
+                    error!("Shutting down all threads...");
+                    std::process::exit(1);
+                }
+            };
+            info!("Listening for metrics request on {}", LISTENHOST.flag);
+            loop {
+                info!("Waiting for request");
+                match server.recv() {
+                    Ok(req) => {
+                        let mut buffer = vec![];
+                        // Gather the metrics.
+                        let encoder = TextEncoder::new();
+                        let metric_families = r.gather();
+                        encoder.encode(&metric_families, &mut buffer).unwrap();
+
+                        let response = tiny_http::Response::from_data(buffer).with_status_code(200);
+                        if let Err(e) = req.respond(response) {
+                            error!("Error responding to request {}", e);
+                        }
+                    }
+                    Err(e) => {
+                        info!("Invalid http request! {}", e);
+                    }
+                }
+            }
+        });
+        parent.adopt(Box::new(render_thread));
+    }
+    // Then we attempt connections to each server.
     for (i, s) in socket_addrs.iter().enumerate() {
         let stun_servers_copy = stun_servers.clone();
         let stun_counter_vec_copy = stun_counter_vec.clone();
@@ -216,41 +262,6 @@ fn main() -> anyhow::Result<()> {
         });
         parent.schedule(Box::new(connect_thread));
     }
-    let stop_signal = stop_signal.clone();
-    let render_thread = thread::Pending::new(move || {
-        debug!("attempting to start server on {}", LISTENHOST.flag);
-        let server = match tiny_http::Server::http(LISTENHOST.flag) {
-            Ok(server) => server,
-            Err(err) => {
-                let mut signal = stop_signal.write().unwrap();
-                *signal = true;
-                error!("Error starting render thread {}", err);
-                error!("Shutting down all threads...");
-                return;
-            }
-        };
-        loop {
-            info!("Waiting for request");
-            match server.recv() {
-                Ok(req) => {
-                    let mut buffer = vec![];
-                    // Gather the metrics.
-                    let encoder = TextEncoder::new();
-                    let metric_families = r.gather();
-                    encoder.encode(&metric_families, &mut buffer).unwrap();
-
-                    let response = tiny_http::Response::from_data(buffer).with_status_code(200);
-                    if let Err(e) = req.respond(response) {
-                        info!("Error responding to request {}", e);
-                    }
-                }
-                Err(e) => {
-                    info!("Invalid http request! {}", e);
-                }
-            }
-        }
-    });
-    parent.schedule(Box::new(render_thread));
     // Blocks forever
     parent.wait();
     Ok(())