Merge branch 'simpler-state-machine'

4 files changed, 48 insertions, 69 deletions

diff --git a/mullvad-daemon/src/tunnel_state_machine/connected_state.rs b/mullvad-daemon/src/tunnel_state_machine/connected_state.rs
index 332608f055..dda19befb7 100644
--- a/mullvad-daemon/src/tunnel_state_machine/connected_state.rs
+++ b/mullvad-daemon/src/tunnel_state_machine/connected_state.rs
@@ -49,7 +49,7 @@ impl ConnectedState {
             allow_lan: self.tunnel_parameters.allow_lan,
         };
 
-        debug!("Set security policy: {:?}", policy);
+        debug!("Setting security policy: {:?}", policy);
         shared_values
             .firewall
             .apply_policy(policy)
diff --git a/mullvad-daemon/src/tunnel_state_machine/connecting_state.rs b/mullvad-daemon/src/tunnel_state_machine/connecting_state.rs
index a564982527..7138bfece9 100644
--- a/mullvad-daemon/src/tunnel_state_machine/connecting_state.rs
+++ b/mullvad-daemon/src/tunnel_state_machine/connecting_state.rs
@@ -67,7 +67,7 @@ impl ConnectingState {
             allow_lan,
         };
 
-        debug!("Set security policy: {:?}", policy);
+        debug!("Setting security policy: {:?}", policy);
         shared_values
             .firewall
             .apply_policy(policy)
