Return proper error for proxy monitor

4 files changed, 32 insertions, 34 deletions

diff --git a/talpid-core/src/proxy/mod.rs b/talpid-core/src/proxy/mod.rs
index c33c09cf05..dd0e0b6cc9 100644
--- a/talpid-core/src/proxy/mod.rs
+++ b/talpid-core/src/proxy/mod.rs
@@ -1,25 +1,29 @@
 mod noop;
 mod shadowsocks;
 
-pub use std::io::Result;
-
 use self::shadowsocks::ShadowsocksProxyMonitor;
 use async_trait::async_trait;
-use std::{fmt, path::PathBuf};
+use std::{fmt, io, path::PathBuf};
 use talpid_types::net::openvpn;
 
-pub enum WaitResult {
+#[derive(err_derive::Error, Debug)]
+pub enum Error {
+    #[error(display = "Monitor exited unexpectedly: {}", _0)]
     UnexpectedExit(String),
-    ProperShutdown,
+
+    #[error(display = "I/O error")]
+    Io(io::Error),
 }
 
+pub type Result<T> = std::result::Result<T, Error>;
+
 #[async_trait]
 pub trait ProxyMonitor: Send {
     /// Create a handle than can be used to ask the proxy service to shut down.
     fn close_handle(&mut self) -> Box<dyn ProxyMonitorCloseHandle>;
 
     /// Consume monitor and wait for proxy service to shut down.
-    async fn wait(self: Box<Self>) -> Result<WaitResult>;
+    async fn wait(self: Box<Self>) -> Result<()>;
 
     /// The port bound to.
     fn port(&self) -> u16;
diff --git a/talpid-core/src/proxy/noop.rs b/talpid-core/src/proxy/noop.rs
index 88ec5b437d..9eb96e0c95 100644
--- a/talpid-core/src/proxy/noop.rs
+++ b/talpid-core/src/proxy/noop.rs
@@ -1,7 +1,7 @@
 use async_trait::async_trait;
 use futures::{channel::mpsc, StreamExt};
 
-use super::{ProxyMonitor, ProxyMonitorCloseHandle, Result, WaitResult};
+use super::{ProxyMonitor, ProxyMonitorCloseHandle, Result};
 
 pub struct NoopProxyMonitor {
     tx: mpsc::UnboundedSender<()>,
@@ -24,9 +24,9 @@ impl ProxyMonitor for NoopProxyMonitor {
         })
     }
 
-    async fn wait(mut self: Box<Self>) -> Result<WaitResult> {
+    async fn wait(mut self: Box<Self>) -> Result<()> {
         let _ = self.rx.next().await;
-        Ok(WaitResult::ProperShutdown)
+        Ok(())
     }
 
     fn port(&self) -> u16 {
diff --git a/talpid-core/src/proxy/shadowsocks.rs b/talpid-core/src/proxy/shadowsocks.rs
index 12f8c1bb69..8bd72242da 100644
--- a/talpid-core/src/proxy/shadowsocks.rs
+++ b/talpid-core/src/proxy/shadowsocks.rs
@@ -15,7 +15,7 @@ use shadowsocks_service::{
     },
 };
 
-use super::{ProxyMonitor, ProxyMonitorCloseHandle, ProxyResourceData, WaitResult};
+use super::{Error, ProxyMonitor, ProxyMonitorCloseHandle, ProxyResourceData};
 use talpid_types::{net::openvpn::ShadowsocksProxySettings, ErrorExt};
 
 pub struct ShadowsocksProxyMonitor {
@@ -28,7 +28,11 @@ impl ShadowsocksProxyMonitor {
     pub async fn start(
         settings: &ShadowsocksProxySettings,
         _resource_data: &ProxyResourceData,
-    ) -> io::Result<Self> {
+    ) -> super::Result<Self> {
+        Self::start_inner(settings).await.map_err(Error::Io)
+    }
+
+    async fn start_inner(settings: &ShadowsocksProxySettings) -> io::Result<Self> {
         // TODO: Patch shadowsocks so the bound address can be obtained afterwards.
         let addr = SocketAddrV4::new(Ipv4Addr::LOCALHOST, 0);
         let sock = Socket::new(
@@ -103,20 +107,18 @@ impl ProxyMonitor for ShadowsocksProxyMonitor {
         })
     }
 
-    async fn wait(mut self: Box<Self>) -> io::Result<WaitResult> {
+    async fn wait(mut self: Box<Self>) -> super::Result<()> {
         match self.server_join_handle.await {
-            Ok(Err(Aborted)) => Ok(WaitResult::ProperShutdown),
+            Ok(Err(Aborted)) => Ok(()),
 
-            Err(join_err) if join_err.is_cancelled() => Ok(WaitResult::ProperShutdown),
-            Err(_) => Ok(WaitResult::UnexpectedExit(
+            Err(join_err) if join_err.is_cancelled() => Ok(()),
+            Err(_) => Err(Error::UnexpectedExit(
                 "Shadowsocks task panicked".to_string(),
             )),
 
             Ok(Ok(result)) => match result {
-                Ok(()) => Ok(WaitResult::UnexpectedExit(
-                    "Exited without error".to_string(),
-                )),
-                Err(error) => Ok(WaitResult::UnexpectedExit(format!(
+                Ok(()) => Err(Error::UnexpectedExit("Exited without error".to_string())),
+                Err(error) => Err(Error::UnexpectedExit(format!(
                     "Error: {}",
                     error.display_chain()
                 ))),
@@ -134,7 +136,7 @@ struct ShadowsocksProxyMonitorCloseHandle {
 }
 
 impl ProxyMonitorCloseHandle for ShadowsocksProxyMonitorCloseHandle {
-    fn close(self: Box<Self>) -> io::Result<()> {
+    fn close(self: Box<Self>) -> super::Result<()> {
         self.server_abort_handle.abort();
         Ok(())
     }
diff --git a/talpid-core/src/tunnel/openvpn/mod.rs b/talpid-core/src/tunnel/openvpn/mod.rs
index 5d18919887..f3ae44b7ea 100644
--- a/talpid-core/src/tunnel/openvpn/mod.rs
+++ b/talpid-core/src/tunnel/openvpn/mod.rs
@@ -119,7 +119,7 @@ pub enum Error {
 
     /// Failures related to the proxy service.
     #[error(display = "Unable to start the proxy service")]
-    StartProxyError(#[error(source)] io::Error),
+    StartProxyError(#[error(source)] proxy::Error),
 
     /// Error while monitoring proxy service
     #[error(display = "Error while monitoring proxy service")]
@@ -495,7 +495,7 @@ impl<C: OpenVpnBuilder + Send + 'static> OpenVpnMonitor<C> {
 
             enum Stopped {
                 Tunnel(Result<()>),
-                Proxy(proxy::Result<proxy::WaitResult>),
+                Proxy(proxy::Result<()>),
             }
 
             let handle = self.runtime.handle().clone();
@@ -517,18 +517,10 @@ impl<C: OpenVpnBuilder + Send + 'static> OpenVpnMonitor<C> {
 
             match result {
                 Stopped::Tunnel(tunnel_result) => tunnel_result,
-                Stopped::Proxy(proxy_result) => {
-                    // The proxy should never exit before openvpn.
-                    match proxy_result {
-                        Ok(proxy::WaitResult::ProperShutdown) => {
-                            Err(Error::ProxyExited("No details".to_owned()))
-                        }
-                        Ok(proxy::WaitResult::UnexpectedExit(details)) => {
-                            Err(Error::ProxyExited(details))
-                        }
-                        Err(err) => Err(err).map_err(Error::MonitorProxyError),
-                    }
-                }
+                Stopped::Proxy(proxy_result) => proxy_result.map_err(|error| match error {
+                    proxy::Error::UnexpectedExit(details) => Error::ProxyExited(details),
+                    proxy::Error::Io(error) => Error::MonitorProxyError(error),
+                }),
             }
         } else {
             // No proxy active, wait only for the tunnel.