Add TunnelStateTransition and TunnelState enum

4 files changed, 50 insertions, 69 deletions

diff --git a/gui/packages/desktop/src/renderer/app.js b/gui/packages/desktop/src/renderer/app.js
index 7bf5cdf534..18c29f9f20 100644
--- a/gui/packages/desktop/src/renderer/app.js
+++ b/gui/packages/desktop/src/renderer/app.js
@@ -28,13 +28,15 @@ import windowActions from './redux/window/actions';
 
 import type { WindowShapeParameters } from '../main/window-controller';
 import type {
+  AccountToken,
+  TunnelStateTransition,
+  RelaySettingsUpdate,
+  TunnelState,
   DaemonRpcProtocol,
   AccountData,
   ConnectionObserver as DaemonConnectionObserver,
 } from './lib/daemon-rpc';
 import type { ReduxStore } from './redux/store';
-import type { AccountToken, TunnelState, RelaySettingsUpdate } from './lib/daemon-rpc';
-import type { ConnectionState } from './redux/connection/reducers';
 import type { TrayIconType } from '../main/tray-icon-controller';
 
 export default class AppRenderer {
@@ -51,7 +53,7 @@ export default class AppRenderer {
   });
   _connectedToDaemon = false;
   _accountToken: ?AccountToken;
-  _tunnelState: ?TunnelState;
+  _tunnelState: ?TunnelStateTransition;
 
   constructor() {
     const store = configureStore(null, this._memoryHistory);
@@ -545,17 +547,17 @@ export default class AppRenderer {
     ]);
   }
 
