From 4ea5d5b1fc96de08547004a55662b6bf36cd0846 Mon Sep 17 00:00:00 2001 From: Andrija Panic Date: Sun, 15 Nov 2026 06:26:25 +0100 Subject: [PATCH 1/2] KVM: register SystemVM templates as dynamically scalable CKS nodes use the KVM SystemVM template by default and inherit its dynamic-scaling flag, which was never set, so a running CKS cluster could not be scaled to a new offering. Set the flag when a KVM SystemVM template is registered, and on upgrade for the existing ones. Fixes #14704 --- .../upgrade/SystemVmTemplateRegistration.java | 4 +++- .../META-INF/db/schema-42300to2400.sql | 4 ++++ .../SystemVmTemplateRegistrationTest.java | 19 +++++++++++++++++++ 3 files changed, 26 insertions(+), 1 deletion(-) diff --git a/engine/schema/src/main/java/com/cloud/upgrade/SystemVmTemplateRegistration.java b/engine/schema/src/main/java/com/cloud/upgrade/SystemVmTemplateRegistration.java index 27005dfda110..af1313cd493d 100644 --- a/engine/schema/src/main/java/com/cloud/upgrade/SystemVmTemplateRegistration.java +++ b/engine/schema/src/main/java/com/cloud/upgrade/SystemVmTemplateRegistration.java @@ -590,7 +590,7 @@ protected String getSystemVmTemplateVersion() { return systemVmTemplateVersion; } - private VMTemplateVO createTemplateObjectInDB(SystemVMTemplateDetails details) { + protected VMTemplateVO createTemplateObjectInDB(SystemVMTemplateDetails details) { Long templateId = vmTemplateDao.getNextInSequence(Long.class, "id"); VMTemplateVO template = new VMTemplateVO(); template.setUuid(details.getUuid()); @@ -613,6 +613,8 @@ private VMTemplateVO createTemplateObjectInDB(SystemVMTemplateDetails details) { template.setArch(details.getArch()); template.setState(VirtualMachineTemplate.State.Inactive); template.setDeployAsIs(false); + // KVM hot-plugs CPU and memory without guest tools; CKS nodes are created from this template. + template.setDynamicallyScalable(Hypervisor.HypervisorType.KVM.equals(details.getHypervisorType())); template = vmTemplateDao.persist(template); return template; } diff --git a/engine/schema/src/main/resources/META-INF/db/schema-42300to2400.sql b/engine/schema/src/main/resources/META-INF/db/schema-42300to2400.sql index 541caae23c11..2a031f41b04e 100644 --- a/engine/schema/src/main/resources/META-INF/db/schema-42300to2400.sql +++ b/engine/schema/src/main/resources/META-INF/db/schema-42300to2400.sql @@ -271,3 +271,7 @@ CALL `cloud`.`IDEMPOTENT_ADD_COLUMN`('cloud.disk_offering', 'error_policy', 'VAR -- Rename persisted FlashArray provider name (plugin getName() changed from 'Flash Array' to 'FlashArray') UPDATE `cloud`.`storage_pool` SET `storage_provider_name` = 'FlashArray' WHERE `storage_provider_name` = 'Flash Array'; + +-- KVM SystemVM templates are dynamically scalable, so CKS nodes created from them can be scaled live. +-- Existing VMs keep their own flag; only VMs created from now on pick it up. +UPDATE `cloud`.`vm_template` SET `dynamically_scalable` = 1 WHERE `type` = 'SYSTEM' AND `hypervisor_type` = 'KVM' AND `removed` IS NULL; diff --git a/engine/schema/src/test/java/com/cloud/upgrade/SystemVmTemplateRegistrationTest.java b/engine/schema/src/test/java/com/cloud/upgrade/SystemVmTemplateRegistrationTest.java index dfc67b1dece3..34476792c664 100644 --- a/engine/schema/src/test/java/com/cloud/upgrade/SystemVmTemplateRegistrationTest.java +++ b/engine/schema/src/test/java/com/cloud/upgrade/SystemVmTemplateRegistrationTest.java @@ -1675,4 +1675,23 @@ public void getSystemVmTemplateVersion_BuildsFromMajorAndTinyVersionAfterCutover SystemVmTemplateRegistration.CS_TINY_VERSION = previousTiny; } } + + @Test + public void createTemplateObjectInDB_KvmTemplateIsDynamicallyScalable() { + assertTrue(createTemplateObject(Hypervisor.HypervisorType.KVM).isDynamicallyScalable()); + } + + @Test + public void createTemplateObjectInDB_OtherHypervisorTemplateIsNotDynamicallyScalable() { + assertFalse(createTemplateObject(Hypervisor.HypervisorType.VMware).isDynamicallyScalable()); + } + + private VMTemplateVO createTemplateObject(Hypervisor.HypervisorType hypervisorType) { + SystemVmTemplateRegistration.SystemVMTemplateDetails details = new SystemVmTemplateRegistration.SystemVMTemplateDetails( + "uuid", "systemvm", new java.sql.Date(System.currentTimeMillis()), "http://localhost/systemvm.qcow2", "d41d8cd98f00b204e9800998ecf8427e", + Storage.ImageFormat.QCOW2, 1, hypervisorType, CPU.CPUArch.amd64, 1L); + when(vmTemplateDao.getNextInSequence(Long.class, "id")).thenReturn(1L); + when(vmTemplateDao.persist(any(VMTemplateVO.class))).thenAnswer(invocation -> invocation.getArgument(0)); + return systemVmTemplateRegistration.createTemplateObjectInDB(details); + } } From 8758799f1b64c04103aaa70d9031b6074b3719db Mon Sep 17 00:00:00 2001 From: Andrija Panic Date: Sun, 15 Nov 2026 12:33:40 +0100 Subject: [PATCH 2/2] KVM: also mark SystemVM templates registered before the upgrade as dynamically scalable An operator can register the new SystemVM template by hand before upgrading. The upgrade SQL runs while it is still a user template, so it does not set the flag. Set it when such a KVM template is turned into a SystemVM template. Templates that already are SystemVM templates keep their flag, so a later upgrade does not undo an operator's choice. --- .../upgrade/SystemVmTemplateRegistration.java | 7 ++++ .../SystemVmTemplateRegistrationTest.java | 33 +++++++++++++++++++ 2 files changed, 40 insertions(+) diff --git a/engine/schema/src/main/java/com/cloud/upgrade/SystemVmTemplateRegistration.java b/engine/schema/src/main/java/com/cloud/upgrade/SystemVmTemplateRegistration.java index af1313cd493d..a9e6c91b07c0 100644 --- a/engine/schema/src/main/java/com/cloud/upgrade/SystemVmTemplateRegistration.java +++ b/engine/schema/src/main/java/com/cloud/upgrade/SystemVmTemplateRegistration.java @@ -1058,6 +1058,13 @@ public void doInTransactionWithoutResult(final TransactionStatus status) { protected void updateRegisteredTemplateDetails(Long templateId, MetadataTemplateDetails templateDetails, Long zoneId) { VMTemplateVO templateVO = vmTemplateDao.findById(templateId); + // A KVM template registered by hand before the upgrade becomes a SystemVM template only here, after the + // upgrade SQL has marked the existing KVM SystemVM templates as dynamically scalable. Templates that are + // already SystemVM templates keep their flag, so an operator who turned it off keeps it off. + if (!Storage.TemplateType.SYSTEM.equals(templateVO.getTemplateType()) + && Hypervisor.HypervisorType.KVM.equals(templateDetails.getHypervisorType())) { + templateVO.setDynamicallyScalable(true); + } templateVO.setTemplateType(Storage.TemplateType.SYSTEM); GuestOSVO guestOS = guestOSDao.findOneByDisplayName(templateDetails.getGuestOs()); if (guestOS != null) { diff --git a/engine/schema/src/test/java/com/cloud/upgrade/SystemVmTemplateRegistrationTest.java b/engine/schema/src/test/java/com/cloud/upgrade/SystemVmTemplateRegistrationTest.java index 34476792c664..79a9f6cf36a4 100644 --- a/engine/schema/src/test/java/com/cloud/upgrade/SystemVmTemplateRegistrationTest.java +++ b/engine/schema/src/test/java/com/cloud/upgrade/SystemVmTemplateRegistrationTest.java @@ -1694,4 +1694,37 @@ private VMTemplateVO createTemplateObject(Hypervisor.HypervisorType hypervisorTy when(vmTemplateDao.persist(any(VMTemplateVO.class))).thenAnswer(invocation -> invocation.getArgument(0)); return systemVmTemplateRegistration.createTemplateObjectInDB(details); } + + @Test + public void updateRegisteredTemplateDetails_PreRegisteredKvmTemplateBecomesDynamicallyScalable() { + VMTemplateVO template = updateRegisteredTemplate(Storage.TemplateType.USER, Hypervisor.HypervisorType.KVM); + assertEquals(Storage.TemplateType.SYSTEM, template.getTemplateType()); + assertTrue(template.isDynamicallyScalable()); + } + + @Test + public void updateRegisteredTemplateDetails_KvmSystemTemplateKeepsItsFlag() { + assertFalse(updateRegisteredTemplate(Storage.TemplateType.SYSTEM, Hypervisor.HypervisorType.KVM).isDynamicallyScalable()); + } + + @Test + public void updateRegisteredTemplateDetails_PreRegisteredOtherHypervisorTemplateIsNotDynamicallyScalable() { + assertFalse(updateRegisteredTemplate(Storage.TemplateType.USER, Hypervisor.HypervisorType.VMware).isDynamicallyScalable()); + } + + private VMTemplateVO updateRegisteredTemplate(Storage.TemplateType currentType, Hypervisor.HypervisorType hypervisorType) { + long templateId = 1L; + VMTemplateVO template = new VMTemplateVO(); + template.setTemplateType(currentType); + template.setDynamicallyScalable(false); + SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = + Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); + when(templateDetails.getHypervisorType()).thenReturn(hypervisorType); + when(vmTemplateDao.findById(templateId)).thenReturn(template); + when(vmTemplateDao.update(template.getId(), template)).thenReturn(true); + doNothing().when(systemVmTemplateRegistration).updateSystemVMEntries(templateId, hypervisorType); + doNothing().when(systemVmTemplateRegistration).updateConfigurationParams(any(), any(), any()); + systemVmTemplateRegistration.updateRegisteredTemplateDetails(templateId, templateDetails, null); + return template; + } }