diff --git a/server/dataFetcher.js b/server/dataFetcher.js
index 755aed140..3e3780fca 100644
--- a/server/dataFetcher.js
+++ b/server/dataFetcher.js
@@ -53,7 +53,60 @@ async function fetchDataForNode(apiClient, endpointId, nodeName) {
*/
async function fetchDataForPveEndpoint(endpointId, apiClientInstance, config) {
const endpointName = config.name || endpointId; // Use configured name or ID
+ let endpointType = 'standalone'; // Default to standalone
+ let actualClusterName = config.name || endpointId; // Default identifier to endpoint name
+ let standaloneNodeName = null; // To store the name of the standalone node if applicable
+
try {
+ // Attempt to determine if the endpoint is part of a multi-node cluster
+ try {
+ const clusterStatusResponse = await apiClientInstance.get('/cluster/status');
+
+ if (clusterStatusResponse.data && Array.isArray(clusterStatusResponse.data.data) && clusterStatusResponse.data.data.length > 0) {
+ const clusterInfoObject = clusterStatusResponse.data.data.find(item => item.type === 'cluster');
+ if (clusterInfoObject) {
+ if (clusterInfoObject.nodes && clusterInfoObject.nodes > 1) {
+ endpointType = 'cluster';
+ actualClusterName = clusterInfoObject.name || actualClusterName; // Use actual cluster name if available
+ } else {
+ endpointType = 'standalone'; // Still standalone if nodes <= 1
+ // Attempt to get the actual node name for the label if it's standalone
+ const nodesListForEndpoint = (await apiClientInstance.get('/nodes')).data?.data;
+ if (nodesListForEndpoint && nodesListForEndpoint.length > 0) {
+ // For a standalone or single-node cluster, use its own node name as the identifier
+ standaloneNodeName = nodesListForEndpoint[0].node;
+ }
+ }
+ } else {
+ endpointType = 'standalone';
+ const nodesListForEndpoint = (await apiClientInstance.get('/nodes')).data?.data;
+ if (nodesListForEndpoint && nodesListForEndpoint.length > 0) {
+ standaloneNodeName = nodesListForEndpoint[0].node;
+ }
+ }
+ } else {
+ console.warn(`[DataFetcher - ${endpointName}] No nodes found or unexpected format.`);
+ endpointType = 'standalone'; // Fallback
+ }
+ } catch (clusterError) {
+ console.error(`[DataFetcher - ${endpointName}] Error fetching /cluster/status: ${clusterError.message}`, clusterError);
+ endpointType = 'standalone'; // Fallback
+ // Even on /cluster/status error, try to get node name if it's likely standalone
+ try {
+ const nodesListForEndpoint = (await apiClientInstance.get('/nodes')).data?.data;
+ if (nodesListForEndpoint && nodesListForEndpoint.length > 0) {
+ standaloneNodeName = nodesListForEndpoint[0].node;
+ }
+ } catch (nodesError) {
+ console.error(`[DataFetcher - ${endpointName}] Also failed to fetch /nodes after /cluster/status error: ${nodesError.message}`);
+ }
+ }
+
+ // Update actualClusterName if this is a standalone endpoint and we found a specific node name
+ if (endpointType === 'standalone' && standaloneNodeName) {
+ actualClusterName = standaloneNodeName;
+ }
+
const nodesResponse = await apiClientInstance.get('/nodes');
const nodes = nodesResponse.data.data;
if (!nodes || !Array.isArray(nodes)) {
@@ -82,6 +135,8 @@ async function fetchDataForPveEndpoint(endpointId, apiClientInstance, config) {
status: correspondingNodeInfo.status || 'unknown',
id: `${endpointId}-${correspondingNodeInfo.node}`, // Use endpointId for node ID
endpointId: endpointId, // Use endpointId for tagging node
+ clusterIdentifier: actualClusterName, // Use actual cluster name or endpoint name
+ endpointType: endpointType, // Added to differentiate cluster vs standalone for labeling
};
if (result.status === 'fulfilled' && result.value) {
@@ -106,9 +161,9 @@ async function fetchDataForPveEndpoint(endpointId, apiClientInstance, config) {
processedNodes.push(finalNode);
} else {
if (result.status === 'rejected') {
- console.error(`[DataFetcher - ${endpointName}] Error processing node ${correspondingNodeInfo.node}: ${result.reason?.message || result.reason}`);
+ console.error(`[DataFetcher - ${endpointName}-${correspondingNodeInfo.node}] Error fetching Node status: ${result.reason?.message || result.reason}`);
} else {
- console.warn(`[DataFetcher - ${endpointName}] Unexpected result status for node ${correspondingNodeInfo.node}: ${result.status}`);
+ console.warn(`[DataFetcher - ${endpointName}-${correspondingNodeInfo.node}] Unexpected result status: ${result.status}`);
}
processedNodes.push(finalNode); // Push node with defaults on failure
}
diff --git a/server/tests/dataFetcher.test.js b/server/tests/dataFetcher.test.js
index bf857b3fb..62c2c9b1b 100644
--- a/server/tests/dataFetcher.test.js
+++ b/server/tests/dataFetcher.test.js
@@ -111,22 +111,28 @@ describe('Data Fetcher', () => {
// Configure mockPveClientInstance.get
mockPveClientInstance.get
- .mockResolvedValueOnce({ data: { data: [{ node: nodeName, status: 'online', maxcpu: 4, maxmem: 8 * 1024**3 , id: `node/${nodeName}` }] } }) // /nodes
- .mockResolvedValueOnce({ data: { data: { cpu: 0.1, mem: 2 * 1024**3, rootfs: { total: 100*1024**3, used: 20*1024**3 }, uptime: 12345 } } }) // status
- .mockResolvedValueOnce({ data: { data: [ { storage: 'local-lvm', type: 'lvmthin', content: 'images,rootdir', total: 500*1024**3, used: 150*1024**3 } ] } }) // storage
- .mockResolvedValueOnce({ data: { data: [ { vmid: vmId, name: 'test-vm', status: 'running', cpu: 0.5, mem: 1 * 1024**3, maxmem: 2 * 1024**3, maxdisk: 32*1024**3 } ] } }) // qemu
- .mockResolvedValueOnce({ data: { data: [ { vmid: ctId, name: 'test-ct', status: 'running', cpu: 0.2, mem: 512 * 1024**2, maxmem: 1 * 1024**3, maxdisk: 8*1024**3 } ] } }); // lxc
+ // Calls within fetchDataForPveEndpoint for 'primary'
+ .mockResolvedValueOnce({ data: { data: [{ type: 'cluster', nodes: 1, name: 'test-cluster' }] } }) // 1. /cluster/status (for endpoint 'primary')
+ .mockResolvedValueOnce({ data: { data: [{ node: nodeName, status: 'online' }] } }) // 2. /nodes (for endpoint 'primary' to get standaloneNodeName if cluster nodes <=1)
+ .mockResolvedValueOnce({ data: { data: [{ node: nodeName, status: 'online', maxcpu: 4, maxmem: 8 * 1024**3 , id: `node/${nodeName}` }] } }) // 3. /nodes (main call for endpoint 'primary' to get node list)
+ // Calls within fetchDataForNode for 'mock-node' (the single node from the call above)
+ .mockResolvedValueOnce({ data: { data: { cpu: 0.1, mem: 2 * 1024**3, rootfs: { total: 100*1024**3, used: 20*1024**3 }, uptime: 12345 } } }) // 4. /nodes/mock-node/status
+ .mockResolvedValueOnce({ data: { data: [ { storage: 'local-lvm', type: 'lvmthin', content: 'images,rootdir', total: 500*1024**3, used: 150*1024**3 } ] } }) // 5. /nodes/mock-node/storage
+ .mockResolvedValueOnce({ data: { data: [ { vmid: vmId, name: 'test-vm', status: 'running', cpu: 0.5, mem: 1 * 1024**3, maxmem: 2 * 1024**3, maxdisk: 32*1024**3 } ] } }) // 6. /nodes/mock-node/qemu
+ .mockResolvedValueOnce({ data: { data: [ { vmid: ctId, name: 'test-ct', status: 'running', cpu: 0.2, mem: 512 * 1024**2, maxmem: 1 * 1024**3, maxdisk: 8*1024**3 } ] } }); // 7. /nodes/mock-node/lxc
// Act: Call function with the clients provided by the (mocked) default setup
const result = await fetchDiscoveryData(mockPveApiClient, mockPbsApiClient);
// Assert
- expect(mockPveClientInstance.get).toHaveBeenCalledTimes(5);
- expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(1, '/nodes');
- expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(2, `/nodes/${nodeName}/status`);
- expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(3, `/nodes/${nodeName}/storage`);
- expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(4, `/nodes/${nodeName}/qemu`);
- expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(5, `/nodes/${nodeName}/lxc`);
+ expect(mockPveClientInstance.get).toHaveBeenCalledTimes(7); // Updated to 7
+ expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(1, '/cluster/status');
+ expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(2, '/nodes'); // For standaloneNodeName
+ expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(3, '/nodes'); // Main nodes call
+ expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(4, `/nodes/${nodeName}/status`);
+ expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(5, `/nodes/${nodeName}/storage`);
+ expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(6, `/nodes/${nodeName}/qemu`);
+ expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(7, `/nodes/${nodeName}/lxc`);
// Assert Nodes
expect(result.nodes).toHaveLength(1);
@@ -178,23 +184,26 @@ describe('Data Fetcher', () => {
test('should handle invalid format for node storage response', async () => {
// Arrange: Use default mock client
const nodeName = 'node-bad-storage-format';
+ const endpointId = 'primary';
const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
mockPveClientInstance.get
- .mockResolvedValueOnce({ data: { data: [{ node: nodeName, status: 'online' }] } }) // /nodes
- .mockResolvedValueOnce({ data: { data: { cpu: 0.1, uptime: 10 } } }) // status
- // ** Invalid storage format **
- .mockResolvedValueOnce({ data: { data: { not_an_array: true } } }) // storage
- .mockResolvedValueOnce({ data: { data: [] } }) // qemu (empty)
- .mockResolvedValueOnce({ data: { data: [] } }); // lxc (empty)
+ // Endpoint level calls
+ .mockResolvedValueOnce({ data: { data: [{ type: 'cluster', nodes: 1, name: 'test-cluster' }] } }) // 1. /cluster/status
+ .mockResolvedValueOnce({ data: { data: [{ node: nodeName }] } }) // 2. /nodes (for standaloneNodeName)
+ .mockResolvedValueOnce({ data: { data: [{ node: nodeName, status: 'online' }] } }) // 3. /nodes (main node list for endpoint)
+ // Node level calls for nodeName
+ .mockResolvedValueOnce({ data: { data: { cpu: 0.1, uptime: 10 } } }) // 4. /nodes/${nodeName}/status
+ .mockResolvedValueOnce({ data: { data: { not_an_array: true } } }) // 5. /nodes/${nodeName}/storage (INVALID)
+ .mockResolvedValueOnce({ data: { data: [] } }) // 6. /nodes/${nodeName}/qemu
+ .mockResolvedValueOnce({ data: { data: [] } }); // 7. /nodes/${nodeName}/lxc
// Act
const result = await fetchDiscoveryData(mockPveApiClient, mockPbsApiClient);
// Assert
expect(consoleWarnSpy).toHaveBeenCalledWith(
- // Adjust expected message based on actual output
- expect.stringContaining(`[DataFetcher - primary-${nodeName}] Node storage data is not an array as expected.`)
+ expect.stringContaining(`[DataFetcher - ${endpointId}-${nodeName}] Node storage data is not an array as expected.`)
);
// Ensure node was still processed and added (just without storage)
expect(result.nodes).toHaveLength(1);
@@ -208,34 +217,34 @@ describe('Data Fetcher', () => {
test('should handle missing or invalid data.data for a node resource', async () => {
// Arrange: Use default mock client and a specific node name
- const nodeName = 'node-missing-data-data';
+ const nodeName = 'node-missing-data-data'; // Can be the same or different, impact is on the mock
+ const endpointId = 'primary';
const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
- // Mock the /nodes call to return the node
- mockPveClientInstance.get.mockResolvedValueOnce({ data: { data: [{ node: nodeName, status: 'online' }] } }); // /nodes
-
- // Mock the /status call to return data with null data.data (covers lines 108-113)
- mockPveClientInstance.get.mockResolvedValueOnce({ data: { data: null } }); // status
-
- // Mock other calls to succeed with empty data to allow the test to proceed
- mockPveClientInstance.get.mockResolvedValueOnce({ data: { data: [] } }); // storage
- mockPveClientInstance.get.mockResolvedValueOnce({ data: { data: [] } }); // qemu
- mockPveClientInstance.get.mockResolvedValueOnce({ data: { data: [] } }); // lxc
+ mockPveClientInstance.get
+ // Endpoint level calls
+ .mockResolvedValueOnce({ data: { data: [{ type: 'cluster', nodes: 1, name: 'test-cluster' }] } }) // 1. /cluster/status
+ .mockResolvedValueOnce({ data: { data: [{ node: nodeName }] } }) // 2. /nodes (for standaloneNodeName)
+ .mockResolvedValueOnce({ data: { data: [{ node: nodeName, status: 'online' }] } }) // 3. /nodes (main node list for endpoint)
+ // Node level calls for nodeName
+ .mockResolvedValueOnce({ data: { data: null } }) // 4. /nodes/${nodeName}/status (INVALID data.data)
+ .mockResolvedValueOnce({ data: { data: [] } }) // 5. /nodes/${nodeName}/storage
+ .mockResolvedValueOnce({ data: { data: [] } }) // 6. /nodes/${nodeName}/qemu
+ .mockResolvedValueOnce({ data: { data: [] } }); // 7. /nodes/${nodeName}/lxc
// Act
const result = await fetchDiscoveryData(mockPveApiClient, mockPbsApiClient);
// Assert
- // Verify the warning was logged by fetchNodeResource (covers line 109)
+ // Verify the warning was logged by fetchNodeResource
expect(consoleWarnSpy).toHaveBeenCalledWith(
- `[DataFetcher - primary-${nodeName}] Node status data missing or invalid format.`
+ `[DataFetcher - ${endpointId}-${nodeName}] Node status data missing or invalid format.`
);
// Verify that the node was still processed but status data is default (null/0)
expect(result.nodes).toHaveLength(1);
expect(result.nodes[0].node).toBe(nodeName);
- expect(result.nodes[0].cpu).toBeNull(); // Should be null due to missing data.data
+ expect(result.nodes[0].cpu).toBeNull();
expect(result.nodes[0].uptime).toBe(0);
- // Other fetches should have succeeded with empty data
expect(result.nodes[0].storage).toEqual([]);
expect(result.vms).toHaveLength(0);
expect(result.containers).toHaveLength(0);
@@ -244,55 +253,51 @@ describe('Data Fetcher', () => {
});
test('should handle API error when fetching /nodes for an endpoint', async () => {
- // Arrange: Need to define specific mock clients for this test
const mockPveClientInstance1 = { get: jest.fn() };
- const mockPveClientInstance2 = { get: jest.fn() };
- // Override the default mock return value for initializeApiClients if needed,
- // OR just create the clients manually and pass them directly like before.
- // Passing manually is simpler:
- const mockClients = {
- primary: { client: mockPveClientInstance1, config: { id: 'primary', name: 'pve1' } },
- secondary: { client: mockPveClientInstance2, config: { id: 'secondary', name: 'pve2' } },
+ const mockPveClientInstance2 = { get: jest.fn() }; // Separate instance for pve2
+ const mockClients = { // Custom clients for this test
+ pve1: { client: mockPveClientInstance1, config: { id: 'pve1', name: 'PVE1 Endpoint' } },
+ pve2: { client: mockPveClientInstance2, config: { id: 'pve2', name: 'PVE2 Endpoint' } },
};
const nodesError = new Error('Network Error on PVE1');
- const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {}); // SETUP SPY HERE
+ const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
- // Configure mocks
- mockPveClientInstance1.get.mockRejectedValueOnce(nodesError);
+ // Configure mockPveClientInstance1 (fails on main /nodes call)
+ mockPveClientInstance1.get
+ .mockResolvedValueOnce({ data: { data: [{ type: 'cluster', nodes: 1, name: 'pve1-cluster' }] } }) // 1. /cluster/status
+ .mockResolvedValueOnce({ data: { data: [{ node: 'pve1-node-temp' }] } }) // 2. /nodes (standalone)
+ .mockRejectedValueOnce(nodesError); // 3. /nodes (main list) -> FAILS
+
+ // Configure mockPveClientInstance2 (succeeds fully, no VMs/CTs)
mockPveClientInstance2.get
- .mockResolvedValueOnce({ data: { data: [{ node: 'node-pve2', status: 'online' }] } })
- .mockResolvedValueOnce({ data: { data: { cpu: 0.1, uptime: 10 } } })
- .mockResolvedValueOnce({ data: { data: [] } })
- .mockResolvedValueOnce({ data: { data: [] } })
- .mockResolvedValueOnce({ data: { data: [] } });
+ .mockResolvedValueOnce({ data: { data: [{ type: 'cluster', nodes: 1, name: 'pve2-cluster' }] } }) // 1. /cluster/status
+ .mockResolvedValueOnce({ data: { data: [{ node: 'node-pve2' }] } }) // 2. /nodes (standalone)
+ .mockResolvedValueOnce({ data: { data: [{ node: 'node-pve2', status: 'online' }] } }) // 3. /nodes (main list)
+ .mockResolvedValueOnce({ data: { data: { cpu: 0.1, uptime: 10 } } }) // 4. /nodes/node-pve2/status
+ .mockResolvedValueOnce({ data: { data: [] } }) // 5. /nodes/node-pve2/storage
+ .mockResolvedValueOnce({ data: { data: [] } }) // 6. /nodes/node-pve2/qemu
+ .mockResolvedValueOnce({ data: { data: [] } }); // 7. /nodes/node-pve2/lxc <<< SHOULD BE EMPTY
- // Act
- const result = await fetchDiscoveryData(mockClients, {}); // Pass the specific mock clients
+ const result = await fetchDiscoveryData(mockClients, {}); // Pass custom clients
- // Assert
- expect(mockPveClientInstance1.get).toHaveBeenCalledTimes(1);
- expect(mockPveClientInstance1.get).toHaveBeenCalledWith('/nodes');
- expect(mockPveClientInstance2.get).toHaveBeenCalledTimes(5); // nodes, status, storage, qemu, lxc
-
- // Check that the error for the failed endpoint was logged
+ // Assertions for pve1 (failed endpoint)
+ expect(mockPveClientInstance1.get).toHaveBeenCalledTimes(3);
expect(consoleErrorSpy).toHaveBeenCalledWith(
- // The error is now caught and logged within fetchDataForPveEndpoint
- expect.stringContaining(`[DataFetcher - pve1] Error fetching PVE discovery data: ${nodesError.message}`)
+ expect.stringContaining(`[DataFetcher - PVE1 Endpoint] Error fetching PVE discovery data: ${nodesError.message}`)
);
- // The second log message about endpoint failure is no longer generated in this path after refactor
- // expect(consoleErrorSpy).toHaveBeenCalledWith(
- // expect.stringContaining(`[DataFetcher] PVE discovery failed for endpoint: pve1. Reason: ${nodesError.message}`)
- // );
- // Should still return data from the successful endpoint (as fetchDataForPveEndpoint returns empty on error)
+ // Assert mockPveClientInstance2 (successful endpoint)
+ expect(mockPveClientInstance2.get).toHaveBeenCalledTimes(7);
+
+ // Should still return data from the successful endpoint (pve2)
expect(result.nodes).toHaveLength(1);
expect(result.nodes[0].node).toBe('node-pve2');
- expect(result.nodes[0].endpointId).toBe('secondary'); // Corrected expectation: Should be the endpointId from the mock client setup
+ expect(result.nodes[0].endpointId).toBe('pve2');
expect(result.vms).toHaveLength(0);
expect(result.containers).toHaveLength(0);
expect(result.pbs).toHaveLength(0);
- consoleErrorSpy.mockRestore(); // RESTORE SPY HERE
+ consoleErrorSpy.mockRestore();
});
test('should handle API error when fetching guests for a specific node', async () => {
@@ -374,34 +379,34 @@ describe('Data Fetcher', () => {
test('should handle missing or invalid data.data for a node resource', async () => {
// Arrange: Use default mock client and a specific node name
- const nodeName = 'node-missing-data-data';
+ const nodeName = 'node-missing-data-data'; // Can be the same or different, impact is on the mock
+ const endpointId = 'primary';
const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
- // Mock the /nodes call to return the node
- mockPveClientInstance.get.mockResolvedValueOnce({ data: { data: [{ node: nodeName, status: 'online' }] } }); // /nodes
-
- // Mock the /status call to return data with null data.data (covers lines 108-113)
- mockPveClientInstance.get.mockResolvedValueOnce({ data: { data: null } }); // status
-
- // Mock other calls to succeed with empty data to allow the test to proceed
- mockPveClientInstance.get.mockResolvedValueOnce({ data: { data: [] } }); // storage
- mockPveClientInstance.get.mockResolvedValueOnce({ data: { data: [] } }); // qemu
- mockPveClientInstance.get.mockResolvedValueOnce({ data: { data: [] } }); // lxc
+ mockPveClientInstance.get
+ // Endpoint level calls
+ .mockResolvedValueOnce({ data: { data: [{ type: 'cluster', nodes: 1, name: 'test-cluster' }] } }) // 1. /cluster/status
+ .mockResolvedValueOnce({ data: { data: [{ node: nodeName }] } }) // 2. /nodes (for standaloneNodeName)
+ .mockResolvedValueOnce({ data: { data: [{ node: nodeName, status: 'online' }] } }) // 3. /nodes (main node list for endpoint)
+ // Node level calls for nodeName
+ .mockResolvedValueOnce({ data: { data: null } }) // 4. /nodes/${nodeName}/status (INVALID data.data)
+ .mockResolvedValueOnce({ data: { data: [] } }) // 5. /nodes/${nodeName}/storage
+ .mockResolvedValueOnce({ data: { data: [] } }) // 6. /nodes/${nodeName}/qemu
+ .mockResolvedValueOnce({ data: { data: [] } }); // 7. /nodes/${nodeName}/lxc
// Act
const result = await fetchDiscoveryData(mockPveApiClient, mockPbsApiClient);
// Assert
- // Verify the warning was logged by fetchNodeResource (covers line 109)
+ // Verify the warning was logged by fetchNodeResource
expect(consoleWarnSpy).toHaveBeenCalledWith(
- `[DataFetcher - primary-${nodeName}] Node status data missing or invalid format.`
+ `[DataFetcher - ${endpointId}-${nodeName}] Node status data missing or invalid format.`
);
// Verify that the node was still processed but status data is default (null/0)
expect(result.nodes).toHaveLength(1);
expect(result.nodes[0].node).toBe(nodeName);
- expect(result.nodes[0].cpu).toBeNull(); // Should be null due to missing data.data
+ expect(result.nodes[0].cpu).toBeNull();
expect(result.nodes[0].uptime).toBe(0);
- // Other fetches should have succeeded with empty data
expect(result.nodes[0].storage).toEqual([]);
expect(result.vms).toHaveLength(0);
expect(result.containers).toHaveLength(0);
@@ -415,11 +420,15 @@ describe('Data Fetcher', () => {
const nodeName = 'pve-node';
const vmId = 200;
mockPveClientInstance.get
- .mockResolvedValueOnce({ data: { data: [{ node: nodeName, status: 'online' }] } }) // /nodes
- .mockResolvedValueOnce({ data: { data: { uptime: 1 } } }) // status
- .mockResolvedValueOnce({ data: { data: [] } }) // storage
- .mockResolvedValueOnce({ data: { data: [{ vmid: vmId, name: 'pve-vm' }] } }) // qemu
- .mockResolvedValueOnce({ data: { data: [] } }); // lxc
+ // PVE Endpoint calls
+ .mockResolvedValueOnce({ data: { data: [{ type: 'cluster', nodes: 1, name: 'test-cluster' }] } }) // 1. /cluster/status
+ .mockResolvedValueOnce({ data: { data: [{ node: nodeName }] } }) // 2. /nodes (standalone)
+ .mockResolvedValueOnce({ data: { data: [{ node: nodeName, status: 'online' }] } }) // 3. /nodes (main list)
+ // PVE Node calls for nodeName
+ .mockResolvedValueOnce({ data: { data: { uptime: 1 } } }) // 4. /nodes/${nodeName}/status
+ .mockResolvedValueOnce({ data: { data: [] } }) // 5. /nodes/${nodeName}/storage
+ .mockResolvedValueOnce({ data: { data: [{ vmid: vmId, name: 'pve-vm' }] } }) // 6. /nodes/${nodeName}/qemu
+ .mockResolvedValueOnce({ data: { data: [] } }); // 7. /nodes/${nodeName}/lxc
// Arrange PBS (Mock the function to be injected)
const mockPbsFunction = jest.fn();
@@ -489,11 +498,15 @@ describe('Data Fetcher', () => {
const nodeName = 'pve-node';
const vmId = 200;
mockPveClientInstance.get
- .mockResolvedValueOnce({ data: { data: [{ node: nodeName, status: 'online' }] } }) // /nodes
- .mockResolvedValueOnce({ data: { data: { uptime: 1 } } }) // status
- .mockResolvedValueOnce({ data: { data: [] } }) // storage
- .mockResolvedValueOnce({ data: { data: [{ vmid: vmId, name: 'pve-vm' }] } }) // qemu
- .mockResolvedValueOnce({ data: { data: [] } }); // lxc
+ // PVE Endpoint calls
+ .mockResolvedValueOnce({ data: { data: [{ type: 'cluster', nodes: 1, name: 'test-cluster' }] } }) // 1. /cluster/status
+ .mockResolvedValueOnce({ data: { data: [{ node: nodeName }] } }) // 2. /nodes (standalone)
+ .mockResolvedValueOnce({ data: { data: [{ node: nodeName, status: 'online' }] } }) // 3. /nodes (main list)
+ // PVE Node calls for nodeName
+ .mockResolvedValueOnce({ data: { data: { uptime: 1 } } }) // 4. /nodes/${nodeName}/status
+ .mockResolvedValueOnce({ data: { data: [] } }) // 5. /nodes/${nodeName}/storage
+ .mockResolvedValueOnce({ data: { data: [{ vmid: vmId, name: 'pve-vm' }] } }) // 6. /nodes/${nodeName}/qemu
+ .mockResolvedValueOnce({ data: { data: [] } }); // 7. /nodes/${nodeName}/lxc
// Arrange PBS: Pass an empty object for PBS clients, mock injected function
const emptyPbsClients = {};
@@ -513,144 +526,187 @@ describe('Data Fetcher', () => {
});
test('should handle error fetching Containers (lxc)', async () => {
- // Arrange: Use default mock client
- const nodeName = 'node-bad-lxc';
+ // Arrange: Uses the default mock clients from beforeEach
+ const nodeNameGood = 'node-good';
+ const nodeNameBad = 'node-bad-guests'; // This node will have the LXC fetch error
+ const endpointId = 'primary'; // Default endpointId from mockPveApiClient setup
const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
- mockPveClientInstance.get
- .mockResolvedValueOnce({ data: { data: [{ node: nodeName, status: 'online' }] } }) // /nodes
- .mockResolvedValueOnce({ data: { data: { cpu: 0.1, uptime: 10 } } }) // status
- .mockResolvedValueOnce({ data: { data: [] } }) // storage (empty)
- .mockResolvedValueOnce({ data: { data: [{ vmid: 200, name: 'vm-ok', status: 'running' }] } }) // qemu (ok)
- // ** Reject lxc call **
- .mockRejectedValueOnce(new Error('Simulated LXC Fetch Error')); // lxc
+ mockPveClientInstance.get.mockImplementation(async (url) => {
+ // Endpoint level calls - needed for the overall fetchDiscoveryData structure
+ if (url === '/cluster/status') {
+ return { data: { data: [{ type: 'cluster', nodes: 2, name: 'test-cluster' }] } }; // Simulate a cluster with 2 nodes
+ }
+ if (url === '/nodes') { // This is the main /nodes call for the endpoint
+ return { data: { data: [
+ { node: nodeNameGood, status: 'online', id: `node/${nodeNameGood}` },
+ { node: nodeNameBad, status: 'online', id: `node/${nodeNameBad}` }
+ ]}};
+ }
- // Act
+ // Calls for nodeNameGood (all succeed)
+ if (url === `/nodes/${nodeNameGood}/status`) return { data: { data: { cpu: 0.1, uptime: 10 } } };
+ if (url === `/nodes/${nodeNameGood}/storage`) return { data: { data: [] } };
+ if (url === `/nodes/${nodeNameGood}/qemu`) return { data: { data: [ { vmid: 100, name: 'vm-good', status: 'running' } ] } };
+ if (url === `/nodes/${nodeNameGood}/lxc`) return { data: { data: [] } };
+
+ // Calls for nodeNameBad
+ if (url === `/nodes/${nodeNameBad}/status`) return { data: { data: { cpu: 0.2, uptime: 20 } } };
+ if (url === `/nodes/${nodeNameBad}/storage`) return { data: { data: [] } };
+ if (url === `/nodes/${nodeNameBad}/qemu`) return { data: { data: [] } }; // QEMU succeeds
+ if (url === `/nodes/${nodeNameBad}/lxc`) { // LXC fetch fails
+ throw new Error('Simulated LXC Fetch Error');
+ }
+
+ // Fallback for unexpected calls
+ console.warn(`Unexpected API call in mockImplementation: ${url}`);
+ throw new Error(`Unexpected API call in mock: ${url}`);
+ });
+
+ // Act: Uses the default mock clients from beforeEach
const result = await fetchDiscoveryData(mockPveApiClient, mockPbsApiClient);
// Assert
expect(consoleErrorSpy).toHaveBeenCalledWith(
- expect.stringContaining(`[DataFetcher - primary-${nodeName}] Error fetching Containers (lxc): Simulated LXC Fetch Error`)
+ expect.stringContaining(`[DataFetcher - ${endpointId}-${nodeNameBad}] Error fetching Containers (lxc): Simulated LXC Fetch Error`)
);
- // Node and VMs should still be present
- expect(result.nodes).toHaveLength(1);
- expect(result.nodes[0].node).toBe(nodeName);
- expect(result.vms).toHaveLength(1);
- expect(result.vms[0].vmid).toBe(200);
- // Containers should be empty
- expect(result.containers).toHaveLength(0);
+ // Check that the correct number of nodes is returned
+ expect(result.nodes).toHaveLength(2);
+
+ const goodNodeResult = result.nodes.find(n => n.node === nodeNameGood);
+ const badNodeResult = result.nodes.find(n => n.node === nodeNameBad);
+ expect(goodNodeResult).toBeDefined();
+ expect(badNodeResult).toBeDefined();
+
+ // VMs/CTs from the good node should be present
+ expect(result.vms).toHaveLength(1); // From nodeNameGood
+ expect(result.vms[0].vmid).toBe(100);
+ // Containers from nodeNameGood are [], and from nodeNameBad failed, so overall should be []
+ expect(result.containers).toHaveLength(0);
+
consoleErrorSpy.mockRestore();
});
test('should handle errors fetching node status and storage', async () => {
- // Arrange: Use default mock client
- const nodeName = 'node-bad-status-storage';
- const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
- const statusError = new Error('Status fetch failed');
- const storageError = new Error('Storage fetch failed');
+ // Arrange
+ const nodeName = 'node-bad-status-storage'; // This won't be used as errors occur at endpoint/node list level
+ const endpointId = 'primary';
+ const endpointConfig = mockPveApiClient[endpointId].config; // Get the config for name
- mockPveClientInstance.get
- .mockResolvedValueOnce({ data: { data: [{ node: nodeName, status: 'online' }] } }) // /nodes
- .mockRejectedValueOnce(statusError) // status fails
- .mockRejectedValueOnce(storageError) // storage fails
- .mockResolvedValueOnce({ data: { data: [] } }) // qemu (ok)
- .mockResolvedValueOnce({ data: { data: [] } }); // lxc (ok)
+ const statusError = new Error('Status fetch failed');
+ const storageError = new Error('Storage fetch failed'); // This will be for the /nodes call
+ const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+ mockPveClientInstance.get.mockImplementation(async (url) => {
+ if (url === '/cluster/status') {
+ // console.log(`Mock: ${url} throwing statusError`);
+ throw statusError;
+ }
+ // This will be called by the catch block of /cluster/status, and potentially the main /nodes call
+ if (url === '/nodes') {
+ // console.log(`Mock: ${url} throwing storageError`);
+ throw storageError;
+ }
+ // console.warn(`Mock: Unexpected call to ${url}`);
+ throw new Error(`Unexpected API call in mock for failing status/storage: ${url}`);
+ });
// Act
const result = await fetchDiscoveryData(mockPveApiClient, mockPbsApiClient);
// Assert
+ // Check the first call to console.error specifically for the /cluster/status failure
+ const firstCallArgs = consoleErrorSpy.mock.calls[0];
+ const expectedLogMessagePart = `[DataFetcher - primary] Error fetching /cluster/status: ${statusError.message}`;
+ expect(firstCallArgs[0]).toContain(expectedLogMessagePart);
+ expect(firstCallArgs[1]).toBeInstanceOf(Error);
+ expect(firstCallArgs[1].message).toBe(statusError.message);
+
+ // Check the second call for the /nodes failure after /cluster/status
expect(consoleErrorSpy).toHaveBeenCalledWith(
- // Adjust expected message (capital 'N' in 'Node')
- expect.stringContaining(`[DataFetcher - primary-${nodeName}] Error fetching Node status: ${statusError.message}`)
- );
+ expect.stringContaining(`[DataFetcher - ${endpointConfig.name}] Also failed to fetch /nodes after /cluster/status error: ${storageError.message}`)
+ );
+ // Third error log from the main catch block in fetchDataForPveEndpoint
expect(consoleErrorSpy).toHaveBeenCalledWith(
- // Adjust expected message (capital 'N' in 'Node')
- expect.stringContaining(`[DataFetcher - primary-${nodeName}] Error fetching Node storage: ${storageError.message}`)
- );
- // Ensure node was still processed and added (just without status/storage)
- expect(result.nodes).toHaveLength(1);
- expect(result.nodes[0].node).toBe(nodeName);
- // Check status fields are null (or default) as the status fetch failed
- expect(result.nodes[0]).toMatchObject({
- cpu: null,
- mem: null,
- disk: null,
- maxdisk: null, // Check maxdisk too
- uptime: 0,
- loadavg: null,
+ expect.stringContaining(`[DataFetcher - ${endpointConfig.name}] Error fetching PVE discovery data: ${storageError.message}`)
+ );
+ expect(consoleErrorSpy).toHaveBeenCalledTimes(3);
+
+ // Data should be empty for this endpoint due to critical failures
+ expect(result.nodes).toEqual([]);
+ expect(result.vms).toEqual([]);
+ expect(result.containers).toEqual([]);
+
+ consoleErrorSpy.mockRestore();
});
- expect(result.nodes[0].storage).toEqual([]); // Storage is empty
- expect(result.vms).toHaveLength(0);
- expect(result.containers).toHaveLength(0);
-
- consoleErrorSpy.mockRestore();
- });
test('should handle invalid format for node status response (invalid data.data)', async () => {
- // Arrange: Use default mock client
- const nodeName = 'node-bad-status-data';
+ const nodeName = 'node-bad-status-data'; // A unique name for this test case
+ const endpointId = 'primary';
const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
mockPveClientInstance.get
- .mockResolvedValueOnce({ data: { data: [{ node: nodeName, status: 'online' }] } }) // /nodes
- .mockResolvedValueOnce({ data: { data: null } }) // status (data.data is null - should trigger warn)
- .mockResolvedValueOnce({ data: { data: [] } }) // storage (ok)
- .mockResolvedValueOnce({ data: { data: [] } }) // qemu (ok)
- .mockResolvedValueOnce({ data: { data: [] } }); // lxc (ok)
+ // Endpoint level calls
+ .mockResolvedValueOnce({ data: { data: [{ type: 'cluster', nodes: 1, name: 'test-cluster' }] } }) // 1. /cluster/status
+ .mockResolvedValueOnce({ data: { data: [{ node: nodeName }] } }) // 2. /nodes (for standaloneNodeName)
+ .mockResolvedValueOnce({ data: { data: [{ node: nodeName, status: 'online' }] } }) // 3. /nodes (main node list for endpoint)
+ // Node level calls for nodeName
+ .mockResolvedValueOnce({ data: { data: null } }) // <--- Invalid: data.data is null for /status
+ .mockResolvedValueOnce({ data: { data: [] } }) // storage
+ .mockResolvedValueOnce({ data: { data: [] } }) // qemu
+ .mockResolvedValueOnce({ data: { data: [] } }); // lxc
- // Act
const result = await fetchDiscoveryData(mockPveApiClient, mockPbsApiClient);
// Assert
expect(consoleWarnSpy).toHaveBeenCalledWith(
- expect.stringContaining(`[DataFetcher - primary-${nodeName}] Node status data missing or invalid format.`)
+ expect.stringContaining(`[DataFetcher - ${endpointId}-${nodeName}] Node status data missing or invalid format.`)
);
- // Node should still exist, but status fields should be default
+ // Node should still exist, but status fields should be default/null
expect(result.nodes).toHaveLength(1);
expect(result.nodes[0].node).toBe(nodeName);
expect(result.nodes[0].cpu).toBeNull();
+ expect(result.nodes[0].mem).toBeNull(); // or existing value if not overwritten by status
expect(result.nodes[0].uptime).toBe(0);
- expect(result.nodes[0].status).toBe('online'); // Status from /nodes remains
consoleWarnSpy.mockRestore();
});
test('should handle invalid format for node status response', async () => {
- // Arrange: Use default mock client
- const nodeName = 'node-bad-status-format';
+ const nodeName = 'node-bad-status-format'; // Test a node where its /status call fails
+ const endpointId = 'primary';
+ const endpointConfig = mockPveApiClient[endpointId].config;
+ const statusFetchError = new Error('Node Status Network Error');
const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
mockPveClientInstance.get
- .mockResolvedValueOnce({ data: { data: [{ node: nodeName, status: 'online' }] } }) // /nodes
- .mockRejectedValueOnce(new Error('Status fetch failed')) // status fails
- .mockResolvedValueOnce({ data: { data: [] } }) // qemu (ok)
- .mockResolvedValueOnce({ data: { data: [] } }); // lxc (ok)
+ .mockResolvedValueOnce({ data: { data: [{ type: 'cluster', nodes: 1, name: 'test-cluster' }] } }) // 1. /cluster/status
+ .mockResolvedValueOnce({ data: { data: [{ node: nodeName }] } }) // 2. /nodes (for standaloneNodeName)
+ .mockResolvedValueOnce({ data: { data: [{ node: nodeName, status: 'online' }] } }) // 3. /nodes (main node list for endpoint)
+ .mockRejectedValueOnce(statusFetchError) // 4. /nodes/${nodeName}/status << THIS FAILS
+ .mockResolvedValueOnce({ data: { data: [] } }) // 5. /nodes/${nodeName}/storage (subsequent calls should still be mocked)
+ .mockResolvedValueOnce({ data: { data: [] } }) // 6. /nodes/${nodeName}/qemu
+ .mockResolvedValueOnce({ data: { data: [] } }); // 7. /nodes/${nodeName}/lxc
- // Act
const result = await fetchDiscoveryData(mockPveApiClient, mockPbsApiClient);
- // Assert
- expect(consoleErrorSpy).toHaveBeenCalledWith(
- // Adjust expected message (capital 'N' in 'Node')
- expect.stringContaining(`[DataFetcher - primary-${nodeName}] Error fetching Node status: Status fetch failed`)
- );
- // Ensure node was still processed and added (just without status)
+ // Assert error logging
+ // Only one log from fetchNodeResource, as it catches the error and returns null,
+ // so the promise in fetchDataForPveEndpoint for this node is fulfilled.
+ expect(consoleErrorSpy).toHaveBeenCalledWith(
+ expect.stringContaining(`[DataFetcher - ${endpointId}-${nodeName}] Error fetching Node status: ${statusFetchError.message}`)
+ );
+ expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
+
+ // Assert node data (node should exist, but with default/error state for status)
expect(result.nodes).toHaveLength(1);
expect(result.nodes[0].node).toBe(nodeName);
- // Check status fields are null (or default) as the status fetch failed
- expect(result.nodes[0]).toMatchObject({
- cpu: null,
- mem: null,
- disk: null,
- maxdisk: null, // Check maxdisk too
- uptime: 0,
- loadavg: null,
- });
- expect(result.nodes[0].storage).toEqual([]); // Storage is empty
- expect(result.vms).toHaveLength(0);
- expect(result.containers).toHaveLength(0);
+ expect(result.nodes[0].cpu).toBeNull();
+ expect(result.nodes[0].mem).toBeNull();
+ expect(result.nodes[0].uptime).toBe(0);
+ // Other parts like storage should be processed if their mocks are fine (empty array here)
+ expect(result.nodes[0].storage).toEqual([]);
consoleErrorSpy.mockRestore();
});
diff --git a/src/index.css b/src/index.css
index 6ca01259d..03e4e4aaf 100644
--- a/src/index.css
+++ b/src/index.css
@@ -5,3 +5,13 @@
.overflow-y-hidden {
overflow-y: hidden;
}
+
+.subtle-stripes-light {
+ background-image: linear-gradient(45deg, rgba(0, 0, 0, 0.05) 25%, transparent 25%, transparent 50%, rgba(0, 0, 0, 0.05) 50%, rgba(0, 0, 0, 0.05) 75%, transparent 75%, transparent);
+ background-size: 10px 10px;
+}
+
+.subtle-stripes-dark {
+ background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.04) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.04) 50%, rgba(255, 255, 255, 0.04) 75%, transparent 75%, transparent);
+ background-size: 10px 10px; /* Explicitly set for dark mode too */
+}
diff --git a/src/public/js/ui/common.js b/src/public/js/ui/common.js
index 3af78ee27..944f12ea2 100644
--- a/src/public/js/ui/common.js
+++ b/src/public/js/ui/common.js
@@ -278,30 +278,36 @@ PulseApp.ui.common = (() => {
}
function resetDashboardView() {
+ // Reset search
if (searchInput) searchInput.value = '';
- PulseApp.state.setSortState('main', 'id', 'asc');
- const groupGroupedRadio = document.getElementById('group-grouped');
- if(groupGroupedRadio) groupGroupedRadio.checked = true;
+ // Reset filters to defaults
PulseApp.state.set('groupByNode', true);
-
- const filterAllRadio = document.getElementById('filter-all');
- if(filterAllRadio) filterAllRadio.checked = true;
+ document.getElementById('group-grouped').checked = true;
PulseApp.state.set('filterGuestType', 'all');
-
- const statusAllRadio = document.getElementById('filter-status-all');
- if(statusAllRadio) statusAllRadio.checked = true;
+ document.getElementById('filter-all').checked = true;
PulseApp.state.set('filterStatus', 'all');
+ document.getElementById('filter-status-all').checked = true;
- PulseApp.ui.thresholds.resetThresholds();
+ // Reset thresholds
+ PulseApp.ui.thresholds.resetThresholds(); // This will also trigger a save
+
+ // Update table and save states
PulseApp.ui.dashboard.updateDashboardTable();
- if (searchInput) searchInput.blur();
- PulseApp.ui.thresholds.updateLogControlsVisibility();
- PulseApp.state.saveFilterState(); // Save reset state
+ PulseApp.state.saveFilterState(); // Thresholds are saved by its own reset
+ // Sort state is not reset by this action intentionally
+ }
+
+ function generateNodeGroupHeaderCellHTML(text, colspan, cellTag = 'td') {
+ const cellClasses = 'py-0.5 px-2 bg-gray-200 dark:bg-gray-700 subtle-stripes-light dark:subtle-stripes-dark text-left font-medium text-sm text-gray-700 dark:text-gray-300';
+ return `<${cellTag} colspan="${colspan}" class="${cellClasses}">${text}`;
}
return {
init,
- updateSortUI
+ updateSortUI,
+ setupTableSorting,
+ resetDashboardView,
+ generateNodeGroupHeaderCellHTML
};
})();
diff --git a/src/public/js/ui/dashboard.js b/src/public/js/ui/dashboard.js
index b4daf7bf6..3133d9398 100644
--- a/src/public/js/ui/dashboard.js
+++ b/src/public/js/ui/dashboard.js
@@ -274,10 +274,7 @@ PulseApp.ui.dashboard = (() => {
visibleNodes.add(nodeName.toLowerCase());
const nodeHeaderRow = document.createElement('tr');
nodeHeaderRow.className = 'node-header bg-gray-100 dark:bg-gray-700/80 font-semibold text-gray-700 dark:text-gray-300 text-xs';
- nodeHeaderRow.innerHTML = `|
-
- ${nodeName}
- | `;
+ nodeHeaderRow.innerHTML = PulseApp.ui.common.generateNodeGroupHeaderCellHTML(nodeName, 11, 'td');
tableBody.appendChild(nodeHeaderRow);
nodeGroups[nodeName].forEach(guest => {
diff --git a/src/public/js/ui/nodes.js b/src/public/js/ui/nodes.js
index 4239312c3..d9b80c403 100644
--- a/src/public/js/ui/nodes.js
+++ b/src/public/js/ui/nodes.js
@@ -79,20 +79,53 @@ PulseApp.ui.nodes = (() => {
console.error('Critical element #nodes-table-body not found for nodes table update!');
return;
}
- // tbody.innerHTML = ''; // Handled by renderTableBody
+ tbody.innerHTML = ''; // Clear previous content
+
+ if (!nodes || nodes.length === 0) {
+ tbody.innerHTML = '| No nodes found or data unavailable |
';
+ return;
+ }
+
+ // Group nodes by clusterIdentifier
+ const clusters = nodes.reduce((acc, node) => {
+ const key = node.clusterIdentifier || 'Unknown Cluster'; // Fallback for safety
+ if (!acc[key]) {
+ acc[key] = [];
+ }
+ acc[key].push(node);
+ return acc;
+ }, {});
const sortStateNodes = PulseApp.state.getSortState('nodes');
- const dataToDisplay = PulseApp.utils.sortData(nodes, sortStateNodes.column, sortStateNodes.direction, 'nodes');
- // if (dataToDisplay.length === 0) { // Handled by renderTableBody
- // tbody.innerHTML = '| No nodes found or data unavailable |
';
- // return;
- // }
+ // Iterate over each cluster group
+ for (const clusterIdentifier in clusters) {
+ if (clusters.hasOwnProperty(clusterIdentifier)) {
+ const nodesInCluster = clusters[clusterIdentifier];
+ // All nodes in this group should have the same endpointType, so pick from the first.
+ // Default to 'standalone' if nodesInCluster is empty or endpointType is missing for some reason.
+ const endpointType = (nodesInCluster && nodesInCluster.length > 0 && nodesInCluster[0].endpointType)
+ ? nodesInCluster[0].endpointType
+ : 'standalone';
+
+ const iconSvg = endpointType === 'cluster'
+ ? PulseApp.ui.common.NODE_GROUP_CLUSTER_ICON_SVG
+ : PulseApp.ui.common.NODE_GROUP_STANDALONE_ICON_SVG;
- // Use the utility function
- PulseApp.utils.renderTableBody(tbody, dataToDisplay, createNodeRow, "No nodes found or data unavailable", 7);
-
- // REMOVED: dataToDisplay.forEach(node => { ... tbody.appendChild(row); });
+ const clusterHeaderRow = document.createElement('tr');
+ // Applying base background, then overlaying with stripe pattern classes
+ clusterHeaderRow.innerHTML = PulseApp.ui.common.generateNodeGroupHeaderCellHTML(clusterIdentifier, 7, 'th');
+ tbody.appendChild(clusterHeaderRow);
+
+ // Sort nodes within this cluster group
+ const sortedNodesInCluster = PulseApp.utils.sortData(nodesInCluster, sortStateNodes.column, sortStateNodes.direction, 'nodes');
+
+ sortedNodesInCluster.forEach(node => {
+ const nodeRow = createNodeRow(node);
+ tbody.appendChild(nodeRow);
+ });
+ }
+ }
}
return {
diff --git a/src/public/js/ui/storage.js b/src/public/js/ui/storage.js
index a0735bd28..a69202cdf 100644
--- a/src/public/js/ui/storage.js
+++ b/src/public/js/ui/storage.js
@@ -123,11 +123,7 @@ PulseApp.ui.storage = (() => {
const nodeHeaderRow = document.createElement('tr');
nodeHeaderRow.className = 'bg-gray-100 dark:bg-gray-700/80 font-semibold text-gray-700 dark:text-gray-300 text-xs node-storage-header';
- nodeHeaderRow.innerHTML = `
-
-
- Node: ${nodeName}
- | `;
+ nodeHeaderRow.innerHTML = PulseApp.ui.common.generateNodeGroupHeaderCellHTML(`Node: ${nodeName}`, 7, 'td');
tbody.appendChild(nodeHeaderRow);
if (nodeStorageData.length === 0) {