add more specific IPC helpers

Signed-off-by: Sebastian Malton <sebastian@malton.name>

src/common/base-store.ts

@@ -22,12 +22,12 @@
 import path from "path";
 import Config from "conf";
 import type { Options as ConfOptions } from "conf/dist/source/types";
-import { app, ipcMain, IpcMainEvent, ipcRenderer, IpcRendererEvent, remote } from "electron";
+import { app, ipcMain, ipcRenderer, remote } from "electron";
 import { IReactionOptions, observable, reaction, runInAction, when } from "mobx";
 import Singleton from "./utils/singleton";
 import { getAppVersion } from "./utils/app-version";
 import logger from "../main/logger";
-import { broadcastMessage, subscribeToBroadcast, unsubscribeFromBroadcast } from "./ipc";
+import { broadcastMessage, ipcMainOn, ipcRendererOn } from "./ipc";
 import isEqual from "lodash/isEqual";
 
 export interface BaseStoreParams<T = any> extends ConfOptions<T> {
@@ -118,23 +118,17 @@ export abstract class BaseStore<T = any> extends Singleton {
     );
 
     if (ipcMain) {
-      const callback = (event: IpcMainEvent, model: T) => {
+      this.syncDisposers.push(ipcMainOn(this.syncMainChannel, (event, model: T) => {
         logger.silly(`[STORE]: SYNC ${this.name} from renderer`, { model });
         this.onSync(model);
-      };
-
-      subscribeToBroadcast(this.syncMainChannel, callback);
-      this.syncDisposers.push(() => unsubscribeFromBroadcast(this.syncMainChannel, callback));
+      }));
     }
 
     if (ipcRenderer) {
-      const callback = (event: IpcRendererEvent, model: T) => {
+      this.syncDisposers.push(ipcRendererOn(this.syncRendererChannel, (event, model: T) => {
         logger.silly(`[STORE]: SYNC ${this.name} from main`, { model });
         this.onSyncFromMain(model);
-      };
-
-      subscribeToBroadcast(this.syncRendererChannel, callback);
-      this.syncDisposers.push(() => unsubscribeFromBroadcast(this.syncRendererChannel, callback));
+      }));
     }
   }
 

src/common/cluster-ipc.ts

@@ -19,7 +19,6 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-import { handleRequest } from "./ipc";
 import { ClusterId, ClusterStore } from "./cluster-store";
 import { appEventBus } from "./event-bus";
 import { ResourceApplier } from "../main/resource-applier";
