refactor: send signals with rpcExtension

Author: feloy

packages/common/src/channels.ts

@@ -3,3 +3,14 @@ import { createRpcChannel } from './rpc';
 
 // RPC channels (used by the webview to send requests to the extension)
 export const API_DASHBOARD = createRpcChannel<DashboardApi>('DashboardApi');
+
+export interface KubernetesUpdateResourceInfo {
+  resourceName: string;
+}
+
+// Broadcast events (sent by extension and received by the webview)
+export const ACTIVE_RESOURCES_COUNT = createRpcChannel<undefined>('ActiveResourcesCount');
+export const KUBERNETES_CONTEXTS_HEALTHS = createRpcChannel<undefined>('KubernetesContextsHealths');
+export const KUBERNETES_CONTEXTS_PERMISSIONS = createRpcChannel<undefined>('KubernetesContextsPermissions');
+export const KUBERNETES_RESOURCES_COUNT = createRpcChannel<undefined>('KubernetesResourcesCount');
+export const KUBERNETES_UPDATE_RESOURCE = createRpcChannel<KubernetesUpdateResourceInfo>('KubernetesUpdateResource');

packages/common/src/interface/dashboard-api.ts

@@ -16,7 +16,9 @@
  * SPDX-License-Identifier: Apache-2.0
  ***********************************************************************/
 
+import type { ResourceCount } from '../model/kubernetes-resource-count';
+
 export const DashboardApi = Symbol.for('DashboardApi');
 export interface DashboardApi {
-  ping(): Promise<string>;
+  getActiveResourcesCount(): Promise<ResourceCount[]>;
 }

packages/extension/src/controller/dashboard-impl.ts

@@ -0,0 +1,35 @@
+/**********************************************************************
+ * Copyright (C) 2025 Red Hat, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ***********************************************************************/
+
+import type { ContextsStatesDispatcher } from '../manager/contexts-states-dispatcher';
+import { API_DASHBOARD } from '/@common/channels';
+import type { DashboardApi } from '/@common/interface/dashboard-api';
+import type { ResourceCount } from '/@common/model/kubernetes-resource-count';
+import type { RpcChannel } from '/@common/rpc';
+
+export class DashboardImpl implements DashboardApi {
+  constructor(private contextsStatesDispatcher: ContextsStatesDispatcher) {}
+
+  getChannel(): RpcChannel<DashboardApi> {
+    return API_DASHBOARD;
+  }
+
+  async getActiveResourcesCount(): Promise<ResourceCount[]> {
+    return this.contextsStatesDispatcher.getActiveResourcesCount();
+  }
+}

packages/extension/src/dashboard-extension.spec.ts

@@ -22,17 +22,19 @@ import { assert, beforeEach, describe, expect, test, vi } from 'vitest';
 import { DashboardExtension } from './dashboard-extension';
 import { vol } from 'memfs';
 
-import type { ContextsManager } from './manager/contexts-manager';
-import type { ContextsStatesDispatcher } from './manager/contexts-states-dispatcher';
+import { ContextsManager } from './manager/contexts-manager';
+import { ContextsStatesDispatcher } from './manager/contexts-states-dispatcher';
 
 let extensionContextMock: ExtensionContext;
 let dashboardExtension: DashboardExtension;
 let contextsManagerMock: ContextsManager;
-let contextsStatesDispatcher: ContextsStatesDispatcher;
+let contextsStatesDispatcherMock: ContextsStatesDispatcher;
 
 vi.mock(import('node:fs'));
 vi.mock(import('node:fs/promises'));
 vi.mock(import('@kubernetes/client-node'));
