Light, fluffy, and always free - The AWS Local Emulator alternative
feat(rds): EnableHttpEndpoint, DisableHttpEndpoint and HttpEndpointEnabled (#5736)
David9cd9002e73f9
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsControlPlaneTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsControlPlaneTest.javaindex b989b1b07f..33592de3a6 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsControlPlaneTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsControlPlaneTest.java@@ -57,6 +57,7 @@ import software.amazon.awssdk.services.rds.model.OptionGroupNotFoundException;import software.amazon.awssdk.services.rds.model.OptionSetting;import software.amazon.awssdk.services.rds.model.RdsException;import software.amazon.awssdk.services.rds.model.RegisterDbProxyTargetsResponse;+import software.amazon.awssdk.services.rds.model.ResourceNotFoundException;import software.amazon.awssdk.services.rds.model.Tag;import software.amazon.awssdk.services.rds.model.UpgradeTarget;import software.amazon.awssdk.services.rds.model.ValidStorageOptions;@@ -764,6 +765,32 @@ class RdsControlPlaneTest {}}+ @Test+ @DisplayName("Data API endpoint: enable, describe and disable on an Aurora cluster")+ void sdkTogglesTheDataApiEndpoint() {+ String clusterName = TestFixtures.uniqueName("rds-data-api");+ try {+ String arn = rds.createDBCluster(b -> b+ .dbClusterIdentifier(clusterName)+ .engine("aurora-postgresql")+ .engineVersion("16.3")+ .masterUsername("admin")+ .masterUserPassword("data-api-secret")).dbCluster().dbClusterArn();+ assertThat(rds.enableHttpEndpoint(b -> b.resourceArn(arn)).httpEndpointEnabled()).isTrue();+ assertThat(rds.describeDBClusters(b -> b.dbClusterIdentifier(clusterName))+ .dbClusters().get(0).httpEndpointEnabled()).isTrue();+ assertThat(rds.disableHttpEndpoint(b -> b.resourceArn(arn)).httpEndpointEnabled()).isFalse();+ assertThatThrownBy(() -> rds.enableHttpEndpoint(b -> b.resourceArn(arn + "-missing")))+ .isInstanceOf(ResourceNotFoundException.class);+ } finally {+ try {+ rds.deleteDBCluster(b -> b.dbClusterIdentifier(clusterName).skipFinalSnapshot(true));+ } catch (Exception e) {+ LOG.log(Level.WARNING, "Failed to clean up RDS cluster " + clusterName, e);+ }+ }+ }+@Test@DisplayName("IAM role associations: add, describe and remove for a cluster and an instance")void sdkRoundTripsIamRoleAssociations() {diff --git a/docs/services/index.md b/docs/services/index.mdindex 4162e57638..3f4f5483b3 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -63,7 +63,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac| [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 | 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 | 98 |+| [RDS](rds.md) | `POST /` with `Action=` param + TCP proxy | Query + wire | 100 || [RDS Data API](rds-data.md) | `/Execute`, `/BeginTransaction`, `/CommitTransaction`, `/RollbackTransaction` | REST JSON | 4 || [Timestream for InfluxDB](timestream-influxdb.md) | `POST /` + `X-Amz-Target: AmazonTimestreamInfluxDB.*` + InfluxDB container | JSON 1.0 + InfluxDB HTTP | 24 || [MSK](msk.md) | `/v1/clusters/...`, `/api/v2/clusters/...` + Redpanda broker | REST JSON + Kafka | 8 |diff --git a/docs/services/rds-data.md b/docs/services/rds-data.mdindex c91af02dda..f41c079408 100644--- a/docs/services/rds-data.md+++ b/docs/services/rds-data.md@@ -47,7 +47,7 @@ The deprecated `ExecuteSql` operation is recognized at `POST /ExecuteSql` and re- SQL errors are returned as `DatabaseErrorException` so AWS SDK callers can handle database failures with normal AWS error decoding.- If `secretArn` points to a local Secrets Manager secret with JSON credentials (`username` or `user`, plus `password`), those credentials are used. A missing or unavailable secret returns `SecretsErrorException`; malformed or incomplete credentials return `InvalidSecretException`. Floci does not fall back to the resolved RDS resource's master credentials when a secret ARN was supplied.- `formatRecordsAs=JSON`, `formattedRecords`, and `resultSetOptions` are not implemented yet, and `ExecuteStatement` requests asking for those result modes return `BadRequestException`. They are `ExecuteStatement`-only fields in the AWS API, so `BatchExecuteStatement` — whose input is limited to `resourceArn`, `secretArn`, `sql`, `database`, `schema`, `parameterSets`, and `transactionId` — ignores them as AWS does rather than rejecting them.-- RDS `HttpEndpointEnabled` control-plane gating is not modeled locally; availability is controlled by `FLOCI_SERVICES_RDS_DATA_ENABLED` and whether the target local RDS resource is running.+- RDS records a cluster's `HttpEndpointEnabled` (`EnableHttpEndpoint` / `DisableHttpEndpoint`, see [RDS](rds.md#data-api-endpoint)), but the Data API does not check it: availability is controlled by `FLOCI_SERVICES_RDS_DATA_ENABLED` and whether the target local RDS resource is running.## Configurationdiff --git a/docs/services/rds.md b/docs/services/rds.mdindex a0b737877b..35fb26bbf3 100644--- a/docs/services/rds.md+++ b/docs/services/rds.md@@ -71,6 +71,8 @@ RDS Data API (`rds-data`) is documented separately because it uses REST JSON rou| `DescribeDBClusterEndpoints` | List a cluster's built-in writer and reader endpoints and its custom endpoints, with the four documented filters || `ModifyDBClusterEndpoint` | Change a custom endpoint's type or member list || `DeleteDBClusterEndpoint` | Delete a custom endpoint |+| `EnableHttpEndpoint` | Turn on an Aurora cluster's Data API endpoint by ARN; see [Data API endpoint](#data-api-endpoint) |+| `DisableHttpEndpoint` | Turn off a cluster's Data API endpoint by ARN || `AddRoleToDBCluster` | Associate an IAM role with a cluster, optionally for a feature; see [IAM role associations](#iam-role-associations) || `RemoveRoleFromDBCluster` | Remove a role from a cluster || `AddRoleToDBInstance` | Associate an IAM role with an instance for a feature |@@ -616,6 +618,19 @@ Custom endpoints are modelled, not routed: a custom endpoint reports the clusterreachable, but connections through it go where the cluster endpoint sends them rather than beingspread across the chosen members.+## Data API endpoint++`EnableHttpEndpoint` and `DisableHttpEndpoint` turn a cluster's Data API endpoint on and off by the+cluster's ARN, and `DescribeDBClusters` reports it as `HttpEndpointEnabled`. `CreateDBCluster` and+`ModifyDBCluster` take `EnableHttpEndpoint` too, as does the `AWS::RDS::DBCluster` CloudFormation+property, so Terraform's `enable_http_endpoint` and CDK's `enableDataApi` read back what they set.++The Data API is offered for Aurora PostgreSQL and Aurora MySQL clusters, so turning it on for any+other engine is `InvalidParameterCombination` (a create checks before the cluster exists); turning+it off is always accepted. An ARN that names no cluster in the caller's account and Region is+`ResourceNotFoundFault`, and a cluster that is not available is `InvalidResourceStateFault`. The flag+is recorded and reported only: the Data API (`rds-data`) does not refuse a cluster with it off.+## IAM role associations`AddRoleToDBCluster` and `AddRoleToDBInstance` associate an IAM role with an available cluster ordiff --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 2c51c20fb1..b77cc68471 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@@ -566,6 +566,7 @@ public class AwsQueryController {"AddTagsToResource", "ListTagsForResource", "RemoveTagsFromResource","CreateDBCluster", "DescribeDBClusters", "DeleteDBCluster", "ModifyDBCluster","AddRoleToDBCluster", "RemoveRoleFromDBCluster", "AddRoleToDBInstance", "RemoveRoleFromDBInstance",+ "EnableHttpEndpoint", "DisableHttpEndpoint","DescribeGlobalClusters","CreateDBParameterGroup", "DescribeDBParameterGroups","DeleteDBParameterGroup", "ModifyDBParameterGroup", "DescribeDBParameters",diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/RdsCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/RdsCfnProvisioner.javaindex d1b21b36de..1a3b1d5714 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/RdsCfnProvisioner.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/RdsCfnProvisioner.java@@ -442,6 +442,11 @@ public class RdsCfnProvisioner implements CfnResourceProvisioner {if (!roles.isEmpty()) {rdsService.validateClusterRoleAssociations(id, resolveOptional(props, "Engine", engine), roles);}+ boolean httpEndpoint = parseStrictBoolProp(props, "EnableHttpEndpoint", engine);+ if (httpEndpoint) {+ // Refused before a new cluster exists, rather than leaving one behind.+ RdsService.requireDataApiEngine(resolveOptional(props, "Engine", engine));+ }boolean created = cluster == null;if (cluster != null) {cluster = rdsService.modifyDbCluster(@@ -470,6 +475,10 @@ public class RdsCfnProvisioner implements CfnResourceProvisioner {false, null, engineMode, storageEncrypted);}cluster = reconcileClusterRoles(r, cluster, roles, created, ctx.isUpdate(), region);+ // EnableHttpEndpoint updates with no interruption; a template that leaves it out wants it off.+ if (httpEndpoint != cluster.isHttpEndpointEnabled()) {+ cluster = rdsService.setHttpEndpoint(region, cluster.getDbClusterIdentifier(), httpEndpoint);+ }r.setPhysicalId(cluster.getDbClusterIdentifier());r.getAttributes().put("DBClusterIdentifier", cluster.getDbClusterIdentifier());if (cluster.getEndpoint() != null) {@@ -1063,6 +1072,29 @@ public class RdsCfnProvisioner implements CfnResourceProvisioner {}}+ /**+ * A Boolean property read strictly: absent, or resolving to {@code AWS::NoValue}, is false; true+ * and false (in any case, as JSON booleans or strings) are themselves; anything else is a+ * {@code ValidationError} rather than a silent false.+ */+ private boolean parseStrictBoolProp(JsonNode props, String name, CloudFormationTemplateEngine engine) {+ if (props == null || !props.has(name)) {+ return false;+ }+ JsonNode value = engine.resolveNodeOmittingNoValue(props.get(name));+ if (value == null || value.isMissingNode() || value.isNull()) {+ return false;+ }+ if (value.isBoolean()) {+ return value.booleanValue();+ }+ String text = value.asText();+ if ("true".equalsIgnoreCase(text) || "false".equalsIgnoreCase(text)) {+ return Boolean.parseBoolean(text);+ }+ throw new AwsException("ValidationError", name + " must be true or false, not " + text + ".", 400);+ }+private boolean parseBoolProp(JsonNode props, String name, CloudFormationTemplateEngine engine) {return Boolean.parseBoolean(resolveOptional(props, name, engine));}diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.javaindex ab8a345c59..27a8aba9e7 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.java@@ -113,6 +113,8 @@ public class RdsQueryHandler {case "DescribeDBClusterEndpoints" -> handleDescribeDbClusterEndpoints(params, region);case "ModifyDBClusterEndpoint" -> handleModifyDbClusterEndpoint(params, region);case "DeleteDBClusterEndpoint" -> handleDeleteDbClusterEndpoint(params, region);+ case "EnableHttpEndpoint" -> handleSetHttpEndpoint("EnableHttpEndpoint", params, region, true);+ case "DisableHttpEndpoint" -> handleSetHttpEndpoint("DisableHttpEndpoint", params, region, false);case "AddRoleToDBCluster" -> handleAddRoleToDbCluster(params, region);case "RemoveRoleFromDBCluster" -> handleRemoveRoleFromDbCluster(params, region);case "AddRoleToDBInstance" -> handleAddRoleToDbInstance(params, region);@@ -368,6 +370,16 @@ public class RdsQueryHandler {new XmlBuilder().raw(eventSubscriptionXml(subscription)).build())).build();}+ private Response handleSetHttpEndpoint(String action, MultivaluedMap<String, String> params, String region,+ boolean enabled) {+ DbCluster cluster = service.setHttpEndpointByArn(region, params.getFirst("ResourceArn"), enabled);+ String result = new XmlBuilder()+ .elem("ResourceArn", cluster.getDbClusterArn())+ .elem("HttpEndpointEnabled", cluster.isHttpEndpointEnabled())+ .build();+ return Response.ok(AwsQueryResponse.envelope(action, AwsNamespaces.RDS, result)).build();+ }+private Response handleAddRoleToDbCluster(MultivaluedMap<String, String> params, String region) {service.addRoleToDbCluster(region, params.getFirst("DBClusterIdentifier"),params.getFirst("RoleArn"), params.getFirst("FeatureName"));@@ -1180,6 +1192,12 @@ public class RdsQueryHandler {try {List<DbRoleAssociation> associatedRoles = parseAssociatedRoles(params);service.validateClusterRoleAssociations(id, engine, associatedRoles);+ boolean enableHttpEndpoint = Boolean.TRUE.equals(parseOptionalBoolean(params, "EnableHttpEndpoint"));+ String globalCluster = params.getFirst("GlobalClusterIdentifier");+ if (enableHttpEndpoint && (globalCluster == null || globalCluster.isBlank())) {+ // A global cluster's members take its Aurora engine; any other create names its own.+ RdsService.requireDataApiEngine(engine);+ }Double serverlessV2Min = parseDoubleParam(params, "ServerlessV2ScalingConfiguration.MinCapacity");Double serverlessV2Max = parseDoubleParam(params, "ServerlessV2ScalingConfiguration.MaxCapacity");Integer serverlessV2SecondsUntilAutoPause = parseIntegerParam(@@ -1222,6 +1240,9 @@ public class RdsQueryHandler {throw e;}}+ if (enableHttpEndpoint) {+ cluster = service.setHttpEndpoint(region, id, true);+ }String result = dbClusterXml(cluster);return Response.ok(AwsQueryResponse.envelope("CreateDBCluster", AwsNamespaces.RDS, result)).build();} catch (AwsException e) {@@ -1331,9 +1352,16 @@ public class RdsQueryHandler {Double serverlessV2Max = parseDoubleParam(params, "ServerlessV2ScalingConfiguration.MaxCapacity");Integer serverlessV2SecondsUntilAutoPause = parseIntegerParam(params, "ServerlessV2ScalingConfiguration.SecondsUntilAutoPause");+ Boolean enableHttpEndpoint = parseOptionalBoolean(params, "EnableHttpEndpoint");+ if (Boolean.TRUE.equals(enableHttpEndpoint)) {+ RdsService.requireDataApiEngine(service.getDbCluster(id, region).getEngineIdentifier());+ }DbCluster cluster = service.modifyDbCluster(id, newPassword, iamEnabled,serverlessV2Min, serverlessV2Max, serverlessV2SecondsUntilAutoPause,manageMasterUserPassword, masterUserSecretKmsKeyId, region);+ if (enableHttpEndpoint != null) {+ cluster = service.setHttpEndpoint(region, id, enableHttpEndpoint);+ }String result = dbClusterXml(cluster);return Response.ok(AwsQueryResponse.envelope("ModifyDBCluster", AwsNamespaces.RDS, result)).build();} catch (AwsException e) {@@ -2918,6 +2946,7 @@ public class RdsQueryHandler {.elem("LatestRestorableTime", Instant.now().toString());}xml.elem("IAMDatabaseAuthenticationEnabled", c.isIamDatabaseAuthenticationEnabled())+ .elem("HttpEndpointEnabled", c.isHttpEndpointEnabled()).elem("MultiAZ", c.isMultiAz()).elem("StorageEncrypted", c.isStorageEncrypted()).elem("AvailabilityZone", c.getAvailabilityZone() != null ? c.getAvailabilityZone() : config.defaultAvailabilityZone())diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java b/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.javaindex 4fc7bcce93..38b0c7f6ce 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java@@ -2213,18 +2213,30 @@ public class RdsService implements Resettable, ResourceProvider {if (!source.startsWith("arn:")) {return source;}+ return clusterIdFromArn(source, region,+ () -> new AwsException("InvalidParameterValue", "Invalid DB cluster identifier: " + source, 400),+ () -> new AwsException("DBClusterNotFoundFault", "DB cluster " + source + " not found.", 404));+ }++ /**+ * The cluster identifier an RDS cluster ARN names. An ARN that does not parse or is not an RDS+ * cluster ARN raises {@code malformed}; one for another account or Region names no cluster here+ * and raises {@code elsewhere}. Each caller supplies the errors its API documents.+ */+ private String clusterIdFromArn(String source, String region, Supplier<AwsException> malformed,+ Supplier<AwsException> elsewhere) {AwsArnUtils.Arn arn;try {arn = AwsArnUtils.parse(source);- } catch (IllegalArgumentException malformed) {- throw new AwsException("InvalidParameterValue", "Invalid DB cluster identifier: " + source, 400);+ } catch (IllegalArgumentException e) {+ throw malformed.get();}String resource = arn.resource();if (!"rds".equals(arn.service()) || !resource.startsWith("cluster:")) {- throw new AwsException("InvalidParameterValue", "Invalid DB cluster identifier: " + source, 400);+ throw malformed.get();}if (!region.equals(arn.region()) || !currentAccountId().equals(arn.accountId())) {- throw new AwsException("DBClusterNotFoundFault", "DB cluster " + source + " not found.", 404);+ throw elsewhere.get();}return resource.substring("cluster:".length());}@@ -9753,6 +9765,67 @@ public class RdsService implements Resettable, ResourceProvider {return subscription;}+ // ── Data API endpoint ─────────────────────────────────────────────────────++ /**+ * Turns a cluster's Data API endpoint on or off by the cluster's ARN, as EnableHttpEndpoint and+ * DisableHttpEndpoint do. An ARN that names no cluster here is {@code ResourceNotFoundFault}, a+ * cluster that is not available {@code InvalidResourceStateFault}. The flag is recorded and+ * reported; the Data API does not consult it.+ */+ public synchronized DbCluster setHttpEndpointByArn(String region, String resourceArn, boolean enabled) {+ requireParameter(resourceArn, "ResourceArn");+ String effectiveRegion = effectiveRegion(region);+ DbCluster cluster = clusterForResourceArn(resourceArn, effectiveRegion);+ if (cluster.getStatus() != null && cluster.getStatus() != DbInstanceStatus.AVAILABLE) {+ throw new AwsException("InvalidResourceStateFault",+ "DB cluster " + cluster.getDbClusterIdentifier() + " is not in available state.", 400);+ }+ return setHttpEndpoint(effectiveRegion, cluster, enabled);+ }++ /** Sets the flag on a cluster named by identifier, for CreateDBCluster, ModifyDBCluster and CloudFormation. */+ public synchronized DbCluster setHttpEndpoint(String region, String clusterId, boolean enabled) {+ String effectiveRegion = effectiveRegion(region);+ return setHttpEndpoint(effectiveRegion, getDbCluster(clusterId, effectiveRegion), enabled);+ }++ private DbCluster setHttpEndpoint(String effectiveRegion, DbCluster cluster, boolean enabled) {+ if (enabled) {+ requireDataApiEngine(engineName(cluster));+ }+ cluster.setHttpEndpointEnabled(enabled);+ putClusterForScope(currentAccountId(), effectiveRegion, cluster.getDbClusterIdentifier(), cluster);+ LOG.infov("Data API endpoint {0} for DB cluster {1}", enabled ? "enabled" : "disabled",+ cluster.getDbClusterIdentifier());+ return RESPONSE_COPIER.convertValue(cluster, DbCluster.class);+ }++ private static final Set<String> DATA_API_ENGINES = Set.of("aurora-postgresql", "aurora-mysql");++ /**+ * The Data API is offered for Aurora PostgreSQL and Aurora MySQL only, so turning it on for any+ * other engine is refused; a create checks this before the cluster exists.+ */+ public static void requireDataApiEngine(String engine) {+ String name = engine == null ? "postgres" : engine.toLowerCase(Locale.ROOT);+ if (!DATA_API_ENGINES.contains(name)) {+ throw new AwsException("InvalidParameterCombination", "The Data API (HTTP endpoint) is available for "+ + "Aurora PostgreSQL and Aurora MySQL DB clusters only, not for engine " + name + ".", 400);+ }+ }++ private DbCluster clusterForResourceArn(String resourceArn, String region) {+ Supplier<AwsException> notFound = () -> new AwsException("ResourceNotFoundFault",+ "The specified resource ARN " + resourceArn + " doesn't refer to an existing DB cluster.", 404);+ DbCluster cluster = findClusterForScope(currentAccountId(), region,+ clusterIdFromArn(resourceArn, region, notFound, notFound));+ if (cluster == null || !resourceArn.equals(cluster.getDbClusterArn())) {+ throw notFound.get();+ }+ return cluster;+ }+// ── IAM role associations ─────────────────────────────────────────────────/**diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/model/DbCluster.java b/src/main/java/io/github/hectorvent/floci/services/rds/model/DbCluster.javaindex f6715cfd2a..b8d11b85a1 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/model/DbCluster.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/model/DbCluster.java@@ -22,6 +22,7 @@ public class DbCluster {private DbEndpoint endpoint;private DbEndpoint readerEndpoint;private boolean iamDatabaseAuthenticationEnabled;+ private boolean httpEndpointEnabled;private List<String> dbClusterMembers = new ArrayList<>();// The member that holds the writer role. Null on a cluster persisted before the role was// modelled, in which case the first member is the writer, as it always was reported.@@ -118,6 +119,10 @@ public class DbCluster {this.iamDatabaseAuthenticationEnabled = iamDatabaseAuthenticationEnabled;}+ /** Whether the Data API endpoint is on; EnableHttpEndpoint and DisableHttpEndpoint set it. */+ public boolean isHttpEndpointEnabled() { return httpEndpointEnabled; }+ public void setHttpEndpointEnabled(boolean httpEndpointEnabled) { this.httpEndpointEnabled = httpEndpointEnabled; }+public List<String> getDbClusterMembers() { return dbClusterMembers; }public void setDbClusterMembers(List<String> dbClusterMembers) { this.dbClusterMembers = dbClusterMembers; }diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/RdsCfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/RdsCfnProvisionerTest.javaindex d390956598..734c46b75f 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/RdsCfnProvisionerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/RdsCfnProvisionerTest.java@@ -232,6 +232,61 @@ class RdsCfnProvisionerTest {null, null, null, false, null, null, false);}+ @Test+ void dbClusterEnableHttpEndpointIsAppliedOnCreateAndUpdate() {+ createDbClusterEchoesRequestedId();+ DbCluster enabled = mock(DbCluster.class);+ when(enabled.getDbClusterIdentifier()).thenReturn("dataapi");+ when(enabled.isHttpEndpointEnabled()).thenReturn(true);+ when(rdsService.setHttpEndpoint("us-east-1", "dataapi", true)).thenReturn(enabled);++ StackResource r = provision("Cluster", "AWS::RDS::DBCluster", """+ {"DBClusterIdentifier":"dataapi","Engine":"aurora-postgresql","EnableHttpEndpoint":true}+ """);+ assertEquals("CREATE_COMPLETE", r.getStatus());+ verify(rdsService).setHttpEndpoint("us-east-1", "dataapi", true);++ // An update that leaves the property out turns the endpoint off again.+ when(rdsService.getDbCluster("dataapi")).thenReturn(enabled);+ when(rdsService.modifyDbCluster(eq("dataapi"), any(), any(), any(), any(), any(), any())).thenReturn(enabled);+ DbCluster disabled = mock(DbCluster.class);+ when(disabled.getDbClusterIdentifier()).thenReturn("dataapi");+ when(rdsService.setHttpEndpoint("us-east-1", "dataapi", false)).thenReturn(disabled);+ provisionExisting("Cluster", "AWS::RDS::DBCluster", """+ {"DBClusterIdentifier":"dataapi","Engine":"aurora-postgresql"}+ """, "us-east-1", "dataapi", Map.of("DBClusterIdentifier", "dataapi"));+ verify(rdsService).setHttpEndpoint("us-east-1", "dataapi", false);+ }++ @Test+ void aMalformedEnableHttpEndpointFailsInsteadOfTurningTheEndpointOff() {+ DbCluster enabled = mock(DbCluster.class);+ when(enabled.getDbClusterIdentifier()).thenReturn("dataapi");+ when(enabled.isHttpEndpointEnabled()).thenReturn(true);+ when(rdsService.getDbCluster("dataapi")).thenReturn(enabled);+ when(rdsService.modifyDbCluster(eq("dataapi"), any(), any(), any(), any(), any(), any())).thenReturn(enabled);++ StackResource r = provisionExisting("Cluster", "AWS::RDS::DBCluster", """+ {"DBClusterIdentifier":"dataapi","Engine":"aurora-postgresql","EnableHttpEndpoint":"yes"}+ """, "us-east-1", "dataapi", Map.of("DBClusterIdentifier", "dataapi"));++ assertEquals("CREATE_FAILED", r.getStatus());+ assertTrue(r.getStatusReason().contains("EnableHttpEndpoint must be true or false"), r.getStatusReason());+ verify(rdsService, never()).setHttpEndpoint(any(), any(), anyBoolean());+ verify(rdsService, never()).modifyDbCluster(any(), any(), any(), any(), any(), any(), any());+ }++ @Test+ void dbClusterEnableHttpEndpointOnANonAuroraEngineFailsBeforeCreating() {+ StackResource r = provision("Cluster", "AWS::RDS::DBCluster", """+ {"DBClusterIdentifier":"dataapi","Engine":"postgres","EnableHttpEndpoint":true}+ """);+ assertEquals("CREATE_FAILED", r.getStatus());+ assertTrue(r.getStatusReason().contains("Aurora"), r.getStatusReason());+ verify(rdsService, never()).createDbCluster(any(), any(), any(), any(), any(), any(), anyBoolean(), any(),+ any(), any(), anyBoolean(), any(), any(), any(), any(), anyBoolean(), any(), any(), anyBoolean());+ }+@Testvoid provisionsDbClusterInStackRegion() {DbCluster cluster = mock(DbCluster.class);diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsHttpEndpointIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsHttpEndpointIntegrationTest.javanew file mode 100644index 0000000000..498a14d342--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsHttpEndpointIntegrationTest.java@@ -0,0 +1,156 @@+package io.github.hectorvent.floci.services.rds;++import io.github.hectorvent.floci.testing.RdsMockProfile;+import io.quarkus.test.junit.QuarkusTest;+import io.quarkus.test.junit.TestProfile;+import io.restassured.specification.RequestSpecification;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestMethodOrder;++import static io.restassured.RestAssured.given;+import static io.restassured.http.ContentType.URLENC;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;++/**+ * The Data API switch: {@code EnableHttpEndpoint} and {@code DisableHttpEndpoint} by cluster ARN,+ * {@code EnableHttpEndpoint} on {@code CreateDBCluster} and {@code ModifyDBCluster}, and+ * {@code HttpEndpointEnabled} on {@code DBCluster}.+ */+@QuarkusTest+@TestProfile(RdsMockProfile.class)+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class RdsHttpEndpointIntegrationTest {++ private static final String CLUSTER = "data-api-cluster";+ private static final String ARN = "arn:aws:rds:us-east-1:000000000000:cluster:" + CLUSTER;+ private static final String DESCRIBED =+ "DescribeDBClustersResponse.DescribeDBClustersResult.DBClusters.DBCluster.HttpEndpointEnabled";++ private static final String AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20261015/us-east-1/rds/aws4_request, "+ + "SignedHeaders=content-type;host, Signature=test";++ private static RequestSpecification query(String action) {+ return given().header("Authorization", AUTH)+ .contentType(URLENC)+ .formParam("Action", action)+ .formParam("Version", "2014-10-31");+ }++ private static RequestSpecification createCluster(String id, String engine) {+ return query("CreateDBCluster")+ .formParam("DBClusterIdentifier", id)+ .formParam("Engine", engine)+ .formParam("MasterUsername", "admin")+ .formParam("MasterUserPassword", "password123");+ }++ private static void expectFlag(String clusterId, String value) {+ query("DescribeDBClusters").formParam("DBClusterIdentifier", clusterId)+ .when().post("/").then().statusCode(200)+ .body(DESCRIBED, equalTo(value));+ }++ @Test+ @Order(1)+ void aNewClusterHasTheEndpointOff() {+ createCluster(CLUSTER, "aurora-postgresql")+ .when().post("/").then().statusCode(200)+ .body(containsString("<HttpEndpointEnabled>false</HttpEndpointEnabled>"));+ }++ @Test+ @Order(2)+ void enableAndDisableByClusterArn() {+ query("EnableHttpEndpoint").formParam("ResourceArn", ARN)+ .when().post("/").then().statusCode(200)+ .body("EnableHttpEndpointResponse.EnableHttpEndpointResult.ResourceArn", equalTo(ARN))+ .body("EnableHttpEndpointResponse.EnableHttpEndpointResult.HttpEndpointEnabled", equalTo("true"));+ expectFlag(CLUSTER, "true");++ query("DisableHttpEndpoint").formParam("ResourceArn", ARN)+ .when().post("/").then().statusCode(200)+ .body("DisableHttpEndpointResponse.DisableHttpEndpointResult.HttpEndpointEnabled", equalTo("false"));+ expectFlag(CLUSTER, "false");+ }++ @Test+ @Order(3)+ void createAndModifyTakeEnableHttpEndpoint() {+ createCluster("data-api-at-create", "aurora-mysql").formParam("EnableHttpEndpoint", "true")+ .when().post("/").then().statusCode(200)+ .body(containsString("<HttpEndpointEnabled>true</HttpEndpointEnabled>"));+ expectFlag("data-api-at-create", "true");++ query("ModifyDBCluster").formParam("DBClusterIdentifier", "data-api-at-create")+ .formParam("EnableHttpEndpoint", "false")+ .when().post("/").then().statusCode(200);+ expectFlag("data-api-at-create", "false");+ // A modify that leaves the parameter out leaves the flag as it is.+ query("ModifyDBCluster").formParam("DBClusterIdentifier", CLUSTER)+ .formParam("EnableHttpEndpoint", "true")+ .when().post("/").then().statusCode(200);+ query("ModifyDBCluster").formParam("DBClusterIdentifier", CLUSTER)+ .formParam("EnableIAMDatabaseAuthentication", "true")+ .when().post("/").then().statusCode(200);+ expectFlag(CLUSTER, "true");+ }++ @Test+ @Order(4)+ void anArnThatNamesNoClusterHereIsNotFound() {+ for (String arn : new String[] {+ "arn:aws:rds:us-east-1:000000000000:cluster:no-such-cluster",+ "arn:aws:rds:us-east-1:000000000000:db:" + CLUSTER,+ "arn:aws:rds:eu-west-1:000000000000:cluster:" + CLUSTER,+ "arn:aws:rds:us-east-1:111111111111:cluster:" + CLUSTER,+ "not-an-arn"}) {+ query("EnableHttpEndpoint").formParam("ResourceArn", arn)+ .when().post("/").then().statusCode(404)+ .body("ErrorResponse.Error.Code", equalTo("ResourceNotFoundFault"));+ }+ query("EnableHttpEndpoint")+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("MissingParameter"));+ }++ @Test+ @Order(5)+ void aStoppedClusterIsInTheWrongState() {+ query("StopDBCluster").formParam("DBClusterIdentifier", CLUSTER)+ .when().post("/").then().statusCode(200);+ query("DisableHttpEndpoint").formParam("ResourceArn", ARN)+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("InvalidResourceStateFault"));+ query("StartDBCluster").formParam("DBClusterIdentifier", CLUSTER)+ .when().post("/").then().statusCode(200);+ }++ @Test+ @Order(6)+ void onlyAuroraClustersTakeTheDataApi() {+ createCluster("data-api-postgres", "postgres").formParam("EnableHttpEndpoint", "true")+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("InvalidParameterCombination"));+ query("DescribeDBClusters").formParam("DBClusterIdentifier", "data-api-postgres")+ .when().post("/").then().statusCode(404);++ createCluster("data-api-postgres", "postgres")+ .when().post("/").then().statusCode(200);+ query("EnableHttpEndpoint")+ .formParam("ResourceArn", "arn:aws:rds:us-east-1:000000000000:cluster:data-api-postgres")+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("InvalidParameterCombination"));+ query("ModifyDBCluster").formParam("DBClusterIdentifier", "data-api-postgres")+ .formParam("EnableHttpEndpoint", "true")+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("InvalidParameterCombination"));+ // Turning it off is never refused.+ query("DisableHttpEndpoint")+ .formParam("ResourceArn", "arn:aws:rds:us-east-1:000000000000:cluster:data-api-postgres")+ .when().post("/").then().statusCode(200);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.javaindex 9ec48cad11..95064fe529 100644--- a/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java@@ -3240,6 +3240,16 @@ class RdsServiceTest {assertNull(RdsEngineCatalog.featureNamesForEngine(null));}+ @Test+ void theDataApiTakesOnlyTheAuroraEngines() {+ RdsService.requireDataApiEngine("aurora-postgresql");+ RdsService.requireDataApiEngine("AURORA-MYSQL");+ for (String engine : new String[] {"aurora", "aurora-serverless", "aurora-postgresql-limitless", "postgres", null}) {+ AwsException refused = assertThrows(AwsException.class, () -> RdsService.requireDataApiEngine(engine));+ assertEquals("InvalidParameterCombination", refused.getErrorCode(), String.valueOf(engine));+ }+ }+@Testvoid engineVersionsSortNumericallyForUpgradeTargets() {RdsEngineCatalog.EngineVersion pg163 = RdsEngineCatalog.VERSIONS.stream()diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/model/DbClusterPersistenceTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/model/DbClusterPersistenceTest.javaindex 58d33a1d05..43fcb860bf 100644--- a/src/test/java/io/github/hectorvent/floci/services/rds/model/DbClusterPersistenceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rds/model/DbClusterPersistenceTest.java@@ -12,6 +12,7 @@ import java.util.Map;import java.util.Optional;import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertNull;import static org.junit.jupiter.api.Assertions.assertTrue;@@ -88,5 +89,24 @@ class DbClusterPersistenceTest {reader.load();assertTrue(reader.get("legacy-cluster").orElseThrow().getAssociatedRoles().isEmpty());+ assertFalse(reader.get("legacy-cluster").orElseThrow().isHttpEndpointEnabled());+ }++ @Test+ void httpEndpointFlagPersistsAcrossInstances(@TempDir Path directory) {+ Path file = directory.resolve("rds-clusters.json");+ DbCluster cluster = new DbCluster();+ cluster.setDbClusterIdentifier("data-api-cluster");+ cluster.setHttpEndpointEnabled(true);++ PersistentStorage<String, DbCluster> writer = new PersistentStorage<>(+ file, new TypeReference<Map<String, DbCluster>>() {});+ writer.put(cluster.getDbClusterIdentifier(), cluster);++ PersistentStorage<String, DbCluster> reader = new PersistentStorage<>(+ file, new TypeReference<Map<String, DbCluster>>() {});+ reader.load();++ assertTrue(reader.get("data-api-cluster").orElseThrow().isHttpEndpointEnabled());}}