Include after disconnect action in new state event

4 files changed, 35 insertions, 6 deletions

diff --git a/gui/packages/desktop/src/renderer/lib/daemon-rpc.js b/gui/packages/desktop/src/renderer/lib/daemon-rpc.js
index d984bfbf76..cece79f783 100644
--- a/gui/packages/desktop/src/renderer/lib/daemon-rpc.js
+++ b/gui/packages/desktop/src/renderer/lib/daemon-rpc.js
@@ -51,10 +51,13 @@ export type BlockReason =
     }
   | { reason: 'auth_failed', details: ?string };
 
+export type AfterDisconnect = 'nothing' | 'block' | 'reconnect';
+
 export type TunnelState = 'connecting' | 'connected' | 'disconnecting' | 'disconnected' | 'blocked';
 
 export type TunnelStateTransition =
-  | { state: 'disconnecting' | 'disconnected' | 'connecting' | 'connected' }
+  | { state: 'disconnected' | 'connecting' | 'connected' }
+  | { state: 'disconnecting', details: AfterDisconnect }
   | { state: 'blocked', details: BlockReason };
 
 export type RelayProtocol = 'tcp' | 'udp';
@@ -235,6 +238,10 @@ const AccountDataSchema = object({
 
 const TunnelStateTransitionSchema = oneOf(
   object({
+    state: enumeration('disconnecting'),
+    details: enumeration('nothing', 'block', 'reconnect'),
+  }),
+  object({
     state: enumeration('blocked'),
     details: oneOf(
       object({
@@ -249,7 +256,7 @@ const TunnelStateTransitionSchema = oneOf(
     ),
   }),
   object({
-    state: enumeration('connected', 'connecting', 'disconnected', 'disconnecting'),
+    state: enumeration('connected', 'connecting', 'disconnected'),
   }),
 );
 
diff --git a/mullvad-cli/src/cmds/status.rs b/mullvad-cli/src/cmds/status.rs
index fbf4e23e1a..06d75380aa 100644
--- a/mullvad-cli/src/cmds/status.rs
+++ b/mullvad-cli/src/cmds/status.rs
@@ -47,7 +47,7 @@ fn print_state(state: &TunnelStateTransition) {
         Connected => println!("Connected"),
         Connecting => println!("Connecting..."),
         Disconnected => println!("Disconnected"),
-        Disconnecting => println!("Disconnecting..."),
+        Disconnecting(_) => println!("Disconnecting..."),
     }
 }
 
diff --git a/talpid-core/src/tunnel_state_machine/disconnecting_state.rs b/talpid-core/src/tunnel_state_machine/disconnecting_state.rs
index a7f20ca5ea..47467e3090 100644
--- a/talpid-core/src/tunnel_state_machine/disconnecting_state.rs
+++ b/talpid-core/src/tunnel_state_machine/disconnecting_state.rs
@@ -4,7 +4,7 @@ use error_chain::ChainedError;
 use futures::sync::{mpsc, oneshot};
 use futures::{Async, Future, Stream};
 
-use talpid_types::tunnel::BlockReason;
+use talpid_types::tunnel::{ActionAfterDisconnect, BlockReason};
 
 use super::{
     BlockedState, ConnectingState, DisconnectedState, EventConsequence, ResultExt,
@@ -103,12 +103,14 @@ impl TunnelState for DisconnectingState {
             }
         });
 
+        let action_after_disconnect = after_disconnect.action();
+
         (
             TunnelStateWrapper::from(DisconnectingState {
                 exited,
                 after_disconnect,
             }),
-            TunnelStateTransition::Disconnecting,
+            TunnelStateTransition::Disconnecting(action_after_disconnect),
         )
     }
 
@@ -128,3 +130,14 @@ pub enum AfterDisconnect {
     Block(BlockReason, bool),
     Reconnect(TunnelParameters),
 }
+
+impl AfterDisconnect {
+    /// Build event representation of the action that will be taken after the disconnection.
+    pub fn action(&self) -> ActionAfterDisconnect {
+        match self {
+            AfterDisconnect::Nothing => ActionAfterDisconnect::Nothing,
+            AfterDisconnect::Block(..) => ActionAfterDisconnect::Block,
+            AfterDisconnect::Reconnect(_) => ActionAfterDisconnect::Reconnect,
+        }
+    }
+}
diff --git a/talpid-types/src/tunnel.rs b/talpid-types/src/tunnel.rs
index 6a1c7a55ed..3d911f640a 100644
--- a/talpid-types/src/tunnel.rs
+++ b/talpid-types/src/tunnel.rs
@@ -12,11 +12,20 @@ pub enum TunnelStateTransition {
     /// Tunnel is connected.
     Connected,
     /// Disconnecting tunnel.
-    Disconnecting,
+    Disconnecting(ActionAfterDisconnect),
     /// Tunnel is disconnected but secured by blocking all connections.
     Blocked(BlockReason),
 }
 
+/// Action that will be taken after disconnection is complete.
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ActionAfterDisconnect {
+    Nothing,
+    Block,
+    Reconnect,
+}
+
 impl TunnelStateTransition {
     pub fn is_blocked(&self) -> bool {
         match self {