@@ -34,13 +33,13 @@ export const clusterKubectlApplyAllHandler = "cluster:kubectl-apply-all";
 export const clusterKubectlDeleteAllHandler = "cluster:kubectl-delete-all";
 
 if (ipcMain) {
-  handleRequest(clusterActivateHandler, (event, clusterId: ClusterId, force = false) => {
+  ipcMain.handle(clusterActivateHandler, (event, clusterId: ClusterId, force = false) => {
     return ClusterStore.getInstance()
       .getById(clusterId)
       ?.activate(force);
   });
 
-  handleRequest(clusterSetFrameIdHandler, (event: IpcMainInvokeEvent, clusterId: ClusterId) => {
+  ipcMain.handle(clusterSetFrameIdHandler, (event: IpcMainInvokeEvent, clusterId: ClusterId) => {
     const cluster = ClusterStore.getInstance().getById(clusterId);
 
     if (cluster) {
@@ -49,13 +48,13 @@ if (ipcMain) {
     }
   });
 
-  handleRequest(clusterRefreshHandler, (event, clusterId: ClusterId) => {
+  ipcMain.handle(clusterRefreshHandler, (event, clusterId: ClusterId) => {
     return ClusterStore.getInstance()
       .getById(clusterId)
       ?.refresh({ refreshMetadata: true });
   });
 
-  handleRequest(clusterDisconnectHandler, (event, clusterId: ClusterId) => {
+  ipcMain.handle(clusterDisconnectHandler, (event, clusterId: ClusterId) => {
     appEventBus.emit({name: "cluster", action: "stop"});
     const cluster = ClusterStore.getInstance().getById(clusterId);
 
@@ -65,7 +64,7 @@ if (ipcMain) {
     }
   });
 
-  handleRequest(clusterKubectlApplyAllHandler, async (event, clusterId: ClusterId, resources: string[], extraArgs: string[]) => {
+  ipcMain.handle(clusterKubectlApplyAllHandler, async (event, clusterId: ClusterId, resources: string[], extraArgs: string[]) => {
     appEventBus.emit({name: "cluster", action: "kubectl-apply-all"});
     const cluster = ClusterStore.getInstance().getById(clusterId);
 
@@ -84,7 +83,7 @@ if (ipcMain) {
     }
   });
 
-  handleRequest(clusterKubectlDeleteAllHandler, async (event, clusterId: ClusterId, resources: string[], extraArgs: string[]) => {
+  ipcMain.handle(clusterKubectlDeleteAllHandler, async (event, clusterId: ClusterId, resources: string[], extraArgs: string[]) => {
     appEventBus.emit({name: "cluster", action: "kubectl-delete-all"});
     const cluster = ClusterStore.getInstance().getById(clusterId);
 

src/common/cluster-store.ts

@@ -31,7 +31,7 @@ import { appEventBus } from "./event-bus";
 import { dumpConfigYaml } from "./kube-helpers";
 import { saveToAppFiles } from "./utils/saveToAppFiles";
 import type { KubeConfig } from "@kubernetes/client-node";
-import { handleRequest, requestMain, subscribeToBroadcast, unsubscribeAllFromBroadcast } from "./ipc";
+import { ipcMainOn, ipcRendererOn, requestMain } from "./ipc";
 import type { ResourceType } from "../renderer/components/cluster-settings/components/cluster-metrics-setting";
 import { disposer, noop } from "./utils";
 
@@ -114,6 +114,8 @@ export interface ClusterPrometheusPreferences {
 }
 
 export class ClusterStore extends BaseStore<ClusterStoreModel> {
+  private static StateChannel = "cluster:state";
+
   static get storedKubeConfigFolder(): string {
     return path.resolve((app || remote.app).getPath("userData"), "kubeconfigs");
   }
@@ -170,7 +172,7 @@ export class ClusterStore extends BaseStore<ClusterStoreModel> {
         }
       });
     } else if (ipcMain) {
-      handleRequest(ClusterStore.stateRequestChannel, (): clusterStateSync[] => {
+      ipcMain.handle(ClusterStore.stateRequestChannel, (): clusterStateSync[] => {
         const states: clusterStateSync[] = [];
 
         this.clustersList.forEach((cluster) => {
@@ -191,17 +193,25 @@ export class ClusterStore extends BaseStore<ClusterStoreModel> {
         reaction(() => this.connectedClustersList, () => {
           this.pushState();
         }),
-        () => unsubscribeAllFromBroadcast("cluster:state"),
       );
     }
   }
 
+  handleStateChange = (event: any, clusterId: string, state: ClusterState) => {
+    logger.silly(`[CLUSTER-STORE]: received push-state at ${location.host} (${webFrame.routingId})`, clusterId, state);
+    this.getById(clusterId)?.setState(state);
+  };
+
   registerIpcListener() {
     logger.info(`[CLUSTER-STORE] start to listen (${webFrame.routingId})`);
-    subscribeToBroadcast("cluster:state", (event, clusterId: string, state: ClusterState) => {
-      logger.silly(`[CLUSTER-STORE]: received push-state at ${location.host} (${webFrame.routingId})`, clusterId, state);
-      this.getById(clusterId)?.setState(state);
-    });
+
+    if (ipcMain) {
+      this.disposer.push(ipcMainOn(ClusterStore.StateChannel, this.handleStateChange));
+    }
+
+    if (ipcRenderer) {
+      this.disposer.push(ipcRendererOn(ClusterStore.StateChannel, this.handleStateChange));
+    }
   }
 
   unregisterIpcListener() {

src/common/ipc/ipc.ts

@@ -27,13 +27,10 @@ import { ipcMain, ipcRenderer, webContents, remote } from "electron";
 import { toJS } from "mobx";
 import logger from "../../main/logger";
 import { ClusterFrameInfo, clusterFrameMap } from "../cluster-frames";
+import type { Disposer } from "../utils";
 
 const subFramesChannel = "ipc:get-sub-frames";
 
-export function handleRequest(channel: string, listener: (event: Electron.IpcMainInvokeEvent, ...args: any[]) => any) {
-  ipcMain.handle(channel, listener);
-}
-
 export async function requestMain(channel: string, ...args: any[]) {
   return ipcRenderer.invoke(channel, ...args);
 }
@@ -71,34 +68,18 @@ export function broadcastMessage(channel: string, ...args: any[]) {
     });
 }
 
-export function subscribeToBroadcast(channel: string, listener: (...args: any[]) => any) {
-  if (ipcRenderer) {
-    ipcRenderer.on(channel, listener);
-  } else if (ipcMain) {
-    ipcMain.on(channel, listener);
-  }
+export function ipcMainOn(channel: string, listener: (event: Electron.IpcMainEvent, ...args: any[]) => any): Disposer {
+  ipcMain.on(channel, listener);
 
-  return listener;
+  return () => ipcMain.off(channel, listener);
 }
 
-export function unsubscribeFromBroadcast(channel: string, listener: (...args: any[]) => any) {
-  if (ipcRenderer) {
-    ipcRenderer.off(channel, listener);
-  } else if (ipcMain) {
-    ipcMain.off(channel, listener);
-  }
-}
+export function ipcRendererOn(channel: string, listener: (event: Electron.IpcRendererEvent, ...args: any[]) => any): Disposer {
+  ipcRenderer.on(channel, listener);
 
-export function unsubscribeAllFromBroadcast(channel: string) {
-  if (ipcRenderer) {
-    ipcRenderer.removeAllListeners(channel);
-  } else if (ipcMain) {
-    ipcMain.removeAllListeners(channel);
-  }
+  return () => ipcRenderer.off(channel, listener);
 }
 
 export function bindBroadcastHandlers() {
-  handleRequest(subFramesChannel, () => {
-    return getSubFrames();
-  });
+  ipcMain.handle(subFramesChannel, getSubFrames);
 }

src/extensions/extension-discovery.ts

@@ -20,13 +20,13 @@
  */
 
 import { watch } from "chokidar";
-import { ipcRenderer } from "electron";
+import { ipcMain, ipcRenderer } from "electron";
 import { EventEmitter } from "events";
 import fse from "fs-extra";
 import { observable, reaction, toJS, when } from "mobx";
 import os from "os";
 import path from "path";
-import { broadcastMessage, handleRequest, requestMain, subscribeToBroadcast } from "../common/ipc";
+import { broadcastMessage, ipcRendererOn, requestMain } from "../common/ipc";
 import { Singleton } from "../common/utils";
 import logger from "../main/logger";
 import { ExtensionInstallationStateStore } from "../renderer/components/+extensions/extension-install.store";
@@ -130,13 +130,13 @@ export class ExtensionDiscovery extends Singleton {
     };
 
     requestMain(ExtensionDiscovery.extensionDiscoveryChannel).then(onMessage);
-    subscribeToBroadcast(ExtensionDiscovery.extensionDiscoveryChannel, (_event, message: ExtensionDiscoveryChannelMessage) => {
+    ipcRendererOn(ExtensionDiscovery.extensionDiscoveryChannel, (_event, message: ExtensionDiscoveryChannelMessage) => {
       onMessage(message);
     });
   }
 
   async initMain() {
-    handleRequest(ExtensionDiscovery.extensionDiscoveryChannel, () => this.toJSON());
+    ipcMain.handle(ExtensionDiscovery.extensionDiscoveryChannel, () => this.toJSON());
 
     reaction(() => this.toJSON(), () => {
       this.broadcast();

src/extensions/extension-loader.ts

@@ -19,13 +19,13 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-import { app, ipcRenderer, remote } from "electron";
+import { app, ipcMain, ipcRenderer, remote } from "electron";
 import { EventEmitter } from "events";
 import { isEqual } from "lodash";
 import { action, computed, observable, reaction, toJS, when } from "mobx";
 import path from "path";
 import { getHostedCluster } from "../common/cluster-store";
-import { broadcastMessage, handleRequest, requestMain, subscribeToBroadcast } from "../common/ipc";
+import { broadcastMessage, ipcMainOn, ipcRendererOn, requestMain } from "../common/ipc";
 import { Singleton } from "../common/utils";
 import logger from "../main/logger";
 import type { InstalledExtension } from "./extension-discovery";
@@ -164,11 +164,11 @@ export class ExtensionLoader extends Singleton {
       this.broadcastExtensions();
     });
 
-    handleRequest(ExtensionLoader.extensionsMainChannel, () => {
+    ipcMain.handle(ExtensionLoader.extensionsMainChannel, () => {
       return Array.from(this.toJSON());
     });
 
-    subscribeToBroadcast(ExtensionLoader.extensionsRendererChannel, (_event, extensions: [LensExtensionId, InstalledExtension][]) => {
+    ipcMainOn(ExtensionLoader.extensionsRendererChannel, (event, extensions: [LensExtensionId, InstalledExtension][]) => {
       this.syncExtensions(extensions);
     });
   }
@@ -193,7 +193,7 @@ export class ExtensionLoader extends Singleton {
     });
 
     requestMain(ExtensionLoader.extensionsMainChannel).then(extensionListHandler);
-    subscribeToBroadcast(ExtensionLoader.extensionsMainChannel, (_event, extensions: [LensExtensionId, InstalledExtension][]) => {
+    ipcRendererOn(ExtensionLoader.extensionsMainChannel, (event, extensions: [LensExtensionId, InstalledExtension][]) => {
       extensionListHandler(extensions);
     });
   }

src/main/catalog-pusher.ts

@@ -20,10 +20,10 @@
  */
 
 import { reaction, toJS } from "mobx";
-import { broadcastMessage, subscribeToBroadcast, unsubscribeFromBroadcast } from "../common/ipc";
+import { broadcastMessage, ipcMainOn } from "../common/ipc";
 import type { CatalogEntityRegistry} from "../common/catalog";
 import "../common/catalog-entities/kubernetes-cluster";
-import type { Disposer } from "../common/utils";
+import { disposer } from "../common/utils";
 
 export class CatalogPusher {
   static init(catalog: CatalogEntityRegistry) {
@@ -33,20 +33,15 @@ export class CatalogPusher {
   private constructor(private catalog: CatalogEntityRegistry) {}
 
   init() {
-    const disposers: Disposer[] = [];
-
-    disposers.push(reaction(() => toJS(this.catalog.items, { recurseEverything: true }), (items) => {
-      broadcastMessage("catalog:items", items);
-    }, {
-      fireImmediately: true,
-    }));
-
-    const listener = subscribeToBroadcast("catalog:broadcast", () => {
-      broadcastMessage("catalog:items", toJS(this.catalog.items, { recurseEverything: true }));
-    });
-
-    disposers.push(() => unsubscribeFromBroadcast("catalog:broadcast", listener));
-
-    return disposers;
+    return disposer(
+      reaction(() => toJS(this.catalog.items, { recurseEverything: true }), (items) => {
+        broadcastMessage("catalog:items", items);
+      }, {
+        fireImmediately: true,
+      }),
+      ipcMainOn("catalog:broadcast", () => {
+        broadcastMessage("catalog:items", toJS(this.catalog.items, { recurseEverything: true }));
+      })
+    );
   }
 }

src/main/window-manager.ts

@@ -24,7 +24,7 @@ import { observable } from "mobx";
 import { app, BrowserWindow, dialog, shell, webContents } from "electron";
 import windowStateKeeper from "electron-window-state";
 import { appEventBus } from "../common/event-bus";
-import { subscribeToBroadcast } from "../common/ipc";
+import { ipcMainOn } from "../common/ipc";
 import { initMenu } from "./menu";
 import { initTray } from "./tray";
 import { Singleton } from "../common/utils";
@@ -140,7 +140,7 @@ export class WindowManager extends Singleton {
 
   protected bindEvents() {
     // track visible cluster from ui
-    subscribeToBroadcast(IpcRendererNavigationEvents.CLUSTER_VIEW_CURRENT_ID, (event, clusterId: ClusterId) => {
+    ipcMainOn(IpcRendererNavigationEvents.CLUSTER_VIEW_CURRENT_ID, (event, clusterId: ClusterId) => {
       this.activeClusterId = clusterId;
     });
   }

src/renderer/api/catalog-entity-registry.ts

@@ -20,7 +20,7 @@
  */
 
 import { action, observable } from "mobx";
-import { broadcastMessage, subscribeToBroadcast } from "../../common/ipc";
+import { broadcastMessage, ipcRendererOn } from "../../common/ipc";
 import { CatalogCategory, CatalogEntity, CatalogEntityData, catalogCategoryRegistry, CatalogCategoryRegistry, CatalogEntityKindData } from "../../common/catalog";
 import "../../common/catalog-entities";
 
@@ -31,7 +31,7 @@ export class CatalogEntityRegistry {
   constructor(private categoryRegistry: CatalogCategoryRegistry) {}
 
   init() {
-    subscribeToBroadcast("catalog:items", (ev, items: (CatalogEntityData & CatalogEntityKindData)[]) => {
+    ipcRendererOn("catalog:items", (ev, items: (CatalogEntityData & CatalogEntityKindData)[]) => {
       this.updateItems(items);
     });
     broadcastMessage("catalog:broadcast");

src/renderer/components/cluster-manager/cluster-status.tsx

@@ -26,7 +26,7 @@ import React from "react";
 import { observer } from "mobx-react";
 import { ipcRenderer } from "electron";
 import { computed, observable } from "mobx";
-import { requestMain, subscribeToBroadcast } from "../../../common/ipc";
+import { ipcRendererOn, requestMain } from "../../../common/ipc";
 import { Icon } from "../icon";
 import { Button } from "../button";
 import { cssNames, IClassName } from "../../utils";
@@ -54,7 +54,7 @@ export class ClusterStatus extends React.Component<Props> {
   }
 
   async componentDidMount() {
-    subscribeToBroadcast(`kube-auth:${this.cluster.id}`, (evt, res: KubeAuthProxyLog) => {
+    ipcRendererOn(`kube-auth:${this.cluster.id}`, (evt, res: KubeAuthProxyLog) => {
       this.authOutput.push({
         data: res.data.trimRight(),
         error: res.error,

src/renderer/components/command-palette/command-container.tsx

@@ -26,7 +26,7 @@ import { observer } from "mobx-react";
 import React from "react";
 import { Dialog } from "../dialog";
 import { EventEmitter } from "../../../common/event-emitter";
-import { subscribeToBroadcast } from "../../../common/ipc";
+import { ipcRendererOn } from "../../../common/ipc";
 import { CommandDialog } from "./command-dialog";
 import { CommandRegistration, CommandRegistry } from "../../../extensions/registries/command-registry";
 
@@ -74,7 +74,7 @@ export class CommandContainer extends React.Component<{ clusterId?: string }> {
 
   componentDidMount() {
     if (this.props.clusterId) {
-      subscribeToBroadcast(`command-palette:run-action:${this.props.clusterId}`, (event, commandId: string) => {
+      ipcRendererOn(`command-palette:run-action:${this.props.clusterId}`, (event, commandId: string) => {
         const command = this.findCommandById(commandId);
 
         if (command) {
@@ -82,7 +82,7 @@ export class CommandContainer extends React.Component<{ clusterId?: string }> {
         }
       });
     } else {
-      subscribeToBroadcast("command-palette:open", () => {
+      ipcRendererOn("command-palette:open", () => {
         CommandOverlay.open(<CommandDialog />);
       });
     }

src/renderer/navigation/events.ts

@@ -22,7 +22,7 @@
 import { ipcRenderer } from "electron";
 import { reaction } from "mobx";
 import { getMatchedClusterId, navigate } from "./helpers";
-import { broadcastMessage, subscribeToBroadcast } from "../../common/ipc";
+import { broadcastMessage, ipcRendererOn } from "../../common/ipc";
 import logger from "../../main/logger";
 
 export const enum IpcRendererNavigationEvents {
@@ -45,7 +45,7 @@ export function bindEvents() {
   }
 
   // Reload dashboard window
-  subscribeToBroadcast(IpcRendererNavigationEvents.RELOAD_PAGE, () => {
+  ipcRendererOn(IpcRendererNavigationEvents.RELOAD_PAGE, () => {
     location.reload();
   });
 }
@@ -60,7 +60,7 @@ function bindClusterManagerRouteEvents() {
   });
 
   // Handle navigation via IPC
-  subscribeToBroadcast(IpcRendererNavigationEvents.NAVIGATE_IN_APP, (event, url: string) => {
+  ipcRendererOn(IpcRendererNavigationEvents.NAVIGATE_IN_APP, (event, url: string) => {
     logger.info(`[IPC]: ${event.type}: ${url}`, { currentLocation: location.href });
     navigate(url);
   });
@@ -68,7 +68,7 @@ function bindClusterManagerRouteEvents() {
 
 // Handle cluster-view renderer process events within iframes
 function bindClusterFrameRouteEvents() {
-  subscribeToBroadcast(IpcRendererNavigationEvents.NAVIGATE_IN_CLUSTER, (event, url: string) => {
+  ipcRendererOn(IpcRendererNavigationEvents.NAVIGATE_IN_CLUSTER, (event, url: string) => {
     logger.info(`[IPC]: ${event.type}: ${url}`, { currentLocation: location.href });
     navigate(url);
   });