add rpc system to improve ipc

app/src/actions/ConnectionManager.ts

@@ -9,14 +9,13 @@ import {
 import { default as persistentStorage, StorageIdentifier } from '../utils/PersistentStorage'
 import { Dispatch } from 'redux'
 import { showError } from './Global'
-import * as electron from 'electron'
 import { promises as fsPromise } from 'fs'
 import * as path from 'path'
 import { ActionTypes, Action } from '../reducers/ConnectionManager'
 import { Subscription } from '../../../backend/src/DataSource/MqttSource'
 import { connectionsMigrator } from './migrations/Connection'
-import { EventDispatcher, openDialogResponse, OpenDialogResponse, rendererEvents, requestOpenDialog } from '../../../events'
-import { v4 } from 'uuid'
+import { rendererRpc } from '../../../events'
+import { makeOpenDialogRpc } from '../../../events/OpenDialogRequest'
 
 export interface ConnectionDictionary {
   [s: string]: ConnectionOptions
@@ -74,29 +73,11 @@ async function openCertificate(): Promise<CertificateParameters> {
     certificateSizeDoesNotMatch: 'Certificate size larger/smaller then expected.',
   }
 
-  let requestId = v4();
-
-  const response = new Promise<OpenDialogResponse>((resolve, reject) => {
-    let callback = (result: OpenDialogResponse) => {
-      rendererEvents.unsubscribe(openDialogResponse(), callback)
-      if (result.identifier == requestId) {
-        resolve(result)
-      } else {
-        reject(new Error("Unexpected file select"))
-      }
-    }
-    rendererEvents.subscribe(openDialogResponse(), callback)
+  const openDialogReturnValue = await rendererRpc.call(makeOpenDialogRpc(), {
+    properties: ['openFile'],
+    securityScopedBookmarks: true,
   })
 
-  rendererEvents.emit(requestOpenDialog(), {
-    identifier: requestId,
-    options: {
-      properties: ['openFile'],
-      securityScopedBookmarks: true,
-    }
-  })
-  const openDialogReturnValue = (await response).result;
-
   const selectedFile = openDialogReturnValue.filePaths && openDialogReturnValue.filePaths[0]
   if (!selectedFile) {
     throw rejectReasons.noCertificateSelected

app/src/components/ConnectionSetup/CertificateFileSelection.tsx

@@ -1,7 +1,5 @@
 import * as React from 'react'
-import Add from '@material-ui/icons/Add'
 import ClearAdornment from '../helper/ClearAdornment'
-import Delete from '@material-ui/icons/Delete'
 import Lock from '@material-ui/icons/Lock'
 import { bindActionCreators } from 'redux'
 import { Button, Theme, Tooltip, Typography } from '@material-ui/core'

app/src/components/Demo/index.tsx

@@ -5,7 +5,7 @@ let heapdump: any
 
 function writeHeapdump(path?: string) {
   if (!heapdump) {
-    //heapdump = require('heapdump')
+    //<heapdump = require('heapdump')
   }
 
   heapdump.writeSnapshot(path || `${Date.now()}.heapsnapshot`)

app/src/components/UpdateNotifier.tsx

@@ -13,6 +13,7 @@ import { Theme, withStyles } from '@material-ui/core/styles'
 import { updateNotifierActions } from '../actions'
 
 import { Button, IconButton, Modal, Paper, Snackbar, SnackbarContent, Typography } from '@material-ui/core'
+import { rendererRpc, getAppVersion } from '../../../events'
 
 interface Props {
   showUpdateNotification: boolean
@@ -50,18 +51,21 @@ class UpdateNotifier extends React.PureComponent<Props, State> {
     super(props)
     this.state = { newerVersions: [] }
 
-    const ownVersion = electron.app.getVersion()
-    this.fetchReleases().then(releases => {
-      const newerVersions = releases
-        .filter(release => this.allowPrereleaseIfOwnVersionIsBeta(release, ownVersion))
-        .filter(release => compareVersions(release.tag_name, ownVersion) > 0)
-        .sort((a, b) => compareVersions(b.tag_name, a.tag_name))
+    this.checkForUpdates()
+  }
 
-      if (newerVersions.length > 0) {
-        this.setState({ newerVersions })
-        this.props.actions.showUpdateNotification(true)
-      }
-    })
+  private async checkForUpdates() {
+    const ownVersion = await rendererRpc.call(getAppVersion, undefined, 10000);
+    const releases = await this.fetchReleases();
+    const newerVersions = releases
+      .filter(release => this.allowPrereleaseIfOwnVersionIsBeta(release, ownVersion))
+      .filter(release => compareVersions(release.tag_name, ownVersion) > 0)
+      .sort((a, b) => compareVersions(b.tag_name, a.tag_name))
+
+    if (newerVersions.length > 0) {
+      this.setState({ newerVersions })
+      this.props.actions.showUpdateNotification(true)
+    }
   }
 
   private allowPrereleaseIfOwnVersionIsBeta(release: GithubRelease, ownVersion: string) {

app/src/utils/PersistentStorage.ts

@@ -1,12 +1,9 @@
-import { rendererEvents } from '../../../events'
-import { v4 } from 'uuid'
+import { rendererRpc } from '../../../events'
 
 import {
   storageStoreEvent,
-  makeStorageResponseEvent,
   storageLoadEvent,
   storageClearEvent,
-  makeStorageAcknowledgementEvent,
 } from '../../../events/StorageEvents'
 
 export interface StorageIdentifier<Model> {
@@ -20,71 +17,23 @@ export interface PersistentStorage {
 }
 
 class RemoteStorage implements PersistentStorage {
-  private timeoutCallback(event: any, callback: any, reject: any) {
-    setTimeout(() => {
-      reject('remote storage timeout')
-      rendererEvents.unsubscribe(event, callback)
-    }, 10000)
-  }
-
-  private expectAck(transactionId: string): Promise<void> {
-    const ack = makeStorageAcknowledgementEvent(transactionId)
-    return new Promise<void>((resolve, reject) => {
-      const callback = (msg: any) => {
-        if (msg && msg.error) {
-          reject(msg.error)
-        } else {
-          resolve()
-        }
-        rendererEvents.unsubscribe(ack, callback)
-      }
-      rendererEvents.subscribe(ack, callback)
-      this.timeoutCallback(ack, callback, reject)
-    })
-  }
-
   public store<Model>(identifier: StorageIdentifier<Model>, data: Model): Promise<void> {
-    const transactionId = v4()
-    const expectation = this.expectAck(transactionId)
-    rendererEvents.emit(storageStoreEvent, {
+    return rendererRpc.call(storageStoreEvent, {
       data,
-      transactionId,
       store: identifier.id,
     })
-    return expectation
   }
 
-  public load<Model>(identifier: StorageIdentifier<Model>): Promise<Model | undefined> {
-    const transactionId = v4()
-    const responseEvent = makeStorageResponseEvent(transactionId)
-
-    const promise = new Promise<Model>((resolve, reject) => {
-      const callback = (msg: any) => {
-        if (msg.error) {
-          reject(msg.error)
-        } else {
-          resolve(msg.data)
-        }
-        rendererEvents.unsubscribe(responseEvent, callback)
-      }
-      rendererEvents.subscribe(responseEvent, callback)
-      this.timeoutCallback(responseEvent, callback, reject)
-    })
-
-    rendererEvents.emit(storageLoadEvent, {
-      transactionId,
+  public async load<Model>(identifier: StorageIdentifier<Model>): Promise<Model | undefined> {
+    const result = await rendererRpc.call(storageLoadEvent, {
       store: identifier.id,
-    })
+    }, 10000)
 
-    return promise
+    return (result as any).data
   }
 
   public clear(): Promise<void> {
-    const transactionId = v4()
-    const expectation = this.expectAck(transactionId)
-
-    rendererEvents.emit(storageClearEvent, { transactionId })
-    return expectation
+    return rendererRpc.call(storageClearEvent, undefined, 10000)
   }
 }