+vi.mock(import('./manager/contexts-manager'));
+vi.mock(import('./manager/contexts-states-dispatcher'));
 
 beforeEach(() => {
   vi.restoreAllMocks();
@@ -50,14 +52,18 @@ beforeEach(() => {
   extensionContextMock = {
     subscriptions: [],
   } as unknown as ExtensionContext;
-  // Create a mock for the contextsManager
+
   contextsManagerMock = {
     update: vi.fn(),
   } as unknown as ContextsManager;
-  contextsStatesDispatcher = {
+  vi.mocked(ContextsManager).mockReturnValue(contextsManagerMock);
+
+  contextsStatesDispatcherMock = {
     init: vi.fn(),
   } as unknown as ContextsStatesDispatcher;
-  dashboardExtension = new DashboardExtension(extensionContextMock, contextsManagerMock, contextsStatesDispatcher);
+  vi.mocked(ContextsStatesDispatcher).mockReturnValue(contextsStatesDispatcherMock);
+
+  dashboardExtension = new DashboardExtension(extensionContextMock);
   vi.mocked(kubernetes.getKubeconfig).mockReturnValue({
     path: '/path/to/kube/config',
   } as Uri);
@@ -80,7 +86,7 @@ describe('a kubeconfig file is not present', () => {
     callback({ type: 'UPDATE', location: { path: '/path/to/kube/config' } as Uri });
     expect(contextsManagerMock.update).toHaveBeenCalledOnce();
 
-    expect(contextsStatesDispatcher.init).toHaveBeenCalledOnce();
+    expect(contextsStatesDispatcherMock.init).toHaveBeenCalledOnce();
   });
 
   test('should deactivate correctly', async () => {
@@ -107,7 +113,7 @@ describe('a kubeconfig file is present', () => {
     callback({ type: 'UPDATE', location: { path: '/path/to/kube/config' } as Uri });
     expect(contextsManagerMock.update).toHaveBeenCalledOnce();
 
-    expect(contextsStatesDispatcher.init).toHaveBeenCalledOnce();
+    expect(contextsStatesDispatcherMock.init).toHaveBeenCalledOnce();
   });
 
   test('should deactivate correctly', async () => {

packages/extension/src/dashboard-extension.ts

@@ -22,24 +22,19 @@ import { kubernetes, Uri, window } from '@podman-desktop/api';
 import { RpcExtension } from '/@common/rpc/rpc';
 
 import { readFile } from 'node:fs/promises';
-import type { ContextsManager } from './manager/contexts-manager';
+import { ContextsManager } from './manager/contexts-manager';
 import { existsSync } from 'node:fs';
 import { KubeConfig } from '@kubernetes/client-node';
-import type { ContextsStatesDispatcher } from './manager/contexts-states-dispatcher';
+import { ContextsStatesDispatcher } from './manager/contexts-states-dispatcher';
+import { DashboardImpl } from './controller/dashboard-impl';
 
 export class DashboardExtension {
   #extensionContext: ExtensionContext;
   #contextsManager: ContextsManager;
   #contextsStatesDispatcher: ContextsStatesDispatcher;
 
-  constructor(
-    readonly extensionContext: ExtensionContext,
-    readonly contextManager: ContextsManager,
-    readonly contextsStatesDispatcher: ContextsStatesDispatcher,
-  ) {
+  constructor(readonly extensionContext: ExtensionContext) {
     this.#extensionContext = extensionContext;
-    this.#contextsManager = contextManager;
-    this.#contextsStatesDispatcher = contextsStatesDispatcher;
   }
 
   async activate(): Promise<void> {
@@ -50,12 +45,19 @@ export class DashboardExtension {
     rpcExtension.init();
     this.#extensionContext.subscriptions.push(rpcExtension);
 
+    this.#contextsManager = new ContextsManager();
+    this.#contextsStatesDispatcher = new ContextsStatesDispatcher(this.#contextsManager, rpcExtension);
+
     const now = performance.now();
 
     const afterFirst = performance.now();
 
     console.log('activation time:', afterFirst - now);
 
+    // Register all controllers
+    const dashboardImpl = new DashboardImpl(this.#contextsStatesDispatcher);
+    rpcExtension.registerInstance(dashboardImpl.getChannel(), dashboardImpl);
+
     await this.listenMonitoring();
     await this.startMonitoring();
   }

packages/extension/src/main.ts

@@ -19,21 +19,12 @@
 import type { ExtensionContext } from '@podman-desktop/api';
 
 import { DashboardExtension } from './dashboard-extension';
-import { ContextsManager } from './manager/contexts-manager';
-import { ContextsStatesDispatcher } from './manager/contexts-states-dispatcher';
 
 let dashboardExtension: DashboardExtension | undefined;
 
 // Initialize the activation of the extension.
 export async function activate(extensionContext: ExtensionContext): Promise<void> {
-  const contextsManager = new ContextsManager();
-  const apiSender = {
-    send: (channel: string, data?: unknown): void => {
-      console.log(`==> recv data "${data}" on channel ${channel}`);
-    },
-  };
-  const contextsStatesDispatcher = new ContextsStatesDispatcher(contextsManager, apiSender);
-  dashboardExtension ??= new DashboardExtension(extensionContext, contextsManager, contextsStatesDispatcher);
+  dashboardExtension ??= new DashboardExtension(extensionContext);
 
   await dashboardExtension.activate();
 }