-  _onChangeTunnelState(tunnelState: TunnelState) {
+  _onChangeTunnelState(tunnelState: TunnelStateTransition) {
     this._tunnelState = tunnelState;
 
     this._updateConnectionStatus(tunnelState);
-    this._updateConnectionLocation(tunnelState.state);
+    this._updateUserLocation(tunnelState.state);
     this._updateTrayIcon(tunnelState.state);
     this._showNotification(tunnelState.state);
   }
 
-  async _updateConnectionLocation(connectionState: ConnectionState) {
-    if (connectionState === 'connecting' || connectionState === 'disconnected') {
+  async _updateUserLocation(tunnelState: TunnelState) {
+    if (tunnelState === 'connecting' || tunnelState === 'disconnected') {
       try {
         await this._fetchLocation();
       } catch (error) {
@@ -564,43 +566,49 @@ export default class AppRenderer {
     }
   }
 
-  _updateConnectionStatus(tunnelState: TunnelState) {
+  _updateConnectionStatus(stateTransition: TunnelStateTransition) {
     const actions = this._reduxActions;
 
-    switch (tunnelState.state) {
+    switch (stateTransition.state) {
       case 'connecting':
         actions.connection.connecting();
         break;
+
       case 'connected':
         actions.connection.connected();
         break;
+
       case 'disconnecting':
         actions.connection.disconnecting();
         break;
+
       case 'disconnected':
         actions.connection.disconnected();
         break;
+
       case 'blocked':
-        actions.connection.blocked(tunnelState.details);
+        actions.connection.blocked(stateTransition.details);
         break;
+
       default:
-        log.error(`Unexpected TunnelState: ${(tunnelState: empty)}`);
+        log.error(`Unexpected TunnelStateTransition: ${(stateTransition.state: empty)}`);
+        break;
     }
   }
 
-  _updateTrayIcon(connectionState: ConnectionState) {
-    const iconTypes: { [ConnectionState]: TrayIconType } = {
+  _updateTrayIcon(tunnelState: TunnelState) {
+    const iconTypes: { [TunnelState]: TrayIconType } = {
       connected: 'secured',
       connecting: 'securing',
       blocked: 'securing',
     };
-    const type = iconTypes[connectionState] || 'unsecured';
+    const type = iconTypes[tunnelState] || 'unsecured';
 
     ipcRenderer.send('change-tray-icon', type);
   }
 
-  _showNotification(connectionState: ConnectionState) {
-    switch (connectionState) {
+  _showNotification(tunnelState: TunnelState) {
+    switch (tunnelState) {
       case 'connecting':
         this._notificationController.show('Connecting');
         break;
@@ -617,7 +625,7 @@ export default class AppRenderer {
         // no-op
         break;
       default:
-        log.error(`Unexpected ConnectionState: ${(connectionState: empty)}`);
+        log.error(`Unexpected TunnelState: ${(tunnelState: empty)}`);
         return;
     }
   }
diff --git a/gui/packages/desktop/src/renderer/components/Connect.js b/gui/packages/desktop/src/renderer/components/Connect.js
index f06ea86eb1..5849d71249 100644
--- a/gui/packages/desktop/src/renderer/components/Connect.js
+++ b/gui/packages/desktop/src/renderer/components/Connect.js
@@ -335,7 +335,7 @@ export default class Connect extends Component<Props, State> {
       case 'blocked':
         return 'success';
       default:
-        throw new Error(`Invalid ConnectionState: ${(status: empty)}`);
+        throw new Error(`Invalid TunnelState: ${(status: empty)}`);
     }
   }
 
diff --git a/gui/packages/desktop/src/renderer/lib/daemon-rpc.js b/gui/packages/desktop/src/renderer/lib/daemon-rpc.js
index b13da5f2ab..9e4c2c1604 100644
--- a/gui/packages/desktop/src/renderer/lib/daemon-rpc.js
+++ b/gui/packages/desktop/src/renderer/lib/daemon-rpc.js
@@ -47,28 +47,12 @@ export type BlockReason =
   | 'start_tunnel_error'
   | 'no_matching_relay'
   | 'no_account_token';
-export type DisconnectedState = {
-  state: 'disconnected',
-};
-export type ConnectingState = {
-  state: 'connecting',
-};
-export type ConnectedState = {
-  state: 'connected',
-};
-export type DisconnectingState = {
-  state: 'disconnecting',
-};
-export type BlockedState = {
-  state: 'blocked',
-  details: BlockReason,
-};
-export type TunnelState =
-  | DisconnectedState
-  | ConnectingState
-  | ConnectedState
-  | DisconnectingState
-  | BlockedState;
+
+export type TunnelState = 'connecting' | 'connected' | 'disconnecting' | 'disconnected' | 'blocked';
+
+export type TunnelStateTransition =
+  | { state: 'disconnecting' | 'disconnected' | 'connecting' | 'connected' }
+  | { state: 'blocked', details: BlockReason };
 
 export type RelayProtocol = 'tcp' | 'udp';
 export type RelayLocation =
@@ -250,21 +234,14 @@ const allBlockReasons: Array<BlockReason> = [
   'no_matching_relay',
   'no_account_token',
 ];
-const BlockedStateSchema = object({
-  state: enumeration('blocked'),
-  details: enumeration(...allBlockReasons),
-});
-const ConnectedStateSchema = object({ state: enumeration('connected') });
-const ConnectingStateSchema = object({ state: enumeration('connecting') });
-const DisconnectedStateSchema = object({ state: enumeration('disconnected') });
-const DisconnectingStateSchema = object({ state: enumeration('disconnecting') });
-
-const TunnelStateSchema = oneOf(
-  BlockedStateSchema,
-  ConnectedStateSchema,
-  ConnectingStateSchema,
-  DisconnectedStateSchema,
-  DisconnectingStateSchema,
+const TunnelStateTransitionSchema = oneOf(
+  object({
+    state: enumeration('blocked'),
+    details: enumeration(...allBlockReasons),
+  }),
+  object({
+    state: enumeration('connected', 'connecting', 'disconnected', 'disconnecting'),
+  }),
 );
 
 export type AppVersionInfo = {
@@ -301,8 +278,8 @@ export interface DaemonRpcProtocol {
   connectTunnel(): Promise<void>;
   disconnectTunnel(): Promise<void>;
   getLocation(): Promise<Location>;
-  getState(): Promise<TunnelState>;
-  subscribeStateListener((state: ?TunnelState, error: ?Error) => void): Promise<void>;
+  getState(): Promise<TunnelStateTransition>;
+  subscribeStateListener((state: ?TunnelStateTransition, error: ?Error) => void): Promise<void>;
   addOpenConnectionObserver(() => void): ConnectionObserver;
   addCloseConnectionObserver((error: ?Error) => void): ConnectionObserver;
   getAccountHistory(): Promise<Array<AccountToken>>;
@@ -494,19 +471,21 @@ export class DaemonRpc implements DaemonRpcProtocol {
     }
   }
 
-  async getState(): Promise<TunnelState> {
+  async getState(): Promise<TunnelStateTransition> {
     const response = await this._transport.send('get_state');
     try {
-      return validate(TunnelStateSchema, response);
+      return validate(TunnelStateTransitionSchema, response);
     } catch (error) {
       throw new ResponseParseError('Invalid response from get_state', error);
     }
   }
 
-  subscribeStateListener(listener: (state: ?TunnelState, error: ?Error) => void): Promise<void> {
+  subscribeStateListener(
+    listener: (state: ?TunnelStateTransition, error: ?Error) => void,
+  ): Promise<void> {
     return this._transport.subscribe('new_state', (payload) => {
       try {
-        const newState = validate(TunnelStateSchema, payload);
+        const newState = validate(TunnelStateTransitionSchema, payload);
         listener(newState, null);
       } catch (error) {
         listener(null, new ResponseParseError('Invalid payload from new_state', error));
diff --git a/gui/packages/desktop/src/renderer/redux/connection/reducers.js b/gui/packages/desktop/src/renderer/redux/connection/reducers.js
index 71f53b3a4c..9381d5e037 100644
--- a/gui/packages/desktop/src/renderer/redux/connection/reducers.js
+++ b/gui/packages/desktop/src/renderer/redux/connection/reducers.js
@@ -1,16 +1,10 @@
 // @flow
 
 import type { ReduxAction } from '../store';
-import type { Ip } from '../../lib/daemon-rpc';
+import type { TunnelState, Ip } from '../../lib/daemon-rpc';
 
-export type ConnectionState =
-  | 'disconnected'
-  | 'disconnecting'
-  | 'connecting'
-  | 'connected'
-  | 'blocked';
 export type ConnectionReduxState = {
-  status: ConnectionState,
+  status: TunnelState,
   isOnline: boolean,
   ip: ?Ip,
   latitude: ?number,