Remove `StateEntryResult` type

5 files changed, 33 insertions, 40 deletions

diff --git a/talpid-core/src/tunnel_state_machine/connected_state.rs b/talpid-core/src/tunnel_state_machine/connected_state.rs
index 1b119eb387..2881e0409c 100644
--- a/talpid-core/src/tunnel_state_machine/connected_state.rs
+++ b/talpid-core/src/tunnel_state_machine/connected_state.rs
@@ -5,8 +5,7 @@ use talpid_types::net::TunnelEndpoint;
 
 use super::{
     AfterDisconnect, ConnectingState, DisconnectingState, EventConsequence, Result, ResultExt,
-    SharedTunnelStateValues, StateEntryResult, TunnelCommand, TunnelParameters, TunnelState,
-    TunnelStateWrapper,
+    SharedTunnelStateValues, TunnelCommand, TunnelParameters, TunnelState, TunnelStateWrapper,
 };
 use security::{NetworkSecurity, SecurityPolicy};
 use tunnel::{CloseHandle, TunnelEvent, TunnelMetadata};
@@ -152,13 +151,13 @@ impl TunnelState for ConnectedState {
     fn enter(
         shared_values: &mut SharedTunnelStateValues,
         bootstrap: Self::Bootstrap,
-    ) -> StateEntryResult {
+    ) -> TunnelStateWrapper {
         let connected_state = ConnectedState::from(bootstrap);
 
         match connected_state.set_security_policy(shared_values) {
-            Ok(()) => Ok(TunnelStateWrapper::from(connected_state)),
-            Err(error) => Err((
-                error,
+            Ok(()) => TunnelStateWrapper::from(connected_state),
+            Err(error) => {
+                error!("{}", error.chain_err(|| "Failed to set security policy"));
                 DisconnectingState::enter(
                     shared_values,
                     (
@@ -166,8 +165,8 @@ impl TunnelState for ConnectedState {
                         connected_state.tunnel_close_event,
                         AfterDisconnect::Nothing,
                     ),
-                ).expect("Failed to disconnect after failed transition to connected state"),
-            )),
+                )
+            }
         }
     }
 
diff --git a/talpid-core/src/tunnel_state_machine/connecting_state.rs b/talpid-core/src/tunnel_state_machine/connecting_state.rs
index 2588da0e77..15e851e351 100644
--- a/talpid-core/src/tunnel_state_machine/connecting_state.rs
+++ b/talpid-core/src/tunnel_state_machine/connecting_state.rs
@@ -13,7 +13,7 @@ use talpid_types::net::{TunnelEndpoint, TunnelEndpointData};
 use super::{
     AfterDisconnect, ConnectedState, ConnectedStateBootstrap, DisconnectedState,
     DisconnectingState, EventConsequence, Result, ResultExt, SharedTunnelStateValues,
-    StateEntryResult, TunnelCommand, TunnelParameters, TunnelState, TunnelStateWrapper,
+    TunnelCommand, TunnelParameters, TunnelState, TunnelStateWrapper,
 };
 use logging;
 use security::{NetworkSecurity, SecurityPolicy};
@@ -269,17 +269,14 @@ impl TunnelState for ConnectingState {
     fn enter(
         shared_values: &mut SharedTunnelStateValues,
         parameters: Self::Bootstrap,
-    ) -> StateEntryResult {
-        Self::new(shared_values, parameters)
-            .map(TunnelStateWrapper::from)
-            .chain_err(|| "Failed to start tunnel")
-            .map_err(|error| {
-                (
-                    error,
-                    DisconnectedState::enter(shared_values, ())
-                        .expect("Failed to transition to fallback disconnected state"),
-                )
-            })
+    ) -> TunnelStateWrapper {
+        match Self::new(shared_values, parameters) {
+            Ok(connecting_state) => TunnelStateWrapper::from(connecting_state),
+            Err(error) => {
+                error!("{}", error.chain_err(|| "Failed to start tunnel"));
+                DisconnectedState::enter(shared_values, ())
+            }
+        }
     }
 
     fn handle_event(
diff --git a/talpid-core/src/tunnel_state_machine/disconnected_state.rs b/talpid-core/src/tunnel_state_machine/disconnected_state.rs
index 694e280ec6..7662f941c6 100644
--- a/talpid-core/src/tunnel_state_machine/disconnected_state.rs
+++ b/talpid-core/src/tunnel_state_machine/disconnected_state.rs
@@ -3,8 +3,8 @@ use futures::sync::mpsc;
 use futures::Stream;
 
 use super::{
-    ConnectingState, Error, EventConsequence, SharedTunnelStateValues, StateEntryResult,
-    TunnelCommand, TunnelState, TunnelStateWrapper,
+    ConnectingState, Error, EventConsequence, SharedTunnelStateValues, TunnelCommand, TunnelState,
+    TunnelStateWrapper,
 };
 use security::NetworkSecurity;
 
@@ -24,10 +24,13 @@ impl DisconnectedState {
 impl TunnelState for DisconnectedState {
     type Bootstrap = ();
 
-    fn enter(shared_values: &mut SharedTunnelStateValues, _: Self::Bootstrap) -> StateEntryResult {
+    fn enter(
+        shared_values: &mut SharedTunnelStateValues,
+        _: Self::Bootstrap,
+    ) -> TunnelStateWrapper {
         Self::reset_security_policy(shared_values);
 
-        Ok(TunnelStateWrapper::from(DisconnectedState))
+        TunnelStateWrapper::from(DisconnectedState)
     }
 
     fn handle_event(
diff --git a/talpid-core/src/tunnel_state_machine/disconnecting_state.rs b/talpid-core/src/tunnel_state_machine/disconnecting_state.rs
index 0643fef13c..ffcbd51a65 100644
--- a/talpid-core/src/tunnel_state_machine/disconnecting_state.rs
+++ b/talpid-core/src/tunnel_state_machine/disconnecting_state.rs
@@ -6,7 +6,7 @@ use futures::{Async, Future, Stream};
 
 use super::{
     ConnectingState, DisconnectedState, EventConsequence, ResultExt, SharedTunnelStateValues,
-    StateEntryResult, TunnelCommand, TunnelParameters, TunnelState, TunnelStateWrapper,
+    TunnelCommand, TunnelParameters, TunnelState, TunnelStateWrapper,
 };
 use tunnel::CloseHandle;
 
@@ -57,7 +57,7 @@ impl DisconnectingState {
         }
     }
 
-    fn after_disconnect(self, shared_values: &mut SharedTunnelStateValues) -> StateEntryResult {
+    fn after_disconnect(self, shared_values: &mut SharedTunnelStateValues) -> TunnelStateWrapper {
         match self.after_disconnect {
             AfterDisconnect::Nothing => DisconnectedState::enter(shared_values, ()),
             AfterDisconnect::Reconnect(tunnel_parameters) => {
@@ -73,7 +73,7 @@ impl TunnelState for DisconnectingState {
     fn enter(
         _: &mut SharedTunnelStateValues,
         (close_handle, exited, after_disconnect): Self::Bootstrap,
-    ) -> StateEntryResult {
+    ) -> TunnelStateWrapper {
         thread::spawn(move || {
             let close_result = close_handle
                 .close()
@@ -84,10 +84,10 @@ impl TunnelState for DisconnectingState {
             }
         });
 
-        Ok(TunnelStateWrapper::from(DisconnectingState {
+        TunnelStateWrapper::from(DisconnectingState {
             exited,
             after_disconnect,
-        }))
+        })
     }
 
     fn handle_event(
diff --git a/talpid-core/src/tunnel_state_machine/mod.rs b/talpid-core/src/tunnel_state_machine/mod.rs
index 01a168e2b6..68dfa17082 100644
--- a/talpid-core/src/tunnel_state_machine/mod.rs
+++ b/talpid-core/src/tunnel_state_machine/mod.rs
@@ -148,8 +148,7 @@ impl TunnelStateMachine {
             NetworkSecurityImpl::new(cache_dir).chain_err(|| ErrorKind::NetworkSecurityError)?;
         let mut shared_values = SharedTunnelStateValues { security };
 
-        let initial_state = TunnelStateWrapper::new(&mut shared_values, ())
-            .expect("Failed to create initial tunnel state");
+        let initial_state = TunnelStateWrapper::new(&mut shared_values, ());
 
         Ok(TunnelStateMachine {
             current_state: Some(initial_state),
@@ -199,7 +198,7 @@ impl<T: TunnelState> From<EventConsequence<T>> for TunnelStateMachineAction {
         use self::TunnelStateMachineAction::*;
 
         match event_consequence {
-            NewState(Ok(state_wrapper)) | NewState(Err((_, state_wrapper))) => {
+            NewState(state_wrapper) => {
                 let transition = state_wrapper.info();
                 Notify(Some(state_wrapper), Ok(Async::Ready(Some(transition))))
             }
@@ -218,7 +217,7 @@ struct SharedTunnelStateValues {
 /// Asynchronous result of an attempt to progress a state.
 enum EventConsequence<T: TunnelState> {
     /// Transition to a new state.
-    NewState(StateEntryResult),
+    NewState(TunnelStateWrapper),
     /// An event was received, but it was ignored by the state so no transition is performed.
     SameState(T),
     /// No events were received, the event loop should block until one becomes available.
@@ -247,11 +246,6 @@ where
     }
 }
 
-/// Result of entering a `T: TunnelState`.
-///
-/// It is either the state itself when successful, or an error paired with a fallback state.
-type StateEntryResult = ::std::result::Result<TunnelStateWrapper, (Error, TunnelStateWrapper)>;
-
 /// Trait that contains the method all states should implement to handle an event and advance the
 /// state machine.
 trait TunnelState: Into<TunnelStateWrapper> + Sized {
@@ -265,7 +259,7 @@ trait TunnelState: Into<TunnelStateWrapper> + Sized {
     fn enter(
         shared_values: &mut SharedTunnelStateValues,
         bootstrap: Self::Bootstrap,
-    ) -> StateEntryResult;
+    ) -> TunnelStateWrapper;
 
     /// Main state function.
     ///
@@ -299,7 +293,7 @@ impl TunnelStateWrapper {
     fn new(
         shared_values: &mut SharedTunnelStateValues,
         bootstrap: <DisconnectedState as TunnelState>::Bootstrap,
-    ) -> StateEntryResult {
+    ) -> TunnelStateWrapper {
         DisconnectedState::enter(shared_values, bootstrap)
     }