Do not crash application when a single painter fails, just reconnect

src/main.rs

@@ -31,8 +31,8 @@ fn start<'a>(arg_handler: &ArgHandler<'a>) {
     println!("Starting... (use CTRL+C to stop)");
 
     // Gather facts about the host
-    let screen_size =
+    let screen_size = gather_host_facts(&arg_handler)
-        gather_host_facts(&arg_handler).expect("Failed to gather facts about pixelflut server");
+        .expect("Failed to gather facts about pixelflut server");
 
     // Determine the size to use
     let size = arg_handler.size(Some(screen_size));

src/pix/canvas.rs

@@ -1,6 +1,7 @@
-use std::sync::mpsc;
+use std::sync::mpsc::{self, Receiver, Sender};
-use std::sync::mpsc::{Receiver, Sender};
+use std::thread::sleep;
 use std::thread;
+use std::time::Duration;
 
 use image::DynamicImage;
 
@@ -68,15 +69,32 @@ impl Canvas {
 
         // Create the painter thread
         let thread = thread::spawn(move || {
+            loop {
+                'paint: loop {
                     // Create a new client
-            let client = Client::connect(host).expect("failed to open stream to pixelflut");
+                    let client = match Client::connect(host.clone()) {
+                        Ok(client) => client,
+                        Err(e) => {
+                            eprintln!("Painter failed to connect: {}", e);
+                            break 'paint;
+                        },
+                    };
 
                     // Create a painter
                     let mut painter = Painter::new(client, area, offset, None);
 
-            // Do some work
+                    // Keep painting
                     loop {
-                painter.work(&rx).expect("Painter failed to perform work");
+                        if let Err(e) = painter.work(&rx) {
+                            println!("Painter error: {}", e);
+                            break 'paint;
+                        }
+                    }
+                }
+
+                // Sleep for half a second before restarting the painter
+                sleep(Duration::from_millis(500));
+                println!("Restarting failed painter...");
             }
         });
 

src/pix/client.rs

@@ -87,8 +87,7 @@ impl Client {
         // TODO: make flushing configurable?
         // TODO: make buffer size configurable?
         self.stream
-            .flush()
+            .flush()?;
-            .expect("failed to flush write buffer to server");
 
         // Everything seems to be ok
         Ok(())