ARTESCA-14623 // implement Metalk8sVolumeProvider

feat: implement K8SLocalVolumeProvider and remove Metalk8sLocalVolumeProvider

feat: add K8SLocalVolumeProvider implementation and associated tests

Author: hervedombya

ui/public/.well-known/micro-app-configuration

@@ -33,6 +33,12 @@
         "scope": "metalk8s"
       }
     },
+    "providers": {
+      "K8SLocalVolumeProvider": {
+        "module": "./K8SLocalVolumeProvider",
+        "scope": "metalk8s"
+      }
+    },
     "components": {
       "TODO_AlertProvider": {
         "module": "",

ui/rspack.config.ts

@@ -117,6 +117,8 @@ const config: Configuration = {
         './platformLibrary': './src/services/platformlibrary/k8s.ts',
         './AlertsNavbarUpdater':
           './src/components/AlertNavbarUpdaterComponent.tsx',
+        './K8SLocalVolumeProvider':
+          './src/services/k8s/K8SLocalVolumeProvider.ts',
       },
       remotes: !isProduction
         ? {
@@ -148,7 +150,17 @@ const config: Configuration = {
       },
     }),
     new rspack.CopyRspackPlugin({
-      patterns: [{ from: 'public' }],
+      patterns: [
+        { from: 'public' },
+        {
+          from: path.resolve(__dirname, 'build/static/js/@mf-types.zip'),
+          to: '@mf-types.zip',
+        },
+        {
+          from: path.resolve(__dirname, 'build/static/js/@mf-types.d.ts'),
+          to: '@mf-types.d.ts',
+        },
+      ],
     }),
     new rspack.DefinePlugin({
       NODE_ENV: process.env.NODE_ENV,

ui/src/services/k8s/K8SLocalVolumeProvider.test.ts

@@ -0,0 +1,130 @@
+import { CoreV1Api, CustomObjectsApi } from '@kubernetes/client-node';
+import K8SLocalVolumeProvider from './K8SLocalVolumeProvider';
+import { Metalk8sV1alpha1VolumeClient } from './Metalk8sVolumeClient.generated';
+import { updateApiServerConfig } from '../k8s/api';
+
+jest.mock('../k8s/api', () => ({
+  updateApiServerConfig: jest.fn(),
+}));
+
+describe('K8SLocalVolumeProvider', () => {
+  let provider: K8SLocalVolumeProvider;
+  const mockUrl = 'mock-url';
+  const mockToken = 'mock-token';
+
+  const mockCustomObjectsApi = {
+    listClusterCustomObject: jest.fn(),
+  } as unknown as CustomObjectsApi;
+
+  const mockVolumeClient = new Metalk8sV1alpha1VolumeClient(
+    mockCustomObjectsApi,
+  );
+
+  const mockCoreV1Api = {
+    listNode: jest.fn(),
+    listPersistentVolume: jest.fn(),
+  } as unknown as CoreV1Api;
+
+  beforeEach(() => {
+    (updateApiServerConfig as jest.Mock).mockReturnValue({
+      coreV1: mockCoreV1Api,
+      customObjects: mockCustomObjectsApi,
+    });
+
+    provider = new K8SLocalVolumeProvider(mockUrl, mockToken);
+    provider.k8sClient = mockCoreV1Api;
+    provider.volumeClient = mockVolumeClient;
+  });
+
+  describe('listLocalPersistentVolumes', () => {
+    it('should return local persistent volumes for a given node.', async () => {
+      (mockCoreV1Api.listNode as jest.Mock).mockResolvedValue({
+        body: {
+          items: [
+            {
+              metadata: { name: 'test-node' },
+              status: {
+                addresses: [
+                  { type: 'Hostname', address: 'test-node' },
+                  { type: 'InternalIP', address: '192.168.1.100' },
+                ],
+              },
+            },
+          ],
+        },
+      });
+
+      (mockCoreV1Api.listPersistentVolume as jest.Mock).mockResolvedValue({
+        body: {
+          items: [
+            {
+              metadata: { name: 'test-volume' },
+              spec: {},
+            },
+          ],
+        },
+      });
+
+      (
+        mockCustomObjectsApi.listClusterCustomObject as jest.Mock
+      ).mockResolvedValue({
+        body: {
+          items: [
+            {
+              metadata: { name: 'test-volume' },
+              spec: {
+                nodeName: 'test-node',
+                rawBlockDevice: { devicePath: '/dev/sda' },
+              },
+            },
+          ],
+        },
+      });
+
+      const volumes = await provider.listLocalPersistentVolumes('test-node');
+
+      expect(volumes).toHaveLength(1);
+      expect(volumes[0]).toMatchObject({
+        IP: '192.168.1.100',
+        devicePath: '/dev/sda',
+        metadata: { name: 'test-volume' },
+      });
+    });
+
+    it('should raise an error if the node cannot be found', async () => {
+      (mockCoreV1Api.listNode as jest.Mock).mockResolvedValue({
+        body: { items: [] },
+      });
+
+      await expect(
+        provider.listLocalPersistentVolumes('non-existent-node'),
+      ).rejects.toThrow('Failed to find IP for node non-existent-node');
+    });
+
+    it('should raise an error if volume recovery fails', async () => {
+      (mockCoreV1Api.listNode as jest.Mock).mockResolvedValue({
+        body: {
+          items: [
+            {
+              metadata: { name: 'test-node' },
+              status: {
+                addresses: [
+                  { type: 'Hostname', address: 'test-node' },
+                  { type: 'InternalIP', address: '192.168.1.100' },
+                ],
+              },
+            },
+          ],
+        },
+      });
+
+      (
+        mockCustomObjectsApi.listClusterCustomObject as jest.Mock
+      ).mockRejectedValue(new Error('Failed to fetch volumes'));
+
+      await expect(
+        provider.listLocalPersistentVolumes('test-node'),
+      ).rejects.toThrow('Failed to fetch metalk8s volumes');
+    });
+  });
+});

ui/src/services/k8s/K8SLocalVolumeProvider.ts

@@ -0,0 +1,79 @@
+import { CoreV1Api, V1PersistentVolume } from '@kubernetes/client-node';
+import * as ApiK8s from '../k8s/api';
+import {
+  Metalk8sV1alpha1VolumeClient,
+  Result,
+} from './Metalk8sVolumeClient.generated';
+
+function isError<T>(result: Result<T>): result is { error: any } {
+  return (result as { error: any }).error !== undefined;
+}
+
+type LocalPersistentVolume = V1PersistentVolume & {
+  IP: string;
+  devicePath: string;
+};
+
+export interface K8SLocalVolumeAdapter {
+  listLocalPersistentVolumes(
+    serverName: string,
+  ): Promise<LocalPersistentVolume[]>;
+}
+
+export default class K8SLocalVolumeProvider implements K8SLocalVolumeAdapter {
+  volumeClient: Metalk8sV1alpha1VolumeClient;
+  k8sClient: CoreV1Api;
+  constructor(private url: string, private token: string) {
+    const { coreV1, customObjects } = ApiK8s.updateApiServerConfig(url, token);
+    this.volumeClient = new Metalk8sV1alpha1VolumeClient(customObjects);
+    this.k8sClient = coreV1;
+  }
+  public async listLocalPersistentVolumes(
+    serverName: string,
+  ): Promise<LocalPersistentVolume[]> {
+    try {
+      const nodes = await this.k8sClient.listNode();
+      const nodeIP = nodes.body.items
+        .find((node) => node.metadata.name === serverName)
+        ?.status.addresses.find((address) => address.type === 'InternalIP');
+
+      if (!nodeIP) {
+        throw new Error(`Failed to find IP for node ${serverName}`);
+      }
+
+      const volumes = await this.volumeClient.getMetalk8sV1alpha1VolumeList();
+
+      if (!isError(volumes)) {
+        const nodeVolumes = volumes.body.items.filter(
+          (volume) => volume.spec.nodeName === serverName,
+        );
+        const pv = await this.k8sClient.listPersistentVolume();
+
+        const localPv: LocalPersistentVolume[] = nodeVolumes.reduce(
+          (acc, item) => {
+            const isLocalPv = pv.body.items.find(
+              (p) => p.metadata.name === item.metadata['name'],
+            );
+            return [
+              ...acc,
+              {
+                ...isLocalPv,
+                IP: nodeIP.address,
+                devicePath: item.spec?.rawBlockDevice?.devicePath,
+              },
+            ];
+          },
+          [],
+        );
+
+        return localPv;
+      } else {
+        throw new Error(`Failed to fetch metalk8s volumes: ${volumes.error}`);
+      }
+    } catch (error) {
+      throw new Error(
+        `Failed to fetch local persistent volumes: ${error.message}`,
+      );
+    }
+  }
+}