diff options
| -rw-r--r-- | talpid-core/src/tunnel_state_machine/connecting_state.rs | 25 | ||||
| -rw-r--r-- | talpid-core/src/tunnel_state_machine/mod.rs | 103 |
2 files changed, 45 insertions, 83 deletions
diff --git a/talpid-core/src/tunnel_state_machine/connecting_state.rs b/talpid-core/src/tunnel_state_machine/connecting_state.rs index 228bc0c6fd..2d0e8d7795 100644 --- a/talpid-core/src/tunnel_state_machine/connecting_state.rs +++ b/talpid-core/src/tunnel_state_machine/connecting_state.rs @@ -262,14 +262,17 @@ impl ConnectingState { self.into_connected_state_bootstrap(metadata), )), Ok(_) => SameState(self), - Err(_) => NewState(DisconnectingState::enter( - shared_values, - ( - self.close_handle, - self.tunnel_close_event, - AfterDisconnect::Reconnect(self.tunnel_parameters), - ), - )), + Err(_) => { + debug!("The OpenVPN tunnel event plugin disconnected"); + NewState(DisconnectingState::enter( + shared_values, + ( + self.close_handle, + self.tunnel_close_event, + AfterDisconnect::Reconnect(self.tunnel_parameters), + ), + )) + } } } @@ -277,16 +280,14 @@ impl ConnectingState { mut self, shared_values: &mut SharedTunnelStateValues, ) -> EventConsequence<Self> { - use self::EventConsequence::*; - match self.tunnel_close_event.poll() { Ok(Async::Ready(_)) => {} - Ok(Async::NotReady) => return NoEvents(self), + Ok(Async::NotReady) => return EventConsequence::NoEvents(self), Err(_cancelled) => warn!("Tunnel monitor thread has stopped unexpectedly"), } info!("Tunnel closed. Reconnecting."); - NewState(ConnectingState::enter( + EventConsequence::NewState(ConnectingState::enter( shared_values, self.tunnel_parameters, )) diff --git a/talpid-core/src/tunnel_state_machine/mod.rs b/talpid-core/src/tunnel_state_machine/mod.rs index f1ab145137..3338d3c4cc 100644 --- a/talpid-core/src/tunnel_state_machine/mod.rs +++ b/talpid-core/src/tunnel_state_machine/mod.rs @@ -7,7 +7,6 @@ mod connecting_state; mod disconnected_state; mod disconnecting_state; -use std::fmt::{Debug, Formatter, Result as FmtResult}; use std::path::{Path, PathBuf}; use std::sync::mpsc as sync_mpsc; use std::thread; @@ -152,8 +151,7 @@ impl TunnelStateMachine { NetworkSecurity::new(cache_dir).chain_err(|| ErrorKind::NetworkSecurityError)?; let mut shared_values = SharedTunnelStateValues { security }; - let initial_state = TunnelStateWrapper::new(&mut shared_values, ()); - + let (initial_state, _) = DisconnectedState::enter(&mut shared_values, ()); Ok(TunnelStateMachine { current_state: Some(initial_state), commands, @@ -281,82 +279,45 @@ trait TunnelState: Into<TunnelStateWrapper> + Sized { ) -> EventConsequence<Self>; } -/// Valid states of the tunnel. -/// -/// All implementations must implement `TunnelState` so that they can handle events and -/// commands in order to advance the state machine. -enum TunnelStateWrapper { - Disconnected(DisconnectedState), - Connecting(ConnectingState), - Connected(ConnectedState), - Disconnecting(DisconnectingState), - Blocked(BlockedState), -} - -impl TunnelStateWrapper { - fn new( - shared_values: &mut SharedTunnelStateValues, - bootstrap: <DisconnectedState as TunnelState>::Bootstrap, - ) -> TunnelStateWrapper { - let (new_state, _transition) = DisconnectedState::enter(shared_values, bootstrap); +macro_rules! state_wrapper { + (enum $wrapper_name:ident { $($state_variant:ident($state_type:ident)),* $(,)* }) => { + /// Valid states of the tunnel. + /// + /// All implementations must implement `TunnelState` so that they can handle events and + /// commands in order to advance the state machine. + enum $wrapper_name { + $($state_variant($state_type),)* + } - new_state - } + $(impl From<$state_type> for $wrapper_name { + fn from(state: $state_type) -> Self { + $wrapper_name::$state_variant(state) + } + })* - fn handle_event( - self, - commands: &mut mpsc::UnboundedReceiver<TunnelCommand>, - shared_values: &mut SharedTunnelStateValues, - ) -> TunnelStateMachineAction { - macro_rules! handle_event { - ( $($state:ident),* $(,)* ) => { + impl $wrapper_name { + fn handle_event( + self, + commands: &mut mpsc::UnboundedReceiver<TunnelCommand>, + shared_values: &mut SharedTunnelStateValues, + ) -> TunnelStateMachineAction { match self { - $( - TunnelStateWrapper::$state(state) => { - let event_consequence = state.handle_event(commands, shared_values); - TunnelStateMachineAction::from(event_consequence) - } - )* + $($wrapper_name::$state_variant(state) => { + let event_consequence = state.handle_event(commands, shared_values); + TunnelStateMachineAction::from(event_consequence) + })* } } } - - handle_event! { - Disconnected, - Connecting, - Connected, - Disconnecting, - Blocked, - } } } -macro_rules! impl_from_for_tunnel_state { - ($state_variant:ident($state_type:ident)) => { - impl From<$state_type> for TunnelStateWrapper { - fn from(state: $state_type) -> Self { - TunnelStateWrapper::$state_variant(state) - } - } - }; -} - -impl_from_for_tunnel_state!(Disconnected(DisconnectedState)); -impl_from_for_tunnel_state!(Connecting(ConnectingState)); -impl_from_for_tunnel_state!(Connected(ConnectedState)); -impl_from_for_tunnel_state!(Disconnecting(DisconnectingState)); -impl_from_for_tunnel_state!(Blocked(BlockedState)); - -impl Debug for TunnelStateWrapper { - fn fmt(&self, formatter: &mut Formatter) -> FmtResult { - use self::TunnelStateWrapper::*; - - match *self { - Disconnected(_) => write!(formatter, "TunnelStateWrapper::Disconnected(_)"), - Connecting(_) => write!(formatter, "TunnelStateWrapper::Connecting(_)"), - Connected(_) => write!(formatter, "TunnelStateWrapper::Connected(_)"), - Disconnecting(_) => write!(formatter, "TunnelStateWrapper::Disconnecting(_)"), - Blocked(_) => write!(formatter, "TunnelStateWrapper::Blocked(_)"), - } +state_wrapper! { + enum TunnelStateWrapper { + Disconnected(DisconnectedState), + Connecting(ConnectingState), + Connected(ConnectedState), + Disconnecting(DisconnectingState), + Blocked(BlockedState), } } |