Enhance Metalk8sLocalVolumeProvider to support additional volume types and improve error handling in volume listing

Author: hervedombya

ui/rspack.config.ts

@@ -155,10 +155,12 @@ const config: Configuration = {
         {
           from: path.resolve(__dirname, 'build/static/js/@mf-types.zip'),
           to: '@mf-types.zip',
+          noErrorOnMissing: true,
         },
         {
           from: path.resolve(__dirname, 'build/static/js/@mf-types.d.ts'),
           to: '@mf-types.d.ts',
+          noErrorOnMissing: true,
         },
       ],
     }),

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

@@ -7,7 +7,7 @@ jest.mock('../k8s/api', () => ({
   updateApiServerConfig: jest.fn(),
 }));
 
-describe('K8SLocalVolumeProvider', () => {
+describe('Metalk8sLocalVolumeProvider', () => {
   let provider: Metalk8sLocalVolumeProvider;
   const mockUrl = 'mock-url';
   const mockToken = 'mock-token';
@@ -77,17 +77,43 @@ describe('K8SLocalVolumeProvider', () => {
                 rawBlockDevice: { devicePath: '/dev/sda' },
               },
             },
+            {
+              metadata: { name: 'test-lvm' },
+              spec: {
+                nodeName: 'test-node',
+                lvmLogicalVolume: { vgName: 'test-lvm', size: '10Gi' },
+              },
+            },
+            {
+              metadata: { name: 'test-sparseLoop' },
+              spec: {
+                nodeName: 'test-node',
+                sparseLoopDevice: {
+                  size: '1Gi',
+                },
+              },
+            },
           ],
         },
       });
 
       const volumes = await provider.listLocalPersistentVolumes('test-node');
 
-      expect(volumes).toHaveLength(1);
+      expect(volumes).toHaveLength(3);
       expect(volumes[0]).toMatchObject({
         IP: '192.168.1.100',
         devicePath: '/dev/sda',
-        metadata: { name: 'test-volume' },
+        nodeName: 'test-node',
+      });
+      expect(volumes[1]).toMatchObject({
+        IP: '192.168.1.100',
+        devicePath: 'test-lvm',
+        nodeName: 'test-node',
+      });
+      expect(volumes[2]).toMatchObject({
+        IP: '192.168.1.100',
+        devicePath: 'test-sparseLoop',
+        nodeName: 'test-node',
       });
     });
 

ui/src/services/k8s/Metalk8sLocalVolumeProvider.ts

@@ -26,14 +26,14 @@ export default class Metalk8sLocalVolumeProvider
 {
   volumeClient: Metalk8sV1alpha1VolumeClient;
   k8sClient: CoreV1Api;
-  constructor(private url: string, private token: string) {
+  constructor(url: string, token: string) {
     const { coreV1, customObjects } = ApiK8s.updateApiServerConfig(url, token);
     this.volumeClient = new Metalk8sV1alpha1VolumeClient(customObjects);
     this.k8sClient = coreV1;
   }
-  public async listLocalPersistentVolumes(
+  public listLocalPersistentVolumes = async (
     serverName: string,
-  ): Promise<LocalPersistentVolume[]> {
+  ): Promise<LocalPersistentVolume[]> => {
     try {
       const nodes = await this.k8sClient.listNode();
       const nodeIP = nodes.body.items
@@ -52,23 +52,22 @@ export default class Metalk8sLocalVolumeProvider
         );
         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,
-                nodeName: item.spec.nodeName,
-              },
-            ];
-          },
-          [],
-        );
+        const localPv = 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 || item.metadata['name'],
+              nodeName: item.spec.nodeName,
+            },
+          ];
+        }, [] as LocalPersistentVolume[]);
 
         return localPv;
       } else {
@@ -79,5 +78,5 @@ export default class Metalk8sLocalVolumeProvider
         `Failed to fetch local persistent volumes: ${error.message}`,
       );
     }
-  }
+  };
 }