diff --git a/mullvad-daemon/src/tunnel_state_machine/disconnected_state.rs b/mullvad-daemon/src/tunnel_state_machine/disconnected_state.rs
index 20abcc7ec2..702d6aefe6 100644
--- a/mullvad-daemon/src/tunnel_state_machine/disconnected_state.rs
+++ b/mullvad-daemon/src/tunnel_state_machine/disconnected_state.rs
@@ -14,7 +14,7 @@ pub struct DisconnectedState;
 
 impl DisconnectedState {
     fn reset_security_policy(shared_values: &mut SharedTunnelStateValues) {
-        debug!("Reset security policy");
+        debug!("Resetting security policy");
         if let Err(error) = shared_values.firewall.reset_policy() {
             let chained_error = Error::with_chain(error, "Failed to reset security policy");
             error!("{}", chained_error.display_chain());
diff --git a/mullvad-daemon/src/tunnel_state_machine/mod.rs b/mullvad-daemon/src/tunnel_state_machine/mod.rs
index 1e84e41d67..f328af6663 100644
--- a/mullvad-daemon/src/tunnel_state_machine/mod.rs
+++ b/mullvad-daemon/src/tunnel_state_machine/mod.rs
@@ -147,7 +147,7 @@ impl TunnelStateMachine {
         let firewall = FirewallProxy::new(cache_dir).chain_err(|| ErrorKind::FirewallError)?;
         let mut shared_values = SharedTunnelStateValues { firewall };
 
-        let initial_state = TunnelStateWrapper::enter(&mut shared_values, ())
+        let initial_state = TunnelStateWrapper::new(&mut shared_values, ())
             .expect("Failed to create initial tunnel state");
 
         Ok(TunnelStateMachine {
@@ -163,28 +163,18 @@ impl Stream for TunnelStateMachine {
     type Error = Error;
 
     fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        let mut state = match self.current_state.take() {
-            Some(state) => state,
-            None => {
-                // State machine has halted
-                return Ok(Async::Ready(None));
-            }
-        };
-
-        loop {
-            let event_consequence = state.handle_event(&mut self.commands, &mut self.shared_values);
-            let action = TunnelStateMachineAction::from(event_consequence);
-
-            match action {
-                TunnelStateMachineAction::Repeat(returned_state) => {
-                    state = returned_state;
+        while let Some(state_wrapper) = self.current_state.take() {
+            match state_wrapper.handle_event(&mut self.commands, &mut self.shared_values) {
+                TunnelStateMachineAction::Repeat(repeat_state_wrapper) => {
+                    self.current_state = Some(repeat_state_wrapper);
                 }
-                TunnelStateMachineAction::Notify(state, result) => {
-                    self.current_state = state;
+                TunnelStateMachineAction::Notify(state_wrapper, result) => {
+                    self.current_state = state_wrapper;
                     return result;
                 }
             }
         }
+        Ok(Async::Ready(None))
     }
 }
 
@@ -202,19 +192,18 @@ enum TunnelStateMachineAction {
     ),
 }
 
-impl From<EventConsequence<TunnelStateWrapper>> for TunnelStateMachineAction {
-    fn from(event_consequence: EventConsequence<TunnelStateWrapper>) -> Self {
+impl<T: TunnelState> From<EventConsequence<T>> for TunnelStateMachineAction {
+    fn from(event_consequence: EventConsequence<T>) -> Self {
         use self::EventConsequence::*;
         use self::TunnelStateMachineAction::*;
 
         match event_consequence {
-            NewState(Ok(state)) | NewState(Err((_, state))) => {
-                let transition = state.info();
-
-                Notify(Some(state), Ok(Async::Ready(Some(transition))))
+            NewState(Ok(state_wrapper)) | NewState(Err((_, state_wrapper))) => {
+                let transition = state_wrapper.info();
+                Notify(Some(state_wrapper), Ok(Async::Ready(Some(transition))))
             }
-            SameState(state) => Repeat(state),
-            NoEvents(state) => Notify(Some(state), Ok(Async::NotReady)),
+            SameState(state) => Repeat(state.into()),
+            NoEvents(state) => Notify(Some(state.into()), Ok(Async::NotReady)),
             Finished => Notify(None, Ok(Async::Ready(None))),
         }
     }
@@ -306,38 +295,9 @@ enum TunnelStateWrapper {
 }
 
 impl TunnelStateWrapper {
-    /// Returns information describing the state.
-    fn info(&self) -> TunnelStateTransition {
-        match *self {
-            TunnelStateWrapper::Disconnected(_) => TunnelStateTransition::Disconnected,
-            TunnelStateWrapper::Connecting(_) => TunnelStateTransition::Connecting,
-            TunnelStateWrapper::Connected(_) => TunnelStateTransition::Connected,
-            TunnelStateWrapper::Disconnecting(_) => TunnelStateTransition::Disconnecting,
-        }
-    }
-}
-
-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 TunnelState for TunnelStateWrapper {
-    type Bootstrap = <DisconnectedState as TunnelState>::Bootstrap;
-
-    fn enter(
+    fn new(
         shared_values: &mut SharedTunnelStateValues,
-        bootstrap: Self::Bootstrap,
+        bootstrap: <DisconnectedState as TunnelState>::Bootstrap,
     ) -> StateEntryResult {
         DisconnectedState::enter(shared_values, bootstrap)
     }
@@ -346,20 +306,14 @@ impl TunnelState for TunnelStateWrapper {
         self,
         commands: &mut mpsc::UnboundedReceiver<TunnelCommand>,
         shared_values: &mut SharedTunnelStateValues,
-    ) -> EventConsequence<TunnelStateWrapper> {
-        use self::EventConsequence::*;
-
+    ) -> TunnelStateMachineAction {
         macro_rules! handle_event {
             ( $($state:ident),* $(,)* ) => {
                 match self {
                     $(
                         TunnelStateWrapper::$state(state) => {
-                            match state.handle_event(commands, shared_values) {
-                                NewState(tunnel_state) => NewState(tunnel_state),
-                                SameState(state) => SameState(TunnelStateWrapper::$state(state)),
-                                NoEvents(state) => NoEvents(TunnelStateWrapper::$state(state)),
-                                Finished => Finished,
-                            }
+                            let event_consequence = state.handle_event(commands, shared_values);
+                            TunnelStateMachineAction::from(event_consequence)
                         }
                     )*
                 }
@@ -373,8 +327,33 @@ impl TunnelState for TunnelStateWrapper {
             Disconnecting,
         }
     }
+
+    /// Returns information describing the state.
+    fn info(&self) -> TunnelStateTransition {
+        match *self {
+            TunnelStateWrapper::Disconnected(_) => TunnelStateTransition::Disconnected,
+            TunnelStateWrapper::Connecting(_) => TunnelStateTransition::Connecting,
+            TunnelStateWrapper::Connected(_) => TunnelStateTransition::Connected,
+            TunnelStateWrapper::Disconnecting(_) => TunnelStateTransition::Disconnecting,
+        }
+    }
 }
 
+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 Debug for TunnelStateWrapper {
     fn fmt(&self, formatter: &mut Formatter) -> FmtResult {
         use self::TunnelStateWrapper::*;