Light, fluffy, and always free - The AWS Local Emulator alternative
feat(rds): engine versions, engine defaults and valid modifications (#5196)
David890b8eca514a
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 814a664c4b..8e03485b36 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@@ -20,6 +20,7 @@ import software.amazon.awssdk.services.rds.model.CreateOptionGroupResponse;import software.amazon.awssdk.services.rds.model.DBCluster;import software.amazon.awssdk.services.rds.model.DBClusterEndpoint;import software.amazon.awssdk.services.rds.model.DBClusterSnapshot;+import software.amazon.awssdk.services.rds.model.DBEngineVersion;import software.amazon.awssdk.services.rds.model.DBInstance;import software.amazon.awssdk.services.rds.model.DBProxyTarget;import software.amazon.awssdk.services.rds.model.DBSnapshot;@@ -34,6 +35,7 @@ import software.amazon.awssdk.services.rds.model.DescribeDbProxyTargetsResponse;import software.amazon.awssdk.services.rds.model.DescribeDbSubnetGroupsResponse;import software.amazon.awssdk.services.rds.model.DescribeOptionGroupsResponse;import software.amazon.awssdk.services.rds.model.DescribeOrderableDbInstanceOptionsResponse;+import software.amazon.awssdk.services.rds.model.EngineDefaults;import software.amazon.awssdk.services.rds.model.InvalidDbInstanceStateException;import software.amazon.awssdk.services.rds.model.InvalidOptionGroupStateException;import software.amazon.awssdk.services.rds.model.InvalidRestoreException;@@ -49,6 +51,8 @@ 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.Tag;+import software.amazon.awssdk.services.rds.model.UpgradeTarget;+import software.amazon.awssdk.services.rds.model.ValidStorageOptions;import java.time.Instant;import java.util.List;@@ -753,6 +757,51 @@ class RdsControlPlaneTest {}}+ @Test+ @DisplayName("Catalogue reads: engine versions, engine defaults and valid instance modifications")+ void sdkReadsTheEngineCatalogue() {+ DBEngineVersion postgres = rds.describeDBEngineVersions(b -> b+ .engine("postgres").engineVersion("16.3")).dbEngineVersions().get(0);+ assertThat(postgres.dbParameterGroupFamily()).isEqualTo("postgres16");+ assertThat(postgres.validUpgradeTarget()).extracting(UpgradeTarget::engineVersion).contains("17.4");+ assertThat(postgres.supportedEngineModes()).containsExactly("provisioned");+ assertThat(postgres.exportableLogTypes()).containsExactly("postgresql", "upgrade");+ assertThat(postgres.supportsLogExportsToCloudwatchLogs()).isTrue();+ assertThat(postgres.supportsReadReplica()).isTrue();+ assertThat(postgres.supportedFeatureNames()).containsExactly("s3Import", "s3Export", "Lambda");+ assertThat(postgres.supportsParallelQuery()).isFalse();+ assertThat(postgres.supportsGlobalDatabases()).isFalse();+ assertThat(postgres.supportsBabelfish()).isFalse();++ assertThat(rds.describeDBEngineVersions(b -> b.engine("mysql").defaultOnly(true)).dbEngineVersions())+ .extracting(DBEngineVersion::engineVersion).containsExactly("8.0.36");+ DBEngineVersion auroraMysql = rds.describeDBEngineVersions(b -> b+ .engine("aurora-mysql").defaultOnly(true)).dbEngineVersions().get(0);+ assertThat(auroraMysql.engineVersion()).isEqualTo("8.0.mysql_aurora.3.05.2");+ assertThat(auroraMysql.supportsGlobalDatabases()).isTrue();+ assertThat(auroraMysql.supportedFeatureNames()).isEmpty();++ EngineDefaults defaults = rds.describeEngineDefaultParameters(b -> b+ .dbParameterGroupFamily("postgres16")).engineDefaults();+ assertThat(defaults.dbParameterGroupFamily()).isEqualTo("postgres16");+ assertThat(rds.describeEngineDefaultClusterParameters(b -> b+ .dbParameterGroupFamily("aurora-postgresql16")).engineDefaults().dbParameterGroupFamily())+ .isEqualTo("aurora-postgresql16");++ String instanceName = TestFixtures.uniqueName("rds-valid-mods");+ try {+ createDbInstance(rds, instanceName, "catalogue-secret");+ ValidStorageOptions storage = rds.describeValidDBInstanceModifications(b -> b+ .dbInstanceIdentifier(instanceName)).validDBInstanceModificationsMessage().storage().get(0);+ assertThat(storage.storageType()).isEqualTo("gp2");+ // 20 GiB stays as it is, and any increase stores at least 10% more (22 GiB).+ assertThat(storage.storageSize()).extracting(r -> r.from() + "-" + r.to())+ .containsExactly("20-20", "22-65536");+ } finally {+ deleteDbInstance(rds, instanceName);+ }+ }+private static CreateDbProxyResponse createIamProxy(RdsClient client, String name, List<String> vpcSubnetIds) {return client.createDBProxy(b -> b.dbProxyName(name)diff --git a/docs/services/index.md b/docs/services/index.mdindex cda7b79b1e..32562840da 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -62,7 +62,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 | 90 |+| [RDS](rds.md) | `POST /` with `Action=` param + TCP proxy | Query + wire | 94 || [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.md b/docs/services/rds.mdindex 986238d70a..f0dd22bdfe 100644--- a/docs/services/rds.md+++ b/docs/services/rds.md@@ -57,7 +57,11 @@ RDS Data API (`rds-data`) is documented separately because it uses REST JSON rou| `PromoteReadReplica` | Detach a read replica into a standalone instance and turn automated backups on || `SwitchoverReadReplica` | Refused with `InvalidDBInstanceState`: AWS supports switchover only for Oracle and SQL Server replicas, neither of which is emulated || `PromoteReadReplicaDBCluster` | Refused with `InvalidDBClusterStateFault`: no cluster is created as a replica of an instance |-| `DescribeOrderableDBInstanceOptions` | List deterministic instance class options |+| `DescribeDBEngineVersions` | List the engine catalogue's versions with their parameter group family, default flag and upgrade targets |+| `DescribeEngineDefaultParameters` | Return a known family's default parameters (an empty list, as Floci's default groups hold none) |+| `DescribeEngineDefaultClusterParameters` | Return a known family's default cluster parameters (an empty list, as for instances) |+| `DescribeValidDBInstanceModifications` | Return the storage an instance can move to: its type and the sizes a modify stores as asked |+| `DescribeOrderableDBInstanceOptions` | List the orderable engine, version and instance class combinations from the engine catalogue; see [Engine catalogue](#engine-catalogue) || `DescribeEvents` | - || `CreateEventSubscription` | Create an event notification subscription (stored, nothing is published) || `DescribeEventSubscriptions` | List subscriptions, or the one the request names |@@ -553,6 +557,33 @@ same-region replicas; a cross-region replica keeps its link with the replication`terminated` until it is promoted or deleted, which is what AWS does for PostgreSQL. Deleting areplica drops it from its source's list.+## Engine catalogue++`DescribeDBEngineVersions` and `DescribeOrderableDBInstanceOptions` read one curated catalogue: a+representative version for each major version Floci knows through its managed parameter and option+groups (PostgreSQL 13 to 18, MySQL 8.0 and 8.4, MariaDB 10.11, 11.2 and 11.4, SQL Server Standard 15,+Aurora PostgreSQL 15 to 17 and Aurora MySQL 8.0). It is not AWS's full version list. Each version+reports the parameter group family the create path computes for it, its major version and its upgrade+targets (the engine's later versions, with `IsMajorVersionUpgrade` set across a major version). Each+engine's default is the version a create request that names none gets (instances, clusters and global+clusters alike), so `DefaultOnly` agrees with what Floci builds; for Aurora MySQL that is+`8.0.mysql_aurora.3.05.2`. Each version also reports what Floci supports for it: `SupportsReadReplica`+for PostgreSQL only, `SupportsGlobalDatabases` for the two Aurora engines, and `SupportsParallelQuery`+and `SupportsBabelfish` as false. `ExportableLogTypes` and `SupportedFeatureNames` list the engine's+documented log types and IAM role feature names. `EngineVersion` takes an exact version or a major version such as `16`, and the+documented filters (`db-parameter-group-family`, `engine`, `engine-mode`, `engine-version`, `status`)+apply. Every version is `available`, so `IncludeAll` changes nothing.++`DescribeEngineDefaultParameters` and `DescribeEngineDefaultClusterParameters` accept a family from the+catalogue (`InvalidParameterValue` otherwise) and return an empty parameter list, consistent with+`DescribeDBParameters` on a default group, which lists only values set on the group.+`DescribeValidDBInstanceModifications` reports the instance's storage type and the sizes `ModifyDBInstance`+stores as asked: the current size, and from the smallest real increase up to the engine's maximum (16384+GiB for SQL Server, 65536 GiB otherwise). Storage only grows, and for PostgreSQL, MySQL and MariaDB an+increase under 10% is rounded up to 10%, so at 40 GiB the second range starts at 44. An Aurora instance+has no storage of its own to modify, so its list is empty. `DescribeOrderableDBInstanceOptions` matches+`EngineVersion` exactly or as a major version prefix, so `8.0` finds the MySQL `8.0.36` rows.+## Cluster endpoints`CreateDBClusterEndpoint` adds an Aurora custom endpoint to an available cluster. As the Aurora userdiff --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 d3a9339a74..14ff0cb5a6 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@@ -554,7 +554,9 @@ public class AwsQueryController {private static final Set<String> RDS_ACTIONS = Set.of("CreateDBInstance", "DescribeDBInstances", "DeleteDBInstance","ModifyDBInstance", "RebootDBInstance",- "DescribeOrderableDBInstanceOptions",+ "DescribeOrderableDBInstanceOptions", "DescribeValidDBInstanceModifications",+ "DescribeDBEngineVersions", "DescribeEngineDefaultParameters",+ "DescribeEngineDefaultClusterParameters","CreateDBSubnetGroup", "DescribeDBSubnetGroups", "ModifyDBSubnetGroup", "DeleteDBSubnetGroup","AddTagsToResource", "ListTagsForResource", "RemoveTagsFromResource","CreateDBCluster", "DescribeDBClusters", "DeleteDBCluster", "ModifyDBCluster",diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/RdsEngineCatalog.java b/src/main/java/io/github/hectorvent/floci/services/rds/RdsEngineCatalog.javanew file mode 100644index 0000000000..1ea5fc7390--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/rds/RdsEngineCatalog.java@@ -0,0 +1,167 @@+package io.github.hectorvent.floci.services.rds;++import java.util.ArrayList;+import java.util.Comparator;+import java.util.List;+import java.util.Locale;+import java.util.Map;++/**+ * The engine versions RDS reports through DescribeDBEngineVersions and+ * DescribeOrderableDBInstanceOptions. It is a curated subset, one representative version per major+ * version that Floci knows through its managed parameter and option groups, not AWS's full list.+ * Each engine's default is the version Floci uses when a create request names none, and each+ * family is the one the create path computes for that version.+ */+final class RdsEngineCatalog {++ /** One engine version; {@code instanceClasses} are its orderable classes. */+ record EngineVersion(String engine, String version, String majorVersion, String family,+ String engineDescription, boolean isDefault, List<String> instanceClasses,+ List<String> engineModes) {++ String versionDescription() {+ return engineDescription + " " + version;+ }+ }++ private static final List<String> PROVISIONED = List.of("provisioned");++ static final List<EngineVersion> VERSIONS = List.of(+ postgres("13.20", "13", false, List.of()),+ postgres("14.17", "14", false, List.of()),+ postgres("15.12", "15", false, List.of()),+ postgres("16.3", "16", true, List.of("db.t3.micro", "db.t4g.micro", "db.t4g.small", "db.t4g.medium")),+ postgres("16.14", "16", false, List.of("db.t3.micro", "db.t4g.small")),+ postgres("17.4", "17", false, List.of()),+ postgres("18.1", "18", false, List.of("db.t3.micro", "db.m8g.large")),+ postgres("18.4", "18", false, List.of("db.m8g.large")),+ new EngineVersion("mysql", "8.0.36", "8.0", "mysql8.0", "MySQL Community Edition", true,+ List.of("db.t3.micro"), PROVISIONED),+ new EngineVersion("mysql", "8.4.4", "8.4", "mysql8.4", "MySQL Community Edition", false,+ List.of(), PROVISIONED),+ new EngineVersion("mariadb", "10.11.11", "10.11", "mariadb10.11", "MariaDb Community Edition", false,+ List.of(), PROVISIONED),+ new EngineVersion("mariadb", "11.2", "11.2", "mariadb11.2", "MariaDb Community Edition", true,+ List.of("db.t3.micro"), PROVISIONED),+ new EngineVersion("mariadb", "11.4.5", "11.4", "mariadb11.4", "MariaDb Community Edition", false,+ List.of(), PROVISIONED),+ new EngineVersion("sqlserver-se", "15.00", "15.00", "sqlserver15", "SQL Server Standard Edition", true,+ List.of("db.t3.micro"), PROVISIONED),+ new EngineVersion("aurora-postgresql", "15.12", "15", "aurora-postgresql15",+ "Aurora (PostgreSQL)", false, List.of(), PROVISIONED),+ new EngineVersion("aurora-postgresql", "16.3", "16", "aurora-postgresql16",+ "Aurora (PostgreSQL)", true, List.of(), PROVISIONED),+ new EngineVersion("aurora-postgresql", "17.4", "17", "aurora-postgresql17",+ "Aurora (PostgreSQL)", false, List.of(), PROVISIONED),+ new EngineVersion("aurora-mysql", "8.0.mysql_aurora.3.05.2", "8.0", "aurora-mysql8.0",+ "Aurora MySQL", true, List.of(), PROVISIONED),+ new EngineVersion("aurora-mysql", "8.0.mysql_aurora.3.08.0", "8.0", "aurora-mysql8.0",+ "Aurora MySQL", false, List.of(), PROVISIONED));++ private RdsEngineCatalog() {+ }++ private static EngineVersion postgres(String version, String major, boolean isDefault, List<String> classes) {+ return new EngineVersion("postgres", version, major, "postgres" + major, "PostgreSQL", isDefault,+ classes, PROVISIONED);+ }++ // The log types each engine has long published to CloudWatch Logs, per the RDS and Aurora user+ // guides. Floci stores EnableCloudwatchLogsExports as given and ships nothing.+ private static final Map<String, List<String>> EXPORTABLE_LOG_TYPES = Map.of(+ "postgres", List.of("postgresql", "upgrade"),+ "mysql", List.of("audit", "error", "general", "slowquery"),+ "mariadb", List.of("audit", "error", "general", "slowquery"),+ "sqlserver-se", List.of("agent", "error"),+ "aurora-mysql", List.of("audit", "error", "general", "slowquery"),+ "aurora-postgresql", List.of("postgresql"));++ // The FeatureName values AddRoleToDBInstance and AddRoleToDBCluster accept for each engine, per+ // the user guides; MySQL, MariaDB and Aurora MySQL take none (Aurora MySQL names its roles in+ // cluster parameters instead).+ private static final Map<String, List<String>> FEATURE_NAMES = Map.of(+ "postgres", List.of("s3Import", "s3Export", "Lambda"),+ "sqlserver-se", List.of("S3_INTEGRATION"),+ "aurora-postgresql", List.of("s3Import", "s3Export", "Lambda", "Comprehend", "SageMaker"));++ static List<String> exportableLogTypes(EngineVersion version) {+ return EXPORTABLE_LOG_TYPES.getOrDefault(version.engine(), List.of());+ }++ static List<String> supportedFeatureNames(EngineVersion version) {+ return FEATURE_NAMES.getOrDefault(version.engine(), List.of());+ }++ /** Floci creates read replicas of PostgreSQL instances only. */+ static boolean supportsReadReplica(EngineVersion version) {+ return version.engine().equals("postgres");+ }++ static boolean supportsGlobalDatabases(EngineVersion version) {+ return RdsService.GLOBAL_CLUSTER_ENGINES.contains(version.engine());+ }++ /**+ * The version a create request that names none gets: the engine's flagged default. {@code aurora}+ * is Aurora MySQL's older engine name and the SQL Server editions share one entry. Null when the+ * catalogue does not know the engine; no engine at all means PostgreSQL.+ */+ static String defaultVersion(String engine) {+ String name = engine == null ? "postgres" : engine.toLowerCase(Locale.ROOT);+ String catalogued = switch (name) {+ case "aurora" -> "aurora-mysql";+ case "sqlserver-ee", "sqlserver-ex", "sqlserver-web" -> "sqlserver-se";+ default -> name;+ };+ return VERSIONS.stream()+ .filter(v -> v.isDefault() && v.engine().equals(catalogued))+ .map(EngineVersion::version)+ .findFirst()+ .orElse(null);+ }++ /**+ * Whether {@code requested} names {@code version}: the exact version, or a prefix of it ending+ * at a dot, so {@code 16} and {@code 16.3} both name {@code 16.3}.+ */+ static boolean versionMatches(String version, String requested) {+ String wanted = requested.toLowerCase(Locale.ROOT);+ String actual = version.toLowerCase(Locale.ROOT);+ return actual.equals(wanted) || actual.startsWith(wanted + ".");+ }++ /** The later versions of the same engine, oldest first, as ValidUpgradeTarget lists them. */+ static List<EngineVersion> upgradeTargets(EngineVersion from) {+ List<EngineVersion> targets = new ArrayList<>();+ for (EngineVersion candidate : VERSIONS) {+ if (candidate.engine().equals(from.engine()) && compareVersions(candidate.version(), from.version()) > 0) {+ targets.add(candidate);+ }+ }+ targets.sort(Comparator.comparing(EngineVersion::version, RdsEngineCatalog::compareVersions));+ return targets;+ }++ /** Numeric parts compare as numbers and the rest as text, so 16.14 sorts after 16.3. */+ static int compareVersions(String left, String right) {+ String[] a = left.split("\\.");+ String[] b = right.split("\\.");+ for (int i = 0; i < Math.max(a.length, b.length); i++) {+ String x = i < a.length ? a[i] : "";+ String y = i < b.length ? b[i] : "";+ int cmp = x.matches("\\d+") && y.matches("\\d+")+ ? Long.compare(Long.parseLong(x), Long.parseLong(y))+ : x.compareTo(y);+ if (cmp != 0) {+ return cmp;+ }+ }+ return 0;+ }++ /** Whether a parameter group family is one the catalogue's versions use. */+ static boolean knowsFamily(String family) {+ return family != null && VERSIONS.stream().anyMatch(v -> v.family().equalsIgnoreCase(family));+ }+}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 33980af5c5..8024531f9f 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@@ -92,6 +92,12 @@ public class RdsQueryHandler {case "PromoteReadReplica" -> handlePromoteReadReplica(params, region);case "SwitchoverReadReplica" -> handleSwitchoverReadReplica(params, region);case "PromoteReadReplicaDBCluster" -> handlePromoteReadReplicaDbCluster(params, region);+ case "DescribeDBEngineVersions" -> handleDescribeDbEngineVersions(params);+ case "DescribeEngineDefaultParameters" -> handleDescribeEngineDefaultParameters(params,+ "DescribeEngineDefaultParameters");+ case "DescribeEngineDefaultClusterParameters" -> handleDescribeEngineDefaultParameters(params,+ "DescribeEngineDefaultClusterParameters");+ case "DescribeValidDBInstanceModifications" -> handleDescribeValidDbInstanceModifications(params, region);case "DescribeOrderableDBInstanceOptions" -> handleDescribeOrderableDbInstanceOptions(params);case "DescribeEvents" -> handleDescribeEvents(params, region);case "CreateEventSubscription" -> handleCreateEventSubscription(params, region);@@ -715,6 +721,109 @@ public class RdsQueryHandler {}}+ private Response handleDescribeDbEngineVersions(MultivaluedMap<String, String> params) {+ Map<String, List<String>> filters = new LinkedHashMap<>();+ for (String name : List.of("db-parameter-group-family", "engine", "engine-mode", "engine-version", "status")) {+ List<String> values = extractRdsFilterValues(params, name);+ if (!values.isEmpty()) {+ filters.put(name, values);+ }+ }+ RdsService.EngineVersionPage page = service.describeDbEngineVersions(+ params.getFirst("Engine"),+ params.getFirst("EngineVersion"),+ params.getFirst("DBParameterGroupFamily"),+ Boolean.parseBoolean(params.getFirst("DefaultOnly")),+ filters,+ optionalInt(params.getFirst("MaxRecords")),+ params.getFirst("Marker"));+ XmlBuilder xml = new XmlBuilder().start("DBEngineVersions");+ for (RdsEngineCatalog.EngineVersion v : page.versions()) {+ xml.start("DBEngineVersion")+ .elem("Engine", v.engine())+ .elem("MajorEngineVersion", v.majorVersion())+ .elem("EngineVersion", v.version())+ .elem("DBParameterGroupFamily", v.family())+ .elem("DBEngineDescription", v.engineDescription())+ .elem("DBEngineVersionDescription", v.versionDescription())+ .start("ValidUpgradeTarget");+ for (RdsEngineCatalog.EngineVersion target : RdsEngineCatalog.upgradeTargets(v)) {+ xml.start("UpgradeTarget")+ .elem("Engine", target.engine())+ .elem("EngineVersion", target.version())+ .elem("Description", target.versionDescription())+ .elem("AutoUpgrade", false)+ .elem("IsMajorVersionUpgrade", !target.majorVersion().equals(v.majorVersion()))+ .end("UpgradeTarget");+ }+ xml.end("ValidUpgradeTarget").start("ExportableLogTypes");+ RdsEngineCatalog.exportableLogTypes(v).forEach(type -> xml.elem("member", type));+ xml.end("ExportableLogTypes")+ .elem("SupportsLogExportsToCloudwatchLogs", !RdsEngineCatalog.exportableLogTypes(v).isEmpty())+ .elem("SupportsReadReplica", RdsEngineCatalog.supportsReadReplica(v))+ .start("SupportedEngineModes");+ v.engineModes().forEach(mode -> xml.elem("member", mode));+ xml.end("SupportedEngineModes").start("SupportedFeatureNames");+ RdsEngineCatalog.supportedFeatureNames(v).forEach(name -> xml.elem("member", name));+ xml.end("SupportedFeatureNames")+ .elem("Status", "available")+ .elem("SupportsParallelQuery", false)+ .elem("SupportsGlobalDatabases", RdsEngineCatalog.supportsGlobalDatabases(v))+ .elem("SupportsBabelfish", false)+ .end("DBEngineVersion");+ }+ xml.end("DBEngineVersions");+ if (page.marker() != null) {+ xml.elem("Marker", page.marker());+ }+ return Response.ok(AwsQueryResponse.envelope("DescribeDBEngineVersions", AwsNamespaces.RDS,+ xml.build())).build();+ }++ /** Serves both engine default calls; they share the request and the EngineDefaults shape. */+ private Response handleDescribeEngineDefaultParameters(MultivaluedMap<String, String> params, String action) {+ String family = params.getFirst("DBParameterGroupFamily");+ List<Map<String, String>> parameters = service.describeEngineDefaultParameters(family);+ XmlBuilder xml = new XmlBuilder().start("EngineDefaults")+ .elem("DBParameterGroupFamily", family)+ .start("Parameters");+ for (Map<String, String> parameter : parameters) {+ xml.start("Parameter")+ .elem("ParameterName", parameter.get("name"))+ .elem("ParameterValue", parameter.get("value"))+ .end("Parameter");+ }+ xml.end("Parameters").end("EngineDefaults");+ return Response.ok(AwsQueryResponse.envelope(action, AwsNamespaces.RDS, xml.build())).build();+ }++ private Response handleDescribeValidDbInstanceModifications(MultivaluedMap<String, String> params, String region) {+ List<RdsService.StorageModification> storage = service.describeValidDbInstanceModifications(+ params.getFirst("DBInstanceIdentifier"), region);+ XmlBuilder xml = new XmlBuilder().start("ValidDBInstanceModificationsMessage").start("Storage");+ for (RdsService.StorageModification option : storage) {+ xml.start("ValidStorageOptions")+ .elem("StorageType", option.storageType())+ .start("StorageSize");+ for (RdsService.SizeRange range : option.sizes()) {+ xml.start("Range")+ .elem("From", range.from())+ .elem("To", range.to())+ .elem("Step", 1)+ .end("Range");+ }+ xml.end("StorageSize")+ .elem("SupportsStorageAutoscaling", true)+ .end("ValidStorageOptions");+ }+ xml.end("Storage")+ .start("ValidProcessorFeatures").end("ValidProcessorFeatures")+ .elem("SupportsDedicatedLogVolume", false)+ .end("ValidDBInstanceModificationsMessage");+ return Response.ok(AwsQueryResponse.envelope("DescribeValidDBInstanceModifications", AwsNamespaces.RDS,+ xml.build())).build();+ }+private Response handleDescribeOrderableDbInstanceOptions(MultivaluedMap<String, String> params) {Collection<Map<String, String>> options = service.describeOrderableDbInstanceOptions(params.getFirst("Engine"),@@ -3206,16 +3315,9 @@ public class RdsQueryHandler {}}+ /** The catalogue's default for the engine, or {@code 1.0} for an engine it does not list. */private static String defaultEngineVersion(String engine) {- if (engine == null) {- return "16.3";- }- return switch (engine.toLowerCase()) {- case "postgres", "aurora-postgresql" -> "16.3";- case "mysql", "aurora-mysql", "aurora" -> "8.0.36";- case "mariadb" -> "11.2";- case "sqlserver-ee", "sqlserver-se", "sqlserver-ex", "sqlserver-web" -> "15.00";- default -> "1.0";- };+ String version = RdsEngineCatalog.defaultVersion(engine);+ return version != null ? version : "1.0";}}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 f285ab802d..cad1249c18 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@@ -3098,32 +3098,135 @@ public class RdsService implements Resettable, ResourceProvider {+ "] does not exist, is not enabled or you do not have permissions to access it.", 400);}+ /**+ * The orderable classes the engine catalogue lists, narrowed by engine, version and class. The+ * version matches exactly or as a prefix ending at a dot, so {@code 8.0} still finds the MySQL+ * 8.0 rows now that the catalogue names {@code 8.0.36}.+ */public List<Map<String, String>> describeOrderableDbInstanceOptions(String engine,String engineVersion,String dbInstanceClass) {- List<Map<String, String>> options = List.of(- Map.of("engine", "postgres", "engineVersion", "16.3", "dbInstanceClass", "db.t3.micro"),- Map.of("engine", "postgres", "engineVersion", "16.14", "dbInstanceClass", "db.t3.micro"),- Map.of("engine", "postgres", "engineVersion", "18.1", "dbInstanceClass", "db.t3.micro"),- Map.of("engine", "postgres", "engineVersion", "18.1", "dbInstanceClass", "db.m8g.large"),- Map.of("engine", "postgres", "engineVersion", "18.4", "dbInstanceClass", "db.m8g.large"),- Map.of("engine", "postgres", "engineVersion", "16.3", "dbInstanceClass", "db.t4g.micro"),- Map.of("engine", "postgres", "engineVersion", "16.3", "dbInstanceClass", "db.t4g.small"),- Map.of("engine", "postgres", "engineVersion", "16.14", "dbInstanceClass", "db.t4g.small"),- Map.of("engine", "postgres", "engineVersion", "16.3", "dbInstanceClass", "db.t4g.medium"),- Map.of("engine", "mysql", "engineVersion", "8.0", "dbInstanceClass", "db.t3.micro"),- Map.of("engine", "mariadb", "engineVersion", "11", "dbInstanceClass", "db.t3.micro"),- Map.of("engine", "sqlserver-se", "engineVersion", "15.00", "dbInstanceClass", "db.t3.micro")- );+ List<Map<String, String>> options = new ArrayList<>();+ for (RdsEngineCatalog.EngineVersion version : RdsEngineCatalog.VERSIONS) {+ for (String instanceClass : version.instanceClasses()) {+ options.add(Map.of("engine", version.engine(), "engineVersion", version.version(),+ "dbInstanceClass", instanceClass));+ }+ }return options.stream().filter(option -> engine == null || engine.isBlank() || engine.equalsIgnoreCase(option.get("engine"))).filter(option -> engineVersion == null || engineVersion.isBlank()- || engineVersion.equalsIgnoreCase(option.get("engineVersion")))+ || RdsEngineCatalog.versionMatches(option.get("engineVersion"), engineVersion)).filter(option -> dbInstanceClass == null || dbInstanceClass.isBlank()|| dbInstanceClass.equalsIgnoreCase(option.get("dbInstanceClass"))).toList();}+ // ── Catalogue reads ───────────────────────────────────────────────────────++ // The largest allocation, in GiB, the RDS user guide gives for general purpose storage.+ private static final int MAX_STORAGE_GIB = 65_536;+ private static final int MAX_SQLSERVER_STORAGE_GIB = 16_384;++ public record EngineVersionPage(List<RdsEngineCatalog.EngineVersion> versions, String marker) {}++ /**+ * The catalogue's engine versions, narrowed by engine, version (exact, or a major version such+ * as {@code 16}), family and the documented filters. Every version is available, so+ * {@code IncludeAll} changes nothing. With {@code DefaultOnly}, each engine (or engine and major+ * version, when the request names a version) contributes its default: the flagged one, or the+ * latest of that major version.+ */+ public EngineVersionPage describeDbEngineVersions(String engine, String engineVersion, String family,+ boolean defaultOnly, Map<String, List<String>> filters,+ Integer maxRecords, String marker) {+ requireValidMaxRecords(maxRecords);+ List<RdsEngineCatalog.EngineVersion> matching = RdsEngineCatalog.VERSIONS.stream()+ .filter(v -> isBlank(engine) || v.engine().equalsIgnoreCase(engine))+ .filter(v -> isBlank(engineVersion) || RdsEngineCatalog.versionMatches(v.version(), engineVersion))+ .filter(v -> isBlank(family) || v.family().equalsIgnoreCase(family))+ .filter(v -> matchesFilter(filters, "engine", v.engine()))+ .filter(v -> matchesFilter(filters, "db-parameter-group-family", v.family()))+ .filter(v -> filterValues(filters, "engine-version").isEmpty()+ || filterValues(filters, "engine-version").stream()+ .anyMatch(w -> RdsEngineCatalog.versionMatches(v.version(), w)))+ .filter(v -> filterValues(filters, "engine-mode").isEmpty()+ || v.engineModes().stream().anyMatch(m -> matchesFilter(filters, "engine-mode", m)))+ .filter(v -> matchesFilter(filters, "status", "available"))+ .toList();+ if (defaultOnly) {+ boolean byMajor = !isBlank(engineVersion);+ Map<String, RdsEngineCatalog.EngineVersion> defaults = new LinkedHashMap<>();+ for (RdsEngineCatalog.EngineVersion v : matching) {+ String group = byMajor ? v.engine() + "/" + v.majorVersion() : v.engine();+ RdsEngineCatalog.EngineVersion current = defaults.get(group);+ if (current == null || (!current.isDefault() && (v.isDefault()+ || RdsEngineCatalog.compareVersions(v.version(), current.version()) > 0))) {+ defaults.put(group, v);+ }+ }+ matching = List.copyOf(defaults.values());+ }+ OffsetPage<RdsEngineCatalog.EngineVersion> page = offsetPage(matching, maxRecords, marker);+ return new EngineVersionPage(page.items(), page.marker());+ }++ private static List<String> filterValues(Map<String, List<String>> filters, String name) {+ List<String> values = filters != null ? filters.get(name) : null;+ return values != null ? values : List.of();+ }++ /**+ * Checks a family for DescribeEngineDefaultParameters and DescribeEngineDefaultClusterParameters.+ * Floci's default parameter groups hold no parameters (DescribeDBParameters lists only values set+ * on a group), so a known family's defaults are an empty list.+ */+ public List<Map<String, String>> describeEngineDefaultParameters(String family) {+ if (isBlank(family)) {+ throw new AwsException("InvalidParameterValue", "DBParameterGroupFamily is required.", 400);+ }+ if (!RdsEngineCatalog.knowsFamily(family)) {+ throw new AwsException("InvalidParameterValue",+ "DBParameterGroupFamily " + family + " is not supported.", 400);+ }+ return List.of();+ }++ /** What ModifyDBInstance can change about an instance's storage: its type and the sizes it can take. */+ public record StorageModification(String storageType, List<SizeRange> sizes) {}++ public record SizeRange(int from, int to) {}++ /**+ * The storage an instance can move to: its storage type and the sizes ModifyDBInstance stores as+ * asked. Storage only grows. For PostgreSQL, MySQL and MariaDB an increase under 10% is rounded+ * up to 10%, so the sizes are the current one (no change) and from 10% more up to the engine's+ * maximum; SQL Server takes any larger size. An Aurora instance has no storage of its own to+ * modify, so it has none.+ */+ public List<StorageModification> describeValidDbInstanceModifications(String id, String region) {+ String effectiveRegion = effectiveRegion(region);+ if (isBlank(id)) {+ throw new AwsException("InvalidParameterValue", "DBInstanceIdentifier is required.", 400);+ }+ DbInstance instance = getDbInstance(id, effectiveRegion);+ if (instance.getStatus() != null && instance.getStatus() != DbInstanceStatus.AVAILABLE) {+ throw new AwsException("InvalidDBInstanceState",+ "DB instance " + id + " is not in available state.", 400);+ }+ if (!isBlank(instance.getDbClusterIdentifier())) {+ return List.of();+ }+ int maximum = instance.getEngine() == DatabaseEngine.SQLSERVER ? MAX_SQLSERVER_STORAGE_GIB : MAX_STORAGE_GIB;+ int current = Math.min(instance.getAllocatedStorage(), maximum);+ int smallestIncrease = instance.getEngine() == DatabaseEngine.SQLSERVER+ ? current + 1 : Math.ceilDiv(current * 11, 10);+ List<SizeRange> sizes = smallestIncrease <= maximum+ ? List.of(new SizeRange(current, current), new SizeRange(smallestIncrease, maximum))+ : List.of(new SizeRange(current, current));+ return List.of(new StorageModification(DbInstance.DEFAULT_STORAGE_TYPE, sizes));+ }+// ── Stop, start and reboot ────────────────────────────────────────────────/** Aurora members are stopped and started through their cluster; the model lists InvalidDBClusterStateFault for both calls. */@@ -4618,7 +4721,7 @@ public class RdsService implements Resettable, ResourceProvider {// ── Global clusters (Aurora global databases) ─────────────────────────────- private static final Set<String> GLOBAL_CLUSTER_ENGINES = Set.of("aurora-mysql", "aurora-postgresql");+ static final Set<String> GLOBAL_CLUSTER_ENGINES = Set.of("aurora-mysql", "aurora-postgresql");/*** Creates an Aurora global database, empty or with an existing cluster (named by ARN or, in@@ -4680,7 +4783,7 @@ public class RdsService implements Resettable, ResourceProvider {requireGlobalClusterEngine(engine, null);global.setEngine(engine.toLowerCase(Locale.ROOT));global.setEngineVersion(hasText(engineVersion)- ? engineVersion : defaultGlobalEngineVersion(global.getEngine()));+ ? engineVersion : RdsEngineCatalog.defaultVersion(global.getEngine()));global.setDatabaseName(hasText(databaseName) ? databaseName : null);global.setStorageEncrypted(Boolean.TRUE.equals(storageEncrypted));}@@ -5131,9 +5234,6 @@ public class RdsService implements Resettable, ResourceProvider {}}- private static String defaultGlobalEngineVersion(String engine) {- return "aurora-mysql".equals(engine) ? "8.0.mysql_aurora.3.05.2" : "16.3";- }private static boolean sameMajorVersion(String current, String requested) {if (current == null || requested == null) {@@ -6834,17 +6934,14 @@ public class RdsService implements Resettable, ResourceProvider {}}- private String expectedClusterParameterGroupFamily(String engineParam, String engineVersion) {+ String expectedClusterParameterGroupFamily(String engineParam, String engineVersion) {String normalizedEngine = effectiveEngineName(engineParam).toLowerCase();String effectiveVersion = engineVersion;if (effectiveVersion == null || effectiveVersion.isBlank()) {- effectiveVersion = switch (normalizedEngine) {- case "postgres", "aurora-postgresql" -> "16.3";- case "mysql", "aurora", "aurora-mysql" -> "8.0.36";- case "mariadb" -> "11.2";- case "sqlserver-ee", "sqlserver-se", "sqlserver-ex", "sqlserver-web" -> "15.00";- default -> throw new AwsException("InvalidParameterValue", invalidParameterValueMessage(), 400);- };+ effectiveVersion = RdsEngineCatalog.defaultVersion(normalizedEngine);+ if (effectiveVersion == null) {+ throw new AwsException("InvalidParameterValue", invalidParameterValueMessage(), 400);+ }}Matcher matcher = IMAGE_TAG_VERSION_PATTERN.matcher(effectiveVersion.trim());@@ -9222,6 +9319,35 @@ public class RdsService implements Resettable, ResourceProvider {private static final int MAX_MAX_RECORDS = 100;private static final int DEFAULT_MAX_RECORDS = 100;+ private static void requireValidMaxRecords(Integer maxRecords) {+ if (maxRecords != null && (maxRecords < MIN_MAX_RECORDS || maxRecords > MAX_MAX_RECORDS)) {+ throw new AwsException("InvalidParameterValue",+ "MaxRecords must be between " + MIN_MAX_RECORDS + " and " + MAX_MAX_RECORDS + ".", 400);+ }+ }++ private record OffsetPage<T>(List<T> items, String marker) {}++ /**+ * One page of a list whose marker is the offset of the page's first item, as+ * DescribeDBEngineVersions and DescribeDBClusterEndpoints page. The next marker is null on the+ * last page.+ */+ private static <T> OffsetPage<T> offsetPage(List<T> matching, Integer maxRecords, String marker) {+ int from = 0;+ if (!isBlank(marker)) {+ try {+ from = Integer.parseInt(marker);+ } catch (NumberFormatException e) {+ throw new AwsException("InvalidParameterValue", "Invalid marker: " + marker, 400);+ }+ }+ int limit = maxRecords == null ? DEFAULT_MAX_RECORDS : maxRecords;+ int start = Math.min(Math.max(from, 0), matching.size());+ int to = Math.min(matching.size(), start + limit);+ return new OffsetPage<>(matching.subList(start, to), to < matching.size() ? Integer.toString(to) : null);+ }+/*** Nothing is published to the topic. The subscription is stored and reported back so a client* can manage it, and no RDS event reaches SNS through it.@@ -9377,10 +9503,7 @@ public class RdsService implements Resettable, ResourceProvider {// Ahead of the named-subscription shortcut, so a bad page size is rejected whether or not// the request also names a subscription. Request validation does not depend on which branch// serves the read.- if (maxRecords != null && (maxRecords < MIN_MAX_RECORDS || maxRecords > MAX_MAX_RECORDS)) {- throw new AwsException("InvalidParameterValue",- "MaxRecords must be between " + MIN_MAX_RECORDS + " and " + MAX_MAX_RECORDS + ".", 400);- }+ requireValidMaxRecords(maxRecords);if (subscriptionName != null && !subscriptionName.isBlank()) {return new EventSubscriptionPage(List.of(requireEventSubscription(region, subscriptionName)), null);@@ -9538,10 +9661,7 @@ public class RdsService implements Resettable, ResourceProvider {Map<String, List<String>> filters,Integer maxRecords, String marker) {String effectiveRegion = effectiveRegion(region);- if (maxRecords != null && (maxRecords < MIN_MAX_RECORDS || maxRecords > MAX_MAX_RECORDS)) {- throw new AwsException("InvalidParameterValue",- "MaxRecords must be between " + MIN_MAX_RECORDS + " and " + MAX_MAX_RECORDS + ".", 400);- }+ requireValidMaxRecords(maxRecords);List<DbCluster> scope = !isBlank(clusterId)? List.of(getDbCluster(clusterId, effectiveRegion)): listDbClusters(null, effectiveRegion).stream()@@ -9570,19 +9690,8 @@ public class RdsService implements Resettable, ResourceProvider {.filter(e -> matchesFilter(filters, "db-cluster-endpoint-id", e.getDbClusterEndpointIdentifier())).filter(e -> matchesFilter(filters, "db-cluster-endpoint-status", e.getStatus())).toList();- int from = 0;- if (!isBlank(marker)) {- try {- from = Integer.parseInt(marker);- } catch (NumberFormatException e) {- throw new AwsException("InvalidParameterValue", "Invalid marker: " + marker, 400);- }- }- int limit = maxRecords == null ? DEFAULT_MAX_RECORDS : maxRecords;- int start = Math.min(Math.max(from, 0), matching.size());- int to = Math.min(matching.size(), start + limit);- return new ClusterEndpointPage(matching.subList(start, to),- to < matching.size() ? Integer.toString(to) : null);+ OffsetPage<DbClusterEndpoint> page = offsetPage(matching, maxRecords, marker);+ return new ClusterEndpointPage(page.items(), page.marker());}private static void requireAuroraCluster(DbCluster cluster) {diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsCatalogueReadIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsCatalogueReadIntegrationTest.javanew file mode 100644index 0000000000..59d124b9dd--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsCatalogueReadIntegrationTest.java@@ -0,0 +1,222 @@+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.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.CsvSource;++import static io.restassured.RestAssured.given;+import static io.restassured.http.ContentType.URLENC;+import static org.hamcrest.Matchers.contains;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.not;+import static org.junit.jupiter.api.Assertions.assertEquals;++/**+ * The RDS catalogue reads over the Query protocol: engine versions with their families, defaults+ * and upgrade targets, the engine default parameter calls, and the storage an instance can move to.+ */+@QuarkusTest+@TestProfile(RdsMockProfile.class)+class RdsCatalogueReadIntegrationTest {++ private static final String VERSIONS =+ "DescribeDBEngineVersionsResponse.DescribeDBEngineVersionsResult.DBEngineVersions.DBEngineVersion";++ private static final String AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20261006/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");+ }++ @Test+ void describeDbEngineVersionsReportsFamiliesDefaultsAndUpgradeTargets() {+ query("DescribeDBEngineVersions")+ .formParam("Engine", "postgres")+ .formParam("EngineVersion", "16.3")+ .when().post("/").then()+ .statusCode(200)+ .body(VERSIONS + ".size()", equalTo(1))+ .body(VERSIONS + ".DBParameterGroupFamily", equalTo("postgres16"))+ .body(VERSIONS + ".MajorEngineVersion", equalTo("16"))+ .body(VERSIONS + ".DBEngineDescription", equalTo("PostgreSQL"))+ .body(VERSIONS + ".Status", equalTo("available"))+ .body(VERSIONS + ".SupportedEngineModes.member", equalTo("provisioned"))+ .body(VERSIONS + ".ValidUpgradeTarget.UpgradeTarget.size()", equalTo(4))+ .body(VERSIONS + ".ValidUpgradeTarget.UpgradeTarget[0].EngineVersion", equalTo("16.14"))+ .body(VERSIONS + ".ValidUpgradeTarget.UpgradeTarget[0].IsMajorVersionUpgrade", equalTo("false"))+ .body(VERSIONS + ".ValidUpgradeTarget.UpgradeTarget[1].IsMajorVersionUpgrade", equalTo("true"));++ // A major version names every version in it; DefaultOnly then keeps that major's default.+ query("DescribeDBEngineVersions").formParam("Engine", "postgres").formParam("EngineVersion", "18")+ .when().post("/").then().statusCode(200).body(VERSIONS + ".size()", equalTo(2));+ query("DescribeDBEngineVersions").formParam("Engine", "postgres").formParam("EngineVersion", "18")+ .formParam("DefaultOnly", "true")+ .when().post("/").then().statusCode(200)+ .body(VERSIONS + ".EngineVersion", equalTo("18.4"));+ // Without a version, DefaultOnly gives the version Floci creates when none is named.+ query("DescribeDBEngineVersions").formParam("Engine", "aurora-mysql").formParam("DefaultOnly", "true")+ .when().post("/").then().statusCode(200)+ .body(VERSIONS + ".EngineVersion", equalTo("8.0.mysql_aurora.3.05.2"))+ .body(VERSIONS + ".DBParameterGroupFamily", equalTo("aurora-mysql8.0"));++ query("DescribeDBEngineVersions")+ .formParam("Filters.Filter.1.Name", "db-parameter-group-family")+ .formParam("Filters.Filter.1.Values.Value.1", "mysql8.4")+ .when().post("/").then().statusCode(200)+ .body(VERSIONS + ".EngineVersion", equalTo("8.4.4"));+ query("DescribeDBEngineVersions").formParam("Engine", "oracle-ee")+ .when().post("/").then().statusCode(200)+ .body(not(containsString("<DBEngineVersion>")));+ query("DescribeDBEngineVersions").formParam("MaxRecords", "20")+ .when().post("/").then().statusCode(200)+ .body(VERSIONS + ".size()", equalTo(19))+ .body(not(containsString("<Marker>")));+ }++ @Test+ void engineVersionsReportWhatFlociSupports() {+ query("DescribeDBEngineVersions").formParam("Engine", "postgres").formParam("EngineVersion", "16.3")+ .when().post("/").then()+ .statusCode(200)+ .body(VERSIONS + ".ExportableLogTypes.member", contains("postgresql", "upgrade"))+ .body(VERSIONS + ".SupportsLogExportsToCloudwatchLogs", equalTo("true"))+ .body(VERSIONS + ".SupportsReadReplica", equalTo("true"))+ .body(VERSIONS + ".SupportedFeatureNames.member", contains("s3Import", "s3Export", "Lambda"))+ .body(VERSIONS + ".SupportsParallelQuery", equalTo("false"))+ .body(VERSIONS + ".SupportsGlobalDatabases", equalTo("false"))+ .body(VERSIONS + ".SupportsBabelfish", equalTo("false"));+ query("DescribeDBEngineVersions").formParam("Engine", "aurora-mysql").formParam("DefaultOnly", "true")+ .when().post("/").then()+ .statusCode(200)+ .body(VERSIONS + ".ExportableLogTypes.member", contains("audit", "error", "general", "slowquery"))+ .body(VERSIONS + ".SupportsReadReplica", equalTo("false"))+ .body(containsString("<SupportedFeatureNames></SupportedFeatureNames>"))+ .body(VERSIONS + ".SupportsGlobalDatabases", equalTo("true"));+ }++ @Test+ void engineVersionsPageByOffset() {+ query("DescribeDBEngineVersions").formParam("Marker", "15")+ .when().post("/").then().statusCode(200)+ .body(VERSIONS + ".size()", equalTo(4))+ .body(not(containsString("<Marker>")));+ query("DescribeDBEngineVersions").formParam("Marker", "next")+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>InvalidParameterValue</Code>"));+ query("DescribeDBEngineVersions").formParam("MaxRecords", "19")+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>InvalidParameterValue</Code>"));+ }++ /** A create that names no version gets the version DescribeDBEngineVersions calls the default. */+ @ParameterizedTest+ @CsvSource({"postgres", "mysql", "mariadb", "sqlserver-se"})+ void instanceCreatedWithoutAVersionGetsTheCataloguesDefault(String engine) {+ String id = "default-" + engine;+ String created = query("CreateDBInstance")+ .formParam("DBInstanceIdentifier", id)+ .formParam("Engine", engine)+ .formParam("MasterUsername", "admin")+ .formParam("MasterUserPassword", "password123")+ .formParam("DBInstanceClass", "db.t3.micro")+ .formParam("AllocatedStorage", "20")+ .when().post("/").then().statusCode(200)+ .extract().xmlPath().getString("CreateDBInstanceResponse.CreateDBInstanceResult.DBInstance.EngineVersion");+ assertEquals(defaultVersion(engine), created);+ query("DeleteDBInstance").formParam("DBInstanceIdentifier", id).formParam("SkipFinalSnapshot", "true")+ .when().post("/").then().statusCode(200);+ }++ @ParameterizedTest+ @CsvSource({"aurora-mysql, 8.0.mysql_aurora.3.05.2", "aurora-postgresql, 16.3"})+ void clusterCreatedWithoutAVersionGetsTheCataloguesDefault(String engine, String expected) {+ String id = "default-" + engine;+ String created = query("CreateDBCluster")+ .formParam("DBClusterIdentifier", id)+ .formParam("Engine", engine)+ .formParam("MasterUsername", "admin")+ .formParam("MasterUserPassword", "password123")+ .when().post("/").then().statusCode(200)+ .extract().xmlPath().getString("CreateDBClusterResponse.CreateDBClusterResult.DBCluster.EngineVersion");+ assertEquals(expected, created);+ assertEquals(defaultVersion(engine), created);+ query("DeleteDBCluster").formParam("DBClusterIdentifier", id).formParam("SkipFinalSnapshot", "true")+ .when().post("/").then().statusCode(200);+ }++ private static String defaultVersion(String engine) {+ return query("DescribeDBEngineVersions").formParam("Engine", engine).formParam("DefaultOnly", "true")+ .when().post("/").then().statusCode(200)+ .extract().xmlPath().getString(VERSIONS + ".EngineVersion");+ }++ @Test+ void orderableOptionsComeFromTheSameCatalogue() {+ query("DescribeOrderableDBInstanceOptions").formParam("Engine", "mysql")+ .when().post("/").then().statusCode(200)+ .body(containsString("<EngineVersion>8.0.36</EngineVersion>"));+ // The versions the list used to name still find their rows.+ query("DescribeOrderableDBInstanceOptions").formParam("Engine", "mysql").formParam("EngineVersion", "8.0")+ .when().post("/").then().statusCode(200)+ .body(containsString("<DBInstanceClass>db.t3.micro</DBInstanceClass>"));+ query("DescribeOrderableDBInstanceOptions").formParam("Engine", "mariadb").formParam("EngineVersion", "11")+ .when().post("/").then().statusCode(200)+ .body(containsString("<EngineVersion>11.2</EngineVersion>"));+ }++ @Test+ void engineDefaultParametersCheckTheFamily() {+ query("DescribeEngineDefaultParameters").formParam("DBParameterGroupFamily", "postgres16")+ .when().post("/").then()+ .statusCode(200)+ .body(containsString("<DescribeEngineDefaultParametersResult><EngineDefaults>"+ + "<DBParameterGroupFamily>postgres16</DBParameterGroupFamily><Parameters></Parameters>"));+ query("DescribeEngineDefaultClusterParameters").formParam("DBParameterGroupFamily", "aurora-postgresql16")+ .when().post("/").then()+ .statusCode(200)+ .body(containsString("<DescribeEngineDefaultClusterParametersResult><EngineDefaults>"));+ query("DescribeEngineDefaultParameters").formParam("DBParameterGroupFamily", "postgres9")+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>InvalidParameterValue</Code>"));+ query("DescribeEngineDefaultParameters")+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>InvalidParameterValue</Code>"));+ }++ @Test+ void validModificationsGiveTheStorageRangeFromTheCurrentAllocation() {+ query("CreateDBInstance")+ .formParam("DBInstanceIdentifier", "catalogue-db")+ .formParam("Engine", "postgres")+ .formParam("MasterUsername", "admin")+ .formParam("MasterUserPassword", "password123")+ .formParam("DBInstanceClass", "db.t3.micro")+ .formParam("AllocatedStorage", "40")+ .when().post("/").then().statusCode(200);++ query("DescribeValidDBInstanceModifications").formParam("DBInstanceIdentifier", "catalogue-db")+ .when().post("/").then()+ .statusCode(200)+ // 40 GiB stays as it is, and any increase stores at least 10% more (44 GiB).+ .body(containsString("<ValidStorageOptions><StorageType>gp2</StorageType><StorageSize>"+ + "<Range><From>40</From><To>40</To><Step>1</Step></Range>"+ + "<Range><From>44</From><To>65536</To><Step>1</Step></Range></StorageSize>"+ + "<SupportsStorageAutoscaling>true</SupportsStorageAutoscaling></ValidStorageOptions>"));+ query("DescribeValidDBInstanceModifications").formParam("DBInstanceIdentifier", "catalogue-missing")+ .when().post("/").then().statusCode(404)+ .body(containsString("<Code>DBInstanceNotFound</Code>"));++ query("DeleteDBInstance").formParam("DBInstanceIdentifier", "catalogue-db")+ .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 82e6203c87..f789e08ea8 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@@ -2396,6 +2396,35 @@ class RdsServiceTest {any(), anyInt(), any(), any(), any(), any(), any(), any());}+ @Test+ void engineCatalogueFamiliesMatchTheFamilyCreateComputes() {+ for (RdsEngineCatalog.EngineVersion version : RdsEngineCatalog.VERSIONS) {+ assertEquals(rdsService.expectedClusterParameterGroupFamily(version.engine(), version.version()),+ version.family(), version.engine() + " " + version.version());+ }+ }++ @Test+ void engineCatalogueOffersEveryOrderableVersionAndOneDefaultPerEngine() {+ for (Map<String, String> option : rdsService.describeOrderableDbInstanceOptions(null, null, null)) {+ assertEquals(1, rdsService.describeDbEngineVersions(option.get("engine"), option.get("engineVersion"),+ null, false, Map.of(), null, null).versions().stream()+ .filter(v -> v.version().equals(option.get("engineVersion"))).count());+ }+ Map<String, Long> defaults = RdsEngineCatalog.VERSIONS.stream()+ .filter(RdsEngineCatalog.EngineVersion::isDefault)+ .collect(Collectors.groupingBy(RdsEngineCatalog.EngineVersion::engine, Collectors.counting()));+ RdsEngineCatalog.VERSIONS.forEach(v -> assertEquals(1L, defaults.get(v.engine()), v.engine()));+ }++ @Test+ void engineVersionsSortNumericallyForUpgradeTargets() {+ RdsEngineCatalog.EngineVersion pg163 = RdsEngineCatalog.VERSIONS.stream()+ .filter(v -> v.engine().equals("postgres") && v.version().equals("16.3")).findFirst().orElseThrow();+ assertEquals(List.of("16.14", "17.4", "18.1", "18.4"),+ RdsEngineCatalog.upgradeTargets(pg163).stream().map(RdsEngineCatalog.EngineVersion::version).toList());+ }+@Testvoid describeOrderableDbInstanceOptionsFiltersByEngineVersionAndClass() {List<Map<String, String>> result = rdsService.describeOrderableDbInstanceOptions(