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 @@ - + 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 = {