Light, fluffy, and always free - The AWS Local Emulator alternative
feat(eks): implement cluster addon management (#4038)
Simone Primarosa6a3380d13a11
diff --git a/docs/services/eks.md b/docs/services/eks.mdindex 1c7f290cb4..b73c1ac6a8 100644--- a/docs/services/eks.md+++ b/docs/services/eks.md@@ -22,6 +22,13 @@ EKS uses a standard REST API with JSON bodies: not the JSON 1.1 (`X-Amz-Target`)| `ListPodIdentityAssociations` | List pod identity associations in a cluster with optional filtering and pagination || `UpdatePodIdentityAssociation` | Update the IAM role, target role, or session tags for a pod identity association || `DeletePodIdentityAssociation` | Delete a pod identity association |+| `CreateAddon` | Create an addon for an EKS cluster |+| `DescribeAddon` | Describe an addon by cluster and addon name |+| `ListAddons` | List addon names installed in a cluster with pagination |+| `UpdateAddon` | Update addon configuration, version, or service account role |+| `DescribeUpdate` | Describe an update for an addon |+| `DeleteAddon` | Delete an addon from a cluster |+| `DescribeAddonVersions` | Describe supported addon versions by Kubernetes version or addon name || `CreateNodegroup` | Create node group metadata for a cluster || `DescribeNodegroup` | Describe a node group by cluster and name || `ListNodegroups` | List node group names for a cluster |@@ -92,6 +99,24 @@ Credentials delivery directly into pods is not yet supported:Applications running inside pods cannot currently exchange tokens for temporary AWS credentials via the link-local endpoint. Use access entries, node credentials, or explicit credential configuration until the pod identity agent endpoint is added.+## Addon management++Floci supports the EKS cluster addon management plane for AWS SDKs and Terraform (`aws_eks_addon` resource).++### Supported operations++- **Creation**: `CreateAddon` creates an addon on an ACTIVE cluster. Supported addons include `vpc-cni`, `coredns`, `kube-proxy`, and `eks-pod-identity-agent`. If `addonVersion` is omitted, the default version compatible with the cluster Kubernetes version is resolved automatically. Referenced `serviceAccountRoleArn` must exist in IAM. Idempotency is supported via `clientRequestToken`.+- **Retrieval**: `DescribeAddon` returns the complete addon resource shape, including ARN, cluster name, version, status (`ACTIVE`), health issues, tags, service account role ARN, configuration values, pod identity associations, owner, and publisher.+- **Listing**: `ListAddons` lists installed addon names with pagination (`maxResults` and `nextToken`).+- **Updating**: `UpdateAddon` updates the addon version, configuration values, service account role ARN, or resolve-conflicts strategy. It returns an `Update` tracking object and updates the addon metadata.+- **Update tracking**: `DescribeUpdate` describes the status of an addon update (such as an in-place addon version update queried by Terraform).+- **Deletion**: `DeleteAddon` marks the addon as `DELETING` and removes it from the cluster. Deleting a cluster automatically cleans up all associated addons.+- **Supported versions**: `DescribeAddonVersions` queries the addon version catalog with optional filtering by `addonName` and `kubernetesVersion`, supporting pagination.++### Metadata recording only++Addons in Floci are recorded metadata only. Creating or updating an addon does not install or reconcile Kubernetes DaemonSets, Deployments, or custom resources inside the cluster container.+## Cluster security groupWhen an EKS cluster is created with a VPC (either specified directly or resolved from subnets), Floci provisions a dedicated EC2 cluster security group and populates its ID in `cluster.resourcesVpcConfig.clusterSecurityGroupId` on both `CreateCluster` and `DescribeCluster` responses.diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/EksAddonCatalog.java b/src/main/java/io/github/hectorvent/floci/services/eks/EksAddonCatalog.javanew file mode 100644index 0000000000..b026ec5b13--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/eks/EksAddonCatalog.java@@ -0,0 +1,188 @@+package io.github.hectorvent.floci.services.eks;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.services.eks.model.AddonInfo;+import io.github.hectorvent.floci.services.eks.model.AddonVersionInfo;+import io.github.hectorvent.floci.services.eks.model.Compatibility;+import io.quarkus.runtime.annotations.RegisterForReflection;+import jakarta.enterprise.context.ApplicationScoped;+import org.jboss.logging.Logger;++import java.io.IOException;+import java.io.InputStream;+import java.util.List;+import java.util.Objects;+import java.util.Optional;++@ApplicationScoped+public class EksAddonCatalog {++ private static final Logger LOG = Logger.getLogger(EksAddonCatalog.class);+ private static final String CATALOG_RESOURCE_NAME = "eks/addon-versions.json";+ private static final ObjectMapper MAPPER = new ObjectMapper();++ private volatile List<AddonInfo> addons;++ public EksAddonCatalog() {+ // Loaded lazily on first access.+ }++ public EksAddonCatalog(List<AddonInfo> addons) {+ this.addons = addons != null ? List.copyOf(addons) : List.of();+ }++ @RegisterForReflection+ @JsonIgnoreProperties(ignoreUnknown = true)+ record CatalogWrapper(List<AddonInfo> addons) {}++ private List<AddonInfo> getAddons() {+ if (addons == null) {+ synchronized (this) {+ if (addons == null) {+ addons = loadCatalog();+ }+ }+ }+ return addons;+ }++ private List<AddonInfo> loadCatalog() {+ try (InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream(CATALOG_RESOURCE_NAME)) {+ if (is == null) {+ LOG.warnv("EKS addon versions catalog resource not found: {0}", CATALOG_RESOURCE_NAME);+ return List.of();+ }+ CatalogWrapper wrapper = MAPPER.readValue(is, CatalogWrapper.class);+ return wrapper.addons() != null ? List.copyOf(wrapper.addons()) : List.of();+ } catch (IOException e) {+ LOG.errorv(e, "Failed to load EKS addon versions catalog from {0}", CATALOG_RESOURCE_NAME);+ return List.of();+ }+ }++ public List<AddonInfo> allAddons() {+ return getAddons();+ }++ public Optional<AddonInfo> findAddon(String addonName) {+ if (addonName == null || addonName.isBlank()) {+ return Optional.empty();+ }+ String normalized = addonName.trim();+ return getAddons().stream()+ .filter(a -> a.addonName().equalsIgnoreCase(normalized))+ .findFirst();+ }++ public boolean isKnownAddon(String addonName) {+ return findAddon(addonName).isPresent();+ }++ public boolean isClusterVersionInCatalog(String kubernetesVersion) {+ if (kubernetesVersion == null || kubernetesVersion.isBlank()) {+ return false;+ }+ String k8s = normalizeK8sVersion(kubernetesVersion);+ return getAddons().stream()+ .flatMap(a -> a.addonVersions().stream())+ .filter(v -> v.compatibilities() != null)+ .flatMap(v -> v.compatibilities().stream())+ .anyMatch(c -> k8s.equals(c.clusterVersion()));+ }++ public boolean isVersionSupported(String addonName, String addonVersion) {+ return isVersionSupported(addonName, addonVersion, null);+ }++ public boolean isVersionSupported(String addonName, String addonVersion, String kubernetesVersion) {+ if (addonName == null || addonName.isBlank() || addonVersion == null || addonVersion.isBlank()) {+ return false;+ }+ String k8s = kubernetesVersion != null && isClusterVersionInCatalog(kubernetesVersion)+ ? normalizeK8sVersion(kubernetesVersion) : null;+ return findAddon(addonName)+ .map(AddonInfo::addonVersions)+ .orElse(List.of())+ .stream()+ .filter(v -> v.addonVersion().equalsIgnoreCase(addonVersion.trim()))+ .anyMatch(v -> k8s == null || isCompatible(v, k8s, false));+ }++ public Optional<String> resolveDefaultVersion(String addonName, String kubernetesVersion) {+ List<AddonVersionInfo> versions = findAddon(addonName)+ .map(AddonInfo::addonVersions)+ .orElse(List.of());+ if (versions.isEmpty()) {+ return Optional.empty();+ }++ String k8s = kubernetesVersion != null && !kubernetesVersion.isBlank()+ ? normalizeK8sVersion(kubernetesVersion) : null;+ if (k8s != null) {+ Optional<String> def = versions.stream()+ .filter(v -> isCompatible(v, k8s, true))+ .map(AddonVersionInfo::addonVersion)+ .findFirst();+ if (def.isPresent()) {+ return def;+ }+ Optional<String> any = versions.stream()+ .filter(v -> isCompatible(v, k8s, false))+ .map(AddonVersionInfo::addonVersion)+ .findFirst();+ if (any.isPresent()) {+ return any;+ }+ }++ return versions.stream()+ .filter(v -> isCompatible(v, null, true))+ .map(AddonVersionInfo::addonVersion)+ .findFirst()+ .or(() -> Optional.of(versions.getFirst().addonVersion()));+ }++ public List<AddonInfo> describeVersions(String addonName, String kubernetesVersion,+ List<String> publishers, List<String> types, List<String> owners) {+ String k8s = kubernetesVersion != null && !kubernetesVersion.isBlank()+ ? normalizeK8sVersion(kubernetesVersion) : null;+ return getAddons().stream()+ .filter(a -> addonName == null || addonName.isBlank() || a.addonName().equalsIgnoreCase(addonName.trim()))+ .filter(a -> publishers == null || publishers.isEmpty() || publishers.contains(a.publisher()))+ .filter(a -> types == null || types.isEmpty() || types.contains(a.type()))+ .filter(a -> owners == null || owners.isEmpty() || owners.contains(a.owner()))+ .map(a -> k8s == null ? a : filterByK8s(a, k8s))+ .filter(Objects::nonNull)+ .toList();+ }++ private static AddonInfo filterByK8s(AddonInfo addon, String k8s) {+ List<AddonVersionInfo> filtered = addon.addonVersions().stream()+ .filter(v -> isCompatible(v, k8s, false))+ .toList();+ return filtered.isEmpty() ? null+ : new AddonInfo(addon.addonName(), addon.type(), filtered, addon.publisher(), addon.owner());+ }++ private static boolean isCompatible(AddonVersionInfo versionInfo, String k8s, boolean defaultOnly) {+ if (versionInfo.compatibilities() == null) {+ return false;+ }+ return versionInfo.compatibilities().stream().anyMatch(c ->+ (!defaultOnly || Boolean.TRUE.equals(c.defaultVersion()))+ && (k8s == null || k8s.equals(c.clusterVersion())));+ }++ private static String normalizeK8sVersion(String version) {+ if (version == null) {+ return "";+ }+ String v = version.trim();+ if (v.startsWith("v")) {+ v = v.substring(1);+ }+ String[] parts = v.split("\\.");+ return parts.length >= 2 ? parts[0] + "." + parts[1] : v;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/EksAddonService.java b/src/main/java/io/github/hectorvent/floci/services/eks/EksAddonService.javanew file mode 100644index 0000000000..8b9e26d1db--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/eks/EksAddonService.java@@ -0,0 +1,528 @@+package io.github.hectorvent.floci.services.eks;++import com.fasterxml.jackson.core.JsonProcessingException;+import com.fasterxml.jackson.core.type.TypeReference;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.PaginatedResult;+import io.github.hectorvent.floci.core.common.Pagination;+import io.github.hectorvent.floci.core.storage.StorageBackend;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.eks.model.Addon;+import io.github.hectorvent.floci.services.eks.model.AddonHealth;+import io.github.hectorvent.floci.services.eks.model.AddonInfo;+import io.github.hectorvent.floci.services.eks.model.AddonPodIdentityAssociation;+import io.github.hectorvent.floci.services.eks.model.Cluster;+import io.github.hectorvent.floci.services.eks.model.ClusterStatus;+import io.github.hectorvent.floci.services.eks.model.CreateAddonRequest;+import io.github.hectorvent.floci.services.eks.model.CreatePodIdentityAssociationRequest;+import io.github.hectorvent.floci.services.eks.model.PodIdentityAssociation;+import io.github.hectorvent.floci.services.eks.model.Update;+import io.github.hectorvent.floci.services.eks.model.UpdateAddonRequest;+import io.github.hectorvent.floci.services.eks.model.UpdateParam;+import io.github.hectorvent.floci.services.iam.IamService;+import io.quarkus.runtime.annotations.RegisterForReflection;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;++import java.time.Instant;+import java.util.ArrayList;+import java.util.List;+import java.util.Locale;+import java.util.Map;+import java.util.Objects;+import java.util.Optional;+import java.util.UUID;+import java.util.function.Function;++@ApplicationScoped+public class EksAddonService {++ private static final Logger LOG = Logger.getLogger(EksAddonService.class);+ private static final ObjectMapper MAPPER = new ObjectMapper();+ private static final int DEFAULT_PAGE_SIZE = 100;+ private static final int MAX_PAGE_SIZE = 100;++ private final StorageBackend<String, StoredAddon> storage;+ private final StorageBackend<String, StoredUpdate> updatesStorage;+ private final EksAddonCatalog catalog;+ private final IamService iam;+ private final EksPodIdentityAssociationService podIdentityAssociations;++ @Inject+ public EksAddonService(StorageFactory storageFactory, EksAddonCatalog catalog,+ IamService iam, EksPodIdentityAssociationService podIdentityAssociations) {+ this(storageFactory.create("eks", "eks-addons.json",+ new TypeReference<Map<String, StoredAddon>>() {}),+ storageFactory.create("eks", "eks-updates.json",+ new TypeReference<Map<String, StoredUpdate>>() {}),+ catalog, iam, podIdentityAssociations);+ }++ EksAddonService(StorageBackend<String, StoredAddon> storage,+ StorageBackend<String, StoredUpdate> updatesStorage,+ EksAddonCatalog catalog,+ IamService iam,+ EksPodIdentityAssociationService podIdentityAssociations) {+ this.storage = storage;+ this.updatesStorage = updatesStorage;+ this.catalog = catalog;+ this.iam = iam;+ this.podIdentityAssociations = podIdentityAssociations;+ }++ @RegisterForReflection+ public record StoredAddon(Addon addon, String clientRequestToken) {}++ @RegisterForReflection+ public record StoredUpdate(Update update, String addonName) {}++ @RegisterForReflection+ public record AddonNamesPage(List<String> addons, String nextToken) {}++ @RegisterForReflection+ public record AddonVersionsPage(List<AddonInfo> addons, String nextToken) {}++ public synchronized Addon create(Cluster cluster, CreateAddonRequest request) {+ requireActiveCluster(cluster);+ if (request == null || request.addonName() == null || request.addonName().isBlank()) {+ throw new AwsException("InvalidParameterException", "addonName is required", 400);+ }++ String addonName = request.addonName().trim();+ if (!catalog.isKnownAddon(addonName)) {+ throw new AwsException("InvalidParameterException",+ "Addon name '" + addonName + "' is not valid", 400);+ }++ String storageKey = prefix(cluster) + addonName.toLowerCase(Locale.ROOT);+ Optional<StoredAddon> existing = storage.get(storageKey);+ if (existing.isPresent()) {+ StoredAddon stored = existing.get();+ if (request.clientRequestToken() != null && !request.clientRequestToken().isBlank()+ && request.clientRequestToken().equals(stored.clientRequestToken())) {+ if (parametersMatch(stored.addon(), request)) {+ return stored.addon();+ }+ throw new AwsException("InvalidParameterException",+ "clientRequestToken was already used with different parameters", 400);+ }+ throw new AwsException("ResourceInUseException", "Addon already exists: " + addonName, 409);+ }++ String version = (request.addonVersion() != null && !request.addonVersion().isBlank())+ ? request.addonVersion().trim()+ : catalog.resolveDefaultVersion(addonName, cluster.getVersion()).orElse(null);+ if (version == null || !catalog.isVersionSupported(addonName, version, cluster.getVersion())) {+ throw new AwsException("InvalidParameterException",+ "Addon version specified is not supported", 400);+ }++ if (request.serviceAccountRoleArn() != null && !request.serviceAccountRoleArn().isBlank()) {+ validateRoleArn(cluster, request.serviceAccountRoleArn(), "serviceAccountRoleArn");+ }++ if (request.resolveConflicts() != null && !request.resolveConflicts().isBlank()) {+ validateResolveConflicts(request.resolveConflicts());+ }++ Map<String, String> tags = request.tags() != null ? request.tags() : Map.of();+ validateTags(tags);++ List<String> associationArns = createOrLinkPodIdentityAssociations(cluster, addonName, request.podIdentityAssociations());++ double now = Instant.now().toEpochMilli() / 1000.0;+ String addonArn = generateAddonArn(cluster, addonName);+ Optional<AddonInfo> addonInfo = catalog.findAddon(addonName);+ String owner = addonInfo.map(AddonInfo::owner).orElse("aws");+ String publisher = addonInfo.map(AddonInfo::publisher).orElse("eks");++ Addon addon = new Addon(+ addonArn,+ addonName,+ version,+ cluster.getName(),+ "ACTIVE",+ new AddonHealth(List.of()),+ now,+ now,+ request.serviceAccountRoleArn(),+ request.configurationValues(),+ Map.copyOf(tags),+ List.copyOf(associationArns),+ owner,+ publisher+ );++ storage.put(storageKey, new StoredAddon(addon, request.clientRequestToken()));+ LOG.infov("Created EKS addon {0} on cluster {1} with version {2}", addonName, cluster.getName(), version);+ return addon;+ }++ public Addon describe(Cluster cluster, String addonName) {+ requireActiveCluster(cluster);+ if (addonName == null || addonName.isBlank()) {+ throw new AwsException("InvalidParameterException", "addonName is required", 400);+ }++ String storageKey = prefix(cluster) + addonName.trim().toLowerCase(Locale.ROOT);+ StoredAddon stored = storage.get(storageKey)+ .orElseThrow(() -> new AwsException("ResourceNotFoundException",+ "No addon: " + addonName + " found for cluster: " + cluster.getName(), 404));+ return stored.addon();+ }++ public AddonNamesPage list(Cluster cluster, Integer maxResults, String nextToken) {+ requireActiveCluster(cluster);+ String p = prefix(cluster);+ List<String> addonNames = storage.scan(key -> key.startsWith(p)).stream()+ .map(stored -> stored.addon().addonName())+ .sorted()+ .toList();++ PaginatedResult<String> result = Pagination.paginate(+ addonNames,+ Function.identity(),+ maxResults,+ nextToken,+ DEFAULT_PAGE_SIZE,+ MAX_PAGE_SIZE,+ "InvalidParameterException"+ );+ return new AddonNamesPage(result.items(), result.nextToken());+ }++ public synchronized Update update(Cluster cluster, String addonName, UpdateAddonRequest request) {+ requireActiveCluster(cluster);+ if (addonName == null || addonName.isBlank()) {+ throw new AwsException("InvalidParameterException", "addonName is required", 400);+ }++ String storageKey = prefix(cluster) + addonName.trim().toLowerCase(Locale.ROOT);+ StoredAddon stored = storage.get(storageKey)+ .orElseThrow(() -> new AwsException("ResourceNotFoundException",+ "No addon: " + addonName + " found for cluster: " + cluster.getName(), 404));++ Addon current = stored.addon();+ String newVersion = current.addonVersion();+ List<UpdateParam> params = new ArrayList<>();++ if (request != null) {+ if (request.addonVersion() != null && !request.addonVersion().isBlank()) {+ String requestedVersion = request.addonVersion().trim();+ if (!catalog.isVersionSupported(addonName, requestedVersion, cluster.getVersion())) {+ throw new AwsException("InvalidParameterException",+ "Addon version specified is not supported", 400);+ }+ newVersion = requestedVersion;+ params.add(new UpdateParam("Version", newVersion));+ }++ if (request.serviceAccountRoleArn() != null) {+ if (!request.serviceAccountRoleArn().isBlank()) {+ validateRoleArn(cluster, request.serviceAccountRoleArn(), "serviceAccountRoleArn");+ }+ params.add(new UpdateParam("ServiceAccountRoleArn", request.serviceAccountRoleArn()));+ }++ if (request.resolveConflicts() != null && !request.resolveConflicts().isBlank()) {+ validateResolveConflicts(request.resolveConflicts());+ params.add(new UpdateParam("ResolveConflicts", request.resolveConflicts()));+ }++ if (request.configurationValues() != null) {+ params.add(new UpdateParam("ConfigurationValues", request.configurationValues()));+ }+ }++ String updatedRoleArn = request != null && request.serviceAccountRoleArn() != null+ ? (request.serviceAccountRoleArn().isBlank() ? null : request.serviceAccountRoleArn())+ : current.serviceAccountRoleArn();+ String updatedConfig = request != null && request.configurationValues() != null+ ? request.configurationValues()+ : current.configurationValues();++ List<String> updatedAssociations = current.podIdentityAssociations();+ if (request != null && request.podIdentityAssociations() != null) {+ validatePodIdentityAssociations(cluster, request.podIdentityAssociations());+ if (podIdentityAssociations != null && current.podIdentityAssociations() != null) {+ for (String arn : current.podIdentityAssociations()) {+ deleteAssociationSilently(cluster, arn);+ }+ }+ updatedAssociations = createOrLinkPodIdentityAssociations(cluster, addonName, request.podIdentityAssociations());+ params.add(new UpdateParam("PodIdentityAssociations", serializeAssociations(request.podIdentityAssociations())));+ }++ double now = Instant.now().toEpochMilli() / 1000.0;+ Addon updatedAddon = new Addon(+ current.addonArn(),+ current.addonName(),+ newVersion,+ current.clusterName(),+ "ACTIVE",+ current.health(),+ current.createdAt(),+ now,+ updatedRoleArn,+ updatedConfig,+ current.tags(),+ updatedAssociations,+ current.owner(),+ current.publisher()+ );++ String token = request != null && request.clientRequestToken() != null+ ? request.clientRequestToken() : stored.clientRequestToken();+ storage.put(storageKey, new StoredAddon(updatedAddon, token));+ LOG.infov("Updated EKS addon {0} on cluster {1}", addonName, cluster.getName());++ Update update = new Update(+ UUID.randomUUID().toString(),+ "Successful",+ "AddonUpdate",+ params,+ now,+ List.of()+ );+ updatesStorage.put(prefix(cluster) + update.id(), new StoredUpdate(update, addonName));+ return update;+ }++ public synchronized Addon delete(Cluster cluster, String addonName, boolean preserve) {+ requireActiveCluster(cluster);+ if (addonName == null || addonName.isBlank()) {+ throw new AwsException("InvalidParameterException", "addonName is required", 400);+ }++ String storageKey = prefix(cluster) + addonName.trim().toLowerCase(Locale.ROOT);+ StoredAddon stored = storage.get(storageKey)+ .orElseThrow(() -> new AwsException("ResourceNotFoundException",+ "No addon: " + addonName + " found for cluster: " + cluster.getName(), 404));++ storage.delete(storageKey);+ if (preserve) {+ LOG.infov("Deleted EKS addon {0} on cluster {1} (preserve=true)", addonName, cluster.getName());+ } else {+ if (podIdentityAssociations != null && stored.addon().podIdentityAssociations() != null) {+ for (String arn : stored.addon().podIdentityAssociations()) {+ deleteAssociationSilently(cluster, arn);+ }+ }+ LOG.infov("Deleted EKS addon {0} on cluster {1} (preserve=false)", addonName, cluster.getName());+ }++ Addon current = stored.addon();+ return new Addon(+ current.addonArn(),+ current.addonName(),+ current.addonVersion(),+ current.clusterName(),+ "DELETING",+ current.health(),+ current.createdAt(),+ Instant.now().toEpochMilli() / 1000.0,+ current.serviceAccountRoleArn(),+ current.configurationValues(),+ current.tags(),+ current.podIdentityAssociations(),+ current.owner(),+ current.publisher()+ );+ }++ public synchronized void deleteClusterAddons(Cluster cluster) {+ if (cluster != null) {+ String p = prefix(cluster);+ storage.keys().stream().filter(k -> k.startsWith(p)).toList().forEach(storage::delete);+ updatesStorage.keys().stream().filter(k -> k.startsWith(p)).toList().forEach(updatesStorage::delete);+ LOG.infov("Purged all addons and updates for cluster {0}", cluster.getName());+ }+ }++ public Update describeUpdate(Cluster cluster, String updateId, String addonName) {+ requireActiveCluster(cluster);+ if (updateId == null || updateId.isBlank()) {+ throw new AwsException("InvalidParameterException", "updateId is required", 400);+ }+ StoredUpdate stored = updatesStorage.get(prefix(cluster) + updateId)+ .orElseThrow(() -> new AwsException("ResourceNotFoundException",+ "No update: " + updateId + " found for cluster: " + cluster.getName(), 404));+ if (addonName != null && !addonName.isBlank()+ && stored.addonName() != null && !stored.addonName().equalsIgnoreCase(addonName.trim())) {+ throw new AwsException("ResourceNotFoundException",+ "No update: " + updateId + " found for addon: " + addonName, 404);+ }+ return stored.update();+ }++ public AddonVersionsPage describeAddonVersions(String addonName, String kubernetesVersion,+ Integer maxResults, String nextToken,+ List<String> publishers, List<String> types, List<String> owners) {+ List<AddonInfo> filtered = catalog.describeVersions(addonName, kubernetesVersion, publishers, types, owners);+ PaginatedResult<AddonInfo> result = Pagination.paginate(+ filtered,+ AddonInfo::addonName,+ maxResults,+ nextToken,+ DEFAULT_PAGE_SIZE,+ MAX_PAGE_SIZE,+ "InvalidParameterException"+ );+ return new AddonVersionsPage(result.items(), result.nextToken());+ }++ private void validatePodIdentityAssociations(Cluster cluster, List<AddonPodIdentityAssociation> associations) {+ if (associations == null || associations.isEmpty()) {+ return;+ }+ for (AddonPodIdentityAssociation assoc : associations) {+ if (assoc.roleArn() == null || assoc.roleArn().isBlank()+ || assoc.serviceAccount() == null || assoc.serviceAccount().isBlank()) {+ throw new AwsException("InvalidParameterException",+ "roleArn and serviceAccount are required for podIdentityAssociations", 400);+ }+ validateRoleArn(cluster, assoc.roleArn(), "roleArn");+ }+ }++ private static String serializeAssociations(List<AddonPodIdentityAssociation> associations) {+ if (associations == null) {+ return "[]";+ }+ try {+ return MAPPER.writeValueAsString(associations);+ } catch (JsonProcessingException e) {+ return "[]";+ }+ }++ private List<String> createOrLinkPodIdentityAssociations(Cluster cluster,+ String addonName,+ List<AddonPodIdentityAssociation> associations) {+ if (associations == null || associations.isEmpty()) {+ return List.of();+ }+ validatePodIdentityAssociations(cluster, associations);+ List<String> arns = new ArrayList<>();+ String namespace = resolveAddonNamespace(addonName);+ for (AddonPodIdentityAssociation assoc : associations) {+ if (podIdentityAssociations != null) {+ CreatePodIdentityAssociationRequest req = new CreatePodIdentityAssociationRequest(+ cluster.getName(),+ namespace,+ assoc.serviceAccount(),+ assoc.roleArn(),+ null,+ Map.of(),+ null,+ null,+ null+ );+ PodIdentityAssociation created = podIdentityAssociations.create(cluster, req);+ arns.add(created.associationArn());+ } else {+ String[] clusterArn = cluster.getArn().split(":", 6);+ String assocId = "a-" + UUID.randomUUID().toString().replace("-", "").substring(0, 17);+ String arn = "arn:" + clusterArn[1] + ":eks:" + clusterArn[3] + ":"+ + clusterArn[4] + ":podidentityassociation/" + cluster.getName() + "/" + assocId;+ arns.add(arn);+ }+ }+ return arns;+ }++ private void deleteAssociationSilently(Cluster cluster, String associationArn) {+ if (associationArn == null || associationArn.isBlank() || podIdentityAssociations == null) {+ return;+ }+ String associationId = associationArn.substring(associationArn.lastIndexOf('/') + 1);+ try {+ podIdentityAssociations.delete(cluster, associationId);+ } catch (AwsException e) {+ LOG.debugf("Ignored error deleting pod identity association %s: %s", associationId, e.getMessage());+ }+ }++ private static String resolveAddonNamespace(String addonName) {+ return "kube-system";+ }++ private static String prefix(Cluster cluster) {+ return cluster.getArn() + "/" + Objects.toString(cluster.getCreatedAt()) + "/";+ }++ private static String generateAddonArn(Cluster cluster, String addonName) {+ String[] clusterArn = cluster.getArn().split(":", 6);+ return "arn:" + clusterArn[1] + ":eks:" + clusterArn[3] + ":"+ + clusterArn[4] + ":addon/" + cluster.getName() + "/" + addonName + "/" + UUID.randomUUID();+ }++ private static void requireActiveCluster(Cluster cluster) {+ if (cluster == null) {+ throw new AwsException("ResourceNotFoundException", "Cluster not found", 404);+ }+ if (cluster.getStatus() != ClusterStatus.ACTIVE) {+ throw new AwsException("InvalidRequestException",+ "Cluster must be ACTIVE, but was " + cluster.getStatus(), 400);+ }+ }++ private void validateRoleArn(Cluster cluster, String roleArn, String fieldName) {+ if (roleArn == null || roleArn.isBlank()) {+ throw new AwsException("InvalidParameterException", fieldName + " is required", 400);+ }+ String[] arn = roleArn.split(":", 6);+ String[] clusterArn = cluster.getArn().split(":", 6);+ if (arn.length != 6 || !"arn".equals(arn[0]) || !arn[1].equals(clusterArn[1])+ || !"iam".equals(arn[2]) || !arn[3].isEmpty() || !arn[4].matches("[0-9]{12}")+ || !arn[5].startsWith("role/") || arn[5].startsWith("role/aws-service-role/")+ || roleArn.endsWith("/")) {+ throw new AwsException("InvalidParameterException", fieldName + " must identify an IAM role", 400);+ }+ if (iam != null) {+ String roleName = roleArn.substring(roleArn.lastIndexOf('/') + 1);+ iam.findRole(arn[4], roleName)+ .filter(role -> roleArn.equals(role.getArn()))+ .orElseThrow(() -> new AwsException("InvalidParameterException", "Role not found: " + roleArn, 400));+ }+ }++ private static void validateResolveConflicts(String resolveConflicts) {+ String upper = resolveConflicts.toUpperCase(Locale.ROOT);+ if (!"OVERWRITE".equals(upper) && !"NONE".equals(upper) && !"PRESERVE".equals(upper)) {+ throw new AwsException("InvalidParameterException",+ "Unsupported resolveConflicts value: " + resolveConflicts, 400);+ }+ }++ private static void validateTags(Map<String, String> tags) {+ if (tags == null) {+ return;+ }+ if (tags.size() > 50) {+ throw new AwsException("InvalidParameterException", "Too many tags: maximum is 50", 400);+ }+ for (Map.Entry<String, String> entry : tags.entrySet()) {+ String key = entry.getKey();+ String value = entry.getValue();+ if (key == null || key.isBlank() || key.length() > 128) {+ throw new AwsException("InvalidParameterException", "Invalid tag key: " + key, 400);+ }+ if (value == null || value.length() > 256) {+ throw new AwsException("InvalidParameterException", "Invalid tag value: " + value, 400);+ }+ }+ }++ private static boolean parametersMatch(Addon existing, CreateAddonRequest request) {+ Map<String, String> existingTags = existing.tags() != null ? existing.tags() : Map.of();+ Map<String, String> requestTags = request.tags() != null ? request.tags() : Map.of();+ return Objects.equals(existing.serviceAccountRoleArn(), request.serviceAccountRoleArn())+ && Objects.equals(existing.configurationValues(), request.configurationValues())+ && (request.addonVersion() == null || request.addonVersion().isBlank()+ || Objects.equals(existing.addonVersion(), request.addonVersion()))+ && Objects.equals(existingTags, requestTags);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/EksController.java b/src/main/java/io/github/hectorvent/floci/services/eks/EksController.javaindex 4015ccdfee..70a4329cb6 100644--- a/src/main/java/io/github/hectorvent/floci/services/eks/EksController.java+++ b/src/main/java/io/github/hectorvent/floci/services/eks/EksController.java@@ -1,8 +1,10 @@package io.github.hectorvent.floci.services.eks;import io.github.hectorvent.floci.core.common.Pagination;+import io.github.hectorvent.floci.services.eks.model.Addon;import io.github.hectorvent.floci.services.eks.model.Cluster;import io.github.hectorvent.floci.services.eks.model.CreateAccessEntryRequest;+import io.github.hectorvent.floci.services.eks.model.CreateAddonRequest;import io.github.hectorvent.floci.services.eks.model.CreateClusterRequest;import io.github.hectorvent.floci.services.eks.model.CreateFargateProfileRequest;import io.github.hectorvent.floci.services.eks.model.CreateNodeGroupRequest;@@ -10,6 +12,8 @@ import io.github.hectorvent.floci.services.eks.model.CreatePodIdentityAssociatioimport io.github.hectorvent.floci.services.eks.model.FargateProfile;import io.github.hectorvent.floci.services.eks.model.Nodegroup;import io.github.hectorvent.floci.services.eks.model.PodIdentityAssociation;+import io.github.hectorvent.floci.services.eks.model.Update;+import io.github.hectorvent.floci.services.eks.model.UpdateAddonRequest;import io.github.hectorvent.floci.services.eks.model.UpdatePodIdentityAssociationRequest;import jakarta.inject.Inject;import jakarta.ws.rs.Consumes;@@ -41,13 +45,16 @@ public class EksController {private final EksService eksService;private final EksAccessEntryService accessEntries;private final EksPodIdentityAssociationService podIdentityAssociations;+ private final EksAddonService addons;@Injectpublic EksController(EksService eksService, EksAccessEntryService accessEntries,- EksPodIdentityAssociationService podIdentityAssociations) {+ EksPodIdentityAssociationService podIdentityAssociations,+ EksAddonService addons) {this.eksService = eksService;this.accessEntries = accessEntries;this.podIdentityAssociations = podIdentityAssociations;+ this.addons = addons;}@POST@@ -175,11 +182,88 @@ public class EksController {return Response.ok(Map.of()).build();}+ @POST+ @Path("/clusters/{name}/addons")+ public Response createAddon(@PathParam("name") String name, CreateAddonRequest request) {+ Cluster cluster = eksService.describeCluster(name);+ Addon addon = addons.create(cluster, request);+ return Response.ok(Map.of("addon", addon)).build();+ }+@GET@Path("/clusters/{name}/addons")- public Response listAddons(@PathParam("name") String name) {- eksService.describeCluster(name);- return Response.ok(Map.of("addons", List.of())).build();+ public Response listAddons(@PathParam("name") String name,+ @QueryParam("maxResults") String maxResults,+ @QueryParam("nextToken") String nextToken) {+ Cluster cluster = eksService.describeCluster(name);+ EksAddonService.AddonNamesPage page = addons.list(cluster,+ Pagination.parseMaxResults(maxResults, "InvalidParameterException"), nextToken);+ return Response.ok(page.nextToken() == null+ ? Map.of("addons", page.addons())+ : Map.of("addons", page.addons(), "nextToken", page.nextToken())).build();+ }++ @GET+ @Path("/clusters/{name}/addons/{addonName}")+ public Response describeAddon(@PathParam("name") String name,+ @PathParam("addonName") String addonName) {+ Cluster cluster = eksService.describeCluster(name);+ Addon addon = addons.describe(cluster, addonName);+ return Response.ok(Map.of("addon", addon)).build();+ }++ @POST+ @Path("/clusters/{name}/addons/{addonName}/update")+ public Response updateAddon(@PathParam("name") String name,+ @PathParam("addonName") String addonName,+ UpdateAddonRequest request) {+ Cluster cluster = eksService.describeCluster(name);+ Update update = addons.update(cluster, addonName, request);+ return Response.ok(Map.of("update", update)).build();+ }++ @GET+ @Path("/clusters/{name}/updates/{updateId}")+ public Response describeUpdate(@PathParam("name") String name,+ @PathParam("updateId") String updateId,+ @QueryParam("addonName") String addonName,+ @QueryParam("nodegroupName") String nodegroupName) {+ Cluster cluster = eksService.describeCluster(name);+ Update update = addons.describeUpdate(cluster, updateId, addonName);+ return Response.ok(Map.of("update", update)).build();+ }++ @DELETE+ @Path("/clusters/{name}/addons/{addonName}")+ public Response deleteAddon(@PathParam("name") String name,+ @PathParam("addonName") String addonName,+ @QueryParam("preserve") Boolean preserve) {+ Cluster cluster = eksService.describeCluster(name);+ Addon addon = addons.delete(cluster, addonName, Boolean.TRUE.equals(preserve));+ return Response.ok(Map.of("addon", addon)).build();+ }++ @GET+ @Path("/addons/supported-versions")+ public Response describeAddonVersions(@QueryParam("addonName") String addonName,+ @QueryParam("kubernetesVersion") String kubernetesVersion,+ @QueryParam("maxResults") String maxResults,+ @QueryParam("nextToken") String nextToken,+ @QueryParam("publishers") List<String> publishers,+ @QueryParam("types") List<String> types,+ @QueryParam("owners") List<String> owners) {+ EksAddonService.AddonVersionsPage page = addons.describeAddonVersions(+ addonName,+ kubernetesVersion,+ Pagination.parseMaxResults(maxResults, "InvalidParameterException"),+ nextToken,+ publishers,+ types,+ owners+ );+ return Response.ok(page.nextToken() == null+ ? Map.of("addons", page.addons())+ : Map.of("addons", page.addons(), "nextToken", page.nextToken())).build();}@GETdiff --git a/src/main/java/io/github/hectorvent/floci/services/eks/EksService.java b/src/main/java/io/github/hectorvent/floci/services/eks/EksService.javaindex 890cc8f92f..63838ed975 100644--- a/src/main/java/io/github/hectorvent/floci/services/eks/EksService.java+++ b/src/main/java/io/github/hectorvent/floci/services/eks/EksService.java@@ -93,13 +93,15 @@ public class EksService implements TagHandler, ResourceProvider {private final EksOidcService oidcService;private final EksAccessEntryService accessEntries;private final EksPodIdentityAssociationService podIdentityAssociations;+ private final EksAddonService addons;private final ScheduledExecutorService poller = Executors.newSingleThreadScheduledExecutor();@Injectpublic EksService(StorageFactory storageFactory, EmulatorConfig config,RegionResolver regionResolver, EksClusterManager clusterManager, Ec2Service ec2Service,EksOidcService oidcService, EksAccessEntryService accessEntries,- EksPodIdentityAssociationService podIdentityAssociations) {+ EksPodIdentityAssociationService podIdentityAssociations,+ EksAddonService addons) {this.storage = storageFactory.create("eks", "eks-clusters.json",new TypeReference<Map<String, Cluster>>() {});@@ -116,13 +118,22 @@ public class EksService implements TagHandler, ResourceProvider {this.oidcService = oidcService;this.accessEntries = accessEntries;this.podIdentityAssociations = podIdentityAssociations;+ this.addons = addons;+ }++ public EksService(StorageFactory storageFactory, EmulatorConfig config,+ RegionResolver regionResolver, EksClusterManager clusterManager, Ec2Service ec2Service,+ EksOidcService oidcService, EksAccessEntryService accessEntries,+ EksPodIdentityAssociationService podIdentityAssociations) {+ this(storageFactory, config, regionResolver, clusterManager, ec2Service,+ oidcService, accessEntries, podIdentityAssociations, null);}public EksService(StorageFactory storageFactory, EmulatorConfig config,RegionResolver regionResolver, EksClusterManager clusterManager, Ec2Service ec2Service,EksOidcService oidcService, EksAccessEntryService accessEntries) {this(storageFactory, config, regionResolver, clusterManager, ec2Service,- oidcService, accessEntries, null);+ oidcService, accessEntries, null, null);}@PostConstruct@@ -564,6 +575,9 @@ public class EksService implements TagHandler, ResourceProvider {if (podIdentityAssociations != null) {podIdentityAssociations.deleteClusterAssociations(cluster);}+ if (addons != null) {+ addons.deleteClusterAddons(cluster);+ }storage.delete(name);oidcService.deleteKey(name);return cluster;diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/model/Addon.java b/src/main/java/io/github/hectorvent/floci/services/eks/model/Addon.javanew file mode 100644index 0000000000..f286778b71--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/eks/model/Addon.java@@ -0,0 +1,28 @@+package io.github.hectorvent.floci.services.eks.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import com.fasterxml.jackson.annotation.JsonInclude;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.List;+import java.util.Map;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+@JsonInclude(JsonInclude.Include.NON_NULL)+public record Addon(+ String addonArn,+ String addonName,+ String addonVersion,+ String clusterName,+ String status,+ AddonHealth health,+ double createdAt,+ double modifiedAt,+ String serviceAccountRoleArn,+ String configurationValues,+ Map<String, String> tags,+ List<String> podIdentityAssociations,+ String owner,+ String publisher+) {}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/model/AddonHealth.java b/src/main/java/io/github/hectorvent/floci/services/eks/model/AddonHealth.javanew file mode 100644index 0000000000..63d5cf72e6--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/eks/model/AddonHealth.java@@ -0,0 +1,14 @@+package io.github.hectorvent.floci.services.eks.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import com.fasterxml.jackson.annotation.JsonInclude;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.List;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+@JsonInclude(JsonInclude.Include.NON_NULL)+public record AddonHealth(+ List<AddonIssue> issues+) {}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/model/AddonInfo.java b/src/main/java/io/github/hectorvent/floci/services/eks/model/AddonInfo.javanew file mode 100644index 0000000000..13d3abb6dd--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/eks/model/AddonInfo.java@@ -0,0 +1,18 @@+package io.github.hectorvent.floci.services.eks.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import com.fasterxml.jackson.annotation.JsonInclude;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.List;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+@JsonInclude(JsonInclude.Include.NON_NULL)+public record AddonInfo(+ String addonName,+ String type,+ List<AddonVersionInfo> addonVersions,+ String publisher,+ String owner+) {}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/model/AddonIssue.java b/src/main/java/io/github/hectorvent/floci/services/eks/model/AddonIssue.javanew file mode 100644index 0000000000..142ec047d6--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/eks/model/AddonIssue.java@@ -0,0 +1,16 @@+package io.github.hectorvent.floci.services.eks.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import com.fasterxml.jackson.annotation.JsonInclude;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.List;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+@JsonInclude(JsonInclude.Include.NON_NULL)+public record AddonIssue(+ String code,+ String message,+ List<String> resourceIds+) {}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/model/AddonPodIdentityAssociation.java b/src/main/java/io/github/hectorvent/floci/services/eks/model/AddonPodIdentityAssociation.javanew file mode 100644index 0000000000..3cbbde1d68--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/eks/model/AddonPodIdentityAssociation.java@@ -0,0 +1,13 @@+package io.github.hectorvent.floci.services.eks.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import com.fasterxml.jackson.annotation.JsonInclude;+import io.quarkus.runtime.annotations.RegisterForReflection;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+@JsonInclude(JsonInclude.Include.NON_NULL)+public record AddonPodIdentityAssociation(+ String roleArn,+ String serviceAccount+) {}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/model/AddonVersionInfo.java b/src/main/java/io/github/hectorvent/floci/services/eks/model/AddonVersionInfo.javanew file mode 100644index 0000000000..cc69709199--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/eks/model/AddonVersionInfo.java@@ -0,0 +1,18 @@+package io.github.hectorvent.floci.services.eks.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import com.fasterxml.jackson.annotation.JsonInclude;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.List;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+@JsonInclude(JsonInclude.Include.NON_NULL)+public record AddonVersionInfo(+ String addonVersion,+ List<String> architecture,+ List<Compatibility> compatibilities,+ Boolean requiresConfiguration,+ Boolean requiresIamPermissions+) {}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/model/Compatibility.java b/src/main/java/io/github/hectorvent/floci/services/eks/model/Compatibility.javanew file mode 100644index 0000000000..b242c004a3--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/eks/model/Compatibility.java@@ -0,0 +1,16 @@+package io.github.hectorvent.floci.services.eks.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import com.fasterxml.jackson.annotation.JsonInclude;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.List;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+@JsonInclude(JsonInclude.Include.NON_NULL)+public record Compatibility(+ String clusterVersion,+ List<String> platformVersions,+ Boolean defaultVersion+) {}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/model/CreateAddonRequest.java b/src/main/java/io/github/hectorvent/floci/services/eks/model/CreateAddonRequest.javanew file mode 100644index 0000000000..683a6616f4--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/eks/model/CreateAddonRequest.java@@ -0,0 +1,20 @@+package io.github.hectorvent.floci.services.eks.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.List;+import java.util.Map;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public record CreateAddonRequest(+ String addonName,+ String addonVersion,+ String serviceAccountRoleArn,+ String resolveConflicts,+ String clientRequestToken,+ String configurationValues,+ Map<String, String> tags,+ List<AddonPodIdentityAssociation> podIdentityAssociations+) {}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/model/ErrorDetail.java b/src/main/java/io/github/hectorvent/floci/services/eks/model/ErrorDetail.javanew file mode 100644index 0000000000..4fc2cb8428--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/eks/model/ErrorDetail.java@@ -0,0 +1,14 @@+package io.github.hectorvent.floci.services.eks.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.List;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public record ErrorDetail(+ String errorCode,+ String errorMessage,+ List<String> resourceIds+) {}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/model/Update.java b/src/main/java/io/github/hectorvent/floci/services/eks/model/Update.javanew file mode 100644index 0000000000..860f6e6c30--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/eks/model/Update.java@@ -0,0 +1,19 @@+package io.github.hectorvent.floci.services.eks.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import com.fasterxml.jackson.annotation.JsonInclude;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.List;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+@JsonInclude(JsonInclude.Include.NON_NULL)+public record Update(+ String id,+ String status,+ String type,+ List<UpdateParam> params,+ double createdAt,+ List<ErrorDetail> errors+) {}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/model/UpdateAddonRequest.java b/src/main/java/io/github/hectorvent/floci/services/eks/model/UpdateAddonRequest.javanew file mode 100644index 0000000000..ce86a63b14--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/eks/model/UpdateAddonRequest.java@@ -0,0 +1,17 @@+package io.github.hectorvent.floci.services.eks.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.List;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public record UpdateAddonRequest(+ String addonVersion,+ String serviceAccountRoleArn,+ String resolveConflicts,+ String clientRequestToken,+ String configurationValues,+ List<AddonPodIdentityAssociation> podIdentityAssociations+) {}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/model/UpdateParam.java b/src/main/java/io/github/hectorvent/floci/services/eks/model/UpdateParam.javanew file mode 100644index 0000000000..919b789de6--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/eks/model/UpdateParam.java@@ -0,0 +1,11 @@+package io.github.hectorvent.floci.services.eks.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public record UpdateParam(+ String type,+ String value+) {}diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex 16ab62d24e..736b909aff 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -57,6 +57,7 @@ quarkus:- ui/*.html- ec2/*.yaml- sagemaker/*.yaml+ - eks/*.json- i18n/*.properties- org/apache/velocity/runtime/defaults/*.properties# DriverManager finds the JDBC drivers through ServiceLoader, and the MySQLdiff --git a/src/main/resources/eks/addon-versions.json b/src/main/resources/eks/addon-versions.jsonnew file mode 100644index 0000000000..a22b850301--- /dev/null+++ b/src/main/resources/eks/addon-versions.json@@ -0,0 +1,260 @@+{+ "addons": [+ {+ "addonName": "vpc-cni",+ "type": "networking",+ "owner": "aws",+ "publisher": "eks",+ "addonVersions": [+ {+ "addonVersion": "v1.18.5-eksbuild.1",+ "architecture": ["amd64", "arm64"],+ "compatibilities": [+ {+ "clusterVersion": "1.32",+ "platformVersions": ["*"],+ "defaultVersion": true+ },+ {+ "clusterVersion": "1.31",+ "platformVersions": ["*"],+ "defaultVersion": true+ },+ {+ "clusterVersion": "1.30",+ "platformVersions": ["*"],+ "defaultVersion": false+ }+ ],+ "requiresConfiguration": false,+ "requiresIamPermissions": true+ },+ {+ "addonVersion": "v1.18.1-eksbuild.1",+ "architecture": ["amd64", "arm64"],+ "compatibilities": [+ {+ "clusterVersion": "1.30",+ "platformVersions": ["*"],+ "defaultVersion": true+ },+ {+ "clusterVersion": "1.29",+ "platformVersions": ["*"],+ "defaultVersion": true+ }+ ],+ "requiresConfiguration": false,+ "requiresIamPermissions": true+ },+ {+ "addonVersion": "v1.16.0-eksbuild.1",+ "architecture": ["amd64", "arm64"],+ "compatibilities": [+ {+ "clusterVersion": "1.28",+ "platformVersions": ["*"],+ "defaultVersion": true+ }+ ],+ "requiresConfiguration": false,+ "requiresIamPermissions": true+ }+ ]+ },+ {+ "addonName": "coredns",+ "type": "networking",+ "owner": "aws",+ "publisher": "eks",+ "addonVersions": [+ {+ "addonVersion": "v1.11.3-eksbuild.1",+ "architecture": ["amd64", "arm64"],+ "compatibilities": [+ {+ "clusterVersion": "1.32",+ "platformVersions": ["*"],+ "defaultVersion": true+ },+ {+ "clusterVersion": "1.31",+ "platformVersions": ["*"],+ "defaultVersion": true+ }+ ],+ "requiresConfiguration": false,+ "requiresIamPermissions": false+ },+ {+ "addonVersion": "v1.11.1-eksbuild.4",+ "architecture": ["amd64", "arm64"],+ "compatibilities": [+ {+ "clusterVersion": "1.30",+ "platformVersions": ["*"],+ "defaultVersion": true+ },+ {+ "clusterVersion": "1.29",+ "platformVersions": ["*"],+ "defaultVersion": true+ }+ ],+ "requiresConfiguration": false,+ "requiresIamPermissions": false+ },+ {+ "addonVersion": "v1.10.1-eksbuild.7",+ "architecture": ["amd64", "arm64"],+ "compatibilities": [+ {+ "clusterVersion": "1.28",+ "platformVersions": ["*"],+ "defaultVersion": true+ }+ ],+ "requiresConfiguration": false,+ "requiresIamPermissions": false+ }+ ]+ },+ {+ "addonName": "kube-proxy",+ "type": "networking",+ "owner": "aws",+ "publisher": "eks",+ "addonVersions": [+ {+ "addonVersion": "v1.32.0-eksbuild.1",+ "architecture": ["amd64", "arm64"],+ "compatibilities": [+ {+ "clusterVersion": "1.32",+ "platformVersions": ["*"],+ "defaultVersion": true+ }+ ],+ "requiresConfiguration": false,+ "requiresIamPermissions": false+ },+ {+ "addonVersion": "v1.31.0-eksbuild.1",+ "architecture": ["amd64", "arm64"],+ "compatibilities": [+ {+ "clusterVersion": "1.31",+ "platformVersions": ["*"],+ "defaultVersion": true+ }+ ],+ "requiresConfiguration": false,+ "requiresIamPermissions": false+ },+ {+ "addonVersion": "v1.30.0-eksbuild.3",+ "architecture": ["amd64", "arm64"],+ "compatibilities": [+ {+ "clusterVersion": "1.30",+ "platformVersions": ["*"],+ "defaultVersion": true+ }+ ],+ "requiresConfiguration": false,+ "requiresIamPermissions": false+ },+ {+ "addonVersion": "v1.29.3-eksbuild.2",+ "architecture": ["amd64", "arm64"],+ "compatibilities": [+ {+ "clusterVersion": "1.29",+ "platformVersions": ["*"],+ "defaultVersion": true+ }+ ],+ "requiresConfiguration": false,+ "requiresIamPermissions": false+ },+ {+ "addonVersion": "v1.28.8-eksbuild.2",+ "architecture": ["amd64", "arm64"],+ "compatibilities": [+ {+ "clusterVersion": "1.28",+ "platformVersions": ["*"],+ "defaultVersion": true+ }+ ],+ "requiresConfiguration": false,+ "requiresIamPermissions": false+ }+ ]+ },+ {+ "addonName": "eks-pod-identity-agent",+ "type": "security",+ "owner": "aws",+ "publisher": "eks",+ "addonVersions": [+ {+ "addonVersion": "v1.3.0-eksbuild.1",+ "architecture": ["amd64", "arm64"],+ "compatibilities": [+ {+ "clusterVersion": "1.32",+ "platformVersions": ["*"],+ "defaultVersion": true+ },+ {+ "clusterVersion": "1.31",+ "platformVersions": ["*"],+ "defaultVersion": true+ },+ {+ "clusterVersion": "1.30",+ "platformVersions": ["*"],+ "defaultVersion": true+ },+ {+ "clusterVersion": "1.29",+ "platformVersions": ["*"],+ "defaultVersion": true+ },+ {+ "clusterVersion": "1.28",+ "platformVersions": ["*"],+ "defaultVersion": true+ }+ ],+ "requiresConfiguration": false,+ "requiresIamPermissions": false+ },+ {+ "addonVersion": "v1.2.0-eksbuild.1",+ "architecture": ["amd64", "arm64"],+ "compatibilities": [+ {+ "clusterVersion": "1.30",+ "platformVersions": ["*"],+ "defaultVersion": false+ },+ {+ "clusterVersion": "1.29",+ "platformVersions": ["*"],+ "defaultVersion": false+ },+ {+ "clusterVersion": "1.28",+ "platformVersions": ["*"],+ "defaultVersion": false+ }+ ],+ "requiresConfiguration": false,+ "requiresIamPermissions": false+ }+ ]+ }+ ]+}diff --git a/src/test/java/io/github/hectorvent/floci/services/eks/EksAddonIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/eks/EksAddonIntegrationTest.javanew file mode 100644index 0000000000..bb96e22aee--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/eks/EksAddonIntegrationTest.java@@ -0,0 +1,426 @@+package io.github.hectorvent.floci.services.eks;++import io.quarkus.test.junit.QuarkusTest;+import org.junit.jupiter.api.Test;++import java.util.List;+import java.util.Map;+import java.util.UUID;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.*;++@QuarkusTest+class EksAddonIntegrationTest {++ @Test+ void addonLifecycleRoundTrip() {+ String account = "123456789012";+ String name = "addon-it-" + UUID.randomUUID().toString().substring(0, 8);+ String roleName = "role-" + name;+ String roleArn = "arn:aws:iam::" + account + ":role/" + roleName;+ String basePath = "/clusters/" + name + "/addons";++ createRole(account, roleName);+ createCluster(account, name, "1.30");++ try {+ // 1. Create addon+ Map<String, Object> createReq = Map.of(+ "addonName", "vpc-cni",+ "addonVersion", "v1.18.1-eksbuild.1",+ "serviceAccountRoleArn", roleArn,+ "configurationValues", "{\"env\":{\"ENABLE_PREFIX_DELEGATION\":\"true\"}}",+ "clientRequestToken", "token-addon-1",+ "tags", Map.of("environment", "test")+ );++ given().header("Authorization", auth(account, "eks"))+ .contentType("application/json")+ .body(createReq)+ .post(basePath)+ .then()+ .statusCode(200)+ .contentType(containsString("application/json"))+ .body("addon.clusterName", equalTo(name))+ .body("addon.addonName", equalTo("vpc-cni"))+ .body("addon.addonVersion", equalTo("v1.18.1-eksbuild.1"))+ .body("addon.status", equalTo("ACTIVE"))+ .body("addon.serviceAccountRoleArn", equalTo(roleArn))+ .body("addon.configurationValues", equalTo("{\"env\":{\"ENABLE_PREFIX_DELEGATION\":\"true\"}}"))+ .body("addon.tags.environment", equalTo("test"))+ .body("addon.health.issues", empty())+ .body("addon.podIdentityAssociations", empty())+ .body("addon.owner", equalTo("aws"))+ .body("addon.publisher", equalTo("eks"))+ .body("addon.addonArn", startsWith("arn:aws:eks:us-east-1:" + account + ":addon/" + name + "/vpc-cni/"))+ .body("addon.createdAt", instanceOf(Number.class))+ .body("addon.modifiedAt", instanceOf(Number.class));++ // 2. Idempotent retry with same parameters and token+ given().header("Authorization", auth(account, "eks"))+ .contentType("application/json")+ .body(createReq)+ .post(basePath)+ .then()+ .statusCode(200)+ .body("addon.addonName", equalTo("vpc-cni"));++ // 3. Conflicting request with same token fails+ Map<String, Object> conflictReq = Map.of(+ "addonName", "vpc-cni",+ "addonVersion", "v1.18.1-eksbuild.1",+ "clientRequestToken", "token-addon-1",+ "tags", Map.of("environment", "production")+ );+ given().header("Authorization", auth(account, "eks"))+ .contentType("application/json")+ .body(conflictReq)+ .post(basePath)+ .then()+ .statusCode(400)+ .contentType(containsString("application/json"))+ .body("__type", equalTo("InvalidParameterException"));++ // 4. Duplicate creation with different token fails (409)+ Map<String, Object> duplicateReq = Map.of(+ "addonName", "vpc-cni",+ "clientRequestToken", "token-addon-2"+ );+ given().header("Authorization", auth(account, "eks"))+ .contentType("application/json")+ .body(duplicateReq)+ .post(basePath)+ .then()+ .statusCode(409)+ .contentType(containsString("application/json"))+ .body("__type", equalTo("ResourceInUseException"));++ // 5. Describe addon+ given().header("Authorization", auth(account, "eks"))+ .get(basePath + "/vpc-cni")+ .then()+ .statusCode(200)+ .contentType(containsString("application/json"))+ .body("addon.addonName", equalTo("vpc-cni"))+ .body("addon.status", equalTo("ACTIVE"))+ .body("addon.addonVersion", equalTo("v1.18.1-eksbuild.1"));++ // 6. Update addon+ String updatedRoleName = "updated-" + roleName;+ String updatedRoleArn = "arn:aws:iam::" + account + ":role/" + updatedRoleName;+ createRole(account, updatedRoleName);++ Map<String, Object> updateReq = Map.of(+ "addonVersion", "v1.18.5-eksbuild.1",+ "serviceAccountRoleArn", updatedRoleArn,+ "configurationValues", "{\"env\":{\"ENABLE_PREFIX_DELEGATION\":\"false\"}}"+ );+ String updateId = given().header("Authorization", auth(account, "eks"))+ .contentType("application/json")+ .body(updateReq)+ .post(basePath + "/vpc-cni/update")+ .then()+ .statusCode(200)+ .contentType(containsString("application/json"))+ .body("update.status", equalTo("Successful"))+ .body("update.type", equalTo("AddonUpdate"))+ .body("update.id", notNullValue())+ .extract().path("update.id");++ // Verify DescribeUpdate (called by Terraform aws_eks_addon waiter)+ given().header("Authorization", auth(account, "eks"))+ .queryParam("addonName", "vpc-cni")+ .get("/clusters/" + name + "/updates/" + updateId)+ .then()+ .statusCode(200)+ .contentType(containsString("application/json"))+ .body("update.id", equalTo(updateId))+ .body("update.status", equalTo("Successful"))+ .body("update.type", equalTo("AddonUpdate"));++ // Verify describe shows updated values+ given().header("Authorization", auth(account, "eks"))+ .get(basePath + "/vpc-cni")+ .then()+ .statusCode(200)+ .body("addon.addonVersion", equalTo("v1.18.5-eksbuild.1"))+ .body("addon.serviceAccountRoleArn", equalTo(updatedRoleArn))+ .body("addon.configurationValues", equalTo("{\"env\":{\"ENABLE_PREFIX_DELEGATION\":\"false\"}}"));++ // 7. List addons+ given().header("Authorization", auth(account, "eks"))+ .get(basePath)+ .then()+ .statusCode(200)+ .contentType(containsString("application/json"))+ .body("addons", hasSize(1))+ .body("addons[0]", equalTo("vpc-cni"));++ // 8. Delete addon+ given().header("Authorization", auth(account, "eks"))+ .delete(basePath + "/vpc-cni")+ .then()+ .statusCode(200)+ .contentType(containsString("application/json"))+ .body("addon.addonName", equalTo("vpc-cni"))+ .body("addon.status", equalTo("DELETING"));++ // 9. Describe after delete returns 404+ given().header("Authorization", auth(account, "eks"))+ .get(basePath + "/vpc-cni")+ .then()+ .statusCode(404)+ .body("__type", equalTo("ResourceNotFoundException"));+ } finally {+ deleteCluster(account, name);+ }+ }++ @Test+ void describeAddonVersionsEndpoints() {+ String account = "123456789012";++ // Query all supported versions+ given().header("Authorization", auth(account, "eks"))+ .get("/addons/supported-versions")+ .then()+ .statusCode(200)+ .contentType(containsString("application/json"))+ .body("addons", hasSize(greaterThanOrEqualTo(4)))+ .body("addons.addonName", hasItems("vpc-cni", "coredns", "kube-proxy", "eks-pod-identity-agent"));++ // Query with addonName filter+ given().header("Authorization", auth(account, "eks"))+ .queryParam("addonName", "vpc-cni")+ .get("/addons/supported-versions")+ .then()+ .statusCode(200)+ .body("addons", hasSize(1))+ .body("addons[0].addonName", equalTo("vpc-cni"))+ .body("addons[0].addonVersions", not(empty()));++ // Query with kubernetesVersion filter+ given().header("Authorization", auth(account, "eks"))+ .queryParam("addonName", "vpc-cni")+ .queryParam("kubernetesVersion", "1.29")+ .get("/addons/supported-versions")+ .then()+ .statusCode(200)+ .body("addons", hasSize(1))+ .body("addons[0].addonName", equalTo("vpc-cni"))+ .body("addons[0].addonVersions.addonVersion", hasItem("v1.18.1-eksbuild.1"));++ // Unknown addon name returns empty list 200+ given().header("Authorization", auth(account, "eks"))+ .queryParam("addonName", "non-existent-addon")+ .get("/addons/supported-versions")+ .then()+ .statusCode(200)+ .body("addons", empty());+ }++ @Test+ void addonPodIdentityAssociationLifecycleIntegration() {+ String account = "123456789012";+ String name = "addon-pia-" + UUID.randomUUID().toString().substring(0, 8);+ String roleName = "role-" + name;+ String roleArn = "arn:aws:iam::" + account + ":role/" + roleName;+ String basePath = "/clusters/" + name + "/addons";++ createRole(account, roleName);+ createCluster(account, name, "1.29");++ try {+ // Create addon with pod identity association+ Map<String, Object> createReq = Map.of(+ "addonName", "vpc-cni",+ "podIdentityAssociations", List.of(+ Map.of("serviceAccount", "aws-node", "roleArn", roleArn)+ )+ );++ given().header("Authorization", auth(account, "eks"))+ .contentType("application/json")+ .body(createReq)+ .post(basePath)+ .then()+ .statusCode(200)+ .body("addon.podIdentityAssociations", hasSize(1));++ // Verify the association was created under kube-system namespace+ given().header("Authorization", auth(account, "eks"))+ .get("/clusters/" + name + "/pod-identity-associations")+ .then()+ .statusCode(200)+ .body("associations", hasSize(1))+ .body("associations[0].namespace", equalTo("kube-system"))+ .body("associations[0].serviceAccount", equalTo("aws-node"));++ // Delete addon with preserve=false (default) -> deletes association+ given().header("Authorization", auth(account, "eks"))+ .delete(basePath + "/vpc-cni")+ .then()+ .statusCode(200);++ given().header("Authorization", auth(account, "eks"))+ .get("/clusters/" + name + "/pod-identity-associations")+ .then()+ .statusCode(200)+ .body("associations", empty());++ // Re-creating addon with same association succeeds (no ResourceInUseException)+ given().header("Authorization", auth(account, "eks"))+ .contentType("application/json")+ .body(createReq)+ .post(basePath)+ .then()+ .statusCode(200)+ .body("addon.addonName", equalTo("vpc-cni"));+ } finally {+ deleteCluster(account, name);+ }+ }++ @Test+ void addonOnClusterVersionOutsideCatalogRangeIntegration() {+ String account = "123456789012";+ String name = "addon-k8s-" + UUID.randomUUID().toString().substring(0, 8);+ String basePath = "/clusters/" + name + "/addons";++ createCluster(account, name, "1.35");+ try {+ // Create with no version resolves default version on cluster outside catalog range+ given().header("Authorization", auth(account, "eks"))+ .contentType("application/json")+ .body(Map.of("addonName", "vpc-cni"))+ .post(basePath)+ .then()+ .statusCode(200)+ .body("addon.addonName", equalTo("vpc-cni"))+ .body("addon.status", equalTo("ACTIVE"))+ .body("addon.addonVersion", notNullValue());++ // In-place update with catalog version succeeds+ given().header("Authorization", auth(account, "eks"))+ .contentType("application/json")+ .body(Map.of("addonVersion", "v1.18.1-eksbuild.1"))+ .post(basePath + "/vpc-cni/update")+ .then()+ .statusCode(200)+ .body("update.status", equalTo("Successful"));++ // In-place update with unknown version fails+ given().header("Authorization", auth(account, "eks"))+ .contentType("application/json")+ .body(Map.of("addonVersion", "v99.0.0"))+ .post(basePath + "/vpc-cni/update")+ .then()+ .statusCode(400)+ .body("__type", equalTo("InvalidParameterException"));+ } finally {+ deleteCluster(account, name);+ }+ }++ @Test+ void clusterDeletionCleansAddons() {+ String account = "123456789012";+ String name = "addon-clean-" + UUID.randomUUID().toString().substring(0, 8);+ String basePath = "/clusters/" + name + "/addons";++ createCluster(account, name, "1.29");++ given().header("Authorization", auth(account, "eks"))+ .contentType("application/json")+ .body(Map.of("addonName", "vpc-cni"))+ .post(basePath)+ .then()+ .statusCode(200);++ // Delete cluster+ deleteCluster(account, name);++ // Recreate cluster with same name+ createCluster(account, name, "1.29");+ try {+ // Addons must be empty on recreated cluster+ given().header("Authorization", auth(account, "eks"))+ .get(basePath)+ .then()+ .statusCode(200)+ .body("addons", empty());+ } finally {+ deleteCluster(account, name);+ }+ }++ @Test+ void routeCollisionsAndMissingCluster() {+ String account = "123456789012";++ // Missing cluster returns 404 JSON, not S3 NoSuchBucket XML+ given().header("Authorization", auth(account, "eks"))+ .get("/clusters/nonexistent-cluster/addons")+ .then()+ .statusCode(404)+ .contentType(containsString("application/json"))+ .body("__type", equalTo("ResourceNotFoundException"));++ // Unknown addon creation parameter error+ String name = "addon-err-" + UUID.randomUUID().toString().substring(0, 8);+ createCluster(account, name, "1.29");+ try {+ given().header("Authorization", auth(account, "eks"))+ .contentType("application/json")+ .body(Map.of("addonName", "unknown-addon"))+ .post("/clusters/" + name + "/addons")+ .then()+ .statusCode(400)+ .contentType(containsString("application/json"))+ .body("__type", equalTo("InvalidParameterException"));+ } finally {+ deleteCluster(account, name);+ }+ }++ private static String auth(String account, String service) {+ return "AWS4-HMAC-SHA256 Credential=" + account+ + "/20260920/us-east-1/" + service + "/aws4_request, SignedHeaders=host, Signature=fake";+ }++ private static void createRole(String account, String roleName) {+ given().header("Authorization", auth(account, "iam"))+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateRole")+ .formParam("RoleName", roleName)+ .formParam("Path", "/")+ .formParam("AssumeRolePolicyDocument", "{}")+ .post("/")+ .then()+ .statusCode(200);+ }++ private static void createCluster(String account, String name, String version) {+ Map<String, Object> req = Map.of(+ "name", name,+ "roleArn", "arn:aws:iam::" + account + ":role/eks-role",+ "version", version,+ "accessConfig", Map.of(+ "authenticationMode", "API",+ "bootstrapClusterCreatorAdminPermissions", false+ )+ );+ given().header("Authorization", auth(account, "eks"))+ .contentType("application/json")+ .body(req)+ .post("/clusters")+ .then()+ .statusCode(200);+ }++ private static void deleteCluster(String account, String name) {+ given().header("Authorization", auth(account, "eks"))+ .delete("/clusters/" + name);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/eks/EksAddonServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/eks/EksAddonServiceTest.javanew file mode 100644index 0000000000..c466ef4c2f--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/eks/EksAddonServiceTest.java@@ -0,0 +1,596 @@+package io.github.hectorvent.floci.services.eks;++import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.storage.InMemoryStorage;+import io.github.hectorvent.floci.services.eks.model.Addon;+import io.github.hectorvent.floci.services.eks.model.AddonInfo;+import io.github.hectorvent.floci.services.eks.model.AddonPodIdentityAssociation;+import io.github.hectorvent.floci.services.eks.model.Cluster;+import io.github.hectorvent.floci.services.eks.model.ClusterStatus;+import io.github.hectorvent.floci.services.eks.model.CreateAddonRequest;+import io.github.hectorvent.floci.services.eks.model.Update;+import io.github.hectorvent.floci.services.eks.model.UpdateAddonRequest;+import io.github.hectorvent.floci.services.iam.IamService;+import io.github.hectorvent.floci.services.iam.model.IamRole;+import org.junit.jupiter.api.Test;++import java.time.Instant;+import java.util.HashMap;+import java.util.List;+import java.util.Map;+import java.util.Optional;++import static org.junit.jupiter.api.Assertions.*;+import static org.mockito.Mockito.*;++class EksAddonServiceTest {++ private static final String ACCOUNT = "123456789012";+ private static final String ROLE = "arn:aws:iam::" + ACCOUNT + ":role/addon-role";++ @Test+ void createAndDescribeAddon() throws Exception {+ Fixture fixture = fixture();+ CreateAddonRequest request = new CreateAddonRequest(+ "vpc-cni",+ "v1.18.1-eksbuild.1",+ ROLE,+ "OVERWRITE",+ "token-1",+ "{\"env\":{\"foo\":\"bar\"}}",+ Map.of("env", "prod"),+ null+ );++ Addon created = fixture.service.create(fixture.cluster, request);++ assertEquals("vpc-cni", created.addonName());+ assertEquals("test-cluster", created.clusterName());+ assertEquals("v1.18.1-eksbuild.1", created.addonVersion());+ assertEquals("ACTIVE", created.status());+ assertNotNull(created.addonArn());+ assertTrue(created.addonArn().startsWith("arn:aws:eks:us-east-1:123456789012:addon/test-cluster/vpc-cni/"));+ assertEquals(ROLE, created.serviceAccountRoleArn());+ assertEquals("{\"env\":{\"foo\":\"bar\"}}", created.configurationValues());+ assertEquals(Map.of("env", "prod"), created.tags());+ assertNotNull(created.health());+ assertTrue(created.health().issues().isEmpty());+ assertEquals("aws", created.owner());+ assertEquals("eks", created.publisher());+ assertTrue(created.createdAt() > 0);+ assertEquals(created.createdAt(), created.modifiedAt());++ // Serialization roundtrip+ EksAddonService.StoredAddon stored = fixture.storage.scan(k -> true).getFirst();+ ObjectMapper mapper = new ObjectMapper();+ EksAddonService.StoredAddon restored = mapper.readValue(+ mapper.writeValueAsBytes(stored), EksAddonService.StoredAddon.class);+ assertEquals(stored, restored);++ // Describe returns the same addon+ Addon described = fixture.service.describe(fixture.cluster, "vpc-cni");+ assertEquals(created, described);+ }++ @Test+ void createResolvesDefaultVersionWhenOmitted() {+ Fixture fixture = fixture();+ fixture.cluster.setVersion("1.29");++ CreateAddonRequest request = new CreateAddonRequest(+ "vpc-cni",+ null,+ null,+ null,+ null,+ null,+ null,+ null+ );++ Addon created = fixture.service.create(fixture.cluster, request);+ assertEquals("v1.18.1-eksbuild.1", created.addonVersion());+ }++ @Test+ void createRejectsUnknownAddonAndUnsupportedVersion() {+ Fixture fixture = fixture();++ CreateAddonRequest unknownAddon = new CreateAddonRequest(+ "unknown-plugin",+ null,+ null,+ null,+ null,+ null,+ null,+ null+ );+ AwsException ex1 = assertThrows(AwsException.class, () ->+ fixture.service.create(fixture.cluster, unknownAddon));+ assertEquals("InvalidParameterException", ex1.getErrorCode());+ assertEquals(400, ex1.getHttpStatus());+ assertTrue(ex1.getMessage().contains("unknown-plugin"));++ CreateAddonRequest badVersion = new CreateAddonRequest(+ "vpc-cni",+ "v99.99.99",+ null,+ null,+ null,+ null,+ null,+ null+ );+ AwsException ex2 = assertThrows(AwsException.class, () ->+ fixture.service.create(fixture.cluster, badVersion));+ assertEquals("InvalidParameterException", ex2.getErrorCode());+ assertEquals(400, ex2.getHttpStatus());+ assertTrue(ex2.getMessage().contains("Addon version specified is not supported"));+ }++ @Test+ void retriesAreIdempotentButConflictingRequestsAndDuplicatesFail() {+ Fixture fixture = fixture();+ CreateAddonRequest request = new CreateAddonRequest(+ "coredns",+ "v1.11.1-eksbuild.4",+ null,+ null,+ "retry-token",+ null,+ Map.of("k", "v"),+ null+ );++ Addon first = fixture.service.create(fixture.cluster, request);+ Addon retry = fixture.service.create(fixture.cluster, request);+ assertEquals(first, retry);++ // Same token with different parameters throws InvalidParameterException+ CreateAddonRequest conflict = new CreateAddonRequest(+ "coredns",+ "v1.11.1-eksbuild.4",+ ROLE,+ null,+ "retry-token",+ null,+ Map.of("k", "v"),+ null+ );+ AwsException exConflict = assertThrows(AwsException.class, () ->+ fixture.service.create(fixture.cluster, conflict));+ assertEquals("InvalidParameterException", exConflict.getErrorCode());+ assertEquals(400, exConflict.getHttpStatus());++ // Duplicate addon with different token throws ResourceInUseException (409)+ CreateAddonRequest duplicate = new CreateAddonRequest(+ "coredns",+ "v1.11.1-eksbuild.4",+ null,+ null,+ "different-token",+ null,+ Map.of(),+ null+ );+ AwsException exDup = assertThrows(AwsException.class, () ->+ fixture.service.create(fixture.cluster, duplicate));+ assertEquals("ResourceInUseException", exDup.getErrorCode());+ assertEquals(409, exDup.getHttpStatus());+ }++ @Test+ void updateAddonValidationsAndModifiedAt() {+ Fixture fixture = fixture();+ fixture.cluster.setVersion("1.30");+ CreateAddonRequest createReq = new CreateAddonRequest(+ "vpc-cni",+ "v1.18.1-eksbuild.1",+ null,+ null,+ null,+ null,+ null,+ null+ );+ Addon created = fixture.service.create(fixture.cluster, createReq);++ // Update version to another supported version+ UpdateAddonRequest updateReq = new UpdateAddonRequest(+ "v1.18.5-eksbuild.1",+ ROLE,+ "OVERWRITE",+ "up-token",+ "{\"some\":\"config\"}",+ null+ );+ Update update = fixture.service.update(fixture.cluster, "vpc-cni", updateReq);+ assertEquals("Successful", update.status());+ assertEquals("AddonUpdate", update.type());+ assertNotNull(update.id());+ assertTrue(update.errors().isEmpty());++ Addon updated = fixture.service.describe(fixture.cluster, "vpc-cni");+ assertEquals("v1.18.5-eksbuild.1", updated.addonVersion());+ assertEquals(ROLE, updated.serviceAccountRoleArn());+ assertEquals("{\"some\":\"config\"}", updated.configurationValues());+ assertTrue(updated.modifiedAt() >= created.createdAt());++ // Update with unsupported version fails+ UpdateAddonRequest badUpdate = new UpdateAddonRequest("v0.0.0", null, null, null, null, null);+ AwsException exBad = assertThrows(AwsException.class, () ->+ fixture.service.update(fixture.cluster, "vpc-cni", badUpdate));+ assertEquals("InvalidParameterException", exBad.getErrorCode());++ // Update non-existent addon fails+ assertThrows(AwsException.class, () ->+ fixture.service.update(fixture.cluster, "kube-proxy", updateReq));+ }++ @Test+ void deleteAddonReturnsDeletedAndRemovesFromStore() {+ Fixture fixture = fixture();+ fixture.cluster.setVersion("1.29");+ CreateAddonRequest request = new CreateAddonRequest("kube-proxy", null, null, null, null, null, null, null);+ Addon created = fixture.service.create(fixture.cluster, request);++ Addon deleted = fixture.service.delete(fixture.cluster, "kube-proxy", false);+ assertEquals("DELETING", deleted.status());+ assertEquals("kube-proxy", deleted.addonName());++ AwsException ex = assertThrows(AwsException.class, () ->+ fixture.service.describe(fixture.cluster, "kube-proxy"));+ assertEquals("ResourceNotFoundException", ex.getErrorCode());+ assertEquals(404, ex.getHttpStatus());++ assertThrows(AwsException.class, () ->+ fixture.service.delete(fixture.cluster, "kube-proxy", false));+ }++ @Test+ void listAddonsWithPagination() {+ Fixture fixture = fixture();+ fixture.cluster.setVersion("1.29");++ fixture.service.create(fixture.cluster, new CreateAddonRequest("vpc-cni", null, null, null, null, null, null, null));+ fixture.service.create(fixture.cluster, new CreateAddonRequest("coredns", null, null, null, null, null, null, null));+ fixture.service.create(fixture.cluster, new CreateAddonRequest("kube-proxy", null, null, null, null, null, null, null));++ // List all+ EksAddonService.AddonNamesPage allPage = fixture.service.list(fixture.cluster, null, null);+ assertEquals(3, allPage.addons().size());+ assertEquals(List.of("coredns", "kube-proxy", "vpc-cni"), allPage.addons());+ assertNull(allPage.nextToken());++ // Paginate limit 1+ EksAddonService.AddonNamesPage p1 = fixture.service.list(fixture.cluster, 1, null);+ assertEquals(1, p1.addons().size());+ assertEquals("coredns", p1.addons().getFirst());+ assertNotNull(p1.nextToken());++ EksAddonService.AddonNamesPage p2 = fixture.service.list(fixture.cluster, 1, p1.nextToken());+ assertEquals(1, p2.addons().size());+ assertEquals("kube-proxy", p2.addons().getFirst());+ assertNotNull(p2.nextToken());++ EksAddonService.AddonNamesPage p3 = fixture.service.list(fixture.cluster, 1, p2.nextToken());+ assertEquals(1, p3.addons().size());+ assertEquals("vpc-cni", p3.addons().getFirst());+ assertNull(p3.nextToken());++ // Invalid maxResults+ assertThrows(AwsException.class, () -> fixture.service.list(fixture.cluster, 0, null));+ assertThrows(AwsException.class, () -> fixture.service.list(fixture.cluster, 101, null));+ }++ @Test+ void clusterDeletionCleansAddonsAndRecreationCannotInheritThem() {+ Fixture fixture = fixture();+ fixture.cluster.setVersion("1.29");+ fixture.service.create(fixture.cluster, new CreateAddonRequest("vpc-cni", null, null, null, null, null, null, null));++ assertEquals(1, fixture.service.list(fixture.cluster, null, null).addons().size());++ fixture.service.deleteClusterAddons(fixture.cluster);+ assertTrue(fixture.storage.scan(k -> true).isEmpty());++ // Recreated cluster with new createdAt cannot inherit old addons or pagination tokens+ fixture.service.create(fixture.cluster, new CreateAddonRequest("vpc-cni", null, null, null, null, null, null, null));+ fixture.service.create(fixture.cluster, new CreateAddonRequest("coredns", null, null, null, null, null, null, null));+ EksAddonService.AddonNamesPage pageBefore = fixture.service.list(fixture.cluster, 1, null);+ assertNotNull(pageBefore.nextToken());++ fixture.cluster.setCreatedAt(fixture.cluster.getCreatedAt().plusSeconds(10));+ assertTrue(fixture.service.list(fixture.cluster, null, null).addons().isEmpty());+ }++ @Test+ void inactiveClusterRejectsOperations() {+ Fixture fixture = fixture();+ fixture.cluster.setStatus(ClusterStatus.CREATING);++ CreateAddonRequest request = new CreateAddonRequest("vpc-cni", null, null, null, null, null, null, null);+ assertThrows(AwsException.class, () -> fixture.service.create(fixture.cluster, request));+ assertThrows(AwsException.class, () -> fixture.service.describe(fixture.cluster, "vpc-cni"));+ assertThrows(AwsException.class, () -> fixture.service.list(fixture.cluster, null, null));+ assertThrows(AwsException.class, () -> fixture.service.update(fixture.cluster, "vpc-cni", null));+ assertThrows(AwsException.class, () -> fixture.service.delete(fixture.cluster, "vpc-cni", false));+ }++ @Test+ void describeUpdateAndNotFound() {+ Fixture fixture = fixture();+ fixture.cluster.setVersion("1.29");+ fixture.service.create(fixture.cluster, new CreateAddonRequest("vpc-cni", null, null, null, null, null, null, null));++ Update update = fixture.service.update(fixture.cluster, "vpc-cni",+ new UpdateAddonRequest("v1.18.1-eksbuild.1", null, null, null, null, null));+ assertNotNull(update.id());+ assertEquals("Successful", update.status());+ assertEquals("AddonUpdate", update.type());++ // Describe without addonName filter+ Update fetched = fixture.service.describeUpdate(fixture.cluster, update.id(), null);+ assertEquals(update.id(), fetched.id());+ assertEquals("Successful", fetched.status());++ // Describe with matching addonName filter+ Update fetchedFiltered = fixture.service.describeUpdate(fixture.cluster, update.id(), "vpc-cni");+ assertEquals(update.id(), fetchedFiltered.id());++ // Describe with mismatched addonName filter+ AwsException exMismatch = assertThrows(AwsException.class, () ->+ fixture.service.describeUpdate(fixture.cluster, update.id(), "coredns"));+ assertEquals("ResourceNotFoundException", exMismatch.getErrorCode());+ assertEquals(404, exMismatch.getHttpStatus());++ // Describe nonexistent updateId+ AwsException exNotFound = assertThrows(AwsException.class, () ->+ fixture.service.describeUpdate(fixture.cluster, "missing-update-id", null));+ assertEquals("ResourceNotFoundException", exNotFound.getErrorCode());+ assertEquals(404, exNotFound.getHttpStatus());+ }++ @Test+ void podIdentityAssociationsLifecycle() {+ Fixture fixture = fixture();+ fixture.cluster.setVersion("1.29");++ AddonPodIdentityAssociation assoc1 = new AddonPodIdentityAssociation(ROLE, "aws-node");+ CreateAddonRequest request = new CreateAddonRequest(+ "vpc-cni", null, null, null, null, null, null, List.of(assoc1));++ Addon created = fixture.service.create(fixture.cluster, request);+ assertEquals(1, created.podIdentityAssociations().size());+ String assocArn = created.podIdentityAssociations().getFirst();++ // Verify association was created in kube-system namespace+ EksPodIdentityAssociationService.Page page = fixture.podIdentityAssociations.list(+ fixture.cluster, "kube-system", "aws-node", null, null);+ assertEquals(1, page.associations().size());+ assertEquals(assocArn, page.associations().getFirst().associationArn());++ // Update with same or new association succeeds without duplicate error+ Update update = fixture.service.update(fixture.cluster, "vpc-cni",+ new UpdateAddonRequest(null, null, null, null, null, List.of(assoc1)));+ assertNotNull(update.id());+ // Verify UpdateParam for PodIdentityAssociations is JSON string, not Java toString()+ assertTrue(update.params().stream().anyMatch(p ->+ "PodIdentityAssociations".equals(p.type())+ && p.value().contains("\"roleArn\"")+ && !p.value().startsWith("AddonPodIdentityAssociation[")+ ));++ // Re-read addon and verify association still present in kube-system+ Addon updated = fixture.service.describe(fixture.cluster, "vpc-cni");+ assertEquals(1, updated.podIdentityAssociations().size());++ // Update with invalid association fails validation BEFORE deleting existing associations+ AddonPodIdentityAssociation invalidAssoc = new AddonPodIdentityAssociation(+ "arn:aws:iam::" + ACCOUNT + ":role/non-existent-role", "aws-node");+ AwsException exInvalidUpdate = assertThrows(AwsException.class, () ->+ fixture.service.update(fixture.cluster, "vpc-cni",+ new UpdateAddonRequest(null, null, null, null, null, List.of(invalidAssoc))));+ assertEquals("InvalidParameterException", exInvalidUpdate.getErrorCode());+ // Verify existing association was NOT deleted+ Addon afterFailedUpdate = fixture.service.describe(fixture.cluster, "vpc-cni");+ assertEquals(1, afterFailedUpdate.podIdentityAssociations().size());+ EksPodIdentityAssociationService.Page stillThere = fixture.podIdentityAssociations.list(+ fixture.cluster, "kube-system", "aws-node", null, null);+ assertEquals(1, stillThere.associations().size());++ // Delete with preserve=false removes association from cluster+ fixture.service.delete(fixture.cluster, "vpc-cni", false);+ EksPodIdentityAssociationService.Page afterDelete = fixture.podIdentityAssociations.list(+ fixture.cluster, "kube-system", "aws-node", null, null);+ assertTrue(afterDelete.associations().isEmpty());++ // Re-creating addon with the same association now succeeds because old one was deleted+ Addon recreated = fixture.service.create(fixture.cluster, request);+ assertEquals(1, recreated.podIdentityAssociations().size());++ // Delete with preserve=true keeps the association in cluster+ fixture.service.delete(fixture.cluster, "vpc-cni", true);+ EksPodIdentityAssociationService.Page afterPreserveDelete = fixture.podIdentityAssociations.list(+ fixture.cluster, "kube-system", "aws-node", null, null);+ assertEquals(1, afterPreserveDelete.associations().size());+ }++ @Test+ void explicitVersionMustBeCompatibleWithClusterKubernetesVersion() {+ Fixture fixture = fixture();+ fixture.cluster.setVersion("1.29");++ // v1.16.0-eksbuild.1 is only compatible with k8s 1.28+ CreateAddonRequest reqIncompatible = new CreateAddonRequest(+ "vpc-cni", "v1.16.0-eksbuild.1", null, null, null, null, null, null);+ AwsException exCreate = assertThrows(AwsException.class, () ->+ fixture.service.create(fixture.cluster, reqIncompatible));+ assertEquals("InvalidParameterException", exCreate.getErrorCode());+ assertEquals(400, exCreate.getHttpStatus());++ // Compatible version works+ CreateAddonRequest reqCompatible = new CreateAddonRequest(+ "vpc-cni", "v1.18.1-eksbuild.1", null, null, null, null, null, null);+ Addon created = fixture.service.create(fixture.cluster, reqCompatible);+ assertEquals("v1.18.1-eksbuild.1", created.addonVersion());++ // Updating to incompatible version fails+ UpdateAddonRequest updateIncompatible = new UpdateAddonRequest(+ "v1.16.0-eksbuild.1", null, null, null, null, null);+ AwsException exUpdate = assertThrows(AwsException.class, () ->+ fixture.service.update(fixture.cluster, "vpc-cni", updateIncompatible));+ assertEquals("InvalidParameterException", exUpdate.getErrorCode());+ assertEquals(400, exUpdate.getHttpStatus());+ }++ @Test+ void clusterVersionOutsideCatalogRangeAllowsCatalogVersionsAndResolvesDefault() {+ Fixture fixture = fixture();+ fixture.cluster.setVersion("1.35");++ // Create with no version resolves a default version from the catalog without error+ CreateAddonRequest reqDefault = new CreateAddonRequest(+ "vpc-cni", null, null, null, null, null, null, null);+ Addon created = fixture.service.create(fixture.cluster, reqDefault);+ assertNotNull(created.addonVersion());+ assertEquals("ACTIVE", created.status());++ // Update with another valid catalog version succeeds+ Update update = fixture.service.update(fixture.cluster, "vpc-cni",+ new UpdateAddonRequest("v1.18.1-eksbuild.1", null, null, null, null, null));+ assertNotNull(update.id());+ Addon updated = fixture.service.describe(fixture.cluster, "vpc-cni");+ assertEquals("v1.18.1-eksbuild.1", updated.addonVersion());++ // Updating with a version NOT in catalog at all still fails+ UpdateAddonRequest updateBad = new UpdateAddonRequest(+ "v99.0.0", null, null, null, null, null);+ AwsException ex = assertThrows(AwsException.class, () ->+ fixture.service.update(fixture.cluster, "vpc-cni", updateBad));+ assertEquals("InvalidParameterException", ex.getErrorCode());+ assertEquals(400, ex.getHttpStatus());+ }++ @Test+ void clusterVersion132SupportedInCatalog() {+ Fixture fixture = fixture();+ fixture.cluster.setVersion("1.32");++ CreateAddonRequest reqKubeProxy = new CreateAddonRequest(+ "kube-proxy", null, null, null, null, null, null, null);+ Addon created = fixture.service.create(fixture.cluster, reqKubeProxy);+ assertEquals("v1.32.0-eksbuild.1", created.addonVersion());++ // Incompatible version (v1.16.0 only compatible with 1.28) is rejected+ CreateAddonRequest reqIncompatible = new CreateAddonRequest(+ "vpc-cni", "v1.16.0-eksbuild.1", null, null, null, null, null, null);+ AwsException ex = assertThrows(AwsException.class, () ->+ fixture.service.create(fixture.cluster, reqIncompatible));+ assertEquals("InvalidParameterException", ex.getErrorCode());+ assertEquals(400, ex.getHttpStatus());+ }++ @Test+ void describeAddonVersionsWithFilteringAndPagination() {+ Fixture fixture = fixture();++ // All addons+ EksAddonService.AddonVersionsPage all = fixture.service.describeAddonVersions(+ null, null, null, null, null, null, null);+ assertTrue(all.addons().size() >= 4);++ // Filter by addonName+ EksAddonService.AddonVersionsPage vpcCniOnly = fixture.service.describeAddonVersions(+ "vpc-cni", null, null, null, null, null, null);+ assertEquals(1, vpcCniOnly.addons().size());+ assertEquals("vpc-cni", vpcCniOnly.addons().getFirst().addonName());++ // Filter by kubernetesVersion+ EksAddonService.AddonVersionsPage k8s128 = fixture.service.describeAddonVersions(+ "vpc-cni", "1.28", null, null, null, null, null);+ assertEquals(1, k8s128.addons().size());+ AddonInfo info128 = k8s128.addons().getFirst();+ assertTrue(info128.addonVersions().stream()+ .anyMatch(v -> "v1.16.0-eksbuild.1".equals(v.addonVersion())));++ // Unknown addon returns empty list+ EksAddonService.AddonVersionsPage empty = fixture.service.describeAddonVersions(+ "unknown-addon", null, null, null, null, null, null);+ assertTrue(empty.addons().isEmpty());++ // Pagination+ EksAddonService.AddonVersionsPage page1 = fixture.service.describeAddonVersions(+ null, null, 2, null, null, null, null);+ assertEquals(2, page1.addons().size());+ assertNotNull(page1.nextToken());++ EksAddonService.AddonVersionsPage page2 = fixture.service.describeAddonVersions(+ null, null, 2, page1.nextToken(), null, null, null);+ assertTrue(page2.addons().size() >= 2);+ }++ @Test+ void roleArnAndTagValidations() {+ Fixture fixture = fixture();+ fixture.cluster.setVersion("1.29");++ // Bad role ARN format+ CreateAddonRequest badRoleArn = new CreateAddonRequest(+ "vpc-cni", null, "invalid-arn", null, null, null, null, null);+ AwsException exRole = assertThrows(AwsException.class, () ->+ fixture.service.create(fixture.cluster, badRoleArn));+ assertEquals("InvalidParameterException", exRole.getErrorCode());++ // Non-existent role+ when(fixture.iam.findRole("123456789012", "missing-role")).thenReturn(Optional.empty());+ CreateAddonRequest missingRole = new CreateAddonRequest(+ "vpc-cni", null, "arn:aws:iam::123456789012:role/missing-role", null, null, null, null, null);+ AwsException exMiss = assertThrows(AwsException.class, () ->+ fixture.service.create(fixture.cluster, missingRole));+ assertEquals("InvalidParameterException", exMiss.getErrorCode());+ assertTrue(exMiss.getMessage().contains("Role not found"));++ // Too many tags (>50)+ Map<String, String> tooManyTags = new HashMap<>();+ for (int i = 0; i < 51; i++) {+ tooManyTags.put("key" + i, "val" + i);+ }+ CreateAddonRequest tagOver = new CreateAddonRequest(+ "vpc-cni", null, null, null, null, null, tooManyTags, null);+ AwsException exTags = assertThrows(AwsException.class, () ->+ fixture.service.create(fixture.cluster, tagOver));+ assertEquals("InvalidParameterException", exTags.getErrorCode());+ assertTrue(exTags.getMessage().contains("Too many tags"));+ }++ private static Fixture fixture() {+ Cluster cluster = new Cluster();+ cluster.setName("test-cluster");+ cluster.setArn("arn:aws:eks:us-east-1:123456789012:cluster/test-cluster");+ cluster.setCreatedAt(Instant.parse("2026-09-20T12:00:00Z"));+ cluster.setStatus(ClusterStatus.ACTIVE);++ IamService iam = mock(IamService.class);+ IamRole role = new IamRole("AROA-addon", "addon-role", "/", ROLE, "{}");+ when(iam.findRole("123456789012", "addon-role")).thenReturn(Optional.of(role));++ EksAddonCatalog catalog = new EksAddonCatalog();+ InMemoryStorage<String, EksAddonService.StoredAddon> storage = new InMemoryStorage<>();+ InMemoryStorage<String, EksAddonService.StoredUpdate> updatesStorage = new InMemoryStorage<>();+ InMemoryStorage<String, EksPodIdentityAssociationService.StoredAssociation> assocStorage = new InMemoryStorage<>();+ EksPodIdentityAssociationService podIdentityAssociations = new EksPodIdentityAssociationService(assocStorage, iam);+ EksAddonService service = new EksAddonService(storage, updatesStorage, catalog, iam, podIdentityAssociations);++ return new Fixture(cluster, iam, role, storage, updatesStorage, catalog, podIdentityAssociations, service);+ }++ private record Fixture(Cluster cluster, IamService iam, IamRole role,+ InMemoryStorage<String, EksAddonService.StoredAddon> storage,+ InMemoryStorage<String, EksAddonService.StoredUpdate> updatesStorage,+ EksAddonCatalog catalog,+ EksPodIdentityAssociationService podIdentityAssociations,+ EksAddonService service) {}+}diff --git a/src/test/java/io/github/hectorvent/floci/services/eks/EksServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/eks/EksServiceTest.javaindex 9fa0796e28..87e006a759 100644--- a/src/test/java/io/github/hectorvent/floci/services/eks/EksServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/eks/EksServiceTest.java@@ -740,6 +740,31 @@ class EksServiceTest {assertTrue(eksService.listClusters().isEmpty());}+ @Test+ void deleteClusterDeletesAddons() {+ StorageFactory storageFactory = new StorageFactory(null, null) {+ @Override+ public <V> AccountAwareStorageBackend<V> create(String serviceName, String fileName,+ TypeReference<Map<String, V>> typeReference) {+ return AccountAwareStorageBackend.inMemory("000000000000");+ }+ };++ EksAddonService mockAddons = mock(EksAddonService.class);+ EksService service = new EksService(storageFactory, testConfig(),+ new RegionResolver("us-east-1", "000000000000"), null, null,+ new EksOidcService(storageFactory, new ObjectMapper()), mock(EksAccessEntryService.class),+ mock(EksPodIdentityAssociationService.class), mockAddons);++ CreateClusterRequest req = new CreateClusterRequest();+ req.setName("addons-cluster-to-delete");+ req.setRoleArn("arn:aws:iam::000000000000:role/eks-role");+ service.createCluster(req);++ service.deleteCluster("addons-cluster-to-delete");+ verify(mockAddons).deleteClusterAddons(any(Cluster.class));+ }+@Testvoid taggingOperations() {CreateClusterRequest req = new CreateClusterRequest();