Merge branch 'feature/ARTESCA-14896-add-attachHardwareVolume-method-in-Metalk8sKubernetesLocalVolumeProvider' into tmp/octopus/w/130.0/feature/ARTESCA-14896-add-attachHardwareVolume-method-in-Metalk8sKubernetesLocalVolumeProvider

Author: bert-e

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

@@ -1,5 +1,6 @@
 import { CoreV1Api, CustomObjectsApi } from '@kubernetes/client-node';
 import Metalk8sLocalVolumeProvider, {
+  HardwareDiskType,
   VolumeType,
 } from './Metalk8sLocalVolumeProvider';
 import { updateApiServerConfig } from './api';
@@ -221,4 +222,94 @@ describe('Metalk8sLocalVolumeProvider', () => {
       );
     });
   });
+
+  describe('attachHardwareVolumes', () => {
+    it('should attach hardware volumes', 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' }],
+              },
+            },
+          ],
+        },
+      });
+      (
+        mockVolumeClient.createMetalk8sV1alpha1Volume as jest.Mock
+      ).mockResolvedValue({
+        metadata: {
+          name: 'storage-data-192.168.1.100-/dev/sda',
+        },
+      });
+      //E
+      const result = await provider.attachHardwareVolumes([
+        {
+          IP: '192.168.1.100',
+          devicePath: '/dev/sda',
+          type: HardwareDiskType.NVMe,
+        },
+      ]);
+      //V
+      expect(
+        mockVolumeClient.createMetalk8sV1alpha1Volume,
+      ).toHaveBeenCalledWith({
+        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(['storage-data-192.168.1.100-/dev/sda']);
+    });
+
+    it('should raise an error if volume creation fails', async () => {
+      //S
+      (
+        mockVolumeClient.createMetalk8sV1alpha1Volume as jest.Mock
+      ).mockRejectedValue(new Error('Failed to create volume'));
+      //E+V
+      await expect(
+        provider.attachHardwareVolumes([
+          {
+            IP: '192.168.1.100',
+            devicePath: '/dev/sda',
+            type: HardwareDiskType.NVMe,
+          },
+        ]),
+      ).rejects.toThrow('Failed to create volume');
+    });
+
+    it('should raise an error if node retrieval fails', async () => {
+      //S
+      (mockCoreV1Api.listNode as jest.Mock).mockRejectedValue(
+        new Error('Failed to fetch nodes'),
+      );
+      //E+V
+      await expect(
+        provider.attachHardwareVolumes([
+          {
+            IP: '192.168.1.100',
+            devicePath: '/dev/sda',
+            type: HardwareDiskType.NVMe,
+          },
+        ]),
+      ).rejects.toThrow('Failed to fetch nodes');
+    });
+  });
 });

ui/src/services/k8s/Metalk8sLocalVolumeProvider.ts

@@ -14,6 +14,17 @@ export enum VolumeType {
   Virtual = 'Virtual',
 }
 
+export enum HardwareDiskType {
+  SATA = 'SATA',
+  NVMe = 'NVMe',
+}
+
+export type HardwareDisk = {
+  IP: string;
+  devicePath: string;
+  type: HardwareDiskType;
+};
+
 export type LocalPersistentVolume = V1PersistentVolume & {
   IP: string;
   devicePath: string;
@@ -100,4 +111,55 @@ export default class Metalk8sLocalVolumeProvider {
       }
     }
   };
+
+  public attachHardwareVolumes = async (
+    hardwareDisks: HardwareDisk[],
+  ): Promise<string[]> => {
+    const nodes = await this.k8sClient.listNode();
+    if (isError(nodes)) {
+      throw new Error(`Failed to fetch nodes: ${nodes.error}`);
+    }
+
+    const volumeNames: string[] = [];
+
+    for (const hardwareDisk of hardwareDisks) {
+      const { IP, devicePath, type } = hardwareDisk;
+
+      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 this.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 create MetalK8s volume: ${volume.error}`);
+      }
+      volumeNames.push(volume.metadata['name']);
+    }
+    return volumeNames;
+  };
 }