Improving error handing according to #33 comments

Author: dr-orlovsky

src/raw_client.rs

@@ -492,8 +492,17 @@ impl<S: Read + Write> RawClient<S> {
 
                             // If the map is not empty, we select a random thread to become the
                             // new reader thread.
-                            if let Some(sender) = map.values().next() {
-                                sender.send(ChannelMessage::WakeUp)?;
+                            if let Some(err) = map.values().find_map(|sender| {
+                                sender
+                                    .send(ChannelMessage::WakeUp)
+                                    .map_err(|err| {
+                                        warn!("Unable to wake up a thread, trying some other");
+                                        err
+                                    })
+                                    .err()
+                            }) {
+                                error!("All the threads has failed, giving up");
+                                return Err(err)?;
                             }
 
                             break Ok(resp);

src/stream.rs

@@ -1,3 +1,4 @@
+use log::error;
 use std::io::{self, Read, Write};
 use std::sync::{Arc, Mutex};
 
@@ -8,7 +9,10 @@ impl<T: Read + Write> Read for ClonableStream<T> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         self.0
             .lock()
-            .map_err(|_| io::Error::from(io::ErrorKind::BrokenPipe))?
+            .map_err(|_| {
+                error!("Unable to acquire lock on ClonableStream read operation");
+                io::Error::from(io::ErrorKind::BrokenPipe)
+            })?
             .read(buf)
     }
 }
@@ -17,14 +21,20 @@ impl<T: Read + Write> Write for ClonableStream<T> {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         self.0
             .lock()
-            .map_err(|_| io::Error::from(io::ErrorKind::BrokenPipe))?
+            .map_err(|_| {
+                error!("Unable to acquire lock on ClonableStream write operation");
+                io::Error::from(io::ErrorKind::BrokenPipe)
+            })?
             .write(buf)
     }
 
     fn flush(&mut self) -> io::Result<()> {
         self.0
             .lock()
-            .map_err(|_| io::Error::from(io::ErrorKind::BrokenPipe))?
+            .map_err(|_| {
+                error!("Unable to acquire lock on ClonableStream flush operation");
+                io::Error::from(io::ErrorKind::BrokenPipe)
+            })?
             .flush()
     }
 }

src/types.rs

@@ -344,6 +344,7 @@ impl Display for Error {
             Error::MissingDomain => f.write_str("Missing domain while it was explicitly asked to validate it"),
             Error::BothSocksAndTimeout => f.write_str("Setting both a proxy and a timeout in `Config` is an error"),
             Error::CouldntLockReader => f.write_str("Couldn't take a lock on the reader mutex. This means that there's already another reader thread is running"),
+            Error::Mpsc => f.write_str("Broken IPC communication channel: the other thread probably has exited"),
         }
     }
 }
@@ -367,7 +368,7 @@ impl_error!(bitcoin::consensus::encode::Error, Bitcoin);
 
 impl<T> From<std::sync::PoisonError<T>> for Error {
     fn from(_: std::sync::PoisonError<T>) -> Self {
-        Error::CouldntLockReader
+        Error::IOError(std::io::Error::from(std::io::ErrorKind::BrokenPipe))
     }
 }