Light, fluffy, and always free - The AWS Local Emulator alternative
feat(elasticache): add serverless cache APIs (#5366)
Vũ Thế Huybac2c7cbf98a
diff --git a/docs/services/elasticache.md b/docs/services/elasticache.mdindex 61b48ae66e..259e407ebc 100644--- a/docs/services/elasticache.md+++ b/docs/services/elasticache.md@@ -21,10 +21,14 @@ Floci manages real Valkey/Redis Docker containers and proxies TCP connections to| `ModifyUser` | Change a user's passwords and authentication mode, replace its access string with `AccessString` or add to it with `AppendAccessString` || `DeleteUser` | Remove an ElastiCache user || `CreateUserGroup` | Create a user group; a `redis` group must contain a user named `default`, a `valkey` group need not |-| `DescribeUserGroups` | List user groups with their users and the replication groups using them |+| `DescribeUserGroups` | List user groups with their users and the replication groups and serverless caches using them || `ModifyUserGroup` | Add or remove users, or change the engine; membership changes apply to authentication at once |-| `DeleteUserGroup` | Remove a user group that no replication group uses |+| `DeleteUserGroup` | Remove a user group that no replication group or serverless cache uses || `CreateCacheCluster` | Start a Memcached cluster, or a single-node Redis/Valkey one (`NumCacheNodes` must be 1) |+| `CreateServerlessCache` | Create a local Valkey, Redis or Memcached runtime with serverless metadata |+| `DescribeServerlessCaches` | List serverless caches, settings and endpoints |+| `ModifyServerlessCache` | Update metadata and user-group association while retaining cache data |+| `DeleteServerlessCache` | Delete serverless metadata and its backing runtime || `DescribeCacheClusters` | List cache clusters: Memcached, single-node Redis/Valkey, and replication group members || `DeleteCacheCluster` | Stop and remove a cache cluster || `CreateCacheSubnetGroup` | Create a cache subnet group |@@ -36,9 +40,42 @@ Floci manages real Valkey/Redis Docker containers and proxies TCP connections to| `ModifyCacheParameterGroup` | Set parameters on a group || `DescribeCacheParameters` | List the parameters set on a group || `DeleteCacheParameterGroup` | Delete a cache parameter group |-| `ListTagsForResource` | Tags on a parameter group ARN |+| `ListTagsForResource` | Read stored tags for supported ElastiCache resource ARNs |<!-- floci:actions:end -->+### Serverless caches and user groups++`CreateServerlessCache`, `DescribeServerlessCaches`, `ModifyServerlessCache` and+`DeleteServerlessCache` use the native AWS Query protocol. Valkey and Redis caches reuse the+existing single-node Valkey container and shared proxy port range. Memcached caches reuse the+existing Memcached container runtime. Their internal backing clusters are hidden from ordinary+cluster management APIs. `Endpoint` and `ReaderEndpoint` identify the same local runtime.++User groups support create, describe, modify and delete. Redis groups require a `default` user;+Valkey groups can be empty and accept authenticated Redis or Valkey users. Caches read the current+group membership and user credentials on each authentication. An attached empty group still+requires authentication and grants no access. Removing `UserGroupId` through `RemoveUserGroup`+allows anonymous connections. Attached groups cannot be deleted until their cache association+is removed. IAM authentication validates tokens against the public serverless cache name.++Descriptions, security groups, usage limits, snapshot schedules and user-group associations can+be modified without recreating the runtime or dropping cached values. Supplied subnets, security+groups and KMS keys must exist in the caller's account and region; network resources must belong+to one VPC. Names, settings, tags, owner account and runtime identity use the existing ElastiCache+storage mode. Restart recovery reserves proxy ports and restores authentication and endpoints;+the cache keyspace itself comes back empty, as for the other local cache runtimes.++Tags on a serverless cache are set at creation and are not editable afterwards, because+`AddTagsToResource` and `RemoveTagsFromResource` are not implemented for ElastiCache.++Local serverless caches have fixed capacity and plaintext TCP endpoints. Usage limits, subnet and+security-group placement, KMS encryption and snapshot schedules are metadata; they do not enable+autoscaling, VPC networking, encryption or snapshot storage. Snapshot restore and final snapshots+are rejected explicitly. Engine/version transitions are rejected; supported major versions are+Valkey 8, Redis 7 and Memcached 1.6. With Docker unavailable, metadata operations still work and+connections require a reachable Docker daemon and a runtime restart. Snapshot APIs and serverless+pagination are not implemented.+### Single-node Redis/Valkey clusters`CreateCacheCluster` serves three engines. `Engine=memcached` starts a Memcached container anddiff --git a/docs/services/index.md b/docs/services/index.mdindex be3277207b..69467179d3 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -60,7 +60,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac| [Amazon Connect](connect.md) | `/instance`, `/instance/{instanceId}/*`, `/tags/*` | REST JSON | 15 || [Amazon AppIntegrations](appintegrations.md) | `/eventIntegrations/*`, `/dataIntegrations/*`, `/tags/*` | REST JSON | 14 || [Amazon Data Lifecycle Manager](dlm.md) | `/policies`, `/policies/{policyId}`, `/tags/{resourceArn}` | REST JSON | 8 |-| [ElastiCache](elasticache.md) | `POST /` with `Action=` param + TCP proxy | Query + RESP | 26 |+| [ElastiCache](elasticache.md) | `POST /` with `Action=` param + TCP proxy | Query + RESP | 30 || [MemoryDB](memorydb.md) | `POST /` + `X-Amz-Target: AmazonMemoryDB.*` + TCP proxy | JSON 1.1 + RESP | 13 || [RDS](rds.md) | `POST /` with `Action=` param + TCP proxy | Query + wire | 90 || [RDS Data API](rds-data.md) | `/Execute`, `/BeginTransaction`, `/CommitTransaction`, `/RollbackTransaction` | REST JSON | 4 |diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.javaindex 14a87dbf6a..e785493afe 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java@@ -536,7 +536,8 @@ public class AwsQueryController {"ValidateIamAuthToken","CreateReplicationGroup", "DescribeReplicationGroups", "ModifyReplicationGroup", "DeleteReplicationGroup","CreateUser", "DescribeUsers", "ModifyUser", "DeleteUser",- "CreateUserGroup", "DescribeUserGroups", "ModifyUserGroup", "DeleteUserGroup"+ "CreateUserGroup", "DescribeUserGroups", "ModifyUserGroup", "DeleteUserGroup",+ "CreateServerlessCache", "DescribeServerlessCaches", "ModifyServerlessCache", "DeleteServerlessCache");private static final Set<String> CLOUDWATCH_ACTIONS = Set.of(diff --git a/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheMemcachedService.java b/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheMemcachedService.javaindex 0080bc84af..044f400274 100644--- a/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheMemcachedService.java+++ b/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheMemcachedService.java@@ -4,6 +4,7 @@ import com.fasterxml.jackson.core.type.TypeReference;import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;import io.github.hectorvent.floci.core.storage.StorageBackend;import io.github.hectorvent.floci.core.storage.StorageFactory;import io.github.hectorvent.floci.services.elasticache.container.ElastiCacheContainerHandle;@@ -37,7 +38,7 @@ public class ElastiCacheMemcachedService {private static final String DEFAULT_CACHE_NODE_TYPE = "cache.t4g.micro";private static final int MAX_CACHE_NODES = 40;- private final StorageBackend<String, CacheCluster> clusters;+ private final AccountAwareStorageBackend<CacheCluster> clusters;/*** The two stores {@link ElastiCacheService} writes, read here for the id check alone.* {@link StorageFactory#create} keys backends by file path and hands back the instance that@@ -79,6 +80,16 @@ public class ElastiCacheMemcachedService {* the members a Memcached cluster has are read; the rest are redis-only and ignored.*/public CacheCluster createCacheCluster(ElastiCacheService.CreateCacheClusterRequest request) {+ return createCacheCluster(request, null, null);+ }++ CacheCluster createServerlessBacking(ElastiCacheService.CreateCacheClusterRequest request,+ String cacheName, String accountId) {+ return createCacheCluster(request, cacheName, accountId);+ }++ private CacheCluster createCacheCluster(ElastiCacheService.CreateCacheClusterRequest request,+ String cacheName, String accountId) {String clusterId = request.cacheClusterId();if (request.numCacheNodes() != null && request.numCacheNodes() < 1) {throw new AwsException("InvalidParameterValue",@@ -102,13 +113,14 @@ public class ElastiCacheMemcachedService {"Cache cluster " + clusterId + " is already being created.", 400);}try {- return provisionCacheCluster(request);+ return provisionCacheCluster(request, cacheName, accountId);} finally {provisioningIds.release(clusterId);}}- private CacheCluster provisionCacheCluster(ElastiCacheService.CreateCacheClusterRequest request) {+ private CacheCluster provisionCacheCluster(ElastiCacheService.CreateCacheClusterRequest request,+ String cacheName, String accountId) {String clusterId = request.cacheClusterId();// Every store that answers DescribeCacheClusters, not just this one: two records sharing// an id would have one describe report it twice, each with a different engine.@@ -126,44 +138,67 @@ public class ElastiCacheMemcachedService {// so the cluster is created and reaches 'available' even when no Docker daemon is// reachable. Only connecting to the cache needs the container.ElastiCacheContainerHandle handle = containerManager.tryStart(clusterId, image, request.region());+ try {+ String endpointHost = resolveEndpointHost(handle);+ int endpointPort = handle != null ? handle.getPort() : BACKEND_PORT;+ Endpoint endpoint = new Endpoint(endpointHost, endpointPort);- String endpointHost = resolveEndpointHost(handle);- int endpointPort = handle != null ? handle.getPort() : BACKEND_PORT;- Endpoint endpoint = new Endpoint(endpointHost, endpointPort);-- CacheCluster cluster = new CacheCluster(- clusterId, CacheClusterStatus.AVAILABLE, ENGINE, ENGINE_VERSION,- endpoint, Instant.now());- // What terraform's aws_elasticache_cluster reads back: anything the request set and the- // describe omitted would be a diff no apply can settle.- cluster.setNumCacheNodes(request.numCacheNodes() != null ? request.numCacheNodes() : 1);- cluster.setCacheNodeType(request.cacheNodeType() != null && !request.cacheNodeType().isBlank()- ? request.cacheNodeType() : DEFAULT_CACHE_NODE_TYPE);- cluster.setCacheParameterGroupName(request.cacheParameterGroupName());- cluster.setCacheSubnetGroupName(request.cacheSubnetGroupName());- cluster.setNetworkType(request.networkType() != null && !request.networkType().isBlank()- ? request.networkType() : "ipv4");- cluster.setSecurityGroupIds(request.securityGroupIds() != null- ? new ArrayList<>(request.securityGroupIds()) : null);- cluster.setPreferredAvailabilityZone(request.preferredAvailabilityZone() != null- && !request.preferredAvailabilityZone().isBlank()- ? request.preferredAvailabilityZone() : regionResolver.getRegion() + "a");- cluster.setArn(regionResolver.buildArn("elasticache", request.region(), "cluster:" + clusterId));- cluster.setTags(request.tags());- if (handle != null) {- cluster.setContainerId(handle.getContainerId());- cluster.setContainerHost(handle.getHost());- cluster.setContainerPort(handle.getPort());- } else {- LOG.warnv("Memcached cluster {0} created without a backing container: no Docker daemon "- + "is reachable. Metadata operations work; connections to the cache do not "- + "until a daemon appears.", clusterId);+ CacheCluster cluster = new CacheCluster(+ clusterId, CacheClusterStatus.AVAILABLE, ENGINE, ENGINE_VERSION,+ endpoint, Instant.now());+ // What terraform's aws_elasticache_cluster reads back: anything the request set and the+ // describe omitted would be a diff no apply can settle.+ cluster.setNumCacheNodes(request.numCacheNodes() != null ? request.numCacheNodes() : 1);+ cluster.setCacheNodeType(request.cacheNodeType() != null && !request.cacheNodeType().isBlank()+ ? request.cacheNodeType() : DEFAULT_CACHE_NODE_TYPE);+ cluster.setCacheParameterGroupName(request.cacheParameterGroupName());+ cluster.setCacheSubnetGroupName(request.cacheSubnetGroupName());+ cluster.setNetworkType(request.networkType() != null && !request.networkType().isBlank()+ ? request.networkType() : "ipv4");+ cluster.setSecurityGroupIds(request.securityGroupIds() != null+ ? new ArrayList<>(request.securityGroupIds()) : null);+ cluster.setPreferredAvailabilityZone(request.preferredAvailabilityZone() != null+ && !request.preferredAvailabilityZone().isBlank()+ ? request.preferredAvailabilityZone() : regionResolver.getRegion() + "a");+ cluster.setArn(regionResolver.buildArn("elasticache", request.region(), "cluster:" + clusterId));+ cluster.setTags(request.tags());+ if (handle != null) {+ cluster.setContainerId(handle.getContainerId());+ cluster.setContainerHost(handle.getHost());+ cluster.setContainerPort(handle.getPort());+ } else {+ LOG.warnv("Memcached cluster {0} created without a backing container: no Docker daemon "+ + "is reachable. Metadata operations work; connections to the cache do not "+ + "until a daemon appears.", clusterId);+ }+ cluster.setRegion(request.region());+ cluster.setServerlessCacheName(cacheName);+ cluster.setOwnerAccountId(accountId);++ putRuntimeCluster(cluster);+ LOG.infov("Memcached cluster {0} created, endpoint={1}:{2}", clusterId, endpointHost, endpointPort);+ return cluster;+ } catch (RuntimeException e) {+ LOG.warnv("Memcached cluster {0} provisioning failed, rolling back: {1}", clusterId, e.getMessage());+ rollbackCacheCluster(clusterId, handle, accountId);+ throw e;}- cluster.setRegion(request.region());+ }- clusters.put(clusterId, cluster);- LOG.infov("Memcached cluster {0} created, endpoint={1}:{2}", clusterId, endpointHost, endpointPort);- return cluster;+ private void rollbackCacheCluster(String clusterId, ElastiCacheContainerHandle handle, String accountId) {+ try {+ if (handle != null) {+ containerManager.stop(handle);+ }+ } catch (RuntimeException e) {+ LOG.warnv("Error stopping container for Memcached cluster {0}: {1}", clusterId, e.getMessage());+ } finally {+ if (accountId == null) {+ clusters.delete(clusterId);+ } else {+ clusters.deleteForAccount(accountId, clusterId);+ }+ }}/**@@ -181,12 +216,15 @@ public class ElastiCacheMemcachedService {*/public CompletableFuture<Void> restorePersistedRuntime() {List<CacheCluster> toRestore = new ArrayList<>();- for (CacheCluster cluster : clusters.scan(k -> true)) {+ List<CacheCluster> records = new ArrayList<>(listCacheClusters(null));+ records.addAll(clusters.scanAllAccounts().stream()+ .filter(cluster -> cluster.getServerlessCacheName() != null).toList());+ for (CacheCluster cluster : records) {if (cluster.getCacheClusterStatus() == CacheClusterStatus.DELETING) {continue;}cluster.setCacheClusterStatus(CacheClusterStatus.CREATING);- clusters.put(cluster.getCacheClusterId(), cluster);+ putRuntimeCluster(cluster);toRestore.add(cluster);}if (toRestore.isEmpty()) {@@ -215,7 +253,7 @@ public class ElastiCacheMemcachedService {// to the default region.ElastiCacheContainerHandle handle = containerManager.tryStart(clusterId, image, cluster.getRegion());synchronized (lockFor(clusterId)) {- if (restoreTargetLost(clusterId)) {+ if (restoreTargetLost(cluster)) {abandonRestoredContainer(clusterId, handle);return;}@@ -236,7 +274,7 @@ public class ElastiCacheMemcachedService {+ "do not until a daemon appears.", clusterId);}cluster.setCacheClusterStatus(CacheClusterStatus.AVAILABLE);- clusters.put(clusterId, cluster);+ putRuntimeCluster(cluster);LOG.infov("Restored Memcached cluster {0}, endpoint={1}:{2}", clusterId,cluster.getConfigurationEndpoint().address(),String.valueOf(cluster.getConfigurationEndpoint().port()));@@ -255,7 +293,7 @@ public class ElastiCacheMemcachedService {private void failRestore(CacheCluster cluster, RuntimeException cause) {String clusterId = cluster.getCacheClusterId();synchronized (lockFor(clusterId)) {- if (restoreTargetLost(clusterId)) {+ if (restoreTargetLost(cluster)) {LOG.warnv(cause, "Failed to restore Memcached cluster {0}, which was deleted while "+ "it was being restored", clusterId);return;@@ -266,7 +304,7 @@ public class ElastiCacheMemcachedService {cluster.setCacheClusterStatus(CacheClusterStatus.RESTORE_FAILED);cluster.setConfigurationEndpoint(null);try {- clusters.put(clusterId, cluster);+ putRuntimeCluster(cluster);} catch (RuntimeException persistFailure) {cause.addSuppressed(persistFailure);}@@ -280,8 +318,9 @@ public class ElastiCacheMemcachedService {* under that same monitor, and putting the cluster back afterwards would resurrect one the* caller was told had been deleted.*/- private boolean restoreTargetLost(String clusterId) {- return clusters.get(clusterId)+ private boolean restoreTargetLost(CacheCluster cluster) {+ return (cluster.getOwnerAccountId() == null ? clusters.get(cluster.getCacheClusterId())+ : clusters.getForAccount(cluster.getOwnerAccountId(), cluster.getCacheClusterId())).map(current -> current.getCacheClusterStatus() == CacheClusterStatus.DELETING).orElse(true);}@@ -310,26 +349,36 @@ public class ElastiCacheMemcachedService {}public CacheCluster getCacheCluster(String clusterId) {- return clusters.get(clusterId).orElseThrow(() ->+ return clusters.get(clusterId).filter(cluster -> cluster.getServerlessCacheName() == null).orElseThrow(() ->new AwsException("CacheClusterNotFound","Cache cluster " + clusterId + " not found.", 404));}public Collection<CacheCluster> listCacheClusters(String filterClusterId) {if (filterClusterId != null && !filterClusterId.isBlank()) {- return clusters.get(filterClusterId)+ return clusters.get(filterClusterId).filter(cluster -> cluster.getServerlessCacheName() == null).map(List::of).orElseThrow(() -> new AwsException("CacheClusterNotFound","Cache cluster " + filterClusterId + " not found.", 404));}- return clusters.scan(k -> true);+ return clusters.scan(k -> true).stream().filter(cluster -> cluster.getServerlessCacheName() == null).toList();}public CacheCluster deleteCacheCluster(String clusterId) {+ return deleteCacheCluster(clusterId, false);+ }++ CacheCluster deleteServerlessBacking(String clusterId) {+ return deleteCacheCluster(clusterId, true);+ }++ private CacheCluster deleteCacheCluster(String clusterId, boolean internal) {// one monitor per cluster for delete and restore: a restore's read-modify-write could// otherwise write the cluster back after this removed itsynchronized (lockFor(clusterId)) {- CacheCluster cluster = getCacheCluster(clusterId);+ CacheCluster cluster = clusters.get(clusterId)+ .filter(record -> internal || record.getServerlessCacheName() == null).orElseThrow(() ->+ new AwsException("CacheClusterNotFound", "Cache cluster " + clusterId + " not found.", 404));cluster.setCacheClusterStatus(CacheClusterStatus.DELETING);clusters.put(clusterId, cluster);@@ -349,4 +398,17 @@ public class ElastiCacheMemcachedService {private String resolveEndpointHost(ElastiCacheContainerHandle handle) {return config.hostname().orElse(handle != null ? handle.getHost() : "localhost");}++ CacheCluster getServerlessBacking(String id, String accountId) {+ return clusters.getForAccount(accountId, id).filter(cluster -> cluster.getServerlessCacheName() != null)+ .orElseThrow(() -> new AwsException("CacheClusterNotFound", "Serverless backing cache not found.", 404));+ }++ private void putRuntimeCluster(CacheCluster cluster) {+ if (cluster.getOwnerAccountId() == null) {+ clusters.put(cluster.getCacheClusterId(), cluster);+ } else {+ clusters.putForAccount(cluster.getOwnerAccountId(), cluster.getCacheClusterId(), cluster);+ }+ }}diff --git a/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheQueryHandler.javaindex 66cc7c7e2e..534307cb2c 100644--- a/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheQueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheQueryHandler.java@@ -50,15 +50,18 @@ public class ElastiCacheQueryHandler {private final ElastiCacheService service;private final ElastiCacheMemcachedService memcachedService;private final RegionResolver regionResolver;+ private final ElastiCacheServerlessQueryHandler serverlessHandler;@Injectpublic ElastiCacheQueryHandler(SigV4Validator sigV4Validator, ElastiCacheService service,ElastiCacheMemcachedService memcachedService,- RegionResolver regionResolver) {+ RegionResolver regionResolver,+ ElastiCacheServerlessQueryHandler serverlessHandler) {this.sigV4Validator = sigV4Validator;this.service = service;this.memcachedService = memcachedService;this.regionResolver = regionResolver;+ this.serverlessHandler = serverlessHandler;}public Response handle(String action, MultivaluedMap<String, String> params, String region) {@@ -78,6 +81,8 @@ public class ElastiCacheQueryHandler {case "ModifyUserGroup" -> handleModifyUserGroup(params);case "DeleteUserGroup" -> handleDeleteUserGroup(params);case "CreateCacheCluster" -> handleCreateCacheCluster(params, region);+ case "CreateServerlessCache", "DescribeServerlessCaches", "ModifyServerlessCache", "DeleteServerlessCache" ->+ serverlessHandler.handle(action, params);case "DescribeCacheClusters" -> handleDescribeCacheClusters(params);case "DeleteCacheCluster" -> handleDeleteCacheCluster(params);case "CreateCacheSubnetGroup" -> handleCreateCacheSubnetGroup(params);@@ -396,7 +401,10 @@ public class ElastiCacheQueryHandler {xml.elem("member", replicationGroupId);}xml.end("ReplicationGroups");- xml.start("ServerlessCaches").end("ServerlessCaches");+ xml.raw(memberListXml("ServerlessCaches", g.getServerlessCacheEngines().keySet().stream()+ .map(key -> key.contains("/") ? key.substring(key.indexOf('/') + 1) : key)+ .distinct()+ .toList()));xml.elem("ARN", g.getArn());return xml.build();}@@ -762,6 +770,9 @@ private Response handleCreateCacheParameterGroup(MultivaluedMap<String, String>}Map<String, String> tags = Map.of();+ if ("serverlesscache".equals(arn[5])) {+ tags = serverlessHandler.getTags(arn[6]);+ }if ("replicationgroup".equals(arn[5])) {// the store keys groups by id alone; the record must be the one the ARN namesReplicationGroup group = service.getReplicationGroup(arn[6]);diff --git a/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheServerlessQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheServerlessQueryHandler.javanew file mode 100644index 0000000000..33ff04f92d--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheServerlessQueryHandler.java@@ -0,0 +1,208 @@+package io.github.hectorvent.floci.services.elasticache;++import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.AwsNamespaces;+import io.github.hectorvent.floci.core.common.AwsQueryResponse;+import io.github.hectorvent.floci.core.common.XmlBuilder;+import io.github.hectorvent.floci.services.elasticache.model.Endpoint;+import io.github.hectorvent.floci.services.elasticache.model.ServerlessCache;+import io.github.hectorvent.floci.services.elasticache.model.ServerlessCache.CacheUsageLimits;+import io.github.hectorvent.floci.services.elasticache.model.ServerlessCache.DataStorage;+import io.github.hectorvent.floci.services.elasticache.model.ServerlessCache.EcpuPerSecond;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import jakarta.ws.rs.core.MultivaluedMap;+import jakarta.ws.rs.core.Response;++import java.util.ArrayList;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++@ApplicationScoped+public class ElastiCacheServerlessQueryHandler {+ private final ElastiCacheServerlessService service;++ @Inject+ public ElastiCacheServerlessQueryHandler(ElastiCacheServerlessService service) {+ this.service = service;+ }++ public Response handle(String action, MultivaluedMap<String, String> params) {+ try {+ String name = params.getFirst("ServerlessCacheName");+ String body = switch (action) {+ case "CreateServerlessCache" -> cacheXml(service.createServerlessCache(+ new ElastiCacheServerlessService.CreateServerlessCacheRequest(name, params.getFirst("Engine"),+ params.getFirst("MajorEngineVersion"), params.getFirst("Description"),+ members(params, "SubnetIds"), members(params, "SecurityGroupIds"), params.getFirst("UserGroupId"),+ params.getFirst("KmsKeyId"), usageLimits(params), integer(params, "SnapshotRetentionLimit"),+ params.getFirst("DailySnapshotTime"), members(params, "SnapshotArnsToRestore"), tags(params))));+ case "ModifyServerlessCache" -> cacheXml(service.modifyServerlessCache(+ new ElastiCacheServerlessService.ModifyServerlessCacheRequest(name, params.getFirst("Description"),+ params.getFirst("Engine"), params.getFirst("MajorEngineVersion"),+ present(params, "SecurityGroupIds") ? members(params, "SecurityGroupIds") : null,+ params.getFirst("UserGroupId"), bool(params, "RemoveUserGroup"), usageLimits(params),+ integer(params, "SnapshotRetentionLimit"), params.getFirst("DailySnapshotTime"))));+ case "DeleteServerlessCache" -> cacheXml(service.deleteServerlessCache(name, params.getFirst("FinalSnapshotName")));+ case "DescribeServerlessCaches" -> {+ XmlBuilder xml = new XmlBuilder().start("ServerlessCaches");+ for (ServerlessCache cache : service.describeServerlessCaches(name)) {+ xml.start("member").raw(cacheFields(cache)).end("member");+ }+ yield xml.end("ServerlessCaches").build();+ }+ default -> throw new AwsException("UnsupportedOperation", "Unsupported serverless cache action.", 400);+ };+ return Response.ok(AwsQueryResponse.envelope(action, AwsNamespaces.EC, body)).build();+ } catch (AwsException exception) {+ return AwsQueryResponse.error(exception.getErrorCode(), exception.getMessage(), AwsNamespaces.EC, exception.getHttpStatus());+ }+ }++ public Map<String, String> getTags(String name) {+ return service.getServerlessCache(name).getTags();+ }++ private static String cacheXml(ServerlessCache cache) {+ return new XmlBuilder().start("ServerlessCache").raw(cacheFields(cache)).end("ServerlessCache").build();+ }++ private static String cacheFields(ServerlessCache cache) {+ XmlBuilder xml = new XmlBuilder().elem("ServerlessCacheName", cache.getServerlessCacheName())+ .elem("Description", cache.getDescription()).elem("Status", cache.getStatus()).elem("Engine", cache.getEngine())+ .elem("MajorEngineVersion", cache.getMajorEngineVersion()).elem("FullEngineVersion", cache.getFullEngineVersion())+ .elem("ARN", cache.getArn()).elem("CreateTime", cache.getCreateTime().toString());+ optional(xml, "UserGroupId", cache.getUserGroupId());+ optional(xml, "KmsKeyId", cache.getKmsKeyId());+ optional(xml, "SnapshotRetentionLimit", cache.getSnapshotRetentionLimit());+ optional(xml, "DailySnapshotTime", cache.getDailySnapshotTime());+ endpoint(xml, "Endpoint", cache.getEndpoint());+ endpoint(xml, "ReaderEndpoint", cache.getReaderEndpoint());+ list(xml, "SubnetIds", cache.getSubnetIds());+ list(xml, "SecurityGroupIds", cache.getSecurityGroupIds());+ CacheUsageLimits limits = cache.getCacheUsageLimits();+ if (limits != null) {+ xml.start("CacheUsageLimits");+ if (limits.dataStorage() != null) {+ xml.start("DataStorage");+ optional(xml, "Minimum", limits.dataStorage().minimum());+ optional(xml, "Maximum", limits.dataStorage().maximum());+ optional(xml, "Unit", limits.dataStorage().unit());+ xml.end("DataStorage");+ }+ if (limits.ecpuPerSecond() != null) {+ xml.start("ECPUPerSecond");+ optional(xml, "Minimum", limits.ecpuPerSecond().minimum());+ optional(xml, "Maximum", limits.ecpuPerSecond().maximum());+ xml.end("ECPUPerSecond");+ }+ xml.end("CacheUsageLimits");+ }+ return xml.build();+ }++ private static void optional(XmlBuilder xml, String name, Object value) {+ if (value != null) {+ xml.elem(name, value.toString());+ }+ }++ private static void endpoint(XmlBuilder xml, String name, Endpoint endpoint) {+ if (endpoint != null) {+ xml.start(name).elem("Address", endpoint.address()).elem("Port", String.valueOf(endpoint.port())).end(name);+ }+ }++ private static void list(XmlBuilder xml, String name, List<String> values) {+ xml.start(name);+ for (String value : values) {+ xml.elem(memberName(name), value);+ }+ xml.end(name);+ }++ private static boolean present(MultivaluedMap<String, String> params, String prefix) {+ return params.keySet().stream().anyMatch(key -> key.equals(prefix) || key.startsWith(prefix + "."));+ }++ private static List<String> members(MultivaluedMap<String, String> params, String name) {+ List<String> result = new ArrayList<>();+ for (int index = 1; ; index++) {+ String value = params.getFirst(name + "." + memberName(name) + "." + index);+ if (value == null) {+ value = params.getFirst(name + ".member." + index);+ }+ if (value == null) {+ break;+ }+ result.add(value);+ }+ return result;+ }++ private static String memberName(String name) {+ return switch (name) {+ case "SubnetIds" -> "SubnetId";+ case "SecurityGroupIds" -> "SecurityGroupId";+ case "SnapshotArnsToRestore" -> "SnapshotArn";+ default -> "member";+ };+ }++ private static Map<String, String> tags(MultivaluedMap<String, String> params) {+ Map<String, String> result = new LinkedHashMap<>();+ for (int index = 1; ; index++) {+ String key = params.getFirst("Tags.Tag." + index + ".Key");+ String value = params.getFirst("Tags.Tag." + index + ".Value");+ if (key == null && value == null) {+ key = params.getFirst("Tags.member." + index + ".Key");+ value = params.getFirst("Tags.member." + index + ".Value");+ }+ if (key == null && value == null) {+ break;+ }+ if (key == null || key.isBlank()) {+ throw new AwsException("InvalidParameterValue", "Tag key cannot be null or empty.", 400);+ }+ result.put(key, value == null ? "" : value);+ }+ return result;+ }++ private static Integer integer(MultivaluedMap<String, String> params, String name) {+ String value = params.getFirst(name);+ if (value == null) {+ return null;+ }+ try {+ return Integer.valueOf(value);+ } catch (NumberFormatException exception) {+ throw new AwsException("InvalidParameterValue", name + " must be an integer.", 400);+ }+ }++ private static Boolean bool(MultivaluedMap<String, String> params, String name) {+ String value = params.getFirst(name);+ if (value == null) {+ return null;+ }+ if (!"true".equalsIgnoreCase(value) && !"false".equalsIgnoreCase(value)) {+ throw new AwsException("InvalidParameterValue", name + " must be true or false.", 400);+ }+ return Boolean.valueOf(value);+ }++ private static CacheUsageLimits usageLimits(MultivaluedMap<String, String> params) {+ if (!present(params, "CacheUsageLimits")) {+ return null;+ }+ DataStorage storage = present(params, "CacheUsageLimits.DataStorage")+ ? new DataStorage(integer(params, "CacheUsageLimits.DataStorage.Minimum"),+ integer(params, "CacheUsageLimits.DataStorage.Maximum"), params.getFirst("CacheUsageLimits.DataStorage.Unit")) : null;+ EcpuPerSecond ecpu = present(params, "CacheUsageLimits.ECPUPerSecond")+ ? new EcpuPerSecond(integer(params, "CacheUsageLimits.ECPUPerSecond.Minimum"),+ integer(params, "CacheUsageLimits.ECPUPerSecond.Maximum")) : null;+ return new CacheUsageLimits(storage, ecpu);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheServerlessService.java b/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheServerlessService.javanew file mode 100644index 0000000000..995c22848a--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheServerlessService.java@@ -0,0 +1,411 @@+package io.github.hectorvent.floci.services.elasticache;++import com.fasterxml.jackson.core.type.TypeReference;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.common.Resettable;+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.elasticache.model.AuthMode;+import io.github.hectorvent.floci.services.elasticache.model.CacheCluster;+import io.github.hectorvent.floci.services.elasticache.model.ServerlessCache;+import io.github.hectorvent.floci.services.elasticache.model.ServerlessCache.CacheUsageLimits;+import io.github.hectorvent.floci.services.elasticache.model.ServerlessCache.DataStorage;+import io.github.hectorvent.floci.services.elasticache.model.ServerlessCache.EcpuPerSecond;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;++import java.time.Instant;+import java.util.List;+import java.util.Locale;+import java.util.Map;+import java.util.Objects;+import java.util.UUID;+import java.util.concurrent.ConcurrentHashMap;++@ApplicationScoped+public class ElastiCacheServerlessService implements Resettable {+ private static final Logger LOG = Logger.getLogger(ElastiCacheServerlessService.class);++ private final AccountAwareStorageBackend<ServerlessCache> caches;+ private final RegionResolver resolver;+ private final ElastiCacheService runtime;+ private final ElastiCacheMemcachedService memcached;+ private final ElastiCacheService groups;+ private final ConcurrentHashMap<String, Object> locks = new ConcurrentHashMap<>();++ @Inject+ public ElastiCacheServerlessService(StorageFactory factory, RegionResolver resolver, ElastiCacheService runtime,+ ElastiCacheMemcachedService memcached, ElastiCacheService groups) {+ this.caches = factory.create("elasticache", "elasticache-serverless-caches.json",+ new TypeReference<Map<String, ServerlessCache>>() {});+ this.resolver = resolver;+ this.runtime = runtime;+ this.memcached = memcached;+ this.groups = groups;+ }++ public record CreateServerlessCacheRequest(String serverlessCacheName, String engine, String majorEngineVersion,+ String description, List<String> subnetIds, List<String> securityGroupIds,+ String userGroupId, String kmsKeyId, CacheUsageLimits cacheUsageLimits,+ Integer snapshotRetentionLimit, String dailySnapshotTime,+ List<String> snapshotArnsToRestore, Map<String, String> tags) {}++ public record ModifyServerlessCacheRequest(String serverlessCacheName, String description, String engine,+ String majorEngineVersion, List<String> securityGroupIds,+ String userGroupId, Boolean removeUserGroup, CacheUsageLimits cacheUsageLimits,+ Integer snapshotRetentionLimit, String dailySnapshotTime) {}++ public ServerlessCache createServerlessCache(CreateServerlessCacheRequest request) {+ String name = normalizedName(request.serverlessCacheName());+ String engine = normalizedEngine(request.engine());+ String major = request.majorEngineVersion() == null ? defaultMajor(engine) : request.majorEngineVersion();+ if (!defaultMajor(engine).equals(major)) {+ throw invalid("Only engine version " + defaultMajor(engine) + " is supported for " + engine + ".");+ }+ validateMetadata(request.description(), request.cacheUsageLimits(), request.snapshotRetentionLimit(),+ request.dailySnapshotTime());+ if (request.snapshotArnsToRestore() != null && !request.snapshotArnsToRestore().isEmpty()) {+ throw invalid("Snapshot restore is not supported locally.");+ }+ if (request.tags() != null && request.tags().size() > 50) {+ throw new AwsException("TagQuotaPerResourceExceeded", "At most 50 tags are supported.", 400);+ }+ String rawGroup = request.userGroupId();+ String group = normalizedUserGroupId(rawGroup);+ String region = resolver.getRegion();+ validateGroup(group, engine, region);+ runtime.validateServerlessDependencies(request.subnetIds(), request.securityGroupIds(), request.kmsKeyId(), region);+ synchronized (lockFor(name)) {+ if (caches.get(key(name)).isPresent()) {+ throw new AwsException("ServerlessCacheAlreadyExistsFault", "Serverless cache " + name + " already exists.", 400);+ }+ boolean attached = false;+ CacheCluster backing = null;+ try {+ if (group != null) {+ groups.attachServerlessCache(group, key(name), engine);+ attached = true;+ }+ String runtimeId = "serverless-" + UUID.randomUUID();+ ElastiCacheService.CreateCacheClusterRequest backingRequest = new ElastiCacheService.CreateCacheClusterRequest(+ runtimeId, engine, null, null, 1, null, AuthMode.NO_AUTH, null, null, null,+ 0, null, null, null, null, null, null, false, region, Map.of());+ String account = resolver.getAccountId();+ backing = "memcached".equals(engine)+ ? memcached.createServerlessBacking(backingRequest, name, account)+ : runtime.createServerlessBacking(backingRequest, name, account, group);+ ServerlessCache cache = new ServerlessCache();+ cache.setServerlessCacheName(name);+ cache.setEngine(engine);+ cache.setMajorEngineVersion(major);+ cache.setFullEngineVersion(backing.getEngineVersion());+ cache.setDescription(request.description() == null ? "" : request.description());+ cache.setStatus("available");+ cache.setCreateTime(Instant.now());+ cache.setArn(resolver.buildArn("elasticache", region, "serverlesscache:" + name));+ cache.setEndpoint(backing.getConfigurationEndpoint());+ cache.setReaderEndpoint(backing.getConfigurationEndpoint());+ cache.setRegion(region);+ cache.setAccountId(account);+ cache.setBackingCacheClusterId(runtimeId);+ cache.setSubnetIds(request.subnetIds());+ cache.setSecurityGroupIds(request.securityGroupIds());+ cache.setUserGroupId(group);+ cache.setKmsKeyId(request.kmsKeyId());+ cache.setCacheUsageLimits(request.cacheUsageLimits());+ cache.setSnapshotRetentionLimit(request.snapshotRetentionLimit() == null ? 0 : request.snapshotRetentionLimit());+ cache.setDailySnapshotTime(request.dailySnapshotTime());+ cache.setTags(request.tags());+ caches.put(key(name), cache);+ return copy(cache);+ } catch (RuntimeException exception) {+ // Each step runs on its own so a failed backing delete never leaves the group attached.+ if (backing != null) {+ try {+ deleteBacking(engine, backing.getCacheClusterId());+ } catch (RuntimeException cleanupFailure) {+ exception.addSuppressed(cleanupFailure);+ }+ }+ if (attached) {+ try {+ groups.detachServerlessCache(group, key(name));+ } catch (RuntimeException cleanupFailure) {+ exception.addSuppressed(cleanupFailure);+ }+ }+ throw exception;+ }+ }+ }++ public ServerlessCache getServerlessCache(String name) {+ String normalized = normalizedName(name);+ synchronized (lockFor(normalized)) {+ return current(requireCache(normalized));+ }+ }++ public List<ServerlessCache> describeServerlessCaches(String name) {+ if (name != null && !name.isBlank()) {+ return List.of(getServerlessCache(name));+ }+ return caches.scan(key -> key.startsWith(resolver.getRegion() + "/")).stream()+ .map(this::currentOrStored).toList();+ }++ public ServerlessCache modifyServerlessCache(ModifyServerlessCacheRequest request) {+ String name = normalizedName(request.serverlessCacheName());+ validateMetadata(request.description(), request.cacheUsageLimits(), request.snapshotRetentionLimit(),+ request.dailySnapshotTime());+ if (Boolean.TRUE.equals(request.removeUserGroup()) && request.userGroupId() != null) {+ throw new AwsException("InvalidParameterCombination", "UserGroupId and RemoveUserGroup conflict.", 400);+ }+ synchronized (lockFor(name)) {+ ServerlessCache previous = requireCache(name);+ if (request.securityGroupIds() != null) {+ runtime.validateServerlessDependencies(previous.getSubnetIds(), request.securityGroupIds(), null, previous.getRegion());+ }+ if (request.engine() != null && !previous.getEngine().equals(normalizedEngine(request.engine()))+ || request.majorEngineVersion() != null && !previous.getMajorEngineVersion().equals(request.majorEngineVersion())) {+ throw invalid("Changing engine or engine version is not supported locally.");+ }+ ServerlessCache updated = copy(previous);+ String group = Boolean.TRUE.equals(request.removeUserGroup()) ? null+ : request.userGroupId() == null ? previous.getUserGroupId() : normalizedUserGroupId(request.userGroupId());+ validateGroup(group, previous.getEngine(), previous.getRegion());+ boolean changedGroup = !Objects.equals(group, previous.getUserGroupId());+ if (changedGroup && group != null) {+ groups.attachServerlessCache(group, key(name), previous.getEngine());+ }+ try {+ if (changedGroup && !"memcached".equals(previous.getEngine())) {+ runtime.updateServerlessUserGroup(previous.getBackingCacheClusterId(), previous.getAccountId(), group);+ }+ updated.setUserGroupId(group);+ if (request.description() != null) {+ updated.setDescription(request.description());+ }+ if (request.securityGroupIds() != null) {+ updated.setSecurityGroupIds(request.securityGroupIds());+ }+ if (request.cacheUsageLimits() != null) {+ updated.setCacheUsageLimits(request.cacheUsageLimits());+ }+ if (request.snapshotRetentionLimit() != null) {+ updated.setSnapshotRetentionLimit(request.snapshotRetentionLimit());+ }+ if (request.dailySnapshotTime() != null) {+ updated.setDailySnapshotTime(request.dailySnapshotTime());+ }+ caches.put(key(name), updated);+ } catch (RuntimeException exception) {+ if (changedGroup) {+ try {+ runtime.updateServerlessUserGroup(previous.getBackingCacheClusterId(), previous.getAccountId(), previous.getUserGroupId());+ if (group != null) {+ groups.detachServerlessCache(group, key(name));+ }+ } catch (RuntimeException rollbackFailure) {+ exception.addSuppressed(rollbackFailure);+ }+ }+ throw exception;+ }+ if (changedGroup && previous.getUserGroupId() != null) {+ groups.detachServerlessCache(previous.getUserGroupId(), key(name));+ }+ return current(updated);+ }+ }++ public ServerlessCache deleteServerlessCache(String name) {+ return deleteServerlessCache(name, null);+ }++ public ServerlessCache deleteServerlessCache(String name, String finalSnapshotName) {+ if (finalSnapshotName != null) {+ throw invalid("Final snapshots are not supported locally.");+ }+ String normalized = normalizedName(name);+ synchronized (lockFor(normalized)) {+ ServerlessCache cache = requireCache(normalized);+ try {+ deleteBacking(cache.getEngine(), cache.getBackingCacheClusterId());+ } catch (AwsException e) {+ if (!"CacheClusterNotFound".equals(e.getErrorCode())) {+ throw e;+ }+ LOG.warnv("Backing cluster {0} of serverless cache {1} is already gone, finishing the delete",+ cache.getBackingCacheClusterId(), normalized);+ }+ if (cache.getUserGroupId() != null) {+ groups.detachServerlessCache(cache.getUserGroupId(), key(normalized));+ }+ caches.delete(key(normalized));+ ServerlessCache deleted = copy(cache);+ deleted.setStatus("deleting");+ return deleted;+ }+ }++ private void deleteBacking(String engine, String id) {+ if ("memcached".equals(engine)) {+ memcached.deleteServerlessBacking(id);+ } else {+ runtime.deleteServerlessBacking(id);+ }+ }++ private ServerlessCache current(ServerlessCache cache) {+ ServerlessCache snapshot = copy(cache);+ CacheCluster backing = "memcached".equals(cache.getEngine())+ ? memcached.getServerlessBacking(cache.getBackingCacheClusterId(), cache.getAccountId())+ : runtime.getServerlessBacking(cache.getBackingCacheClusterId(), cache.getAccountId());+ snapshot.setEndpoint(backing.getConfigurationEndpoint());+ snapshot.setReaderEndpoint(backing.getConfigurationEndpoint());+ snapshot.setStatus(backing.getCacheClusterStatus().wireName());+ return snapshot;+ }++ private ServerlessCache currentOrStored(ServerlessCache cache) {+ try {+ return current(cache);+ } catch (AwsException e) {+ LOG.warnv("Serverless cache {0} has no backing cluster, listing its stored state: {1}",+ cache.getServerlessCacheName(), e.getMessage());+ return copy(cache);+ }+ }++ private ServerlessCache requireCache(String name) {+ return caches.get(key(name)).orElseThrow(() -> new AwsException("ServerlessCacheNotFoundFault",+ "Serverless cache " + name + " not found.", 404));+ }++ private String key(String name) {+ return resolver.getRegion() + "/" + name;+ }++ private Object lockFor(String name) {+ return locks.computeIfAbsent(resolver.getAccountId() + "/" + key(name), key -> new Object());+ }++ private void validateGroup(String group, String engine, String region) {+ if (group == null) {+ return;+ }+ if ("memcached".equals(engine)) {+ throw new AwsException("InvalidParameterCombination", "Memcached does not support user groups.", 400);+ }+ groups.validateServerlessAssociation(group, engine);+ }++ private static String normalizedName(String name) {+ if (name == null || !name.matches("[a-zA-Z][a-zA-Z0-9-]{0,39}") || name.endsWith("-") || name.contains("--")) {+ throw invalid("ServerlessCacheName must contain 1 to 40 letters, digits and hyphens and begin with a letter.");+ }+ return name.toLowerCase(Locale.ROOT);+ }++ private static String normalizedUserGroupId(String userGroupId) {+ return userGroupId == null ? null : userGroupId.toLowerCase(Locale.ROOT);+ }++ private static String normalizedEngine(String engine) {+ if (engine == null || !List.of("valkey", "redis", "memcached").contains(engine.toLowerCase(Locale.ROOT))) {+ throw invalid("Engine must be valkey, redis or memcached.");+ }+ return engine.toLowerCase(Locale.ROOT);+ }++ private static String defaultMajor(String engine) {+ return switch (engine) {+ case "valkey" -> "8";+ case "redis" -> "7";+ default -> "1.6";+ };+ }++ private static void validateMetadata(String description, CacheUsageLimits limits, Integer retention, String time) {+ if (description != null && description.length() > 255) {+ throw invalid("Description cannot exceed 255 characters.");+ }+ if (retention != null && (retention < 0 || retention > 35)) {+ throw invalid("SnapshotRetentionLimit must be between 0 and 35.");+ }+ if (time != null && !time.matches("(?:[01][0-9]|2[0-3]):[0-5][0-9]")) {+ throw invalid("DailySnapshotTime must be HH:mm.");+ }+ if (limits != null) {+ DataStorage storage = limits.dataStorage();+ if (storage != null) {+ if (!"GB".equals(storage.unit())) {+ throw invalid("DataStorage.Unit must be GB.");+ }+ validateBounds(storage.minimum(), storage.maximum());+ }+ EcpuPerSecond ecpu = limits.ecpuPerSecond();+ if (ecpu != null) {+ validateBounds(ecpu.minimum(), ecpu.maximum());+ }+ }+ }++ private static void validateBounds(Integer minimum, Integer maximum) {+ if (minimum != null && minimum < 0 || maximum != null && maximum < 1+ || minimum != null && maximum != null && minimum > maximum) {+ throw invalid("Usage limits must be nonnegative and minimum cannot exceed maximum.");+ }+ }++ private static AwsException invalid(String message) {+ return new AwsException("InvalidParameterValue", message, 400);+ }++ @Override+ public void clear() {+ for (ServerlessCache cache : caches.scanAllAccounts()) {+ try {+ deleteBacking(cache.getEngine(), cache.getBackingCacheClusterId());+ } catch (RuntimeException e) {+ LOG.warnv(e, "Could not release backing cluster {0} of serverless cache {1} on reset",+ cache.getBackingCacheClusterId(), cache.getServerlessCacheName());+ }+ if (cache.getUserGroupId() != null) {+ groups.detachServerlessCache(cache.getUserGroupId(),+ cache.getRegion() + "/" + cache.getServerlessCacheName());+ }+ }+ caches.clear();+ }++ private static ServerlessCache copy(ServerlessCache cache) {+ ServerlessCache copy = new ServerlessCache();+ copy.setServerlessCacheName(cache.getServerlessCacheName());+ copy.setEngine(cache.getEngine());+ copy.setMajorEngineVersion(cache.getMajorEngineVersion());+ copy.setFullEngineVersion(cache.getFullEngineVersion());+ copy.setDescription(cache.getDescription());+ copy.setStatus(cache.getStatus());+ copy.setArn(cache.getArn());+ copy.setCreateTime(cache.getCreateTime());+ copy.setEndpoint(cache.getEndpoint());+ copy.setReaderEndpoint(cache.getReaderEndpoint());+ copy.setRegion(cache.getRegion());+ copy.setAccountId(cache.getAccountId());+ copy.setBackingCacheClusterId(cache.getBackingCacheClusterId());+ copy.setUserGroupId(cache.getUserGroupId());+ copy.setKmsKeyId(cache.getKmsKeyId());+ copy.setSnapshotRetentionLimit(cache.getSnapshotRetentionLimit());+ copy.setDailySnapshotTime(cache.getDailySnapshotTime());+ copy.setCacheUsageLimits(cache.getCacheUsageLimits());+ copy.setSubnetIds(cache.getSubnetIds());+ copy.setSecurityGroupIds(cache.getSecurityGroupIds());+ copy.setTags(cache.getTags());+ return copy;+ }++}diff --git a/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheService.java b/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheService.javaindex 5a0fc9db0d..dc33ee5f53 100644--- a/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheService.java+++ b/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheService.java@@ -13,6 +13,7 @@ import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;import io.github.hectorvent.floci.core.storage.StorageBackend;import io.github.hectorvent.floci.core.storage.StorageFactory;import io.github.hectorvent.floci.services.ec2.Ec2Service;+import io.github.hectorvent.floci.services.ec2.model.SecurityGroup;import io.github.hectorvent.floci.services.ec2.model.Subnet;import io.github.hectorvent.floci.services.elasticache.container.ElastiCacheContainerHandle;import io.github.hectorvent.floci.services.elasticache.container.ElastiCacheContainerManager;@@ -33,6 +34,8 @@ import io.github.hectorvent.floci.services.elasticache.proxy.ElastiCacheAuthProximport io.github.hectorvent.floci.services.elasticache.proxy.ElastiCacheProxyManager;import io.github.hectorvent.floci.services.kms.KmsService;import io.github.hectorvent.floci.services.kms.model.KmsKey;+import io.github.hectorvent.floci.services.kms.model.KmsKeySpec;+import io.github.hectorvent.floci.services.kms.model.KmsKeyUsage;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import org.jboss.logging.Logger;@@ -66,7 +69,7 @@ public class ElastiCacheService implements ResourceProvider {private static final Logger LOG = Logger.getLogger(ElastiCacheService.class);private final StorageBackend<String, ReplicationGroup> groups;- private final StorageBackend<String, CacheCluster> cacheClusters;+ private final AccountAwareStorageBackend<CacheCluster> cacheClusters;/*** The Memcached cluster store, the one {@link ElastiCacheMemcachedService} writes.* {@link StorageFactory#create} keys backends by file path and hands the second caller the@@ -74,7 +77,7 @@ public class ElastiCacheService implements ResourceProvider {* is one namespace whatever engine claims it, and only a reader of both can say it is free.*/private final StorageBackend<String, CacheCluster> memcachedClusters;- private final StorageBackend<String, ElastiCacheUser> users;+ private final AccountAwareStorageBackend<ElastiCacheUser> users;private final AccountAwareStorageBackend<ElastiCacheUserGroup> userGroups;private final AccountAwareStorageBackend<CacheParameterGroup> parameterGroups;private final StorageBackend<String, CacheSubnetGroup> subnetGroups;@@ -659,12 +662,12 @@ public class ElastiCacheService implements ResourceProvider {}groups.put(group.getReplicationGroupId(), group);}- for (CacheCluster cluster : cacheClusters.scan(k -> true)) {+ for (CacheCluster cluster : runtimeCacheClusters()) {if (cluster.getCacheClusterStatus() == CacheClusterStatus.DELETING) {continue;}reserveCacheCluster(cluster, cacheClustersToRestore);- cacheClusters.put(cluster.getCacheClusterId(), cluster);+ putRuntimeCluster(cluster);}if (clusterModeToRestore.isEmpty() && singleNodeToRestore.isEmpty()&& cacheClustersToRestore.isEmpty()) {@@ -774,7 +777,7 @@ public class ElastiCacheService implements ResourceProvider {try {ElastiCacheContainerHandle handle = containerManager.tryStart(clusterId, image, regionOf(cluster.getArn()));synchronized (lockFor("cc:" + clusterId)) {- if (cacheClusterRestoreTargetLost(clusterId)) {+ if (cacheClusterRestoreTargetLost(cluster)) {abandonRestoredCacheClusterContainer(clusterId, handle);return;}@@ -782,9 +785,7 @@ public class ElastiCacheService implements ResourceProvider {cluster.setContainerId(handle.getContainerId());cluster.setContainerHost(handle.getHost());cluster.setContainerPort(handle.getPort());- proxyManager.startProxy(clusterId, cluster.getAuthMode(),- cluster.getConfigurationEndpoint().port(), handle.getHost(), handle.getPort(),- (username, password) -> validateCacheClusterPassword(clusterId, username, password));+ startCacheClusterProxy(cluster, handle);} else {// Cleared rather than left alone: whatever the record carried describes a// container from the previous process, and nothing must read it as live.@@ -796,7 +797,7 @@ public class ElastiCacheService implements ResourceProvider {+ "the cache do not until a daemon appears.", clusterId);}cluster.setCacheClusterStatus(CacheClusterStatus.AVAILABLE);- cacheClusters.put(clusterId, cluster);+ putRuntimeCluster(cluster);LOG.infov("Restored cache cluster {0}, endpoint={1}:{2}", clusterId,cluster.getConfigurationEndpoint().address(),String.valueOf(cluster.getConfigurationEndpoint().port()));@@ -811,8 +812,8 @@ public class ElastiCacheService implements ResourceProvider {* Callers must hold the cluster's monitor, for the reason given on* {@link #restoreTargetLost}.*/- private boolean cacheClusterRestoreTargetLost(String clusterId) {- return cacheClusters.get(clusterId)+ private boolean cacheClusterRestoreTargetLost(CacheCluster cluster) {+ return runtimeCluster(cluster.getCacheClusterId(), cluster.getOwnerAccountId()).map(current -> current.getCacheClusterStatus() == CacheClusterStatus.DELETING).orElse(true);}@@ -859,7 +860,7 @@ public class ElastiCacheService implements ResourceProvider {} catch (RuntimeException e) {LOG.warnv("Error stopping container for cache cluster {0}: {1}", clusterId, e.getMessage());}- if (cacheClusterRestoreTargetLost(clusterId)) {+ if (cacheClusterRestoreTargetLost(cluster)) {LOG.warnv(cause, "Failed to restore cache cluster {0}, which was deleted while it "+ "was being restored", clusterId);return;@@ -874,7 +875,7 @@ public class ElastiCacheService implements ResourceProvider {cluster.setCacheClusterStatus(CacheClusterStatus.RESTORE_FAILED);cluster.setConfigurationEndpoint(null);try {- cacheClusters.put(clusterId, cluster);+ putRuntimeCluster(cluster);} catch (RuntimeException persistFailure) {cause.addSuppressed(persistFailure);}@@ -1234,6 +1235,62 @@ public class ElastiCacheService implements ResourceProvider {}public CacheCluster createCacheCluster(CreateCacheClusterRequest request) {+ return createCacheCluster(request, null, null, null);+ }++ CacheCluster createServerlessBacking(CreateCacheClusterRequest request, String cacheName,+ String accountId, String userGroupId) {+ return createCacheCluster(request, cacheName, accountId, userGroupId);+ }++ void validateServerlessDependencies(List<String> subnetIds, List<String> securityGroupIds,+ String kmsKeyId, String region) {+ String vpc = null;+ if (subnetIds != null && !subnetIds.isEmpty()) {+ List<Subnet> resolved = ec2Service.describeSubnets(region, subnetIds, Map.of());+ if (new HashSet<>(subnetIds).size() != subnetIds.size() || resolved.size() != subnetIds.size()) {+ throw new AwsException("InvalidParameterValue", "SubnetIds contain duplicate or missing subnets.", 400);+ }+ vpc = resolved.getFirst().getVpcId();+ for (Subnet subnet : resolved) {+ if (!vpc.equals(subnet.getVpcId())) {+ throw new AwsException("InvalidParameterValue", "All subnets must belong to the same VPC.", 400);+ }+ }+ }+ if (securityGroupIds != null && !securityGroupIds.isEmpty()) {+ List<SecurityGroup> resolved = ec2Service.describeSecurityGroups(region, securityGroupIds, List.of(), Map.of());+ if (new HashSet<>(securityGroupIds).size() != securityGroupIds.size() || resolved.size() != securityGroupIds.size()) {+ throw new AwsException("InvalidParameterValue", "SecurityGroupIds contain duplicate or missing groups.", 400);+ }+ if (vpc == null) {+ vpc = resolved.getFirst().getVpcId();+ }+ for (SecurityGroup group : resolved) {+ if (!vpc.equals(group.getVpcId())) {+ throw new AwsException("InvalidParameterValue", "Security groups and subnets must belong to the same VPC.", 400);+ }+ }+ }+ if (kmsKeyId != null) {+ KmsKey key;+ try {+ key = kmsService.describeKey(kmsKeyId, region);+ } catch (AwsException exception) {+ if ("NotFoundException".equals(exception.getErrorCode())) {+ throw new AwsException("InvalidParameterValue", "KmsKeyId does not identify a key in this account and region.", 400);+ }+ throw exception;+ }+ if (!key.isEnabled() || key.getKeySpec() != KmsKeySpec.SYMMETRIC_DEFAULT+ || key.getKeyUsage() != KmsKeyUsage.ENCRYPT_DECRYPT) {+ throw new AwsException("InvalidParameterValue", "KmsKeyId must identify an enabled symmetric encryption key.", 400);+ }+ }+ }++ private CacheCluster createCacheCluster(CreateCacheClusterRequest request, String cacheName,+ String accountId, String userGroupId) {String clusterId = request.cacheClusterId();String engine = normalizeEngine(request.engine());if (request.numCacheNodes() != null && request.numCacheNodes() != 1) {@@ -1258,7 +1315,7 @@ public class ElastiCacheService implements ResourceProvider {"Cache cluster " + clusterId + " is already being created.", 400);}try {- return provisionCacheCluster(request, engine);+ return provisionCacheCluster(request, engine, cacheName, accountId, userGroupId);} finally {provisioningIds.release(clusterId);}@@ -1309,7 +1366,8 @@ public class ElastiCacheService implements ResourceProvider {* cluster-mode-disabled replication group: the same Valkey container, fronted by the same* auth proxy on a port from the same range, so the endpoint a describe reports answers RESP.*/- private CacheCluster provisionCacheCluster(CreateCacheClusterRequest request, String engine) {+ private CacheCluster provisionCacheCluster(CreateCacheClusterRequest request, String engine,+ String cacheName, String accountId, String userGroupId) {String clusterId = request.cacheClusterId();AuthMode authMode = request.authMode() != null ? request.authMode() : AuthMode.NO_AUTH;int proxyPort = allocateProxyPort(request.port());@@ -1336,6 +1394,10 @@ public class ElastiCacheService implements ResourceProvider {: "cache.t4g.micro");cluster.setAuthMode(authMode);cluster.setAuthToken(request.authToken());+ cluster.setRegion(request.region());+ cluster.setServerlessCacheName(cacheName);+ cluster.setOwnerAccountId(accountId);+ cluster.setUserGroupId(userGroupId);cluster.setArn(regionResolver.buildArn("elasticache", request.region(), "cluster:" + clusterId));cluster.setCacheParameterGroupName(request.cacheParameterGroupName());cluster.setCacheSubnetGroupName(request.cacheSubnetGroupName());@@ -1352,9 +1414,7 @@ public class ElastiCacheService implements ResourceProvider {synchronized (lockFor("cc:" + clusterId)) {cacheClusters.put(clusterId, cluster);if (handle != null) {- proxyManager.startProxy(clusterId, authMode, proxyPort,- handle.getHost(), handle.getPort(),- (username, password) -> validateCacheClusterPassword(clusterId, username, password));+ startCacheClusterProxy(cluster, handle);} else {LOG.warnv("Cache cluster {0} created without a backing cache container: no "+ "Docker daemon is reachable. Metadata operations work; connections to "@@ -1434,14 +1494,24 @@ public class ElastiCacheService implements ResourceProvider {*/public List<CacheCluster> findCacheClusters(String filterClusterId) {if (filterClusterId != null && !filterClusterId.isBlank()) {- return cacheClusters.get(filterClusterId).map(List::of).orElseGet(List::of);+ return cacheClusters.get(filterClusterId).filter(cluster -> cluster.getServerlessCacheName() == null)+ .map(List::of).orElseGet(List::of);}- return cacheClusters.scan(k -> true);+ return cacheClusters.scan(k -> true).stream().filter(cluster -> cluster.getServerlessCacheName() == null).toList();}public CacheCluster deleteCacheCluster(String clusterId) {+ return deleteCacheCluster(clusterId, false);+ }++ CacheCluster deleteServerlessBacking(String clusterId) {+ return deleteCacheCluster(clusterId, true);+ }++ private CacheCluster deleteCacheCluster(String clusterId, boolean internal) {synchronized (lockFor("cc:" + clusterId)) {- CacheCluster cluster = cacheClusters.get(clusterId).orElseThrow(() ->+ CacheCluster cluster = cacheClusters.get(clusterId)+ .filter(record -> internal || record.getServerlessCacheName() == null).orElseThrow(() ->new AwsException("CacheClusterNotFound","Cache cluster " + clusterId + " not found.", 404));@@ -1483,6 +1553,93 @@ public class ElastiCacheService implements ResourceProvider {return (username == null || username.isEmpty()) && cluster.getAuthToken().equals(password);}+ private List<CacheCluster> runtimeCacheClusters() {+ List<CacheCluster> records = new ArrayList<>(findCacheClusters(null));+ records.addAll(cacheClusters.scanAllAccounts().stream()+ .filter(cluster -> cluster.getServerlessCacheName() != null).toList());+ return records;+ }++ private Optional<CacheCluster> runtimeCluster(String id, String accountId) {+ return accountId == null ? cacheClusters.get(id) : cacheClusters.getForAccount(accountId, id);+ }++ private void putRuntimeCluster(CacheCluster cluster) {+ if (cluster.getOwnerAccountId() == null) {+ cacheClusters.put(cluster.getCacheClusterId(), cluster);+ } else {+ cacheClusters.putForAccount(cluster.getOwnerAccountId(), cluster.getCacheClusterId(), cluster);+ }+ }++ CacheCluster getServerlessBacking(String id, String accountId) {+ return cacheClusters.getForAccount(accountId, id)+ .filter(cluster -> cluster.getServerlessCacheName() != null)+ .orElseThrow(() -> new AwsException("CacheClusterNotFound", "Serverless backing cache not found.", 404));+ }++ void updateServerlessUserGroup(String id, String accountId, String groupId) {+ synchronized (lockFor("cc:" + id)) {+ CacheCluster cluster = getServerlessBacking(id, accountId);+ cluster.setUserGroupId(groupId);+ putRuntimeCluster(cluster);+ }+ }++ private void startCacheClusterProxy(CacheCluster cluster, ElastiCacheContainerHandle handle) {+ if (cluster.getServerlessCacheName() == null) {+ proxyManager.startProxy(cluster.getCacheClusterId(), cluster.getAuthMode(),+ cluster.getConfigurationEndpoint().port(), handle.getHost(), handle.getPort(),+ (username, password) -> validateCacheClusterPassword(cluster.getCacheClusterId(), username, password));+ } else {+ proxyManager.startProxy(cluster.getCacheClusterId(), AuthMode.NO_AUTH,+ cluster.getConfigurationEndpoint().port(), handle.getHost(), handle.getPort(),+ serverlessAuthenticator(cluster), cluster.getServerlessCacheName());+ }+ }++ private ElastiCacheAuthProxy.PasswordValidator serverlessAuthenticator(CacheCluster original) {+ String id = original.getCacheClusterId();+ String account = original.getOwnerAccountId();+ return new ElastiCacheAuthProxy.PasswordValidator() {+ private ElastiCacheUser member(String username) {+ String name = username == null || username.isEmpty() ? "default" : username;+ synchronized (users) {+ CacheCluster cluster = cacheClusters.getForAccount(account, id).orElse(null);+ if (cluster == null || cluster.getUserGroupId() == null) {+ return null;+ }+ ElastiCacheUserGroup group = userGroups.getForAccount(account, normalizeUserGroupId(cluster.getUserGroupId())).orElse(null);+ if (group == null) {+ return null;+ }+ return group.getUserIds().stream().map(userId -> users.getForAccount(account, userId).orElse(null))+ .filter(user -> user != null && name.equals(user.getUserName()) && user.isEnabled())+ .findFirst().orElse(null);+ }+ }++ @Override+ public boolean validatePassword(String username, String password) {+ ElastiCacheUser user = member(username);+ return user != null && (user.getAuthMode() == AuthMode.NO_AUTH+ || user.getAuthMode() == AuthMode.PASSWORD && user.getPasswords().contains(password));+ }++ @Override+ public boolean hasMembers() {+ return cacheClusters.getForAccount(account, id).map(cluster -> cluster.getUserGroupId() != null)+ .orElse(true);+ }++ @Override+ public AuthMode memberAuthMode(String username) {+ ElastiCacheUser user = member(username);+ return user == null ? null : user.getAuthMode();+ }+ };+ }+/*** A replication-group member viewed as the cache cluster AWS reports it as. The terraform* provider follows {@code MemberClusters} into DescribeCacheClusters, so every member name@@ -1806,6 +1963,9 @@ public class ElastiCacheService implements ResourceProvider {for (ReplicationGroup group : replicationGroupsUsing(id)) {requireEngineCompatible(newEngine, id, group.getEngine());}+ for (String cacheEngine : userGroup.getServerlessCacheEngines().values()) {+ requireEngineCompatible(newEngine, id, cacheEngine);+ }}userGroup.setEngine(newEngine);userGroup.setUserIds(members);@@ -1823,6 +1983,10 @@ public class ElastiCacheService implements ResourceProvider {throw new AwsException("InvalidUserGroupState","User group " + id + " is in use by a replication group. Disassociate it before deleting it.", 400);}+ if (!userGroup.getServerlessCacheEngines().isEmpty()) {+ throw new AwsException("InvalidUserGroupState",+ "User group " + id + " is in use by a serverless cache. Disassociate it before deleting it.", 400);+ }userGroups.delete(id);userGroup.setStatus("deleting");LOG.infov("ElastiCache user group {0} deleted", id);@@ -1830,6 +1994,32 @@ public class ElastiCacheService implements ResourceProvider {}}+ /** Checks, under the user group lock, that a serverless cache of this engine may use the group. */+ void validateServerlessAssociation(String userGroupId, String cacheEngine) {+ synchronized (userGroupLock) {+ ElastiCacheUserGroup userGroup = getUserGroup(userGroupId);+ requireEngineCompatible(userGroup.getEngine(), userGroup.getUserGroupId(), normalizeEngine(cacheEngine));+ }+ }++ void attachServerlessCache(String userGroupId, String cacheName, String cacheEngine) {+ synchronized (userGroupLock) {+ ElastiCacheUserGroup userGroup = getUserGroup(userGroupId);+ requireEngineCompatible(userGroup.getEngine(), userGroup.getUserGroupId(), normalizeEngine(cacheEngine));+ userGroup.getServerlessCacheEngines().put(cacheName, normalizeEngine(cacheEngine));+ userGroups.put(userGroup.getUserGroupId(), userGroup);+ }+ }++ void detachServerlessCache(String userGroupId, String cacheName) {+ synchronized (userGroupLock) {+ Optional<ElastiCacheUserGroup> userGroup = userGroups.get(normalizeUserGroupId(userGroupId));+ if (userGroup.isPresent() && userGroup.get().getServerlessCacheEngines().remove(cacheName) != null) {+ userGroups.put(userGroup.get().getUserGroupId(), userGroup.get());+ }+ }+ }+public List<String> replicationGroupIdsUsing(String userGroupId) {return replicationGroupsUsing(normalizeUserGroupId(userGroupId)).stream().map(ReplicationGroup::getReplicationGroupId)@@ -2468,7 +2658,7 @@ public class ElastiCacheService implements ResourceProvider {Map.of()));}for (CacheCluster cluster : cacheClusters.scan(k -> true)) {- if (cluster.getArn() == null) {+ if (cluster.getArn() == null || cluster.getServerlessCacheName() != null) {continue;}AwsArnUtils.Arn parsed = AwsArnUtils.parse(cluster.getArn());diff --git a/src/main/java/io/github/hectorvent/floci/services/elasticache/container/ElastiCacheContainerManager.java b/src/main/java/io/github/hectorvent/floci/services/elasticache/container/ElastiCacheContainerManager.javaindex ea86670f1d..52bff51812 100644--- a/src/main/java/io/github/hectorvent/floci/services/elasticache/container/ElastiCacheContainerManager.java+++ b/src/main/java/io/github/hectorvent/floci/services/elasticache/container/ElastiCacheContainerManager.java@@ -236,8 +236,10 @@ public class ElastiCacheContainerManager {if (handle == null) {return;}- activeContainers.remove(handle.getGroupId());- lifecycleManager.stopAndRemove(handle.getContainerId(), handle.getLogStream());+ ElastiCacheContainerHandle existing = activeContainers.remove(handle.getGroupId());+ Closeable logStream = handle.getLogStream() != null ? handle.getLogStream()+ : (existing != null ? existing.getLogStream() : null);+ lifecycleManager.stopAndRemove(handle.getContainerId(), logStream);}/**diff --git a/src/main/java/io/github/hectorvent/floci/services/elasticache/container/ElastiCacheMemcachedContainerManager.java b/src/main/java/io/github/hectorvent/floci/services/elasticache/container/ElastiCacheMemcachedContainerManager.javaindex a0cbb867e7..56a7f8f32a 100644--- a/src/main/java/io/github/hectorvent/floci/services/elasticache/container/ElastiCacheMemcachedContainerManager.java+++ b/src/main/java/io/github/hectorvent/floci/services/elasticache/container/ElastiCacheMemcachedContainerManager.java@@ -213,8 +213,10 @@ public class ElastiCacheMemcachedContainerManager {if (handle == null) {return;}- activeContainers.remove(handle.getGroupId());- lifecycleManager.stopAndRemove(handle.getContainerId(), handle.getLogStream());+ ElastiCacheContainerHandle existing = activeContainers.remove(handle.getGroupId());+ Closeable logStream = handle.getLogStream() != null ? handle.getLogStream()+ : (existing != null ? existing.getLogStream() : null);+ lifecycleManager.stopAndRemove(handle.getContainerId(), logStream);}public void stopAll() {diff --git a/src/main/java/io/github/hectorvent/floci/services/elasticache/model/CacheCluster.java b/src/main/java/io/github/hectorvent/floci/services/elasticache/model/CacheCluster.javaindex af28f203ce..1a5e414fd1 100644--- a/src/main/java/io/github/hectorvent/floci/services/elasticache/model/CacheCluster.java+++ b/src/main/java/io/github/hectorvent/floci/services/elasticache/model/CacheCluster.java@@ -35,6 +35,9 @@ public class CacheCluster {private boolean atRestEncryptionEnabled;private List<String> securityGroupIds = new ArrayList<>();private Map<String, String> tags = new LinkedHashMap<>();+ private String serverlessCacheName;+ private String ownerAccountId;+ private String userGroupId;// Transient: not persisted, restored on container restartprivate transient String containerId;@@ -123,6 +126,15 @@ public class CacheCluster {public Map<String, String> getTags() { return tags; }public void setTags(Map<String, String> tags) { this.tags = tags == null ? new LinkedHashMap<>() : tags; }+ public String getServerlessCacheName() { return serverlessCacheName; }+ public void setServerlessCacheName(String serverlessCacheName) { this.serverlessCacheName = serverlessCacheName; }++ public String getOwnerAccountId() { return ownerAccountId; }+ public void setOwnerAccountId(String ownerAccountId) { this.ownerAccountId = ownerAccountId; }++ public String getUserGroupId() { return userGroupId; }+ public void setUserGroupId(String userGroupId) { this.userGroupId = userGroupId; }+public String getContainerId() { return containerId; }public void setContainerId(String containerId) { this.containerId = containerId; }diff --git a/src/main/java/io/github/hectorvent/floci/services/elasticache/model/ElastiCacheUserGroup.java b/src/main/java/io/github/hectorvent/floci/services/elasticache/model/ElastiCacheUserGroup.javaindex 54f686721a..172b88948a 100644--- a/src/main/java/io/github/hectorvent/floci/services/elasticache/model/ElastiCacheUserGroup.java+++ b/src/main/java/io/github/hectorvent/floci/services/elasticache/model/ElastiCacheUserGroup.java@@ -3,7 +3,9 @@ package io.github.hectorvent.floci.services.elasticache.model;import io.quarkus.runtime.annotations.RegisterForReflection;import java.time.Instant;+import java.util.LinkedHashMap;import java.util.LinkedHashSet;+import java.util.Map;import java.util.Set;@RegisterForReflection@@ -16,6 +18,8 @@ public class ElastiCacheUserGroup {private Set<String> userIds = new LinkedHashSet<>();private Instant createdAt;private String arn;+ // Serverless caches attached to this group, by cache name, with the engine each runs.+ private Map<String, String> serverlessCacheEngines = new LinkedHashMap<>();public ElastiCacheUserGroup() {}@@ -47,4 +51,9 @@ public class ElastiCacheUserGroup {public String getArn() { return arn; }public void setArn(String arn) { this.arn = arn; }++ public Map<String, String> getServerlessCacheEngines() { return serverlessCacheEngines; }+ public void setServerlessCacheEngines(Map<String, String> serverlessCacheEngines) {+ this.serverlessCacheEngines = serverlessCacheEngines != null ? serverlessCacheEngines : new LinkedHashMap<>();+ }}diff --git a/src/main/java/io/github/hectorvent/floci/services/elasticache/model/ServerlessCache.java b/src/main/java/io/github/hectorvent/floci/services/elasticache/model/ServerlessCache.javanew file mode 100644index 0000000000..48929b2126--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/elasticache/model/ServerlessCache.java@@ -0,0 +1,109 @@+package io.github.hectorvent.floci.services.elasticache.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;+import java.util.ArrayList;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++@RegisterForReflection+public class ServerlessCache {+ private String serverlessCacheName;+ private String engine;+ private String majorEngineVersion;+ private String fullEngineVersion;+ private String description;+ private String status;+ private String arn;+ private Instant createTime;+ private Endpoint endpoint;+ private Endpoint readerEndpoint;+ private String region;+ private String accountId;+ private String backingCacheClusterId;+ private String userGroupId;+ private String kmsKeyId;+ private Integer snapshotRetentionLimit;+ private String dailySnapshotTime;+ private CacheUsageLimits cacheUsageLimits;+ private List<String> subnetIds = new ArrayList<>();+ private List<String> securityGroupIds = new ArrayList<>();+ private Map<String, String> tags = new LinkedHashMap<>();++ public ServerlessCache() {}++ public String getServerlessCacheName() { return serverlessCacheName; }+ public void setServerlessCacheName(String serverlessCacheName) { this.serverlessCacheName = serverlessCacheName; }++ public String getEngine() { return engine; }+ public void setEngine(String engine) { this.engine = engine; }++ public String getMajorEngineVersion() { return majorEngineVersion; }+ public void setMajorEngineVersion(String majorEngineVersion) { this.majorEngineVersion = majorEngineVersion; }++ public String getFullEngineVersion() { return fullEngineVersion; }+ public void setFullEngineVersion(String fullEngineVersion) { this.fullEngineVersion = fullEngineVersion; }++ public String getDescription() { return description; }+ public void setDescription(String description) { this.description = description; }++ public String getStatus() { return status; }+ public void setStatus(String status) { this.status = status; }++ public String getArn() { return arn; }+ public void setArn(String arn) { this.arn = arn; }++ public Instant getCreateTime() { return createTime; }+ public void setCreateTime(Instant createTime) { this.createTime = createTime; }++ public Endpoint getEndpoint() { return endpoint; }+ public void setEndpoint(Endpoint endpoint) { this.endpoint = endpoint; }++ public Endpoint getReaderEndpoint() { return readerEndpoint; }+ public void setReaderEndpoint(Endpoint readerEndpoint) { this.readerEndpoint = readerEndpoint; }++ public String getRegion() { return region; }+ public void setRegion(String region) { this.region = region; }++ public String getAccountId() { return accountId; }+ public void setAccountId(String accountId) { this.accountId = accountId; }++ public String getBackingCacheClusterId() { return backingCacheClusterId; }+ public void setBackingCacheClusterId(String backingCacheClusterId) { this.backingCacheClusterId = backingCacheClusterId; }++ public String getUserGroupId() { return userGroupId; }+ public void setUserGroupId(String userGroupId) { this.userGroupId = userGroupId; }++ public String getKmsKeyId() { return kmsKeyId; }+ public void setKmsKeyId(String kmsKeyId) { this.kmsKeyId = kmsKeyId; }++ public Integer getSnapshotRetentionLimit() { return snapshotRetentionLimit; }+ public void setSnapshotRetentionLimit(Integer snapshotRetentionLimit) { this.snapshotRetentionLimit = snapshotRetentionLimit; }++ public String getDailySnapshotTime() { return dailySnapshotTime; }+ public void setDailySnapshotTime(String dailySnapshotTime) { this.dailySnapshotTime = dailySnapshotTime; }++ public CacheUsageLimits getCacheUsageLimits() { return cacheUsageLimits; }+ public void setCacheUsageLimits(CacheUsageLimits cacheUsageLimits) { this.cacheUsageLimits = cacheUsageLimits; }++ public List<String> getSubnetIds() { return new ArrayList<>(subnetIds); }+ public void setSubnetIds(List<String> subnetIds) { this.subnetIds = subnetIds == null ? new ArrayList<>() : new ArrayList<>(subnetIds); }++ public List<String> getSecurityGroupIds() { return new ArrayList<>(securityGroupIds); }+ public void setSecurityGroupIds(List<String> securityGroupIds) { this.securityGroupIds = securityGroupIds == null ? new ArrayList<>() : new ArrayList<>(securityGroupIds); }++ public Map<String, String> getTags() { return new LinkedHashMap<>(tags); }+ public void setTags(Map<String, String> tags) { this.tags = tags == null ? new LinkedHashMap<>() : new LinkedHashMap<>(tags); }++ @RegisterForReflection+ public record CacheUsageLimits(DataStorage dataStorage, EcpuPerSecond ecpuPerSecond) {}++ @RegisterForReflection+ public record DataStorage(Integer minimum, Integer maximum, String unit) {}++ @RegisterForReflection+ public record EcpuPerSecond(Integer minimum, Integer maximum) {}+}+diff --git a/src/main/java/io/github/hectorvent/floci/services/elasticache/proxy/ElastiCacheProxyManager.java b/src/main/java/io/github/hectorvent/floci/services/elasticache/proxy/ElastiCacheProxyManager.javaindex 156c41f548..bd442de4ef 100644--- a/src/main/java/io/github/hectorvent/floci/services/elasticache/proxy/ElastiCacheProxyManager.java+++ b/src/main/java/io/github/hectorvent/floci/services/elasticache/proxy/ElastiCacheProxyManager.java@@ -28,8 +28,14 @@ public class ElastiCacheProxyManager {public void startProxy(String groupId, AuthMode authMode, int proxyPort,String backendHost, int backendPort,ElastiCacheAuthProxy.PasswordValidator passwordValidator) {+ startProxy(groupId, authMode, proxyPort, backendHost, backendPort, passwordValidator, groupId);+ }++ public void startProxy(String groupId, AuthMode authMode, int proxyPort,+ String backendHost, int backendPort,+ ElastiCacheAuthProxy.PasswordValidator passwordValidator, String authIdentity) {ElastiCacheAuthProxy proxy = new ElastiCacheAuthProxy(- groupId, authMode, backendHost, backendPort,+ authIdentity, authMode, backendHost, backendPort,passwordValidator, sigV4Validator);try {proxy.start(proxyPort);diff --git a/src/test/java/io/github/hectorvent/floci/core/common/AwsQueryActionRoutingParityTest.java b/src/test/java/io/github/hectorvent/floci/core/common/AwsQueryActionRoutingParityTest.javaindex 733ece29c4..5fdca71431 100644--- a/src/test/java/io/github/hectorvent/floci/core/common/AwsQueryActionRoutingParityTest.java+++ b/src/test/java/io/github/hectorvent/floci/core/common/AwsQueryActionRoutingParityTest.java@@ -64,6 +64,7 @@ class AwsQueryActionRoutingParityTest {new QueryHandler("iam", HANDLERS_ROOT + "iam/IamQueryHandler.java"),new QueryHandler("sns", HANDLERS_ROOT + "sns/SnsQueryHandler.java"),new QueryHandler("elasticache", HANDLERS_ROOT + "elasticache/ElastiCacheQueryHandler.java"),+ new QueryHandler("elasticache", HANDLERS_ROOT + "elasticache/ElastiCacheServerlessQueryHandler.java"),new QueryHandler("rds", HANDLERS_ROOT + "rds/RdsQueryHandler.java"),new QueryHandler("rds", HANDLERS_ROOT + "docdb/DocDbQueryHandler.java"),new QueryHandler("rds", HANDLERS_ROOT + "neptune/NeptuneQueryHandler.java"),diff --git a/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheMemcachedServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheMemcachedServiceTest.javaindex c8ec4563a6..031b003f81 100644--- a/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheMemcachedServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheMemcachedServiceTest.java@@ -28,8 +28,10 @@ import static org.junit.jupiter.api.Assertions.assertTrue;import static org.mockito.ArgumentMatchers.any;import static org.mockito.ArgumentMatchers.anyString;import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.Mockito.doThrow;import static org.mockito.Mockito.mock;import static org.mockito.Mockito.never;+import static org.mockito.Mockito.spy;import static org.mockito.Mockito.verify;import static org.mockito.Mockito.when;@@ -41,13 +43,14 @@ class ElastiCacheMemcachedServiceTest {private ElastiCacheMemcachedContainerManager containerManager;private ElastiCacheProvisioningIds provisioningIds;private AccountAwareStorageBackend<CacheSubnetGroup> subnetGroups;+ private EmulatorConfig config;@BeforeEachvoid setUp() {containerManager = mock(ElastiCacheMemcachedContainerManager.class);provisioningIds = new ElastiCacheProvisioningIds();StorageFactory storageFactory = mock(StorageFactory.class);- EmulatorConfig config = mock(EmulatorConfig.class);+ config = mock(EmulatorConfig.class);EmulatorConfig.ServicesConfig servicesConfig = mock(EmulatorConfig.ServicesConfig.class);EmulatorConfig.ElastiCacheServiceConfig ecConfig = mock(EmulatorConfig.ElastiCacheServiceConfig.class);@@ -394,4 +397,27 @@ class ElastiCacheMemcachedServiceTest {null, null, null, null, null, null, null, null, null, null, null, null, null, null,region, null);}++ @Test+ void deleteUnknownClusterIncludesClusterIdInErrorMessage() {+ AwsException ex = assertThrows(AwsException.class, () -> service.deleteCacheCluster("missing-cluster"));+ assertEquals("CacheClusterNotFound", ex.getErrorCode());+ assertEquals("Cache cluster missing-cluster not found.", ex.getMessage());+ }++ @Test+ void provisioningFailureRollsBackContainerAndStorage() {+ StorageFactory failingStorageFactory = mock(StorageFactory.class);+ AccountAwareStorageBackend<CacheCluster> store = spy(AccountAwareStorageBackend.inMemory("000000000000"));+ doThrow(new RuntimeException("Storage failure")).when(store).put(anyString(), any());+ when(failingStorageFactory.create(anyString(), anyString(), any())).thenAnswer(inv -> store);++ ElastiCacheMemcachedService failingService = new ElastiCacheMemcachedService(+ containerManager, failingStorageFactory, config, provisioningIds, REGION_RESOLVER);++ assertThrows(RuntimeException.class, () -> failingService.createCacheCluster(request("fail-cluster")));++ verify(containerManager).stop(any(ElastiCacheContainerHandle.class));+ assertTrue(store.get("fail-cluster").isEmpty());+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheQueryHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheQueryHandlerTest.javaindex 1dc409e913..875f2aca3f 100644--- a/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheQueryHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheQueryHandlerTest.java@@ -47,7 +47,8 @@ class ElastiCacheQueryHandlerTest {RegionResolver regionResolver = mock(RegionResolver.class);when(regionResolver.getRegion()).thenReturn("us-east-1");when(regionResolver.getAccountId()).thenReturn("000000000000");- handler = new ElastiCacheQueryHandler(sigV4Validator, service, memcachedService, regionResolver);+ handler = new ElastiCacheQueryHandler(sigV4Validator, service, memcachedService, regionResolver,+ mock(ElastiCacheServerlessQueryHandler.class));}@Testdiff --git a/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheServerlessIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheServerlessIntegrationTest.javanew file mode 100644index 0000000000..cb5ebe0cb2--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheServerlessIntegrationTest.java@@ -0,0 +1,270 @@+package io.github.hectorvent.floci.services.elasticache;++import io.github.hectorvent.floci.services.ec2.Ec2Service;+import io.quarkus.test.common.http.TestHTTPResource;+import io.quarkus.test.junit.QuarkusTest;+import io.quarkus.test.junit.TestProfile;+import jakarta.inject.Inject;+import org.junit.jupiter.api.Assumptions;+import org.junit.jupiter.api.Test;+import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;+import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;+import software.amazon.awssdk.regions.Region;+import software.amazon.awssdk.services.elasticache.ElastiCacheClient;+import software.amazon.awssdk.services.elasticache.model.ServerlessCache;+import software.amazon.awssdk.services.elasticache.model.ServerlessCacheNotFoundException;++import java.io.IOException;+import java.io.InputStream;+import java.net.Socket;+import java.net.URI;+import java.nio.charset.StandardCharsets;+import java.util.List;+import java.util.concurrent.TimeUnit;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;++@QuarkusTest+@TestProfile(ServerlessTestProfile.class)+class ElastiCacheServerlessIntegrationTest {+ @TestHTTPResource+ URI endpoint;+ @Inject+ Ec2Service ec2;++ private ElastiCacheClient client() {+ return ElastiCacheClient.builder().endpointOverride(endpoint).region(Region.US_EAST_1)+ .credentialsProvider(StaticCredentialsProvider.create(AwsBasicCredentials.create("test", "test")))+ .build();+ }++ @Test+ void sdkCrudRoundtripsMetadataAndKeepsTheSameEndpoint() {+ String region = "us-east-1";+ String vpc = ec2.createVpc(region, "10.65.0.0/16", false).getVpcId();+ String subnet = ec2.createSubnet(region, vpc, "10.65.1.0/24", region + "a").getSubnetId();+ String securityGroup = ec2.createSecurityGroup(region, "serverless-first", "first", vpc).getGroupId();+ String updatedGroup = ec2.createSecurityGroup(region, "serverless-second", "second", vpc).getGroupId();+ try (ElastiCacheClient client = client()) {+ ServerlessCache created = client.createServerlessCache(request -> request.serverlessCacheName("sdk-serverless")+ .engine("valkey").description("first").securityGroupIds(securityGroup).subnetIds(subnet)+ .snapshotRetentionLimit(3).dailySnapshotTime("03:00")+ .cacheUsageLimits(limits -> limits.dataStorage(storage -> storage.maximum(5).unit("GB"))+ .ecpuPerSecond(ecpu -> ecpu.maximum(1000)))+ .tags(tag -> tag.key("team").value("test"))).serverlessCache();+ assertEquals("available", created.status());+ assertEquals("valkey", created.engine());+ assertNotNull(created.createTime());+ assertNotNull(created.endpoint());+ assertEquals(created.endpoint(), created.readerEndpoint());+ assertTrue(created.arn().endsWith(":serverlesscache:sdk-serverless"));+ assertEquals(List.of(securityGroup), created.securityGroupIds());+ assertEquals(List.of(subnet), created.subnetIds());+ assertEquals(5, created.cacheUsageLimits().dataStorage().maximum());+ assertEquals(3, created.snapshotRetentionLimit());+ assertEquals("03:00", created.dailySnapshotTime());+ assertEquals("test", client.listTagsForResource(request -> request.resourceName(created.arn()))+ .tagList().getFirst().value());+ ServerlessCache updated = client.modifyServerlessCache(request -> request.serverlessCacheName("sdk-serverless")+ .description("second").securityGroupIds(updatedGroup)).serverlessCache();+ assertEquals(created.endpoint(), updated.endpoint());+ assertEquals("second", updated.description());+ assertEquals(List.of(updatedGroup), updated.securityGroupIds());+ assertEquals("second", client.describeServerlessCaches(request -> request.serverlessCacheName("sdk-serverless"))+ .serverlessCaches().getFirst().description());+ assertTrue(client.describeCacheClusters().cacheClusters().stream()+ .noneMatch(cluster -> created.endpoint().equals(cluster.configurationEndpoint())));+ assertEquals("deleting", client.deleteServerlessCache(request -> request.serverlessCacheName("sdk-serverless"))+ .serverlessCache().status());+ assertThrows(ServerlessCacheNotFoundException.class,+ () -> client.describeServerlessCaches(request -> request.serverlessCacheName("sdk-serverless")));+ } finally {+ try (ElastiCacheClient client = client()) {+ try {+ client.deleteServerlessCache(request -> request.serverlessCacheName("sdk-serverless"));+ } catch (ServerlessCacheNotFoundException expected) {+ // Already deleted by the successful test path.+ }+ }+ ec2.deleteSecurityGroup(region, updatedGroup);+ ec2.deleteSecurityGroup(region, securityGroup);+ ec2.deleteSubnet(region, subnet);+ ec2.deleteVpc(region, vpc);+ }+ }++ @Test+ void dockerValkeyPreservesDataAndAuthenticatesCurrentGroupMembers() throws Exception {+ Assumptions.assumeTrue(dockerAvailable(), "Docker is required for the serverless data plane");+ try (ElastiCacheClient client = client()) {+ client.createUser(request -> request.userId("serverless-alice").userName("alice").engine("valkey")+ .accessString("on ~* +@all").passwords("alice-password-123"));+ client.createUser(request -> request.userId("serverless-bob").userName("bob").engine("valkey")+ .accessString("on ~* +@all").passwords("bob-password-123"));+ client.createUserGroup(request -> request.userGroupId("serverless-team").engine("valkey").userIds("serverless-alice"));+ try {+ ServerlessCache cache = client.createServerlessCache(request -> request.serverlessCacheName("serverless-data")+ .engine("valkey").userGroupId("serverless-team")).serverlessCache();+ try (Socket socket = socket(cache)) {+ resp(socket, "PING");+ assertTrue(line(socket).startsWith("-NOAUTH"));+ }+ try (Socket socket = socket(cache)) {+ resp(socket, "AUTH", "alice", "alice-password-123");+ assertEquals("+OK\r\n", line(socket));+ resp(socket, "SET", "serverless-key", "retained");+ assertEquals("+OK\r\n", line(socket));+ ServerlessCache updated = client.modifyServerlessCache(request -> request.serverlessCacheName("serverless-data")+ .description("changed while connected")).serverlessCache();+ assertEquals(cache.endpoint(), updated.endpoint());+ resp(socket, "GET", "serverless-key");+ assertEquals("$8\r\n", line(socket));+ assertEquals("retained\r\n", line(socket));+ }+ client.modifyUserGroup(request -> request.userGroupId("serverless-team")+ .userIdsToAdd("serverless-bob").userIdsToRemove("serverless-alice"));+ try (Socket socket = socket(cache)) {+ resp(socket, "AUTH", "alice", "alice-password-123");+ assertTrue(line(socket).startsWith("-ERR invalid username-password"));+ }+ try (Socket socket = socket(cache)) {+ resp(socket, "AUTH", "bob", "bob-password-123");+ assertEquals("+OK\r\n", line(socket));+ resp(socket, "GET", "serverless-key");+ assertEquals("$8\r\n", line(socket));+ assertEquals("retained\r\n", line(socket));+ }+ client.modifyUserGroup(request -> request.userGroupId("serverless-team").userIdsToRemove("serverless-bob"));+ try (Socket socket = socket(cache)) {+ resp(socket, "PING");+ assertTrue(line(socket).startsWith("-NOAUTH"));+ }+ try (Socket socket = socket(cache)) {+ resp(socket, "AUTH", "bob", "bob-password-123");+ assertTrue(line(socket).startsWith("-ERR invalid username-password"));+ }+ client.modifyServerlessCache(request -> request.serverlessCacheName("serverless-data").removeUserGroup(true));+ try (Socket socket = socket(cache)) {+ resp(socket, "PING");+ assertEquals("+PONG\r\n", line(socket));+ }+ } finally {+ deleteIfPresent(client, "serverless-data");+ client.deleteUserGroup(request -> request.userGroupId("serverless-team"));+ client.deleteUser(request -> request.userId("serverless-alice"));+ client.deleteUser(request -> request.userId("serverless-bob"));+ }+ }+ }++ @Test+ void dockerMemcachedPreservesValuesAcrossMetadataChanges() throws Exception {+ Assumptions.assumeTrue(dockerAvailable(), "Docker is required for the serverless Memcached data plane");+ try (ElastiCacheClient client = client()) {+ try {+ ServerlessCache cache = client.createServerlessCache(request -> request.serverlessCacheName("serverless-memcached")+ .engine("memcached")).serverlessCache();+ try (Socket socket = socket(cache)) {+ text(socket, "set serverless-key 0 60 8\r\nretained\r\n");+ assertEquals("STORED\r\n", line(socket));+ ServerlessCache updated = client.modifyServerlessCache(request -> request.serverlessCacheName("serverless-memcached")+ .description("same data")).serverlessCache();+ assertEquals(cache.endpoint(), updated.endpoint());+ text(socket, "get serverless-key\r\n");+ assertEquals("VALUE serverless-key 0 8\r\n", line(socket));+ assertEquals("retained\r\n", line(socket));+ assertEquals("END\r\n", line(socket));+ }+ assertTrue(client.describeCacheClusters().cacheClusters().stream()+ .noneMatch(cluster -> "memcached".equals(cluster.engine())));+ } finally {+ deleteIfPresent(client, "serverless-memcached");+ }+ }+ }++ private static void deleteIfPresent(ElastiCacheClient client, String name) {+ try {+ client.deleteServerlessCache(request -> request.serverlessCacheName(name));+ } catch (ServerlessCacheNotFoundException expected) {+ // Creation failed before publication, or the successful test already deleted it.+ }+ }++ private static boolean dockerAvailable() throws IOException, InterruptedException {+ Process process;+ try {+ process = new ProcessBuilder("docker", "info").redirectOutput(ProcessBuilder.Redirect.DISCARD)+ .redirectError(ProcessBuilder.Redirect.DISCARD).start();+ } catch (IOException expected) {+ // Docker CLI is optional on development machines.+ return false;+ }+ if (!process.waitFor(10, TimeUnit.SECONDS)) {+ process.destroyForcibly();+ return false;+ }+ return process.exitValue() == 0;+ }++ private static Socket socket(ServerlessCache cache) throws IOException {+ Socket socket = new Socket(cache.endpoint().address(), cache.endpoint().port());+ socket.setSoTimeout(10_000);+ return socket;+ }++ private static void resp(Socket socket, String... values) throws IOException {+ StringBuilder request = new StringBuilder("*" + values.length + "\r\n");+ for (String value : values) {+ request.append('$').append(value.getBytes(StandardCharsets.UTF_8).length).append("\r\n")+ .append(value).append("\r\n");+ }+ text(socket, request.toString());+ }++ private static void text(Socket socket, String value) throws IOException {+ socket.getOutputStream().write(value.getBytes(StandardCharsets.UTF_8));+ socket.getOutputStream().flush();+ }++ private static String line(Socket socket) throws IOException {+ InputStream input = socket.getInputStream();+ StringBuilder result = new StringBuilder();+ int next;+ while ((next = input.read()) != -1) {+ result.append((char) next);+ if (result.length() >= 2 && result.charAt(result.length() - 2) == '\r'+ && result.charAt(result.length() - 1) == '\n') {+ return result.toString();+ }+ }+ throw new IOException("Connection closed before reply terminator");+ }++ @Test+ void createServerlessCacheWithTagValueMissingKeyReturnsInvalidParameterValue() {+ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", "AWS4-HMAC-SHA256 Credential=test/20261010/us-east-1/elasticache/aws4_request")+ .formParam("Action", "CreateServerlessCache")+ .formParam("ServerlessCacheName", "tag-fail-cache")+ .formParam("Engine", "valkey")+ .formParam("Tags.Tag.1.Value", "malformed-value")+ .when()+ .post(endpoint)+ .then()+ .statusCode(400)+ .body(containsString("InvalidParameterValue"))+ .body(containsString("Tag key cannot be null or empty"));++ try (ElastiCacheClient client = client()) {+ assertThrows(ServerlessCacheNotFoundException.class,+ () -> client.describeServerlessCaches(r -> r.serverlessCacheName("tag-fail-cache")));+ }+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheServerlessServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheServerlessServiceTest.javanew file mode 100644index 0000000000..77396e71b1--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheServerlessServiceTest.java@@ -0,0 +1,434 @@+package io.github.hectorvent.floci.services.elasticache;++import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.common.RequestContext;+import io.github.hectorvent.floci.core.common.ServiceConfigAccess;+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;+import io.github.hectorvent.floci.core.storage.InMemoryStorage;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.ec2.Ec2Service;+import io.github.hectorvent.floci.services.ec2.model.SecurityGroup;+import io.github.hectorvent.floci.services.ec2.model.Subnet;+import io.github.hectorvent.floci.services.elasticache.container.ElastiCacheContainerHandle;+import io.github.hectorvent.floci.services.elasticache.container.ElastiCacheContainerManager;+import io.github.hectorvent.floci.services.elasticache.container.ElastiCacheMemcachedContainerManager;+import io.github.hectorvent.floci.services.elasticache.container.ValkeyClusterFormation;+import io.github.hectorvent.floci.services.elasticache.model.AuthMode;+import io.github.hectorvent.floci.services.elasticache.model.CacheCluster;+import io.github.hectorvent.floci.services.elasticache.model.ServerlessCache;+import io.github.hectorvent.floci.services.elasticache.proxy.ElastiCacheAuthProxy;+import io.github.hectorvent.floci.services.elasticache.proxy.ElastiCacheProxyManager;+import io.github.hectorvent.floci.services.kms.KmsService;+import jakarta.enterprise.inject.Instance;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.io.TempDir;+import org.mockito.ArgumentCaptor;++import java.nio.file.Path;+import java.util.List;+import java.util.Map;+import java.util.Optional;+import java.util.concurrent.CompletableFuture;+import java.util.concurrent.ConcurrentHashMap;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.TimeUnit;++import static org.junit.jupiter.api.Assertions.*;+import static org.mockito.ArgumentMatchers.*;+import static org.mockito.Mockito.*;++class ElastiCacheServerlessServiceTest {+ private ElastiCacheServerlessService service;+ private ElastiCacheService runtime;+ private ElastiCacheMemcachedService memcached;+ private ElastiCacheContainerManager containers;+ private ElastiCacheProxyManager proxies;+ private StorageFactory factory;+ private EmulatorConfig config;+ private RegionResolver resolver;+ private Ec2Service ec2;+ private KmsService kms;+ private RequestContext context;+ @TempDir+ Path directory;++ @BeforeEach+ void setUp() {+ factory = mock(StorageFactory.class);+ context = new RequestContext();+ context.setAccountId("000000000000");+ context.setRegion("us-east-1");+ Instance<RequestContext> requestInstance = mock(Instance.class);+ when(requestInstance.get()).thenReturn(context);+ Map<String, AccountAwareStorageBackend<?>> stores = new ConcurrentHashMap<>();+ when(factory.create(anyString(), anyString(), any())).thenAnswer(invocation -> stores.computeIfAbsent(+ invocation.getArgument(1), file -> new AccountAwareStorageBackend<>(new InMemoryStorage<>(), requestInstance, "000000000000")));+ config = mock(EmulatorConfig.class);+ EmulatorConfig.ServicesConfig services = mock(EmulatorConfig.ServicesConfig.class);+ EmulatorConfig.ElastiCacheServiceConfig settings = mock(EmulatorConfig.ElastiCacheServiceConfig.class);+ when(config.services()).thenReturn(services);+ when(services.elasticache()).thenReturn(settings);+ when(settings.proxyBasePort()).thenReturn(17400);+ when(settings.proxyMaxPort()).thenReturn(17401);+ when(settings.defaultImage()).thenReturn("valkey/valkey:8");+ when(settings.defaultMemcachedImage()).thenReturn("memcached:1.6");+ when(config.hostname()).thenReturn(Optional.of("localhost"));+ resolver = spy(new RegionResolver("us-east-1", "000000000000"));+ doAnswer(invocation -> context.getAccountId()).when(resolver).getAccountId();+ doAnswer(invocation -> context.getRegion()).when(resolver).getRegion();+ containers = mock(ElastiCacheContainerManager.class);+ when(containers.tryStart(anyString(), anyString(), any())).thenReturn(+ new ElastiCacheContainerHandle("container", "backing", "localhost", 6379));+ proxies = mock(ElastiCacheProxyManager.class);+ ec2 = mock(Ec2Service.class);+ when(ec2.describeSubnets(anyString(), anyList(), anyMap())).thenAnswer(invocation -> {+ List<String> ids = invocation.getArgument(1);+ return ids.stream().filter(id -> id.equals("subnet-local")).map(id -> {+ Subnet subnet = new Subnet();+ subnet.setSubnetId(id);+ subnet.setVpcId("vpc-local");+ return subnet;+ }).toList();+ });+ when(ec2.describeSecurityGroups(anyString(), anyList(), anyList(), anyMap())).thenAnswer(invocation -> {+ List<String> ids = invocation.getArgument(1);+ return ids.stream().filter(id -> id.equals("sg-local") || id.equals("sg-new")).map(id -> {+ SecurityGroup group = new SecurityGroup();+ group.setGroupId(id);+ group.setVpcId("vpc-local");+ return group;+ }).toList();+ });+ kms = mock(KmsService.class);+ when(kms.describeKey(anyString(), anyString())).thenThrow(new AwsException("NotFoundException", "Missing key", 400));+ runtime = new ElastiCacheService(containers, proxies, mock(ValkeyClusterFormation.class), factory,+ config, ec2, resolver, kms, new ElastiCacheProvisioningIds());+ memcached = new ElastiCacheMemcachedService(mock(ElastiCacheMemcachedContainerManager.class), factory,+ config, new ElastiCacheProvisioningIds(), resolver);+ service = new ElastiCacheServerlessService(factory, resolver, runtime, memcached, runtime);+ runtime.createUser("alice", "alice", AuthMode.PASSWORD, List.of("password-a"), "on ~* +@all", "valkey");+ runtime.createUser("bob", "bob", AuthMode.PASSWORD, List.of("password-b"), "on ~* +@all", "valkey");+ runtime.createUserGroup("team", "valkey", List.of("alice"), "us-east-1");+ }++ private ElastiCacheServerlessService.CreateServerlessCacheRequest create(String name, String engine, String group) {+ return new ElastiCacheServerlessService.CreateServerlessCacheRequest(name, engine, null, "description",+ List.of("subnet-local"), List.of("sg-local"), group, null, null, 0, null, List.of(),+ Map.of("team", "local"));+ }++ private ElastiCacheServerlessService.ModifyServerlessCacheRequest modify(String name, String group, Boolean remove) {+ return new ElastiCacheServerlessService.ModifyServerlessCacheRequest(name, "updated", null, null,+ List.of("sg-new"), group, remove, null, null, null);+ }++ private void error(String code, Runnable action) {+ assertEquals(code, assertThrows(AwsException.class, action::run).getErrorCode());+ }++ @Test+ void createsHiddenRuntimeMutatesMetadataAndReleasesPortOnDelete() {+ ServerlessCache cache = service.createServerlessCache(create("cache", "valkey", "team"));+ assertEquals("available", cache.getStatus());+ assertEquals(cache.getEndpoint(), cache.getReaderEndpoint());+ assertTrue(runtime.findCacheClusters(null).isEmpty());+ error("CacheClusterNotFound", () -> runtime.deleteCacheCluster(cache.getBackingCacheClusterId()));+ error("InvalidUserGroupState", () -> runtime.deleteUserGroup("team"));+ ServerlessCache updated = service.modifyServerlessCache(modify("cache", null, null));+ assertEquals(cache.getEndpoint(), updated.getEndpoint());+ assertEquals(cache.getBackingCacheClusterId(), updated.getBackingCacheClusterId());+ assertEquals("updated", updated.getDescription());+ assertEquals(List.of("sg-new"), updated.getSecurityGroupIds());+ error("ServerlessCacheAlreadyExistsFault", () -> service.createServerlessCache(create("cache", "valkey", "team")));+ assertEquals(List.of("us-east-1/cache"), List.copyOf(runtime.getUserGroup("team").getServerlessCacheEngines().keySet()));+ service.deleteServerlessCache("cache");+ assertTrue(service.describeServerlessCaches(null).isEmpty());+ runtime.deleteUserGroup("team");+ ServerlessCache replacement = service.createServerlessCache(create("replacement", "valkey", null));+ assertEquals(cache.getEndpoint().port(), replacement.getEndpoint().port());+ }++ @Test+ void deleteIsRetryableAfterBackingWasAlreadyRemoved() {+ ServerlessCache cache = service.createServerlessCache(create("cache", "valkey", "team"));+ runtime.deleteServerlessBacking(cache.getBackingCacheClusterId());+ service.deleteServerlessCache("cache");+ error("ServerlessCacheNotFoundFault", () -> service.getServerlessCache("cache"));+ runtime.deleteUserGroup("team");+ }++ @Test+ void listingSurvivesACacheWhoseBackingIsMissing() {+ ServerlessCache broken = service.createServerlessCache(create("broken", "valkey", null));+ service.createServerlessCache(create("healthy", "valkey", null));+ runtime.deleteServerlessBacking(broken.getBackingCacheClusterId());+ assertEquals(2, service.describeServerlessCaches(null).size());+ }++ @Test+ void resetReleasesBackingClustersAndUserGroupAttachments() {+ ServerlessCache cache = service.createServerlessCache(create("cache", "valkey", "team"));+ service.clear();+ assertTrue(service.describeServerlessCaches(null).isEmpty());+ error("CacheClusterNotFound", () -> runtime.deleteServerlessBacking(cache.getBackingCacheClusterId()));+ runtime.deleteUserGroup("team");+ }++ @Test+ void credentialsReadLiveMembershipAndUpdatedUserGroup() {+ ServerlessCache cache = service.createServerlessCache(create("cache", "valkey", "team"));+ ArgumentCaptor<ElastiCacheAuthProxy.PasswordValidator> validator = ArgumentCaptor.forClass(+ ElastiCacheAuthProxy.PasswordValidator.class);+ verify(proxies).startProxy(eq(cache.getBackingCacheClusterId()), any(), anyInt(), anyString(), anyInt(),+ validator.capture(), eq("cache"));+ assertTrue(validator.getValue().validatePassword("alice", "password-a"));+ assertFalse(validator.getValue().validatePassword("bob", "password-b"));+ runtime.modifyUserGroup("team", List.of("bob"), List.of("alice"), null);+ assertFalse(validator.getValue().validatePassword("alice", "password-a"));+ assertTrue(validator.getValue().validatePassword("bob", "password-b"));+ runtime.modifyUser("bob", AuthMode.PASSWORD, List.of("password-b-updated"), null, null, null);+ assertFalse(validator.getValue().validatePassword("bob", "password-b"));+ assertTrue(validator.getValue().validatePassword("bob", "password-b-updated"));+ runtime.createUserGroup("other", "valkey", List.of("alice"), "us-east-1");+ service.modifyServerlessCache(modify("cache", "other", false));+ assertTrue(validator.getValue().validatePassword("alice", "password-a"));+ assertFalse(validator.getValue().validatePassword("bob", "password-b"));+ assertTrue(List.copyOf(runtime.getUserGroup("team").getServerlessCacheEngines().keySet()).isEmpty());+ service.modifyServerlessCache(modify("cache", null, true));+ assertFalse(validator.getValue().hasMembers());+ }++ @Test+ void validationAndFailedAllocationLeaveNoAssociationOrRecord() {+ error("UserGroupNotFound", () -> service.createServerlessCache(create("missing", "valkey", "absent")));+ error("InvalidParameterCombination", () -> service.createServerlessCache(create("memcached", "memcached", "team")));+ error("InvalidParameterValue", () -> service.createServerlessCache(create("bad_name", "valkey", null)));+ verifyNoInteractions(proxies);+ when(containers.tryStart(anyString(), anyString(), any())).thenThrow(new IllegalStateException("allocation failed"));+ assertThrows(IllegalStateException.class, () -> service.createServerlessCache(create("failed", "valkey", "team")));+ assertTrue(List.copyOf(runtime.getUserGroup("team").getServerlessCacheEngines().keySet()).isEmpty());+ assertTrue(service.describeServerlessCaches(null).isEmpty());+ assertTrue(runtime.findCacheClusters(null).isEmpty());+ }++ @Test+ void failedBackingCleanupStillDetachesTheUserGroupAfterAFailedCreate() {+ IllegalStateException creationFailure = new IllegalStateException("record failed");+ doThrow(creationFailure).when(resolver).buildArn("elasticache", "us-east-1", "serverlesscache:failed");+ doThrow(new IllegalStateException("stop failed")).when(proxies).stopProxy(anyString());++ IllegalStateException thrown = assertThrows(IllegalStateException.class,+ () -> service.createServerlessCache(create("failed", "valkey", "team")));++ assertSame(creationFailure, thrown);+ assertEquals(1, thrown.getSuppressed().length);+ assertTrue(runtime.getUserGroup("team").getServerlessCacheEngines().isEmpty());+ }++ @Test+ void failedDeletionKeepsGroupProtectedUntilRetrySucceeds() {+ ServerlessCache cache = service.createServerlessCache(create("cache", "valkey", "team"));+ doThrow(new IllegalStateException("stop failed")).when(proxies).stopProxy(cache.getBackingCacheClusterId());+ assertThrows(IllegalStateException.class, () -> service.deleteServerlessCache("cache"));+ error("InvalidUserGroupState", () -> runtime.deleteUserGroup("team"));+ doNothing().when(proxies).stopProxy(cache.getBackingCacheClusterId());+ service.deleteServerlessCache("cache");+ runtime.deleteUserGroup("team");+ }++ @Test+ void rehydratedServiceRetainsRuntimeIdentityAndAssociation() {+ ServerlessCache original = service.createServerlessCache(create("cache", "valkey", "team"));+ ElastiCacheServerlessService reloaded = new ElastiCacheServerlessService(factory, resolver, runtime, memcached, runtime);+ assertEquals(original.getBackingCacheClusterId(), reloaded.getServerlessCache("cache").getBackingCacheClusterId());+ error("InvalidUserGroupState", () -> runtime.deleteUserGroup("team"));+ reloaded.deleteServerlessCache("cache");+ runtime.deleteUserGroup("team");+ }++ @Test+ void emptyAttachedGroupRemainsAuthRequiredAndCannotAuthenticate() {+ runtime.createUserGroup("empty", "valkey", List.of(), "us-east-1");+ ServerlessCache cache = service.createServerlessCache(create("empty-cache", "valkey", "empty"));+ ArgumentCaptor<ElastiCacheAuthProxy.PasswordValidator> validator = ArgumentCaptor.forClass(+ ElastiCacheAuthProxy.PasswordValidator.class);+ verify(proxies).startProxy(eq(cache.getBackingCacheClusterId()), any(), anyInt(), anyString(), anyInt(),+ validator.capture(), eq("empty-cache"));+ assertTrue(validator.getValue().hasMembers());+ assertNull(validator.getValue().memberAuthMode("default"));+ assertFalse(validator.getValue().validatePassword(null, "password-a"));+ }++ @Test+ void concurrentDuplicateCannotRemoveWinningAssociation() throws Exception {+ CountDownLatch allocating = new CountDownLatch(1);+ CountDownLatch complete = new CountDownLatch(1);+ when(containers.tryStart(anyString(), anyString(), any())).thenAnswer(invocation -> {+ allocating.countDown();+ assertTrue(complete.await(10, TimeUnit.SECONDS));+ return new ElastiCacheContainerHandle("container", "backing", "localhost", 6379);+ });+ CompletableFuture<ServerlessCache> first = CompletableFuture.supplyAsync(() ->+ service.createServerlessCache(create("race", "valkey", "team")));+ assertTrue(allocating.await(10, TimeUnit.SECONDS));+ error("InvalidUserGroupState", () -> runtime.deleteUserGroup("team"));+ CompletableFuture<String> second = CompletableFuture.supplyAsync(() -> {+ AwsException exception = assertThrows(AwsException.class,+ () -> service.createServerlessCache(create("race", "valkey", "team")));+ return exception.getErrorCode();+ });+ complete.countDown();+ assertEquals("race", first.get(10, TimeUnit.SECONDS).getServerlessCacheName());+ assertEquals("ServerlessCacheAlreadyExistsFault", second.get(10, TimeUnit.SECONDS));+ assertEquals(List.of("us-east-1/race"), List.copyOf(runtime.getUserGroup("team").getServerlessCacheEngines().keySet()));+ }++ @Test+ void snapshotsAndUnsupportedTransitionsFailWithoutMutation() {+ ElastiCacheServerlessService.CreateServerlessCacheRequest base = create("snapshot", "valkey", "team");+ error("InvalidParameterValue", () -> service.createServerlessCache(new ElastiCacheServerlessService.CreateServerlessCacheRequest(+ base.serverlessCacheName(), base.engine(), null, null, null, null, "team", null, null, null, null,+ List.of("arn:aws:elasticache:us-east-1:000000000000:serverlesscachesnapshot:test"), null)));+ assertTrue(List.copyOf(runtime.getUserGroup("team").getServerlessCacheEngines().keySet()).isEmpty());+ service.createServerlessCache(base);+ error("InvalidParameterValue", () -> service.deleteServerlessCache("snapshot", "final-snapshot"));+ error("InvalidParameterValue", () -> service.modifyServerlessCache(new ElastiCacheServerlessService.ModifyServerlessCacheRequest(+ "snapshot", "must-not-change", "redis", null, null, null, null, null, null, null)));+ error("UserGroupNotFound", () -> service.modifyServerlessCache(modify("snapshot", "absent", false)));+ assertEquals("description", service.getServerlessCache("snapshot").getDescription());+ assertEquals("team", service.getServerlessCache("snapshot").getUserGroupId());+ }++ @Test+ void persistentRestartRestoresHiddenRuntimeCredentialsAndPortOwnership() {+ StorageFactory persistent = persistentFactory();+ ElastiCacheService persistedRuntime = newRuntime(persistent);+ ElastiCacheServerlessService persisted = new ElastiCacheServerlessService(persistent, resolver, persistedRuntime, memcached, persistedRuntime);+ persistedRuntime.createUser("member", "member", AuthMode.PASSWORD, List.of("secret"), "on ~* +@all", "valkey");+ persistedRuntime.createUserGroup("persisted-team", "valkey", List.of("member"), "us-east-1");+ ServerlessCache original = persisted.createServerlessCache(create("persistent", "valkey", "persisted-team"));+ persistent.shutdownAll();+ StorageFactory reloadedFactory = persistentFactory();+ ElastiCacheService reloadedRuntime = newRuntime(reloadedFactory);+ ElastiCacheServerlessService reloaded = new ElastiCacheServerlessService(reloadedFactory, resolver, reloadedRuntime, memcached, reloadedRuntime);+ reloadedFactory.loadAll();+ clearInvocations(proxies);+ reloadedRuntime.restorePersistedRuntime().join();+ ServerlessCache restored = reloaded.getServerlessCache("persistent");+ assertEquals(original.getBackingCacheClusterId(), restored.getBackingCacheClusterId());+ assertEquals(original.getEndpoint(), restored.getEndpoint());+ assertEquals("000000000000", restored.getAccountId());+ assertTrue(reloadedRuntime.findCacheClusters(null).isEmpty());+ ArgumentCaptor<ElastiCacheAuthProxy.PasswordValidator> validator = ArgumentCaptor.forClass(+ ElastiCacheAuthProxy.PasswordValidator.class);+ verify(proxies).startProxy(eq(restored.getBackingCacheClusterId()), any(), anyInt(), anyString(), anyInt(),+ validator.capture(), eq("persistent"));+ assertTrue(validator.getValue().validatePassword("member", "secret"));+ assertEquals(List.of("us-east-1/persistent"), List.copyOf(reloadedRuntime.getUserGroup("persisted-team").getServerlessCacheEngines().keySet()));+ reloaded.deleteServerlessCache("persistent");+ reloadedRuntime.deleteUserGroup("persisted-team");+ ServerlessCache replacement = reloaded.createServerlessCache(create("reused", "valkey", null));+ assertEquals(original.getEndpoint().port(), replacement.getEndpoint().port());+ reloaded.deleteServerlessCache("reused");+ reloadedFactory.shutdownAll();+ }++ @Test+ void credentialsAndRestoreUseRecordedOwnerOutsideRequestScope() {+ context.setAccountId("111111111111");+ context.setRegion("cn-north-1");+ runtime.createUser("alice", "alice", AuthMode.PASSWORD, List.of("owner-secret"), "on ~* +@all", "valkey");+ runtime.createUserGroup("team", "valkey", List.of("alice"), "us-east-1");+ ServerlessCache original = service.createServerlessCache(create("account-cache", "valkey", "team"));+ assertTrue(original.getArn().startsWith("arn:aws-cn:elasticache:cn-north-1:111111111111:"));+ context.setAccountId("000000000000");+ context.setRegion("us-east-1");+ assertTrue(service.describeServerlessCaches(null).isEmpty());+ ElastiCacheService reloadedRuntime = newRuntime(factory);+ clearInvocations(proxies);+ reloadedRuntime.restorePersistedRuntime().join();+ ArgumentCaptor<ElastiCacheAuthProxy.PasswordValidator> validator = ArgumentCaptor.forClass(+ ElastiCacheAuthProxy.PasswordValidator.class);+ verify(proxies).startProxy(eq(original.getBackingCacheClusterId()), any(), anyInt(), anyString(), anyInt(),+ validator.capture(), eq("account-cache"));+ assertTrue(validator.getValue().validatePassword("alice", "owner-secret"));+ assertFalse(validator.getValue().validatePassword("alice", "password-a"));+ AccountAwareStorageBackend<CacheCluster> backing = factory.create("elasticache", "elasticache-redis-clusters.json", null);+ assertTrue(backing.getForAccount("000000000000", original.getBackingCacheClusterId()).isEmpty());+ assertTrue(backing.getForAccount("111111111111", original.getBackingCacheClusterId()).isPresent());+ context.setAccountId("111111111111");+ context.setRegion("cn-north-1");+ ElastiCacheServerlessService reloaded = new ElastiCacheServerlessService(factory, resolver, reloadedRuntime, memcached, reloadedRuntime);+ assertEquals(original.getEndpoint(), reloaded.getServerlessCache("account-cache").getEndpoint());+ reloaded.deleteServerlessCache("account-cache");+ runtime.deleteUserGroup("team");+ }++ private ElastiCacheService newRuntime(StorageFactory activeFactory) {+ return new ElastiCacheService(containers, proxies, mock(ValkeyClusterFormation.class), activeFactory,+ config, ec2, resolver, kms, new ElastiCacheProvisioningIds());+ }++ @Test+ void missingNetworkAndKmsDependenciesAreRejectedBeforeRuntimeAllocation() {+ for (ElastiCacheServerlessService.CreateServerlessCacheRequest request : List.of(+ new ElastiCacheServerlessService.CreateServerlessCacheRequest("missing-subnet", "valkey", null,+ null, List.of("subnet-absent"), null, "team", null, null, null, null, null, null),+ new ElastiCacheServerlessService.CreateServerlessCacheRequest("missing-sg", "valkey", null,+ null, null, List.of("sg-absent"), "team", null, null, null, null, null, null),+ new ElastiCacheServerlessService.CreateServerlessCacheRequest("missing-key", "valkey", null,+ null, null, null, "team", "missing", null, null, null, null, null))) {+ error("InvalidParameterValue", () -> service.createServerlessCache(request));+ }+ verifyNoInteractions(proxies);+ assertTrue(List.copyOf(runtime.getUserGroup("team").getServerlessCacheEngines().keySet()).isEmpty());+ assertTrue(service.describeServerlessCaches(null).isEmpty());+ }++ private StorageFactory persistentFactory() {+ EmulatorConfig persistenceConfig = mock(EmulatorConfig.class, RETURNS_DEEP_STUBS);+ when(persistenceConfig.defaultAccountId()).thenReturn("000000000000");+ when(persistenceConfig.storage().persistentPath()).thenReturn(directory.toString());+ ServiceConfigAccess access = mock(ServiceConfigAccess.class);+ when(access.storageMode(anyString())).thenReturn("persistent");+ when(access.storageFlushInterval(anyString())).thenReturn(60_000L);+ return new StorageFactory(persistenceConfig, access);+ }++ @Test+ void modifyingUserGroupWithDifferentCasePreservesAssociation() {+ service.createServerlessCache(create("case-cache", "valkey", "team"));+ service.modifyServerlessCache(modify("case-cache", "TEAM", null));+ ServerlessCache cache = service.getServerlessCache("case-cache");+ assertEquals("team", cache.getUserGroupId());++ // Deleting the user group should still fail because it is in use by case-cache+ error("InvalidUserGroupState", () -> runtime.deleteUserGroup("team"));++ service.deleteServerlessCache("case-cache");+ assertNotNull(runtime.deleteUserGroup("team"));+ }++ @Test+ void sameNamedServerlessCachesInDifferentRegionsMaintainIndependentGroupTracking() {+ context.setRegion("us-east-1");+ service.createServerlessCache(create("multi-cache", "valkey", "team"));++ context.setRegion("eu-west-1");+ service.createServerlessCache(create("multi-cache", "valkey", "team"));++ // Delete cache in eu-west-1+ service.deleteServerlessCache("multi-cache");++ // The user group should still be associated with the us-east-1 cache+ error("InvalidUserGroupState", () -> runtime.deleteUserGroup("team"));++ context.setRegion("us-east-1");+ service.deleteServerlessCache("multi-cache");++ assertNotNull(runtime.deleteUserGroup("team"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/elasticache/ServerlessTestProfile.java b/src/test/java/io/github/hectorvent/floci/services/elasticache/ServerlessTestProfile.javanew file mode 100644index 0000000000..18be39a490--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/elasticache/ServerlessTestProfile.java@@ -0,0 +1,13 @@+package io.github.hectorvent.floci.services.elasticache;++import io.quarkus.test.junit.QuarkusTestProfile;++import java.util.Map;++public class ServerlessTestProfile implements QuarkusTestProfile {+ @Override+ public Map<String, String> getConfigOverrides() {+ return Map.of("floci.services.rds.mock", "true", "floci.services.docdb.mock", "true",+ "floci.docker.resource-namespace", "issue4650-serverless");+ }+}diff --git a/tools/docs/services.yaml b/tools/docs/services.yamlindex d1122577db..376f1aef7a 100644--- a/tools/docs/services.yaml+++ b/tools/docs/services.yaml@@ -214,8 +214,10 @@ services:- { path: src/main/java/io/github/hectorvent/floci/services/organizations/OrganizationsJsonHandler.java, mode: switch }- service: elasticachedoc: docs/services/elasticache.md+ exclude_actions: [SubnetIds, SecurityGroupIds, SnapshotArnsToRestore]sources:- { path: src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheQueryHandler.java, mode: switch }+ - { path: src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheServerlessQueryHandler.java, mode: switch }- service: emrdoc: docs/services/emr.mdsources: