Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

feat(redshift): implement Redshift emulation with snapshot and parameter group support (#2472)

Vũ Thế Huya1383fdd3d1d
diff --git a/compatibility-tests/sdk-test-java/pom.xml b/compatibility-tests/sdk-test-java/pom.xml
index 4351a52fc8..7d7bffb074 100644
--- a/compatibility-tests/sdk-test-java/pom.xml
+++ b/compatibility-tests/sdk-test-java/pom.xml
@@ -96,6 +96,10 @@
<groupId>software.amazon.awssdk</groupId>
<artifactId>ssm</artifactId>
</dependency>
+ <dependency>
+ <groupId>software.amazon.awssdk</groupId>
+ <artifactId>redshift</artifactId>
+ </dependency>
<dependency>
<groupId>software.amazon.awssdk</groupId>
<artifactId>sns</artifactId>
diff --git a/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java b/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java
index ba77b9d7ec..abbb3d05b3 100644
--- a/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java
+++ b/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java
@@ -26,6 +26,7 @@ import software.amazon.awssdk.services.lambda.LambdaClient;
import software.amazon.awssdk.services.opensearch.OpenSearchClient;
import software.amazon.awssdk.services.neptune.NeptuneClient;
import software.amazon.awssdk.services.rds.RdsClient;
+import software.amazon.awssdk.services.redshift.RedshiftClient;
import software.amazon.awssdk.services.guardduty.GuardDutyClient;
import software.amazon.awssdk.services.fis.FisClient;
import software.amazon.awssdk.services.organizations.OrganizationsClient;
@@ -1030,4 +1031,12 @@ public final class TestFixtures {
.credentialsProvider(CREDENTIALS)
.build();
}
+
+ public static RedshiftClient redshiftClient() {
+ return RedshiftClient.builder()
+ .endpointOverride(ENDPOINT)
+ .region(REGION)
+ .credentialsProvider(CREDENTIALS)
+ .build();
+ }
}
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftOperationsTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftOperationsTest.java
new file mode 100644
index 0000000000..baa2454c9b
--- /dev/null
+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftOperationsTest.java
@@ -0,0 +1,336 @@
+package com.floci.test;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import software.amazon.awssdk.services.redshift.RedshiftClient;
+import software.amazon.awssdk.services.redshift.model.Cluster;
+import software.amazon.awssdk.services.redshift.model.ClusterParameterGroup;
+import software.amazon.awssdk.services.redshift.model.CreateClusterParameterGroupRequest;
+import software.amazon.awssdk.services.redshift.model.CreateClusterParameterGroupResponse;
+import software.amazon.awssdk.services.redshift.model.CreateClusterRequest;
+import software.amazon.awssdk.services.redshift.model.CreateClusterResponse;
+import software.amazon.awssdk.services.redshift.model.CreateClusterSnapshotRequest;
+import software.amazon.awssdk.services.redshift.model.CreateClusterSnapshotResponse;
+import software.amazon.awssdk.services.redshift.model.CreateClusterSubnetGroupRequest;
+import software.amazon.awssdk.services.redshift.model.CreateTagsRequest;
+import software.amazon.awssdk.services.redshift.model.DeleteClusterParameterGroupRequest;
+import software.amazon.awssdk.services.redshift.model.DeleteClusterRequest;
+import software.amazon.awssdk.services.redshift.model.DeleteClusterSnapshotRequest;
+import software.amazon.awssdk.services.redshift.model.DeleteClusterSubnetGroupRequest;
+import software.amazon.awssdk.services.redshift.model.DeleteTagsRequest;
+import software.amazon.awssdk.services.redshift.model.DescribeClusterParameterGroupsRequest;
+import software.amazon.awssdk.services.redshift.model.DescribeClusterParameterGroupsResponse;
+import software.amazon.awssdk.services.redshift.model.DescribeClusterSnapshotsRequest;
+import software.amazon.awssdk.services.redshift.model.DescribeClusterSnapshotsResponse;
+import software.amazon.awssdk.services.redshift.model.DescribeClusterSubnetGroupsRequest;
+import software.amazon.awssdk.services.redshift.model.DescribeClustersRequest;
+import software.amazon.awssdk.services.redshift.model.DescribeClustersResponse;
+import software.amazon.awssdk.services.redshift.model.DescribeTagsRequest;
+import software.amazon.awssdk.services.redshift.model.ModifyClusterRequest;
+import software.amazon.awssdk.services.redshift.model.RebootClusterRequest;
+import software.amazon.awssdk.services.redshift.model.RestoreFromClusterSnapshotRequest;
+import software.amazon.awssdk.services.redshift.model.RestoreFromClusterSnapshotResponse;
+import software.amazon.awssdk.services.redshift.model.Snapshot;
+import software.amazon.awssdk.services.redshift.model.Tag;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Properties;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@DisplayName("Redshift Operations")
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+class RedshiftOperationsTest {
+
+ private static final Logger LOG = Logger.getLogger(RedshiftOperationsTest.class.getName());
+
+ private static final String USERNAME = "admin";
+ private static final String PASSWORD = "password123";
+ private static final String DATABASE = "dev";
+
+ private static RedshiftClient client;
+ private static final List<String> clustersToCleanup = new ArrayList<>();
+ private static final List<String> snapshotsToCleanup = new ArrayList<>();
+ private static final List<String> parameterGroupsToCleanup = new ArrayList<>();
+ private static final List<String> subnetGroupsToCleanup = new ArrayList<>();
+
+ @BeforeAll
+ static void setup() {
+ client = TestFixtures.redshiftClient();
+ }
+
+ @AfterAll
+ static void cleanup() {
+ if (client != null) {
+ for (String clusterId : clustersToCleanup) {
+ try {
+ client.deleteCluster(DeleteClusterRequest.builder()
+ .clusterIdentifier(clusterId)
+ .build());
+ } catch (Exception e) {
+ LOG.log(Level.WARNING, "Failed to clean up Redshift cluster " + clusterId, e);
+ }
+ }
+ for (String snapId : snapshotsToCleanup) {
+ try {
+ client.deleteClusterSnapshot(DeleteClusterSnapshotRequest.builder()
+ .snapshotIdentifier(snapId)
+ .build());
+ } catch (Exception e) {
+ LOG.log(Level.WARNING, "Failed to clean up Redshift snapshot " + snapId, e);
+ }
+ }
+ for (String pgName : parameterGroupsToCleanup) {
+ try {
+ client.deleteClusterParameterGroup(DeleteClusterParameterGroupRequest.builder()
+ .parameterGroupName(pgName)
+ .build());
+ } catch (Exception e) {
+ LOG.log(Level.WARNING, "Failed to clean up Redshift parameter group " + pgName, e);
+ }
+ }
+ for (String subnetGroupName : subnetGroupsToCleanup) {
+ try {
+ client.deleteClusterSubnetGroup(DeleteClusterSubnetGroupRequest.builder()
+ .clusterSubnetGroupName(subnetGroupName)
+ .build());
+ } catch (Exception e) {
+ LOG.log(Level.WARNING, "Failed to clean up Redshift cluster subnet group " + subnetGroupName, e);
+ }
+ }
+ client.close();
+ }
+ }
+
+ @Test
+ @Order(1)
+ @DisplayName("Create cluster, insert data, snapshot, restore to new cluster, verify data")
+ void testSnapshotAndRestoreLifecycle() throws Exception {
+ String sourceClusterId = TestFixtures.uniqueName("rs-source");
+ String restoredClusterId = TestFixtures.uniqueName("rs-restored");
+ String snapshotId = TestFixtures.uniqueName("rs-snap");
+
+ clustersToCleanup.add(sourceClusterId);
+ clustersToCleanup.add(restoredClusterId);
+ snapshotsToCleanup.add(snapshotId);
+
+ // 1. Create source cluster
+ CreateClusterResponse createRes = client.createCluster(CreateClusterRequest.builder()
+ .clusterIdentifier(sourceClusterId)
+ .nodeType("dc2.large")
+ .masterUsername(USERNAME)
+ .masterUserPassword(PASSWORD)
+ .build());
+
+ assertThat(createRes.cluster()).isNotNull();
+ assertThat(createRes.cluster().clusterIdentifier()).isEqualTo(sourceClusterId);
+
+ DescribeClustersResponse descRes = client.describeClusters(DescribeClustersRequest.builder()
+ .clusterIdentifier(sourceClusterId)
+ .build());
+ Cluster sourceCluster = descRes.clusters().get(0);
+ assertThat(sourceCluster.endpoint()).isNotNull();
+ String sourceHost = sourceCluster.endpoint().address();
+ int sourcePort = sourceCluster.endpoint().port();
+
+ // 2. Use JDBC to create a table and insert a row
+ try (Connection conn = awaitPostgresConnection(sourceHost, sourcePort, USERNAME, PASSWORD);
+ Statement stmt = conn.createStatement()) {
+ stmt.execute("CREATE TABLE test_data (id INT PRIMARY KEY, name VARCHAR(100));");
+ stmt.execute("INSERT INTO test_data (id, name) VALUES (1, 'floci-redshift-snapshot-val');");
+ }
+
+ // 3. Call createClusterSnapshot via AWS SDK
+ CreateClusterSnapshotResponse snapRes = client.createClusterSnapshot(CreateClusterSnapshotRequest.builder()
+ .snapshotIdentifier(snapshotId)
+ .clusterIdentifier(sourceClusterId)
+ .build());
+
+ Snapshot snapshot = snapRes.snapshot();
+ assertThat(snapshot).isNotNull();
+ assertThat(snapshot.snapshotIdentifier()).isEqualTo(snapshotId);
+ assertThat(snapshot.clusterIdentifier()).isEqualTo(sourceClusterId);
+ assertThat(snapshot.status()).isEqualTo("available");
+
+ DescribeClusterSnapshotsResponse descSnapRes = client.describeClusterSnapshots(DescribeClusterSnapshotsRequest.builder()
+ .snapshotIdentifier(snapshotId)
+ .build());
+ assertThat(descSnapRes.snapshots()).isNotEmpty();
+ assertThat(descSnapRes.snapshots().get(0).snapshotIdentifier()).isEqualTo(snapshotId);
+
+ // 4. Delete source cluster
+ client.deleteCluster(DeleteClusterRequest.builder()
+ .clusterIdentifier(sourceClusterId)
+ .build());
+ clustersToCleanup.remove(sourceClusterId);
+
+ // 5. Restore from snapshot to a new cluster identifier
+ RestoreFromClusterSnapshotResponse restoreRes = client.restoreFromClusterSnapshot(
+ RestoreFromClusterSnapshotRequest.builder()
+ .clusterIdentifier(restoredClusterId)
+ .snapshotIdentifier(snapshotId)
+ .nodeType("dc2.large")
+ .build());
+
+ Cluster restoredCluster = restoreRes.cluster();
+ assertThat(restoredCluster).isNotNull();
+ assertThat(restoredCluster.clusterIdentifier()).isEqualTo(restoredClusterId);
+ assertThat(restoredCluster.endpoint()).isNotNull();
+
+ String restoredHost = restoredCluster.endpoint().address();
+ int restoredPort = restoredCluster.endpoint().port();
+
+ // 6. Use JDBC to query restored cluster and verify row exists
+ try (Connection conn = awaitPostgresConnection(restoredHost, restoredPort, USERNAME, PASSWORD);
+ Statement stmt = conn.createStatement();
+ ResultSet rs = stmt.executeQuery("SELECT name FROM test_data WHERE id = 1;")) {
+ assertThat(rs.next()).isTrue();
+ assertThat(rs.getString("name")).isEqualTo("floci-redshift-snapshot-val");
+ }
+
+ // Cleanup restored cluster and snapshot
+ client.deleteCluster(DeleteClusterRequest.builder()
+ .clusterIdentifier(restoredClusterId)
+ .build());
+ clustersToCleanup.remove(restoredClusterId);
+
+ client.deleteClusterSnapshot(DeleteClusterSnapshotRequest.builder()
+ .snapshotIdentifier(snapshotId)
+ .build());
+ snapshotsToCleanup.remove(snapshotId);
+ }
+
+ @Test
+ @Order(2)
+ @DisplayName("Create, describe, and delete cluster parameter group")
+ void testClusterParameterGroupLifecycle() {
+ String pgName = TestFixtures.uniqueName("rs-pg");
+ parameterGroupsToCleanup.add(pgName);
+
+ // 1. Create cluster parameter group
+ CreateClusterParameterGroupResponse createPgRes = client.createClusterParameterGroup(
+ CreateClusterParameterGroupRequest.builder()
+ .parameterGroupName(pgName)
+ .parameterGroupFamily("redshift-1.0")
+ .description("Test parameter group for Redshift")
+ .build());
+
+ ClusterParameterGroup pg = createPgRes.clusterParameterGroup();
+ assertThat(pg).isNotNull();
+ assertThat(pg.parameterGroupName()).isEqualTo(pgName);
+ assertThat(pg.parameterGroupFamily()).isEqualTo("redshift-1.0");
+ assertThat(pg.description()).isEqualTo("Test parameter group for Redshift");
+
+ // 2. Describe cluster parameter groups
+ DescribeClusterParameterGroupsResponse descPgRes = client.describeClusterParameterGroups(
+ DescribeClusterParameterGroupsRequest.builder()
+ .parameterGroupName(pgName)
+ .build());
+
+ assertThat(descPgRes.parameterGroups()).isNotEmpty();
+ ClusterParameterGroup foundPg = descPgRes.parameterGroups().stream()
+ .filter(g -> pgName.equals(g.parameterGroupName()))
+ .findFirst()
+ .orElse(null);
+ assertThat(foundPg).isNotNull();
+ assertThat(foundPg.parameterGroupFamily()).isEqualTo("redshift-1.0");
+ assertThat(foundPg.description()).isEqualTo("Test parameter group for Redshift");
+
+ // 3. Delete cluster parameter group
+ client.deleteClusterParameterGroup(DeleteClusterParameterGroupRequest.builder()
+ .parameterGroupName(pgName)
+ .build());
+ parameterGroupsToCleanup.remove(pgName);
+ }
+
+ @Test
+ @Order(3)
+ void testTaggingAndSubnetGroupAndModify() {
+ // Cluster subnet group
+ String subnetGroupName = TestFixtures.uniqueName("rs-subnet-group");
+ client.createClusterSubnetGroup(CreateClusterSubnetGroupRequest.builder()
+ .clusterSubnetGroupName(subnetGroupName)
+ .description("SDK test subnet group")
+ .subnetIds("subnet-aaa", "subnet-bbb")
+ .build());
+ subnetGroupsToCleanup.add(subnetGroupName);
+
+ var describedGroups = client.describeClusterSubnetGroups(
+ DescribeClusterSubnetGroupsRequest.builder()
+ .clusterSubnetGroupName(subnetGroupName)
+ .build());
+ assertThat(describedGroups.clusterSubnetGroups()).hasSize(1);
+ assertThat(describedGroups.clusterSubnetGroups().get(0).subnets()).hasSize(2);
+
+ // Cluster + tagging + modify + reboot
+ String clusterId = TestFixtures.uniqueName("rs-tag-cluster");
+ CreateClusterResponse created = client.createCluster(CreateClusterRequest.builder()
+ .clusterIdentifier(clusterId)
+ .nodeType("dc2.large")
+ .masterUsername(USERNAME)
+ .masterUserPassword(PASSWORD)
+ .build());
+ clustersToCleanup.add(clusterId);
+ String arn = "arn:aws:redshift:us-east-1:000000000000:cluster:" + clusterId;
+
+ client.createTags(CreateTagsRequest.builder()
+ .resourceName(arn)
+ .tags(Tag.builder().key("env").value("test").build())
+ .build());
+
+ var described = client.describeTags(DescribeTagsRequest.builder()
+ .resourceName(arn)
+ .build());
+ assertThat(described.taggedResources()).anyMatch(t -> "env".equals(t.tag().key()) && "test".equals(t.tag().value()));
+
+ client.deleteTags(DeleteTagsRequest.builder()
+ .resourceName(arn)
+ .tagKeys("env")
+ .build());
+
+ var modified = client.modifyCluster(ModifyClusterRequest.builder()
+ .clusterIdentifier(clusterId)
+ .nodeType("ra3.xlplus")
+ .build());
+ assertThat(modified.cluster().nodeType()).isEqualTo("ra3.xlplus");
+
+ var rebooted = client.rebootCluster(RebootClusterRequest.builder()
+ .clusterIdentifier(clusterId)
+ .build());
+ assertThat(rebooted.cluster().clusterStatus()).isEqualTo("available");
+ }
+
+ private static Connection awaitPostgresConnection(String host, int port, String username, String password) throws Exception {
+ Instant deadline = Instant.now().plus(Duration.ofSeconds(60));
+ SQLException last = null;
+ while (Instant.now().isBefore(deadline)) {
+ try {
+ Properties properties = new Properties();
+ properties.setProperty("user", username);
+ properties.setProperty("password", password);
+ properties.setProperty("sslmode", "disable");
+ properties.setProperty("connectTimeout", "5");
+ return DriverManager.getConnection("jdbc:postgresql://" + host + ":" + port + "/" + DATABASE, properties);
+ } catch (SQLException e) {
+ last = e;
+ Thread.sleep(1000);
+ }
+ }
+ throw last != null ? last : new SQLException("Timed out waiting for PostgreSQL connection at " + host + ":" + port);
+ }
+}
diff --git a/compatibility-tests/sdk-test-java/src/test/java/io/github/hectorvent/floci/compat/RedshiftTest.java b/compatibility-tests/sdk-test-java/src/test/java/io/github/hectorvent/floci/compat/RedshiftTest.java
new file mode 100644
index 0000000000..80bbaa270a
--- /dev/null
+++ b/compatibility-tests/sdk-test-java/src/test/java/io/github/hectorvent/floci/compat/RedshiftTest.java
@@ -0,0 +1,75 @@
+package io.github.hectorvent.floci.compat;
+
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import software.amazon.awssdk.services.redshift.RedshiftClient;
+import software.amazon.awssdk.services.redshift.model.Cluster;
+import software.amazon.awssdk.services.redshift.model.CreateClusterRequest;
+import software.amazon.awssdk.services.redshift.model.CreateClusterResponse;
+import software.amazon.awssdk.services.redshift.model.DescribeClustersRequest;
+import software.amazon.awssdk.services.redshift.model.DescribeClustersResponse;
+import software.amazon.awssdk.services.redshift.model.DeleteClusterRequest;
+import software.amazon.awssdk.services.redshift.model.DeleteClusterResponse;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+public class RedshiftTest {
+
+ private RedshiftClient getClient() {
+ return RedshiftClient.builder()
+ .region(software.amazon.awssdk.regions.Region.US_EAST_1)
+ .credentialsProvider(software.amazon.awssdk.auth.credentials.StaticCredentialsProvider.create(
+ software.amazon.awssdk.auth.credentials.AwsBasicCredentials.create("test", "test")))
+ .endpointOverride(java.net.URI.create("http://localhost:4566"))
+ .build();
+ }
+
+ @Test
+ @Order(1)
+ public void testCreateCluster() throws Exception {
+ RedshiftClient client = getClient();
+ CreateClusterResponse res = client.createCluster(CreateClusterRequest.builder()
+ .clusterIdentifier("test-cluster")
+ .nodeType("dc2.large")
+ .masterUsername("admin")
+ .masterUserPassword("Password123")
+ .build());
+
+ assertEquals("test-cluster", res.cluster().clusterIdentifier());
+
+ DescribeClustersResponse describeRes = client.describeClusters(DescribeClustersRequest.builder()
+ .clusterIdentifier("test-cluster")
+ .build());
+
+ Cluster cluster = describeRes.clusters().get(0);
+ assertEquals("test-cluster", cluster.clusterIdentifier());
+ assertNotNull(cluster.endpoint());
+
+ String address = cluster.endpoint().address();
+ int port = cluster.endpoint().port();
+
+ String jdbcUrl = "jdbc:postgresql://" + address + ":" + port + "/dev";
+ try (Connection conn = DriverManager.getConnection(jdbcUrl, "admin", "Password123")) {
+ assertTrue(conn.isValid(5));
+ }
+ }
+
+ @Test
+ @Order(2)
+ public void testDeleteCluster() {
+ RedshiftClient client = getClient();
+ DeleteClusterResponse res = client.deleteCluster(DeleteClusterRequest.builder()
+ .clusterIdentifier("test-cluster")
+ .build());
+ assertEquals("test-cluster", res.cluster().clusterIdentifier());
+ assertEquals("deleting", res.cluster().clusterStatus());
+ }
+}
diff --git a/docs/services/index.md b/docs/services/index.md
index 07619f1a48..e78807c20e 100644
--- a/docs/services/index.md
+++ b/docs/services/index.md
@@ -55,6 +55,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac
| [Lake Formation](lakeformation.md) | `POST /<Action>` | REST JSON | 16 |
| [Neptune](neptune.md) | `POST /` with `Action=` param + Gremlin TCP proxy | Query + WebSocket | 8 |
| [DocumentDB](docdb.md) | `POST /` with `Action=` param + MongoDB container | Query + MongoDB wire | 8 |
+| [Redshift](redshift.md) | `POST /` with `Action=` param + PostgreSQL container | Query + PostgreSQL wire | 21 |
| [EMR](emr.md) | `POST /` + `X-Amz-Target: ElasticMapReduce.*` | JSON 1.1 | 24 |
| [EMR Serverless](emr-serverless.md) | `/applications/*` | REST JSON | 7 |
| [Data Firehose](firehose.md) | `POST /` + `X-Amz-Target: Firehose_20150804.*` | JSON 1.1 | 6 |
diff --git a/docs/services/redshift.md b/docs/services/redshift.md
new file mode 100644
index 0000000000..0d632298b0
--- /dev/null
+++ b/docs/services/redshift.md
@@ -0,0 +1,141 @@
+# Redshift
+
+**Protocol:** Query (XML) for the management API
+**Management Endpoint:** `POST http://localhost:4566/` with `Action=` param
+**Data Endpoint:** the `Endpoint` and `Port` returned by `DescribeClusters` (PostgreSQL wire protocol)
+
+Floci emulates Amazon Redshift by managing a real [PostgreSQL](https://www.postgresql.org/) Docker container per cluster behind a Redshift-shaped control plane. Redshift speaks the PostgreSQL wire protocol, so the cluster endpoint returned by `DescribeClusters` works with any standard PostgreSQL driver (`psql`, JDBC, `psycopg`, …).
+
+> **Always read the host and port from `DescribeClusters`** rather than assuming a fixed port. PostgreSQL listens on `5432` *inside* the container; the port you connect to is dynamically assigned on the host and returned as `Clusters[0].Endpoint.Port`. Redshift's conventional port is `5439`, but the emulator does not bind it — use whatever `DescribeClusters` reports.
+
+The container has **no persistent volume**: if the physical container survives a Floci restart it is adopted and its data is kept, but if the container itself is gone (host reboot, `docker rm`, a pruned dev box) the cluster comes back empty. Use `CreateClusterSnapshot` / `RestoreFromClusterSnapshot` to preserve data explicitly.
+
+## Supported Actions
+
+<!-- floci:actions:start -->
+| Action | Description |
+| --- | --- |
+| `CreateCluster` | Create a cluster and start a PostgreSQL container for it |
+| `DescribeClusters` | List clusters and their connection details |
+| `DeleteCluster` | Stop and remove a cluster and its container |
+| `CreateClusterSnapshot` | Back up a cluster to a SQL dump via `pg_dump` |
+| `DescribeClusterSnapshots` | List snapshots, optionally filtered by snapshot or cluster identifier |
+| `DeleteClusterSnapshot` | Remove a snapshot and its stored dump |
+| `RestoreFromClusterSnapshot` | Create a new cluster and load a snapshot's dump into it via `psql` |
+| `CreateClusterParameterGroup` | Register a parameter group (metadata only) |
+| `DescribeClusterParameterGroups` | List parameter groups, optionally filtered by name |
+| `DescribeClusterParameters` | Return the parameters of a group, with any values set by `ModifyClusterParameterGroup` |
+| `ModifyClusterParameterGroup` | Update parameter values on a group |
+| `DeleteClusterParameterGroup` | Remove a parameter group |
+| `CreateTags` | Add or overwrite tags on a cluster, snapshot, subnet group or parameter group |
+| `DeleteTags` | Remove tags by key from a resource |
+| `DescribeTags` | List tagged resources and their tags |
+| `CreateClusterSubnetGroup` | Register a cluster subnet group (metadata only) |
+| `DescribeClusterSubnetGroups` | List subnet groups, optionally filtered by name |
+| `ModifyClusterSubnetGroup` | Update a subnet group's description or subnet list |
+| `DeleteClusterSubnetGroup` | Remove a subnet group |
+| `ModifyCluster` | Update node type, parameter group, security groups, or the master password |
+| `RebootCluster` | Restart a cluster's container |
+<!-- floci:actions:end -->
+
+## Configuration
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `FLOCI_SERVICES_REDSHIFT_ENABLED` | `true` | Enable or disable Redshift |
+| `FLOCI_SERVICES_REDSHIFT_IMAGE_VERSION` | `postgres:15-alpine` | PostgreSQL Docker image backing each cluster |
+| `FLOCI_SERVICES_REDSHIFT_DEFAULT_PORT` | `5439` | Reported Redshift port hint (the real host port is dynamic and comes from `DescribeClusters`) |
+
+Redshift needs the Docker socket so it can launch PostgreSQL containers. Each cluster's container is published on a dynamically assigned host port, returned by `DescribeClusters`.
+
+### Docker Compose
+
+```yaml
+services:
+ floci:
+ image: floci/floci:latest
+ ports:
+ - "4566:4566"
+ volumes:
+ - /var/run/docker.sock:/var/run/docker.sock
+```
+
+For private registry authentication and other Docker settings see [Docker Configuration](../configuration/docker.md).
+
+## Examples
+
+### Management API (AWS CLI)
+
+```bash
+export AWS_ENDPOINT_URL=http://localhost:4566
+export AWS_DEFAULT_REGION=us-east-1
+export AWS_ACCESS_KEY_ID=test
+export AWS_SECRET_ACCESS_KEY=test
+
+# Create a cluster (starts a PostgreSQL container)
+aws redshift create-cluster \
+ --cluster-identifier my-warehouse \
+ --node-type dc2.large \
+ --master-username admin \
+ --master-user-password Secret123
+
+# Read the cluster endpoint and port
+aws redshift describe-clusters \
+ --cluster-identifier my-warehouse \
+ --query 'Clusters[0].Endpoint'
+
+# Snapshot and restore
+aws redshift create-cluster-snapshot \
+ --snapshot-identifier snap-1 \
+ --cluster-identifier my-warehouse
+aws redshift restore-from-cluster-snapshot \
+ --cluster-identifier my-warehouse-restored \
+ --snapshot-identifier snap-1
+
+# Delete
+aws redshift delete-cluster \
+ --cluster-identifier my-warehouse \
+ --skip-final-cluster-snapshot
+```
+
+### Data plane (Python + psycopg)
+
+```python
+import psycopg
+
+# Read host and port from DescribeClusters — the host port is dynamic.
+host, port = "localhost", 32768 # e.g. Clusters[0].Endpoint.Address / .Port
+with psycopg.connect(f"host={host} port={port} dbname=dev user=admin password=Secret123") as conn:
+ conn.execute("CREATE TABLE people (name text)")
+ conn.execute("INSERT INTO people VALUES ('Alice')")
+ for row in conn.execute("SELECT * FROM people"):
+ print(row)
+```
+
+### Management API (Python / boto3)
+
+```python
+import boto3
+
+redshift = boto3.client(
+ "redshift",
+ endpoint_url="http://localhost:4566",
+ region_name="us-east-1",
+)
+
+cluster = redshift.create_cluster(
+ ClusterIdentifier="my-warehouse",
+ NodeType="dc2.large",
+ MasterUsername="admin",
+ MasterUserPassword="Secret123",
+)
+print(cluster["Cluster"]["Endpoint"])
+```
+
+## Out of Scope
+
+- Real Redshift SQL semantics — the data plane is stock PostgreSQL, so Redshift-only SQL (distribution/sort keys, `COPY`/`UNLOAD` from S3, `SUPER`/`SPECTRUM`) is not emulated.
+- Multi-node clusters — `NodeType` and `NumberOfNodes` are stored as metadata; every cluster is a single PostgreSQL container.
+- Parameter groups apply no real engine settings; values are stored and echoed back only.
+- Subnet groups, VPC routing, and security groups are metadata only.
+- Resize, pause/resume, IAM authentication, snapshot schedules, and cross-region snapshot copy.
diff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java
index 84faf36782..2e8cc5a99e 100644
--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java
+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java
@@ -263,6 +263,7 @@ public interface EmulatorConfig {
ElastiCacheStorageConfig elasticache();
MemoryDbStorageConfig memorydb();
RdsStorageConfig rds();
+ RedshiftStorageConfig redshift();
Ec2StorageConfig ec2();
NeptuneStorageConfig neptune();
BackupStorageConfig backup();
@@ -401,6 +402,10 @@ public interface EmulatorConfig {
long flushIntervalMs();
}
+ interface RedshiftStorageConfig {
+ Optional<String> mode();
+ }
+
interface RdsStorageConfig {
Optional<String> mode();
}
@@ -609,6 +614,7 @@ public interface EmulatorConfig {
ElastiCacheServiceConfig elasticache();
MemoryDbServiceConfig memorydb();
RdsServiceConfig rds();
+ RedshiftServiceConfig redshift();
RdsDataServiceConfig rdsData();
EventBridgeServiceConfig eventbridge();
CloudMapServiceConfig cloudmap();
@@ -1095,6 +1101,16 @@ public interface EmulatorConfig {
Optional<String> dockerNetwork();
}
+ interface RedshiftServiceConfig {
+ @WithDefault("true")
+ boolean enabled();
+ @WithDefault("5439")
+ int defaultPort();
+ @WithDefault("postgres:15-alpine")
+ String imageVersion();
+ Optional<String> dockerNetwork();
+ }
+
interface RdsServiceConfig {
String DEFAULT_POSTGRES_IMAGE = "postgres:16-alpine";
String DEFAULT_MYSQL_IMAGE = "mysql:8.0";
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsNamespaces.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsNamespaces.java
index c4fc69ab1a..0936f33df0 100644
--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsNamespaces.java
+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsNamespaces.java
@@ -22,6 +22,7 @@ public final class AwsNamespaces {
public static final String ELASTIC_BEANSTALK = "https://elasticbeanstalk.amazonaws.com/docs/2010-12-01/";
public static final String ROUTE53 = "https://route53.amazonaws.com/doc/2013-04-01/";
public static final String CLOUDFRONT = "http://cloudfront.amazonaws.com/doc/2020-05-31/";
+ public static final String REDSHIFT = "http://redshift.amazonaws.com/doc/2012-12-01/";
private AwsNamespaces() {}
}
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java
index 22b8bca5e9..f2689e54d0 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
@@ -16,6 +16,7 @@ import io.github.hectorvent.floci.services.iam.IamQueryHandler;
import io.github.hectorvent.floci.services.iam.StsQueryHandler;
import io.github.hectorvent.floci.services.rds.RdsQueryHandler;
import io.github.hectorvent.floci.services.rds.RdsService;
+import io.github.hectorvent.floci.services.redshift.RedshiftQueryHandler;
import io.github.hectorvent.floci.services.sns.SnsQueryHandler;
import io.github.hectorvent.floci.services.ses.SesQueryHandler;
import io.github.hectorvent.floci.services.sqs.SqsQueryHandler;
@@ -196,6 +197,7 @@ public class AwsQueryController {
private final ElbV2QueryHandler elbV2QueryHandler;
private final AutoScalingQueryHandler autoScalingQueryHandler;
private final ElasticBeanstalkQueryHandler elasticBeanstalkQueryHandler;
+ private final RedshiftQueryHandler redshiftQueryHandler;
private final ResolvedServiceCatalog catalog;
private final RegionResolver regionResolver;
@@ -217,6 +219,7 @@ public class AwsQueryController {
ElbV2QueryHandler elbV2QueryHandler,
AutoScalingQueryHandler autoScalingQueryHandler,
ElasticBeanstalkQueryHandler elasticBeanstalkQueryHandler,
+ RedshiftQueryHandler redshiftQueryHandler,
ResolvedServiceCatalog catalog,
RegionResolver regionResolver) {
this.cloudFormationQueryHandler = cloudFormationQueryHandler;
@@ -238,6 +241,7 @@ public class AwsQueryController {
this.elbV2QueryHandler = elbV2QueryHandler;
this.autoScalingQueryHandler = autoScalingQueryHandler;
this.elasticBeanstalkQueryHandler = elasticBeanstalkQueryHandler;
+ this.redshiftQueryHandler = redshiftQueryHandler;
this.catalog = catalog;
this.regionResolver = regionResolver;
}
@@ -342,6 +346,7 @@ public class AwsQueryController {
case "elasticloadbalancing" -> elbV2QueryHandler.handle(action, formParams, region);
case "autoscaling" -> autoScalingQueryHandler.handle(action, formParams, region);
case "elasticbeanstalk" -> elasticBeanstalkQueryHandler.handle(action, formParams, region);
+ case "redshift" -> redshiftQueryHandler.handle(action, formParams);
default -> xmlErrorResponse("UnknownService",
"Unknown or unsupported service: " + service, 400);
};
@@ -533,6 +538,16 @@ public class AwsQueryController {
"AdminAddUserToGroup", "AdminRemoveUserFromGroup", "AdminListGroupsForUser"
);
+ private static final Set<String> REDSHIFT_ACTIONS = Set.of(
+ "CreateCluster", "DescribeClusters", "DeleteCluster",
+ "CreateClusterSnapshot", "DescribeClusterSnapshots", "DeleteClusterSnapshot", "RestoreFromClusterSnapshot",
+ "ModifyCluster", "RebootCluster",
+ "CreateClusterParameterGroup", "DescribeClusterParameterGroups", "DescribeClusterParameters", "DeleteClusterParameterGroup",
+ "ModifyClusterParameterGroup",
+ "CreateClusterSubnetGroup", "DescribeClusterSubnetGroups", "ModifyClusterSubnetGroup", "DeleteClusterSubnetGroup",
+ "CreateTags", "DeleteTags", "DescribeTags"
+ );
+
private String resolveService(String authorization, String action) {
ServiceDescriptor descriptor = SigV4CredentialScope.serviceName(authorization)
.flatMap(catalog::byCredentialScope)
@@ -583,6 +598,9 @@ public class AwsQueryController {
if (ELASTIC_BEANSTALK_ACTIONS.contains(action)) {
return "elasticbeanstalk";
}
+ if (REDSHIFT_ACTIONS.contains(action)) {
+ return "redshift";
+ }
// SQS actions are numerous and not enumerated — fall back to sqs only for
// requests that arrived without an Authorization header (raw/test clients)
return "sqs";
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java b/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java
index 46087b4805..707d6cb6c3 100644
--- a/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java
+++ b/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java
@@ -156,6 +156,11 @@ public class ResolvedServiceCatalog {
5000L, AwsNamespaces.RDS, ServiceProtocol.QUERY,
protocols(ServiceProtocol.QUERY),
Set.of(), Set.of("docdb"), Set.of(), Set.of()),
+ descriptor("redshift", "redshift", config.services().redshift().enabled(), true,
+ "redshift", storageMode(config.storage().services().redshift().mode(), config.storage().mode()),
+ 5000L, AwsNamespaces.REDSHIFT, ServiceProtocol.QUERY,
+ protocols(ServiceProtocol.QUERY),
+ Set.of(), Set.of("redshift"), Set.of(), Set.of()),
descriptor("events", "eventbridge", config.services().eventbridge().enabled(), true,
"eventbridge", config.storage().mode(), 5000L, null, ServiceProtocol.JSON,
diff --git a/src/main/java/io/github/hectorvent/floci/core/storage/AccountAwareStorageBackend.java b/src/main/java/io/github/hectorvent/floci/core/storage/AccountAwareStorageBackend.java
index 4063bbc7ab..2473a8fb86 100644
--- a/src/main/java/io/github/hectorvent/floci/core/storage/AccountAwareStorageBackend.java
+++ b/src/main/java/io/github/hectorvent/floci/core/storage/AccountAwareStorageBackend.java
@@ -380,6 +380,11 @@ public class AccountAwareStorageBackend<V> implements StorageBackend<String, V>
// ---
+ /** Returns the account ID that keys are currently being prefixed with. */
+ public String accountId() {
+ return prefix();
+ }
+
private String prefix() {
if (requestContextInstance != null) {
try {
diff --git a/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandler.java
new file mode 100644
index 0000000000..c57252fa6a
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandler.java
@@ -0,0 +1,598 @@
+package io.github.hectorvent.floci.services.redshift;
+
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.common.XmlBuilder;
+import io.github.hectorvent.floci.services.redshift.model.Cluster;
+import io.github.hectorvent.floci.services.redshift.model.ClusterParameterGroup;
+import io.github.hectorvent.floci.services.redshift.model.ClusterSubnetGroup;
+import io.github.hectorvent.floci.services.redshift.model.Parameter;
+import io.github.hectorvent.floci.services.redshift.model.Snapshot;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.Response;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+@ApplicationScoped
+public class RedshiftQueryHandler {
+ private final RedshiftService service;
+
+ @Inject
+ public RedshiftQueryHandler(RedshiftService service) {
+ this.service = service;
+ }
+
+ public Response handle(String action, MultivaluedMap<String, String> params) {
+ switch (action) {
+ case "CreateCluster" -> {
+ String identifier = params.getFirst("ClusterIdentifier");
+ String nodeType = params.getFirst("NodeType");
+ String masterUsername = params.getFirst("MasterUsername");
+ String masterUserPassword = params.getFirst("MasterUserPassword");
+ String clusterSubnetGroupName = params.getFirst("ClusterSubnetGroupName");
+ List<String> vpcSecurityGroupIds = memberList(params, "VpcSecurityGroupIds");
+
+ Cluster cluster = service.createCluster(identifier, nodeType, masterUsername, masterUserPassword,
+ clusterSubnetGroupName, vpcSecurityGroupIds);
+ String xml = new XmlBuilder()
+ .start("CreateClusterResponse")
+ .start("CreateClusterResult")
+ .raw(buildClusterXml(cluster))
+ .end("CreateClusterResult")
+ .start("ResponseMetadata")
+ .elem("RequestId", "test-req-id")
+ .end("ResponseMetadata")
+ .end("CreateClusterResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+ case "DescribeClusters" -> {
+ String identifier = params.getFirst("ClusterIdentifier");
+ List<Cluster> clusters = service.describeClusters(identifier);
+ XmlBuilder xmlBuilder = new XmlBuilder()
+ .start("DescribeClustersResponse")
+ .start("DescribeClustersResult")
+ .start("Clusters");
+ for (Cluster cluster : clusters) {
+ xmlBuilder.raw(buildClusterXml(cluster));
+ }
+ String xml = xmlBuilder
+ .end("Clusters")
+ .end("DescribeClustersResult")
+ .start("ResponseMetadata")
+ .elem("RequestId", "test-req-id")
+ .end("ResponseMetadata")
+ .end("DescribeClustersResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+ case "DeleteCluster" -> {
+ String identifier = params.getFirst("ClusterIdentifier");
+ Cluster cluster = service.deleteCluster(identifier);
+ String xml = new XmlBuilder()
+ .start("DeleteClusterResponse")
+ .start("DeleteClusterResult")
+ .raw(buildClusterXml(cluster))
+ .end("DeleteClusterResult")
+ .start("ResponseMetadata")
+ .elem("RequestId", "test-req-id")
+ .end("ResponseMetadata")
+ .end("DeleteClusterResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+ case "CreateClusterSnapshot" -> {
+ String snapshotIdentifier = params.getFirst("SnapshotIdentifier");
+ String clusterIdentifier = params.getFirst("ClusterIdentifier");
+ Snapshot snapshot = service.createSnapshot(snapshotIdentifier, clusterIdentifier);
+ String xml = new XmlBuilder()
+ .start("CreateClusterSnapshotResponse")
+ .start("CreateClusterSnapshotResult")
+ .raw(buildSnapshotXml(snapshot))
+ .end("CreateClusterSnapshotResult")
+ .start("ResponseMetadata")
+ .elem("RequestId", "test-req-id")
+ .end("ResponseMetadata")
+ .end("CreateClusterSnapshotResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+ case "DescribeClusterSnapshots" -> {
+ String snapshotIdentifier = params.getFirst("SnapshotIdentifier");
+ String clusterIdentifier = params.getFirst("ClusterIdentifier");
+ List<Snapshot> snapshots = service.describeSnapshots(snapshotIdentifier, clusterIdentifier);
+ XmlBuilder xmlBuilder = new XmlBuilder()
+ .start("DescribeClusterSnapshotsResponse")
+ .start("DescribeClusterSnapshotsResult")
+ .start("Snapshots");
+ for (Snapshot snapshot : snapshots) {
+ xmlBuilder.raw(buildSnapshotXml(snapshot));
+ }
+ String xml = xmlBuilder
+ .end("Snapshots")
+ .end("DescribeClusterSnapshotsResult")
+ .start("ResponseMetadata")
+ .elem("RequestId", "test-req-id")
+ .end("ResponseMetadata")
+ .end("DescribeClusterSnapshotsResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+ case "DeleteClusterSnapshot" -> {
+ String snapshotIdentifier = params.getFirst("SnapshotIdentifier");
+ Snapshot snapshot = service.deleteSnapshot(snapshotIdentifier);
+ String xml = new XmlBuilder()
+ .start("DeleteClusterSnapshotResponse")
+ .start("DeleteClusterSnapshotResult")
+ .raw(buildSnapshotXml(snapshot))
+ .end("DeleteClusterSnapshotResult")
+ .start("ResponseMetadata")
+ .elem("RequestId", "test-req-id")
+ .end("ResponseMetadata")
+ .end("DeleteClusterSnapshotResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+ case "RestoreFromClusterSnapshot" -> {
+ String clusterIdentifier = params.getFirst("ClusterIdentifier");
+ String snapshotIdentifier = params.getFirst("SnapshotIdentifier");
+ String nodeType = params.getFirst("NodeType");
+ Cluster cluster = service.restoreFromClusterSnapshot(clusterIdentifier, snapshotIdentifier, nodeType);
+ String xml = new XmlBuilder()
+ .start("RestoreFromClusterSnapshotResponse")
+ .start("RestoreFromClusterSnapshotResult")
+ .raw(buildClusterXml(cluster))
+ .end("RestoreFromClusterSnapshotResult")
+ .start("ResponseMetadata")
+ .elem("RequestId", "test-req-id")
+ .end("ResponseMetadata")
+ .end("RestoreFromClusterSnapshotResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+ case "CreateClusterParameterGroup" -> {
+ String parameterGroupName = params.getFirst("ParameterGroupName");
+ String parameterGroupFamily = params.getFirst("ParameterGroupFamily");
+ String description = params.getFirst("Description");
+ ClusterParameterGroup group = service.createClusterParameterGroup(parameterGroupName, parameterGroupFamily, description);
+ String xml = new XmlBuilder()
+ .start("CreateClusterParameterGroupResponse")
+ .start("CreateClusterParameterGroupResult")
+ .raw(buildClusterParameterGroupXml(group))
+ .end("CreateClusterParameterGroupResult")
+ .start("ResponseMetadata")
+ .elem("RequestId", "test-req-id")
+ .end("ResponseMetadata")
+ .end("CreateClusterParameterGroupResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+ case "DescribeClusterParameterGroups" -> {
+ String parameterGroupName = params.getFirst("ParameterGroupName");
+ List<ClusterParameterGroup> groups = service.describeClusterParameterGroups(parameterGroupName);
+ XmlBuilder xmlBuilder = new XmlBuilder()
+ .start("DescribeClusterParameterGroupsResponse")
+ .start("DescribeClusterParameterGroupsResult")
+ .start("ParameterGroups");
+ for (ClusterParameterGroup group : groups) {
+ xmlBuilder.raw(buildClusterParameterGroupXml(group));
+ }
+ String xml = xmlBuilder
+ .end("ParameterGroups")
+ .end("DescribeClusterParameterGroupsResult")
+ .start("ResponseMetadata")
+ .elem("RequestId", "test-req-id")
+ .end("ResponseMetadata")
+ .end("DescribeClusterParameterGroupsResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+ case "DescribeClusterParameters" -> {
+ String parameterGroupName = params.getFirst("ParameterGroupName");
+ if (parameterGroupName == null || parameterGroupName.isBlank()) {
+ throw new AwsException("InvalidParameterValue", "ParameterGroupName is required", 400);
+ }
+ List<Parameter> parameters = service.describeClusterParameters(parameterGroupName);
+
+ XmlBuilder xmlBuilder = new XmlBuilder()
+ .start("DescribeClusterParametersResponse")
+ .start("DescribeClusterParametersResult")
+ .start("Parameters");
+ for (Parameter param : parameters) {
+ xmlBuilder.raw(buildParameterXml(param));
+ }
+ String xml = xmlBuilder.end("Parameters")
+ .end("DescribeClusterParametersResult")
+ .start("ResponseMetadata")
+ .elem("RequestId", "test-req-id")
+ .end("ResponseMetadata")
+ .end("DescribeClusterParametersResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+ case "ModifyClusterParameterGroup" -> {
+ String parameterGroupName = params.getFirst("ParameterGroupName");
+ if (parameterGroupName == null || parameterGroupName.isBlank()) {
+ throw new AwsException("InvalidParameterValue", "ParameterGroupName is required", 400);
+ }
+ List<Parameter> updates = parseParameters(params);
+ service.modifyClusterParameterGroup(parameterGroupName, updates);
+ String xml = new XmlBuilder()
+ .start("ModifyClusterParameterGroupResponse")
+ .start("ModifyClusterParameterGroupResult")
+ .elem("ParameterGroupName", parameterGroupName)
+ .elem("ParameterGroupStatus", "pending-reboot")
+ .end("ModifyClusterParameterGroupResult")
+ .start("ResponseMetadata")
+ .elem("RequestId", "test-req-id")
+ .end("ResponseMetadata")
+ .end("ModifyClusterParameterGroupResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+ case "DeleteClusterParameterGroup" -> {
+ String parameterGroupName = params.getFirst("ParameterGroupName");
+ service.deleteClusterParameterGroup(parameterGroupName);
+ String xml = new XmlBuilder()
+ .start("DeleteClusterParameterGroupResponse")
+ .start("ResponseMetadata")
+ .elem("RequestId", "test-req-id")
+ .end("ResponseMetadata")
+ .end("DeleteClusterParameterGroupResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+ case "CreateTags" -> {
+ String resourceName = params.getFirst("ResourceName");
+ service.createTags(resourceName, parseTags(params));
+ String xml = new XmlBuilder()
+ .start("CreateTagsResponse")
+ .start("ResponseMetadata")
+ .elem("RequestId", "test-req-id")
+ .end("ResponseMetadata")
+ .end("CreateTagsResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+ case "DeleteTags" -> {
+ String resourceName = params.getFirst("ResourceName");
+ List<String> tagKeys = memberList(params, "TagKeys");
+ service.deleteTags(resourceName, tagKeys);
+ String xml = new XmlBuilder()
+ .start("DeleteTagsResponse")
+ .start("ResponseMetadata")
+ .elem("RequestId", "test-req-id")
+ .end("ResponseMetadata")
+ .end("DeleteTagsResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+ case "DescribeTags" -> {
+ String resourceName = params.getFirst("ResourceName");
+ String resourceType = params.getFirst("ResourceType");
+ List<String> tagKeys = memberList(params, "TagKeys");
+ List<RedshiftService.TaggedResource> tagged = service.describeTags(resourceName, resourceType, tagKeys);
+ XmlBuilder xmlBuilder = new XmlBuilder()
+ .start("DescribeTagsResponse")
+ .start("DescribeTagsResult")
+ .start("TaggedResources");
+ for (RedshiftService.TaggedResource t : tagged) {
+ xmlBuilder.start("TaggedResource")
+ .elem("ResourceName", t.resourceName())
+ .elem("ResourceType", t.resourceType())
+ .start("Tag")
+ .elem("Key", t.tagKey())
+ .elem("Value", t.tagValue())
+ .end("Tag")
+ .end("TaggedResource");
+ }
+ String xml = xmlBuilder
+ .end("TaggedResources")
+ .end("DescribeTagsResult")
+ .start("ResponseMetadata")
+ .elem("RequestId", "test-req-id")
+ .end("ResponseMetadata")
+ .end("DescribeTagsResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+ case "CreateClusterSubnetGroup" -> {
+ String name = params.getFirst("ClusterSubnetGroupName");
+ if (name == null || name.isBlank()) {
+ throw new AwsException("InvalidParameterValue", "ClusterSubnetGroupName is required", 400);
+ }
+ String description = params.getFirst("Description");
+ List<String> subnetIds = memberList(params, "SubnetIds");
+ ClusterSubnetGroup group = service.createClusterSubnetGroup(name, description, null, subnetIds);
+ String xml = new XmlBuilder()
+ .start("CreateClusterSubnetGroupResponse")
+ .start("CreateClusterSubnetGroupResult")
+ .raw(buildClusterSubnetGroupXml(group))
+ .end("CreateClusterSubnetGroupResult")
+ .start("ResponseMetadata")
+ .elem("RequestId", "test-req-id")
+ .end("ResponseMetadata")
+ .end("CreateClusterSubnetGroupResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+ case "DescribeClusterSubnetGroups" -> {
+ String name = params.getFirst("ClusterSubnetGroupName");
+ List<ClusterSubnetGroup> groups = service.describeClusterSubnetGroups(name);
+ XmlBuilder xmlBuilder = new XmlBuilder()
+ .start("DescribeClusterSubnetGroupsResponse")
+ .start("DescribeClusterSubnetGroupsResult")
+ .start("ClusterSubnetGroups");
+ for (ClusterSubnetGroup group : groups) {
+ xmlBuilder.raw(buildClusterSubnetGroupXml(group));
+ }
+ String xml = xmlBuilder
+ .end("ClusterSubnetGroups")
+ .end("DescribeClusterSubnetGroupsResult")
+ .start("ResponseMetadata")
+ .elem("RequestId", "test-req-id")
+ .end("ResponseMetadata")
+ .end("DescribeClusterSubnetGroupsResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+ case "ModifyClusterSubnetGroup" -> {
+ String name = params.getFirst("ClusterSubnetGroupName");
+ String description = params.getFirst("Description");
+ List<String> subnetIds = memberList(params, "SubnetIds");
+ ClusterSubnetGroup group = service.modifyClusterSubnetGroup(name, description, subnetIds);
+ String xml = new XmlBuilder()
+ .start("ModifyClusterSubnetGroupResponse")
+ .start("ModifyClusterSubnetGroupResult")
+ .raw(buildClusterSubnetGroupXml(group))
+ .end("ModifyClusterSubnetGroupResult")
+ .start("ResponseMetadata")
+ .elem("RequestId", "test-req-id")
+ .end("ResponseMetadata")
+ .end("ModifyClusterSubnetGroupResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+ case "DeleteClusterSubnetGroup" -> {
+ String name = params.getFirst("ClusterSubnetGroupName");
+ service.deleteClusterSubnetGroup(name);
+ String xml = new XmlBuilder()
+ .start("DeleteClusterSubnetGroupResponse")
+ .start("ResponseMetadata")
+ .elem("RequestId", "test-req-id")
+ .end("ResponseMetadata")
+ .end("DeleteClusterSubnetGroupResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+ case "ModifyCluster" -> {
+ String clusterIdentifier = params.getFirst("ClusterIdentifier");
+ if (clusterIdentifier == null || clusterIdentifier.isBlank()) {
+ throw new AwsException("InvalidParameterValue", "ClusterIdentifier is required", 400);
+ }
+ String nodeType = params.getFirst("NodeType");
+ Integer numberOfNodes = parseOptionalInteger(params, "NumberOfNodes");
+ String masterUserPassword = params.getFirst("MasterUserPassword");
+ String clusterParameterGroupName = params.getFirst("ClusterParameterGroupName");
+ List<String> vpcSecurityGroupIds = memberList(params, "VpcSecurityGroupIds");
+ Cluster cluster = service.modifyCluster(clusterIdentifier, nodeType, numberOfNodes,
+ masterUserPassword, clusterParameterGroupName, vpcSecurityGroupIds);
+ String xml = new XmlBuilder()
+ .start("ModifyClusterResponse")
+ .start("ModifyClusterResult")
+ .raw(buildClusterXml(cluster))
+ .end("ModifyClusterResult")
+ .start("ResponseMetadata")
+ .elem("RequestId", "test-req-id")
+ .end("ResponseMetadata")
+ .end("ModifyClusterResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+ case "RebootCluster" -> {
+ String clusterIdentifier = params.getFirst("ClusterIdentifier");
+ if (clusterIdentifier == null || clusterIdentifier.isBlank()) {
+ throw new AwsException("InvalidParameterValue", "ClusterIdentifier is required", 400);
+ }
+ Cluster cluster = service.rebootCluster(clusterIdentifier);
+ String xml = new XmlBuilder()
+ .start("RebootClusterResponse")
+ .start("RebootClusterResult")
+ .raw(buildClusterXml(cluster))
+ .end("RebootClusterResult")
+ .start("ResponseMetadata")
+ .elem("RequestId", "test-req-id")
+ .end("ResponseMetadata")
+ .end("RebootClusterResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+ default -> throw new AwsException("InvalidAction", "Action " + action + " is not supported", 400);
+ }
+ }
+
+ private String buildClusterXml(Cluster cluster) {
+ XmlBuilder builder = new XmlBuilder()
+ .start("Cluster")
+ .elem("ClusterIdentifier", cluster.getClusterIdentifier())
+ .elem("NodeType", cluster.getNodeType())
+ .elem("MasterUsername", cluster.getMasterUsername())
+ .elem("ClusterStatus", cluster.getClusterStatus())
+ .elem("ClusterSubnetGroupName", cluster.getClusterSubnetGroupName());
+
+ if (cluster.getVpcSecurityGroupIds() != null && !cluster.getVpcSecurityGroupIds().isEmpty()) {
+ builder.start("VpcSecurityGroups");
+ for (String sgId : cluster.getVpcSecurityGroupIds()) {
+ builder.start("VpcSecurityGroup").elem("VpcSecurityGroupId", sgId).end("VpcSecurityGroup");
+ }
+ builder.end("VpcSecurityGroups");
+ }
+
+ if (cluster.getClusterParameterGroupName() != null) {
+ builder.start("ClusterParameterGroups")
+ .start("ClusterParameterGroup")
+ .elem("ParameterGroupName", cluster.getClusterParameterGroupName())
+ .elem("ParameterApplyStatus", "in-sync")
+ .end("ClusterParameterGroup")
+ .end("ClusterParameterGroups");
+ }
+
+ if (cluster.getTags() != null && !cluster.getTags().isEmpty()) {
+ builder.start("Tags");
+ for (Map.Entry<String, String> tag : cluster.getTags().entrySet()) {
+ builder.start("Tag")
+ .elem("Key", tag.getKey())
+ .elem("Value", tag.getValue())
+ .end("Tag");
+ }
+ builder.end("Tags");
+ }
+
+ if (cluster.getEndpoint() != null) {
+ builder.start("Endpoint")
+ .elem("Address", cluster.getEndpoint().getAddress())
+ .elem("Port", String.valueOf(cluster.getEndpoint().getPort()))
+ .end("Endpoint");
+ }
+
+ return builder.end("Cluster").build();
+ }
+
+ private String buildSnapshotXml(Snapshot snapshot) {
+ XmlBuilder builder = new XmlBuilder()
+ .start("Snapshot")
+ .elem("SnapshotIdentifier", snapshot.getSnapshotIdentifier())
+ .elem("ClusterIdentifier", snapshot.getClusterIdentifier())
+ .elem("Status", snapshot.getStatus())
+ .elem("Port", String.valueOf(snapshot.getPort()))
+ .elem("MasterUsername", snapshot.getMasterUsername());
+
+ return builder.end("Snapshot").build();
+ }
+
+ private String buildClusterParameterGroupXml(ClusterParameterGroup group) {
+ XmlBuilder builder = new XmlBuilder()
+ .start("ClusterParameterGroup")
+ .elem("ParameterGroupName", group.getParameterGroupName())
+ .elem("ParameterGroupFamily", group.getParameterGroupFamily())
+ .elem("Description", group.getDescription());
+
+ return builder.end("ClusterParameterGroup").build();
+ }
+
+ private String buildClusterSubnetGroupXml(ClusterSubnetGroup group) {
+ XmlBuilder builder = new XmlBuilder()
+ .start("ClusterSubnetGroup")
+ .elem("ClusterSubnetGroupName", group.getClusterSubnetGroupName())
+ .elem("Description", group.getDescription())
+ .elem("VpcId", group.getVpcId())
+ .start("Subnets");
+ for (String subnetId : group.getSubnetIds()) {
+ builder.start("Subnet").elem("SubnetIdentifier", subnetId).end("Subnet");
+ }
+ return builder.end("Subnets").end("ClusterSubnetGroup").build();
+ }
+
+ private String buildParameterXml(Parameter param) {
+ XmlBuilder builder = new XmlBuilder()
+ .start("Parameter")
+ .elem("ParameterName", param.getParameterName())
+ .elem("ParameterValue", param.getParameterValue());
+
+ if (param.getDescription() != null) {
+ builder.elem("Description", param.getDescription());
+ }
+ if (param.getDataType() != null) {
+ builder.elem("DataType", param.getDataType());
+ }
+ return builder.end("Parameter").build();
+ }
+
+ private static List<String> memberList(MultivaluedMap<String, String> params, String baseName) {
+ return params.keySet().stream()
+ .filter(key -> key.matches(memberKeyRegex(baseName)))
+ .sorted(Comparator.comparingInt(RedshiftQueryHandler::numericSuffix))
+ .map(params::getFirst)
+ .filter(value -> value != null && !value.isBlank())
+ .toList();
+ }
+
+ // The AWS Query protocol accepts both the generic ".member.N" form and each shape's own
+ // locationName (e.g. the real Redshift SDK sends "SubnetIds.SubnetIdentifier.N", not "SubnetIds.member.N").
+ private static String memberKeyRegex(String baseName) {
+ String quoted = Pattern.quote(baseName);
+ return switch (baseName) {
+ case "SubnetIds" -> quoted + "(\\.member|\\.SubnetIdentifier)?\\.\\d+";
+ case "VpcSecurityGroupIds" -> quoted + "(\\.member|\\.VpcSecurityGroupId)?\\.\\d+";
+ case "TagKeys" -> quoted + "(\\.member|\\.TagKey)?\\.\\d+";
+ default -> quoted + "(\\.member)?\\.\\d+";
+ };
+ }
+
+ private static int numericSuffix(String key) {
+ int lastDot = key.lastIndexOf('.');
+ if (lastDot < 0 || lastDot == key.length() - 1) {
+ return Integer.MAX_VALUE;
+ }
+ try {
+ return Integer.parseInt(key.substring(lastDot + 1));
+ } catch (NumberFormatException e) {
+ return Integer.MAX_VALUE;
+ }
+ }
+
+ private static List<Parameter> parseParameters(MultivaluedMap<String, String> params) {
+ List<Parameter> parsed = new ArrayList<>();
+ readParameters(params, "Parameters.member", parsed);
+ readParameters(params, "Parameters.Parameter", parsed);
+ return parsed;
+ }
+
+ private static void readParameters(MultivaluedMap<String, String> params, String prefix, List<Parameter> parsed) {
+ for (int i = 1; ; i++) {
+ String name = params.getFirst(prefix + "." + i + ".ParameterName");
+ if (name == null) {
+ break;
+ }
+ String value = params.getFirst(prefix + "." + i + ".ParameterValue");
+ parsed.add(new Parameter(name, value));
+ }
+ }
+
+ private static Map<String, String> parseTags(MultivaluedMap<String, String> params) {
+ Map<String, String> tags = new LinkedHashMap<>();
+ readTags(params, "Tags.member", tags);
+ readTags(params, "Tags.Tag", tags);
+ return tags;
+ }
+
+ private static void readTags(MultivaluedMap<String, String> params, String prefix, Map<String, String> tags) {
+ for (int i = 1; ; i++) {
+ String key = params.getFirst(prefix + "." + i + ".Key");
+ if (key == null) {
+ break;
+ }
+ String value = params.getFirst(prefix + "." + i + ".Value");
+ tags.put(key, value == null ? "" : value);
+ }
+ }
+
+ private static Integer parseOptionalInteger(MultivaluedMap<String, String> params, String parameterName) {
+ String value = params.getFirst(parameterName);
+ if (value == null) {
+ return null;
+ }
+ try {
+ return Integer.valueOf(value);
+ } catch (NumberFormatException e) {
+ throw new AwsException("InvalidParameterValue", parameterName + " must be an integer.", 400);
+ }
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftService.java b/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftService.java
new file mode 100644
index 0000000000..40cc75c875
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftService.java
@@ -0,0 +1,728 @@
+package io.github.hectorvent.floci.services.redshift;
+
+import io.github.hectorvent.floci.config.EmulatorConfig;
+import io.github.hectorvent.floci.core.common.AwsArnUtils;
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.common.RegionResolver;
+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;
+import io.github.hectorvent.floci.core.storage.StorageFactory;
+import io.github.hectorvent.floci.services.redshift.container.RedshiftContainerHandle;
+import io.github.hectorvent.floci.services.redshift.container.RedshiftContainerManager;
+import io.github.hectorvent.floci.services.redshift.model.Cluster;
+import io.github.hectorvent.floci.services.redshift.model.ClusterParameterGroup;
+import io.github.hectorvent.floci.services.redshift.model.ClusterSubnetGroup;
+import io.github.hectorvent.floci.services.redshift.model.Endpoint;
+import io.github.hectorvent.floci.services.redshift.model.Parameter;
+import io.github.hectorvent.floci.services.redshift.model.Snapshot;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.enterprise.event.Observes;
+import jakarta.inject.Inject;
+import com.fasterxml.jackson.core.type.TypeReference;
+import io.quarkus.runtime.StartupEvent;
+import org.jboss.logging.Logger;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Consumer;
+
+@ApplicationScoped
+public class RedshiftService {
+ private static final Logger LOG = Logger.getLogger(RedshiftService.class);
+
+ private final AccountAwareStorageBackend<Cluster> clusters;
+ private final AccountAwareStorageBackend<Snapshot> snapshots;
+ private final AccountAwareStorageBackend<ClusterParameterGroup> parameterGroups;
+ private final AccountAwareStorageBackend<ClusterSubnetGroup> subnetGroups;
+ private final RedshiftContainerManager containerManager;
+ private final EmulatorConfig config;
+ private final RegionResolver regionResolver;
+
+ @Inject
+ public RedshiftService(StorageFactory storageFactory, RedshiftContainerManager containerManager,
+ EmulatorConfig config, RegionResolver regionResolver) {
+ this.clusters = storageFactory.create("redshift", "redshift-clusters.json", new TypeReference<Map<String, Cluster>>() {});
+ this.snapshots = storageFactory.create("redshift", "redshift-snapshots.json", new TypeReference<Map<String, Snapshot>>() {});
+ this.parameterGroups = storageFactory.create("redshift", "redshift-parameter-groups.json", new TypeReference<Map<String, ClusterParameterGroup>>() {});
+ this.subnetGroups = storageFactory.create("redshift", "redshift-subnet-groups.json", new TypeReference<Map<String, ClusterSubnetGroup>>() {});
+ this.containerManager = containerManager;
+ this.config = config;
+ this.regionResolver = regionResolver;
+ }
+
+ // Recreate Docker containers for persisted clusters on app restart (across every account, not just default)
+ void onStart(@Observes StartupEvent event) {
+ List<AccountAwareStorageBackend.AccountEntry<Cluster>> availableClusters =
+ clusters.scanAllAccountEntries(k -> true).stream()
+ .filter(entry -> "available".equals(entry.value().getClusterStatus()))
+ .toList();
+ for (AccountAwareStorageBackend.AccountEntry<Cluster> entry : availableClusters) {
+ Cluster cluster = entry.value();
+ if (containerManager.getContainer(entry.accountId(), cluster.getClusterIdentifier()).isPresent()) {
+ continue;
+ }
+ String password = cluster.getMasterPassword() != null ? cluster.getMasterPassword() : "admin";
+ try {
+ LOG.infov("Recovering container for persisted cluster: {0}", cluster.getClusterIdentifier());
+ RedshiftContainerHandle handle = containerManager.adoptOrStart(
+ entry.accountId(), cluster.getClusterIdentifier(), cluster.getMasterUsername(), password);
+ Endpoint endpoint = new Endpoint();
+ endpoint.setAddress(handle.getHost());
+ endpoint.setPort(handle.getPort());
+ cluster.setEndpoint(endpoint);
+ clusters.putForAccount(entry.accountId(), entry.key(), cluster);
+ } catch (Exception e) {
+ LOG.warnv(e, "Failed to recover container for cluster {0}, marking as unavailable",
+ cluster.getClusterIdentifier());
+ cluster.setClusterStatus("unavailable");
+ clusters.putForAccount(entry.accountId(), entry.key(), cluster);
+ }
+ }
+ clusters.flush();
+ }
+
+ public Cluster createCluster(String identifier, String nodeType, String username, String password) {
+ return createCluster(identifier, nodeType, username, password, null, List.of());
+ }
+
+ public Cluster createCluster(String identifier, String nodeType, String username, String password,
+ String clusterSubnetGroupName, List<String> vpcSecurityGroupIds) {
+ if (clusters.get(identifier).isPresent()) {
+ throw new AwsException("ClusterAlreadyExists", "Cluster " + identifier + " already exists", 400);
+ }
+
+ Cluster cluster = new Cluster();
+ cluster.setClusterIdentifier(identifier);
+ cluster.setNodeType(nodeType);
+ cluster.setMasterUsername(username);
+ cluster.setMasterPassword(password);
+ cluster.setClusterSubnetGroupName(clusterSubnetGroupName);
+ cluster.setVpcSecurityGroupIds(vpcSecurityGroupIds != null ? vpcSecurityGroupIds : List.of());
+ cluster.setClusterStatus("creating");
+ clusters.put(identifier, cluster);
+ clusters.flush();
+
+ // Start container
+ try {
+ RedshiftContainerHandle handle = containerManager.start(clusters.accountId(), identifier, username, password);
+ Endpoint endpoint = new Endpoint();
+ endpoint.setAddress(handle.getHost());
+ endpoint.setPort(handle.getPort());
+ cluster.setEndpoint(endpoint);
+ cluster.setClusterStatus("available");
+ } catch (Exception e) {
+ cluster.setClusterStatus("failed");
+ clusters.flush();
+ throw new AwsException("InternalFailure", "Failed to start container: " + e.getMessage(), 500);
+ }
+
+ clusters.put(identifier, cluster);
+ clusters.flush();
+ return cluster;
+ }
+
+ public List<Cluster> describeClusters(String identifier) {
+ if (identifier != null) {
+ Optional<Cluster> cluster = clusters.get(identifier);
+ if (cluster.isEmpty()) {
+ throw new AwsException("ClusterNotFound", "Cluster " + identifier + " not found", 404);
+ }
+ return List.of(cluster.get());
+ }
+ return clusters.scan(k -> true);
+ }
+
+ public Cluster deleteCluster(String identifier) {
+ Optional<Cluster> clusterOpt = clusters.get(identifier);
+ if (clusterOpt.isEmpty()) {
+ throw new AwsException("ClusterNotFound", "Cluster " + identifier + " not found", 404);
+ }
+ Cluster cluster = clusterOpt.get();
+
+ containerManager.stop(clusters.accountId(), identifier);
+ clusters.delete(identifier);
+ clusters.flush();
+
+ cluster.setClusterStatus("deleting");
+ return cluster;
+ }
+
+ public synchronized Cluster modifyCluster(String clusterIdentifier, String nodeType, Integer numberOfNodes,
+ String masterUserPassword, String clusterParameterGroupName,
+ List<String> vpcSecurityGroupIds) {
+ Cluster cluster = clusters.get(clusterIdentifier)
+ .orElseThrow(() -> new AwsException("ClusterNotFound", "Cluster " + clusterIdentifier + " not found", 404));
+
+ // alterUserPassword runs before any mutation of the cluster object (a live reference
+ // from HybridStorage, not a copy) — if it throws, no metadata has been changed yet.
+ if (masterUserPassword != null && !masterUserPassword.isBlank()) {
+ containerManager.alterUserPassword(clusters.accountId(), clusterIdentifier,
+ cluster.getMasterUsername(), masterUserPassword);
+ cluster.setMasterPassword(masterUserPassword);
+ }
+
+ // NodeType only updates metadata — it does not resize the underlying Postgres container
+ // (Redshift node-count has no equivalent here). NumberOfNodes is accepted for API-shape
+ // compatibility but is not modelled or stored anywhere — known gap, see plan Task 9.
+ if (nodeType != null && !nodeType.isBlank()) {
+ cluster.setNodeType(nodeType);
+ }
+ if (clusterParameterGroupName != null && !clusterParameterGroupName.isBlank()) {
+ cluster.setClusterParameterGroupName(clusterParameterGroupName);
+ }
+ if (vpcSecurityGroupIds != null && !vpcSecurityGroupIds.isEmpty()) {
+ cluster.setVpcSecurityGroupIds(vpcSecurityGroupIds);
+ }
+
+ clusters.put(clusterIdentifier, cluster);
+ clusters.flush();
+ return cluster;
+ }
+
+ public synchronized Cluster rebootCluster(String clusterIdentifier) {
+ Cluster cluster = clusters.get(clusterIdentifier)
+ .orElseThrow(() -> new AwsException("ClusterNotFound", "Cluster " + clusterIdentifier + " not found", 404));
+
+ // The container backing a cluster has no persistent volume (see RedshiftContainerManager),
+ // so a plain stop+recreate would silently drop the cluster's data. Dump before stopping and
+ // restore immediately after starting, using a throwaway temp file — no Snapshot resource is
+ // created or exposed to the caller.
+ Path tempDump;
+ try {
+ tempDump = Files.createTempFile("redshift-reboot-" + clusterIdentifier, ".sql");
+ } catch (IOException e) {
+ throw new AwsException("InternalFailure", "Failed to prepare reboot dump file: " + e.getMessage(), 500);
+ }
+
+ try {
+ containerManager.takeSnapshot(clusters.accountId(), clusterIdentifier, cluster.getMasterUsername(), tempDump);
+ containerManager.stop(clusters.accountId(), clusterIdentifier);
+
+ String password = cluster.getMasterPassword() != null ? cluster.getMasterPassword() : "admin";
+ RedshiftContainerHandle handle = containerManager.start(
+ clusters.accountId(), clusterIdentifier, cluster.getMasterUsername(), password);
+ Endpoint endpoint = new Endpoint();
+ endpoint.setAddress(handle.getHost());
+ endpoint.setPort(handle.getPort());
+ cluster.setEndpoint(endpoint);
+
+ containerManager.restoreSnapshot(clusters.accountId(), clusterIdentifier, cluster.getMasterUsername(), tempDump);
+
+ cluster.setClusterStatus("available");
+ } catch (AwsException e) {
+ cluster.setClusterStatus("failed");
+ clusters.flush();
+ throw e;
+ } catch (Exception e) {
+ cluster.setClusterStatus("failed");
+ clusters.flush();
+ throw new AwsException("InternalFailure", "Failed to reboot cluster " + clusterIdentifier + ": " + e.getMessage(), 500);
+ } finally {
+ try {
+ Files.deleteIfExists(tempDump);
+ } catch (IOException ignored) {
+ // best-effort cleanup of a temp file
+ }
+ }
+
+ clusters.put(clusterIdentifier, cluster);
+ clusters.flush();
+ return cluster;
+ }
+
+ // ── Snapshot Operations ──────────────────────────────────────────────────
+
+ // AWS constrains a snapshot identifier to 1-255 characters, first a letter, then
+ // letters, digits or single hyphens (no trailing or doubled hyphen). Enforcing that
+ // here also keeps the value safe to splice into the dump file path below: '.', '/'
+ // and '\' can never appear, so it cannot escape the account's dump directory.
+ private static void validateSnapshotIdentifier(String id) {
+ if (id == null || !id.matches("[a-zA-Z][a-zA-Z0-9-]{0,254}")
+ || id.contains("--") || id.endsWith("-")) {
+ throw new AwsException("InvalidParameterValue",
+ "SnapshotIdentifier must be 1-255 characters, start with a letter, and contain "
+ + "only letters, digits and non-consecutive hyphens", 400);
+ }
+ }
+
+ /** Absolute, normalised {@code <persistentPath>/redshift-dumps/<accountId>} for this request's account. */
+ private Path accountDumpDir() {
+ return Paths.get(config.storage().persistentPath())
+ .resolve("redshift-dumps")
+ .resolve(clusters.accountId())
+ .toAbsolutePath()
+ .normalize();
+ }
+
+ /**
+ * A stored {@code sqlDump} path is trusted only if it still resolves inside this account's
+ * dump directory. Guards restore/delete against a path persisted by an older, unvalidated
+ * createSnapshot (or by a different account).
+ */
+ private boolean isTrustedDumpPath(String storedPath) {
+ if (storedPath == null || storedPath.isBlank()) {
+ return false;
+ }
+ Path dir = accountDumpDir();
+ return Paths.get(storedPath).toAbsolutePath().normalize().startsWith(dir);
+ }
+
+ public Snapshot createSnapshot(String snapshotIdentifier, String clusterIdentifier) {
+ validateSnapshotIdentifier(snapshotIdentifier);
+ Optional<Cluster> clusterOpt = clusters.get(clusterIdentifier);
+ if (clusterOpt.isEmpty()) {
+ throw new AwsException("ClusterNotFound", "Cluster " + clusterIdentifier + " not found", 404);
+ }
+ if (snapshots.get(snapshotIdentifier).isPresent()) {
+ throw new AwsException("ClusterSnapshotAlreadyExists", "Snapshot " + snapshotIdentifier + " already exists", 400);
+ }
+
+ Cluster cluster = clusterOpt.get();
+ Snapshot snapshot = new Snapshot();
+ snapshot.setSnapshotIdentifier(snapshotIdentifier);
+ snapshot.setClusterIdentifier(clusterIdentifier);
+ snapshot.setStatus("available");
+ snapshot.setMasterUsername(cluster.getMasterUsername());
+ snapshot.setMasterPassword(cluster.getMasterPassword());
+ if (cluster.getEndpoint() != null) {
+ snapshot.setPort(cluster.getEndpoint().getPort());
+ } else {
+ snapshot.setPort(5439);
+ }
+
+ Path dumpDir = accountDumpDir();
+ // Defence in depth: validateSnapshotIdentifier already rejects path separators,
+ // but keep the containment check so the dump can never land outside the account dir.
+ Path dumpFile = dumpDir.resolve(snapshotIdentifier + ".sql").normalize();
+ if (!dumpFile.startsWith(dumpDir)) {
+ throw new AwsException("InvalidParameterValue", "Invalid snapshot identifier", 400);
+ }
+ try {
+ Files.createDirectories(dumpDir);
+ containerManager.takeSnapshot(clusters.accountId(), clusterIdentifier, cluster.getMasterUsername(), dumpFile);
+ snapshot.setSqlDump(dumpFile.toString());
+ } catch (AwsException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new AwsException("InternalFailure", "Failed to take snapshot for cluster " + clusterIdentifier + ": " + e.getMessage(), 500);
+ }
+
+ snapshots.put(snapshotIdentifier, snapshot);
+ snapshots.flush();
+ return snapshot;
+ }
+
+ public List<Snapshot> describeSnapshots(String snapshotIdentifier, String clusterIdentifier) {
+ if (snapshotIdentifier != null && !snapshotIdentifier.isBlank()) {
+ Optional<Snapshot> snapshot = snapshots.get(snapshotIdentifier);
+ if (snapshot.isEmpty()) {
+ throw new AwsException("ClusterSnapshotNotFound", "Snapshot " + snapshotIdentifier + " not found", 404);
+ }
+ return List.of(snapshot.get());
+ }
+ if (clusterIdentifier != null && !clusterIdentifier.isBlank()) {
+ return snapshots.scan(k -> true).stream()
+ .filter(s -> clusterIdentifier.equals(s.getClusterIdentifier()))
+ .toList();
+ }
+ return snapshots.scan(k -> true);
+ }
+
+ public List<Snapshot> describeSnapshots(String snapshotIdentifier) {
+ return describeSnapshots(snapshotIdentifier, null);
+ }
+
+ public Optional<Snapshot> getSnapshot(String snapshotIdentifier) {
+ return snapshots.get(snapshotIdentifier);
+ }
+
+ public Snapshot deleteSnapshot(String snapshotIdentifier) {
+ Optional<Snapshot> snapshotOpt = snapshots.get(snapshotIdentifier);
+ if (snapshotOpt.isEmpty()) {
+ throw new AwsException("ClusterSnapshotNotFound", "Snapshot " + snapshotIdentifier + " not found", 404);
+ }
+ Snapshot snapshot = snapshotOpt.get();
+ snapshots.delete(snapshotIdentifier);
+ snapshots.flush();
+ if (isTrustedDumpPath(snapshot.getSqlDump())) {
+ try {
+ Files.deleteIfExists(Paths.get(snapshot.getSqlDump()));
+ } catch (IOException e) {
+ // ignore
+ }
+ }
+ snapshot.setStatus("deleted");
+ return snapshot;
+ }
+
+ public Cluster restoreFromClusterSnapshot(String clusterIdentifier, String snapshotIdentifier) {
+ return restoreFromClusterSnapshot(clusterIdentifier, snapshotIdentifier, null);
+ }
+
+ public Cluster restoreFromClusterSnapshot(String clusterIdentifier, String snapshotIdentifier, String nodeType) {
+ if (clusters.get(clusterIdentifier).isPresent()) {
+ throw new AwsException("ClusterAlreadyExists", "Cluster " + clusterIdentifier + " already exists", 400);
+ }
+
+ Optional<Snapshot> snapshotOpt = snapshots.get(snapshotIdentifier);
+ if (snapshotOpt.isEmpty()) {
+ throw new AwsException("ClusterSnapshotNotFound", "Snapshot " + snapshotIdentifier + " not found", 404);
+ }
+
+ Snapshot snapshot = snapshotOpt.get();
+
+ // Validate the stored dump location up front, before any provisioning. A snapshot whose
+ // sqlDump was written by pre-validation code could point outside this account's dump dir;
+ // rejecting it here (rather than mid-restore) avoids leaving a half-created cluster record
+ // and an orphaned container behind.
+ String sqlDump = snapshot.getSqlDump();
+ boolean hasDump = sqlDump != null && !sqlDump.isBlank();
+ if (hasDump && !isTrustedDumpPath(sqlDump)) {
+ throw new AwsException("InvalidParameterValue",
+ "Snapshot " + snapshotIdentifier + " has an unusable dump location", 400);
+ }
+
+ String effectiveNodeType = (nodeType != null && !nodeType.isBlank()) ? nodeType : "dc2.large";
+ String username = snapshot.getMasterUsername() != null ? snapshot.getMasterUsername() : "admin";
+ String sourceCluster = snapshot.getClusterIdentifier();
+ String password = Optional.ofNullable(snapshot.getMasterPassword())
+ .filter(p -> !p.isBlank())
+ .or(() -> clusters.get(sourceCluster).map(Cluster::getMasterPassword))
+ .filter(p -> p != null && !p.isBlank())
+ .orElse("admin");
+
+ Cluster cluster = new Cluster();
+ cluster.setClusterIdentifier(clusterIdentifier);
+ cluster.setNodeType(effectiveNodeType);
+ cluster.setMasterUsername(username);
+ cluster.setMasterPassword(password);
+ cluster.setClusterStatus("creating");
+ clusters.put(clusterIdentifier, cluster);
+ clusters.flush();
+
+ try {
+ RedshiftContainerHandle handle = containerManager.start(clusters.accountId(), clusterIdentifier, username, password);
+ Endpoint endpoint = new Endpoint();
+ endpoint.setAddress(handle.getHost());
+ endpoint.setPort(handle.getPort());
+ cluster.setEndpoint(endpoint);
+
+ if (hasDump) {
+ containerManager.restoreSnapshot(clusters.accountId(), clusterIdentifier, username, Paths.get(sqlDump));
+ }
+
+ cluster.setClusterStatus("available");
+ } catch (AwsException e) {
+ cluster.setClusterStatus("failed");
+ clusters.flush();
+ throw e;
+ } catch (Exception e) {
+ cluster.setClusterStatus("failed");
+ clusters.flush();
+ throw new AwsException("InternalFailure", "Failed to restore cluster from snapshot: " + e.getMessage(), 500);
+ }
+
+ clusters.put(clusterIdentifier, cluster);
+ clusters.flush();
+ return cluster;
+ }
+
+ // ── Parameter Group Operations ───────────────────────────────────────────
+
+ public ClusterParameterGroup createClusterParameterGroup(String parameterGroupName, String parameterGroupFamily, String description) {
+ if (parameterGroups.get(parameterGroupName).isPresent()) {
+ throw new AwsException("ClusterParameterGroupAlreadyExists", "Cluster parameter group " + parameterGroupName + " already exists", 400);
+ }
+
+ ClusterParameterGroup group = new ClusterParameterGroup(parameterGroupName, parameterGroupFamily, description);
+ parameterGroups.put(parameterGroupName, group);
+ parameterGroups.flush();
+ return group;
+ }
+
+ public List<ClusterParameterGroup> describeClusterParameterGroups(String parameterGroupName) {
+ if (parameterGroupName != null && !parameterGroupName.isBlank()) {
+ Optional<ClusterParameterGroup> group = parameterGroups.get(parameterGroupName);
+ if (group.isEmpty()) {
+ throw new AwsException("ClusterParameterGroupNotFound", "Cluster parameter group " + parameterGroupName + " not found", 404);
+ }
+ return List.of(group.get());
+ }
+ return parameterGroups.scan(k -> true);
+ }
+
+ public Optional<ClusterParameterGroup> getClusterParameterGroup(String parameterGroupName) {
+ return parameterGroups.get(parameterGroupName);
+ }
+
+ public List<Parameter> describeClusterParameters(String parameterGroupName) {
+ ClusterParameterGroup group = parameterGroups.get(parameterGroupName)
+ .orElseThrow(() -> new AwsException("ClusterParameterGroupNotFound",
+ "Cluster parameter group " + parameterGroupName + " not found", 404));
+ return group.getParameters();
+ }
+
+ public synchronized ClusterParameterGroup modifyClusterParameterGroup(
+ String parameterGroupName, List<Parameter> updates) {
+ ClusterParameterGroup group = parameterGroups.get(parameterGroupName)
+ .orElseThrow(() -> new AwsException("ClusterParameterGroupNotFound",
+ "Cluster parameter group " + parameterGroupName + " not found", 404));
+
+ List<Parameter> current = new ArrayList<>(group.getParameters());
+ for (Parameter update : updates) {
+ boolean matched = false;
+ for (int i = 0; i < current.size(); i++) {
+ Parameter existing = current.get(i);
+ if (existing.getParameterName().equals(update.getParameterName())) {
+ // Preserve metadata (description, dataType) from existing parameter if not provided in update
+ existing.setParameterValue(update.getParameterValue());
+ if (update.getDescription() != null) {
+ existing.setDescription(update.getDescription());
+ }
+ if (update.getDataType() != null) {
+ existing.setDataType(update.getDataType());
+ }
+ matched = true;
+ break;
+ }
+ }
+ if (!matched) {
+ current.add(update);
+ }
+ }
+ group.setParameters(current);
+ parameterGroups.put(parameterGroupName, group);
+ parameterGroups.flush();
+ return group;
+ }
+
+ public ClusterParameterGroup deleteClusterParameterGroup(String parameterGroupName) {
+ Optional<ClusterParameterGroup> groupOpt = parameterGroups.get(parameterGroupName);
+ if (groupOpt.isEmpty()) {
+ throw new AwsException("ClusterParameterGroupNotFound", "Cluster parameter group " + parameterGroupName + " not found", 404);
+ }
+ ClusterParameterGroup group = groupOpt.get();
+ parameterGroups.delete(parameterGroupName);
+ parameterGroups.flush();
+ return group;
+ }
+
+ // ── Cluster Subnet Group Operations ──────────────────────────────────────
+
+ public ClusterSubnetGroup createClusterSubnetGroup(String name, String description, String vpcId, List<String> subnetIds) {
+ if (subnetGroups.get(name).isPresent()) {
+ throw new AwsException("ClusterSubnetGroupAlreadyExists", "Cluster subnet group " + name + " already exists", 400);
+ }
+ ClusterSubnetGroup group = new ClusterSubnetGroup(name, description, vpcId, subnetIds);
+ subnetGroups.put(name, group);
+ subnetGroups.flush();
+ return group;
+ }
+
+ public List<ClusterSubnetGroup> describeClusterSubnetGroups(String name) {
+ if (name != null && !name.isBlank()) {
+ ClusterSubnetGroup group = subnetGroups.get(name)
+ .orElseThrow(() -> new AwsException("ClusterSubnetGroupNotFound", "Cluster subnet group " + name + " not found", 404));
+ return List.of(group);
+ }
+ return subnetGroups.scan(k -> true);
+ }
+
+ public synchronized ClusterSubnetGroup modifyClusterSubnetGroup(String name, String description, List<String> subnetIds) {
+ ClusterSubnetGroup group = subnetGroups.get(name)
+ .orElseThrow(() -> new AwsException("ClusterSubnetGroupNotFound", "Cluster subnet group " + name + " not found", 404));
+ if (description != null) {
+ group.setDescription(description);
+ }
+ if (subnetIds != null && !subnetIds.isEmpty()) {
+ group.setSubnetIds(subnetIds);
+ }
+ subnetGroups.put(name, group);
+ subnetGroups.flush();
+ return group;
+ }
+
+ public ClusterSubnetGroup deleteClusterSubnetGroup(String name) {
+ ClusterSubnetGroup group = subnetGroups.get(name)
+ .orElseThrow(() -> new AwsException("ClusterSubnetGroupNotFound", "Cluster subnet group " + name + " not found", 404));
+ subnetGroups.delete(name);
+ subnetGroups.flush();
+ return group;
+ }
+
+ // ── Tagging Operations ───────────────────────────────────────────────────
+
+ /** A resolved tag target: its current tags plus a sink that persists an updated map. */
+ private record TagHandle(Map<String, String> tags, Consumer<Map<String, String>> save) {}
+
+ public record TaggedResource(String resourceName, String resourceType, String tagKey, String tagValue) {}
+
+ public Map<String, String> listTagsForResource(String resourceName) {
+ return Map.copyOf(resolveTagHandle(resourceName).tags());
+ }
+
+ public synchronized void createTags(String resourceName, Map<String, String> tags) {
+ TagHandle handle = resolveTagHandle(resourceName);
+ Map<String, String> updated = new LinkedHashMap<>(handle.tags());
+ updated.putAll(tags);
+ handle.save().accept(updated);
+ }
+
+ public synchronized void deleteTags(String resourceName, Collection<String> tagKeys) {
+ TagHandle handle = resolveTagHandle(resourceName);
+ Map<String, String> updated = new LinkedHashMap<>(handle.tags());
+ tagKeys.forEach(updated::remove);
+ handle.save().accept(updated);
+ }
+
+ public List<TaggedResource> describeTags(String resourceName, String resourceType, List<String> tagKeysFilter) {
+ List<TaggedResource> result = new ArrayList<>();
+ if (resourceName != null && !resourceName.isBlank()) {
+ TagHandle handle = resolveTagHandle(resourceName);
+ String type = arnResourceType(resourceName);
+ addTaggedResources(result, resourceName, type, handle.tags(), tagKeysFilter);
+ return result;
+ }
+ if (resourceType == null || "cluster".equalsIgnoreCase(resourceType)) {
+ for (Cluster c : clusters.scan(k -> true)) {
+ addTaggedResources(result, clusterArn(c.getClusterIdentifier()), "cluster", c.getTags(), tagKeysFilter);
+ }
+ }
+ if (resourceType == null || "snapshot".equalsIgnoreCase(resourceType)) {
+ for (Snapshot s : snapshots.scan(k -> true)) {
+ addTaggedResources(result, snapshotArn(s.getClusterIdentifier(), s.getSnapshotIdentifier()),
+ "snapshot", s.getTags(), tagKeysFilter);
+ }
+ }
+ if (resourceType == null || "parametergroup".equalsIgnoreCase(resourceType)) {
+ for (ClusterParameterGroup g : parameterGroups.scan(k -> true)) {
+ addTaggedResources(result, parameterGroupArn(g.getParameterGroupName()),
+ "parametergroup", g.getTags(), tagKeysFilter);
+ }
+ }
+ if (resourceType == null || "subnetgroup".equalsIgnoreCase(resourceType)) {
+ for (ClusterSubnetGroup g : subnetGroups.scan(k -> true)) {
+ addTaggedResources(result, subnetGroupArn(g.getClusterSubnetGroupName()),
+ "subnetgroup", g.getTags(), tagKeysFilter);
+ }
+ }
+ return result;
+ }
+
+ private void addTaggedResources(List<TaggedResource> out, String arn, String type,
+ Map<String, String> tags, List<String> tagKeysFilter) {
+ for (Map.Entry<String, String> e : tags.entrySet()) {
+ if (tagKeysFilter != null && !tagKeysFilter.isEmpty() && !tagKeysFilter.contains(e.getKey())) {
+ continue;
+ }
+ out.add(new TaggedResource(arn, type, e.getKey(), e.getValue()));
+ }
+ }
+
+ private String arnResourceType(String resourceName) {
+ AwsArnUtils.Arn arn = AwsArnUtils.parse(resourceName);
+ String resource = arn.resource();
+ int sep = resource.indexOf(':');
+ return resource.substring(0, sep);
+ }
+
+ private String clusterArn(String clusterIdentifier) {
+ return regionResolver.buildArn("redshift", regionResolver.getRegion(), "cluster:" + clusterIdentifier);
+ }
+
+ private String snapshotArn(String clusterIdentifier, String snapshotIdentifier) {
+ return regionResolver.buildArn("redshift", regionResolver.getRegion(),
+ "snapshot:" + clusterIdentifier + "/" + snapshotIdentifier);
+ }
+
+ private String parameterGroupArn(String parameterGroupName) {
+ return regionResolver.buildArn("redshift", regionResolver.getRegion(), "parametergroup:" + parameterGroupName);
+ }
+
+ private String subnetGroupArn(String name) {
+ return regionResolver.buildArn("redshift", regionResolver.getRegion(), "subnetgroup:" + name);
+ }
+
+ /**
+ * Resolves a tagging ResourceName to its backing resource.
+ *
+ * Redshift ARNs have the shape {@code arn:aws:redshift:<region>:<account>:<type>:<id>},
+ * where {@code <type>} is one of {@code cluster}, {@code snapshot} (id shape
+ * {@code <clusterId>/<snapshotId>}), or {@code parametergroup}. Unlike RDS's tag
+ * resolution, there is no bare-name fallback — Redshift tagging is new, so there is no
+ * existing caller to stay backward compatible with.
+ */
+ private TagHandle resolveTagHandle(String resourceName) {
+ if (resourceName == null || resourceName.isBlank()) {
+ throw new AwsException("InvalidParameterValue", "ResourceName is required.", 400);
+ }
+ if (!resourceName.startsWith("arn:")) {
+ throw new AwsException("InvalidParameterValue", "ResourceName must be a Redshift ARN: " + resourceName, 400);
+ }
+ AwsArnUtils.Arn arn;
+ try {
+ arn = AwsArnUtils.parse(resourceName);
+ } catch (IllegalArgumentException malformed) {
+ throw new AwsException("InvalidParameterValue", "Invalid resource name: " + resourceName, 400);
+ }
+ if (!"redshift".equals(arn.service())) {
+ throw new AwsException("InvalidParameterValue", "Invalid resource name: " + resourceName, 400);
+ }
+ String resource = arn.resource();
+ int sep = resource.indexOf(':');
+ if (sep < 0) {
+ throw new AwsException("InvalidParameterValue", "Invalid resource name: " + resourceName, 400);
+ }
+ String type = resource.substring(0, sep);
+ String id = resource.substring(sep + 1);
+
+ return switch (type) {
+ case "cluster" -> {
+ Cluster cluster = clusters.get(id)
+ .orElseThrow(() -> new AwsException("ClusterNotFound", "Cluster " + id + " not found", 404));
+ yield new TagHandle(cluster.getTags(), updated -> {
+ cluster.setTags(updated);
+ clusters.put(id, cluster);
+ clusters.flush();
+ });
+ }
+ case "snapshot" -> {
+ String snapshotId = id.contains("/") ? id.substring(id.lastIndexOf('/') + 1) : id;
+ Snapshot snapshot = snapshots.get(snapshotId)
+ .orElseThrow(() -> new AwsException("ClusterSnapshotNotFound", "Snapshot " + snapshotId + " not found", 404));
+ yield new TagHandle(snapshot.getTags(), updated -> {
+ snapshot.setTags(updated);
+ snapshots.put(snapshotId, snapshot);
+ snapshots.flush();
+ });
+ }
+ case "parametergroup" -> {
+ ClusterParameterGroup group = parameterGroups.get(id)
+ .orElseThrow(() -> new AwsException("ClusterParameterGroupNotFound", "Cluster parameter group " + id + " not found", 404));
+ yield new TagHandle(group.getTags(), updated -> {
+ group.setTags(updated);
+ parameterGroups.put(id, group);
+ parameterGroups.flush();
+ });
+ }
+ case "subnetgroup" -> {
+ ClusterSubnetGroup group = subnetGroups.get(id)
+ .orElseThrow(() -> new AwsException("ClusterSubnetGroupNotFound", "Cluster subnet group " + id + " not found", 404));
+ yield new TagHandle(group.getTags(), updated -> {
+ group.setTags(updated);
+ subnetGroups.put(id, group);
+ subnetGroups.flush();
+ });
+ }
+ default -> throw new AwsException("InvalidParameterValue",
+ "Tagging for resource type '" + type + "' is not supported: " + resourceName, 400);
+ };
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/redshift/container/RedshiftContainerHandle.java b/src/main/java/io/github/hectorvent/floci/services/redshift/container/RedshiftContainerHandle.java
new file mode 100644
index 0000000000..63fe9834d5
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/container/RedshiftContainerHandle.java
@@ -0,0 +1,25 @@
+package io.github.hectorvent.floci.services.redshift.container;
+
+import java.io.Closeable;
+
+public class RedshiftContainerHandle {
+ private final String containerId;
+ private final String clusterIdentifier;
+ private final String host;
+ private final int port;
+ private Closeable logStream;
+
+ public RedshiftContainerHandle(String containerId, String clusterIdentifier, String host, int port) {
+ this.containerId = containerId;
+ this.clusterIdentifier = clusterIdentifier;
+ this.host = host;
+ this.port = port;
+ }
+
+ public String getContainerId() { return containerId; }
+ public String getClusterIdentifier() { return clusterIdentifier; }
+ public String getHost() { return host; }
+ public int getPort() { return port; }
+ public void setLogStream(Closeable logStream) { this.logStream = logStream; }
+ public Closeable getLogStream() { return logStream; }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/redshift/container/RedshiftContainerManager.java b/src/main/java/io/github/hectorvent/floci/services/redshift/container/RedshiftContainerManager.java
new file mode 100644
index 0000000000..002c0059e8
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/container/RedshiftContainerManager.java
@@ -0,0 +1,386 @@
+package io.github.hectorvent.floci.services.redshift.container;
+
+import com.github.dockerjava.api.async.ResultCallback;
+import com.github.dockerjava.api.model.Frame;
+import com.github.dockerjava.api.model.StreamType;
+import io.github.hectorvent.floci.config.EmulatorConfig;
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.common.docker.ContainerBuilder;
+import io.github.hectorvent.floci.core.common.docker.ContainerDetector;
+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager;
+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager.ContainerInfo;
+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager.EndpointInfo;
+import io.github.hectorvent.floci.core.common.docker.ContainerLogStreamer;
+import io.github.hectorvent.floci.core.common.docker.ContainerSpec;
+import io.github.hectorvent.floci.services.redshift.model.Cluster;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import org.apache.commons.compress.archivers.tar.TarArchiveEntry;
+import org.apache.commons.compress.archivers.tar.TarArchiveInputStream;
+import org.apache.commons.compress.archivers.tar.TarArchiveOutputStream;
+import org.jboss.logging.Logger;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+@ApplicationScoped
+public class RedshiftContainerManager {
+
+ private static final Logger LOG = Logger.getLogger(RedshiftContainerManager.class);
+
+ private final ContainerBuilder containerBuilder;
+ private final ContainerLifecycleManager lifecycleManager;
+ private final ContainerLogStreamer logStreamer;
+ private final ContainerDetector containerDetector;
+ private final EmulatorConfig config;
+ private final Map<String, RedshiftContainerHandle> containers = new ConcurrentHashMap<>();
+
+ @Inject
+ public RedshiftContainerManager(ContainerBuilder containerBuilder,
+ ContainerLifecycleManager lifecycleManager,
+ ContainerLogStreamer logStreamer,
+ ContainerDetector containerDetector,
+ EmulatorConfig config) {
+ this.containerBuilder = containerBuilder;
+ this.lifecycleManager = lifecycleManager;
+ this.logStreamer = logStreamer;
+ this.containerDetector = containerDetector;
+ this.config = config;
+ }
+
+ public RedshiftContainerHandle start(String accountId, String clusterIdentifier, String masterUsername, String masterPassword) {
+ String image = config.services().redshift().imageVersion();
+ String containerName = containerName(accountId, clusterIdentifier);
+
+ List<String> envVars = List.of(
+ "POSTGRES_USER=" + masterUsername,
+ "POSTGRES_PASSWORD=" + masterPassword,
+ "POSTGRES_DB=dev"
+ );
+
+ ContainerBuilder.Builder specBuilder = containerBuilder.newContainer(image)
+ .withName(containerName)
+ .withEnv(envVars)
+ .withDockerNetwork(config.services().redshift().dockerNetwork())
+ .withLogRotation();
+
+ int enginePort = 5432; // Default postgres port
+ if (!containerDetector.isRunningInContainer()) {
+ specBuilder.withDynamicPort(enginePort);
+ } else {
+ specBuilder.withExposedPort(enginePort);
+ }
+
+ ContainerSpec spec = specBuilder.build();
+ ContainerInfo info = lifecycleManager.createAndStart(spec);
+ EndpointInfo endpoint = info.getEndpoint(enginePort);
+
+ RedshiftContainerHandle handle = new RedshiftContainerHandle(
+ info.containerId(), clusterIdentifier, endpoint.host(), endpoint.port());
+
+ try {
+ Closeable stream = logStreamer.attach(info.containerId(), "/floci/redshift", clusterIdentifier, "us-east-1", "redshift:" + clusterIdentifier);
+ handle.setLogStream(stream);
+ } catch (Exception e) {
+ LOG.warnv("Failed to stream logs for {0}", containerName);
+ }
+
+ try {
+ Thread.sleep(3000);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ }
+
+ containers.put(containerKey(accountId, clusterIdentifier), handle);
+ return handle;
+ }
+
+ /**
+ * Starts a cluster's container the same way {@link #start}, except that a container
+ * already running under this cluster's name (e.g. Floci's own process restarted but
+ * Docker did not) is adopted instead of destroyed and recreated. The container has no
+ * persistent volume, so a blind recreate would silently discard the cluster's data;
+ * adopting preserves it whenever the physical container survived. If no such container
+ * exists (first start, or the container itself was removed), this falls back to
+ * {@link #start} — in that case the previous data is unrecoverable, matching this
+ * project's decision not to back Redshift containers with a Docker volume.
+ */
+ public RedshiftContainerHandle adoptOrStart(String accountId, String clusterIdentifier, String masterUsername, String masterPassword) {
+ String containerName = containerName(accountId, clusterIdentifier);
+ var existing = lifecycleManager.findByName(containerName);
+ if (existing.isEmpty()) {
+ LOG.warnv("No surviving container for cluster {0}; starting a fresh empty one — the previous"
+ + " contents are not recoverable (no Docker volume backs Redshift containers)", clusterIdentifier);
+ return start(accountId, clusterIdentifier, masterUsername, masterPassword);
+ }
+
+ LOG.infov("Adopting existing container {0} for cluster {1} to avoid discarding its data",
+ containerName, clusterIdentifier);
+ int enginePort = 5432;
+ ContainerInfo info = lifecycleManager.adopt(existing.get().getId(), List.of(enginePort));
+ EndpointInfo endpoint = info.getEndpoint(enginePort);
+
+ RedshiftContainerHandle handle = new RedshiftContainerHandle(
+ info.containerId(), clusterIdentifier, endpoint.host(), endpoint.port());
+ try {
+ Closeable stream = logStreamer.attach(info.containerId(), "/floci/redshift", clusterIdentifier, "us-east-1", "redshift:" + clusterIdentifier);
+ handle.setLogStream(stream);
+ } catch (Exception e) {
+ LOG.warnv("Failed to stream logs for {0}", containerName);
+ }
+
+ containers.put(containerKey(accountId, clusterIdentifier), handle);
+ return handle;
+ }
+
+ public void stop(String accountId, String clusterIdentifier) {
+ containers.remove(containerKey(accountId, clusterIdentifier));
+ lifecycleManager.removeIfExists(containerName(accountId, clusterIdentifier));
+ }
+
+ public Optional<RedshiftContainerHandle> getContainer(String accountId, String clusterIdentifier) {
+ return Optional.ofNullable(containers.get(containerKey(accountId, clusterIdentifier)));
+ }
+
+ /** Distinguishes clusters that share an identifier across accounts, e.g. for the in-memory map key and Docker container name. */
+ private static String containerKey(String accountId, String clusterIdentifier) {
+ return accountId + "/" + clusterIdentifier;
+ }
+
+ private static String containerName(String accountId, String clusterIdentifier) {
+ return "floci-redshift-" + accountId + "-" + clusterIdentifier;
+ }
+
+ public void takeSnapshot(String accountId, String clusterIdentifier, String username, String dbname, Path outputFile) {
+ RedshiftContainerHandle handle = containers.get(containerKey(accountId, clusterIdentifier));
+ if (handle == null) {
+ throw new AwsException("ClusterNotFound", "Cluster container for " + clusterIdentifier + " not found", 404);
+ }
+
+ String effectiveUser = (username != null && !username.isBlank()) ? username : "postgres";
+ String effectiveDb = (dbname != null && !dbname.isBlank()) ? dbname : "dev";
+
+ String[] cmd = new String[]{"pg_dump", "-U", effectiveUser, effectiveDb, "-f", "/tmp/dump.sql"};
+ try {
+ ExecResult result = execInContainer(handle.getContainerId(), cmd, 30);
+ if (result.exitCode() != 0) {
+ LOG.warnv("pg_dump failed for cluster {0} (exit {1}): {2}", clusterIdentifier, result.exitCode(), result.stderr());
+ throw new AwsException("InternalFailure", "Failed to create snapshot for cluster " + clusterIdentifier + ": " + result.stderr(), 500);
+ }
+
+ try (InputStream in = lifecycleManager.getDockerClient().copyArchiveFromContainerCmd(handle.getContainerId(), "/tmp/dump.sql").exec();
+ TarArchiveInputStream tar = new TarArchiveInputStream(in)) {
+ tar.getNextTarEntry();
+ Files.copy(tar, outputFile, StandardCopyOption.REPLACE_EXISTING);
+ }
+ } catch (AwsException e) {
+ throw e;
+ } catch (Exception e) {
+ LOG.errorv(e, "Error executing pg_dump for cluster {0}", clusterIdentifier);
+ throw new AwsException("InternalFailure", "Failed to execute pg_dump for cluster " + clusterIdentifier + ": " + e.getMessage(), 500);
+ }
+ }
+
+ public void takeSnapshot(String accountId, String clusterIdentifier, String username, Path outputFile) {
+ takeSnapshot(accountId, clusterIdentifier, username, "dev", outputFile);
+ }
+
+ public void alterUserPassword(String accountId, String clusterIdentifier, String username, String newPassword) {
+ RedshiftContainerHandle handle = containers.get(containerKey(accountId, clusterIdentifier));
+ if (handle == null) {
+ throw new AwsException("ClusterNotFound", "Cluster container for " + clusterIdentifier + " not found", 404);
+ }
+ String effectiveUser = (username != null && !username.isBlank()) ? username : "postgres";
+ // Validate effectiveUser against safe SQL identifier pattern to prevent SQL injection.
+ // psql -c sends the query string to Postgres, which allows multiple ;-separated statements,
+ // so even argv-escaping doesn't protect against a username like "postgres; DROP TABLE ..."
+ if (!effectiveUser.matches("^[A-Za-z_][A-Za-z0-9_]*$")) {
+ throw new AwsException("InvalidParameterValue", "Username must be a valid SQL identifier", 400);
+ }
+ // AWS ModifyCluster rejects ', ", \, / and @ in MasterUserPassword and enforces an
+ // 8-64 length plus at least one uppercase, one lowercase and one digit — we enforce
+ // the same set for parity. The single-quote rejection is doubly load-bearing: the
+ // password is spliced into a psql -c SQL literal here, so ' would also break that
+ // literal — but it is AWS-correct regardless, so do not "fix" it away by escaping.
+ if (newPassword != null) {
+ for (char forbidden : new char[]{'\'', '"', '\\', '/', '@'}) {
+ if (newPassword.indexOf(forbidden) >= 0) {
+ throw new AwsException("InvalidParameterValue",
+ "MasterUserPassword must not contain ', \", \\, / or @", 400);
+ }
+ }
+ if (newPassword.length() < 8 || newPassword.length() > 64) {
+ throw new AwsException("InvalidParameterValue",
+ "MasterUserPassword must be between 8 and 64 characters in length", 400);
+ }
+ if (!newPassword.matches(".*[A-Z].*") || !newPassword.matches(".*[a-z].*")
+ || !newPassword.matches(".*[0-9].*")) {
+ throw new AwsException("InvalidParameterValue",
+ "MasterUserPassword must contain at least one uppercase letter, one lowercase letter and one number", 400);
+ }
+ }
+ String sql = "ALTER USER " + effectiveUser + " PASSWORD '" + newPassword + "'";
+ String[] cmd = new String[]{"psql", "-U", effectiveUser, "-d", "dev", "-c", sql};
+ try {
+ ExecResult result = execInContainer(handle.getContainerId(), cmd, 15);
+ if (result.exitCode() != 0) {
+ // Deliberately omit result.stderr() from the log and the exception: psql echoes
+ // the failing ALTER USER statement, which contains the password literal.
+ LOG.warnv("ALTER USER command failed for cluster {0} (exit {1})", clusterIdentifier, result.exitCode());
+ throw new AwsException("InternalFailure", "Failed to change master password for cluster " + clusterIdentifier, 500);
+ }
+ } catch (AwsException e) {
+ throw e;
+ } catch (Exception e) {
+ LOG.errorv(e, "Error changing master password for cluster {0}", clusterIdentifier);
+ throw new AwsException("InternalFailure", "Failed to change master password for cluster " + clusterIdentifier + ": " + e.getMessage(), 500);
+ }
+ }
+
+ public void createSnapshot(String accountId, Cluster cluster, Path outputFile) {
+ if (cluster == null) {
+ throw new AwsException("InvalidParameterValue", "Cluster cannot be null", 400);
+ }
+ takeSnapshot(accountId, cluster.getClusterIdentifier(), cluster.getMasterUsername(), "dev", outputFile);
+ }
+
+ public void restoreSnapshot(String accountId, String clusterIdentifier, String username, String dbname, Path sqlDumpFile) {
+ RedshiftContainerHandle handle = containers.get(containerKey(accountId, clusterIdentifier));
+ if (handle == null) {
+ throw new AwsException("ClusterNotFound", "Cluster container for " + clusterIdentifier + " not found", 404);
+ }
+
+ if (sqlDumpFile == null || !Files.exists(sqlDumpFile)) {
+ LOG.infov("Empty snapshot dump for cluster {0}, skipping restore", clusterIdentifier);
+ return;
+ }
+
+ String effectiveUser = (username != null && !username.isBlank()) ? username : "postgres";
+ String effectiveDb = (dbname != null && !dbname.isBlank()) ? dbname : "dev";
+ String fileName = sqlDumpFile.getFileName().toString();
+
+ try {
+ lifecycleManager.getDockerClient().copyArchiveToContainerCmd(handle.getContainerId())
+ .withHostResource(sqlDumpFile.toString())
+ .withRemotePath("/tmp")
+ .exec();
+
+ String[] cmd = new String[]{"psql", "-U", effectiveUser, "-d", effectiveDb, "-f", "/tmp/" + fileName};
+ ExecResult result = execInContainer(handle.getContainerId(), cmd, 60);
+ if (result.exitCode() != 0) {
+ LOG.warnv("psql restore failed for cluster {0} (exit {1}): {2}", clusterIdentifier, result.exitCode(), result.stderr());
+ throw new AwsException("InternalFailure", "Failed to restore snapshot for cluster " + clusterIdentifier + ": " + result.stderr(), 500);
+ }
+ } catch (AwsException e) {
+ throw e;
+ } catch (Exception e) {
+ LOG.errorv(e, "Error restoring snapshot for cluster {0}", clusterIdentifier);
+ throw new AwsException("InternalFailure", "Failed to restore snapshot for cluster " + clusterIdentifier + ": " + e.getMessage(), 500);
+ }
+ }
+
+ public void restoreSnapshot(String accountId, String clusterIdentifier, String username, Path sqlDumpFile) {
+ restoreSnapshot(accountId, clusterIdentifier, username, "dev", sqlDumpFile);
+ }
+
+ public void restoreSnapshot(String accountId, Cluster cluster, Path sqlDumpFile) {
+ if (cluster == null) {
+ throw new AwsException("InvalidParameterValue", "Cluster cannot be null", 400);
+ }
+ restoreSnapshot(accountId, cluster.getClusterIdentifier(), cluster.getMasterUsername(), "dev", sqlDumpFile);
+ }
+
+ private ExecResult execInContainer(String containerId, String[] cmd, int timeoutSeconds) throws Exception {
+ ByteArrayOutputStream stdout = new ByteArrayOutputStream();
+ ExecResult res = execInContainer(containerId, cmd, timeoutSeconds, stdout);
+ return new ExecResult(res.exitCode(), stdout.toString(StandardCharsets.UTF_8), res.stderr());
+ }
+
+ private ExecResult execInContainer(String containerId, String[] cmd, int timeoutSeconds, OutputStream out) throws Exception {
+ String execId = lifecycleManager.getDockerClient().execCreateCmd(containerId)
+ .withCmd(cmd)
+ .withAttachStdout(true)
+ .withAttachStderr(true)
+ .exec()
+ .getId();
+
+ CountDownLatch latch = new CountDownLatch(1);
+ ByteArrayOutputStream stderr = new ByteArrayOutputStream();
+
+ Closeable callback = lifecycleManager.getDockerClient().execStartCmd(execId).exec(new ResultCallback.Adapter<Frame>() {
+ @Override
+ public void onNext(Frame frame) {
+ byte[] payload = frame.getPayload();
+ if (payload == null) {
+ return;
+ }
+ try {
+ if (frame.getStreamType() == StreamType.STDERR) {
+ stderr.write(payload);
+ } else {
+ out.write(payload);
+ }
+ } catch (IOException ignored) {
+ }
+ }
+
+ @Override
+ public void onComplete() {
+ latch.countDown();
+ }
+
+ @Override
+ public void onError(Throwable t) {
+ LOG.warnv(t, "Container exec {0} failed", execId);
+ latch.countDown();
+ }
+ });
+
+ try {
+ boolean completed = latch.await(timeoutSeconds, TimeUnit.SECONDS);
+ if (!completed) {
+ return new ExecResult(-1, "", "Timed out after " + timeoutSeconds + "s");
+ }
+ Long exitCode = lifecycleManager.getDockerClient().inspectExecCmd(execId).exec().getExitCodeLong();
+ return new ExecResult(
+ exitCode != null ? exitCode : -1,
+ "",
+ stderr.toString(StandardCharsets.UTF_8));
+ } finally {
+ try {
+ callback.close();
+ } catch (IOException ignored) {
+ }
+ }
+ }
+
+ private byte[] buildSingleFileTar(String filename, byte[] content, int mode) throws IOException {
+ ByteArrayOutputStream bos = new ByteArrayOutputStream();
+ try (TarArchiveOutputStream tar = new TarArchiveOutputStream(bos)) {
+ tar.setLongFileMode(TarArchiveOutputStream.LONGFILE_GNU);
+ TarArchiveEntry entry = new TarArchiveEntry(filename);
+ entry.setSize(content.length);
+ entry.setMode(mode);
+ tar.putArchiveEntry(entry);
+ tar.write(content);
+ tar.closeArchiveEntry();
+ }
+ return bos.toByteArray();
+ }
+
+ public record ExecResult(long exitCode, String stdout, String stderr) {}
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/redshift/model/Cluster.java b/src/main/java/io/github/hectorvent/floci/services/redshift/model/Cluster.java
new file mode 100644
index 0000000000..cd518fabbe
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/model/Cluster.java
@@ -0,0 +1,44 @@
+package io.github.hectorvent.floci.services.redshift.model;
+
+import io.quarkus.runtime.annotations.RegisterForReflection;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+@RegisterForReflection
+public class Cluster {
+ private String clusterIdentifier;
+ private String nodeType;
+ private String masterUsername;
+ private String masterPassword;
+ private String clusterStatus;
+ private Endpoint endpoint;
+ private String clusterSubnetGroupName;
+ private String clusterParameterGroupName;
+ private List<String> vpcSecurityGroupIds = new ArrayList<>();
+
+ public String getClusterIdentifier() { return clusterIdentifier; }
+ public void setClusterIdentifier(String clusterIdentifier) { this.clusterIdentifier = clusterIdentifier; }
+ public String getNodeType() { return nodeType; }
+ public void setNodeType(String nodeType) { this.nodeType = nodeType; }
+ public String getMasterUsername() { return masterUsername; }
+ public void setMasterUsername(String masterUsername) { this.masterUsername = masterUsername; }
+ public String getMasterPassword() { return masterPassword; }
+ public void setMasterPassword(String masterPassword) { this.masterPassword = masterPassword; }
+ public String getClusterStatus() { return clusterStatus; }
+ public void setClusterStatus(String clusterStatus) { this.clusterStatus = clusterStatus; }
+ public Endpoint getEndpoint() { return endpoint; }
+ public void setEndpoint(Endpoint endpoint) { this.endpoint = endpoint; }
+ public String getClusterSubnetGroupName() { return clusterSubnetGroupName; }
+ public void setClusterSubnetGroupName(String clusterSubnetGroupName) { this.clusterSubnetGroupName = clusterSubnetGroupName; }
+ public String getClusterParameterGroupName() { return clusterParameterGroupName; }
+ public void setClusterParameterGroupName(String clusterParameterGroupName) { this.clusterParameterGroupName = clusterParameterGroupName; }
+ public List<String> getVpcSecurityGroupIds() { return vpcSecurityGroupIds; }
+ public void setVpcSecurityGroupIds(List<String> vpcSecurityGroupIds) { this.vpcSecurityGroupIds = vpcSecurityGroupIds; }
+
+ private Map<String, String> tags = new LinkedHashMap<>();
+
+ public Map<String, String> getTags() { return tags; }
+ public void setTags(Map<String, String> tags) { this.tags = tags; }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/redshift/model/ClusterParameterGroup.java b/src/main/java/io/github/hectorvent/floci/services/redshift/model/ClusterParameterGroup.java
new file mode 100644
index 0000000000..4b5ada595d
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/model/ClusterParameterGroup.java
@@ -0,0 +1,59 @@
+package io.github.hectorvent.floci.services.redshift.model;
+
+import io.quarkus.runtime.annotations.RegisterForReflection;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+@RegisterForReflection
+public class ClusterParameterGroup {
+ private String parameterGroupName;
+ private String parameterGroupFamily;
+ private String description;
+
+ public ClusterParameterGroup() {}
+
+ public ClusterParameterGroup(String parameterGroupName, String parameterGroupFamily, String description) {
+ this.parameterGroupName = parameterGroupName;
+ this.parameterGroupFamily = parameterGroupFamily;
+ this.description = description;
+ }
+
+ public String getParameterGroupName() {
+ return parameterGroupName;
+ }
+
+ public void setParameterGroupName(String parameterGroupName) {
+ this.parameterGroupName = parameterGroupName;
+ }
+
+ public String getParameterGroupFamily() {
+ return parameterGroupFamily;
+ }
+
+ public void setParameterGroupFamily(String parameterGroupFamily) {
+ this.parameterGroupFamily = parameterGroupFamily;
+ }
+
+ public String getDescription() {
+ return description;
+ }
+
+ public void setDescription(String description) {
+ this.description = description;
+ }
+
+ private Map<String, String> tags = new LinkedHashMap<>();
+
+ public Map<String, String> getTags() { return tags; }
+ public void setTags(Map<String, String> tags) { this.tags = tags; }
+
+ private List<Parameter> parameters = new ArrayList<>(List.of(
+ new Parameter("max_cursor_result_set_size", "0", "Maximum cursor result set size", "integer"),
+ new Parameter("wlm_json_configuration", "{}", "WLM configuration", "string")
+ ));
+
+ public List<Parameter> getParameters() { return parameters; }
+ public void setParameters(List<Parameter> parameters) { this.parameters = parameters; }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/redshift/model/ClusterSubnetGroup.java b/src/main/java/io/github/hectorvent/floci/services/redshift/model/ClusterSubnetGroup.java
new file mode 100644
index 0000000000..d73f53aed2
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/model/ClusterSubnetGroup.java
@@ -0,0 +1,37 @@
+package io.github.hectorvent.floci.services.redshift.model;
+
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+@RegisterForReflection
+public class ClusterSubnetGroup {
+ private String clusterSubnetGroupName;
+ private String description;
+ private String vpcId;
+ private List<String> subnetIds = new ArrayList<>();
+ private Map<String, String> tags = new LinkedHashMap<>();
+
+ public ClusterSubnetGroup() {}
+
+ public ClusterSubnetGroup(String clusterSubnetGroupName, String description, String vpcId, List<String> subnetIds) {
+ this.clusterSubnetGroupName = clusterSubnetGroupName;
+ this.description = description;
+ this.vpcId = vpcId;
+ this.subnetIds = subnetIds;
+ }
+
+ public String getClusterSubnetGroupName() { return clusterSubnetGroupName; }
+ public void setClusterSubnetGroupName(String clusterSubnetGroupName) { this.clusterSubnetGroupName = clusterSubnetGroupName; }
+ public String getDescription() { return description; }
+ public void setDescription(String description) { this.description = description; }
+ public String getVpcId() { return vpcId; }
+ public void setVpcId(String vpcId) { this.vpcId = vpcId; }
+ public List<String> getSubnetIds() { return subnetIds; }
+ public void setSubnetIds(List<String> subnetIds) { this.subnetIds = subnetIds; }
+ public Map<String, String> getTags() { return tags; }
+ public void setTags(Map<String, String> tags) { this.tags = tags; }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/redshift/model/Endpoint.java b/src/main/java/io/github/hectorvent/floci/services/redshift/model/Endpoint.java
new file mode 100644
index 0000000000..87370fc906
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/model/Endpoint.java
@@ -0,0 +1,21 @@
+package io.github.hectorvent.floci.services.redshift.model;
+
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+@RegisterForReflection
+public class Endpoint {
+ private String address;
+ private int port;
+
+ public Endpoint() {}
+
+ public Endpoint(String address, int port) {
+ this.address = address;
+ this.port = port;
+ }
+
+ public String getAddress() { return address; }
+ public void setAddress(String address) { this.address = address; }
+ public int getPort() { return port; }
+ public void setPort(int port) { this.port = port; }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/redshift/model/Parameter.java b/src/main/java/io/github/hectorvent/floci/services/redshift/model/Parameter.java
new file mode 100644
index 0000000000..927969bdfe
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/model/Parameter.java
@@ -0,0 +1,57 @@
+package io.github.hectorvent.floci.services.redshift.model;
+
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+@RegisterForReflection
+public class Parameter {
+ private String parameterName;
+ private String parameterValue;
+ private String description;
+ private String dataType;
+
+ public Parameter() {}
+
+ public Parameter(String parameterName, String parameterValue) {
+ this.parameterName = parameterName;
+ this.parameterValue = parameterValue;
+ }
+
+ public Parameter(String parameterName, String parameterValue, String description, String dataType) {
+ this.parameterName = parameterName;
+ this.parameterValue = parameterValue;
+ this.description = description;
+ this.dataType = dataType;
+ }
+
+ public String getParameterName() {
+ return parameterName;
+ }
+
+ public void setParameterName(String parameterName) {
+ this.parameterName = parameterName;
+ }
+
+ public String getParameterValue() {
+ return parameterValue;
+ }
+
+ public void setParameterValue(String parameterValue) {
+ this.parameterValue = parameterValue;
+ }
+
+ public String getDescription() {
+ return description;
+ }
+
+ public void setDescription(String description) {
+ this.description = description;
+ }
+
+ public String getDataType() {
+ return dataType;
+ }
+
+ public void setDataType(String dataType) {
+ this.dataType = dataType;
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/redshift/model/Snapshot.java b/src/main/java/io/github/hectorvent/floci/services/redshift/model/Snapshot.java
new file mode 100644
index 0000000000..9f6a7a825c
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/model/Snapshot.java
@@ -0,0 +1,96 @@
+package io.github.hectorvent.floci.services.redshift.model;
+
+import io.quarkus.runtime.annotations.RegisterForReflection;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+@RegisterForReflection
+public class Snapshot {
+ private String snapshotIdentifier;
+ private String clusterIdentifier;
+ private String status;
+ private int port;
+ private String masterUsername;
+ private String masterPassword;
+ private String sqlDump;
+
+ public Snapshot() {}
+
+ public Snapshot(String snapshotIdentifier, String clusterIdentifier, String status, int port, String masterUsername) {
+ this.snapshotIdentifier = snapshotIdentifier;
+ this.clusterIdentifier = clusterIdentifier;
+ this.status = status;
+ this.port = port;
+ this.masterUsername = masterUsername;
+ }
+
+ public Snapshot(String snapshotIdentifier, String clusterIdentifier, String status, int port, String masterUsername, String sqlDump) {
+ this.snapshotIdentifier = snapshotIdentifier;
+ this.clusterIdentifier = clusterIdentifier;
+ this.status = status;
+ this.port = port;
+ this.masterUsername = masterUsername;
+ this.sqlDump = sqlDump;
+ }
+
+ public String getSnapshotIdentifier() {
+ return snapshotIdentifier;
+ }
+
+ public void setSnapshotIdentifier(String snapshotIdentifier) {
+ this.snapshotIdentifier = snapshotIdentifier;
+ }
+
+ public String getClusterIdentifier() {
+ return clusterIdentifier;
+ }
+
+ public void setClusterIdentifier(String clusterIdentifier) {
+ this.clusterIdentifier = clusterIdentifier;
+ }
+
+ public String getStatus() {
+ return status;
+ }
+
+ public void setStatus(String status) {
+ this.status = status;
+ }
+
+ public int getPort() {
+ return port;
+ }
+
+ public void setPort(int port) {
+ this.port = port;
+ }
+
+ public String getMasterUsername() {
+ return masterUsername;
+ }
+
+ public void setMasterUsername(String masterUsername) {
+ this.masterUsername = masterUsername;
+ }
+
+ public String getMasterPassword() {
+ return masterPassword;
+ }
+
+ public void setMasterPassword(String masterPassword) {
+ this.masterPassword = masterPassword;
+ }
+
+ public String getSqlDump() {
+ return sqlDump;
+ }
+
+ public void setSqlDump(String sqlDump) {
+ this.sqlDump = sqlDump;
+ }
+
+ private Map<String, String> tags = new LinkedHashMap<>();
+
+ public Map<String, String> getTags() { return tags; }
+ public void setTags(Map<String, String> tags) { this.tags = tags; }
+}
diff --git a/src/main/resources/application.yml b/src/main/resources/application.yml
index a8dc3b6077..059686497b 100644
--- a/src/main/resources/application.yml
+++ b/src/main/resources/application.yml
@@ -312,6 +312,10 @@ floci:
proxy-base-port: 6400
proxy-max-port: 6419
default-image: "valkey/valkey:8"
+ redshift:
+ enabled: true
+ default-port: 5439
+ image-version: postgres:15-alpine
rds:
enabled: true
mock: false # FLOCI_SERVICES_RDS_MOCK — true = metadata only, no Docker (useful for CI)
diff --git a/src/test/java/io/github/hectorvent/floci/core/storage/AccountAwareStorageBackendTest.java b/src/test/java/io/github/hectorvent/floci/core/storage/AccountAwareStorageBackendTest.java
index 2e9edfa962..d789ea5527 100644
--- a/src/test/java/io/github/hectorvent/floci/core/storage/AccountAwareStorageBackendTest.java
+++ b/src/test/java/io/github/hectorvent/floci/core/storage/AccountAwareStorageBackendTest.java
@@ -12,6 +12,14 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
class AccountAwareStorageBackendTest {
+ @Test
+ void accountIdReturnsDefaultOutsideRequestScope() {
+ AccountAwareStorageBackend<String> storage =
+ new AccountAwareStorageBackend<>(new InMemoryStorage<>(), null, "111111111111");
+
+ assertEquals("111111111111", storage.accountId());
+ }
+
@Test
void guardedLegacyLookupMigratesMatchingRawValue() {
InMemoryStorage<String, String> raw = new InMemoryStorage<>();
diff --git a/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftOperationsTest.java b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftOperationsTest.java
new file mode 100644
index 0000000000..8c969c2b54
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftOperationsTest.java
@@ -0,0 +1,371 @@
+package io.github.hectorvent.floci.services.redshift;
+
+import io.github.hectorvent.floci.services.redshift.container.RedshiftContainerHandle;
+import io.github.hectorvent.floci.services.redshift.container.RedshiftContainerManager;
+import io.quarkus.test.InjectMock;
+import io.quarkus.test.junit.QuarkusTest;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.containsString;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+
+@QuarkusTest
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+public class RedshiftOperationsTest {
+
+ private static final String AUTH_HEADER =
+ "AWS4-HMAC-SHA256 Credential=test/20260822/us-east-1/redshift/aws4_request";
+
+ @InjectMock
+ RedshiftContainerManager containerManager;
+
+ @Test
+ @Order(1)
+ void testParameterGroupLifecycle() {
+ // 1. CreateClusterParameterGroup
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "CreateClusterParameterGroup")
+ .formParam("ParameterGroupName", "pg-test-1")
+ .formParam("ParameterGroupFamily", "redshift-1.0")
+ .formParam("Description", "Test Redshift Parameter Group")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .contentType("application/xml")
+ .body(containsString("<ParameterGroupName>pg-test-1</ParameterGroupName>"))
+ .body(containsString("<ParameterGroupFamily>redshift-1.0</ParameterGroupFamily>"));
+
+ // 2. DescribeClusterParameterGroups
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "DescribeClusterParameterGroups")
+ .formParam("ParameterGroupName", "pg-test-1")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .contentType("application/xml")
+ .body(containsString("<ParameterGroupName>pg-test-1</ParameterGroupName>"));
+
+ // 2b. ModifyClusterParameterGroup
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "ModifyClusterParameterGroup")
+ .formParam("ParameterGroupName", "pg-test-1")
+ .formParam("Parameters.member.1.ParameterName", "statement_timeout")
+ .formParam("Parameters.member.1.ParameterValue", "5000")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .contentType("application/xml")
+ .body(containsString("<ParameterGroupName>pg-test-1</ParameterGroupName>"));
+
+ // 3. DescribeClusterParameters
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "DescribeClusterParameters")
+ .formParam("ParameterGroupName", "pg-test-1")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .contentType("application/xml")
+ .body(containsString("<DescribeClusterParametersResponse>"))
+ .body(containsString("<ParameterName>statement_timeout</ParameterName>"))
+ .body(containsString("<ParameterValue>5000</ParameterValue>"));
+
+ // 4. DeleteClusterParameterGroup
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "DeleteClusterParameterGroup")
+ .formParam("ParameterGroupName", "pg-test-1")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .contentType("application/xml")
+ .body(containsString("<DeleteClusterParameterGroupResponse>"));
+ }
+
+ @Test
+ @Order(2)
+ void testClusterAndSnapshotLifecycle() {
+ when(containerManager.start(any(), eq("cluster-src"), any(), any()))
+ .thenReturn(new RedshiftContainerHandle("c1", "cluster-src", "localhost", 5439));
+ org.mockito.Mockito.doAnswer(invocation -> {
+ java.nio.file.Path p = invocation.getArgument(3);
+ java.nio.file.Files.writeString(p, "-- dump sql table test_data;");
+ return null;
+ }).when(containerManager).takeSnapshot(any(), eq("cluster-src"), eq("admin"), any(java.nio.file.Path.class));
+ when(containerManager.start(any(), eq("cluster-restored"), any(), any()))
+ .thenReturn(new RedshiftContainerHandle("c2", "cluster-restored", "localhost", 5440));
+
+ // 1. CreateCluster
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "CreateCluster")
+ .formParam("ClusterIdentifier", "cluster-src")
+ .formParam("NodeType", "dc2.large")
+ .formParam("MasterUsername", "admin")
+ .formParam("MasterUserPassword", "password123")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .contentType("application/xml")
+ .body(containsString("<ClusterIdentifier>cluster-src</ClusterIdentifier>"))
+ .body(containsString("<ClusterStatus>available</ClusterStatus>"));
+
+ // 1b. RebootCluster — must preserve data (no Docker volume backs this container)
+ when(containerManager.getContainer(any(), eq("cluster-src")))
+ .thenReturn(java.util.Optional.of(new RedshiftContainerHandle("c1", "cluster-src", "localhost", 5439)));
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "RebootCluster")
+ .formParam("ClusterIdentifier", "cluster-src")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .contentType("application/xml")
+ .body(containsString("<ClusterIdentifier>cluster-src</ClusterIdentifier>"))
+ .body(containsString("<ClusterStatus>available</ClusterStatus>"));
+
+ // 1c. ModifyCluster
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "ModifyCluster")
+ .formParam("ClusterIdentifier", "cluster-src")
+ .formParam("NodeType", "ra3.xlplus")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<NodeType>ra3.xlplus</NodeType>"));
+
+ // 2. CreateClusterSnapshot
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "CreateClusterSnapshot")
+ .formParam("SnapshotIdentifier", "snap-test-1")
+ .formParam("ClusterIdentifier", "cluster-src")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .contentType("application/xml")
+ .body(containsString("<SnapshotIdentifier>snap-test-1</SnapshotIdentifier>"))
+ .body(containsString("<ClusterIdentifier>cluster-src</ClusterIdentifier>"));
+
+ // 3. DescribeClusterSnapshots
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "DescribeClusterSnapshots")
+ .formParam("SnapshotIdentifier", "snap-test-1")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .contentType("application/xml")
+ .body(containsString("<SnapshotIdentifier>snap-test-1</SnapshotIdentifier>"));
+
+ // 4. DeleteCluster
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "DeleteCluster")
+ .formParam("ClusterIdentifier", "cluster-src")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .contentType("application/xml")
+ .body(containsString("<ClusterIdentifier>cluster-src</ClusterIdentifier>"))
+ .body(containsString("<ClusterStatus>deleting</ClusterStatus>"));
+
+ // 5. RestoreFromClusterSnapshot
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "RestoreFromClusterSnapshot")
+ .formParam("ClusterIdentifier", "cluster-restored")
+ .formParam("SnapshotIdentifier", "snap-test-1")
+ .formParam("NodeType", "dc2.large")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .contentType("application/xml")
+ .body(containsString("<ClusterIdentifier>cluster-restored</ClusterIdentifier>"))
+ .body(containsString("<ClusterStatus>available</ClusterStatus>"))
+ .body(containsString("<Port>5440</Port>"));
+
+ // 6. DeleteClusterSnapshot
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "DeleteClusterSnapshot")
+ .formParam("SnapshotIdentifier", "snap-test-1")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .contentType("application/xml")
+ .body(containsString("<SnapshotIdentifier>snap-test-1</SnapshotIdentifier>"))
+ .body(containsString("<Status>deleted</Status>"));
+
+ // 7. Delete restored cluster
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "DeleteCluster")
+ .formParam("ClusterIdentifier", "cluster-restored")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .contentType("application/xml")
+ .body(containsString("<ClusterIdentifier>cluster-restored</ClusterIdentifier>"));
+ }
+
+ @Test
+ @Order(4)
+ void testClusterSubnetGroupLifecycle() {
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "CreateClusterSubnetGroup")
+ .formParam("ClusterSubnetGroupName", "subnet-group-1")
+ .formParam("Description", "Test subnet group")
+ .formParam("SubnetIds.member.1", "subnet-aaa")
+ .formParam("SubnetIds.member.2", "subnet-bbb")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .contentType("application/xml")
+ .body(containsString("<ClusterSubnetGroupName>subnet-group-1</ClusterSubnetGroupName>"))
+ .body(containsString("<SubnetIdentifier>subnet-aaa</SubnetIdentifier>"));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "DescribeClusterSubnetGroups")
+ .formParam("ClusterSubnetGroupName", "subnet-group-1")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<ClusterSubnetGroupName>subnet-group-1</ClusterSubnetGroupName>"));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "ModifyClusterSubnetGroup")
+ .formParam("ClusterSubnetGroupName", "subnet-group-1")
+ .formParam("Description", "Updated")
+ .formParam("SubnetIds.member.1", "subnet-ccc")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<SubnetIdentifier>subnet-ccc</SubnetIdentifier>"));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "DeleteClusterSubnetGroup")
+ .formParam("ClusterSubnetGroupName", "subnet-group-1")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ @Test
+ @Order(3)
+ void testTagLifecycle() {
+ when(containerManager.start(any(), eq("cluster-tags"), any(), any()))
+ .thenReturn(new RedshiftContainerHandle("c3", "cluster-tags", "localhost", 5441));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "CreateCluster")
+ .formParam("ClusterIdentifier", "cluster-tags")
+ .formParam("NodeType", "dc2.large")
+ .formParam("MasterUsername", "admin")
+ .formParam("MasterUserPassword", "password123")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ String clusterArn = "arn:aws:redshift:us-east-1:000000000000:cluster:cluster-tags";
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "CreateTags")
+ .formParam("ResourceName", clusterArn)
+ .formParam("Tags.member.1.Key", "env")
+ .formParam("Tags.member.1.Value", "test")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .contentType("application/xml");
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "DescribeTags")
+ .formParam("ResourceName", clusterArn)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<Key>env</Key>"))
+ .body(containsString("<Value>test</Value>"));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "DeleteTags")
+ .formParam("ResourceName", clusterArn)
+ .formParam("TagKeys.member.1", "env")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH_HEADER)
+ .formParam("Action", "DeleteCluster")
+ .formParam("ClusterIdentifier", "cluster-tags")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandlerTest.java
new file mode 100644
index 0000000000..b062eeeacf
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandlerTest.java
@@ -0,0 +1,329 @@
+package io.github.hectorvent.floci.services.redshift;
+
+import io.github.hectorvent.floci.services.redshift.model.Cluster;
+import io.github.hectorvent.floci.services.redshift.model.ClusterParameterGroup;
+import io.github.hectorvent.floci.services.redshift.model.ClusterSubnetGroup;
+import io.github.hectorvent.floci.services.redshift.model.Endpoint;
+import io.github.hectorvent.floci.services.redshift.model.Parameter;
+import io.github.hectorvent.floci.services.redshift.model.Snapshot;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.Response;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.*;
+
+class RedshiftQueryHandlerTest {
+
+ private RedshiftQueryHandler handler;
+ private RedshiftService service;
+
+ @BeforeEach
+ void setUp() {
+ service = mock(RedshiftService.class);
+ handler = new RedshiftQueryHandler(service);
+ }
+
+ @Test
+ void testCreateClusterAction() {
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("ClusterIdentifier", "test-cluster");
+ params.putSingle("NodeType", "dc2.large");
+ params.putSingle("MasterUsername", "admin");
+ params.putSingle("MasterUserPassword", "password123");
+
+ Cluster cluster = new Cluster();
+ cluster.setClusterIdentifier("test-cluster");
+ cluster.setClusterStatus("available");
+ when(service.createCluster(any(), any(), any(), any(), any(), any())).thenReturn(cluster);
+
+ Response response = handler.handle("CreateCluster", params);
+
+ assertEquals(200, response.getStatus());
+ assertNotNull(response.getEntity());
+ String xml = (String) response.getEntity();
+ assertTrue(xml.contains("<ClusterIdentifier>test-cluster</ClusterIdentifier>"));
+ assertTrue(xml.contains("<ClusterStatus>available</ClusterStatus>"));
+ assertTrue(xml.contains("<RequestId>test-req-id</RequestId>"));
+ }
+
+ @Test
+ void testDescribeClusters() {
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("ClusterIdentifier", "test-cluster");
+
+ Cluster cluster = new Cluster();
+ cluster.setClusterIdentifier("test-cluster");
+ cluster.setClusterStatus("available");
+ when(service.describeClusters(any())).thenReturn(List.of(cluster));
+
+ Response response = handler.handle("DescribeClusters", params);
+ assertEquals(200, response.getStatus());
+ String xml = (String) response.getEntity();
+ assertTrue(xml.contains("<ClusterIdentifier>test-cluster</ClusterIdentifier>"));
+ }
+
+ @Test
+ void testDeleteCluster() {
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("ClusterIdentifier", "test-cluster");
+
+ Cluster cluster = new Cluster();
+ cluster.setClusterIdentifier("test-cluster");
+ cluster.setClusterStatus("deleting");
+ when(service.deleteCluster(any())).thenReturn(cluster);
+
+ Response response = handler.handle("DeleteCluster", params);
+ assertEquals(200, response.getStatus());
+ String xml = (String) response.getEntity();
+ assertTrue(xml.contains("<ClusterIdentifier>test-cluster</ClusterIdentifier>"));
+ assertTrue(xml.contains("<ClusterStatus>deleting</ClusterStatus>"));
+ }
+
+ @Test
+ void testCreateClusterSnapshot() {
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("SnapshotIdentifier", "test-snapshot");
+ params.putSingle("ClusterIdentifier", "test-cluster");
+
+ Snapshot snapshot = new Snapshot("test-snapshot", "test-cluster", "available", 5439, "admin");
+ when(service.createSnapshot("test-snapshot", "test-cluster")).thenReturn(snapshot);
+
+ Response response = handler.handle("CreateClusterSnapshot", params);
+ assertEquals(200, response.getStatus());
+ String xml = (String) response.getEntity();
+ assertTrue(xml.contains("<SnapshotIdentifier>test-snapshot</SnapshotIdentifier>"));
+ assertTrue(xml.contains("<ClusterIdentifier>test-cluster</ClusterIdentifier>"));
+ assertTrue(xml.contains("<Status>available</Status>"));
+ assertTrue(xml.contains("<Port>5439</Port>"));
+ assertTrue(xml.contains("<MasterUsername>admin</MasterUsername>"));
+ assertTrue(xml.contains("<RequestId>test-req-id</RequestId>"));
+ }
+
+ @Test
+ void testDescribeClusterSnapshots() {
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("SnapshotIdentifier", "test-snapshot");
+ params.putSingle("ClusterIdentifier", "test-cluster");
+
+ Snapshot snapshot = new Snapshot("test-snapshot", "test-cluster", "available", 5439, "admin");
+ when(service.describeSnapshots("test-snapshot", "test-cluster")).thenReturn(List.of(snapshot));
+
+ Response response = handler.handle("DescribeClusterSnapshots", params);
+ assertEquals(200, response.getStatus());
+ String xml = (String) response.getEntity();
+ assertTrue(xml.contains("<Snapshots>"));
+ assertTrue(xml.contains("<SnapshotIdentifier>test-snapshot</SnapshotIdentifier>"));
+ assertTrue(xml.contains("</Snapshots>"));
+ }
+
+ @Test
+ void testDeleteClusterSnapshot() {
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("SnapshotIdentifier", "test-snapshot");
+
+ Snapshot snapshot = new Snapshot("test-snapshot", "test-cluster", "deleted", 5439, "admin");
+ when(service.deleteSnapshot("test-snapshot")).thenReturn(snapshot);
+
+ Response response = handler.handle("DeleteClusterSnapshot", params);
+ assertEquals(200, response.getStatus());
+ String xml = (String) response.getEntity();
+ assertTrue(xml.contains("<SnapshotIdentifier>test-snapshot</SnapshotIdentifier>"));
+ assertTrue(xml.contains("<Status>deleted</Status>"));
+ }
+
+ @Test
+ void testRestoreFromClusterSnapshot() {
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("ClusterIdentifier", "restored-cluster");
+ params.putSingle("SnapshotIdentifier", "test-snapshot");
+ params.putSingle("NodeType", "dc2.large");
+
+ Cluster cluster = new Cluster();
+ cluster.setClusterIdentifier("restored-cluster");
+ cluster.setNodeType("dc2.large");
+ cluster.setMasterUsername("admin");
+ cluster.setClusterStatus("available");
+ cluster.setEndpoint(new Endpoint("localhost", 5439));
+ when(service.restoreFromClusterSnapshot("restored-cluster", "test-snapshot", "dc2.large")).thenReturn(cluster);
+
+ Response response = handler.handle("RestoreFromClusterSnapshot", params);
+ assertEquals(200, response.getStatus());
+ String xml = (String) response.getEntity();
+ assertTrue(xml.contains("<ClusterIdentifier>restored-cluster</ClusterIdentifier>"));
+ assertTrue(xml.contains("<ClusterStatus>available</ClusterStatus>"));
+ assertTrue(xml.contains("<Address>localhost</Address>"));
+ assertTrue(xml.contains("<Port>5439</Port>"));
+ }
+
+ @Test
+ void testCreateClusterParameterGroup() {
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("ParameterGroupName", "test-pg");
+ params.putSingle("ParameterGroupFamily", "redshift-1.0");
+ params.putSingle("Description", "custom redshift param group");
+
+ ClusterParameterGroup group = new ClusterParameterGroup("test-pg", "redshift-1.0", "custom redshift param group");
+ when(service.createClusterParameterGroup("test-pg", "redshift-1.0", "custom redshift param group")).thenReturn(group);
+
+ Response response = handler.handle("CreateClusterParameterGroup", params);
+ assertEquals(200, response.getStatus());
+ String xml = (String) response.getEntity();
+ assertTrue(xml.contains("<ParameterGroupName>test-pg</ParameterGroupName>"));
+ assertTrue(xml.contains("<ParameterGroupFamily>redshift-1.0</ParameterGroupFamily>"));
+ assertTrue(xml.contains("<Description>custom redshift param group</Description>"));
+ }
+
+ @Test
+ void testDescribeClusterParameterGroups() {
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("ParameterGroupName", "test-pg");
+
+ ClusterParameterGroup group = new ClusterParameterGroup("test-pg", "redshift-1.0", "custom redshift param group");
+ when(service.describeClusterParameterGroups("test-pg")).thenReturn(List.of(group));
+
+ Response response = handler.handle("DescribeClusterParameterGroups", params);
+ assertEquals(200, response.getStatus());
+ String xml = (String) response.getEntity();
+ assertTrue(xml.contains("<ParameterGroups>"));
+ assertTrue(xml.contains("<ParameterGroupName>test-pg</ParameterGroupName>"));
+ assertTrue(xml.contains("</ParameterGroups>"));
+ }
+
+ @Test
+ void testDescribeClusterParameters() {
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("ParameterGroupName", "test-pg");
+
+ ClusterParameterGroup group = new ClusterParameterGroup("test-pg", "redshift-1.0", "custom redshift param group");
+ when(service.describeClusterParameterGroups("test-pg")).thenReturn(List.of(group));
+
+ Response response = handler.handle("DescribeClusterParameters", params);
+ assertEquals(200, response.getStatus());
+ String xml = (String) response.getEntity();
+ assertTrue(xml.contains("<Parameters>"));
+ assertTrue(xml.contains("</Parameters>"));
+ }
+
+ @Test
+ void testDeleteClusterParameterGroup() {
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("ParameterGroupName", "test-pg");
+
+ ClusterParameterGroup group = new ClusterParameterGroup("test-pg", "redshift-1.0", "custom redshift param group");
+ when(service.deleteClusterParameterGroup("test-pg")).thenReturn(group);
+
+ Response response = handler.handle("DeleteClusterParameterGroup", params);
+ assertEquals(200, response.getStatus());
+ String xml = (String) response.getEntity();
+ assertTrue(xml.contains("<DeleteClusterParameterGroupResponse>"));
+ }
+
+ @Test
+ void testCreateTagsAcceptsNamedMemberForm() {
+ // Real Redshift SDK sends "Tags.Tag.N.Key/.Value", không phải "Tags.member.N...".
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("ResourceName", "arn:aws:redshift:us-east-1:000000000000:cluster:test-cluster");
+ params.putSingle("Tags.Tag.1.Key", "env");
+ params.putSingle("Tags.Tag.1.Value", "prod");
+
+ Response response = handler.handle("CreateTags", params);
+ assertEquals(200, response.getStatus());
+
+ @SuppressWarnings("unchecked")
+ ArgumentCaptor<Map<String, String>> captor = ArgumentCaptor.forClass(Map.class);
+ verify(service).createTags(eq("arn:aws:redshift:us-east-1:000000000000:cluster:test-cluster"), captor.capture());
+ assertEquals(Map.of("env", "prod"), captor.getValue());
+ }
+
+ @Test
+ void testCreateClusterSubnetGroupAcceptsNamedMemberForm() {
+ // Real Redshift SDK sends "SubnetIds.SubnetIdentifier.N", không phải "SubnetIds.member.N".
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("ClusterSubnetGroupName", "test-sng");
+ params.putSingle("Description", "desc");
+ params.putSingle("SubnetIds.SubnetIdentifier.1", "subnet-aaa");
+ params.putSingle("SubnetIds.SubnetIdentifier.2", "subnet-bbb");
+
+ ClusterSubnetGroup group = new ClusterSubnetGroup("test-sng", "desc", null, List.of("subnet-aaa", "subnet-bbb"));
+ when(service.createClusterSubnetGroup(any(), any(), any(), any())).thenReturn(group);
+
+ Response response = handler.handle("CreateClusterSubnetGroup", params);
+ assertEquals(200, response.getStatus());
+
+ @SuppressWarnings("unchecked")
+ ArgumentCaptor<List<String>> captor = ArgumentCaptor.forClass(List.class);
+ verify(service).createClusterSubnetGroup(eq("test-sng"), eq("desc"), any(), captor.capture());
+ assertEquals(List.of("subnet-aaa", "subnet-bbb"), captor.getValue());
+ }
+
+ @Test
+ void testModifyClusterParameterGroupAcceptsNamedMemberForm() {
+ // Real Redshift SDK sends "Parameters.Parameter.N.ParameterName/.ParameterValue".
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("ParameterGroupName", "test-pg");
+ params.putSingle("Parameters.Parameter.1.ParameterName", "statement_timeout");
+ params.putSingle("Parameters.Parameter.1.ParameterValue", "5000");
+
+ Response response = handler.handle("ModifyClusterParameterGroup", params);
+ assertEquals(200, response.getStatus());
+
+ @SuppressWarnings("unchecked")
+ ArgumentCaptor<List<Parameter>> captor = ArgumentCaptor.forClass(List.class);
+ verify(service).modifyClusterParameterGroup(eq("test-pg"), captor.capture());
+ assertEquals(1, captor.getValue().size());
+ assertEquals("statement_timeout", captor.getValue().get(0).getParameterName());
+ assertEquals("5000", captor.getValue().get(0).getParameterValue());
+ }
+
+ @Test
+ void testCreateClusterSubnetGroupRequiresName() {
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("Description", "desc");
+
+ io.github.hectorvent.floci.core.common.AwsException ex = org.junit.jupiter.api.Assertions.assertThrows(
+ io.github.hectorvent.floci.core.common.AwsException.class,
+ () -> handler.handle("CreateClusterSubnetGroup", params));
+ assertEquals("InvalidParameterValue", ex.getErrorCode());
+ }
+
+ @Test
+ void testModifyClusterRequiresClusterIdentifier() {
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("NodeType", "dc2.large");
+
+ io.github.hectorvent.floci.core.common.AwsException ex = org.junit.jupiter.api.Assertions.assertThrows(
+ io.github.hectorvent.floci.core.common.AwsException.class,
+ () -> handler.handle("ModifyCluster", params));
+ assertEquals("InvalidParameterValue", ex.getErrorCode());
+ }
+
+ @Test
+ void testBuildClusterXmlIncludesParameterGroupAndTags() {
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("ClusterIdentifier", "test-cluster");
+
+ Cluster cluster = new Cluster();
+ cluster.setClusterIdentifier("test-cluster");
+ cluster.setClusterStatus("available");
+ cluster.setClusterParameterGroupName("test-pg");
+ cluster.setTags(Map.of("env", "prod"));
+ when(service.describeClusters(any())).thenReturn(List.of(cluster));
+
+ Response response = handler.handle("DescribeClusters", params);
+ String xml = (String) response.getEntity();
+ assertTrue(xml.contains("<ClusterParameterGroups>"));
+ assertTrue(xml.contains("<ParameterGroupName>test-pg</ParameterGroupName>"));
+ assertTrue(xml.contains("<ParameterApplyStatus>in-sync</ParameterApplyStatus>"));
+ assertTrue(xml.contains("<Tags>"));
+ assertTrue(xml.contains("<Key>env</Key>"));
+ assertTrue(xml.contains("<Value>prod</Value>"));
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftServiceTest.java
new file mode 100644
index 0000000000..23f4bca6d3
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftServiceTest.java
@@ -0,0 +1,748 @@
+package io.github.hectorvent.floci.services.redshift;
+
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;
+import io.github.hectorvent.floci.core.storage.StorageFactory;
+import io.github.hectorvent.floci.services.redshift.container.RedshiftContainerHandle;
+import io.github.hectorvent.floci.services.redshift.container.RedshiftContainerManager;
+import io.github.hectorvent.floci.services.redshift.model.Cluster;
+import io.github.hectorvent.floci.services.redshift.model.ClusterParameterGroup;
+import io.github.hectorvent.floci.services.redshift.model.ClusterSubnetGroup;
+import io.github.hectorvent.floci.services.redshift.model.Endpoint;
+import io.github.hectorvent.floci.services.redshift.model.Parameter;
+import io.github.hectorvent.floci.services.redshift.model.Snapshot;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.*;
+
+class RedshiftServiceTest {
+
+ private StorageFactory sf;
+ private AccountAwareStorageBackend<Cluster> clusterBackend;
+ private AccountAwareStorageBackend<Snapshot> snapshotBackend;
+ private AccountAwareStorageBackend<String> snapshotDumpBackend;
+ private AccountAwareStorageBackend<ClusterParameterGroup> parameterGroupBackend;
+ private AccountAwareStorageBackend<ClusterSubnetGroup> subnetGroupBackend;
+ private RedshiftContainerManager cm;
+ private io.github.hectorvent.floci.core.common.RegionResolver regionResolver;
+ private RedshiftService service;
+
+ @BeforeEach
+ @SuppressWarnings("unchecked")
+ void setUp() {
+ sf = mock(StorageFactory.class);
+ clusterBackend = mock(AccountAwareStorageBackend.class);
+ snapshotBackend = mock(AccountAwareStorageBackend.class);
+ snapshotDumpBackend = mock(AccountAwareStorageBackend.class);
+ parameterGroupBackend = mock(AccountAwareStorageBackend.class);
+ subnetGroupBackend = mock(AccountAwareStorageBackend.class);
+ cm = mock(RedshiftContainerManager.class);
+
+ io.github.hectorvent.floci.config.EmulatorConfig config = mock(io.github.hectorvent.floci.config.EmulatorConfig.class);
+ io.github.hectorvent.floci.config.EmulatorConfig.StorageConfig storageConfig = mock(io.github.hectorvent.floci.config.EmulatorConfig.StorageConfig.class);
+ when(config.storage()).thenReturn(storageConfig);
+ when(storageConfig.persistentPath()).thenReturn("target/test-data");
+
+ when(sf.<Cluster>create(eq("redshift"), eq("redshift-clusters.json"), any())).thenReturn(clusterBackend);
+ when(sf.<Snapshot>create(eq("redshift"), eq("redshift-snapshots.json"), any())).thenReturn(snapshotBackend);
+ when(sf.<ClusterParameterGroup>create(eq("redshift"), eq("redshift-parameter-groups.json"), any())).thenReturn(parameterGroupBackend);
+ when(sf.<ClusterSubnetGroup>create(eq("redshift"), eq("redshift-subnet-groups.json"), any())).thenReturn(subnetGroupBackend);
+ when(clusterBackend.accountId()).thenReturn("111111111111");
+
+ regionResolver = new io.github.hectorvent.floci.core.common.RegionResolver("us-east-1", "111111111111");
+
+ service = new RedshiftService(sf, cm, config, regionResolver);
+ }
+
+ /** Absolute dump path as {@code createSnapshot} now stores it: under {@code <persistentPath>/redshift-dumps/<accountId>}. */
+ private static String dumpPath(String snapshotId) {
+ return java.nio.file.Paths.get("target/test-data", "redshift-dumps", "111111111111", snapshotId + ".sql")
+ .toAbsolutePath().normalize().toString();
+ }
+
+ @Test
+ void testOnStartRecreatesContainersAcrossAccounts() {
+ Cluster clusterA = new Cluster();
+ clusterA.setClusterIdentifier("cluster-a");
+ clusterA.setMasterUsername("admin");
+ clusterA.setMasterPassword("pw-a");
+ clusterA.setClusterStatus("available");
+
+ Cluster clusterB = new Cluster();
+ clusterB.setClusterIdentifier("cluster-b");
+ clusterB.setMasterUsername("admin");
+ clusterB.setMasterPassword("pw-b");
+ clusterB.setClusterStatus("available");
+
+ when(clusterBackend.scanAllAccountEntries(any())).thenReturn(List.of(
+ new AccountAwareStorageBackend.AccountEntry<>("111111111111", "cluster-a", clusterA),
+ new AccountAwareStorageBackend.AccountEntry<>("222222222222", "cluster-b", clusterB)));
+ when(cm.getContainer(anyString(), anyString())).thenReturn(Optional.empty());
+ when(cm.adoptOrStart(eq("111111111111"), eq("cluster-a"), eq("admin"), eq("pw-a")))
+ .thenReturn(new RedshiftContainerHandle("c-a", "cluster-a", "localhost", 5432));
+ when(cm.adoptOrStart(eq("222222222222"), eq("cluster-b"), eq("admin"), eq("pw-b")))
+ .thenReturn(new RedshiftContainerHandle("c-b", "cluster-b", "localhost", 5433));
+
+ service.onStart(null);
+
+ // Cluster owned by a second, non-default account must also be recovered
+ verify(cm).adoptOrStart("111111111111", "cluster-a", "admin", "pw-a");
+ verify(cm).adoptOrStart("222222222222", "cluster-b", "admin", "pw-b");
+ verify(clusterBackend).putForAccount(eq("111111111111"), eq("cluster-a"), any(Cluster.class));
+ verify(clusterBackend).putForAccount(eq("222222222222"), eq("cluster-b"), any(Cluster.class));
+ verify(clusterBackend).flush();
+ }
+
+ @Test
+ void testOnStartSkipsClusterWithRunningContainer() {
+ Cluster cluster = new Cluster();
+ cluster.setClusterIdentifier("cluster-a");
+ cluster.setClusterStatus("available");
+ when(clusterBackend.scanAllAccountEntries(any())).thenReturn(List.of(
+ new AccountAwareStorageBackend.AccountEntry<>("111111111111", "cluster-a", cluster)));
+ when(cm.getContainer("111111111111", "cluster-a"))
+ .thenReturn(Optional.of(new RedshiftContainerHandle("c-a", "cluster-a", "localhost", 5432)));
+
+ service.onStart(null);
+
+ verify(cm, never()).adoptOrStart(any(), any(), any(), any());
+ verify(clusterBackend, never()).putForAccount(any(), any(), any());
+ }
+
+ @Test
+ void testOnStartMarksClusterUnavailableOnStartFailure() {
+ Cluster cluster = new Cluster();
+ cluster.setClusterIdentifier("cluster-a");
+ cluster.setMasterUsername("admin");
+ cluster.setMasterPassword("pw-a");
+ cluster.setClusterStatus("available");
+ when(clusterBackend.scanAllAccountEntries(any())).thenReturn(List.of(
+ new AccountAwareStorageBackend.AccountEntry<>("111111111111", "cluster-a", cluster)));
+ when(cm.getContainer("111111111111", "cluster-a")).thenReturn(Optional.empty());
+ when(cm.adoptOrStart(eq("111111111111"), eq("cluster-a"), eq("admin"), eq("pw-a"))).thenThrow(new RuntimeException("docker down"));
+
+ service.onStart(null);
+
+ ArgumentCaptor<Cluster> captor = ArgumentCaptor.forClass(Cluster.class);
+ verify(clusterBackend).putForAccount(eq("111111111111"), eq("cluster-a"), captor.capture());
+ assertEquals("unavailable", captor.getValue().getClusterStatus());
+ }
+
+ @Test
+ void testCreateCluster() {
+ when(clusterBackend.get(anyString())).thenReturn(Optional.empty());
+ when(cm.start(any(), any(), any(), any())).thenReturn(new RedshiftContainerHandle("c1", "my-cluster", "localhost", 5432));
+
+ Cluster cluster = service.createCluster("my-cluster", "dc2.large", "admin", "password123");
+ assertNotNull(cluster);
+ assertEquals("my-cluster", cluster.getClusterIdentifier());
+ assertEquals("available", cluster.getClusterStatus());
+ assertEquals("localhost", cluster.getEndpoint().getAddress());
+ verify(clusterBackend, times(2)).put(eq("my-cluster"), any(Cluster.class));
+ }
+
+ @Test
+ void testCreateClusterWithVpcMetadata() {
+ when(clusterBackend.get(anyString())).thenReturn(Optional.empty());
+ when(cm.start(any(), any(), any(), any())).thenReturn(new RedshiftContainerHandle("c1", "my-cluster", "localhost", 5432));
+
+ Cluster cluster = service.createCluster("my-cluster", "dc2.large", "admin", "password123",
+ "my-subnet-group", List.of("sg-1", "sg-2"));
+
+ assertEquals("my-subnet-group", cluster.getClusterSubnetGroupName());
+ assertEquals(List.of("sg-1", "sg-2"), cluster.getVpcSecurityGroupIds());
+ }
+
+ @Test
+ void testCreateClusterAlreadyExists() {
+ when(clusterBackend.get("existing-cluster")).thenReturn(Optional.of(new Cluster()));
+
+ assertThrows(AwsException.class, () ->
+ service.createCluster("existing-cluster", "dc2.large", "admin", "password123"));
+ }
+
+ @Test
+ void testDescribeClusters() {
+ Cluster c = new Cluster();
+ c.setClusterIdentifier("test-c");
+ when(clusterBackend.get("test-c")).thenReturn(Optional.of(c));
+
+ List<Cluster> list = service.describeClusters("test-c");
+ assertEquals(1, list.size());
+ assertEquals("test-c", list.get(0).getClusterIdentifier());
+ }
+
+ @Test
+ void testDeleteCluster() {
+ Cluster c = new Cluster();
+ c.setClusterIdentifier("test-c");
+ when(clusterBackend.get("test-c")).thenReturn(Optional.of(c));
+
+ Cluster deleted = service.deleteCluster("test-c");
+ assertEquals("deleting", deleted.getClusterStatus());
+ verify(cm).stop("111111111111", "test-c");
+ verify(clusterBackend).delete("test-c");
+ }
+
+ @Test
+ void testRebootClusterDumpsAndRestoresData() throws Exception {
+ Cluster cluster = new Cluster();
+ cluster.setClusterIdentifier("my-cluster");
+ cluster.setMasterUsername("admin");
+ cluster.setMasterPassword("pw");
+ cluster.setClusterStatus("available");
+ when(clusterBackend.get("my-cluster")).thenReturn(Optional.of(cluster));
+ when(cm.start(eq("111111111111"), eq("my-cluster"), eq("admin"), eq("pw")))
+ .thenReturn(new RedshiftContainerHandle("c-rebooted", "my-cluster", "localhost", 5555));
+ doAnswer(invocation -> {
+ java.nio.file.Path dumpFile = invocation.getArgument(3);
+ java.nio.file.Files.writeString(dumpFile, "-- dump");
+ return null;
+ }).when(cm).takeSnapshot(eq("111111111111"), eq("my-cluster"), eq("admin"), any(java.nio.file.Path.class));
+
+ Cluster rebooted = service.rebootCluster("my-cluster");
+
+ assertEquals("available", rebooted.getClusterStatus());
+ assertEquals(5555, rebooted.getEndpoint().getPort());
+ verify(cm).stop("111111111111", "my-cluster");
+ verify(cm).start("111111111111", "my-cluster", "admin", "pw");
+ verify(cm).restoreSnapshot(eq("111111111111"), eq("my-cluster"), eq("admin"), any(java.nio.file.Path.class));
+ }
+
+ @Test
+ void testRebootClusterNotFound() {
+ when(clusterBackend.get("missing")).thenReturn(Optional.empty());
+
+ assertThrows(AwsException.class, () -> service.rebootCluster("missing"));
+ }
+
+ @Test
+ void testCreateSnapshot() {
+ Cluster cluster = new Cluster();
+ cluster.setClusterIdentifier("my-cluster");
+ cluster.setMasterUsername("admin");
+ cluster.setMasterPassword("secret-pw");
+ cluster.setEndpoint(new Endpoint("localhost", 5439));
+
+ when(clusterBackend.get("my-cluster")).thenReturn(Optional.of(cluster));
+ when(snapshotBackend.get("my-snapshot")).thenReturn(Optional.empty());
+ doNothing().when(cm).takeSnapshot(eq("111111111111"), eq("my-cluster"), eq("admin"), any(java.nio.file.Path.class));
+
+ Snapshot snapshot = service.createSnapshot("my-snapshot", "my-cluster");
+ assertNotNull(snapshot);
+ assertEquals("my-snapshot", snapshot.getSnapshotIdentifier());
+ assertEquals("my-cluster", snapshot.getClusterIdentifier());
+ assertEquals("available", snapshot.getStatus());
+ assertEquals("admin", snapshot.getMasterUsername());
+ // Password captured at snapshot time so restore can recover it after the source cluster is gone
+ assertEquals("secret-pw", snapshot.getMasterPassword());
+ assertEquals(5439, snapshot.getPort());
+ // sqlDump is now an absolute path scoped by account to avoid collisions across accounts
+ assertTrue(snapshot.getSqlDump().contains("111111111111"));
+ assertTrue(snapshot.getSqlDump().endsWith("my-snapshot.sql"));
+ verify(snapshotBackend).put(eq("my-snapshot"), any(Snapshot.class));
+ verify(snapshotBackend).flush();
+ verify(cm).takeSnapshot(eq("111111111111"), eq("my-cluster"), eq("admin"), any(java.nio.file.Path.class));
+ }
+
+ @Test
+ void testCreateSnapshotClusterNotFound() {
+ when(clusterBackend.get("missing-cluster")).thenReturn(Optional.empty());
+
+ assertThrows(AwsException.class, () ->
+ service.createSnapshot("snap-1", "missing-cluster"));
+ }
+
+ @Test
+ void testCreateSnapshotAlreadyExists() {
+ Cluster cluster = new Cluster();
+ cluster.setClusterIdentifier("my-cluster");
+ when(clusterBackend.get("my-cluster")).thenReturn(Optional.of(cluster));
+ when(snapshotBackend.get("snap-1")).thenReturn(Optional.of(new Snapshot()));
+
+ assertThrows(AwsException.class, () ->
+ service.createSnapshot("snap-1", "my-cluster"));
+ }
+
+ @Test
+ void testCreateSnapshotRejectsTraversalOrMalformedIdentifier() {
+ Cluster cluster = new Cluster();
+ cluster.setClusterIdentifier("my-cluster");
+ cluster.setMasterUsername("admin");
+ when(clusterBackend.get("my-cluster")).thenReturn(Optional.of(cluster));
+ when(snapshotBackend.get(anyString())).thenReturn(Optional.empty());
+
+ String[] bad = {
+ "../evil", "../../etc/cron.d/x", "/etc/passwd", "a/b", "a\\b",
+ "foo/../bar", "-leading", "trailing-", "double--hyphen", "1startsdigit", "", "has space",
+ };
+ for (String id : bad) {
+ AwsException ex = assertThrows(AwsException.class,
+ () -> service.createSnapshot(id, "my-cluster"), "expected rejection for: " + id);
+ assertEquals("InvalidParameterValue", ex.getErrorCode(), id);
+ assertEquals(400, ex.getHttpStatus(), id);
+ }
+ verify(cm, never()).takeSnapshot(any(), any(), any(), any(java.nio.file.Path.class));
+ verify(snapshotBackend, never()).put(anyString(), any(Snapshot.class));
+ }
+
+ @Test
+ void testModifyClusterUpdatesMetadataAndPassword() {
+ Cluster cluster = new Cluster();
+ cluster.setClusterIdentifier("my-cluster");
+ cluster.setNodeType("dc2.large");
+ cluster.setMasterUsername("admin");
+ cluster.setMasterPassword("old-pw");
+ when(clusterBackend.get("my-cluster")).thenReturn(Optional.of(cluster));
+
+ Cluster updated = service.modifyCluster("my-cluster", "ra3.xlplus", null, "new-pw", null, null);
+
+ assertEquals("ra3.xlplus", updated.getNodeType());
+ assertEquals("new-pw", updated.getMasterPassword());
+ verify(cm).alterUserPassword("111111111111", "my-cluster", "admin", "new-pw");
+ verify(clusterBackend).put(eq("my-cluster"), any(Cluster.class));
+ verify(clusterBackend).flush();
+ }
+
+ @Test
+ void testModifyClusterUpdatesVpcSecurityGroups() {
+ Cluster cluster = new Cluster();
+ cluster.setClusterIdentifier("my-cluster");
+ cluster.setMasterUsername("admin");
+ when(clusterBackend.get("my-cluster")).thenReturn(Optional.of(cluster));
+
+ Cluster updated = service.modifyCluster("my-cluster", null, null, null, "custom-pg", List.of("sg-9"));
+
+ assertEquals("custom-pg", updated.getClusterParameterGroupName());
+ assertEquals(List.of("sg-9"), updated.getVpcSecurityGroupIds());
+ verify(cm, never()).alterUserPassword(any(), any(), any(), any());
+ }
+
+ @Test
+ void testModifyClusterNotFound() {
+ when(clusterBackend.get("missing")).thenReturn(Optional.empty());
+
+ assertThrows(AwsException.class, () ->
+ service.modifyCluster("missing", "ra3.xlplus", null, null, null, null));
+ }
+
+ @Test
+ void testDescribeSnapshots() {
+ Snapshot s = new Snapshot("snap-1", "my-cluster", "available", 5439, "admin");
+ when(snapshotBackend.get("snap-1")).thenReturn(Optional.of(s));
+
+ List<Snapshot> list = service.describeSnapshots("snap-1");
+ assertEquals(1, list.size());
+ assertEquals("snap-1", list.get(0).getSnapshotIdentifier());
+ }
+
+ @Test
+ void testDescribeSnapshotsNotFound() {
+ when(snapshotBackend.get("missing-snap")).thenReturn(Optional.empty());
+
+ assertThrows(AwsException.class, () -> service.describeSnapshots("missing-snap"));
+ }
+
+ @Test
+ void testDeleteSnapshot() {
+ Snapshot s = new Snapshot("snap-1", "my-cluster", "available", 5439, "admin");
+ s.setSqlDump(dumpPath("snap-1"));
+ when(snapshotBackend.get("snap-1")).thenReturn(Optional.of(s));
+
+ Snapshot deleted = service.deleteSnapshot("snap-1");
+ assertNotNull(deleted);
+ assertEquals("deleted", deleted.getStatus());
+ verify(snapshotBackend).delete("snap-1");
+ verify(snapshotBackend).flush();
+ }
+
+ @Test
+ void testDeleteSnapshotNotFound() {
+ when(snapshotBackend.get("missing-snap")).thenReturn(Optional.empty());
+
+ assertThrows(AwsException.class, () -> service.deleteSnapshot("missing-snap"));
+ }
+
+ @Test
+ void testRestoreFromClusterSnapshot() {
+ Cluster sourceCluster = new Cluster();
+ sourceCluster.setClusterIdentifier("source-cluster");
+ sourceCluster.setMasterPassword("password123");
+
+ Snapshot snapshot = new Snapshot("my-snapshot", "source-cluster", "available", 5439, "admin");
+ snapshot.setSqlDump(dumpPath("my-snapshot"));
+ when(clusterBackend.get("restored-cluster")).thenReturn(Optional.empty());
+ when(clusterBackend.get("source-cluster")).thenReturn(Optional.of(sourceCluster));
+ when(snapshotBackend.get("my-snapshot")).thenReturn(Optional.of(snapshot));
+ when(cm.start(eq("111111111111"), eq("restored-cluster"), eq("admin"), eq("password123")))
+ .thenReturn(new RedshiftContainerHandle("c-new", "restored-cluster", "localhost", 5432));
+ doNothing().when(cm).restoreSnapshot(eq("111111111111"), eq("restored-cluster"), eq("admin"), any(java.nio.file.Path.class));
+
+ Cluster cluster = service.restoreFromClusterSnapshot("restored-cluster", "my-snapshot", "dc2.large");
+ assertNotNull(cluster);
+ assertEquals("restored-cluster", cluster.getClusterIdentifier());
+ assertEquals("available", cluster.getClusterStatus());
+ assertEquals("admin", cluster.getMasterUsername());
+ assertEquals("password123", cluster.getMasterPassword());
+ assertEquals("dc2.large", cluster.getNodeType());
+ assertEquals("localhost", cluster.getEndpoint().getAddress());
+
+ // Restore must use the source cluster's actual password, not a hardcoded one
+ verify(cm).start("111111111111", "restored-cluster", "admin", "password123");
+ verify(cm).restoreSnapshot(eq("111111111111"), eq("restored-cluster"), eq("admin"), any(java.nio.file.Path.class));
+ verify(clusterBackend, times(2)).put(eq("restored-cluster"), any(Cluster.class));
+ verify(clusterBackend, times(2)).flush();
+ }
+
+ @Test
+ void testRestoreFromClusterSnapshotUsesStoredPasswordAfterSourceClusterDeleted() {
+ Snapshot snapshot = new Snapshot("my-snapshot", "deleted-source", "available", 5439, "admin");
+ snapshot.setMasterPassword("original-secret");
+ snapshot.setSqlDump(dumpPath("my-snapshot"));
+ when(clusterBackend.get("restored-cluster")).thenReturn(Optional.empty());
+ // Source cluster no longer exists, but the snapshot itself still carries the original password
+ when(clusterBackend.get("deleted-source")).thenReturn(Optional.empty());
+ when(snapshotBackend.get("my-snapshot")).thenReturn(Optional.of(snapshot));
+ when(cm.start(eq("111111111111"), eq("restored-cluster"), eq("admin"), eq("original-secret")))
+ .thenReturn(new RedshiftContainerHandle("c-new", "restored-cluster", "localhost", 5432));
+ doNothing().when(cm).restoreSnapshot(eq("111111111111"), eq("restored-cluster"), eq("admin"), any(java.nio.file.Path.class));
+
+ Cluster cluster = service.restoreFromClusterSnapshot("restored-cluster", "my-snapshot", "dc2.large");
+ assertEquals("original-secret", cluster.getMasterPassword());
+ verify(cm).start("111111111111", "restored-cluster", "admin", "original-secret");
+ }
+
+ @Test
+ void testRestoreFromClusterSnapshotFallsBackToAdminWhenSourceClusterGone() {
+ Snapshot snapshot = new Snapshot("my-snapshot", "deleted-source", "available", 5439, "admin");
+ snapshot.setSqlDump(dumpPath("my-snapshot"));
+ when(clusterBackend.get("restored-cluster")).thenReturn(Optional.empty());
+ when(clusterBackend.get("deleted-source")).thenReturn(Optional.empty());
+ when(snapshotBackend.get("my-snapshot")).thenReturn(Optional.of(snapshot));
+ when(cm.start(eq("111111111111"), eq("restored-cluster"), eq("admin"), eq("admin")))
+ .thenReturn(new RedshiftContainerHandle("c-new", "restored-cluster", "localhost", 5432));
+ doNothing().when(cm).restoreSnapshot(eq("111111111111"), eq("restored-cluster"), eq("admin"), any(java.nio.file.Path.class));
+
+ Cluster cluster = service.restoreFromClusterSnapshot("restored-cluster", "my-snapshot", "dc2.large");
+ assertEquals("admin", cluster.getMasterPassword());
+ verify(cm).start("111111111111", "restored-cluster", "admin", "admin");
+ }
+
+ @Test
+ void testRestoreFromClusterSnapshotAlreadyExists() {
+ when(clusterBackend.get("existing-cluster")).thenReturn(Optional.of(new Cluster()));
+
+ assertThrows(AwsException.class, () ->
+ service.restoreFromClusterSnapshot("existing-cluster", "my-snapshot"));
+ }
+
+ @Test
+ void testRestoreFromClusterSnapshotNotFound() {
+ when(clusterBackend.get("new-cluster")).thenReturn(Optional.empty());
+ when(snapshotBackend.get("missing-snapshot")).thenReturn(Optional.empty());
+
+ assertThrows(AwsException.class, () ->
+ service.restoreFromClusterSnapshot("new-cluster", "missing-snapshot"));
+ }
+
+ @Test
+ void testRestoreFromClusterSnapshotFailure() {
+ Snapshot snapshot = new Snapshot("my-snapshot", "source-cluster", "available", 5439, "admin", dumpPath("my-snapshot"));
+ when(clusterBackend.get("failed-cluster")).thenReturn(Optional.empty());
+ when(snapshotBackend.get("my-snapshot")).thenReturn(Optional.of(snapshot));
+ when(cm.start(any(), any(), any(), any())).thenThrow(new RuntimeException("Docker error"));
+
+ assertThrows(AwsException.class, () ->
+ service.restoreFromClusterSnapshot("failed-cluster", "my-snapshot"));
+ }
+
+ @Test
+ void testRestoreFromClusterSnapshotRejectsUntrustedDumpPathBeforeProvisioning() {
+ // A dump path persisted outside the account dir (e.g. by pre-validation code) must be
+ // rejected up front — no cluster record, no container.
+ Snapshot snapshot = new Snapshot("my-snapshot", "source-cluster", "available", 5439, "admin", "/etc/shadow");
+ when(clusterBackend.get("restored-cluster")).thenReturn(Optional.empty());
+ when(snapshotBackend.get("my-snapshot")).thenReturn(Optional.of(snapshot));
+
+ AwsException ex = assertThrows(AwsException.class, () ->
+ service.restoreFromClusterSnapshot("restored-cluster", "my-snapshot", "dc2.large"));
+ assertEquals("InvalidParameterValue", ex.getErrorCode());
+ assertEquals(400, ex.getHttpStatus());
+ verify(cm, never()).start(any(), any(), any(), any());
+ verify(cm, never()).restoreSnapshot(any(), any(), any(), any());
+ verify(clusterBackend, never()).put(anyString(), any(Cluster.class));
+ }
+
+ @Test
+ void testCreateClusterParameterGroup() {
+ when(parameterGroupBackend.get("my-pg")).thenReturn(Optional.empty());
+
+ ClusterParameterGroup pg = service.createClusterParameterGroup("my-pg", "redshift-1.0", "custom pg");
+ assertNotNull(pg);
+ assertEquals("my-pg", pg.getParameterGroupName());
+ assertEquals("redshift-1.0", pg.getParameterGroupFamily());
+ assertEquals("custom pg", pg.getDescription());
+ verify(parameterGroupBackend).put(eq("my-pg"), any(ClusterParameterGroup.class));
+ verify(parameterGroupBackend).flush();
+ }
+
+ @Test
+ void testCreateClusterParameterGroupAlreadyExists() {
+ when(parameterGroupBackend.get("my-pg")).thenReturn(Optional.of(new ClusterParameterGroup()));
+
+ assertThrows(AwsException.class, () ->
+ service.createClusterParameterGroup("my-pg", "redshift-1.0", "custom pg"));
+ }
+
+ @Test
+ void testDescribeClusterParameterGroups() {
+ ClusterParameterGroup pg = new ClusterParameterGroup("my-pg", "redshift-1.0", "custom pg");
+ when(parameterGroupBackend.get("my-pg")).thenReturn(Optional.of(pg));
+
+ List<ClusterParameterGroup> list = service.describeClusterParameterGroups("my-pg");
+ assertEquals(1, list.size());
+ assertEquals("my-pg", list.get(0).getParameterGroupName());
+ }
+
+ @Test
+ void testDescribeClusterParameterGroupsNotFound() {
+ when(parameterGroupBackend.get("missing-pg")).thenReturn(Optional.empty());
+
+ assertThrows(AwsException.class, () ->
+ service.describeClusterParameterGroups("missing-pg"));
+ }
+
+ @Test
+ void testDeleteClusterParameterGroup() {
+ ClusterParameterGroup pg = new ClusterParameterGroup("my-pg", "redshift-1.0", "custom pg");
+ when(parameterGroupBackend.get("my-pg")).thenReturn(Optional.of(pg));
+
+ ClusterParameterGroup deleted = service.deleteClusterParameterGroup("my-pg");
+ assertNotNull(deleted);
+ assertEquals("my-pg", deleted.getParameterGroupName());
+ verify(parameterGroupBackend).delete("my-pg");
+ verify(parameterGroupBackend).flush();
+ }
+
+ @Test
+ void testDeleteClusterParameterGroupNotFound() {
+ when(parameterGroupBackend.get("missing-pg")).thenReturn(Optional.empty());
+
+ assertThrows(AwsException.class, () ->
+ service.deleteClusterParameterGroup("missing-pg"));
+ }
+
+ @Test
+ void testModifyClusterParameterGroup() {
+ ClusterParameterGroup group = new ClusterParameterGroup("my-pg", "redshift-1.0", "custom pg");
+ when(parameterGroupBackend.get("my-pg")).thenReturn(Optional.of(group));
+
+ ClusterParameterGroup updated = service.modifyClusterParameterGroup("my-pg",
+ List.of(new Parameter("max_cursor_result_set_size", "1000")));
+
+ assertEquals("1000", updated.getParameters().stream()
+ .filter(p -> "max_cursor_result_set_size".equals(p.getParameterName()))
+ .findFirst().orElseThrow().getParameterValue());
+ verify(parameterGroupBackend).put(eq("my-pg"), any(ClusterParameterGroup.class));
+ verify(parameterGroupBackend).flush();
+ }
+
+ @Test
+ void testModifyClusterParameterGroupAppendsUnknownParameter() {
+ ClusterParameterGroup group = new ClusterParameterGroup("my-pg", "redshift-1.0", "custom pg");
+ when(parameterGroupBackend.get("my-pg")).thenReturn(Optional.of(group));
+
+ ClusterParameterGroup updated = service.modifyClusterParameterGroup("my-pg",
+ List.of(new Parameter("statement_timeout", "5000")));
+
+ assertTrue(updated.getParameters().stream()
+ .anyMatch(p -> "statement_timeout".equals(p.getParameterName()) && "5000".equals(p.getParameterValue())));
+ }
+
+ @Test
+ void testModifyClusterParameterGroupNotFound() {
+ when(parameterGroupBackend.get("missing")).thenReturn(Optional.empty());
+
+ assertThrows(AwsException.class, () ->
+ service.modifyClusterParameterGroup("missing", List.of(new Parameter("x", "y"))));
+ }
+
+ @Test
+ void testDescribeClusterParametersReturnsStoredValues() {
+ ClusterParameterGroup group = new ClusterParameterGroup("my-pg", "redshift-1.0", "custom pg");
+ group.setParameters(new java.util.ArrayList<>(List.of(new Parameter("statement_timeout", "5000"))));
+ when(parameterGroupBackend.get("my-pg")).thenReturn(Optional.of(group));
+
+ List<Parameter> params = service.describeClusterParameters("my-pg");
+
+ assertEquals(1, params.size());
+ assertEquals("statement_timeout", params.get(0).getParameterName());
+ assertEquals("5000", params.get(0).getParameterValue());
+ }
+
+ @Test
+ void testModifyClusterParameterGroupPreservesMetadata() {
+ ClusterParameterGroup group = new ClusterParameterGroup("my-pg", "redshift-1.0", "custom pg");
+ when(parameterGroupBackend.get("my-pg")).thenReturn(Optional.of(group));
+
+ // Modify using 2-arg constructor (only name and value) - should preserve description and dataType
+ ClusterParameterGroup updated = service.modifyClusterParameterGroup("my-pg",
+ List.of(new Parameter("max_cursor_result_set_size", "1000")));
+
+ Parameter modified = updated.getParameters().stream()
+ .filter(p -> "max_cursor_result_set_size".equals(p.getParameterName()))
+ .findFirst().orElseThrow();
+ assertEquals("1000", modified.getParameterValue());
+ assertEquals("Maximum cursor result set size", modified.getDescription());
+ assertEquals("integer", modified.getDataType());
+ }
+
+ @Test
+ void testCreateAndListTagsForCluster() {
+ Cluster cluster = new Cluster();
+ cluster.setClusterIdentifier("my-cluster");
+ when(clusterBackend.get("my-cluster")).thenReturn(Optional.of(cluster));
+
+ service.createTags("arn:aws:redshift:us-east-1:111111111111:cluster:my-cluster",
+ java.util.Map.of("env", "test"));
+
+ assertEquals("test", cluster.getTags().get("env"));
+ verify(clusterBackend).put(eq("my-cluster"), any(Cluster.class));
+ }
+
+ @Test
+ void testDeleteTagsForCluster() {
+ Cluster cluster = new Cluster();
+ cluster.setClusterIdentifier("my-cluster");
+ cluster.setTags(new java.util.LinkedHashMap<>(java.util.Map.of("env", "test", "team", "data")));
+ when(clusterBackend.get("my-cluster")).thenReturn(Optional.of(cluster));
+
+ service.deleteTags("arn:aws:redshift:us-east-1:111111111111:cluster:my-cluster", java.util.List.of("env"));
+
+ assertEquals(java.util.Map.of("team", "data"), cluster.getTags());
+ }
+
+ @Test
+ void testCreateTagsRejectsNonArnResourceName() {
+ assertThrows(AwsException.class, () ->
+ service.createTags("my-cluster", java.util.Map.of("env", "test")));
+ }
+
+ @Test
+ void testCreateTagsRejectsUnknownResourceType() {
+ assertThrows(AwsException.class, () ->
+ service.createTags("arn:aws:redshift:us-east-1:111111111111:reservednode:foo", java.util.Map.of("env", "test")));
+ }
+
+ @Test
+ void testDescribeTagsForSpecificResource() {
+ Cluster cluster = new Cluster();
+ cluster.setClusterIdentifier("my-cluster");
+ cluster.setTags(new java.util.LinkedHashMap<>(java.util.Map.of("env", "test")));
+ when(clusterBackend.get("my-cluster")).thenReturn(Optional.of(cluster));
+
+ List<RedshiftService.TaggedResource> tagged =
+ service.describeTags("arn:aws:redshift:us-east-1:111111111111:cluster:my-cluster", null, null);
+
+ assertEquals(1, tagged.size());
+ assertEquals("cluster", tagged.get(0).resourceType());
+ assertEquals("env", tagged.get(0).tagKey());
+ assertEquals("test", tagged.get(0).tagValue());
+ }
+
+ @Test
+ void testDescribeTagsScansAllResourcesOfType() {
+ Cluster a = new Cluster();
+ a.setClusterIdentifier("cluster-a");
+ a.setTags(new java.util.LinkedHashMap<>(java.util.Map.of("env", "prod")));
+ Cluster b = new Cluster();
+ b.setClusterIdentifier("cluster-b");
+ b.setTags(new java.util.LinkedHashMap<>());
+ when(clusterBackend.scan(any())).thenReturn(java.util.List.of(a, b));
+ when(snapshotBackend.scan(any())).thenReturn(java.util.List.of());
+ when(parameterGroupBackend.scan(any())).thenReturn(java.util.List.of());
+ when(subnetGroupBackend.scan(any())).thenReturn(java.util.List.of());
+
+ List<RedshiftService.TaggedResource> tagged = service.describeTags(null, "cluster", null);
+
+ assertEquals(1, tagged.size());
+ assertEquals("cluster-a", extractResourceId(tagged.get(0).resourceName()));
+ }
+
+ @Test
+ void testCreateClusterSubnetGroup() {
+ when(subnetGroupBackend.get("my-subnet-group")).thenReturn(Optional.empty());
+
+ ClusterSubnetGroup group = service.createClusterSubnetGroup(
+ "my-subnet-group", "test group", "vpc-123", List.of("subnet-1", "subnet-2"));
+
+ assertEquals("my-subnet-group", group.getClusterSubnetGroupName());
+ assertEquals(List.of("subnet-1", "subnet-2"), group.getSubnetIds());
+ verify(subnetGroupBackend).put(eq("my-subnet-group"), any(ClusterSubnetGroup.class));
+ verify(subnetGroupBackend).flush();
+ }
+
+ @Test
+ void testCreateClusterSubnetGroupAlreadyExists() {
+ when(subnetGroupBackend.get("existing")).thenReturn(Optional.of(new ClusterSubnetGroup()));
+
+ assertThrows(AwsException.class, () ->
+ service.createClusterSubnetGroup("existing", "d", "vpc-1", List.of("subnet-1")));
+ }
+
+ @Test
+ void testDescribeClusterSubnetGroups() {
+ ClusterSubnetGroup group = new ClusterSubnetGroup("my-group", "d", "vpc-1", List.of("subnet-1"));
+ when(subnetGroupBackend.get("my-group")).thenReturn(Optional.of(group));
+
+ List<ClusterSubnetGroup> list = service.describeClusterSubnetGroups("my-group");
+
+ assertEquals(1, list.size());
+ assertEquals("my-group", list.get(0).getClusterSubnetGroupName());
+ }
+
+ @Test
+ void testModifyClusterSubnetGroup() {
+ ClusterSubnetGroup group = new ClusterSubnetGroup("my-group", "old", "vpc-1", List.of("subnet-1"));
+ when(subnetGroupBackend.get("my-group")).thenReturn(Optional.of(group));
+
+ ClusterSubnetGroup updated = service.modifyClusterSubnetGroup("my-group", "new", List.of("subnet-2", "subnet-3"));
+
+ assertEquals("new", updated.getDescription());
+ assertEquals(List.of("subnet-2", "subnet-3"), updated.getSubnetIds());
+ }
+
+ @Test
+ void testDeleteClusterSubnetGroup() {
+ ClusterSubnetGroup group = new ClusterSubnetGroup("my-group", "d", "vpc-1", List.of("subnet-1"));
+ when(subnetGroupBackend.get("my-group")).thenReturn(Optional.of(group));
+
+ ClusterSubnetGroup deleted = service.deleteClusterSubnetGroup("my-group");
+
+ assertEquals("my-group", deleted.getClusterSubnetGroupName());
+ verify(subnetGroupBackend).delete("my-group");
+ verify(subnetGroupBackend).flush();
+ }
+
+ @Test
+ void testDeleteClusterSubnetGroupNotFound() {
+ when(subnetGroupBackend.get("missing")).thenReturn(Optional.empty());
+
+ assertThrows(AwsException.class, () -> service.deleteClusterSubnetGroup("missing"));
+ }
+
+ private static String extractResourceId(String arn) {
+ String resource = arn.substring(arn.lastIndexOf(':') + 1);
+ return resource.contains("/") ? resource.substring(resource.lastIndexOf('/') + 1) : resource;
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/redshift/container/RedshiftContainerManagerTest.java b/src/test/java/io/github/hectorvent/floci/services/redshift/container/RedshiftContainerManagerTest.java
new file mode 100644
index 0000000000..e6da56d53f
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/redshift/container/RedshiftContainerManagerTest.java
@@ -0,0 +1,467 @@
+package io.github.hectorvent.floci.services.redshift.container;
+
+import com.github.dockerjava.api.DockerClient;
+import com.github.dockerjava.api.async.ResultCallback;
+import com.github.dockerjava.api.command.CopyArchiveToContainerCmd;
+import com.github.dockerjava.api.command.ExecCreateCmd;
+import com.github.dockerjava.api.command.ExecCreateCmdResponse;
+import com.github.dockerjava.api.command.ExecStartCmd;
+import com.github.dockerjava.api.command.InspectExecCmd;
+import com.github.dockerjava.api.command.InspectExecResponse;
+import com.github.dockerjava.api.model.Container;
+import com.github.dockerjava.api.model.Frame;
+import com.github.dockerjava.api.model.StreamType;
+import io.github.hectorvent.floci.config.EmulatorConfig;
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.common.docker.ContainerBuilder;
+import io.github.hectorvent.floci.core.common.docker.ContainerDetector;
+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager;
+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager.ContainerInfo;
+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager.EndpointInfo;
+import io.github.hectorvent.floci.core.common.docker.ContainerLogStreamer;
+import io.github.hectorvent.floci.services.redshift.model.Cluster;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.Closeable;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+class RedshiftContainerManagerTest {
+
+ private ContainerBuilder containerBuilder;
+ private ContainerLifecycleManager lifecycleManager;
+ private ContainerLogStreamer logStreamer;
+ private ContainerDetector containerDetector;
+ private EmulatorConfig config;
+ private DockerClient dockerClient;
+ private RedshiftContainerManager manager;
+
+ @BeforeEach
+ void setUp() {
+ containerBuilder = mock(ContainerBuilder.class);
+ lifecycleManager = mock(ContainerLifecycleManager.class);
+ logStreamer = mock(ContainerLogStreamer.class);
+ containerDetector = mock(ContainerDetector.class);
+ config = mock(EmulatorConfig.class, org.mockito.Mockito.RETURNS_DEEP_STUBS);
+ dockerClient = mock(DockerClient.class);
+
+ when(lifecycleManager.getDockerClient()).thenReturn(dockerClient);
+ when(config.services().redshift().imageVersion()).thenReturn("postgres:16-alpine");
+ when(config.services().redshift().dockerNetwork()).thenReturn(Optional.empty());
+
+ manager = new RedshiftContainerManager(
+ containerBuilder,
+ lifecycleManager,
+ logStreamer,
+ containerDetector,
+ config
+ );
+ }
+
+ private static final String ACCOUNT_ID = "111111111111";
+
+ @Test
+ void testTakeSnapshotContainerNotFound() {
+ AwsException ex = assertThrows(AwsException.class, () ->
+ manager.takeSnapshot(ACCOUNT_ID, "non-existent-cluster", "admin", "dev", java.nio.file.Path.of("dummy.sql")));
+ assertEquals("ClusterNotFound", ex.getErrorCode());
+ assertEquals(404, ex.getHttpStatus());
+ }
+
+ @Test
+ void testRestoreSnapshotContainerNotFound() {
+ AwsException ex = assertThrows(AwsException.class, () ->
+ manager.restoreSnapshot(ACCOUNT_ID, "non-existent-cluster", "admin", "dev", java.nio.file.Path.of("dummy.sql")));
+ assertEquals("ClusterNotFound", ex.getErrorCode());
+ assertEquals(404, ex.getHttpStatus());
+ }
+
+ @Test
+ void testCreateSnapshotNullCluster() {
+ AwsException ex = assertThrows(AwsException.class, () ->
+ manager.createSnapshot(ACCOUNT_ID, null, java.nio.file.Path.of("dummy.sql")));
+ assertEquals("InvalidParameterValue", ex.getErrorCode());
+ assertEquals(400, ex.getHttpStatus());
+ }
+
+ @Test
+ void testRestoreSnapshotNullCluster() {
+ AwsException ex = assertThrows(AwsException.class, () ->
+ manager.restoreSnapshot(ACCOUNT_ID, (Cluster) null, java.nio.file.Path.of("dummy.sql")));
+ assertEquals("InvalidParameterValue", ex.getErrorCode());
+ assertEquals(400, ex.getHttpStatus());
+ }
+
+ @Test
+ void testTakeSnapshotSuccess() throws Exception {
+ ContainerBuilder.Builder specBuilder = mock(ContainerBuilder.Builder.class, org.mockito.Mockito.RETURNS_SELF);
+ when(containerBuilder.newContainer(anyString())).thenReturn(specBuilder);
+ ContainerInfo info = new ContainerInfo("cont-123", Map.of(5432, new EndpointInfo("localhost", 5432)));
+ when(lifecycleManager.createAndStart(any())).thenReturn(info);
+
+ RedshiftContainerHandle handle = manager.start(ACCOUNT_ID, "test-cluster", "admin", "pass");
+ assertNotNull(handle);
+ assertEquals("cont-123", handle.getContainerId());
+ assertTrue(manager.getContainer(ACCOUNT_ID, "test-cluster").isPresent());
+
+ // Mock docker exec for pg_dump
+ ExecCreateCmd createCmd = mock(ExecCreateCmd.class, org.mockito.Mockito.RETURNS_SELF);
+ ExecCreateCmdResponse createResponse = mock(ExecCreateCmdResponse.class);
+ when(createResponse.getId()).thenReturn("exec-1");
+ when(createCmd.exec()).thenReturn(createResponse);
+ when(dockerClient.execCreateCmd("cont-123")).thenReturn(createCmd);
+
+ ExecStartCmd startCmd = mock(ExecStartCmd.class);
+ when(startCmd.exec(any())).thenAnswer(invocation -> {
+ @SuppressWarnings("unchecked")
+ ResultCallback.Adapter<Frame> adapter = invocation.getArgument(0);
+ adapter.onComplete();
+ return adapter;
+ });
+ when(dockerClient.execStartCmd("exec-1")).thenReturn(startCmd);
+
+ InspectExecCmd inspectCmd = mock(InspectExecCmd.class);
+ InspectExecResponse inspectResponse = mock(InspectExecResponse.class);
+ when(inspectResponse.getExitCodeLong()).thenReturn(0L);
+ when(inspectCmd.exec()).thenReturn(inspectResponse);
+ when(dockerClient.inspectExecCmd("exec-1")).thenReturn(inspectCmd);
+
+ // mock copyArchiveFromContainerCmd
+ com.github.dockerjava.api.command.CopyArchiveFromContainerCmd copyCmd = mock(com.github.dockerjava.api.command.CopyArchiveFromContainerCmd.class, org.mockito.Mockito.RETURNS_SELF);
+ byte[] tarBytes = "-- PostgreSQL dump\nCREATE TABLE foo (id int);\n".getBytes(StandardCharsets.UTF_8);
+ java.io.ByteArrayOutputStream bos = new java.io.ByteArrayOutputStream();
+ try (org.apache.commons.compress.archivers.tar.TarArchiveOutputStream tar = new org.apache.commons.compress.archivers.tar.TarArchiveOutputStream(bos)) {
+ org.apache.commons.compress.archivers.tar.TarArchiveEntry entry = new org.apache.commons.compress.archivers.tar.TarArchiveEntry("dump.sql");
+ entry.setSize(tarBytes.length);
+ tar.putArchiveEntry(entry);
+ tar.write(tarBytes);
+ tar.closeArchiveEntry();
+ }
+ when(copyCmd.exec()).thenReturn(new java.io.ByteArrayInputStream(bos.toByteArray()));
+ when(dockerClient.copyArchiveFromContainerCmd("cont-123", "/tmp/dump.sql")).thenReturn(copyCmd);
+
+ java.nio.file.Path tempFile = java.nio.file.Files.createTempFile("test-take-snapshot", ".sql");
+ try {
+ manager.takeSnapshot(ACCOUNT_ID, "test-cluster", "admin", "dev",tempFile);
+ String dump = java.nio.file.Files.readString(tempFile);
+ assertTrue(dump.contains("PostgreSQL dump"));
+ assertTrue(dump.contains("CREATE TABLE foo"));
+ } finally {
+ java.nio.file.Files.deleteIfExists(tempFile);
+ }
+ }
+
+ @Test
+ void testTakeSnapshotFailureExitCode() throws Exception {
+ ContainerBuilder.Builder specBuilder = mock(ContainerBuilder.Builder.class, org.mockito.Mockito.RETURNS_SELF);
+ when(containerBuilder.newContainer(anyString())).thenReturn(specBuilder);
+ ContainerInfo info = new ContainerInfo("cont-123", Map.of(5432, new EndpointInfo("localhost", 5432)));
+ when(lifecycleManager.createAndStart(any())).thenReturn(info);
+
+ manager.start(ACCOUNT_ID, "test-cluster", "admin", "pass");
+
+ ExecCreateCmd createCmd = mock(ExecCreateCmd.class, org.mockito.Mockito.RETURNS_SELF);
+ ExecCreateCmdResponse createResponse = mock(ExecCreateCmdResponse.class);
+ when(createResponse.getId()).thenReturn("exec-fail");
+ when(createCmd.exec()).thenReturn(createResponse);
+ when(dockerClient.execCreateCmd("cont-123")).thenReturn(createCmd);
+
+ ExecStartCmd startCmd = mock(ExecStartCmd.class);
+ when(startCmd.exec(any())).thenAnswer(invocation -> {
+ @SuppressWarnings("unchecked")
+ ResultCallback.Adapter<Frame> adapter = invocation.getArgument(0);
+ byte[] err = "pg_dump: error: connection failed".getBytes(StandardCharsets.UTF_8);
+ adapter.onNext(new Frame(StreamType.STDERR, err));
+ adapter.onComplete();
+ return adapter;
+ });
+ when(dockerClient.execStartCmd("exec-fail")).thenReturn(startCmd);
+
+ InspectExecCmd inspectCmd = mock(InspectExecCmd.class);
+ InspectExecResponse inspectResponse = mock(InspectExecResponse.class);
+ when(inspectResponse.getExitCodeLong()).thenReturn(1L);
+ when(inspectCmd.exec()).thenReturn(inspectResponse);
+ when(dockerClient.inspectExecCmd("exec-fail")).thenReturn(inspectCmd);
+
+ AwsException ex = assertThrows(AwsException.class, () ->
+ manager.takeSnapshot(ACCOUNT_ID, "test-cluster", "admin", "dev",java.nio.file.Path.of("dummy.sql")));
+ assertEquals("InternalFailure", ex.getErrorCode());
+ assertEquals(500, ex.getHttpStatus());
+ }
+
+ @Test
+ void testRestoreSnapshotEmptyDump() {
+ ContainerBuilder.Builder specBuilder = mock(ContainerBuilder.Builder.class, org.mockito.Mockito.RETURNS_SELF);
+ when(containerBuilder.newContainer(anyString())).thenReturn(specBuilder);
+ ContainerInfo info = new ContainerInfo("cont-123", Map.of(5432, new EndpointInfo("localhost", 5432)));
+ when(lifecycleManager.createAndStart(any())).thenReturn(info);
+
+ manager.start(ACCOUNT_ID, "test-cluster", "admin", "pass");
+
+ // Should return cleanly without touching dockerClient
+ manager.restoreSnapshot(ACCOUNT_ID, "test-cluster", "admin", "dev",java.nio.file.Path.of("non-existent-dump.sql"));
+ manager.restoreSnapshot(ACCOUNT_ID, "test-cluster", "admin", "dev",(java.nio.file.Path) null);
+ }
+
+ @Test
+ void testRestoreSnapshotSuccess() throws Exception {
+ ContainerBuilder.Builder specBuilder = mock(ContainerBuilder.Builder.class, org.mockito.Mockito.RETURNS_SELF);
+ when(containerBuilder.newContainer(anyString())).thenReturn(specBuilder);
+ ContainerInfo info = new ContainerInfo("cont-123", Map.of(5432, new EndpointInfo("localhost", 5432)));
+ when(lifecycleManager.createAndStart(any())).thenReturn(info);
+
+ manager.start(ACCOUNT_ID, "test-cluster", "admin", "pass");
+
+ // Mock copyArchiveToContainerCmd
+ CopyArchiveToContainerCmd copyCmd = mock(CopyArchiveToContainerCmd.class, org.mockito.Mockito.RETURNS_SELF);
+ when(dockerClient.copyArchiveToContainerCmd("cont-123")).thenReturn(copyCmd);
+
+ // Mock docker exec for psql
+ ExecCreateCmd createCmd = mock(ExecCreateCmd.class, org.mockito.Mockito.RETURNS_SELF);
+ ExecCreateCmdResponse createResponse = mock(ExecCreateCmdResponse.class);
+ when(createResponse.getId()).thenReturn("exec-restore");
+ when(createCmd.exec()).thenReturn(createResponse);
+ when(dockerClient.execCreateCmd("cont-123")).thenReturn(createCmd);
+
+ ExecStartCmd startCmd = mock(ExecStartCmd.class);
+ when(startCmd.exec(any())).thenAnswer(invocation -> {
+ @SuppressWarnings("unchecked")
+ ResultCallback.Adapter<Frame> adapter = invocation.getArgument(0);
+ adapter.onComplete();
+ return adapter;
+ });
+ when(dockerClient.execStartCmd("exec-restore")).thenReturn(startCmd);
+
+ InspectExecCmd inspectCmd = mock(InspectExecCmd.class);
+ InspectExecResponse inspectResponse = mock(InspectExecResponse.class);
+ when(inspectResponse.getExitCodeLong()).thenReturn(0L);
+ when(inspectCmd.exec()).thenReturn(inspectResponse);
+ when(dockerClient.inspectExecCmd("exec-restore")).thenReturn(inspectCmd);
+
+ java.nio.file.Path tempFile = java.nio.file.Files.createTempFile("test-restore-snapshot", ".sql");
+ try {
+ manager.restoreSnapshot(ACCOUNT_ID, "test-cluster", "admin", "dev",tempFile);
+ verify(dockerClient).copyArchiveToContainerCmd("cont-123");
+ verify(dockerClient).execCreateCmd("cont-123");
+ } finally {
+ java.nio.file.Files.deleteIfExists(tempFile);
+ }
+ }
+
+ @Test
+ void testStopRemovesContainer() {
+ ContainerBuilder.Builder specBuilder = mock(ContainerBuilder.Builder.class, org.mockito.Mockito.RETURNS_SELF);
+ when(containerBuilder.newContainer(anyString())).thenReturn(specBuilder);
+ ContainerInfo info = new ContainerInfo("cont-123", Map.of(5432, new EndpointInfo("localhost", 5432)));
+ when(lifecycleManager.createAndStart(any())).thenReturn(info);
+
+ manager.start(ACCOUNT_ID, "test-cluster", "admin", "pass");
+ assertTrue(manager.getContainer(ACCOUNT_ID, "test-cluster").isPresent());
+
+ manager.stop(ACCOUNT_ID, "test-cluster");
+ assertTrue(manager.getContainer(ACCOUNT_ID, "test-cluster").isEmpty());
+ verify(lifecycleManager).removeIfExists("floci-redshift-" + ACCOUNT_ID + "-test-cluster");
+ }
+
+ @Test
+ void testSameClusterIdentifierAcrossAccountsDoesNotCollide() {
+ ContainerBuilder.Builder specBuilder = mock(ContainerBuilder.Builder.class, org.mockito.Mockito.RETURNS_SELF);
+ when(containerBuilder.newContainer(anyString())).thenReturn(specBuilder);
+ ContainerInfo infoA = new ContainerInfo("cont-account-a", Map.of(5432, new EndpointInfo("localhost", 5432)));
+ ContainerInfo infoB = new ContainerInfo("cont-account-b", Map.of(5432, new EndpointInfo("localhost", 5433)));
+ when(lifecycleManager.createAndStart(any())).thenReturn(infoA, infoB);
+
+ String otherAccountId = "222222222222";
+ manager.start(ACCOUNT_ID, "shared-id", "admin", "pass");
+ manager.start(otherAccountId, "shared-id", "admin", "pass");
+
+ // Both accounts keep their own running container despite the shared cluster identifier
+ assertTrue(manager.getContainer(ACCOUNT_ID, "shared-id").isPresent());
+ assertTrue(manager.getContainer(otherAccountId, "shared-id").isPresent());
+ assertEquals("cont-account-a", manager.getContainer(ACCOUNT_ID, "shared-id").get().getContainerId());
+ assertEquals("cont-account-b", manager.getContainer(otherAccountId, "shared-id").get().getContainerId());
+ }
+
+ @Test
+ void testAdoptOrStartAdoptsExistingContainerInsteadOfRecreatingIt() {
+ String containerName = "floci-redshift-" + ACCOUNT_ID + "-test-cluster";
+ Container existing = mock(Container.class);
+ when(existing.getId()).thenReturn("cont-existing");
+ when(lifecycleManager.findByName(containerName)).thenReturn(Optional.of(existing));
+ ContainerInfo adopted = new ContainerInfo("cont-existing", Map.of(5432, new EndpointInfo("localhost", 6000)));
+ when(lifecycleManager.adopt(eq("cont-existing"), any())).thenReturn(adopted);
+
+ RedshiftContainerHandle handle = manager.adoptOrStart(ACCOUNT_ID, "test-cluster", "admin", "pass");
+
+ assertEquals("cont-existing", handle.getContainerId());
+ assertEquals(6000, handle.getPort());
+ assertTrue(manager.getContainer(ACCOUNT_ID, "test-cluster").isPresent());
+ // Data lives only in the container's writable layer (no volume) — recreating it
+ // would silently discard it, so a container found by name must never be recreated.
+ verify(lifecycleManager, never()).createAndStart(any());
+ }
+
+ @Test
+ void testAdoptOrStartFallsBackToStartWhenNoExistingContainer() {
+ String containerName = "floci-redshift-" + ACCOUNT_ID + "-test-cluster";
+ when(lifecycleManager.findByName(containerName)).thenReturn(Optional.empty());
+ ContainerBuilder.Builder specBuilder = mock(ContainerBuilder.Builder.class, org.mockito.Mockito.RETURNS_SELF);
+ when(containerBuilder.newContainer(anyString())).thenReturn(specBuilder);
+ ContainerInfo info = new ContainerInfo("cont-fresh", Map.of(5432, new EndpointInfo("localhost", 5432)));
+ when(lifecycleManager.createAndStart(any())).thenReturn(info);
+
+ RedshiftContainerHandle handle = manager.adoptOrStart(ACCOUNT_ID, "test-cluster", "admin", "pass");
+
+ assertEquals("cont-fresh", handle.getContainerId());
+ verify(lifecycleManager, never()).adopt(any(), any());
+ }
+
+ @Test
+ void testAlterUserPasswordSuccess() throws Exception {
+ ContainerBuilder.Builder specBuilder = mock(ContainerBuilder.Builder.class, org.mockito.Mockito.RETURNS_SELF);
+ when(containerBuilder.newContainer(anyString())).thenReturn(specBuilder);
+ ContainerInfo info = new ContainerInfo("cont-123", Map.of(5432, new EndpointInfo("localhost", 5432)));
+ when(lifecycleManager.createAndStart(any())).thenReturn(info);
+ manager.start(ACCOUNT_ID, "test-cluster", "admin", "pass");
+
+ ExecCreateCmd createCmd = mock(ExecCreateCmd.class, org.mockito.Mockito.RETURNS_SELF);
+ ExecCreateCmdResponse createResponse = mock(ExecCreateCmdResponse.class);
+ when(createResponse.getId()).thenReturn("exec-alter");
+ when(createCmd.exec()).thenReturn(createResponse);
+ when(dockerClient.execCreateCmd("cont-123")).thenReturn(createCmd);
+
+ ExecStartCmd startCmd = mock(ExecStartCmd.class);
+ when(startCmd.exec(any())).thenAnswer(invocation -> {
+ @SuppressWarnings("unchecked")
+ ResultCallback.Adapter<Frame> adapter = invocation.getArgument(0);
+ adapter.onComplete();
+ return adapter;
+ });
+ when(dockerClient.execStartCmd("exec-alter")).thenReturn(startCmd);
+
+ InspectExecCmd inspectCmd = mock(InspectExecCmd.class);
+ InspectExecResponse inspectResponse = mock(InspectExecResponse.class);
+ when(inspectResponse.getExitCodeLong()).thenReturn(0L);
+ when(inspectCmd.exec()).thenReturn(inspectResponse);
+ when(dockerClient.inspectExecCmd("exec-alter")).thenReturn(inspectCmd);
+
+ manager.alterUserPassword(ACCOUNT_ID, "test-cluster", "admin", "NewSecret1");
+
+ verify(dockerClient).execCreateCmd("cont-123");
+ }
+
+ @Test
+ void testAlterUserPasswordContainerNotFound() {
+ AwsException ex = assertThrows(AwsException.class, () ->
+ manager.alterUserPassword(ACCOUNT_ID, "non-existent-cluster", "admin", "new-secret"));
+ assertEquals("ClusterNotFound", ex.getErrorCode());
+ assertEquals(404, ex.getHttpStatus());
+ }
+
+ @Test
+ void testAlterUserPasswordInvalidUsername() throws Exception {
+ ContainerBuilder.Builder specBuilder = mock(ContainerBuilder.Builder.class, org.mockito.Mockito.RETURNS_SELF);
+ when(containerBuilder.newContainer(anyString())).thenReturn(specBuilder);
+ ContainerInfo info = new ContainerInfo("cont-123", Map.of(5432, new EndpointInfo("localhost", 5432)));
+ when(lifecycleManager.createAndStart(any())).thenReturn(info);
+ manager.start(ACCOUNT_ID, "test-cluster", "admin", "pass");
+
+ // Test SQL injection attempt with semicolon
+ AwsException ex = assertThrows(AwsException.class, () ->
+ manager.alterUserPassword(ACCOUNT_ID, "test-cluster", "postgres; DROP TABLE some_table; --", "new-secret"));
+ assertEquals("InvalidParameterValue", ex.getErrorCode());
+ assertEquals(400, ex.getHttpStatus());
+
+ // Test SQL injection attempt with space
+ ex = assertThrows(AwsException.class, () ->
+ manager.alterUserPassword(ACCOUNT_ID, "test-cluster", "admin user", "new-secret"));
+ assertEquals("InvalidParameterValue", ex.getErrorCode());
+ assertEquals(400, ex.getHttpStatus());
+ }
+
+ @Test
+ void testAlterUserPasswordInvalidPassword() throws Exception {
+ ContainerBuilder.Builder specBuilder = mock(ContainerBuilder.Builder.class, org.mockito.Mockito.RETURNS_SELF);
+ when(containerBuilder.newContainer(anyString())).thenReturn(specBuilder);
+ ContainerInfo info = new ContainerInfo("cont-123", Map.of(5432, new EndpointInfo("localhost", 5432)));
+ when(lifecycleManager.createAndStart(any())).thenReturn(info);
+ manager.start(ACCOUNT_ID, "test-cluster", "admin", "pass");
+
+ // Forbidden characters: ', ", \, / and @ (AWS ModifyCluster rejects the same set)
+ for (String bad : new String[]{"Pass'word1", "Pass\"word1", "Pass\\word1", "Pass/word1", "Pass@word1"}) {
+ AwsException ex = assertThrows(AwsException.class, () ->
+ manager.alterUserPassword(ACCOUNT_ID, "test-cluster", "admin", bad));
+ assertEquals("InvalidParameterValue", ex.getErrorCode());
+ assertEquals(400, ex.getHttpStatus());
+ }
+
+ // Too short (< 8) and too long (> 64)
+ for (String bad : new String[]{"Ab1cde", "A1" + "a".repeat(63)}) {
+ AwsException ex = assertThrows(AwsException.class, () ->
+ manager.alterUserPassword(ACCOUNT_ID, "test-cluster", "admin", bad));
+ assertEquals("InvalidParameterValue", ex.getErrorCode());
+ assertEquals(400, ex.getHttpStatus());
+ }
+
+ // Missing a required class: no uppercase, no lowercase, no digit
+ for (String bad : new String[]{"lowercase1", "UPPERCASE1", "NoDigitsHere"}) {
+ AwsException ex = assertThrows(AwsException.class, () ->
+ manager.alterUserPassword(ACCOUNT_ID, "test-cluster", "admin", bad));
+ assertEquals("InvalidParameterValue", ex.getErrorCode());
+ assertEquals(400, ex.getHttpStatus());
+ }
+ }
+
+ @Test
+ void testAlterUserPasswordExecFailure() throws Exception {
+ ContainerBuilder.Builder specBuilder = mock(ContainerBuilder.Builder.class, org.mockito.Mockito.RETURNS_SELF);
+ when(containerBuilder.newContainer(anyString())).thenReturn(specBuilder);
+ ContainerInfo info = new ContainerInfo("cont-123", Map.of(5432, new EndpointInfo("localhost", 5432)));
+ when(lifecycleManager.createAndStart(any())).thenReturn(info);
+ manager.start(ACCOUNT_ID, "test-cluster", "admin", "pass");
+
+ ExecCreateCmd createCmd = mock(ExecCreateCmd.class, org.mockito.Mockito.RETURNS_SELF);
+ ExecCreateCmdResponse createResponse = mock(ExecCreateCmdResponse.class);
+ when(createResponse.getId()).thenReturn("exec-fail");
+ when(createCmd.exec()).thenReturn(createResponse);
+ when(dockerClient.execCreateCmd("cont-123")).thenReturn(createCmd);
+
+ ExecStartCmd startCmd = mock(ExecStartCmd.class);
+ when(startCmd.exec(any())).thenAnswer(invocation -> {
+ @SuppressWarnings("unchecked")
+ ResultCallback.Adapter<Frame> adapter = invocation.getArgument(0);
+ byte[] err = "ERROR: role \"admin\" does not exist".getBytes(StandardCharsets.UTF_8);
+ adapter.onNext(new Frame(StreamType.STDERR, err));
+ adapter.onComplete();
+ return adapter;
+ });
+ when(dockerClient.execStartCmd("exec-fail")).thenReturn(startCmd);
+
+ InspectExecCmd inspectCmd = mock(InspectExecCmd.class);
+ InspectExecResponse inspectResponse = mock(InspectExecResponse.class);
+ when(inspectResponse.getExitCodeLong()).thenReturn(1L);
+ when(inspectCmd.exec()).thenReturn(inspectResponse);
+ when(dockerClient.inspectExecCmd("exec-fail")).thenReturn(inspectCmd);
+
+ AwsException ex = assertThrows(AwsException.class, () ->
+ manager.alterUserPassword(ACCOUNT_ID, "test-cluster", "admin", "NewSecret1"));
+ assertEquals("InternalFailure", ex.getErrorCode());
+ assertEquals(500, ex.getHttpStatus());
+ }
+}
diff --git a/src/test/resources/application.yml b/src/test/resources/application.yml
index 1fd20634b7..254d7a8995 100644
--- a/src/test/resources/application.yml
+++ b/src/test/resources/application.yml
@@ -162,6 +162,10 @@ floci:
proxy-base-port: 6400
proxy-max-port: 6419
default-image: "valkey/valkey:8"
+ redshift:
+ enabled: true
+ default-port: 5439
+ image-version: postgres:15-alpine
rds:
enabled: true
mock: false
diff --git a/tools/docs/services.yaml b/tools/docs/services.yaml
index 51207f1d83..ea8835d9d5 100644
--- a/tools/docs/services.yaml
+++ b/tools/docs/services.yaml
@@ -129,6 +129,13 @@ services:
sources:
- { path: src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.java, mode: switch }
exclude_actions: [SubnetIds, VpcSecurityGroupIds, OptionsToRemove]
+ - service: redshift
+ doc: docs/services/redshift.md
+ sources:
+ - { path: src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandler.java, mode: switch }
+ # SubnetIds / VpcSecurityGroupIds / TagKeys are labels of an inner member-name
+ # switch (memberKeyRegex), not actions — same shape as the rds exclusions above.
+ exclude_actions: [SubnetIds, VpcSecurityGroupIds, TagKeys]
- service: route53resolver
doc: docs/services/route53resolver.md
sources: