From 98a08dc13a61ee90794eebdbf771ee2c554fc33a Mon Sep 17 00:00:00 2001 From: Andrija Panic Date: Sun, 15 Nov 2026 07:54:16 +0100 Subject: [PATCH 1/4] CKS: refuse etcd nodes when the Kubernetes ISO has no etcd A cluster with dedicated etcd nodes was accepted even when the ISO of the chosen Kubernetes version did not include the etcd binaries. The etcd nodes then never came up and the cluster sat in Starting until the one hour start timeout. The secondary storage VM can now be asked whether an ISO contains a given file. The result for etcd/etcd-linux-amd64.tar.gz is saved as the ISO detail cks.etcd.included, so each ISO is checked only once. A background task checks the Kubernetes ISOs that have no result yet, which also covers ISOs registered before an upgrade. If there is still no result when a cluster with etcd nodes is requested, the check runs at that point. createKubernetesCluster with etcd nodes is rejected with a clear message when the ISO has no etcd. When the ISO cannot be checked, for example because the storage VM is down or the ISO is direct download, the request is allowed as before. listKubernetesSupportedVersions returns supportsetcd, and the UI shows a warning when etcd nodes are asked for with a version that lacks etcd. Fixes #14703 --- .../apache/cloudstack/api/ApiConstants.java | 1 + .../storage/command/CheckFileInIsoAnswer.java | 48 ++++ .../command/CheckFileInIsoCommand.java | 67 ++++++ .../cluster/KubernetesClusterManagerImpl.java | 28 +++ .../version/KubernetesVersionManagerImpl.java | 179 ++++++++++++++ .../version/KubernetesVersionService.java | 12 + .../KubernetesSupportedVersionResponse.java | 12 + .../KubernetesClusterManagerImplTest.java | 39 ++++ .../KubernetesVersionManagerImplTest.java | 219 ++++++++++++++++++ .../resource/NfsSecondaryStorageResource.java | 63 +++++ .../NfsSecondaryStorageResourceTest.java | 92 ++++++++ ui/public/locales/en.json | 1 + .../views/compute/CreateKubernetesCluster.vue | 6 + 13 files changed, 767 insertions(+) create mode 100644 core/src/main/java/org/apache/cloudstack/storage/command/CheckFileInIsoAnswer.java create mode 100644 core/src/main/java/org/apache/cloudstack/storage/command/CheckFileInIsoCommand.java diff --git a/api/src/main/java/org/apache/cloudstack/api/ApiConstants.java b/api/src/main/java/org/apache/cloudstack/api/ApiConstants.java index 0711444c061b..9e5e16f5fb51 100644 --- a/api/src/main/java/org/apache/cloudstack/api/ApiConstants.java +++ b/api/src/main/java/org/apache/cloudstack/api/ApiConstants.java @@ -1324,6 +1324,7 @@ public class ApiConstants { public static final String NODE_ROOT_DISK_SIZE = "noderootdisksize"; public static final String SUPPORTS_HA = "supportsha"; public static final String SUPPORTS_AUTOSCALING = "supportsautoscaling"; + public static final String SUPPORTS_ETCD = "supportsetcd"; public static final String AUTOSCALING_ENABLED = "autoscalingenabled"; public static final String MIN_SIZE = "minsize"; public static final String MAX_SIZE = "maxsize"; diff --git a/core/src/main/java/org/apache/cloudstack/storage/command/CheckFileInIsoAnswer.java b/core/src/main/java/org/apache/cloudstack/storage/command/CheckFileInIsoAnswer.java new file mode 100644 index 000000000000..c0fe46bfb8e7 --- /dev/null +++ b/core/src/main/java/org/apache/cloudstack/storage/command/CheckFileInIsoAnswer.java @@ -0,0 +1,48 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package org.apache.cloudstack.storage.command; + +import com.cloud.agent.api.Answer; + +public class CheckFileInIsoAnswer extends Answer { + + private boolean filePresent; + + public CheckFileInIsoAnswer() { + super(); + } + + /** + * The ISO was read and the file was or was not found in it. + */ + public CheckFileInIsoAnswer(final CheckFileInIsoCommand cmd, final boolean filePresent) { + super(cmd, true, null); + this.filePresent = filePresent; + } + + /** + * The ISO could not be read, so nothing is known about the file. + */ + public CheckFileInIsoAnswer(final CheckFileInIsoCommand cmd, final String errorDetails) { + super(cmd, false, errorDetails); + } + + public boolean isFilePresent() { + return filePresent; + } +} diff --git a/core/src/main/java/org/apache/cloudstack/storage/command/CheckFileInIsoCommand.java b/core/src/main/java/org/apache/cloudstack/storage/command/CheckFileInIsoCommand.java new file mode 100644 index 000000000000..a747b9eec1d1 --- /dev/null +++ b/core/src/main/java/org/apache/cloudstack/storage/command/CheckFileInIsoCommand.java @@ -0,0 +1,67 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package org.apache.cloudstack.storage.command; + +import com.cloud.agent.api.to.DataStoreTO; + +/** + * Asks the secondary storage VM whether an ISO on the given image store contains a file. + */ +public class CheckFileInIsoCommand extends StorageSubSystemCommand { + + private DataStoreTO store; + private String isoPath; + private String filePath; + + public CheckFileInIsoCommand() { + super(); + } + + public CheckFileInIsoCommand(final DataStoreTO store, final String isoPath, final String filePath) { + super(); + this.store = store; + this.isoPath = isoPath; + this.filePath = filePath; + } + + public DataStoreTO getStore() { + return store; + } + + /** + * @return path of the ISO, relative to the root of the image store + */ + public String getIsoPath() { + return isoPath; + } + + /** + * @return path of the file to look for, relative to the root of the ISO + */ + public String getFilePath() { + return filePath; + } + + @Override + public boolean executeInSequence() { + return false; + } + + @Override + public void setExecuteInSequence(boolean inSeq) {} +} diff --git a/plugins/integrations/kubernetes-service/src/main/java/com/cloud/kubernetes/cluster/KubernetesClusterManagerImpl.java b/plugins/integrations/kubernetes-service/src/main/java/com/cloud/kubernetes/cluster/KubernetesClusterManagerImpl.java index eb4ebb78ee48..b455b1f91e5d 100644 --- a/plugins/integrations/kubernetes-service/src/main/java/com/cloud/kubernetes/cluster/KubernetesClusterManagerImpl.java +++ b/plugins/integrations/kubernetes-service/src/main/java/com/cloud/kubernetes/cluster/KubernetesClusterManagerImpl.java @@ -180,6 +180,7 @@ import com.cloud.kubernetes.version.KubernetesSupportedVersion; import com.cloud.kubernetes.version.KubernetesSupportedVersionVO; import com.cloud.kubernetes.version.KubernetesVersionManagerImpl; +import com.cloud.kubernetes.version.KubernetesVersionService; import com.cloud.kubernetes.version.dao.KubernetesSupportedVersionDao; import com.cloud.network.IpAddress; import com.cloud.network.Network; @@ -326,6 +327,8 @@ public class KubernetesClusterManagerImpl extends ManagerBase implements Kuberne @Inject public KubernetesSupportedVersionDao kubernetesSupportedVersionDao; @Inject + protected KubernetesVersionService kubernetesVersionService; + @Inject protected SSHKeyPairDao sshKeyPairDao; @Inject protected DataCenterDao dataCenterDao; @@ -1094,6 +1097,29 @@ public boolean isCommandSupported(KubernetesCluster cluster, String cmdName) { } } + /** + * Dedicated etcd nodes install etcd from the Kubernetes ISO, and not every ISO has it. Fail the request when + * the ISO is known not to have it. When the ISO could not be checked the request is let through, and a failed + * etcd setup is then caught while the cluster starts. + */ + protected void validateEtcdNodesSupportedByKubernetesVersion(final long etcdNodes, final KubernetesSupportedVersion kubernetesVersion) { + if (etcdNodes <= 0) { + return; + } + Boolean etcdIncluded = kubernetesVersionService.isEtcdIncludedInIso(kubernetesVersion); + if (etcdIncluded == null) { + logger.warn("Unable to tell whether the ISO of Kubernetes version {} includes the etcd binaries, allowing the request for {} etcd node(s)", + kubernetesVersion, etcdNodes); + return; + } + if (!etcdIncluded) { + throw new InvalidParameterValueException(String.format("Kubernetes version %s (ID: %s) cannot be used for a cluster with dedicated etcd nodes " + + "as its ISO does not include the etcd binaries (%s). Use a Kubernetes version whose ISO was built with etcd, " + + "or create the cluster without etcd nodes", kubernetesVersion.getName(), kubernetesVersion.getUuid(), + KubernetesVersionService.ETCD_ARCHIVE_PATH_IN_ISO)); + } + } + private void validateManagedKubernetesClusterCreateParameters(final CreateKubernetesClusterCmd cmd) throws CloudRuntimeException { ApiServiceConfiguration.validateEndpointUrl(); final String name = cmd.getName(); @@ -1168,6 +1194,8 @@ private void validateManagedKubernetesClusterCreateParameters(final CreateKubern throw new InvalidParameterValueException(String.format("ISO associated with version ID: %s is not in Ready state for datacenter ID: %s", clusterKubernetesVersion.getUuid(), zone.getUuid())); } + validateEtcdNodesSupportedByKubernetesVersion(cmd.getEtcdNodes(), clusterKubernetesVersion); + validateServiceOfferingsForNodeTypes(serviceOfferingNodeTypeMap, defaultServiceOfferingId, cmd.getEtcdNodes(), clusterKubernetesVersion); validateSshKeyPairForKubernetesCreateParameters(sshKeyPair, owner); diff --git a/plugins/integrations/kubernetes-service/src/main/java/com/cloud/kubernetes/version/KubernetesVersionManagerImpl.java b/plugins/integrations/kubernetes-service/src/main/java/com/cloud/kubernetes/version/KubernetesVersionManagerImpl.java index aef020335f2d..4ec9b3b09c6c 100644 --- a/plugins/integrations/kubernetes-service/src/main/java/com/cloud/kubernetes/version/KubernetesVersionManagerImpl.java +++ b/plugins/integrations/kubernetes-service/src/main/java/com/cloud/kubernetes/version/KubernetesVersionManagerImpl.java @@ -19,9 +19,17 @@ import java.net.MalformedURLException; import java.util.ArrayList; +import java.util.HashSet; import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; import javax.inject.Inject; +import javax.naming.ConfigurationException; import org.apache.cloudstack.api.ApiCommandResourceType; import org.apache.cloudstack.api.ApiConstants; @@ -37,11 +45,21 @@ import org.apache.cloudstack.api.response.KubernetesSupportedVersionResponse; import org.apache.cloudstack.api.response.ListResponse; import org.apache.cloudstack.context.CallContext; +import org.apache.cloudstack.engine.subsystem.api.storage.DataStore; +import org.apache.cloudstack.engine.subsystem.api.storage.DataStoreManager; +import org.apache.cloudstack.engine.subsystem.api.storage.EndPoint; +import org.apache.cloudstack.engine.subsystem.api.storage.EndPointSelector; +import org.apache.cloudstack.managed.context.ManagedContextRunnable; +import org.apache.cloudstack.storage.command.CheckFileInIsoAnswer; +import org.apache.cloudstack.storage.command.CheckFileInIsoCommand; import org.apache.cloudstack.storage.datastore.db.ImageStoreDao; import org.apache.cloudstack.storage.datastore.db.ImageStoreVO; +import org.apache.cloudstack.storage.datastore.db.TemplateDataStoreDao; +import org.apache.cloudstack.storage.datastore.db.TemplateDataStoreVO; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.lang3.StringUtils; +import com.cloud.agent.api.Answer; import com.cloud.api.query.dao.TemplateJoinDao; import com.cloud.api.query.vo.TemplateJoinVO; import com.cloud.cpu.CPU; @@ -55,8 +73,11 @@ import com.cloud.kubernetes.cluster.KubernetesClusterVO; import com.cloud.kubernetes.cluster.dao.KubernetesClusterDao; import com.cloud.kubernetes.version.dao.KubernetesSupportedVersionDao; +import com.cloud.storage.DataStoreRole; +import com.cloud.storage.VMTemplateDetailVO; import com.cloud.storage.VMTemplateVO; import com.cloud.storage.dao.VMTemplateDao; +import com.cloud.storage.dao.VMTemplateDetailsDao; import com.cloud.storage.dao.VMTemplateZoneDao; import com.cloud.template.TemplateApiService; import com.cloud.template.VirtualMachineTemplate; @@ -65,7 +86,9 @@ import com.cloud.utils.Pair; import com.cloud.utils.component.ComponentContext; import com.cloud.utils.component.ManagerBase; +import com.cloud.utils.concurrency.NamedThreadFactory; import com.cloud.utils.db.Filter; +import com.cloud.utils.db.GlobalLock; import com.cloud.utils.db.JoinBuilder; import com.cloud.utils.db.SearchBuilder; import com.cloud.utils.db.SearchCriteria; @@ -91,6 +114,21 @@ public class KubernetesVersionManagerImpl extends ManagerBase implements Kuberne private ImageStoreDao imageStoreDao; @Inject private TemplateApiService templateService; + @Inject + private VMTemplateDetailsDao templateDetailsDao; + @Inject + private TemplateDataStoreDao templateDataStoreDao; + @Inject + private DataStoreManager dataStoreManager; + @Inject + private EndPointSelector endPointSelector; + + protected static final int ETCD_IN_ISO_CHECK_INTERVAL_SECONDS = 300; + protected static final int MAX_FAILED_BACKGROUND_ETCD_IN_ISO_CHECKS = 3; + + private ScheduledExecutorService etcdInIsoChecker; + // ISO ID -> number of background checks that could not be run for it + private final Map failedEtcdInIsoChecks = new ConcurrentHashMap<>(); public static final String MINIMUN_AUTOSCALER_SUPPORTED_VERSION = "1.15.0"; @@ -131,6 +169,7 @@ private KubernetesSupportedVersionResponse createKubernetesSupportedVersionRespo response.setSupportsHA(compareSemanticVersions(kubernetesSupportedVersion.getSemanticVersion(), KubernetesClusterService.MIN_KUBERNETES_VERSION_HA_SUPPORT)>=0); response.setSupportsAutoscaling(versionSupportsAutoscaling(kubernetesSupportedVersion)); + response.setSupportsEtcd(getStoredEtcdIncludedInIso(kubernetesSupportedVersion.getIsoId())); updateTemplateDetailsInKubernetesSupportedVersionResponse(kubernetesSupportedVersion, response, isRootAdmin); response.setCreated(kubernetesSupportedVersion.getCreated()); return response; @@ -539,6 +578,146 @@ public KubernetesSupportedVersionResponse updateKubernetesSupportedVersion(final return createKubernetesSupportedVersionResponse(version, true); } + /** + * @return what an earlier check found for the ISO, or null if the ISO has not been checked yet + */ + protected Boolean getStoredEtcdIncludedInIso(long isoId) { + VMTemplateDetailVO detail = templateDetailsDao.findDetail(isoId, ETCD_INCLUDED_ISO_DETAIL); + if (detail == null || StringUtils.isBlank(detail.getValue())) { + return null; + } + return Boolean.parseBoolean(detail.getValue()); + } + + /** + * Asks the secondary storage VM whether the ISO has the etcd binaries and stores the answer as a detail of + * the ISO, so the ISO is read only once. + * + * @return null if the check could not be run, in which case nothing is stored + */ + protected Boolean checkAndStoreEtcdIncludedInIso(long isoId) { + VMTemplateVO iso = templateDao.findById(isoId); + if (iso == null || iso.isDirectDownload()) { + // A direct download ISO is not kept on an image store, so there is nothing the secondary storage VM can read + return null; + } + TemplateDataStoreVO isoOnStore = templateDataStoreDao.findReadyByTemplate(isoId, DataStoreRole.Image); + if (isoOnStore == null || StringUtils.isBlank(isoOnStore.getInstallPath())) { + logger.debug("Kubernetes ISO {} is not ready on any image store, unable to check it for the etcd binaries", iso); + return null; + } + DataStore store = dataStoreManager.getDataStore(isoOnStore.getDataStoreId(), DataStoreRole.Image); + EndPoint endPoint = store == null ? null : endPointSelector.select(store); + if (endPoint == null) { + logger.debug("No secondary storage VM available to check Kubernetes ISO {} for the etcd binaries", iso); + return null; + } + CheckFileInIsoCommand cmd = new CheckFileInIsoCommand(store.getTO(), isoOnStore.getInstallPath(), ETCD_ARCHIVE_PATH_IN_ISO); + Answer answer = endPoint.sendMessage(cmd); + if (!(answer instanceof CheckFileInIsoAnswer) || !answer.getResult()) { + logger.warn("Unable to check Kubernetes ISO {} for the etcd binaries: {}", iso, answer == null ? "no answer" : answer.getDetails()); + return null; + } + boolean etcdIncluded = ((CheckFileInIsoAnswer)answer).isFilePresent(); + templateDetailsDao.addDetail(isoId, ETCD_INCLUDED_ISO_DETAIL, String.valueOf(etcdIncluded), true); + logger.info("Kubernetes ISO {} {} the etcd binaries needed for dedicated etcd nodes", iso, etcdIncluded ? "includes" : "does not include"); + return etcdIncluded; + } + + @Override + public Boolean isEtcdIncludedInIso(KubernetesSupportedVersion kubernetesSupportedVersion) { + long isoId = kubernetesSupportedVersion.getIsoId(); + Boolean etcdIncluded = getStoredEtcdIncludedInIso(isoId); + if (etcdIncluded != null) { + return etcdIncluded; + } + try { + return checkAndStoreEtcdIncludedInIso(isoId); + } catch (CloudRuntimeException e) { + logger.warn("Unable to check the ISO of Kubernetes version {} for the etcd binaries", kubernetesSupportedVersion, e); + return null; + } + } + + /** + * Checks the Kubernetes ISOs that are ready but have not been checked for the etcd binaries yet. This covers + * both newly registered ISOs and the ones registered before this check existed. + */ + protected void checkEtcdIncludedInKubernetesIsos() { + Set isoIds = new HashSet<>(); + for (KubernetesSupportedVersionVO version : kubernetesSupportedVersionDao.listAll()) { + long isoId = version.getIsoId(); + if (!isoIds.add(isoId)) { + continue; + } + if (getStoredEtcdIncludedInIso(isoId) != null) { + failedEtcdInIsoChecks.remove(isoId); + continue; + } + if (failedEtcdInIsoChecks.getOrDefault(isoId, 0) >= MAX_FAILED_BACKGROUND_ETCD_IN_ISO_CHECKS) { + // Stop trying in the background, the ISO is still checked when a cluster with etcd nodes is requested + continue; + } + VMTemplateVO iso = templateDao.findById(isoId); + if (iso == null || iso.isDirectDownload() || templateDataStoreDao.findReadyByTemplate(isoId, DataStoreRole.Image) == null) { + continue; + } + try { + if (checkAndStoreEtcdIncludedInIso(isoId) == null) { + failedEtcdInIsoChecks.merge(isoId, 1, Integer::sum); + } + } catch (CloudRuntimeException e) { + logger.warn("Unable to check the ISO of Kubernetes version {} for the etcd binaries", version, e); + failedEtcdInIsoChecks.merge(isoId, 1, Integer::sum); + } + } + failedEtcdInIsoChecks.keySet().retainAll(isoIds); + } + + public class EtcdInKubernetesIsoChecker extends ManagedContextRunnable { + @Override + protected void runInContext() { + GlobalLock lock = GlobalLock.getInternLock("KubernetesVersion.EtcdInIsoCheck.Lock"); + try { + if (lock.lock(3)) { + try { + checkEtcdIncludedInKubernetesIsos(); + } catch (Exception e) { + logger.warn("Failed to check the Kubernetes ISOs for the etcd binaries", e); + } finally { + lock.unlock(); + } + } + } finally { + lock.releaseRef(); + } + } + } + + @Override + public boolean configure(String name, Map params) throws ConfigurationException { + super.configure(name, params); + etcdInIsoChecker = Executors.newScheduledThreadPool(1, new NamedThreadFactory("Kubernetes-ISO-Etcd-Checker")); + return true; + } + + @Override + public boolean start() { + if (KubernetesClusterService.KubernetesServiceEnabled.value()) { + etcdInIsoChecker.scheduleWithFixedDelay(new EtcdInKubernetesIsoChecker(), ETCD_IN_ISO_CHECK_INTERVAL_SECONDS, + ETCD_IN_ISO_CHECK_INTERVAL_SECONDS, TimeUnit.SECONDS); + } + return true; + } + + @Override + public boolean stop() { + if (etcdInIsoChecker != null) { + etcdInIsoChecker.shutdownNow(); + } + return true; + } + @Override public List> getCommands() { List> cmdList = new ArrayList>(); diff --git a/plugins/integrations/kubernetes-service/src/main/java/com/cloud/kubernetes/version/KubernetesVersionService.java b/plugins/integrations/kubernetes-service/src/main/java/com/cloud/kubernetes/version/KubernetesVersionService.java index cbe33e94d1ef..1540e7be319f 100644 --- a/plugins/integrations/kubernetes-service/src/main/java/com/cloud/kubernetes/version/KubernetesVersionService.java +++ b/plugins/integrations/kubernetes-service/src/main/java/com/cloud/kubernetes/version/KubernetesVersionService.java @@ -31,6 +31,18 @@ public interface KubernetesVersionService extends PluggableService { static final String MIN_KUBERNETES_VERSION = "1.11.0"; + // Detail of a Kubernetes ISO which records whether the ISO has the etcd binaries needed for dedicated etcd nodes + static final String ETCD_INCLUDED_ISO_DETAIL = "cks.etcd.included"; + static final String ETCD_ARCHIVE_PATH_IN_ISO = "etcd/etcd-linux-amd64.tar.gz"; + + /** + * Tells whether the ISO of a Kubernetes version has the etcd binaries needed for dedicated etcd nodes. The ISO + * is checked on the first call and the result is stored with the ISO. + * + * @return null if it is not known because the ISO could not be checked + */ + Boolean isEtcdIncludedInIso(KubernetesSupportedVersion kubernetesSupportedVersion); + ListResponse listKubernetesSupportedVersions(ListKubernetesSupportedVersionsCmd cmd); KubernetesSupportedVersionResponse addKubernetesSupportedVersion(AddKubernetesSupportedVersionCmd cmd) throws CloudRuntimeException; GetUploadParamsResponse registerKubernetesSupportedVersionForPostUpload(GetUploadParamsForKubernetesSupportedVersionCmd cmd); diff --git a/plugins/integrations/kubernetes-service/src/main/java/org/apache/cloudstack/api/response/KubernetesSupportedVersionResponse.java b/plugins/integrations/kubernetes-service/src/main/java/org/apache/cloudstack/api/response/KubernetesSupportedVersionResponse.java index f6e1ee859449..8c22231ba4a3 100644 --- a/plugins/integrations/kubernetes-service/src/main/java/org/apache/cloudstack/api/response/KubernetesSupportedVersionResponse.java +++ b/plugins/integrations/kubernetes-service/src/main/java/org/apache/cloudstack/api/response/KubernetesSupportedVersionResponse.java @@ -78,6 +78,10 @@ public class KubernetesSupportedVersionResponse extends BaseResponse { @Param(description = "Whether Kubernetes supported version supports Autoscaling") private Boolean supportsAutoscaling; + @SerializedName(ApiConstants.SUPPORTS_ETCD) + @Param(description = "Whether the ISO of the Kubernetes supported version has the etcd binaries needed for dedicated etcd nodes. Not returned if the ISO has not been checked yet", since = "24.0.0") + private Boolean supportsEtcd; + @SerializedName(ApiConstants.STATE) @Param(description = "The enabled or disabled state of the Kubernetes supported version") private String state; @@ -218,6 +222,14 @@ public void setSupportsAutoscaling(Boolean supportsAutoscaling) { this.supportsAutoscaling = supportsAutoscaling; } + public Boolean getSupportsEtcd() { + return supportsEtcd; + } + + public void setSupportsEtcd(Boolean supportsEtcd) { + this.supportsEtcd = supportsEtcd; + } + public void setCreated(Date created) { this.created = created; } diff --git a/plugins/integrations/kubernetes-service/src/test/java/com/cloud/kubernetes/cluster/KubernetesClusterManagerImplTest.java b/plugins/integrations/kubernetes-service/src/test/java/com/cloud/kubernetes/cluster/KubernetesClusterManagerImplTest.java index 1fab5420c3c3..b25165b8baae 100644 --- a/plugins/integrations/kubernetes-service/src/test/java/com/cloud/kubernetes/cluster/KubernetesClusterManagerImplTest.java +++ b/plugins/integrations/kubernetes-service/src/test/java/com/cloud/kubernetes/cluster/KubernetesClusterManagerImplTest.java @@ -30,6 +30,7 @@ import com.cloud.kubernetes.cluster.dao.KubernetesClusterDao; import com.cloud.kubernetes.cluster.dao.KubernetesClusterVmMapDao; import com.cloud.kubernetes.version.KubernetesSupportedVersion; +import com.cloud.kubernetes.version.KubernetesVersionService; import com.cloud.network.Network; import com.cloud.network.dao.FirewallRulesDao; import com.cloud.network.rules.FirewallRule; @@ -118,6 +119,9 @@ public class KubernetesClusterManagerImplTest { @Mock private HostDao hostDao; + @Mock + private KubernetesVersionService kubernetesVersionService; + @Spy @InjectMocks KubernetesClusterManagerImpl kubernetesClusterManager; @@ -914,4 +918,39 @@ public void testValidateNodeAffinityGroupsAffinityNoExistingWorkers() { Mockito.verify(kubernetesClusterAffinityGroupMapDao).listAffinityGroupIdsByClusterIdAndNodeType(1L, WORKER.name()); } + @Test + public void testValidateEtcdNodesSupportedByKubernetesVersionNoEtcdNodes() { + KubernetesSupportedVersion version = Mockito.mock(KubernetesSupportedVersion.class); + kubernetesClusterManager.validateEtcdNodesSupportedByKubernetesVersion(0, version); + Mockito.verifyNoInteractions(kubernetesVersionService); + } + + @Test + public void testValidateEtcdNodesSupportedByKubernetesVersionEtcdIncluded() { + KubernetesSupportedVersion version = Mockito.mock(KubernetesSupportedVersion.class); + Mockito.when(kubernetesVersionService.isEtcdIncludedInIso(version)).thenReturn(true); + kubernetesClusterManager.validateEtcdNodesSupportedByKubernetesVersion(3, version); + } + + @Test + public void testValidateEtcdNodesSupportedByKubernetesVersionNotKnown() { + KubernetesSupportedVersion version = Mockito.mock(KubernetesSupportedVersion.class); + Mockito.when(kubernetesVersionService.isEtcdIncludedInIso(version)).thenReturn(null); + kubernetesClusterManager.validateEtcdNodesSupportedByKubernetesVersion(1, version); + } + + @Test + public void testValidateEtcdNodesSupportedByKubernetesVersionEtcdNotIncluded() { + KubernetesSupportedVersion version = Mockito.mock(KubernetesSupportedVersion.class); + Mockito.when(version.getName()).thenReturn("v1.28.4"); + Mockito.when(kubernetesVersionService.isEtcdIncludedInIso(version)).thenReturn(false); + try { + kubernetesClusterManager.validateEtcdNodesSupportedByKubernetesVersion(1, version); + Assert.fail("A cluster with etcd nodes should be rejected when the ISO has no etcd"); + } catch (InvalidParameterValueException e) { + Assert.assertTrue(e.getMessage(), e.getMessage().contains("v1.28.4")); + Assert.assertTrue(e.getMessage(), e.getMessage().contains("does not include the etcd binaries")); + } + } + } diff --git a/plugins/integrations/kubernetes-service/src/test/java/com/cloud/kubernetes/version/KubernetesVersionManagerImplTest.java b/plugins/integrations/kubernetes-service/src/test/java/com/cloud/kubernetes/version/KubernetesVersionManagerImplTest.java index 35f8e66e0452..bd61e4c8e7b8 100644 --- a/plugins/integrations/kubernetes-service/src/test/java/com/cloud/kubernetes/version/KubernetesVersionManagerImplTest.java +++ b/plugins/integrations/kubernetes-service/src/test/java/com/cloud/kubernetes/version/KubernetesVersionManagerImplTest.java @@ -22,9 +22,17 @@ import java.util.UUID; import org.apache.cloudstack.api.response.KubernetesSupportedVersionResponse; +import org.apache.cloudstack.engine.subsystem.api.storage.DataStore; +import org.apache.cloudstack.engine.subsystem.api.storage.DataStoreManager; +import org.apache.cloudstack.engine.subsystem.api.storage.EndPoint; +import org.apache.cloudstack.engine.subsystem.api.storage.EndPointSelector; import org.apache.cloudstack.engine.subsystem.api.storage.ObjectInDataStoreStateMachine; +import org.apache.cloudstack.storage.command.CheckFileInIsoAnswer; +import org.apache.cloudstack.storage.command.CheckFileInIsoCommand; import org.apache.cloudstack.storage.datastore.db.ImageStoreDao; import org.apache.cloudstack.storage.datastore.db.ImageStoreVO; +import org.apache.cloudstack.storage.datastore.db.TemplateDataStoreDao; +import org.apache.cloudstack.storage.datastore.db.TemplateDataStoreVO; import org.junit.Assert; import org.junit.Test; import org.junit.runner.RunWith; @@ -34,12 +42,19 @@ import org.mockito.junit.MockitoJUnitRunner; import org.springframework.test.util.ReflectionTestUtils; +import com.cloud.agent.api.Answer; import com.cloud.api.query.dao.TemplateJoinDao; import com.cloud.api.query.vo.TemplateJoinVO; import com.cloud.cpu.CPU; import com.cloud.dc.DataCenterVO; import com.cloud.dc.dao.DataCenterDao; import com.cloud.exception.InvalidParameterValueException; +import com.cloud.kubernetes.version.dao.KubernetesSupportedVersionDao; +import com.cloud.storage.DataStoreRole; +import com.cloud.storage.VMTemplateDetailVO; +import com.cloud.storage.VMTemplateVO; +import com.cloud.storage.dao.VMTemplateDao; +import com.cloud.storage.dao.VMTemplateDetailsDao; @RunWith(MockitoJUnitRunner.class) public class KubernetesVersionManagerImplTest { @@ -53,6 +68,24 @@ public class KubernetesVersionManagerImplTest { @Mock DataCenterDao dataCenterDao; + @Mock + KubernetesSupportedVersionDao kubernetesSupportedVersionDao; + + @Mock + VMTemplateDao templateDao; + + @Mock + VMTemplateDetailsDao templateDetailsDao; + + @Mock + TemplateDataStoreDao templateDataStoreDao; + + @Mock + DataStoreManager dataStoreManager; + + @Mock + EndPointSelector endPointSelector; + @InjectMocks KubernetesVersionManagerImpl kubernetesVersionManager = new KubernetesVersionManagerImpl(); @@ -144,4 +177,190 @@ public void testValidateImageStoreForAllZonesWithSomeMissingStorage() { ReflectionTestUtils.invokeMethod(kubernetesVersionManager, "validateImageStoreForZone", (Long) null, false); } + + private static final long ISO_ID = 200L; + + private KubernetesSupportedVersionVO mockVersionWithIso() { + KubernetesSupportedVersionVO version = Mockito.mock(KubernetesSupportedVersionVO.class); + Mockito.when(version.getIsoId()).thenReturn(ISO_ID); + return version; + } + + private void mockStoredEtcdDetail(String value) { + VMTemplateDetailVO detail = Mockito.mock(VMTemplateDetailVO.class); + Mockito.when(detail.getValue()).thenReturn(value); + Mockito.when(templateDetailsDao.findDetail(ISO_ID, KubernetesVersionService.ETCD_INCLUDED_ISO_DETAIL)).thenReturn(detail); + } + + private EndPoint mockIsoReadyOnImageStore() { + VMTemplateVO iso = Mockito.mock(VMTemplateVO.class); + Mockito.when(iso.isDirectDownload()).thenReturn(false); + Mockito.when(templateDao.findById(ISO_ID)).thenReturn(iso); + TemplateDataStoreVO isoOnStore = Mockito.mock(TemplateDataStoreVO.class); + Mockito.when(isoOnStore.getInstallPath()).thenReturn("template/tmpl/1/200/200-1-uuid.iso"); + Mockito.when(isoOnStore.getDataStoreId()).thenReturn(5L); + Mockito.when(templateDataStoreDao.findReadyByTemplate(ISO_ID, DataStoreRole.Image)).thenReturn(isoOnStore); + DataStore store = Mockito.mock(DataStore.class); + Mockito.when(dataStoreManager.getDataStore(5L, DataStoreRole.Image)).thenReturn(store); + EndPoint endPoint = Mockito.mock(EndPoint.class); + Mockito.when(endPointSelector.select(store)).thenReturn(endPoint); + return endPoint; + } + + private void verifyNothingStored() { + Mockito.verify(templateDetailsDao, Mockito.never()).addDetail(Mockito.anyLong(), Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean()); + } + + @Test + public void testIsEtcdIncludedInIsoUsesStoredResult() { + KubernetesSupportedVersionVO version = mockVersionWithIso(); + mockStoredEtcdDetail("true"); + Assert.assertEquals(Boolean.TRUE, kubernetesVersionManager.isEtcdIncludedInIso(version)); + mockStoredEtcdDetail("false"); + Assert.assertEquals(Boolean.FALSE, kubernetesVersionManager.isEtcdIncludedInIso(version)); + Mockito.verifyNoInteractions(endPointSelector); + verifyNothingStored(); + } + + @Test + public void testIsEtcdIncludedInIsoChecksAndStoresWhenEtcdPresent() { + KubernetesSupportedVersionVO version = mockVersionWithIso(); + EndPoint endPoint = mockIsoReadyOnImageStore(); + Mockito.when(endPoint.sendMessage(Mockito.any(CheckFileInIsoCommand.class))).thenAnswer(invocation -> { + CheckFileInIsoCommand cmd = invocation.getArgument(0); + Assert.assertEquals("template/tmpl/1/200/200-1-uuid.iso", cmd.getIsoPath()); + Assert.assertEquals(KubernetesVersionService.ETCD_ARCHIVE_PATH_IN_ISO, cmd.getFilePath()); + return new CheckFileInIsoAnswer(cmd, true); + }); + + Assert.assertEquals(Boolean.TRUE, kubernetesVersionManager.isEtcdIncludedInIso(version)); + + Mockito.verify(templateDetailsDao).addDetail(ISO_ID, KubernetesVersionService.ETCD_INCLUDED_ISO_DETAIL, "true", true); + } + + @Test + public void testIsEtcdIncludedInIsoChecksAndStoresWhenEtcdMissing() { + KubernetesSupportedVersionVO version = mockVersionWithIso(); + EndPoint endPoint = mockIsoReadyOnImageStore(); + Mockito.when(endPoint.sendMessage(Mockito.any(CheckFileInIsoCommand.class))) + .thenAnswer(invocation -> new CheckFileInIsoAnswer(invocation.getArgument(0), false)); + + Assert.assertEquals(Boolean.FALSE, kubernetesVersionManager.isEtcdIncludedInIso(version)); + + Mockito.verify(templateDetailsDao).addDetail(ISO_ID, KubernetesVersionService.ETCD_INCLUDED_ISO_DETAIL, "false", true); + } + + @Test + public void testIsEtcdIncludedInIsoUnknownWhenIsoCouldNotBeRead() { + KubernetesSupportedVersionVO version = mockVersionWithIso(); + EndPoint endPoint = mockIsoReadyOnImageStore(); + Mockito.when(endPoint.sendMessage(Mockito.any(CheckFileInIsoCommand.class))) + .thenAnswer(invocation -> new CheckFileInIsoAnswer((CheckFileInIsoCommand)invocation.getArgument(0), "isoinfo: command not found")); + + Assert.assertNull(kubernetesVersionManager.isEtcdIncludedInIso(version)); + + verifyNothingStored(); + } + + @Test + public void testIsEtcdIncludedInIsoUnknownWhenAgentDoesNotKnowTheCommand() { + KubernetesSupportedVersionVO version = mockVersionWithIso(); + EndPoint endPoint = mockIsoReadyOnImageStore(); + Mockito.when(endPoint.sendMessage(Mockito.any(CheckFileInIsoCommand.class))) + .thenAnswer(invocation -> Answer.createUnsupportedCommandAnswer(invocation.getArgument(0))); + + Assert.assertNull(kubernetesVersionManager.isEtcdIncludedInIso(version)); + + verifyNothingStored(); + } + + @Test + public void testIsEtcdIncludedInIsoUnknownWhenNoSecondaryStorageVm() { + KubernetesSupportedVersionVO version = mockVersionWithIso(); + mockIsoReadyOnImageStore(); + Mockito.when(endPointSelector.select(Mockito.any(DataStore.class))).thenReturn(null); + + Assert.assertNull(kubernetesVersionManager.isEtcdIncludedInIso(version)); + + verifyNothingStored(); + } + + @Test + public void testIsEtcdIncludedInIsoUnknownForDirectDownloadIso() { + KubernetesSupportedVersionVO version = mockVersionWithIso(); + VMTemplateVO iso = Mockito.mock(VMTemplateVO.class); + Mockito.when(iso.isDirectDownload()).thenReturn(true); + Mockito.when(templateDao.findById(ISO_ID)).thenReturn(iso); + + Assert.assertNull(kubernetesVersionManager.isEtcdIncludedInIso(version)); + + Mockito.verifyNoInteractions(endPointSelector); + verifyNothingStored(); + } + + @Test + public void testBackgroundCheckSkipsCheckedIsos() { + KubernetesSupportedVersionVO version = mockVersionWithIso(); + Mockito.when(kubernetesSupportedVersionDao.listAll()).thenReturn(List.of(version)); + mockStoredEtcdDetail("false"); + + kubernetesVersionManager.checkEtcdIncludedInKubernetesIsos(); + + Mockito.verifyNoInteractions(endPointSelector); + verifyNothingStored(); + } + + @Test + public void testBackgroundCheckStoresResultForUncheckedIso() { + KubernetesSupportedVersionVO version = mockVersionWithIso(); + // Two versions sharing one ISO are checked once + Mockito.when(kubernetesSupportedVersionDao.listAll()).thenReturn(List.of(version, version)); + EndPoint endPoint = mockIsoReadyOnImageStore(); + Mockito.when(endPoint.sendMessage(Mockito.any(CheckFileInIsoCommand.class))) + .thenAnswer(invocation -> new CheckFileInIsoAnswer(invocation.getArgument(0), true)); + + kubernetesVersionManager.checkEtcdIncludedInKubernetesIsos(); + + Mockito.verify(endPoint, Mockito.times(1)).sendMessage(Mockito.any(CheckFileInIsoCommand.class)); + Mockito.verify(templateDetailsDao).addDetail(ISO_ID, KubernetesVersionService.ETCD_INCLUDED_ISO_DETAIL, "true", true); + } + + @Test + public void testBackgroundCheckGivesUpAfterRepeatedFailures() { + KubernetesSupportedVersionVO version = mockVersionWithIso(); + Mockito.when(kubernetesSupportedVersionDao.listAll()).thenReturn(List.of(version)); + EndPoint endPoint = mockIsoReadyOnImageStore(); + Mockito.when(endPoint.sendMessage(Mockito.any(CheckFileInIsoCommand.class))) + .thenAnswer(invocation -> new CheckFileInIsoAnswer((CheckFileInIsoCommand)invocation.getArgument(0), "isoinfo: command not found")); + + for (int i = 0; i < KubernetesVersionManagerImpl.MAX_FAILED_BACKGROUND_ETCD_IN_ISO_CHECKS + 2; i++) { + kubernetesVersionManager.checkEtcdIncludedInKubernetesIsos(); + } + + Mockito.verify(endPoint, Mockito.times(KubernetesVersionManagerImpl.MAX_FAILED_BACKGROUND_ETCD_IN_ISO_CHECKS)) + .sendMessage(Mockito.any(CheckFileInIsoCommand.class)); + verifyNothingStored(); + } + + @Test + public void testBackgroundCheckWaitsForIsoToBeReady() { + KubernetesSupportedVersionVO version = mockVersionWithIso(); + Mockito.when(kubernetesSupportedVersionDao.listAll()).thenReturn(List.of(version)); + VMTemplateVO iso = Mockito.mock(VMTemplateVO.class); + Mockito.when(templateDao.findById(ISO_ID)).thenReturn(iso); + Mockito.when(templateDataStoreDao.findReadyByTemplate(ISO_ID, DataStoreRole.Image)).thenReturn(null); + + // An ISO that is still downloading is not counted as a failed check, however long it takes + for (int i = 0; i < KubernetesVersionManagerImpl.MAX_FAILED_BACKGROUND_ETCD_IN_ISO_CHECKS + 2; i++) { + kubernetesVersionManager.checkEtcdIncludedInKubernetesIsos(); + } + Mockito.verifyNoInteractions(endPointSelector); + + EndPoint endPoint = mockIsoReadyOnImageStore(); + Mockito.when(endPoint.sendMessage(Mockito.any(CheckFileInIsoCommand.class))) + .thenAnswer(invocation -> new CheckFileInIsoAnswer(invocation.getArgument(0), true)); + kubernetesVersionManager.checkEtcdIncludedInKubernetesIsos(); + + Mockito.verify(templateDetailsDao).addDetail(ISO_ID, KubernetesVersionService.ETCD_INCLUDED_ISO_DETAIL, "true", true); + } } diff --git a/services/secondary-storage/server/src/main/java/org/apache/cloudstack/storage/resource/NfsSecondaryStorageResource.java b/services/secondary-storage/server/src/main/java/org/apache/cloudstack/storage/resource/NfsSecondaryStorageResource.java index 4345ff24e3c5..cea39fd81837 100644 --- a/services/secondary-storage/server/src/main/java/org/apache/cloudstack/storage/resource/NfsSecondaryStorageResource.java +++ b/services/secondary-storage/server/src/main/java/org/apache/cloudstack/storage/resource/NfsSecondaryStorageResource.java @@ -58,6 +58,8 @@ import org.apache.cloudstack.framework.security.keystore.KeystoreManager; import org.apache.cloudstack.storage.NfsMountManagerImpl.PathParser; import org.apache.cloudstack.storage.command.BackupDeleteAnswer; +import org.apache.cloudstack.storage.command.CheckFileInIsoAnswer; +import org.apache.cloudstack.storage.command.CheckFileInIsoCommand; import org.apache.cloudstack.storage.command.CopyCmdAnswer; import org.apache.cloudstack.storage.command.CopyCommand; import org.apache.cloudstack.storage.command.DeleteCommand; @@ -342,11 +344,72 @@ public Answer executeRequest(Command cmd) { return execute((ListDataStoreObjectsCommand)cmd); } else if (cmd instanceof QuerySnapshotZoneCopyCommand) { return execute((QuerySnapshotZoneCopyCommand)cmd); + } else if (cmd instanceof CheckFileInIsoCommand) { + return execute((CheckFileInIsoCommand)cmd); } else { return Answer.createUnsupportedCommandAnswer(cmd); } } + protected Answer execute(CheckFileInIsoCommand cmd) { + DataStoreTO store = cmd.getStore(); + if (!(store instanceof NfsTO)) { + return new CheckFileInIsoAnswer(cmd, "Checking the content of an ISO is supported only on NFS image stores"); + } + if (org.apache.commons.lang3.StringUtils.isAnyBlank(cmd.getIsoPath(), cmd.getFilePath())) { + return new CheckFileInIsoAnswer(cmd, "ISO path and file path are required to check the content of an ISO"); + } + String rootDir = getRootDir(((NfsTO)store).getUrl(), _nfsVersion); + File iso = new File(rootDir, cmd.getIsoPath()); + if (!iso.isFile()) { + return new CheckFileInIsoAnswer(cmd, String.format("ISO %s not found on the image store", cmd.getIsoPath())); + } + String listing; + try { + listing = listFilesInIso(iso); + } catch (CloudRuntimeException e) { + logger.warn("Unable to list the files in ISO {}: {}", iso.getAbsolutePath(), e.getMessage()); + return new CheckFileInIsoAnswer(cmd, e.getMessage()); + } + boolean filePresent = isFileInIsoListing(listing, cmd.getFilePath()); + logger.debug("File {} is {} in ISO {}", cmd.getFilePath(), filePresent ? "present" : "not present", iso.getAbsolutePath()); + return new CheckFileInIsoAnswer(cmd, filePresent); + } + + /** + * Lists all the files in an ISO, one full path per line, without mounting it. + */ + protected String listFilesInIso(File iso) { + Script command = new Script("isoinfo", _timeout, logger); + command.add("-R"); + command.add("-f"); + command.add("-i", iso.getAbsolutePath()); + OutputInterpreter.AllLinesParser parser = new OutputInterpreter.AllLinesParser(); + String result = command.execute(parser); + if (result != null) { + throw new CloudRuntimeException(String.format("Unable to list the files in ISO %s: %s", iso.getName(), result)); + } + return parser.getLines(); + } + + /** + * Looks for a file in the output of {@link #listFilesInIso(File)}. The comparison ignores the case and the + * ";1" version suffix, which are what an ISO without Rock Ridge names would give. + */ + protected static boolean isFileInIsoListing(String listing, String filePath) { + if (org.apache.commons.lang3.StringUtils.isAnyBlank(listing, filePath)) { + return false; + } + String wanted = org.apache.commons.lang3.StringUtils.strip(filePath.trim(), "/"); + for (String line : listing.split("\\R")) { + String entry = org.apache.commons.lang3.StringUtils.strip(line.trim().replaceFirst(";\\d+$", ""), "/"); + if (entry.equalsIgnoreCase(wanted)) { + return true; + } + } + return false; + } + private Answer execute(ListDataStoreObjectsCommand cmd) { return listFilesAtPath(getRootDir(cmd.getStore().getUrl(), _nfsVersion), cmd.getPath(), cmd.getStartIndex(), cmd.getPageSize()); } diff --git a/services/secondary-storage/server/src/test/java/org/apache/cloudstack/storage/resource/NfsSecondaryStorageResourceTest.java b/services/secondary-storage/server/src/test/java/org/apache/cloudstack/storage/resource/NfsSecondaryStorageResourceTest.java index 4ed6001d3b7e..01ba5d5af1fc 100644 --- a/services/secondary-storage/server/src/test/java/org/apache/cloudstack/storage/resource/NfsSecondaryStorageResourceTest.java +++ b/services/secondary-storage/server/src/test/java/org/apache/cloudstack/storage/resource/NfsSecondaryStorageResourceTest.java @@ -39,6 +39,8 @@ import com.cloud.agent.api.Answer; import com.cloud.agent.api.to.NfsTO; import org.apache.cloudstack.storage.command.BackupDeleteAnswer; +import org.apache.cloudstack.storage.command.CheckFileInIsoAnswer; +import org.apache.cloudstack.storage.command.CheckFileInIsoCommand; import org.apache.cloudstack.storage.command.DeleteCommand; import org.apache.cloudstack.storage.command.QuerySnapshotZoneCopyAnswer; import org.apache.cloudstack.storage.command.QuerySnapshotZoneCopyCommand; @@ -59,6 +61,7 @@ import com.cloud.agent.api.to.DataStoreTO; import com.cloud.exception.InvalidParameterValueException; import com.cloud.utils.EncryptionUtil; +import com.cloud.utils.exception.CloudRuntimeException; import com.cloud.utils.net.NetUtils; @RunWith(MockitoJUnitRunner.class) @@ -407,4 +410,93 @@ public void deleteScreenshotTestPathStartsWithSeparator() { verify(resource).deleteLocalFile("/root/" + "path/to/file"); } + + private static final String ETCD_ARCHIVE = "etcd/etcd-linux-amd64.tar.gz"; + + @Test + public void testIsFileInIsoListingFindsFile() { + String listing = "/docker\n/docker/etcd:3.5.21-0.tar\n/etcd\n/etcd/etcd-linux-amd64.tar.gz\n/k8s/kubeadm\n"; + assertTrue(NfsSecondaryStorageResource.isFileInIsoListing(listing, ETCD_ARCHIVE)); + assertTrue(NfsSecondaryStorageResource.isFileInIsoListing(listing, "/" + ETCD_ARCHIVE)); + } + + @Test + public void testIsFileInIsoListingFileMissing() { + // What an ISO built without ETCD_VERSION has: only the etcd image that kubeadm runs on control nodes + String listing = "/docker\n/docker/etcd:3.5.21-0.tar\n/k8s/kubeadm\n"; + assertFalse(NfsSecondaryStorageResource.isFileInIsoListing(listing, ETCD_ARCHIVE)); + assertFalse(NfsSecondaryStorageResource.isFileInIsoListing("", ETCD_ARCHIVE)); + assertFalse(NfsSecondaryStorageResource.isFileInIsoListing(null, ETCD_ARCHIVE)); + } + + @Test + public void testIsFileInIsoListingWithoutRockRidgeNames() { + String listing = "/ETCD\r\n/ETCD/ETCD-LINUX-AMD64.TAR.GZ;1\r\n"; + assertTrue(NfsSecondaryStorageResource.isFileInIsoListing(listing, ETCD_ARCHIVE)); + } + + private CheckFileInIsoCommand prepareCheckFileInIsoCommand(Path root) throws Exception { + Path isoDir = Files.createDirectories(root.resolve("template/tmpl/1/200")); + Files.createFile(isoDir.resolve("200-1-uuid.iso")); + NfsTO store = Mockito.mock(NfsTO.class); + Mockito.when(store.getUrl()).thenReturn("nfs://host/export"); + doReturn(root.toString()).when(resource).getRootDir(any(), any()); + return new CheckFileInIsoCommand(store, "template/tmpl/1/200/200-1-uuid.iso", ETCD_ARCHIVE); + } + + @Test + public void testExecuteCheckFileInIsoCommandFilePresent() throws Exception { + Path root = Files.createTempDirectory("checkiso"); + CheckFileInIsoCommand cmd = prepareCheckFileInIsoCommand(root); + doReturn("/etcd\n/etcd/etcd-linux-amd64.tar.gz\n").when(resource).listFilesInIso(any()); + + Answer answer = resource.execute(cmd); + + assertTrue(answer.getResult()); + assertTrue(((CheckFileInIsoAnswer)answer).isFilePresent()); + } + + @Test + public void testExecuteCheckFileInIsoCommandFileNotPresent() throws Exception { + Path root = Files.createTempDirectory("checkiso"); + CheckFileInIsoCommand cmd = prepareCheckFileInIsoCommand(root); + doReturn("/k8s\n/k8s/kubeadm\n").when(resource).listFilesInIso(any()); + + Answer answer = resource.execute(cmd); + + assertTrue(answer.getResult()); + assertFalse(((CheckFileInIsoAnswer)answer).isFilePresent()); + } + + @Test + public void testExecuteCheckFileInIsoCommandIsoCannotBeListed() throws Exception { + Path root = Files.createTempDirectory("checkiso"); + CheckFileInIsoCommand cmd = prepareCheckFileInIsoCommand(root); + doThrow(new CloudRuntimeException("isoinfo: command not found")).when(resource).listFilesInIso(any()); + + Answer answer = resource.execute(cmd); + + assertFalse(answer.getResult()); + assertFalse(((CheckFileInIsoAnswer)answer).isFilePresent()); + } + + @Test + public void testExecuteCheckFileInIsoCommandIsoMissing() throws Exception { + Path root = Files.createTempDirectory("checkiso"); + NfsTO store = Mockito.mock(NfsTO.class); + Mockito.when(store.getUrl()).thenReturn("nfs://host/export"); + doReturn(root.toString()).when(resource).getRootDir(any(), any()); + + Answer answer = resource.execute(new CheckFileInIsoCommand(store, "template/tmpl/1/200/missing.iso", ETCD_ARCHIVE)); + + assertFalse(answer.getResult()); + verify(resource, times(0)).listFilesInIso(any()); + } + + @Test + public void testExecuteCheckFileInIsoCommandNonNfsStore() { + Answer answer = resource.execute(new CheckFileInIsoCommand(Mockito.mock(DataStoreTO.class), "x.iso", ETCD_ARCHIVE)); + + assertFalse(answer.getResult()); + } } diff --git a/ui/public/locales/en.json b/ui/public/locales/en.json index 1c193e96d490..c9f3124f5d85 100644 --- a/ui/public/locales/en.json +++ b/ui/public/locales/en.json @@ -3945,6 +3945,7 @@ "message.ip.v6.prefix.delete": "IPv6 prefix deleted", "message.iso.arch": "Please select an ISO architecture", "message.iso.desc": "Disc image containing data or bootable media for OS.", +"message.kubernetes.version.etcd.not.included": "The ISO of the selected Kubernetes version does not include etcd, so a Cluster with dedicated etcd nodes cannot be created with it. Select another version or leave the etcd nodes empty.", "message.kubernetes.cluster.add.nodes": "Please confirm that you want to add the following nodes to the cluster", "message.kubernetes.cluster.delete": "Please confirm that you want to destroy the Cluster.", "message.kubeconfig.cluster.not.available": "Kubernetes Cluster kubeconfig not available currently.", diff --git a/ui/src/views/compute/CreateKubernetesCluster.vue b/ui/src/views/compute/CreateKubernetesCluster.vue index 618e46cb72d9..b820634f5a15 100644 --- a/ui/src/views/compute/CreateKubernetesCluster.vue +++ b/ui/src/views/compute/CreateKubernetesCluster.vue @@ -297,6 +297,12 @@ +