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..a9e6c91b07c0 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; } @@ -1056,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/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..79a9f6cf36a4 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,56 @@ 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); + } + + @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; + } }