ARTESCA-14896: Add attachHardwareVolume in Metalk8sLocalVolumeProvider

Author: ChengYanJin

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

@@ -273,4 +273,91 @@ describe('Metalk8sLocalVolumeProvider', () => {
       );
     });
   });
+
+  describe('attachHardwareVolume', () => {
+    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({
+        body: {},
+      });
+      //E
+      await provider.attachHardwareVolume([
+        {
+          IP: '192.168.1.100',
+          devicePath: '/dev/sda',
+          storageClassName: 'hdd-ext4',
+        },
+      ]);
+      //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: 'hdd-ext4',
+        },
+      });
+    });
+
+    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.attachHardwareVolume([
+          {
+            IP: '192.168.1.100',
+            devicePath: '/dev/sda',
+            storageClassName: 'hdd-ext4',
+          },
+        ]),
+      ).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.attachHardwareVolume([
+          {
+            IP: '192.168.1.100',
+            devicePath: '/dev/sda',
+            storageClassName: 'hdd-ext4',
+          },
+        ]),
+      ).rejects.toThrow('Failed to fetch nodes');
+    });
+  });
 });

ui/src/services/k8s/Metalk8sLocalVolumeProvider.ts

@@ -129,4 +129,50 @@ export default class Metalk8sLocalVolumeProvider {
       }
     }
   };
+
+  public attachHardwareVolume = async (
+    hardwareVolumes: {
+      IP: string;
+      devicePath: string;
+      storageClassName: string;
+    }[],
+  ): Promise<void> => {
+    const nodes = await this.k8sClient.listNode();
+    if (isError(nodes)) {
+      throw new Error(`Failed to fetch nodes: ${nodes.error}`);
+    }
+
+    for (const hardwareVolume of hardwareVolumes) {
+      const nodeName = nodes.body.items.find((node) =>
+        node.status.addresses.find(
+          (address) =>
+            address.type === 'InternalIP' &&
+            address.address === hardwareVolume.IP,
+        ),
+      )?.metadata.name;
+      if (!nodeName) {
+        throw new Error(`Failed to find node for IP ${hardwareVolume.IP}`);
+      }
+
+      const volume = await this.volumeClient.createMetalk8sV1alpha1Volume({
+        apiVersion: 'storage.metalk8s.scality.com/v1alpha1',
+        kind: 'Volume',
+        metadata: {
+          // It will be change to serial number in the future
+          name: `storage-data-${hardwareVolume.IP}-${hardwareVolume.devicePath}`,
+          labels: {
+            'xcore.scality.com/volume-type': 'data',
+          },
+        },
+        spec: {
+          nodeName: nodeName,
+          rawBlockDevice: { devicePath: hardwareVolume.devicePath },
+          storageClassName: hardwareVolume.storageClassName,
+        },
+      });
+      if (isError(volume)) {
+        throw new Error(`Failed to create metalk8s volume: ${volume.error}`);
+      }
+    }
+  };
 }