feat: simple no current context pages (#317)

Signed-off-by: Philippe Martin <[email protected]>

Author: feloy

packages/common/src/channels.ts

@@ -23,6 +23,7 @@ import type { PortForwardApi } from './interface/port-forward-api';
 import type { SubscribeApi } from './interface/subscribe-api';
 import type { SystemApi } from './interface/system-api';
 import type { ActiveResourcesCountInfo } from './model/active-resources-count-info';
+import type { AvailableContextsInfo } from './model/available-contexts-info';
 import type { ContextsHealthsInfo } from './model/contexts-healths-info';
 import type { ContextsPermissionsInfo } from './model/contexts-permissions-info';
 import type { CurrentContextInfo } from './model/current-context-info';
@@ -50,6 +51,7 @@ export const CONTEXTS_HEALTHS = createRpcChannel<ContextsHealthsInfo>('ContextsH
 export const CONTEXTS_PERMISSIONS = createRpcChannel<ContextsPermissionsInfo>('ContextsPermissions');
 export const UPDATE_RESOURCE = createRpcChannel<UpdateResourceInfo>('UpdateResource');
 export const CURRENT_CONTEXT = createRpcChannel<CurrentContextInfo>('CurrentContext');
+export const AVAILABLE_CONTEXTS = createRpcChannel<AvailableContextsInfo>('AvailableContexts');
 export const RESOURCE_DETAILS = createRpcChannel<ResourceDetailsInfo>('ResourceDetailsInfo');
 export const RESOURCE_EVENTS = createRpcChannel<ResourceEventsInfo>('ResourceEvents');
 export const PORT_FORWARDS = createRpcChannel<PortForwardsInfo>('PortForwards');

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

@@ -19,6 +19,7 @@
 export const ContextsApi = Symbol.for('ContextsApi');
 
 export interface ContextsApi {
+  setCurrentContext(contextName: string): Promise<void>;
   refreshContextState(contextName: string): Promise<void>;
   deleteObject(kind: string, name: string, namespace?: string): Promise<void>;
   deleteObjects(objects: { kind: string; name: string; namespace?: string }[]): Promise<void>;

packages/common/src/model/available-contexts-info.ts

@@ -0,0 +1,21 @@
+/**********************************************************************
+ * 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
+ ***********************************************************************/
+
+export interface AvailableContextsInfo {
+  contextNames: string[];
+}

packages/extension/package.json

@@ -46,6 +46,7 @@
     "@kubernetes/client-node": "^1.3.0",
     "inversify": "^7.9.1",
     "reflect-metadata": "^0.2.2",
-    "yaml": "^2.8.1"
+    "yaml": "^2.8.1",
+    "js-yaml": "^4.1.0"
   }
 }

packages/extension/src/dispatcher/_dispatcher-module.ts

@@ -28,6 +28,7 @@ import { ResourceDetailsDispatcher } from './resource-details-dispatcher';
 import { ResourceEventsDispatcher } from './resource-events-dispatcher';
 import { PortForwardsDispatcher } from './port-forwards-dispatcher';
 import { EndpointsDispatcher } from './endpoints-dispatcher';
+import { AvailableContextsDispatcher } from './available-contexts-dispatcher';
 
 const dispatchersModule = new ContainerModule(options => {
   options.bind<ActiveResourcesCountDispatcher>(ActiveResourcesCountDispatcher).toSelf().inSingletonScope();
@@ -45,6 +46,9 @@ const dispatchersModule = new ContainerModule(options => {
   options.bind<CurrentContextDispatcher>(CurrentContextDispatcher).toSelf().inSingletonScope();
   options.bind(DispatcherObject).toService(CurrentContextDispatcher);
 
+  options.bind<AvailableContextsDispatcher>(AvailableContextsDispatcher).toSelf().inSingletonScope();
+  options.bind(DispatcherObject).toService(AvailableContextsDispatcher);
+
   options.bind<UpdateResourceDispatcher>(UpdateResourceDispatcher).toSelf().inSingletonScope();
   options.bind(DispatcherObject).toService(UpdateResourceDispatcher);
 

packages/extension/src/dispatcher/available-contexts-dispatcher.ts

@@ -0,0 +1,44 @@
+/**********************************************************************
+ * 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 { inject, injectable } from 'inversify';
+import type { DispatcherObject } from './util/dispatcher-object';
+import { AbsDispatcherObjectImpl } from './util/dispatcher-object';
+import { AVAILABLE_CONTEXTS } from '/@common/channels';
+import { RpcExtension } from '/@common/rpc/rpc';
+import { AvailableContextsInfo } from '/@common/model/available-contexts-info';
+import { ContextsManager } from '/@/manager/contexts-manager';
+
+@injectable()
+export class AvailableContextsDispatcher
+  extends AbsDispatcherObjectImpl<void, AvailableContextsInfo>
+  implements DispatcherObject<void>
+{
+  constructor(
+    @inject(RpcExtension) rpcExtension: RpcExtension,
+    @inject(ContextsManager) private manager: ContextsManager,
+  ) {
+    super(rpcExtension, AVAILABLE_CONTEXTS);
+  }
+
+  getData(): AvailableContextsInfo {
+    return {
+      contextNames: this.manager.getContextsNames(),
+    };
+  }
+}

packages/extension/src/manager/contexts-manager.spec.ts

@@ -18,9 +18,9 @@
 
 import type { Cluster, CoreV1Event, KubernetesObject, ObjectCache, V1Status } from '@kubernetes/client-node';
 import { ApiException, KubeConfig } from '@kubernetes/client-node';
-import type { Event } from '@podman-desktop/api';
+import type { Event, Uri } from '@podman-desktop/api';
 import { afterEach, assert, beforeEach, describe, expect, test, vi } from 'vitest';
-import { window } from '@podman-desktop/api';
+import { kubernetes, window } from '@podman-desktop/api';
 
 import type { ContextHealthState } from './context-health-checker.js';
 import { ContextHealthChecker } from './context-health-checker.js';
@@ -39,6 +39,7 @@ import type {
   OfflineEvent,
   ResourceInformer,
 } from '/@/types/resource-informer.js';
+import { vol } from 'memfs';
 
 const onCacheUpdatedMock = vi.fn<Event<CacheUpdatedEvent>>();
 const onOfflineMock = vi.fn<Event<OfflineEvent>>();
@@ -278,6 +279,8 @@ const kcWithNoCurrentContext = {
   ],
 };
 
+vi.mock('node:fs/promises');
+vi.mock('node:fs');
 vi.mock('./context-health-checker.js');
 vi.mock('./context-permissions-checker.js');
 
@@ -287,6 +290,7 @@ const originalConsoleWarn = console.warn;
 const originalConsoleError = console.error;
 
 beforeEach(() => {
+  vol.reset();
   vi.clearAllMocks();
   kcWith2contexts = {
     contexts: [
@@ -405,6 +409,12 @@ describe('HealthChecker is built and start is called for each context the first
 
     expect(permissionsStartMock).toHaveBeenCalledTimes(2);
   });
+
+  test('getContextsNames returns the correct contexts names', async () => {
+    await manager.update(kc);
+    const contextsNames = manager.getContextsNames();
+    expect(contextsNames).toEqual(['context1', 'context2']);
+  });
 });
 
 describe('HealthChecker pass and PermissionsChecker resturns a value', async () => {
@@ -1398,6 +1408,28 @@ test('get currentContext', async () => {
   expect(currentContext?.getKubeConfig().currentContext).toEqual('context1');
 });
 
+test('setCurrentContext sets the current context', async () => {
+  vol.fromJSON({
+    '/path/to/config': JSON.stringify(kcWith2contexts),
+  });
+  const kc = new KubeConfig();
+  kc.loadFromOptions(kcWith2contexts);
+  const manager = new TestContextsManager();
+  vi.spyOn(manager, 'startMonitoring').mockImplementation(async (): Promise<void> => {});
+  vi.spyOn(manager, 'stopMonitoring').mockImplementation((): void => {});
+  await manager.update(kc);
+  const currentContext = manager.currentContext;
+  expect(currentContext?.getKubeConfig().currentContext).toEqual('context1');
+
+  vi.mocked(kubernetes.getKubeconfig).mockReturnValue({
+    path: '/path/to/config',
+  } as Uri);
+
+  await manager.setCurrentContext('context2');
+  const content = vol.readFileSync('/path/to/config', 'utf-8');
+  expect(content).toContain('current-context: context2');
+});
+
 test('onCurrentContextChange is fired', async () => {
   const kc = new KubeConfig();
   kc.loadFromOptions(kcWith2contexts);

packages/extension/src/manager/contexts-manager.ts

@@ -32,7 +32,8 @@ import {
 import type { ContextPermission } from '/@common/model/kubernetes-contexts-permissions.js';
 import type { ResourceCount } from '/@common/model/kubernetes-resource-count.js';
 import type { KubernetesTroubleshootingInformation } from '/@common/model/kubernetes-troubleshooting.js';
-import { window } from '@podman-desktop/api';
+import { kubernetes, window } from '@podman-desktop/api';
+import * as jsYaml from 'js-yaml';
 
 import type { Event } from '/@/types/emitter.js';
 import { Emitter } from '/@/types/emitter.js';
@@ -72,6 +73,7 @@ import { TargetRef } from '/@common/model/target-ref.js';
 import { Endpoint } from '/@common/model/endpoint.js';
 import { V1Route } from '/@common/model/openshift-types.js';
 import { parseAllDocuments, stringify, type Tags } from 'yaml';
+import { writeFile } from 'node:fs/promises';
 
 const HEALTH_CHECK_TIMEOUT_MS = 5_000;
 const DEFAULT_NAMESPACE = 'default';
@@ -108,6 +110,9 @@ export class ContextsManager {
   #onContextDelete = new Emitter<DispatcherEvent>();
   onContextDelete: Event<DispatcherEvent> = this.#onContextDelete.event;
 
+  #onContextAdd = new Emitter<DispatcherEvent>();
+  onContextAdd: Event<DispatcherEvent> = this.#onContextAdd.event;
+
   #onResourceUpdated = new Emitter<{ contextName: string; resourceName: string }>();
   onResourceUpdated: Event<{ contextName: string; resourceName: string }> = this.#onResourceUpdated.event;
 
@@ -139,6 +144,7 @@ export class ContextsManager {
     this.#dispatcher.onUpdate(this.onUpdate.bind(this));
     this.#dispatcher.onDelete(this.onDelete.bind(this));
     this.#dispatcher.onDelete((state: DispatcherEvent) => this.#onContextDelete.fire(state));
+    this.#dispatcher.onAdd((state: DispatcherEvent) => this.#onContextAdd.fire(state));
     this.#dispatcher.onCurrentChange(this.onCurrentChange.bind(this));
   }
 
@@ -835,4 +841,16 @@ export class ContextsManager {
     }
     return tags;
   }
+
+  getContextsNames(): string[] {
+    return this.#currentKubeConfig.contexts.map(ctx => ctx.name);
+  }
+
+  async setCurrentContext(contextName: string): Promise<void> {
+    this.#currentKubeConfig.currentContext = contextName;
+    const jsonString = this.#currentKubeConfig.exportConfig();
+    const yamlString = jsYaml.dump(JSON.parse(jsonString));
+    const kubeconfigUri = kubernetes.getKubeconfig();
+    await writeFile(kubeconfigUri.path, yamlString);
+  }
 }

packages/extension/src/manager/contexts-states-dispatcher.spec.ts

@@ -35,6 +35,7 @@ import { ContextsHealthsDispatcher } from '/@/dispatcher/contexts-healths-dispat
 import { ContextsPermissionsDispatcher } from '/@/dispatcher/contexts-permissions-dispatcher.js';
 import {
   ACTIVE_RESOURCES_COUNT,
+  AVAILABLE_CONTEXTS,
   CONTEXTS_HEALTHS,
   CONTEXTS_PERMISSIONS,
   CURRENT_CONTEXT,
@@ -51,6 +52,7 @@ const contextsManagerMock: ContextsManager = {
   onOfflineChange: vi.fn(),
   onContextPermissionResult: vi.fn(),
   onContextDelete: vi.fn(),
+  onContextAdd: vi.fn(),
   getHealthCheckersStates: vi.fn(),
   getPermissions: vi.fn(),
   onResourceCountUpdated: vi.fn(),
@@ -143,10 +145,24 @@ test('ContextsStatesDispatcher should call updateHealthStates and updatePermissi
   vi.mocked(contextsManagerMock.onContextDelete).mockImplementation(f => f({} as DispatcherEvent) as IDisposable);
   dispatcher.init();
   await vi.waitFor(() => {
-    expect(dispatcherSpy).toHaveBeenCalledTimes(2);
+    expect(dispatcherSpy).toHaveBeenCalledTimes(3);
   });
   expect(dispatcherSpy).toHaveBeenCalledWith(CONTEXTS_HEALTHS);
   expect(dispatcherSpy).toHaveBeenCalledWith(CONTEXTS_PERMISSIONS);
+  expect(dispatcherSpy).toHaveBeenCalledWith(AVAILABLE_CONTEXTS);
+});
+
+test('ContextsStatesDispatcher should dispatchavailable contexts when onContextAdd event is fired', async () => {
+  const dispatcherSpy = vi.spyOn(dispatcher, 'dispatch').mockResolvedValue();
+  dispatcher.init();
+  expect(dispatcherSpy).not.toHaveBeenCalled();
+
+  vi.mocked(contextsManagerMock.onContextAdd).mockImplementation(f => f({} as DispatcherEvent) as IDisposable);
+  dispatcher.init();
+  await vi.waitFor(() => {
+    expect(dispatcherSpy).toHaveBeenCalledTimes(1);
+  });
+  expect(dispatcherSpy).toHaveBeenCalledWith(AVAILABLE_CONTEXTS);
 });
 
 test('ContextsStatesDispatcher should call updateResource and updateActiveResourcesCount when onResourceUpdated event is fired', async () => {

packages/extension/src/manager/contexts-states-dispatcher.ts

@@ -25,6 +25,7 @@ import { ContextsManager } from './contexts-manager.js';
 import { RpcChannel } from '/@common/rpc/rpc.js';
 import {
   ACTIVE_RESOURCES_COUNT,
+  AVAILABLE_CONTEXTS,
   CONTEXTS_HEALTHS,
   CONTEXTS_PERMISSIONS,
   CURRENT_CONTEXT,
@@ -73,6 +74,10 @@ export class ContextsStatesDispatcher extends ChannelSubscriber implements Subsc
     this.manager.onContextDelete(async (_state: DispatcherEvent) => {
       await this.dispatch(CONTEXTS_HEALTHS);
       await this.dispatch(CONTEXTS_PERMISSIONS);
+      await this.dispatch(AVAILABLE_CONTEXTS);
+    });
+    this.manager.onContextAdd(async (_state: DispatcherEvent) => {
+      await this.dispatch(AVAILABLE_CONTEXTS);
     });
     this.manager.onResourceCountUpdated(async () => {
       await this.dispatch(RESOURCES_COUNT);