ARTESCA-14895: Add detach volumes method in Metalk8sLocalvolumeProvider

Author: ChengYanJin

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

@@ -2,8 +2,8 @@ import { CoreV1Api, CustomObjectsApi } from '@kubernetes/client-node';
 import Metalk8sLocalVolumeProvider, {
   VolumeType,
 } from './Metalk8sLocalVolumeProvider';
-import { Metalk8sV1alpha1VolumeClient } from './Metalk8sVolumeClient.generated';
 import { updateApiServerConfig } from './api';
+import { Metalk8sV1alpha1VolumeClient } from './Metalk8sVolumeClient.generated';
 
 jest.mock('../k8s/api', () => ({
   updateApiServerConfig: jest.fn(),
@@ -18,13 +18,18 @@ describe('Metalk8sLocalVolumeProvider', () => {
     listClusterCustomObject: jest.fn(),
   } as unknown as CustomObjectsApi;
 
-  const mockVolumeClient = new Metalk8sV1alpha1VolumeClient(
-    mockCustomObjectsApi,
-  );
+  const mockVolumeClient = {
+    deleteMetalk8sV1alpha1Volume: jest.fn().mockResolvedValue({ body: {} }),
+    getMetalk8sV1alpha1VolumeList: jest.fn(),
+    getMetalk8sV1alpha1Volume: jest.fn(),
+    createMetalk8sV1alpha1Volume: jest.fn(),
+    patchMetalk8sV1alpha1Volume: jest.fn(),
+  } as unknown as Metalk8sV1alpha1VolumeClient;
 
   const mockCoreV1Api = {
     listNode: jest.fn(),
     listPersistentVolume: jest.fn(),
+    deletePersistentVolume: jest.fn(),
   } as unknown as CoreV1Api;
 
   beforeEach(() => {
@@ -68,7 +73,7 @@ describe('Metalk8sLocalVolumeProvider', () => {
       });
 
       (
-        mockCustomObjectsApi.listClusterCustomObject as jest.Mock
+        mockVolumeClient.getMetalk8sV1alpha1VolumeList as jest.Mock
       ).mockResolvedValue({
         body: {
           items: [
@@ -150,12 +155,122 @@ describe('Metalk8sLocalVolumeProvider', () => {
       });
 
       (
-        mockCustomObjectsApi.listClusterCustomObject as jest.Mock
+        mockVolumeClient.getMetalk8sV1alpha1VolumeList as jest.Mock
       ).mockRejectedValue(new Error('Failed to fetch volumes'));
 
       await expect(
         provider.listLocalPersistentVolumes('test-node'),
-      ).rejects.toThrow('Failed to fetch metalk8s volumes');
+      ).rejects.toThrow(
+        'Failed to fetch local persistent volumes: Failed to fetch volumes',
+      );
+    });
+  });
+
+  describe('detachVolumes', () => {
+    it('should detach hardware volumes and virtual volumes', async () => {
+      //S
+      (
+        mockVolumeClient.deleteMetalk8sV1alpha1Volume as jest.Mock
+      ).mockResolvedValue({
+        body: {},
+      });
+      (mockCoreV1Api.deletePersistentVolume as jest.Mock).mockResolvedValue({
+        body: {},
+      });
+      (
+        mockVolumeClient.getMetalk8sV1alpha1VolumeList as jest.Mock
+      ).mockResolvedValue({
+        body: {
+          items: [
+            {
+              metadata: { name: 'test-volume' },
+              spec: {
+                nodeName: 'test-node',
+                rawBlockDevice: { devicePath: '/dev/sda' },
+              },
+            },
+            {
+              metadata: { name: 'test-lvm' },
+              spec: {
+                nodeName: 'test-node',
+                lvmLogicalVolume: { vgName: 'test-lvm', size: '10Gi' },
+              },
+            },
+          ],
+        },
+      });
+
+      //E
+      await provider.detachVolumes([
+        {
+          IP: '192.168.1.100',
+          devicePath: '/dev/sda',
+          volumeType: VolumeType.Hardware,
+          nodeName: 'test-node',
+        },
+        {
+          IP: '192.168.1.100',
+          devicePath: 'test-lvm',
+          volumeType: VolumeType.Virtual,
+          nodeName: 'test-node',
+        },
+      ]);
+      //V
+      expect(mockCoreV1Api.deletePersistentVolume).toHaveBeenCalledWith(
+        'test-volume',
+      );
+      expect(
+        mockVolumeClient.deleteMetalk8sV1alpha1Volume,
+      ).toHaveBeenCalledWith('test-volume');
+      expect(mockCoreV1Api.deletePersistentVolume).toHaveBeenCalledWith(
+        'test-lvm',
+      );
+      expect(
+        mockVolumeClient.deleteMetalk8sV1alpha1Volume,
+      ).toHaveBeenCalledWith('test-lvm');
+    });
+
+    it('should raise an error if pv deletion fails', async () => {
+      //S
+      (mockCoreV1Api.deletePersistentVolume as jest.Mock).mockRejectedValue(
+        new Error('Failed to delete volume'),
+      );
+      //E+V
+      await expect(
+        provider.detachVolumes([
+          {
+            IP: '192.168.1.100',
+            devicePath: '/dev/sda',
+            volumeType: VolumeType.Hardware,
+            nodeName: 'test-node',
+          },
+        ]),
+      ).rejects.toThrow(
+        'Failed to delete PV test-volume: Failed to delete volume',
+      );
+    });
+
+    it('should raise an error if metalk8s volume deletion fails', async () => {
+      //S
+      (mockCoreV1Api.deletePersistentVolume as jest.Mock).mockResolvedValue({
+        body: {},
+      });
+      (
+        mockVolumeClient.deleteMetalk8sV1alpha1Volume as jest.Mock
+      ).mockRejectedValue(new Error('Failed to delete metalk8s volume'));
+      //E+V
+      await expect(
+        provider.detachVolumes([
+          {
+            IP: '192.168.1.100',
+            devicePath: '/dev/sda',
+            volumeType: VolumeType.Hardware,
+            nodeName: 'test-node',
+          },
+        ]),
+      ).rejects.toThrow(
+        'Failed to delete Metalk8s volume test-volume: Failed to delete metalk8s volume',
+      );
     });
   });
 });

ui/src/services/k8s/Metalk8sLocalVolumeProvider.ts

@@ -80,4 +80,53 @@ export default class Metalk8sLocalVolumeProvider {
       );
     }
   };
+
+  // Since we don't have unique Serial Number for the disks, we need to retrieve the Volume Name from the PV.
+  public detachVolumes = async (
+    localPVs: LocalPersistentVolume[],
+  ): Promise<void> => {
+    const volumeNames = [];
+    for (const localPV of localPVs) {
+      const volumes = await this.volumeClient.getMetalk8sV1alpha1VolumeList();
+      if (isError(volumes)) {
+        throw new Error(`Failed to fetch metalk8s volumes: ${volumes.error}`);
+      }
+      const volumeName = volumes.body.items.find(
+        (volume) =>
+          volume.spec.nodeName === localPV.nodeName &&
+          (localPV.volumeType === VolumeType.Hardware
+            ? volume.spec.rawBlockDevice?.devicePath === localPV.devicePath
+            : volume.metadata['name'] === localPV.devicePath),
+      )?.metadata['name'];
+      if (!volumeName) {
+        throw new Error(
+          `Failed to find Volume for devicePath ${localPV.devicePath}`,
+        );
+      }
+      volumeNames.push(volumeName);
+    }
+
+    for (const volumeName of volumeNames) {
+      try {
+        await this.k8sClient.deletePersistentVolume(volumeName);
+      } catch (error) {
+        throw new Error(
+          `Failed to delete PV ${volumeName}: ${
+            error instanceof Error ? error.message : JSON.stringify(error)
+          }`,
+        );
+      }
+    }
+    for (const volumeName of volumeNames) {
+      try {
+        await this.volumeClient.deleteMetalk8sV1alpha1Volume(volumeName);
+      } catch (error) {
+        throw new Error(
+          `Failed to delete Metalk8s volume ${volumeName}: ${
+            error instanceof Error ? error.message : JSON.stringify(error)
+          }`,
+        );
+      }
+    }
+  };
 }