Refactor ipc module (#1225)

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

src/main/__test__/kube-auth-proxy.test.ts

@@ -30,14 +30,14 @@ jest.mock("tcp-port-used")
 import { Cluster } from "../cluster"
 import { KubeAuthProxy } from "../kube-auth-proxy"
 import { getFreePort } from "../port"
-import { broadcastIpc } from "../../common/ipc"
+import { broadcastMessage } from "../../common/ipc"
 import { ChildProcess, spawn, SpawnOptions } from "child_process"
 import { bundledKubectlPath, Kubectl } from "../kubectl"
 import { mock, MockProxy } from 'jest-mock-extended';
 import { waitUntilUsed } from 'tcp-port-used';
 import { Readable } from "stream"
 
-const mockBroadcastIpc = broadcastIpc as jest.MockedFunction<typeof broadcastIpc>
+const mockBroadcastIpc = broadcastMessage as jest.MockedFunction<typeof broadcastMessage>
 const mockSpawn = spawn as jest.MockedFunction<typeof spawn>
 const mockWaitUntilUsed = waitUntilUsed as jest.MockedFunction<typeof waitUntilUsed>
 
@@ -95,35 +95,35 @@ describe("kube auth proxy tests", () => {
       await proxy.run()
       listeners["error"]({ message: "foobarbat" })
 
-      expect(mockBroadcastIpc).toBeCalledWith({ channel: "kube-auth:foobar", args: [{ data: "foobarbat", error: true }] })
+      expect(mockBroadcastIpc).toBeCalledWith("kube-auth:foobar", { data: "foobarbat", error: true })
     })
 
     it("should call spawn and broadcast exit", async () => {
       await proxy.run()
       listeners["exit"](0)
 
-      expect(mockBroadcastIpc).toBeCalledWith({ channel: "kube-auth:foobar", args: [{ data: "proxy exited with code: 0", error: false }] })
+      expect(mockBroadcastIpc).toBeCalledWith("kube-auth:foobar", { data: "proxy exited with code: 0", error: false })
     })
 
     it("should call spawn and broadcast errors from stderr", async () => {
       await proxy.run()
       listeners["stderr/data"]("an error")
 
-      expect(mockBroadcastIpc).toBeCalledWith({ channel: "kube-auth:foobar", args: [{ data: "an error", error: true }] })
+      expect(mockBroadcastIpc).toBeCalledWith("kube-auth:foobar", { data: "an error", error: true })
     })
 
     it("should call spawn and broadcast stdout serving info", async () => {
       await proxy.run()
       listeners["stdout/data"]("Starting to serve on")
 
-      expect(mockBroadcastIpc).toBeCalledWith({ channel: "kube-auth:foobar", args: [{ data: "Authentication proxy started\n" }] })
+      expect(mockBroadcastIpc).toBeCalledWith("kube-auth:foobar", { data: "Authentication proxy started\n" })
     })
 
     it("should call spawn and broadcast stdout other info", async () => {
       await proxy.run()
       listeners["stdout/data"]("some info")
 
-      expect(mockBroadcastIpc).toBeCalledWith({ channel: "kube-auth:foobar", args: [{ data: "some info" }] })
+      expect(mockBroadcastIpc).toBeCalledWith("kube-auth:foobar", { data: "some info" })
     })
   })
 })

src/main/cluster.ts

@@ -4,7 +4,7 @@ import type { IMetricsReqParams } from "../renderer/api/endpoints/metrics.api";
 import type { WorkspaceId } from "../common/workspace-store";
 import { action, computed, observable, reaction, toJS, when } from "mobx";
 import { apiKubePrefix } from "../common/vars";
-import { broadcastIpc } from "../common/ipc";
+import { broadcastMessage } from "../common/ipc";
 import { ContextHandler } from "./context-handler"
 import { AuthorizationV1Api, CoreV1Api, KubeConfig, V1ResourceAttributes } from "@kubernetes/client-node"
 import { Kubectl } from "./kubectl";
@@ -50,7 +50,6 @@ export interface ClusterState {
 
 export class Cluster implements ClusterModel, ClusterState {
   public id: ClusterId;
-  public frameId: number;
   public kubeCtl: Kubectl
   public contextHandler: ContextHandler;
   public ownerRef: string;
@@ -406,11 +405,7 @@ export class Cluster implements ClusterModel, ClusterState {
 
   pushState(state = this.getState()) {
     logger.silly(`[CLUSTER]: push-state`, state);
-    broadcastIpc({
-      channel: "cluster:state",
-      frameId: this.frameId,
-      args: [this.id, state],
-    })
+    broadcastMessage("cluster:state", this.id, state)
   }
 
   // get cluster system meta, e.g. use in "logger"

src/main/kube-auth-proxy.ts

@@ -1,6 +1,6 @@
 import { ChildProcess, spawn } from "child_process"
 import { waitUntilUsed } from "tcp-port-used";
-import { broadcastIpc } from "../common/ipc";
+import { broadcastMessage } from "../common/ipc";
 import type { Cluster } from "./cluster"
 import { Kubectl } from "./kubectl"
 import logger from "./logger"
@@ -94,7 +94,7 @@ export class KubeAuthProxy {
   protected async sendIpcLogMessage(res: KubeAuthProxyLog) {
     const channel = `kube-auth:${this.cluster.id}`
     logger.info(`[KUBE-AUTH]: out-channel "${channel}"`, { ...res, meta: this.cluster.getMeta() });
-    broadcastIpc({ channel: channel, args: [res] });
+    broadcastMessage(channel, res)
   }
 
   public exit() {

src/main/window-manager.ts

@@ -1,13 +1,13 @@
 import type { ClusterId } from "../common/cluster-store";
-import { clusterStore } from "../common/cluster-store";
 import { observable } from "mobx";
-import { app, BrowserWindow, dialog, ipcMain, shell, webContents } from "electron"
+import { app, BrowserWindow, dialog, shell, webContents } from "electron"
 import windowStateKeeper from "electron-window-state"
-import { extensionLoader } from "../extensions/extension-loader";
 import { appEventBus } from "../common/event-bus"
+import { subscribeToBroadcast } from "../common/ipc"
 import { initMenu } from "./menu";
 import { initTray } from "./tray";
 import { Singleton } from "../common/utils";
+import { clusterFrameMap } from "../common/cluster-frames";
 
 export class WindowManager extends Singleton {
   protected mainWindow: BrowserWindow;
@@ -63,7 +63,7 @@ export class WindowManager extends Singleton {
         shell.openExternal(url);
       });
       this.mainWindow.webContents.on("dom-ready", () => {
-        extensionLoader.broadcastExtensions()
+        appEventBus.emit({name: "app", action: "dom-ready"})
       })
       this.mainWindow.on("focus", () => {
         appEventBus.emit({name: "app", action: "focus"})
@@ -101,9 +101,9 @@ export class WindowManager extends Singleton {
 
   protected bindEvents() {
     // track visible cluster from ui
-    ipcMain.on("cluster-view:current-id", (event, clusterId: ClusterId) => {
+    subscribeToBroadcast("cluster-view:current-id", (event, clusterId: ClusterId) => {
       this.activeClusterId = clusterId;
-    });
+    })
   }
 
   async ensureMainWindow(): Promise<BrowserWindow> {
@@ -130,7 +130,7 @@ export class WindowManager extends Singleton {
   }
 
   reload() {
-    const frameId = clusterStore.getById(this.activeClusterId)?.frameId;
+    const frameId = clusterFrameMap.get(this.activeClusterId)
     if (frameId) {
       this.sendToView({ channel: "renderer:reload", frameId });
     } else {