diff --git a/pkg/harvester/config/feature-flags.js b/pkg/harvester/config/feature-flags.js
index 421a3c19..f88e5a84 100644
--- a/pkg/harvester/config/feature-flags.js
+++ b/pkg/harvester/config/feature-flags.js
@@ -88,6 +88,7 @@ const FEATURE_FLAGS = {
'componentHealth',
'repositoryStorageClass',
'shutdownVMOnMigrationFailure',
+ 'vmListPagination',
],
};
diff --git a/pkg/harvester/config/harvester-cluster.js b/pkg/harvester/config/harvester-cluster.js
index ee273b5d..b3a7fc03 100644
--- a/pkg/harvester/config/harvester-cluster.js
+++ b/pkg/harvester/config/harvester-cluster.js
@@ -54,6 +54,8 @@ import {
FORKLIFT_PLAN_TARGET_NS,
FORKLIFT_PLAN_VM_COUNT,
FORKLIFT_MIGRATION_PLAN,
+ VM_HEADERS,
+ VM_PAGINATION_HEADERS,
} from './table-headers';
import { ADD_ONS } from './harvester-map';
import { registerAddonSideNav } from '../utils/dynamic-nav';
@@ -257,6 +259,7 @@ export function init($plugin, store) {
basicType([HCI.VM]);
configureType(HCI.VM, { canYaml: false });
+ headers(HCI.VM, VM_HEADERS, VM_PAGINATION_HEADERS);
virtualType({
labelKey: 'harvester.virtualMachine.label',
group: 'root',
diff --git a/pkg/harvester/config/labels-annotations.js b/pkg/harvester/config/labels-annotations.js
index 38d2c955..676311c7 100644
--- a/pkg/harvester/config/labels-annotations.js
+++ b/pkg/harvester/config/labels-annotations.js
@@ -21,6 +21,7 @@ export const HCI = {
VM_NAME: 'harvesterhci.io/vmName',
VM_NAME_PREFIX: 'harvesterhci.io/vmNamePrefix',
VM_DISPLAY_NAME: 'harvesterhci.io/vmDisplayName',
+ VMI_CREATED_BY: 'kubevirt.io/created-by',
VM_RESERVED_MEMORY: 'harvesterhci.io/reservedMemory',
MAINTENANCE_STATUS: 'harvesterhci.io/maintain-status', // Deprecated >= v1.10.0
HOST_CUSTOM_NAME: 'harvesterhci.io/host-custom-name',
diff --git a/pkg/harvester/config/table-headers.js b/pkg/harvester/config/table-headers.js
index c93fb920..60e4e8b4 100644
--- a/pkg/harvester/config/table-headers.js
+++ b/pkg/harvester/config/table-headers.js
@@ -1,7 +1,10 @@
/**
* Harvester
*/
-import { DESCRIPTION } from '@shell/config/table-headers';
+import {
+ DESCRIPTION, STATE, AGE, NAME, NAMESPACE
+} from '@shell/config/table-headers';
+import { HCI as HCI_ANNOTATIONS } from './labels-annotations';
// image
export const IMAGE_DOWNLOAD_SIZE = {
@@ -297,3 +300,85 @@ export const FORKLIFT_MIGRATION_PLAN = {
sort: 'spec.plan.name',
align: 'left',
};
+
+// Virtual machine list
+export const VM_HEADERS = [
+ STATE,
+ {
+ ...NAME,
+ width: 350,
+ value: 'nameDisplay',
+ sort: ['nameDisplay'],
+ },
+ NAMESPACE,
+ {
+ name: 'CPU',
+ label: 'CPU',
+ sort: ['displayCPU'],
+ value: 'displayCPU',
+ align: 'center',
+ dashIfEmpty: true,
+ },
+ {
+ name: 'Memory',
+ value: 'displayMemory',
+ sort: ['memorySort'],
+ align: 'center',
+ labelKey: 'tableHeaders.memory',
+ formatter: 'Si',
+ formatterOpts: {
+ opts: {
+ increment: 1024, addSuffix: true, maxExponent: 3, minExponent: 3, suffix: 'i',
+ },
+ needParseSi: true
+ },
+ },
+ {
+ name: 'ip',
+ label: 'IP Address',
+ value: 'id',
+ formatter: 'HarvesterIpAddress',
+ labelKey: 'tableHeaders.ipAddress',
+ sort: ['id'],
+ },
+ // The VM list only shows it when the cluster's nodes can be seen
+ {
+ name: 'node',
+ label: 'Node',
+ value: 'nodeName',
+ sort: ['realAttachNodeName'],
+ formatter: 'HarvesterHost',
+ labelKey: 'harvester.tableHeaders.vm.node'
+ },
+ // The VM list only shows it while a backup is being restored
+ {
+ name: 'restoreProgress',
+ labelKey: 'harvester.tableHeaders.restore',
+ value: 'restoreProgress',
+ align: 'left',
+ formatter: 'HarvesterBackupProgressBar',
+ width: 200,
+ },
+ {
+ ...AGE,
+ sort: 'metadata.creationTimestamp:desc',
+ }
+];
+
+// With server-side pagination the API sorts and searches, so only the fields it indexes can be used. CPU, memory, IP,
+// node and restore progress come from the VM model or other resources. The VM's printer columns are listed as Name, Age, Status, Ready, so its
+// Status is `metadata.fields.2`
+const VM_PAGINATION_FIELDS = {
+ [STATE.name]: { sort: ['metadata.fields.2'], search: false },
+ [NAME.name]: {
+ sort: ['metadata.name'],
+ search: ['metadata.name', `metadata.annotations[${ HCI_ANNOTATIONS.VM_DISPLAY_NAME }]`],
+ },
+ [NAMESPACE.name]: { sort: ['metadata.namespace'], search: 'metadata.namespace' },
+ [AGE.name]: { search: false },
+};
+
+export const VM_PAGINATION_HEADERS = VM_HEADERS.map((header) => ({
+ ...header,
+ ...(VM_PAGINATION_FIELDS[header.name] || { sort: false, search: false }),
+}));
diff --git a/pkg/harvester/detail/loadbalancer.harvesterhci.io.loadbalancer.vue b/pkg/harvester/detail/loadbalancer.harvesterhci.io.loadbalancer.vue
index bda0223f..d4b0343e 100644
--- a/pkg/harvester/detail/loadbalancer.harvesterhci.io.loadbalancer.vue
+++ b/pkg/harvester/detail/loadbalancer.harvesterhci.io.loadbalancer.vue
@@ -5,7 +5,7 @@ import SortableTable from '@shell/components/SortableTable';
import { HCI } from '@pkg/harvester/types';
import { allHash } from '@shell/utils/promise';
import { KEY, VALUE } from '@shell/config/table-headers';
-import { VM_HEADERS } from '@pkg/harvester/list/kubevirt.io.virtualmachine';
+import { VM_HEADERS } from '@pkg/harvester/config/table-headers';
import { matching } from '@shell/utils/selector';
import { IP_POOL_HEADERS } from '../config/harvester-cluster';
@@ -103,7 +103,7 @@ export default {
},
vmHeaders() {
- const filterNames = ['state', 'ip', 'node'];
+ const filterNames = ['state', 'ip', 'node', 'restoreProgress'];
return VM_HEADERS.filter((h) => !filterNames.includes(h.name));
},
diff --git a/pkg/harvester/dialog/HarvesterAddHotplugVolumeModal.vue b/pkg/harvester/dialog/HarvesterAddHotplugVolumeModal.vue
index 9ddd1d94..50bd90fc 100644
--- a/pkg/harvester/dialog/HarvesterAddHotplugVolumeModal.vue
+++ b/pkg/harvester/dialog/HarvesterAddHotplugVolumeModal.vue
@@ -30,9 +30,9 @@ export default {
},
async fetch() {
- this.allPVCs = await this.$store.dispatch('harvester/findAll', { type: PVC });
+ this.allPVCs = await this.actionResource.findInNamespace(PVC);
this.allStorageClasses = await this.$store.dispatch('harvester/findAll', { type: STORAGE_CLASS });
- this.allVMs = await this.$store.dispatch('harvester/findAll', { type: HCI.VM });
+ this.allVMs = await this.actionResource.findInNamespace(HCI.VM);
},
data() {
diff --git a/pkg/harvester/dialog/HarvesterRestoreDialog.vue b/pkg/harvester/dialog/HarvesterRestoreDialog.vue
index e5a6bfb0..9ba6ff16 100644
--- a/pkg/harvester/dialog/HarvesterRestoreDialog.vue
+++ b/pkg/harvester/dialog/HarvesterRestoreDialog.vue
@@ -2,7 +2,6 @@
import { mapGetters } from 'vuex';
import { randomStr } from '@shell/utils/string';
-import { allHash } from '@shell/utils/promise';
import { exceptionToErrorsArray } from '@shell/utils/error';
import { Card } from '@components/Card';
@@ -24,9 +23,7 @@ export default {
},
async fetch() {
- const hash = await allHash({ backups: this.$store.dispatch('harvester/findAll', { type: HCI.BACKUP }) });
-
- this.backups = hash.backups;
+ this.backups = await this.actionResource.findInNamespace(HCI.BACKUP);
},
props: {
diff --git a/pkg/harvester/dialog/HarvesterStorageMigrationDialog.vue b/pkg/harvester/dialog/HarvesterStorageMigrationDialog.vue
index 4c679ecb..d89a3d95 100644
--- a/pkg/harvester/dialog/HarvesterStorageMigrationDialog.vue
+++ b/pkg/harvester/dialog/HarvesterStorageMigrationDialog.vue
@@ -29,7 +29,13 @@ export default {
},
async fetch() {
- this.allPVCs = await this.$store.dispatch('harvester/findAll', { type: PVC });
+ const [pvcs, vms] = await Promise.all([
+ this.actionResource.findInNamespace(PVC),
+ this.actionResource.findInNamespace(HCI.VM),
+ ]);
+
+ this.allPVCs = pvcs;
+ this.namespaceVMs = vms;
},
data() {
@@ -38,6 +44,7 @@ export default {
targetVolume: '',
errors: [],
allPVCs: [],
+ namespaceVMs: [],
};
},
@@ -68,10 +75,9 @@ export default {
},
vmUsedVolumeNames() {
- const allVMs = this.$store.getters['harvester/all'](HCI.VM) || [];
const names = new Set();
- allVMs.forEach((vm) => {
+ this.namespaceVMs.forEach((vm) => {
// Collect volume names from spec.template.spec.volumes (both PVC and DataVolume references)
const volumes = vm.spec?.template?.spec?.volumes || [];
diff --git a/pkg/harvester/dialog/__tests__/vm-list-dialogs.test.js b/pkg/harvester/dialog/__tests__/vm-list-dialogs.test.js
new file mode 100644
index 00000000..a6a4514b
--- /dev/null
+++ b/pkg/harvester/dialog/__tests__/vm-list-dialogs.test.js
@@ -0,0 +1,55 @@
+import { PVC, STORAGE_CLASS } from '@shell/config/types';
+import HotplugVolumeModal from '../HarvesterAddHotplugVolumeModal.vue';
+import StorageMigrationDialog from '../HarvesterStorageMigrationDialog.vue';
+import RestoreDialog from '../HarvesterRestoreDialog.vue';
+import { HCI } from '../../types';
+
+// The dialogs of the VM list read the VMs, PVCs and backups of the VM's namespace through the VM, so a paged VM list
+// keeps its page (see `findInNamespace` in the VM model)
+describe('dialogs of the VM list', () => {
+ const vm = (claims = []) => ({
+ metadata: { namespace: 'default', name: 'vm' },
+ spec: { template: { spec: { volumes: claims.map((claimName) => ({ persistentVolumeClaim: { claimName } })) } } },
+ findInNamespace: jest.fn((type) => Promise.resolve([{ type }])),
+ });
+
+ it('should load the PVCs and VMs of Add Volume through the VM', async() => {
+ const actionResource = vm();
+ const dispatch = jest.fn(() => Promise.resolve([]));
+ const dialog = { actionResource, $store: { dispatch } };
+
+ await HotplugVolumeModal.fetch.call(dialog);
+
+ expect(actionResource.findInNamespace.mock.calls).toStrictEqual([[PVC], [HCI.VM]]);
+ expect(dialog.allPVCs).toStrictEqual([{ type: PVC }]);
+ expect(dialog.allVMs).toStrictEqual([{ type: HCI.VM }]);
+ expect(dispatch.mock.calls).toStrictEqual([['harvester/findAll', { type: STORAGE_CLASS }]]);
+ });
+
+ it('should load the PVCs and VMs of Storage Migration through the VM', async() => {
+ const actionResource = vm();
+ const dialog = { actionResource };
+
+ await StorageMigrationDialog.fetch.call(dialog);
+
+ expect(actionResource.findInNamespace.mock.calls).toStrictEqual([[PVC], [HCI.VM]]);
+ expect(dialog.allPVCs).toStrictEqual([{ type: PVC }]);
+ expect(dialog.namespaceVMs).toStrictEqual([{ type: HCI.VM }]);
+ });
+
+ it('should exclude the volumes of the loaded VMs from the Storage Migration targets', () => {
+ const used = StorageMigrationDialog.computed.vmUsedVolumeNames.call({ namespaceVMs: [vm(['a-disk']), vm(['b-disk'])] });
+
+ expect([...used]).toStrictEqual(['default/a-disk', 'default/b-disk']);
+ });
+
+ it('should load the backups of Restore through the VM', async() => {
+ const actionResource = vm();
+ const dialog = { actionResource };
+
+ await RestoreDialog.fetch.call(dialog);
+
+ expect(actionResource.findInNamespace.mock.calls).toStrictEqual([[HCI.BACKUP]]);
+ expect(dialog.backups).toStrictEqual([{ type: HCI.BACKUP }]);
+ });
+});
diff --git a/pkg/harvester/index.ts b/pkg/harvester/index.ts
index 8270d904..62352d31 100644
--- a/pkg/harvester/index.ts
+++ b/pkg/harvester/index.ts
@@ -6,6 +6,7 @@ import harvesterCommonStore from './store/harvester-common';
import harvesterStore from './store/harvester-store';
import customValidators from './validators';
import { PRODUCT_NAME } from './config/harvester';
+import { HCI } from './types';
import {
hostResolvesL10nGlobals, resolveL10nGlobals, standaloneProductName, PRODUCT_NAME_GLOBAL
} from './utils/l10n-globals';
@@ -41,6 +42,16 @@ export default function (plugin: IPlugin) {
plugin.addDashboardStore(harvesterStore.config.namespace, harvesterStore.specifics, harvesterStore.config, harvesterStore.init);
plugin.validators = customValidators;
+ // The store's `paginationEnabled` getter turns it off on clusters whose API can't page the VM list
+ plugin.enableServerSidePagination?.({
+ [PRODUCT_NAME]: {
+ resources: {
+ enableAll: false,
+ enableSome: { enabled: [HCI.VM] }
+ }
+ }
+ });
+
plugin.addRoutes(extensionRoutes);
plugin.register('component', 'NavHeaderRight', defineAsyncComponent(() =>
diff --git a/pkg/harvester/list/__tests__/kubevirt.io.virtualmachine.test.js b/pkg/harvester/list/__tests__/kubevirt.io.virtualmachine.test.js
new file mode 100644
index 00000000..87ced7dc
--- /dev/null
+++ b/pkg/harvester/list/__tests__/kubevirt.io.virtualmachine.test.js
@@ -0,0 +1,373 @@
+import { shallowMount } from '@vue/test-utils';
+import {
+ PVC, PV, POD, NODE, STORAGE_CLASS
+} from '@shell/config/types';
+import VmList from '../kubevirt.io.virtualmachine.vue';
+import { VM_HEADERS, VM_PAGINATION_HEADERS } from '../../config/table-headers';
+import { HCI } from '../../types';
+
+const schemaWithColumns = (id, columns) => ({
+ id,
+ attributes: { columns: columns.map((name, i) => ({ name, field: `$.metadata.fields[${ i }]` })) }
+});
+
+const SCHEMAS = {
+ [HCI.VM]: schemaWithColumns(HCI.VM, ['Name', 'Age', 'Status', 'Ready']),
+ [HCI.VMIM]: schemaWithColumns(HCI.VMIM, ['Name', 'Phase', 'VMI']),
+ [HCI.RESTORE]: schemaWithColumns(HCI.RESTORE, ['Name', 'TARGET_KIND', 'TARGET_NAME']),
+ [HCI.VMI]: { id: HCI.VMI },
+ [HCI.BACKUP]: { id: HCI.BACKUP },
+ [POD]: { id: POD },
+ [PVC]: { id: PVC },
+ [PV]: { id: PV },
+};
+
+// `harvester/paginationEnabled` is the store's getter, which checks the cluster's API (see store/harvester-store/getters.ts)
+function createStore({
+ paginationEnabled = true, havePage = true, found = {}, failing = [], storedVMs = [], storedVMIs = [], namespaceFilters = []
+} = {}) {
+ const dispatch = jest.fn((action, { type } = {}) => (failing.includes(type) ? Promise.reject(new Error('failed')) : Promise.resolve(found[type] || [])));
+
+ return {
+ dispatch,
+ getters: {
+ currentProduct: { inStore: 'harvester' },
+ 'harvester/paginationEnabled': jest.fn((args) => paginationEnabled && (args?.id || args) === HCI.VM),
+ 'harvester/havePage': (type) => havePage && type === HCI.VM,
+ 'harvester/schemaFor': (type) => SCHEMAS[type],
+ 'harvester/all': (type) => ({ [HCI.VM]: storedVMs, [HCI.VMI]: storedVMIs }[type] || []),
+ 'type-map/headersFor': (schema, pagination) => (pagination ? VM_PAGINATION_HEADERS : VM_HEADERS),
+ 'action-menu/performCallbackData': undefined,
+ namespaceFilters,
+ }
+ };
+}
+
+const call = (name, ctx) => VmList.computed[name].call(ctx);
+const byName = (headers) => Object.fromEntries(headers.map((h) => [h.name, { sort: h.sort, search: h.search }]));
+
+const vm = (namespace, name, claimNames = []) => ({
+ id: `${ namespace }/${ name }`,
+ metadata: { namespace, name },
+ persistentVolumeClaimName: claimNames,
+});
+
+describe('list: kubevirt.io.virtualmachine', () => {
+ describe('without server-side pagination', () => {
+ it('should not page when the store says the cluster\'s API can\'t page the VMs', () => {
+ const $store = createStore({ paginationEnabled: false });
+
+ expect(call('canPaginate', { $store })).toBe(false);
+ expect($store.getters['harvester/paginationEnabled']).toHaveBeenCalledWith(HCI.VM);
+ });
+
+ it('should show the product\'s VM columns, with node and restore progress when they apply', () => {
+ const ctx = {
+ $store: createStore({ paginationEnabled: false }), schema: SCHEMAS[HCI.VM], hasNode: true, hasBackUpRestoreInProgress: true
+ };
+
+ ctx.applicableColumns = VmList.methods.applicableColumns.bind(ctx);
+ const headers = call('headers', ctx);
+
+ expect(headers.map(({ name }) => name)).toStrictEqual(['state', 'name', 'namespace', 'CPU', 'Memory', 'ip', 'node', 'restoreProgress', 'age']);
+ expect(byName(headers).CPU).toStrictEqual({ sort: ['displayCPU'], search: undefined });
+ expect(byName(headers).node).toStrictEqual({ sort: ['realAttachNodeName'], search: undefined });
+ });
+
+ it.each([
+ ['node', 'the cluster\'s nodes can\'t be seen', { hasNode: false, hasBackUpRestoreInProgress: true }],
+ ['restoreProgress', 'no backup is being restored', { hasNode: true, hasBackUpRestoreInProgress: false }],
+ ])('should leave out the %s column when %s', (column, _, flags) => {
+ const ctx = {
+ $store: createStore(), schema: SCHEMAS[HCI.VM], ...flags
+ };
+
+ ctx.applicableColumns = VmList.methods.applicableColumns.bind(ctx);
+
+ expect(call('headers', ctx).map(({ name }) => name)).not.toContain(column);
+ expect(call('paginationHeaders', ctx).map(({ name }) => name)).not.toContain(column);
+ expect(call('headers', ctx)).toHaveLength(VM_HEADERS.length - 1);
+ });
+
+ it('should add VMIs without a VM to the rows', () => {
+ const vms = [{ id: 'default/a' }];
+ const $store = createStore({ storedVMs: vms, storedVMIs: [{ id: 'default/a' }, { id: 'default/orphan' }] });
+ const ctx = {
+ $store, inStore: 'harvester', canPaginate: false, vms
+ };
+
+ ctx.vmisWithoutVM = call('vmisWithoutVM', ctx);
+
+ expect(VmList.methods.addVMIsWithoutVM.call(ctx, vms).map(({ id }) => id)).toStrictEqual(['default/a', 'default/orphan']);
+ expect(call('rows', ctx).map(({ id }) => id)).toStrictEqual(['default/a', 'default/orphan']);
+ });
+
+ it('should load every resource the rows need, the table loads the VMs', async() => {
+ const $store = createStore({ paginationEnabled: false });
+
+ await VmList.methods.fetchSecondaryResources.call({
+ $store, inStore: 'harvester', hasNode: true
+ }, { canPaginate: false });
+
+ expect($store.dispatch.mock.calls.map(([action, { type }]) => `${ action } ${ type }`).sort()).toStrictEqual([
+ HCI.BACKUP, HCI.IMAGE, HCI.RESTORE, HCI.VMI, HCI.VMIM, NODE, POD, PV, PVC, STORAGE_CLASS
+ ].map((type) => `harvester/findAll ${ type }`).sort());
+ });
+ });
+
+ describe('with server-side pagination', () => {
+ it('should page when the store says the cluster\'s API can page the VMs', () => {
+ expect(call('canPaginate', { $store: createStore() })).toBe(true);
+ });
+
+ it('should only sort and search on fields the API indexes', () => {
+ const ctx = {
+ $store: createStore(), schema: SCHEMAS[HCI.VM], hasNode: true, hasBackUpRestoreInProgress: true
+ };
+
+ ctx.applicableColumns = VmList.methods.applicableColumns.bind(ctx);
+
+ expect(byName(call('paginationHeaders', ctx))).toStrictEqual({
+ state: { sort: ['metadata.fields.2'], search: false },
+ name: { sort: ['metadata.name'], search: ['metadata.name', 'metadata.annotations[harvesterhci.io/vmDisplayName]'] },
+ namespace: { sort: ['metadata.namespace'], search: 'metadata.namespace' },
+ CPU: { sort: false, search: false },
+ Memory: { sort: false, search: false },
+ ip: { sort: false, search: false },
+ node: { sort: false, search: false },
+ restoreProgress: { sort: false, search: false },
+ age: { sort: 'metadata.creationTimestamp:desc', search: false },
+ });
+ });
+
+ it('should take the VMs of the page from the store', () => {
+ const storedVMs = [vm('default', 'a')];
+ const $store = createStore({ storedVMs });
+
+ expect(call('vms', { $store, inStore: 'harvester' })).toBe(storedVMs);
+ });
+
+ it('should list only the VMs of the page', () => {
+ const page = [vm('default', 'a')];
+ const $store = createStore({ storedVMs: page, storedVMIs: [{ id: 'default/orphan' }] });
+ const ctx = {
+ $store, inStore: 'harvester', canPaginate: true, vms: page
+ };
+
+ ctx.vmisWithoutVM = call('vmisWithoutVM', ctx);
+
+ expect(call('rows', ctx)).toStrictEqual(page);
+ });
+
+ it('should fetch only the resources of the VMs on the page', async() => {
+ const $store = createStore({
+ found: {
+ [PVC]: [{ spec: { volumeName: 'pv-a' } }, { spec: {} }],
+ [HCI.RESTORE]: [{ spec: { virtualMachineBackupName: 'backup-a' } }],
+ [HCI.VMI]: [{ metadata: { name: 'a', uid: 'uid-a' } }, { metadata: { name: 'b', uid: 'uid-b' } }],
+ }
+ });
+ const ctx = { $store, inStore: 'harvester' };
+
+ ctx.findPageByField = VmList.methods.findPageByField.bind(ctx);
+ ctx.printerColumnField = VmList.methods.printerColumnField.bind(ctx);
+
+ await VmList.methods.fetchPageSecondaryResources.call(ctx, {
+ force: true,
+ page: [vm('default', 'a', ['a-disk']), vm('other', 'a'), vm('default', 'b', ['b-disk'])],
+ });
+
+ const filters = Object.fromEntries($store.dispatch.mock.calls.map(([action, { type, opt }]) => {
+ expect(action).toBe('harvester/findPage');
+ expect(opt.force).toBe(true);
+
+ return [type, opt.pagination.filters[0].fields.map(({ field, value, equality }) => `${ field }${ equality }(${ value })`)];
+ }));
+
+ expect(filters).toStrictEqual({
+ [PVC]: ['metadata.name IN (a-disk,b-disk)'],
+ [HCI.RESTORE]: ['metadata.fields.2 IN (a,b)'],
+ [HCI.VMI]: ['metadata.name IN (a,b)'],
+ [POD]: ['metadata.labels[kubevirt.io/created-by] IN (uid-a,uid-b)'],
+ [HCI.VMIM]: ['metadata.fields.2 IN (a,b)'],
+ [PV]: ['metadata.name IN (pv-a)'],
+ [HCI.BACKUP]: ['metadata.name IN (backup-a)'],
+ });
+ });
+
+ it('should fetch the rest when one request fails', async() => {
+ const $store = createStore({ failing: [HCI.RESTORE], found: { [PVC]: [{ spec: { volumeName: 'pv-a' } }], [HCI.VMI]: [{ metadata: { uid: 'uid-a' } }] } });
+ const ctx = { $store, inStore: 'harvester' };
+
+ ctx.findPageByField = VmList.methods.findPageByField.bind(ctx);
+ ctx.printerColumnField = VmList.methods.printerColumnField.bind(ctx);
+
+ await expect(VmList.methods.fetchPageSecondaryResources.call(ctx, { force: false, page: [vm('default', 'a', ['a-disk'])] })).resolves.toBeUndefined();
+
+ const types = $store.dispatch.mock.calls.map(([, { type }]) => type);
+
+ expect(types).toStrictEqual(expect.arrayContaining([PVC, HCI.VMI, POD, HCI.VMIM, PV]));
+ expect(types).not.toContain(HCI.BACKUP);
+ });
+
+ it('should not fetch a type when no VM on the page needs it', async() => {
+ const $store = createStore();
+ const ctx = { $store, inStore: 'harvester' };
+
+ ctx.findPageByField = VmList.methods.findPageByField.bind(ctx);
+ ctx.printerColumnField = VmList.methods.printerColumnField.bind(ctx);
+
+ await VmList.methods.fetchPageSecondaryResources.call(ctx, { force: false, page: [vm('default', 'a')] });
+
+ const types = $store.dispatch.mock.calls.map(([, { type }]) => type);
+
+ expect(types).not.toContain(PVC);
+ expect(types).not.toContain(PV);
+ expect(types).not.toContain(HCI.BACKUP);
+ expect(types).not.toContain(POD);
+ });
+
+ it('should load only what every row shares, not the per-VM resources', async() => {
+ const $store = createStore();
+
+ await VmList.methods.fetchSecondaryResources.call({
+ $store, inStore: 'harvester', hasNode: true
+ }, { canPaginate: true });
+
+ expect($store.dispatch.mock.calls).toStrictEqual([
+ ['harvester/findAll', { type: HCI.IMAGE }],
+ ['harvester/findAll', { type: STORAGE_CLASS }],
+ ['harvester/findAll', { type: NODE }],
+ ]);
+ });
+ });
+
+ // The header's filter is shared by every list, so Not in a Project can come from a list that doesn't page
+ it.each([
+ ['ask for another namespace filter while paging when the API can\'t filter by it', { namespaceFilters: ['all://orphans'] }, true],
+ ['show the list while paging with a namespace filter the API can use', { namespaceFilters: ['ns://default'] }, false],
+ ['show the list without pagination, whatever the filter', { paginationEnabled: false, namespaceFilters: ['all://orphans'] }, false],
+ ])('should %s', (_, opts, asks) => {
+ const wrapper = shallowMount(VmList, {
+ props: { schema: SCHEMAS[HCI.VM] },
+ global: { mocks: { $store: createStore(opts), t: (key) => key }, stubs: { 'router-link': true } },
+ });
+
+ expect(wrapper.findComponent({ name: 'IconMessage' }).exists()).toBe(asks);
+ expect(wrapper.findComponent({ name: 'PaginatedResourceTable' }).exists()).toBe(!asks);
+ });
+
+ it('should hide the masthead loading count only with pagination', () => {
+ expect(VmList.$loadingResources(null, createStore())).toStrictEqual({ loadResources: [] });
+ expect(VmList.$loadingResources(null, createStore({ paginationEnabled: false }))).toStrictEqual({});
+ });
+
+ describe('restart required notification', () => {
+ const rvm = (namespace, name) => ({
+ id: `${ namespace }/${ name }`, metadata: { namespace, name }, isRestartRequired: true
+ });
+ const notify = (ctx, vms, oldVms) => VmList.watch.restartRequiredVMs.handler.call(ctx, vms, oldVms);
+ const createCtx = (restartNotificationKey) => ({
+ $store: { dispatch: jest.fn() },
+ t: (key, args) => `${ key } ${ JSON.stringify(args) }`,
+ restartNotificationKey,
+ });
+ const mountList = ($store) => shallowMount(VmList, {
+ props: { schema: SCHEMAS[HCI.VM] },
+ global: { mocks: { $store, t: (key, args) => `${ key } ${ JSON.stringify(args) }` }, stubs: { 'router-link': true } },
+ });
+ const warning = (count, vmNames) => ['growl/warning', {
+ title: `harvester.notification.restartRequired.title ${ JSON.stringify({ count }) }`,
+ message: `harvester.notification.restartRequired.message ${ JSON.stringify({ vmNames }) }`,
+ timeout: 10000,
+ }, { root: true }];
+
+ it('should only list the VMs that need a restart', () => {
+ const a = rvm('default', 'a');
+
+ expect(call('restartRequiredVMs', { canPaginate: false, vms: [a, { id: 'default/b', isRestartRequired: false }] })).toStrictEqual([a]);
+ });
+
+ it.each([
+ ['wait for the list\'s page while paging', { havePage: false }, []],
+ ['take the VMs of the page once it is loaded', { havePage: true }, ['a']],
+ ])('should %s', (_, opts, names) => {
+ const ctx = {
+ $store: createStore(opts), inStore: 'harvester', canPaginate: true, vms: [rvm('default', 'a')]
+ };
+
+ expect(call('restartRequiredVMs', ctx).map(({ metadata }) => metadata.name)).toStrictEqual(names);
+ });
+
+ // Coming back to the list, the store already holds the VMs, so they never change after the list is created
+ it.each([
+ ['without pagination', { paginationEnabled: false, havePage: false }],
+ ['with pagination', { paginationEnabled: true, havePage: true }],
+ ])('should notify when the list opens with the VMs already in the store, %s', (_, opts) => {
+ const $store = createStore({ ...opts, storedVMs: [rvm('default', 'a')] });
+
+ mountList($store);
+
+ expect($store.dispatch).toHaveBeenCalledWith(...warning(1, 'a'));
+ });
+
+ it('should not notify about VMs another page left in the store while the list is paged', () => {
+ const $store = createStore({ havePage: false, storedVMs: [rvm('default', 'a')] });
+
+ mountList($store);
+
+ expect($store.dispatch).not.toHaveBeenCalledWith('growl/warning', expect.anything(), expect.anything());
+ });
+
+ it('should notify when VMs need a restart', () => {
+ const ctx = createCtx('');
+
+ notify(ctx, [rvm('default', 'a'), rvm('default', 'b')], []);
+
+ expect(ctx.$store.dispatch).toHaveBeenCalledWith(...warning(2, 'a, b'));
+ expect(ctx.restartNotificationKey).toBe('default/a,default/b');
+ });
+
+ it('should notify on a new visit to the list, even when the VMs it saw before are the same', () => {
+ const ctx = createCtx('');
+
+ notify(ctx, [rvm('default', 'a')], [rvm('default', 'a')]);
+
+ expect(ctx.$store.dispatch).toHaveBeenCalledWith(...warning(1, 'a'));
+ });
+
+ it('should not notify again when a refresh, page or sort brings back the same VMs', () => {
+ const ctx = createCtx('default/a,default/b');
+
+ notify(ctx, [rvm('default', 'b'), rvm('default', 'a')], [rvm('default', 'a'), rvm('default', 'b')]);
+
+ expect(ctx.$store.dispatch).not.toHaveBeenCalled();
+ });
+
+ it('should notify again when a VM of the same name in another namespace takes its place', () => {
+ const ctx = createCtx('');
+
+ notify(ctx, [rvm('ns1', 'a')], []);
+ notify(ctx, [rvm('ns2', 'a')], [rvm('ns1', 'a')]);
+
+ expect(ctx.$store.dispatch.mock.calls).toStrictEqual([warning(1, 'a'), ['growl/clear'], warning(1, 'a')]);
+ });
+
+ it('should replace the notification when the VMs change', () => {
+ const ctx = createCtx('default/a,default/b');
+
+ notify(ctx, [rvm('default', 'a'), rvm('default', 'c')], [rvm('default', 'a'), rvm('default', 'b')]);
+
+ expect(ctx.$store.dispatch.mock.calls).toStrictEqual([['growl/clear'], warning(2, 'a, c')]);
+ });
+
+ it('should reset when no VM needs a restart', () => {
+ const ctx = createCtx('default/a');
+
+ notify(ctx, [], [rvm('default', 'a')]);
+
+ expect(ctx.$store.dispatch).not.toHaveBeenCalled();
+ expect(ctx.restartNotificationKey).toBe('');
+ });
+ });
+});
diff --git a/pkg/harvester/list/kubevirt.io.virtualmachine.vue b/pkg/harvester/list/kubevirt.io.virtualmachine.vue
index 613a0363..d9cb096b 100644
--- a/pkg/harvester/list/kubevirt.io.virtualmachine.vue
+++ b/pkg/harvester/list/kubevirt.io.virtualmachine.vue
@@ -1,15 +1,17 @@
-
-
-
+
+
+ {{ t('resourceList.nsFilteringGeneric') }}
+
+
+
@@ -279,7 +352,7 @@ export default {
/>
-
+
diff --git a/pkg/harvester/models/__tests__/kubevirt.io.virtualmachine.test.js b/pkg/harvester/models/__tests__/kubevirt.io.virtualmachine.test.js
index 43269933..e32c1775 100644
--- a/pkg/harvester/models/__tests__/kubevirt.io.virtualmachine.test.js
+++ b/pkg/harvester/models/__tests__/kubevirt.io.virtualmachine.test.js
@@ -395,4 +395,57 @@ describe('class VirtVm', () => {
expect(vm.isRestartRequired).toBe(true);
});
});
+
+ describe('findInNamespace', () => {
+ function vmWithStore({ havePage }) {
+ const vm = Object.create(VirtVm.prototype);
+ const stored = [{ metadata: { namespace: 'ns1', name: 'a' } }, { metadata: { namespace: 'other', name: 'b' } }];
+ const dispatch = jest.fn((action) => Promise.resolve(action === 'findPage' ? { data: [{ metadata: { namespace: 'ns1', name: 'page' } }] } : stored));
+
+ vm.metadata = { name: 'vm1', namespace: 'ns1' };
+ Object.defineProperty(vm, '$getters', { value: { havePage: (type) => havePage && type === PVC } });
+ Object.defineProperty(vm, '$dispatch', { value: dispatch });
+
+ return {
+ vm, dispatch, stored
+ };
+ }
+
+ it('should load every resource and return a copy with the ones of the namespace when no page of the type is stored', async() => {
+ const { vm, dispatch, stored } = vmWithStore({ havePage: false });
+ const out = await vm.findInNamespace(PVC);
+
+ expect(dispatch.mock.calls).toStrictEqual([['findAll', { type: PVC }]]);
+ expect(out.map(({ metadata }) => metadata.name)).toStrictEqual(['a']);
+ expect(out).not.toBe(stored);
+ });
+
+ it('should read only the namespace, without storing it, when a paged list keeps a page of the type', async() => {
+ const { vm, dispatch } = vmWithStore({ havePage: true });
+ const out = await vm.findInNamespace(PVC);
+
+ expect(out.map(({ metadata }) => metadata.name)).toStrictEqual(['page']);
+ expect(dispatch).toHaveBeenCalledTimes(1);
+
+ const [action, { type, opt }] = dispatch.mock.calls[0];
+
+ expect([action, type, opt.transient]).toStrictEqual(['findPage', PVC, true]);
+ expect(opt.pagination.filters[0].fields.map(({ field, value }) => `${ field }=${ value }`)).toStrictEqual(['metadata.namespace=ns1']);
+ });
+ });
+
+ describe('disableResourceDetailDrawerConfigTab', () => {
+ it.each([
+ ['hide the drawer\'s Config tab while the paged VM list keeps a page of VMs', { paged: true }, true],
+ ['keep the drawer\'s Config tab when every VM is loaded', null, false],
+ ])('should %s', (_, page, hidden) => {
+ const vm = Object.create(VirtVm.prototype);
+ const havePage = jest.fn(() => page);
+
+ Object.defineProperty(vm, '$getters', { value: { havePage } });
+
+ expect(vm.disableResourceDetailDrawerConfigTab).toBe(hidden);
+ expect(havePage).toHaveBeenCalledWith(HCI.VM);
+ });
+ });
});
diff --git a/pkg/harvester/models/kubevirt.io.virtualmachine.js b/pkg/harvester/models/kubevirt.io.virtualmachine.js
index 741a316c..64b82503 100644
--- a/pkg/harvester/models/kubevirt.io.virtualmachine.js
+++ b/pkg/harvester/models/kubevirt.io.virtualmachine.js
@@ -3,6 +3,7 @@ import { omitBy, pickBy } from 'lodash';
import { PRODUCT_NAME as HARVESTER_PRODUCT } from '../config/harvester';
import { colorForState, stateSort } from '@shell/plugins/dashboard-store/resource-class';
import { POD, NODE, PVC } from '@shell/config/types';
+import { FilterArgs, PaginationParamFilter } from '@shell/types/store/pagination.types';
import { findBy } from '@shell/utils/array';
import { parseSi } from '@shell/utils/units';
import { get, set } from '@shell/utils/object';
@@ -1162,6 +1163,35 @@ export default class VirtVm extends HarvesterResource {
.filter((name) => !!name);
}
+ // The resources of `type` in this VM's namespace, for the dialogs of the VM list. When the paged list keeps a page of
+ // `type` in the store, loading every resource would replace that page, and the next page load would shrink a list
+ // shared with the store, so read the namespace without storing it then.
+ async findInNamespace(type) {
+ const namespace = this.metadata.namespace;
+
+ if (!this.$getters['havePage'](type)) {
+ const all = await this.$dispatch('findAll', { type });
+
+ return all.filter((resource) => resource.metadata?.namespace === namespace);
+ }
+
+ const res = await this.$dispatch('findPage', {
+ type,
+ opt: {
+ transient: true,
+ pagination: new FilterArgs({ filters: PaginationParamFilter.createSingleField({ field: 'metadata.namespace', value: namespace }) }),
+ }
+ });
+
+ return res?.data || [];
+ }
+
+ // The configuration form loads every VM, volume, VMI and migration, which would replace the page the paged VM list
+ // keeps in the store, so the drawer only shows the YAML then. The VM's own page still shows its configuration
+ get disableResourceDetailDrawerConfigTab() {
+ return !!this.$getters['havePage'](HCI.VM);
+ }
+
get rootImageId() {
let imageId = '';
diff --git a/pkg/harvester/store/harvester-store/__tests__/getters.test.ts b/pkg/harvester/store/harvester-store/__tests__/getters.test.ts
index 45244f5e..1c3f6526 100644
--- a/pkg/harvester/store/harvester-store/__tests__/getters.test.ts
+++ b/pkg/harvester/store/harvester-store/__tests__/getters.test.ts
@@ -1,7 +1,7 @@
import {
CONFIG_MAP, COUNT, NAMESPACE, NETWORK_ATTACHMENT, NODE, PVC, STORAGE_CLASS
} from '@shell/config/types';
-import harvesterGetters from '../getters';
+import harvesterGetters, { vmAwarePaginationEnabled } from '../getters';
import { HCI, DATA_VOLUME, VOLUME_SNAPSHOT } from '../../../types';
import { HCI_SETTING } from '../../../config/settings';
@@ -288,3 +288,38 @@ describe('harvester store: visibleSettings', () => {
expect(shown.data.source).toBe('harvester');
});
});
+
+describe('harvester store: paginationEnabled', () => {
+ const SQL_CACHE_COLUMNS = [{ name: 'Name', field: '$.metadata.fields[0]' }, { name: 'Status', field: '$.metadata.fields[2]' }];
+ const OLD_API_COLUMNS = [{ name: 'Status', field: '.status.printableStatus' }];
+
+ // `shellEnabled` is what the store's own getter answers, from the extension's registration and Rancher's settings
+ function paginationEnabled(args: any, { shellEnabled = true, featureEnabled = true, columns = SQL_CACHE_COLUMNS } = {}) {
+ const base = jest.fn(() => () => shellEnabled);
+ const getters = { schemaFor: (type: string) => (type === HCI.VM ? { id: HCI.VM, attributes: { columns } } : undefined) };
+ const rootGetters = { 'harvester-common/getFeatureEnabled': (name: string) => featureEnabled && name === 'vmListPagination' };
+
+ return vmAwarePaginationEnabled(base)({}, getters, {}, rootGetters)(args);
+ }
+
+ it.each([
+ ['the VM id', HCI.VM],
+ ['the VM id and a context', { id: HCI.VM, context: 'any' }],
+ ['the VM id without a context, like the header\'s namespace filter', { id: HCI.VM }],
+ ])('should page the VMs when the cluster\'s API can, asked with %s', (_, args) => {
+ expect(paginationEnabled(args)).toBe(true);
+ });
+
+ // The list's table asks with an object, the header's namespace filter with the type
+ it.each([HCI.VM, { id: HCI.VM, context: 'any' }])('should not page the VMs when the cluster can\'t, asked with %j', (args) => {
+ expect(paginationEnabled(args, { shellEnabled: false })).toBe(false);
+ expect(paginationEnabled(args, { featureEnabled: false })).toBe(false);
+ expect(paginationEnabled(args, { columns: OLD_API_COLUMNS })).toBe(false);
+ });
+
+ it('should leave the other types and the question without a type to the store\'s getter', () => {
+ expect(paginationEnabled(HCI.VMI, { featureEnabled: false, columns: OLD_API_COLUMNS })).toBe(true);
+ expect(paginationEnabled(undefined, { featureEnabled: false })).toBe(true);
+ expect(paginationEnabled(HCI.VMI, { shellEnabled: false })).toBe(false);
+ });
+});
diff --git a/pkg/harvester/store/harvester-store/__tests__/index.test.ts b/pkg/harvester/store/harvester-store/__tests__/index.test.ts
new file mode 100644
index 00000000..d39d4721
--- /dev/null
+++ b/pkg/harvester/store/harvester-store/__tests__/index.test.ts
@@ -0,0 +1,17 @@
+import { HCI } from '../../../types';
+import harvesterStore from '../index';
+
+// The shell answers yes for every type here, so only the store's own check can keep a cluster off pagination
+jest.mock('@shell/utils/pagination-utils', () => ({ __esModule: true, default: { isEnabled: () => true } }));
+
+describe('harvester store', () => {
+ it('should not page the VMs on a cluster whose API can\'t, whatever the shell answers', () => {
+ const { paginationEnabled } = harvesterStore.specifics.getters as any;
+ const getters = { schemaFor: () => ({ id: HCI.VM, attributes: { columns: [{ name: 'Status', field: '.status.printableStatus' }] } }) };
+ const rootGetters = { 'harvester-common/getFeatureEnabled': () => true };
+ const state = { config: { namespace: 'harvester' } };
+
+ expect(paginationEnabled(state, getters, {}, rootGetters)({ id: HCI.VM, context: 'any' })).toBe(false);
+ expect(paginationEnabled(state, getters, {}, rootGetters)(HCI.VMI)).toBe(true);
+ });
+});
diff --git a/pkg/harvester/store/harvester-store/getters.ts b/pkg/harvester/store/harvester-store/getters.ts
index daa77bf8..ffe20fcc 100644
--- a/pkg/harvester/store/harvester-store/getters.ts
+++ b/pkg/harvester/store/harvester-store/getters.ts
@@ -228,7 +228,43 @@ function resourceCount(state: any, rootGetters: any, getters: any, typeObj: any)
return unfilteredCount(getters, resourceType, namespaces);
}
+/**
+ * Whether this cluster's API can page the VM list. Only an API served from
+ * Steve's SQL cache can filter it, and that API lists the printer columns of a
+ * CRD as `metadata.fields[N]`. The server version alone can't tell, as it can
+ * be missing or not semver.
+ */
+function canPaginateVMs(getters: any, rootGetters: any): boolean {
+ if (!rootGetters['harvester-common/getFeatureEnabled']?.('vmListPagination')) {
+ return false;
+ }
+
+ const columns = getters.schemaFor(HCI.VM)?.attributes?.columns || [];
+
+ return columns.some((col: any) => col.field?.startsWith('$.metadata.fields['));
+}
+
+/**
+ * Wraps the store's `paginationEnabled` getter. The VM list is registered for
+ * pagination on every cluster (index.ts), so answer for this cluster here.
+ * Every caller then agrees, like the header's namespace filter, which disables
+ * the options a paged list can't filter by.
+ */
+export function vmAwarePaginationEnabled(paginationEnabled: any) {
+ return (state: any, getters: any, rootState: any, rootGetters: any) => (args: any) => {
+ const enabled = paginationEnabled(state, getters, rootState, rootGetters)(args);
+ const id = typeof args === 'object' ? args?.id : args;
+
+ if (!enabled || id !== HCI.VM) {
+ return enabled;
+ }
+
+ return canPaginateVMs(getters, rootGetters);
+ };
+}
+
export default {
+
namespaceFilterOptions: (state: any, getters: any, rootState: any, rootGetters: any) => ({
addNamespace,
divider,
diff --git a/pkg/harvester/store/harvester-store/index.ts b/pkg/harvester/store/harvester-store/index.ts
index 7033cd38..ded3450a 100644
--- a/pkg/harvester/store/harvester-store/index.ts
+++ b/pkg/harvester/store/harvester-store/index.ts
@@ -3,7 +3,7 @@ import { CoreStoreSpecifics, CoreStoreConfig } from '@shell/core/types';
import { SteveFactory, steveStoreInit } from '@shell/plugins/steve/index';
import { PRODUCT_NAME } from '../../config/harvester';
-import getters from './getters';
+import getters, { vmAwarePaginationEnabled } from './getters';
import mutations from './mutations';
import actions from './actions';
@@ -22,6 +22,7 @@ const harvesterFactory = (): CoreStoreSpecifics => {
steveFactory.getters = {
...steveFactory.getters,
...getters,
+ paginationEnabled: vmAwarePaginationEnabled(steveFactory.getters.paginationEnabled),
};
steveFactory.mutations = {