ARTESCA-14896: Add attachHardwareVolume in Metalk8sLocalVolumeProvider

Author: ChengYanJin

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

@@ -1,6 +1,7 @@
 import { CoreV1Api, CustomObjectsApi } from '@kubernetes/client-node';
 import { updateApiServerConfig } from './api';
 import Metalk8sLocalVolumeProvider, {
+  HardwareDiskType,
   VolumeType,
 } from './Metalk8sLocalVolumeProvider';
 
@@ -20,6 +21,7 @@ describe('Metalk8sLocalVolumeProvider', () => {
   const mockCustomObjectsApi = {
     listClusterCustomObject: jest.fn(),
     deleteClusterCustomObject: jest.fn(),
+    createClusterCustomObject: jest.fn(),
   } as unknown as CustomObjectsApi;
 
   const mockCoreV1Api = {
@@ -227,4 +229,99 @@ describe('Metalk8sLocalVolumeProvider', () => {
       );
     });
   });
+
+  describe('attachHardwareVolume', () => {
+    it('should attach hardware volume', async () => {
+      //S
+      (mockCoreV1Api.listNode as jest.Mock).mockResolvedValue({
+        body: {
+          apiVersion: 'v1',
+          kind: 'NodeList',
+          items: [
+            {
+              metadata: {
+                name: 'test-node',
+              },
+              status: {
+                addresses: [{ type: 'InternalIP', address: '192.168.1.100' }],
+              },
+            },
+          ],
+        },
+      });
+      (
+        mockCustomObjectsApi.createClusterCustomObject as jest.Mock
+      ).mockResolvedValue({
+        metadata: {
+          name: 'storage-data-192.168.1.100-/dev/sda',
+        },
+      });
+      //E
+      const result = await provider.attachHardwareVolume({
+        IP: '192.168.1.100',
+        devicePath: '/dev/sda',
+        type: HardwareDiskType.NVMe,
+      });
+      //V
+      expect(
+        mockCustomObjectsApi.createClusterCustomObject,
+      ).toHaveBeenCalledWith(
+        'storage.metalk8s.scality.com',
+        'v1alpha1',
+        'volumes',
+        {
+          apiVersion: 'storage.metalk8s.scality.com/v1alpha1',
+          kind: 'Volume',
+          metadata: {
+            name: 'storage-data-192.168.1.100-/dev/sda',
+            labels: {
+              'xcore.scality.com/volume-type': 'data',
+            },
+          },
+          spec: {
+            nodeName: 'test-node',
+            rawBlockDevice: { devicePath: '/dev/sda' },
+            storageClassName: 'ssd-ext4',
+          },
+        },
+      );
+      expect(result).toEqual({
+        IP: '192.168.1.100',
+        devicePath: '/dev/sda',
+        nodeName: 'test-node',
+        volumeType: VolumeType.Hardware,
+        volumeName: 'storage-data-192.168.1.100-/dev/sda',
+      });
+    });
+
+    it('should raise an error if volume creation fails', async () => {
+      //S
+      (
+        mockCustomObjectsApi.createClusterCustomObject as jest.Mock
+      ).mockRejectedValue(new Error('Error'));
+      //E+V
+      await expect(
+        provider.attachHardwareVolume({
+          IP: '192.168.1.100',
+          devicePath: '/dev/sda',
+          type: HardwareDiskType.NVMe,
+        }),
+      ).rejects.toThrow('Failed to attach hardware volume: Error');
+    });
+
+    it('should raise an error if node retrieval fails', async () => {
+      //S
+      (mockCoreV1Api.listNode as jest.Mock).mockRejectedValue(
+        new Error('Error'),
+      );
+      //E+V
+      await expect(
+        provider.attachHardwareVolume({
+          IP: '192.168.1.100',
+          devicePath: '/dev/sda',
+          type: HardwareDiskType.NVMe,
+        }),
+      ).rejects.toThrow('Failed to fetch nodes: Error');
+    });
+  });
 });

ui/src/services/k8s/Metalk8sLocalVolumeProvider.ts

@@ -14,13 +14,28 @@ export enum VolumeType {
   Virtual = 'Virtual',
 }
 
-export type LocalPersistentVolume = V1PersistentVolume & {
+export enum HardwareDiskType {
+  SATA = 'SATA',
+  NVMe = 'NVMe',
+}
+
+export type HardwareDisk = {
+  IP: string;
+  devicePath: string;
+  type: HardwareDiskType;
+};
+
+type LocalVolumeInfo = {
   IP: string;
   devicePath: string;
   nodeName: string;
   volumeType: VolumeType;
 };
 
+export type LocalPersistentVolume = V1PersistentVolume & LocalVolumeInfo;
+
+type LocalVolume = LocalVolumeInfo & { volumeName: string };
+
 export default class Metalk8sLocalVolumeProvider {
   apiUrl: string;
   constructor(apiUrl: string, private getToken: () => Promise<string>) {
@@ -121,4 +136,84 @@ export default class Metalk8sLocalVolumeProvider {
       }
     }
   };
+
+  public attachHardwareVolume = async (
+    hardwareDisk: HardwareDisk,
+  ): Promise<LocalVolume> => {
+    const { IP, devicePath, type } = hardwareDisk;
+
+    const token = await this.getToken();
+    const { coreV1, customObjects } = ApiK8s.updateApiServerConfig(
+      this.apiUrl,
+      token,
+    );
+    const volumeClient = new Metalk8sV1alpha1VolumeClient(customObjects);
+    const k8sClient = coreV1;
+
+    if (isError(volumeClient)) {
+      throw new Error(
+        `Failed to create volume client: ${volumeClient.error.message}`,
+      );
+    }
+    if (isError(k8sClient)) {
+      throw new Error(
+        `Failed to create k8s client: ${k8sClient.error.message}`,
+      );
+    }
+
+    const nodes = await k8sClient.listNode().catch((error) => {
+      throw new Error(
+        `Failed to fetch nodes: ${
+          error instanceof Error ? error.message : JSON.stringify(error)
+        }`,
+      );
+    });
+
+    if (isError(nodes)) {
+      throw new Error(`Failed to fetch nodes: ${nodes.error.message}`);
+    }
+    const nodeName = nodes.body.items.find((node) =>
+      node.status.addresses.find(
+        (address) => address.type === 'InternalIP' && address.address === IP,
+      ),
+    )?.metadata.name;
+    if (!nodeName) {
+      throw new Error(`Failed to find node for IP ${IP}`);
+    }
+    // The map between hardwareDisk Type and StorageClassName
+    // NVMe => SSD
+    // the rest=> HDD
+    const storageClassName =
+      type === HardwareDiskType.NVMe ? 'ssd-ext4' : 'hdd-ext4';
+
+    const volume = await volumeClient.createMetalk8sV1alpha1Volume({
+      apiVersion: 'storage.metalk8s.scality.com/v1alpha1',
+      kind: 'Volume',
+      metadata: {
+        // It will be changed to Disk Serial Number in the future.
+        name: `storage-data-${IP}-${devicePath}`,
+        labels: {
+          'xcore.scality.com/volume-type': 'data',
+        },
+      },
+      spec: {
+        nodeName,
+        rawBlockDevice: { devicePath },
+        storageClassName,
+      },
+    });
+    if (isError(volume)) {
+      throw new Error(
+        `Failed to attach hardware volume: ${volume.error.message}`,
+      );
+    }
+
+    return {
+      IP,
+      devicePath,
+      nodeName,
+      volumeType: VolumeType.Hardware,
+      volumeName: volume.metadata['name'],
+    };
+  };
 }