Replace `DaemonState` with `TunnelStateTransition`

2 files changed, 24 insertions, 32 deletions

diff --git a/gui/packages/desktop/src/renderer/app.js b/gui/packages/desktop/src/renderer/app.js
index e0374f05d5..03fae931dd 100644
--- a/gui/packages/desktop/src/renderer/app.js
+++ b/gui/packages/desktop/src/renderer/app.js
@@ -32,7 +32,7 @@ import type {
   ConnectionObserver as DaemonConnectionObserver,
 } from './lib/daemon-rpc';
 import type { ReduxStore } from './redux/store';
-import type { AccountToken, BackendState, RelaySettingsUpdate } from './lib/daemon-rpc';
+import type { AccountToken, TunnelState, RelaySettingsUpdate } from './lib/daemon-rpc';
 import type { ConnectionState } from './redux/connection/reducers';
 import type { TrayIconType } from '../main/tray-icon-controller';
 
@@ -211,7 +211,7 @@ export default class AppRenderer {
 
     try {
       const currentState = await this._daemonRpc.getState();
-      if (currentState.state === 'secured') {
+      if (currentState === 'connected' || currentState === 'connecting') {
         log.debug('Refusing to connect as connection is already secured');
         actions.connection.connected();
       } else {
@@ -395,7 +395,7 @@ export default class AppRenderer {
 
   async _fetchSecurityState() {
     const securityState = await this._daemonRpc.getState();
-    const connectionState = this._securityStateToConnectionState(securityState);
+    const connectionState = this._tunnelStateToConnectionState(securityState);
     this._updateConnectionState(connectionState);
   }
 
@@ -493,13 +493,9 @@ export default class AppRenderer {
       }
 
       if (newState) {
-        const connectionState = this._securityStateToConnectionState(newState);
+        const connectionState = this._tunnelStateToConnectionState(newState);
 
-        log.debug(
-          `Got new state from daemon {state: ${newState.state}, target_state: ${
-            newState.target_state
-          }}, translated to '${connectionState}'`,
-        );
+        log.debug(`Got new state from daemon '${newState}', translated to '${connectionState}'`);
 
         this._updateConnectionState(connectionState);
         this._refreshStateOnChange();
@@ -539,15 +535,13 @@ export default class AppRenderer {
     }
   }
 
-  _securityStateToConnectionState(backendState: BackendState): ConnectionState {
-    if (backendState.state === 'unsecured' && backendState.target_state === 'secured') {
-      return 'connecting';
-    } else if (backendState.state === 'secured' && backendState.target_state === 'secured') {
-      return 'connected';
-    } else if (backendState.target_state === 'unsecured') {
+  _tunnelStateToConnectionState(tunnelState: TunnelState): ConnectionState {
+    if (tunnelState === 'disconnected' || tunnelState === 'disconnecting') {
       return 'disconnected';
+    } else if (tunnelState === 'connected' || tunnelState === 'connecting') {
+      return tunnelState;
     }
-    throw new Error('Unsupported state/target state combination: ' + JSON.stringify(backendState));
+    throw new Error('Unsupported state/target state combination: ' + JSON.stringify(tunnelState));
   }
 
   _updateConnectionState(connectionState: ConnectionState) {
diff --git a/gui/packages/desktop/src/renderer/lib/daemon-rpc.js b/gui/packages/desktop/src/renderer/lib/daemon-rpc.js
index c403e3fa92..e590534d69 100644
--- a/gui/packages/desktop/src/renderer/lib/daemon-rpc.js
+++ b/gui/packages/desktop/src/renderer/lib/daemon-rpc.js
@@ -41,11 +41,7 @@ const LocationSchema = object({
   mullvad_exit_ip: boolean,
 });
 
-export type SecurityState = 'secured' | 'unsecured';
-export type BackendState = {
-  state: SecurityState,
-  target_state: SecurityState,
-};
+export type TunnelState = 'disconnected' | 'connecting' | 'connected' | 'disconnecting';
 
 export type RelayProtocol = 'tcp' | 'udp';
 export type RelayLocation = {| city: [string, string] |} | {| country: string |};
@@ -200,11 +196,13 @@ const AccountDataSchema = object({
   expiry: string,
 });
 
-const allSecurityStates: Array<SecurityState> = ['secured', 'unsecured'];
-const BackendStateSchema = object({
-  state: enumeration(...allSecurityStates),
-  target_state: enumeration(...allSecurityStates),
-});
+const allTunnelStates: Array<TunnelState> = [
+  'disconnected',
+  'connecting',
+  'connected',
+  'disconnecting',
+];
+const TunnelStateSchema = enumeration(...allTunnelStates);
 
 export type AppVersionInfo = {
   currentIsSupported: boolean,
@@ -240,8 +238,8 @@ export interface DaemonRpcProtocol {
   connectTunnel(): Promise<void>;
   disconnectTunnel(): Promise<void>;
   getLocation(): Promise<Location>;
-  getState(): Promise<BackendState>;
-  subscribeStateListener((state: ?BackendState, error: ?Error) => void): Promise<void>;
+  getState(): Promise<TunnelState>;
+  subscribeStateListener((state: ?TunnelState, error: ?Error) => void): Promise<void>;
   addOpenConnectionObserver(() => void): ConnectionObserver;
   addCloseConnectionObserver((error: ?Error) => void): ConnectionObserver;
   authenticate(sharedSecret: string): Promise<void>;
@@ -442,19 +440,19 @@ export class DaemonRpc implements DaemonRpcProtocol {
     }
   }
 
-  async getState(): Promise<BackendState> {
+  async getState(): Promise<TunnelState> {
     const response = await this._transport.send('get_state');
     try {
-      return validate(BackendStateSchema, response);
+      return validate(TunnelStateSchema, response);
     } catch (error) {
       throw new ResponseParseError('Invalid response from get_state', error);
     }
   }
 
-  subscribeStateListener(listener: (state: ?BackendState, error: ?Error) => void): Promise<void> {
+  subscribeStateListener(listener: (state: ?TunnelState, error: ?Error) => void): Promise<void> {
     return this._transport.subscribe('new_state', (payload) => {
       try {
-        const newState = validate(BackendStateSchema, payload);
+        const newState = validate(TunnelStateSchema, payload);
         listener(newState, null);
       } catch (error) {
         listener(null, new ResponseParseError('Invalid payload from new_state', error));