Light, fluffy, and always free - The AWS Local Emulator alternative
feat(rds): restore DB instances and clusters to a point in time (#4963)
David9c49ecf25505
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 3bbc75878f..72919c5f54 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@@ -32,6 +32,7 @@ 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.InvalidOptionGroupStateException;+import software.amazon.awssdk.services.rds.model.InvalidRestoreException;import software.amazon.awssdk.services.rds.model.ListTagsForResourceResponse;import software.amazon.awssdk.services.rds.model.ModifyDbClusterResponse;import software.amazon.awssdk.services.rds.model.ModifyDbProxyResponse;@@ -44,6 +45,7 @@ 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 java.time.Instant;import java.util.List;import java.util.logging.Level;import java.util.logging.Logger;@@ -611,6 +613,69 @@ class RdsControlPlaneTest {}}+ @Test+ @DisplayName("Point in time restore of an instance and a cluster, and the restorable times")+ void sdkRestoresAnInstanceAndAClusterToAPointInTime() {+ String instanceName = TestFixtures.uniqueName("rds-pitr-db");+ String restoredInstance = instanceName + "-restored";+ String clusterName = TestFixtures.uniqueName("rds-pitr-cluster");+ String restoredCluster = clusterName + "-restored";+ try {+ createDbInstance(rds, instanceName, "pitr-secret");+ DBInstance source = rds.describeDBInstances(b -> b.dbInstanceIdentifier(instanceName))+ .dbInstances().get(0);+ assertThat(source.latestRestorableTime()).isNotNull();++ DBInstance restored = rds.restoreDBInstanceToPointInTime(b -> b+ .sourceDBInstanceIdentifier(instanceName)+ .targetDBInstanceIdentifier(restoredInstance)+ .useLatestRestorableTime(true)+ .dbInstanceClass("db.t3.small"))+ .dbInstance();+ assertThat(restored.dbInstanceIdentifier()).isEqualTo(restoredInstance);+ assertThat(restored.dbInstanceClass()).isEqualTo("db.t3.small");+ assertThat(restored.dbName()).isEqualTo("app");++ assertThatThrownBy(() -> rds.restoreDBInstanceToPointInTime(b -> b+ .sourceDBInstanceIdentifier(instanceName)+ .targetDBInstanceIdentifier(instanceName + "-early")+ // Before the source existed, so outside its restorable window.+ .restoreTime(Instant.now().minusSeconds(3 * 86400))))+ .isInstanceOf(InvalidRestoreException.class);++ rds.createDBCluster(b -> b+ .dbClusterIdentifier(clusterName)+ .engine("aurora-postgresql")+ .engineVersion("16.3")+ .masterUsername("admin")+ .masterUserPassword("pitr-secret")+ .databaseName("app"));+ DBCluster sourceCluster = rds.describeDBClusters(b -> b.dbClusterIdentifier(clusterName))+ .dbClusters().get(0);+ assertThat(sourceCluster.earliestRestorableTime()).isNotNull();+ assertThat(sourceCluster.latestRestorableTime()).isAfterOrEqualTo(sourceCluster.earliestRestorableTime());++ DBCluster restoredFromTime = rds.restoreDBClusterToPointInTime(b -> b+ .dbClusterIdentifier(restoredCluster)+ .sourceDBClusterIdentifier(sourceCluster.dbClusterArn())+ .restoreToTime(sourceCluster.earliestRestorableTime())+ .restoreType("copy-on-write"))+ .dbCluster();+ assertThat(restoredFromTime.dbClusterIdentifier()).isEqualTo(restoredCluster);+ assertThat(restoredFromTime.databaseName()).isEqualTo("app");+ } finally {+ deleteDbInstance(rds, restoredInstance);+ deleteDbInstance(rds, instanceName);+ for (String name : List.of(restoredCluster, clusterName)) {+ try {+ rds.deleteDBCluster(b -> b.dbClusterIdentifier(name).skipFinalSnapshot(true));+ } catch (Exception e) {+ LOG.log(Level.WARNING, "Failed to clean up RDS cluster " + name, e);+ }+ }+ }+ }+private static CreateDbProxyResponse createIamProxy(RdsClient client, String name, List<String> vpcSubnetIds) {return client.createDBProxy(b -> b.dbProxyName(name)diff --git a/docs/services/rds.md b/docs/services/rds.mdindex 6fc369a02c..d1ebcdc2d3 100644--- a/docs/services/rds.md+++ b/docs/services/rds.md@@ -97,6 +97,7 @@ RDS Data API (`rds-data`) is documented separately because it uses REST JSON rou| `CopyDBSnapshot` | Copy an available DB snapshot, optionally copying tags or overriding the option group and KMS key || `ModifyDBSnapshot` | Change the engine version or option group of an available manual DB snapshot || `RestoreDBInstanceFromDBSnapshot` | Create a new DB instance from a snapshot |+| `RestoreDBInstanceToPointInTime` | Create a new DB instance from a source instance at a time in its restorable window; see [Point in time restore](#point-in-time-restore) || `DescribeDBSnapshots` | List DB instance snapshots || `DescribeDBSnapshotAttributes` | Return a snapshot's `restore` attribute (accounts authorized to copy/restore it) || `ModifyDBSnapshotAttribute` | Add or remove accounts authorized to copy/restore a snapshot |@@ -114,6 +115,7 @@ RDS Data API (`rds-data`) is documented separately because it uses REST JSON rou| `DeleteDBClusterSnapshot` | Delete an available cluster snapshot and its data; the response carries `Status` `deleted` || `CopyDBClusterSnapshot` | Copy an available cluster snapshot (by identifier or same-region ARN) to a new manual one with its data; `CopyTags` and `Tags`; the copy reports `SourceDBClusterSnapshotArn` || `RestoreDBClusterFromSnapshot` | Create a cluster from a cluster snapshot's settings and data; `Engine` must match the snapshot's |+| `RestoreDBClusterToPointInTime` | Create a cluster from a source cluster at a time in its restorable window; see [Point in time restore](#point-in-time-restore) || `DescribeDBClusterSnapshotAttributes` | Return the `restore` attribute of a cluster snapshot || `ModifyDBClusterSnapshotAttribute` | Add or remove `restore` values (account ids or `all`) on a cluster snapshot || `DescribeGlobalClusters` | List the account's global clusters with their primary and secondary members; see [Global clusters](#global-clusters) |@@ -209,8 +211,8 @@ they belong to, as the model requires. An omitted `Enabled` activates the subscrRDS requires the Docker socket and port range exposure. For private registry authentication and other Docker settings see [Docker Configuration](../configuration/docker.md).-`CreateDBInstance`, `CreateDBCluster`, `RestoreDBInstanceFromDBSnapshot`, and-`RestoreDBClusterFromSnapshot` honor a requested `Port` only within the configured+`CreateDBInstance`, `CreateDBCluster`, `RestoreDBInstanceFromDBSnapshot`,+`RestoreDBClusterFromSnapshot` and the two point in time restores honor a requested `Port` only within the configuredRDS proxy range. A port outside that range causes Floci to assign the next free portand return it in the endpoint. A port inside the range that is already in use isrejected. This differs from AWS because Floci's local proxy must use a published@@ -526,6 +528,34 @@ 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.+## Point in time restore++`RestoreDBInstanceToPointInTime` and `RestoreDBClusterToPointInTime` check the request as AWS does:+exactly one of `RestoreTime` (`RestoreToTime` for a cluster) and `UseLatestRestorableTime`, and a+time inside the source's restorable window, or `InvalidRestoreFault`. The window is what the describe+calls report. An instance's runs from the later of its creation and the start of its backup+retention period up to `LatestRestorableTime` on `DescribeDBInstances`; an instance with+`BackupRetentionPeriod` 0 reports no `LatestRestorableTime` and is refused with+`PointInTimeRestoreNotEnabled`. Floci does not model a cluster's backup retention, so a cluster's+window runs from its creation (`EarliestRestorableTime`) to `LatestRestorableTime` on+`DescribeDBClusters`.++An instance source is named by `SourceDBInstanceIdentifier` or `SourceDbiResourceId`, a cluster+source by `SourceDBClusterIdentifier` (identifier or ARN) or `SourceDbClusterResourceId`. Restoring+from retained automated backups (`SourceDBInstanceAutomatedBackupsArn`, used for a deleted instance)+is not supported, since Floci keeps no automated backups, and answers+`DBInstanceAutomatedBackupNotFound`. A restored instance takes the source's engine, version,+credentials, database name, storage and encryption, and its instance class unless the request names+one; everything else is the request's or the default a new instance gets. A restored cluster takes+the source's engine, version, credentials, database name and encryption, and has no instances until+they are added with `CreateDBInstance`, as on AWS.++Floci keeps no transaction log, so it cannot rebuild a database as it was at an earlier time. The+target is seeded from a `pg_dumpall` of the source taken when the request arrives, the mechanism read+replicas use, so the restored data is the source's latest state whatever time in the window is+asked for; this is also why `LatestRestorableTime` is always the current time. As with+`CreateDBSnapshot`, only PostgreSQL sources are accepted.+## Global clusters`CreateGlobalCluster` creates an Aurora global database (`aurora-mysql` or `aurora-postgresql`),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 01eba60703..d0552c3e38 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@@ -30,6 +30,7 @@ import io.github.hectorvent.floci.services.rds.model.GlobalCluster;import io.github.hectorvent.floci.services.rds.model.GlobalClusterMember;import io.github.hectorvent.floci.services.rds.model.OptionGroup;import io.github.hectorvent.floci.services.rds.model.OptionGroupOption;+import io.github.hectorvent.floci.services.rds.model.PointInTimeRestoreRequest;import io.github.hectorvent.floci.services.rds.model.RdsEvent;import io.github.hectorvent.floci.services.rds.model.ReadReplicaRequest;import jakarta.enterprise.context.ApplicationScoped;@@ -38,6 +39,7 @@ import jakarta.ws.rs.core.MultivaluedMap;import jakarta.ws.rs.core.Response;import org.jboss.logging.Logger;+import java.time.Instant;import java.util.ArrayList;import java.util.Collection;import java.util.LinkedHashMap;@@ -131,6 +133,7 @@ public class RdsQueryHandler {case "CopyDBSnapshot" -> handleCopyDbSnapshot(params, region);case "ModifyDBSnapshot" -> handleModifyDbSnapshot(params, region);case "RestoreDBInstanceFromDBSnapshot" -> handleRestoreDbInstanceFromDbSnapshot(params, region);+ case "RestoreDBInstanceToPointInTime" -> handleRestoreDbInstanceToPointInTime(params, region);case "DescribeDBSnapshots" -> handleDescribeDbSnapshots(params, region);case "DescribeDBSnapshotAttributes" -> handleDescribeDbSnapshotAttributes(params, region);case "ModifyDBSnapshotAttribute" -> handleModifyDbSnapshotAttribute(params, region);@@ -148,6 +151,7 @@ public class RdsQueryHandler {case "DeleteDBClusterSnapshot" -> handleDeleteDbClusterSnapshot(params, region);case "CopyDBClusterSnapshot" -> handleCopyDbClusterSnapshot(params, region);case "RestoreDBClusterFromSnapshot" -> handleRestoreDbClusterFromSnapshot(params, region);+ case "RestoreDBClusterToPointInTime" -> handleRestoreDbClusterToPointInTime(params, region);case "DescribeDBClusterSnapshotAttributes" -> handleDescribeDbClusterSnapshotAttributes(params, region);case "ModifyDBClusterSnapshotAttribute" -> handleModifyDbClusterSnapshotAttribute(params, region);case "DescribeGlobalClusters" -> handleDescribeGlobalClusters(params);@@ -2203,6 +2207,63 @@ public class RdsQueryHandler {dbClusterSnapshotXml(copy))).build();}+ private Response handleRestoreDbInstanceToPointInTime(MultivaluedMap<String, String> params, String region) {+ try {+ PointInTimeRestoreRequest request = new PointInTimeRestoreRequest(+ params.getFirst("TargetDBInstanceIdentifier"),+ params.getFirst("SourceDBInstanceIdentifier"),+ params.getFirst("SourceDbiResourceId"),+ params.getFirst("SourceDBInstanceAutomatedBackupsArn"),+ parseOptionalInstant(params.getFirst("RestoreTime")),+ parseOptionalBoolean(params, "UseLatestRestorableTime"),+ params.getFirst("DBInstanceClass"),+ parseIntegerParam(params, "Port"),+ params.getFirst("AvailabilityZone"),+ parseOptionalBoolean(params, "MultiAZ"),+ parseOptionalBoolean(params, "AutoMinorVersionUpgrade"),+ params.getFirst("DBName"),+ params.getFirst("OptionGroupName"),+ params.getFirst("DBParameterGroupName"),+ parseOptionalBoolean(params, "PubliclyAccessible"),+ params.getFirst("DBSubnetGroupName"),+ hasMemberKeys(params, "VpcSecurityGroupIds") ? vpcSecurityGroupIds(params) : null,+ parseOptionalBoolean(params, "CopyTagsToSnapshot"),+ parseOptionalBoolean(params, "EnableIAMDatabaseAuthentication"),+ parseIntegerParam(params, "BackupRetentionPeriod"),+ params.getFirst("PreferredBackupWindow"),+ parseOptionalBoolean(params, "DeletionProtection"),+ parseTags(params));+ DbInstance instance = service.restoreDbInstanceToPointInTime(request, region);+ return Response.ok(AwsQueryResponse.envelope(+ "RestoreDBInstanceToPointInTime", AwsNamespaces.RDS, dbInstanceXml(instance))).build();+ } catch (AwsException e) {+ return AwsQueryResponse.error(e.getErrorCode(), e.getMessage(), AwsNamespaces.RDS, e.getHttpStatus());+ }+ }++ private Response handleRestoreDbClusterToPointInTime(MultivaluedMap<String, String> params, String region) {+ String clusterId = params.getFirst("DBClusterIdentifier");+ Response missing = firstMissingParam("DBClusterIdentifier", clusterId);+ if (missing != null) {+ return missing;+ }+ try {+ DbCluster cluster = service.restoreDbClusterToPointInTime(clusterId,+ params.getFirst("SourceDBClusterIdentifier"), params.getFirst("SourceDbClusterResourceId"),+ params.getFirst("RestoreType"),+ parseOptionalInstant(params.getFirst("RestoreToTime")),+ parseOptionalBoolean(params, "UseLatestRestorableTime"),+ optionalInt(params.getFirst("Port")), params.getFirst("DBSubnetGroupName"),+ params.getFirst("DBClusterParameterGroupName"),+ optionalBoolean(params.getFirst("EnableIAMDatabaseAuthentication")),+ params.getFirst("EngineMode"), parseTags(params), region);+ return Response.ok(AwsQueryResponse.envelope("RestoreDBClusterToPointInTime", AwsNamespaces.RDS,+ dbClusterXml(cluster))).build();+ } catch (AwsException e) {+ return AwsQueryResponse.error(e.getErrorCode(), e.getMessage(), AwsNamespaces.RDS, e.getHttpStatus());+ }+ }+private Response handleRestoreDbClusterFromSnapshot(MultivaluedMap<String, String> params, String region) {String clusterId = params.getFirst("DBClusterIdentifier");String snapshotId = params.getFirst("SnapshotIdentifier");@@ -2386,6 +2447,10 @@ public class RdsQueryHandler {.elem("MonitoringInterval", i.getMonitoringInterval()).elem("PerformanceInsightsEnabled", i.isPerformanceInsightsEnabled()).elem("EngineLifecycleSupport", i.getEngineLifecycleSupport());+ if (i.getBackupRetentionPeriod() > 0) {+ // Point in time restore copies the source's current data, so the latest restorable time is now.+ xml.elem("LatestRestorableTime", Instant.now().toString());+ }if (i.getMonitoringRoleArn() != null && !i.getMonitoringRoleArn().isBlank()) {xml.elem("MonitoringRoleArn", i.getMonitoringRoleArn());}@@ -2569,6 +2634,11 @@ public class RdsQueryHandler {if (readerEp != null) {xml.elem("ReaderEndpoint", readerEp.address());}+ if (c.getCreatedAt() != null) {+ // The restorable window runs from creation to now; see RestoreDBClusterToPointInTime.+ xml.elem("EarliestRestorableTime", c.getCreatedAt().toString())+ .elem("LatestRestorableTime", Instant.now().toString());+ }xml.elem("IAMDatabaseAuthenticationEnabled", c.isIamDatabaseAuthenticationEnabled()).elem("MultiAZ", c.isMultiAz()).elem("StorageEncrypted", c.isStorageEncrypted())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 28fba514b2..cb1905140a 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@@ -46,6 +46,7 @@ import io.github.hectorvent.floci.services.rds.model.DbProxy;import io.github.hectorvent.floci.services.rds.model.DbProxyAuth;import io.github.hectorvent.floci.services.rds.model.DbProxyTarget;import io.github.hectorvent.floci.services.rds.model.DbProxyTargetGroup;+import io.github.hectorvent.floci.services.rds.model.PointInTimeRestoreRequest;import io.github.hectorvent.floci.services.rds.model.RdsEvent;import io.github.hectorvent.floci.services.rds.model.ReadReplicaRequest;import io.github.hectorvent.floci.services.rds.model.DbSnapshot;@@ -1180,6 +1181,188 @@ public class RdsService implements Resettable, ResourceProvider {return instance;}+ // ── Point in time restore ─────────────────────────────────────────────────++ // The RDS rule for a PostgreSQL DBName: a letter, then letters, digits or underscores, 63 at most.+ private static final Pattern POSTGRES_DB_NAME = Pattern.compile("[A-Za-z][A-Za-z0-9_]{0,62}");++ /**+ * The earliest time a DB instance can be restored to: the later of its creation and the start+ * of its backup retention period. Floci restores from the source's current data (see+ * {@link #restoreDbInstanceToPointInTime}), so the latest restorable time is always now.+ */+ public static Instant earliestRestorableTime(DbInstance instance, Instant now) {+ Instant retentionStart = now.minus(Duration.ofDays(instance.getBackupRetentionPeriod()));+ Instant created = instance.getCreatedAt();+ return created != null && created.isAfter(retentionStart) ? created : retentionStart;+ }++ /**+ * Creates a new DB instance from a source instance as of a time in its restorable window.+ *+ * <p>Floci keeps no transaction log, so it cannot rebuild the source as it was at an earlier+ * time. The requested time is checked against the window as AWS checks it, and the new+ * instance is then seeded from a dump of the source taken now, the mechanism read replicas+ * use. The restored data is therefore the source's latest state for any time in the window.+ */+ public DbInstance restoreDbInstanceToPointInTime(PointInTimeRestoreRequest request, String region) {+ String effectiveRegion = effectiveRegion(region);+ String targetId = request.targetDbInstanceIdentifier();+ if (targetId == null || targetId.isBlank()) {+ throw new AwsException("InvalidParameterValue", "TargetDBInstanceIdentifier is required.", 400);+ }+ DbInstance source = resolvePointInTimeSource(request, effectiveRegion);+ String sourceId = source.getDbInstanceIdentifier();+ if (source.getDbClusterIdentifier() != null && !source.getDbClusterIdentifier().isBlank()) {+ throw new AwsException("InvalidParameterCombination",+ "DB instance " + sourceId + " belongs to DB cluster " + source.getDbClusterIdentifier()+ + ". Use RestoreDBClusterToPointInTime to restore the cluster.", 400);+ }+ if (source.getStatus() != DbInstanceStatus.AVAILABLE) {+ throw new AwsException("InvalidDBInstanceState",+ "DB instance " + sourceId + " is not in available state.", 400);+ }+ if (source.getBackupRetentionPeriod() <= 0) {+ throw new AwsException("PointInTimeRestoreNotEnabled",+ "Point-in-time restore is not enabled for DB instance " + sourceId+ + " because its backup retention period is 0.", 400);+ }+ Instant now = Instant.now();+ requireRestorableTime(request.restoreTime(), request.useLatestRestorableTime(),+ earliestRestorableTime(source, now), now, "RestoreTime");+ if (source.getEngine() != DatabaseEngine.POSTGRES) {+ // CreateDBSnapshot draws the same line: the copy of the source is pg_dumpall based.+ throw new AwsException("InvalidDBInstanceState",+ "Operation RestoreDBInstanceToPointInTime is not supported for engine "+ + source.getEngine() + ".", 400);+ }++ String dbName = firstNonBlank(request.dbName(), source.getDbName());+ // The database the source's dump carries: its DBName, or, without one, the database the+ // image names after the master user.+ String sourceDatabase = firstNonBlank(source.getDbName(),+ firstNonBlank(source.getMasterUsername(), "postgres"));+ boolean renameDatabase = !isBlank(request.dbName()) && !request.dbName().equals(sourceDatabase);+ if (renameDatabase && !POSTGRES_DB_NAME.matcher(request.dbName()).matches()) {+ throw new AwsException("InvalidParameterValue",+ "DBName must begin with a letter and contain only letters, digits and underscores, "+ + "up to 63 characters.", 400);+ }++ String engineParam = source.getEngineIdentifier() != null+ ? source.getEngineIdentifier() : source.getEngine().name().toLowerCase(Locale.ROOT);+ // Encryption follows the source, as it does for a snapshot restore; backups and windows+ // not in the request take the defaults a new instance gets.+ DbInstanceSettings settings = new DbInstanceSettings(+ source.isStorageEncrypted() ? Boolean.TRUE : null,+ source.isStorageEncrypted() ? source.getKmsKeyId() : null,+ request.backupRetentionPeriod(), request.preferredBackupWindow(), null,+ request.copyTagsToSnapshot());+ DbInstance instance = createDbInstance(targetId, engineParam, source.getEngineVersion(),+ source.getMasterUsername(), source.getMasterPassword(), dbName,+ firstNonBlank(request.dbInstanceClass(), source.getDbInstanceClass()),+ source.getAllocatedStorage(),+ Boolean.TRUE.equals(request.iamDatabaseAuthenticationEnabled()),+ request.dbParameterGroupName(), request.dbSubnetGroupName(), null,+ request.availabilityZone(), Boolean.TRUE.equals(request.multiAz()), false, null,+ request.tags() != null ? request.tags() : Map.of(),+ request.vpcSecurityGroupIds() != null ? request.vpcSecurityGroupIds() : List.of(),+ request.optionGroupName(), effectiveRegion,+ request.autoMinorVersionUpgrade() == null || request.autoMinorVersionUpgrade(),+ // Deletion protection is turned on only once the copy succeeds, so a failed copy can+ // still remove the target it created.+ settings, request.publiclyAccessible(), request.port(), null);++ if (!config.services().rds().mock()) {+ try {+ // Without both containers there is nothing to copy from or into, and reporting the+ // restore as done would hand back an instance without the source's data.+ if (source.getContainerId() == null || instance.getContainerId() == null) {+ throw new IllegalStateException("the source or target database container is not running");+ }+ String sqlDump = containerManager.createPostgresSnapshot(+ source.getContainerId(), source.getMasterUsername());+ containerManager.restorePostgresSnapshot(+ instance.getContainerId(), instance.getMasterUsername(), sqlDump);+ if (renameDatabase) {+ // The dump brings the source's database under its own name.+ containerManager.renamePostgresDatabase(instance.getContainerId(),+ instance.getMasterUsername(), sourceDatabase, dbName);+ }+ } catch (Exception e) {+ try {+ deleteDbInstance(targetId, effectiveRegion);+ } catch (RuntimeException cleanupError) {+ e.addSuppressed(cleanupError);+ }+ AwsException failure = new AwsException("InvalidDBInstanceState",+ "Failed to restore DB instance " + sourceId + " to " + targetId + ": "+ + e.getMessage(), 400);+ failure.initCause(e);+ throw failure;+ }+ }+ if (Boolean.TRUE.equals(request.deletionProtection())) {+ instance.setDeletionProtection(true);+ putInstanceForScope(currentAccountId(), effectiveRegion, targetId, instance);+ }+ LOG.infov("DB instance {0} restored to point in time as {1}", sourceId, targetId);+ return instance;+ }++ /**+ * The source of a point in time restore. A live instance can be named by identifier or by its+ * DbiResourceId; an automated backups ARN names retained backups, which Floci does not keep.+ */+ private DbInstance resolvePointInTimeSource(PointInTimeRestoreRequest request, String region) {+ String byId = request.sourceDbInstanceIdentifier();+ String byResourceId = request.sourceDbiResourceId();+ String byBackupsArn = request.sourceDbInstanceAutomatedBackupsArn();+ int named = (isBlank(byId) ? 0 : 1) + (isBlank(byResourceId) ? 0 : 1) + (isBlank(byBackupsArn) ? 0 : 1);+ if (named != 1) {+ throw new AwsException("InvalidParameterCombination",+ "Specify exactly one of SourceDBInstanceIdentifier, SourceDbiResourceId and "+ + "SourceDBInstanceAutomatedBackupsArn.", 400);+ }+ if (!isBlank(byId)) {+ return getDbInstance(byId, region);+ }+ if (!isBlank(byResourceId)) {+ return listDbInstancesByDbiResourceIds(List.of(byResourceId), region).stream()+ .findFirst()+ .orElseThrow(() -> new AwsException("DBInstanceNotFound",+ "DB instance with resource ID " + byResourceId + " not found.", 404));+ }+ throw new AwsException("DBInstanceAutomatedBackupNotFound",+ "Automated backups " + byBackupsArn + " not found.", 404);+ }++ /**+ * Exactly one of a restore time and the latest restorable time must be asked for, and a+ * restore time must lie in the window from {@code earliest} to {@code latest}.+ */+ private static void requireRestorableTime(Instant restoreTime, Boolean useLatest,+ Instant earliest, Instant latest, String timeParam) {+ boolean latestRequested = Boolean.TRUE.equals(useLatest);+ if (restoreTime != null && latestRequested) {+ throw new AwsException("InvalidParameterCombination",+ timeParam + " cannot be specified when UseLatestRestorableTime is true.", 400);+ }+ if (restoreTime == null && !latestRequested) {+ throw new AwsException("InvalidParameterCombination",+ "Specify either " + timeParam + " or UseLatestRestorableTime.", 400);+ }+ if (restoreTime != null && (restoreTime.isBefore(earliest) || restoreTime.isAfter(latest))) {+ throw new AwsException("InvalidRestoreFault",+ "The restore time " + restoreTime + " is outside the restorable window from "+ + earliest + " to " + latest + ".", 400);+ }+ }++ private static boolean isBlank(String value) {+ return value == null || value.isBlank();+ }+// ── Read replicas ─────────────────────────────────────────────────────────static final String READ_REPLICATION_REPLICATING = "replicating";@@ -1792,6 +1975,93 @@ public class RdsService implements Resettable, ResourceProvider {return cluster;}+ /**+ * Creates a new DB cluster from a source cluster as of a time in its restorable window, from+ * the cluster's creation to now. Floci does not model a cluster's backup retention period, so+ * the window opens at creation. As for an instance, the data is the source's state when the+ * request arrives (see {@link #restoreDbInstanceToPointInTime}). Like a cluster snapshot+ * restore, this creates the cluster only; instances are added with CreateDBInstance.+ */+ public DbCluster restoreDbClusterToPointInTime(String clusterId, String sourceClusterRef,+ String sourceClusterResourceId, String restoreType,+ Instant restoreToTime, Boolean useLatestRestorableTime,+ Integer port, String dbSubnetGroupName, String parameterGroupName,+ Boolean iamEnabled, String engineMode,+ Map<String, String> tags, String region) {+ String effectiveRegion = effectiveRegion(region);+ String accountId = currentAccountId();+ if (isBlank(clusterId)) {+ throw new AwsException("InvalidParameterValue", "DBClusterIdentifier is required.", 400);+ }+ if (isBlank(sourceClusterRef) == isBlank(sourceClusterResourceId)) {+ throw new AwsException("InvalidParameterCombination",+ "Specify exactly one of SourceDBClusterIdentifier and SourceDbClusterResourceId.", 400);+ }+ if (restoreType != null && !"full-copy".equals(restoreType) && !"copy-on-write".equals(restoreType)) {+ throw new AwsException("InvalidParameterValue",+ "RestoreType must be full-copy or copy-on-write.", 400);+ }+ // SourceDBClusterIdentifier takes the cluster's identifier or its ARN (API reference).+ DbCluster source = !isBlank(sourceClusterRef)+ ? getDbCluster(clusterIdentifierFromArnOrName(sourceClusterRef, effectiveRegion), effectiveRegion)+ : listDbClusters(null, effectiveRegion).stream()+ .filter(c -> sourceClusterResourceId.equals(c.getDbClusterResourceId()))+ .findFirst()+ .orElseThrow(() -> new AwsException("DBClusterNotFoundFault",+ "DB cluster with resource ID " + sourceClusterResourceId + " not found.", 404));+ String sourceId = source.getDbClusterIdentifier();+ if (source.getStatus() != null && source.getStatus() != DbInstanceStatus.AVAILABLE) {+ throw new AwsException("InvalidDBClusterStateFault",+ "DB cluster " + sourceId + " is not in available state.", 400);+ }+ Instant now = Instant.now();+ Instant earliest = source.getCreatedAt() != null ? source.getCreatedAt() : now;+ requireRestorableTime(restoreToTime, useLatestRestorableTime, earliest, now, "RestoreToTime");+ if (source.getEngine() != DatabaseEngine.POSTGRES) {+ throw new AwsException("InvalidDBClusterStateFault",+ "Operation RestoreDBClusterToPointInTime is not supported for engine "+ + source.getEngine() + ".", 400);+ }++ String engineParam = source.getEngineIdentifier() != null+ ? source.getEngineIdentifier() : source.getEngine().name().toLowerCase(Locale.ROOT);+ DbCluster cluster = createDbClusterWithPort(clusterId, engineParam, source.getEngineVersion(),+ source.getMasterUsername(), source.getMasterPassword(), source.getDatabaseName(),+ iamEnabled != null ? iamEnabled : source.isIamDatabaseAuthenticationEnabled(),+ parameterGroupName, dbSubnetGroupName, null, false, effectiveRegion,+ null, null, null, false, null,+ !isBlank(engineMode) ? engineMode : source.getEngineMode(),+ source.isStorageEncrypted(), port);+ if (tags != null && !tags.isEmpty()) {+ cluster.getTags().putAll(tags);+ putClusterForScope(accountId, effectiveRegion, clusterId, cluster);+ }+ if (!config.services().rds().mock()) {+ try {+ if (source.getContainerId() == null || cluster.getContainerId() == null) {+ throw new IllegalStateException("the source or target database container is not running");+ }+ String sqlDump = containerManager.createPostgresSnapshot(+ source.getContainerId(), source.getMasterUsername());+ containerManager.restorePostgresSnapshot(+ cluster.getContainerId(), cluster.getMasterUsername(), sqlDump);+ } catch (Exception e) {+ try {+ deleteDbCluster(clusterId, effectiveRegion);+ } catch (Exception cleanupError) {+ e.addSuppressed(cleanupError);+ }+ AwsException failure = new AwsException("InvalidDBClusterStateFault",+ "Failed to restore DB cluster " + sourceId + " to " + clusterId + ": "+ + e.getMessage(), 400);+ failure.initCause(e);+ throw failure;+ }+ }+ LOG.infov("DB cluster {0} restored to point in time as {1}", sourceId, clusterId);+ return cluster;+ }+private DbClusterSnapshot clusterSnapshotOf(DbCluster cluster, String snapshotId, String region) {DbClusterSnapshot snapshot = new DbClusterSnapshot();snapshot.setDbClusterSnapshotIdentifier(snapshotId);@@ -1868,6 +2138,27 @@ public class RdsService implements Resettable, ResourceProvider {}}+ /** A cluster named by identifier or by ARN; an ARN for another account or Region names no cluster here. */+ private String clusterIdentifierFromArnOrName(String source, String region) {+ if (!source.startsWith("arn:")) {+ return source;+ }+ AwsArnUtils.Arn arn;+ try {+ arn = AwsArnUtils.parse(source);+ } catch (IllegalArgumentException malformed) {+ throw new AwsException("InvalidParameterValue", "Invalid DB cluster identifier: " + source, 400);+ }+ String resource = arn.resource();+ if (!"rds".equals(arn.service()) || !resource.startsWith("cluster:")) {+ throw new AwsException("InvalidParameterValue", "Invalid DB cluster identifier: " + source, 400);+ }+ if (!region.equals(arn.region()) || !currentAccountId().equals(arn.accountId())) {+ throw new AwsException("DBClusterNotFoundFault", "DB cluster " + source + " not found.", 404);+ }+ return resource.substring("cluster:".length());+ }+private String clusterSnapshotIdentifierFromArnOrName(String source, String region) {if (source == null || source.isBlank()) {throw new AwsException("InvalidParameterValue", "A DB cluster snapshot identifier is required.", 400);diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManager.java b/src/main/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManager.javaindex 756a4554e0..009b7fbb41 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManager.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManager.java@@ -947,6 +947,34 @@ public class RdsContainerManager implements RdsBackendGate, Resettable {}}+ /**+ * Gives a restored database the name a point in time restore asked for. {@code from} is the+ * database the source's dump brought over: its DBName, or the master user's name when it had+ * none, which is how the image names its default database. The rename runs connected to+ * template1, so it also works when {@code from} is {@code postgres}.+ */+ public void renamePostgresDatabase(String containerId, String masterUsername, String from, String to) {+ String effectiveUser = (masterUsername != null && !masterUsername.isBlank()) ? masterUsername : "postgres";+ String sql = "ALTER DATABASE " + quotePostgresIdentifier(from) + " RENAME TO " + quotePostgresIdentifier(to);+ String[] cmd = {"psql", "-v", "ON_ERROR_STOP=1", "-U", effectiveUser, "-d", "template1", "-c", sql};+ try (Lease _ = holdContainer(containerId)) {+ ContainerExec.Result result = execInContainer(containerId, cmd, 60);+ if (result.exitCode() != 0) {+ throw new RuntimeException("Renaming database " + from + " to " + to + " failed with exit code "+ + result.exitCode() + ": " + result.stderr());+ }+ } catch (RuntimeException e) {+ throw e;+ } catch (Exception e) {+ throw new RuntimeException("Failed to rename database " + from + " to " + to, e);+ }+ }++ /** A PostgreSQL quoted identifier: wrapped in double quotes, with each embedded one doubled. */+ static String quotePostgresIdentifier(String name) {+ return "\"" + name.replace("\"", "\"\"") + "\"";+ }+static String postgresRestoreScript() {return """#!/bin/shdiff --git a/src/main/java/io/github/hectorvent/floci/services/rds/model/PointInTimeRestoreRequest.java b/src/main/java/io/github/hectorvent/floci/services/rds/model/PointInTimeRestoreRequest.javanew file mode 100644index 0000000000..7ba2adba11--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/rds/model/PointInTimeRestoreRequest.java@@ -0,0 +1,39 @@+package io.github.hectorvent.floci.services.rds.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;+import java.util.List;+import java.util.Map;++/**+ * The RestoreDBInstanceToPointInTime request as the service consumes it. The source is named by+ * identifier, DbiResourceId or automated backups ARN; the time by RestoreTime or+ * UseLatestRestorableTime. A null override means the API reference's default: the source's+ * instance class, and the Region's defaults for everything else.+ */+@RegisterForReflection+public record PointInTimeRestoreRequest(String targetDbInstanceIdentifier,+ String sourceDbInstanceIdentifier,+ String sourceDbiResourceId,+ String sourceDbInstanceAutomatedBackupsArn,+ Instant restoreTime,+ Boolean useLatestRestorableTime,+ String dbInstanceClass,+ Integer port,+ String availabilityZone,+ Boolean multiAz,+ Boolean autoMinorVersionUpgrade,+ String dbName,+ String optionGroupName,+ String dbParameterGroupName,+ Boolean publiclyAccessible,+ String dbSubnetGroupName,+ List<String> vpcSecurityGroupIds,+ Boolean copyTagsToSnapshot,+ Boolean iamDatabaseAuthenticationEnabled,+ Integer backupRetentionPeriod,+ String preferredBackupWindow,+ Boolean deletionProtection,+ Map<String, String> tags) {+}diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsPointInTimeRestoreIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsPointInTimeRestoreIntegrationTest.javanew file mode 100644index 0000000000..5d3d284c7c--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsPointInTimeRestoreIntegrationTest.java@@ -0,0 +1,398 @@+package io.github.hectorvent.floci.services.rds;++import com.github.dockerjava.api.DockerClient;+import com.github.dockerjava.api.model.Frame;+import com.github.dockerjava.api.model.StreamType;+import com.github.dockerjava.core.command.ExecStartResultCallback;+import io.github.hectorvent.floci.services.rds.model.DbCluster;+import io.github.hectorvent.floci.services.rds.model.DbInstance;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.path.xml.XmlPath;+import io.restassured.specification.RequestSpecification;+import jakarta.inject.Inject;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Tag;+import org.junit.jupiter.api.Test;++import java.io.ByteArrayOutputStream;+import java.io.Closeable;+import java.io.IOException;+import java.nio.charset.StandardCharsets;+import java.time.Duration;+import java.time.Instant;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.TimeUnit;++import static io.restassured.RestAssured.given;+import static io.restassured.http.ContentType.URLENC;+import static org.hamcrest.Matchers.containsString;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.junit.jupiter.api.Assumptions.assumeTrue;++/**+ * RestoreDBInstanceToPointInTime and RestoreDBClusterToPointInTime against real Postgres+ * containers: a row in the source comes back from the restored target, the describe calls report+ * the restorable window, and each refusal carries the API reference's error.+ */+@QuarkusTest+@Tag("docker")+class RdsPointInTimeRestoreIntegrationTest {++ private static final String AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20261002/us-east-1/rds/aws4_request, "+ + "SignedHeaders=content-type;host, Signature=test";++ @Inject+ DockerClient dockerClient;++ @Inject+ RdsService rdsService;++ @BeforeEach+ void checkDocker() {+ try {+ dockerClient.pingCmd().exec();+ } catch (Exception e) {+ assumeTrue(false, "Docker is not available: " + e.getMessage());+ }+ }++ private static RequestSpecification query(String action) {+ return given().header("Authorization", AUTH)+ .contentType(URLENC)+ .formParam("Action", action)+ .formParam("Version", "2014-10-31");+ }++ @Test+ void instanceRestoresToPointInTimeWithTheSourcesData() throws Exception {+ String suffix = Long.toString(System.nanoTime(), 36);+ String source = "pitr-src-" + suffix;+ String latest = "pitr-latest-" + suffix;+ String timed = "pitr-timed-" + suffix;++ query("CreateDBInstance")+ .formParam("DBInstanceIdentifier", source)+ .formParam("Engine", "postgres")+ .formParam("MasterUsername", "admin")+ .formParam("MasterUserPassword", "password123")+ .formParam("DBName", "appdb")+ .formParam("DBInstanceClass", "db.t3.micro")+ .formParam("AllocatedStorage", "20")+ .when().post("/").then().statusCode(200);+ waitForDb(source);+ DbInstance sourceInstance = rdsService.getDbInstance(source);+ psql(sourceInstance.getContainerId(), "CREATE TABLE marker(v text); INSERT INTO marker VALUES ('source-row');");++ XmlPath described = query("DescribeDBInstances").formParam("DBInstanceIdentifier", source)+ .when().post("/").then().statusCode(200).extract().xmlPath();+ String instancePath = "DescribeDBInstancesResponse.DescribeDBInstancesResult.DBInstances.DBInstance.";+ Instant latestRestorable = Instant.parse(described.getString(instancePath + "LatestRestorableTime"));+ assertTrue(!latestRestorable.isBefore(sourceInstance.getCreatedAt().minusSeconds(1)));+ String dbiResourceId = described.getString(instancePath + "DbiResourceId");++ query("RestoreDBInstanceToPointInTime")+ .formParam("SourceDBInstanceIdentifier", source)+ .formParam("TargetDBInstanceIdentifier", latest)+ .formParam("UseLatestRestorableTime", "true")+ .formParam("DBInstanceClass", "db.t3.small")+ .formParam("Tags.Tag.1.Key", "env")+ .formParam("Tags.Tag.1.Value", "restore")+ .when().post("/").then()+ .statusCode(200)+ .body(containsString("<RestoreDBInstanceToPointInTimeResult>"))+ .body(containsString("<DBInstanceIdentifier>" + latest + "</DBInstanceIdentifier>"))+ .body(containsString("<Engine>postgres</Engine>"))+ .body(containsString("<DBName>appdb</DBName>"))+ .body(containsString("<MasterUsername>admin</MasterUsername>"))+ .body(containsString("<DBInstanceClass>db.t3.small</DBInstanceClass>"));+ waitForDb(latest);+ assertEquals("source-row", psql(rdsService.getDbInstance(latest).getContainerId(),+ "SELECT v FROM marker;").trim());++ // A time inside the window, named through the source's DbiResourceId. The copied database+ // takes the requested DBName, and protection comes on once the copy is done.+ query("RestoreDBInstanceToPointInTime")+ .formParam("SourceDbiResourceId", dbiResourceId)+ .formParam("TargetDBInstanceIdentifier", timed)+ .formParam("RestoreTime", Instant.now().minusSeconds(1).toString())+ .formParam("DBName", "otherdb")+ .formParam("DeletionProtection", "true")+ .when().post("/").then().statusCode(200)+ .body(containsString("<DBInstanceClass>db.t3.micro</DBInstanceClass>"))+ .body(containsString("<DBName>otherdb</DBName>"))+ .body(containsString("<DeletionProtection>true</DeletionProtection>"));+ waitForDb(timed);+ assertEquals("source-row", psql(rdsService.getDbInstance(timed).getContainerId(), "otherdb",+ "SELECT v FROM marker;").trim());+ query("RestoreDBInstanceToPointInTime")+ .formParam("SourceDBInstanceIdentifier", source)+ .formParam("TargetDBInstanceIdentifier", "pitr-x-" + suffix)+ .formParam("UseLatestRestorableTime", "true")+ .formParam("DBName", "1bad-name")+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>InvalidParameterValue</Code>"));++ expectInstanceError(source, latest, "UseLatestRestorableTime", "true", "DBInstanceAlreadyExists");+ expectInstanceError(source, "pitr-x-" + suffix, "RestoreTime",+ Instant.now().minus(Duration.ofDays(2)).toString(), "InvalidRestoreFault");+ expectInstanceError(source, "pitr-x-" + suffix, "RestoreTime",+ Instant.now().plus(Duration.ofHours(1)).toString(), "InvalidRestoreFault");+ expectInstanceError("pitr-missing-" + suffix, "pitr-x-" + suffix, "UseLatestRestorableTime", "true",+ "DBInstanceNotFound");+ query("RestoreDBInstanceToPointInTime")+ .formParam("SourceDBInstanceIdentifier", source)+ .formParam("TargetDBInstanceIdentifier", "pitr-x-" + suffix)+ .formParam("UseLatestRestorableTime", "true")+ .formParam("RestoreTime", Instant.now().toString())+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>InvalidParameterCombination</Code>"));+ query("RestoreDBInstanceToPointInTime")+ .formParam("SourceDBInstanceIdentifier", source)+ .formParam("TargetDBInstanceIdentifier", "pitr-x-" + suffix)+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>InvalidParameterCombination</Code>"));+ query("RestoreDBInstanceToPointInTime")+ .formParam("SourceDBInstanceAutomatedBackupsArn",+ "arn:aws:rds:us-east-1:000000000000:auto-backup:ab-missing")+ .formParam("TargetDBInstanceIdentifier", "pitr-x-" + suffix)+ .formParam("UseLatestRestorableTime", "true")+ .when().post("/").then().statusCode(404)+ .body(containsString("<Code>DBInstanceAutomatedBackupNotFound</Code>"));++ // With backups off there is no restorable window, and no LatestRestorableTime.+ query("ModifyDBInstance")+ .formParam("DBInstanceIdentifier", source)+ .formParam("BackupRetentionPeriod", "0")+ .formParam("ApplyImmediately", "true")+ .when().post("/").then().statusCode(200);+ waitForDb(source);+ String withoutBackups = query("DescribeDBInstances").formParam("DBInstanceIdentifier", source)+ .when().post("/").then().statusCode(200).extract().asString();+ assertTrue(!withoutBackups.contains("<LatestRestorableTime>"));+ expectInstanceError(source, "pitr-x-" + suffix, "UseLatestRestorableTime", "true",+ "PointInTimeRestoreNotEnabled");++ query("ModifyDBInstance")+ .formParam("DBInstanceIdentifier", timed)+ .formParam("DeletionProtection", "false")+ .formParam("ApplyImmediately", "true")+ .when().post("/").then().statusCode(200);+ for (String id : new String[] {timed, latest, source}) {+ query("DeleteDBInstance").formParam("DBInstanceIdentifier", id)+ .when().post("/").then().statusCode(200);+ }+ }++ @Test+ void sourceWithoutDbNameRestoresItsDefaultDatabaseUnderTheRequestedName() throws Exception {+ String suffix = Long.toString(System.nanoTime(), 36);+ String source = "pitr-nodb-" + suffix;+ String restored = "pitr-named-" + suffix;++ // Without DBName the image names the default database after the master user.+ query("CreateDBInstance")+ .formParam("DBInstanceIdentifier", source)+ .formParam("Engine", "postgres")+ .formParam("MasterUsername", "admin")+ .formParam("MasterUserPassword", "password123")+ .formParam("DBInstanceClass", "db.t3.micro")+ .formParam("AllocatedStorage", "20")+ .when().post("/").then().statusCode(200);+ waitForDb(source);+ psql(rdsService.getDbInstance(source).getContainerId(), "admin",+ "CREATE TABLE marker(v text); INSERT INTO marker VALUES ('default-db-row');");++ query("RestoreDBInstanceToPointInTime")+ .formParam("SourceDBInstanceIdentifier", source)+ .formParam("TargetDBInstanceIdentifier", restored)+ .formParam("UseLatestRestorableTime", "true")+ .formParam("DBName", "named")+ .when().post("/").then().statusCode(200)+ .body(containsString("<DBName>named</DBName>"));+ waitForDb(restored);+ assertEquals("default-db-row", psql(rdsService.getDbInstance(restored).getContainerId(), "named",+ "SELECT v FROM marker;").trim());++ for (String id : new String[] {restored, source}) {+ query("DeleteDBInstance").formParam("DBInstanceIdentifier", id)+ .when().post("/").then().statusCode(200);+ }+ }++ @Test+ void clusterRestoresToPointInTimeWithTheSourcesData() throws Exception {+ String suffix = Long.toString(System.nanoTime(), 36);+ String source = "pitr-csrc-" + suffix;+ String restored = "pitr-crest-" + suffix;+ String byResourceId = "pitr-cres-" + suffix;++ query("CreateDBCluster")+ .formParam("DBClusterIdentifier", source)+ .formParam("Engine", "aurora-postgresql")+ .formParam("EngineVersion", "16.3")+ .formParam("MasterUsername", "admin")+ .formParam("MasterUserPassword", "password123")+ .formParam("DatabaseName", "appdb")+ .when().post("/").then().statusCode(200);+ waitForCluster(source);+ DbCluster sourceCluster = rdsService.getDbCluster(source);+ psql(sourceCluster.getContainerId(), "CREATE TABLE marker(v text); INSERT INTO marker VALUES ('cluster-row');");++ XmlPath described = query("DescribeDBClusters").formParam("DBClusterIdentifier", source)+ .when().post("/").then().statusCode(200).extract().xmlPath();+ String clusterPath = "DescribeDBClustersResponse.DescribeDBClustersResult.DBClusters.DBCluster.";+ Instant earliest = Instant.parse(described.getString(clusterPath + "EarliestRestorableTime"));+ Instant latest = Instant.parse(described.getString(clusterPath + "LatestRestorableTime"));+ assertEquals(sourceCluster.getCreatedAt(), earliest);+ assertTrue(!latest.isBefore(earliest.minusSeconds(1)));+ String clusterArn = described.getString(clusterPath + "DBClusterArn");+ String resourceId = described.getString(clusterPath + "DbClusterResourceId");++ // The window's earliest time, with the source named by ARN.+ query("RestoreDBClusterToPointInTime")+ .formParam("DBClusterIdentifier", restored)+ .formParam("SourceDBClusterIdentifier", clusterArn)+ .formParam("RestoreToTime", earliest.toString())+ .formParam("RestoreType", "copy-on-write")+ .when().post("/").then()+ .statusCode(200)+ .body(containsString("<RestoreDBClusterToPointInTimeResult>"))+ .body(containsString("<DBClusterIdentifier>" + restored + "</DBClusterIdentifier>"))+ .body(containsString("<Engine>aurora-postgresql</Engine>"))+ .body(containsString("<DatabaseName>appdb</DatabaseName>"));+ waitForCluster(restored);+ assertEquals("cluster-row", psql(rdsService.getDbCluster(restored).getContainerId(),+ "SELECT v FROM marker;").trim());++ query("RestoreDBClusterToPointInTime")+ .formParam("DBClusterIdentifier", byResourceId)+ .formParam("SourceDbClusterResourceId", resourceId)+ .formParam("UseLatestRestorableTime", "true")+ .when().post("/").then().statusCode(200);+ waitForCluster(byResourceId);++ expectClusterError(source, restored, "UseLatestRestorableTime", "true", "DBClusterAlreadyExistsFault");+ expectClusterError(source, "pitr-cx-" + suffix, "RestoreToTime",+ earliest.minusSeconds(60).toString(), "InvalidRestoreFault");+ expectClusterError("pitr-cmissing-" + suffix, "pitr-cx-" + suffix, "UseLatestRestorableTime", "true",+ "DBClusterNotFoundFault");+ query("RestoreDBClusterToPointInTime")+ .formParam("DBClusterIdentifier", "pitr-cx-" + suffix)+ .formParam("SourceDBClusterIdentifier", source)+ .formParam("UseLatestRestorableTime", "true")+ .formParam("RestoreType", "snapshot")+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>InvalidParameterValue</Code>"));+ query("RestoreDBClusterToPointInTime")+ .formParam("DBClusterIdentifier", "pitr-cx-" + suffix)+ .formParam("SourceDBClusterIdentifier", source)+ .formParam("SourceDbClusterResourceId", resourceId)+ .formParam("UseLatestRestorableTime", "true")+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>InvalidParameterCombination</Code>"));++ for (String id : new String[] {byResourceId, restored, source}) {+ query("DeleteDBCluster").formParam("DBClusterIdentifier", id).formParam("SkipFinalSnapshot", "true")+ .when().post("/").then().statusCode(200);+ }+ }++ private void expectInstanceError(String source, String target, String timeParam, String timeValue, String code) {+ query("RestoreDBInstanceToPointInTime")+ .formParam("SourceDBInstanceIdentifier", source)+ .formParam("TargetDBInstanceIdentifier", target)+ .formParam(timeParam, timeValue)+ .when().post("/").then()+ .body(containsString("<Code>" + code + "</Code>"));+ }++ private void expectClusterError(String source, String target, String timeParam, String timeValue, String code) {+ query("RestoreDBClusterToPointInTime")+ .formParam("DBClusterIdentifier", target)+ .formParam("SourceDBClusterIdentifier", source)+ .formParam(timeParam, timeValue)+ .when().post("/").then()+ .body(containsString("<Code>" + code + "</Code>"));+ }++ private void waitForDb(String dbId) throws Exception {+ for (int i = 0; i < 60; i++) {+ String status = query("DescribeDBInstances")+ .formParam("DBInstanceIdentifier", dbId)+ .when().post("/").then()+ .extract().xmlPath().getString(+ "DescribeDBInstancesResponse.DescribeDBInstancesResult.DBInstances.DBInstance.DBInstanceStatus");+ if ("available".equals(status)) {+ return;+ }+ Thread.sleep(1000);+ }+ throw new RuntimeException("DB instance " + dbId + " did not become available.");+ }++ private void waitForCluster(String clusterId) throws Exception {+ for (int i = 0; i < 60; i++) {+ String status = query("DescribeDBClusters")+ .formParam("DBClusterIdentifier", clusterId)+ .when().post("/").then()+ .extract().xmlPath().getString(+ "DescribeDBClustersResponse.DescribeDBClustersResult.DBClusters.DBCluster.Status");+ if ("available".equals(status)) {+ return;+ }+ Thread.sleep(1000);+ }+ throw new RuntimeException("DB cluster " + clusterId + " did not become available.");+ }++ private String psql(String containerId, String sql) throws Exception {+ return psql(containerId, "appdb", sql);+ }++ private String psql(String containerId, String database, String sql) throws Exception {+ String[] command = {"psql", "-U", "admin", "-d", database, "-tAc", sql};+ String execId = dockerClient.execCreateCmd(containerId)+ .withCmd(command)+ .withAttachStdout(true)+ .withAttachStderr(true)+ .exec()+ .getId();+ ByteArrayOutputStream output = new ByteArrayOutputStream();+ ByteArrayOutputStream errors = new ByteArrayOutputStream();+ CountDownLatch latch = new CountDownLatch(1);+ Closeable callback = dockerClient.execStartCmd(execId).exec(new ExecStartResultCallback() {+ @Override+ public void onNext(Frame frame) {+ try {+ if (frame.getStreamType() == StreamType.STDOUT) {+ output.write(frame.getPayload());+ } else if (frame.getStreamType() == StreamType.STDERR) {+ errors.write(frame.getPayload());+ }+ } catch (IOException e) {+ throw new IllegalStateException("Failed to capture psql output", e);+ }+ }++ @Override+ public void onComplete() {+ latch.countDown();+ }++ @Override+ public void onError(Throwable throwable) {+ latch.countDown();+ }+ });+ try {+ assertTrue(latch.await(30, TimeUnit.SECONDS), "Timed out running psql");+ long exitCode = dockerClient.inspectExecCmd(execId).exec().getExitCodeLong();+ assertTrue(exitCode == 0, "psql failed with exit code " + exitCode + ": " + errors.toString(StandardCharsets.UTF_8));+ return output.toString(StandardCharsets.UTF_8);+ } finally {+ callback.close();+ }+ }+}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 9b6530fda0..e7f7ec3579 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@@ -37,6 +37,7 @@ import io.github.hectorvent.floci.services.rds.model.GlobalCluster;import io.github.hectorvent.floci.services.rds.model.GlobalClusterMember;import io.github.hectorvent.floci.services.rds.model.OptionGroup;import io.github.hectorvent.floci.services.rds.model.OptionGroupOption;+import io.github.hectorvent.floci.services.rds.model.PointInTimeRestoreRequest;import io.github.hectorvent.floci.services.rds.model.RdsEvent;import io.github.hectorvent.floci.services.rds.model.ReadReplicaRequest;import io.github.hectorvent.floci.services.rds.proxy.RdsAuthProxy;@@ -2489,6 +2490,35 @@ class RdsServiceTest {() -> rdsService.startDbInstance("standalone")).getErrorCode());}+ @Test+ void pointInTimeRestoreFailsAndCleansUpWhenTheTargetContainerDidNotStart() {+ rdsService.createDbInstance("pitr-source", "postgres", "16",+ "admin", "password", "dbname", "db.t3.micro",+ 20, false, null, null, null);+ rdsService.createDbCluster("pitr-cluster", "aurora-postgresql", "16.3",+ "admin", "password", "dbname", false, null);+ // The target's container fails to start, so there is nothing to copy the source into.+ when(containerManager.tryStart(any(), any(), any(), any(), any(), any(), any(), any(), any()))+ .thenReturn(null);++ AwsException instanceFault = assertThrows(AwsException.class, () -> rdsService.restoreDbInstanceToPointInTime(+ new PointInTimeRestoreRequest("pitr-target", "pitr-source", null, null, null, true,+ null, null, null, null, null, null, null, null, null, null, null, null, null,+ null, null, null, Map.of()),+ "us-east-1"));+ assertEquals("InvalidDBInstanceState", instanceFault.getErrorCode());+ assertEquals("DBInstanceNotFound", assertThrows(AwsException.class,+ () -> rdsService.getDbInstance("pitr-target")).getErrorCode());++ AwsException clusterFault = assertThrows(AwsException.class, () -> rdsService.restoreDbClusterToPointInTime(+ "pitr-cluster-target", "pitr-cluster", null, null, null, true,+ null, null, null, null, null, Map.of(), "us-east-1"));+ assertEquals("InvalidDBClusterStateFault", clusterFault.getErrorCode());+ assertEquals("DBClusterNotFoundFault", assertThrows(AwsException.class,+ () -> rdsService.getDbCluster("pitr-cluster-target")).getErrorCode());+ verify(containerManager, never()).createPostgresSnapshot(any(), any());+ }+@Testvoid stopDbInstanceTakesTheRequestedSnapshotFirst() {rdsService.createDbInstance("standalone", "postgres", "16",diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManagerTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManagerTest.javaindex 96721ed75c..9cf940a767 100644--- a/src/test/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManagerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManagerTest.java@@ -60,6 +60,12 @@ class RdsContainerManagerTest {@TempDirPath tempDir;+ @Test+ void quotePostgresIdentifierDoublesEmbeddedQuotes() {+ assertEquals("\"appdb\"", RdsContainerManager.quotePostgresIdentifier("appdb"));+ assertEquals("\"app\"\"db\"", RdsContainerManager.quotePostgresIdentifier("app\"db"));+ }+@Testvoid mysql84UsesSupportedNativePasswordOptions() {assertEquals(