Light, fluffy, and always free - The AWS Local Emulator alternative
feat/redshift auth proxy (#2751)
Vũ Thế Huy426fbcb284d5
diff --git a/.github/workflows/compatibility.yml b/.github/workflows/compatibility.ymlindex 494f633d77..bec4fe27cb 100644--- a/.github/workflows/compatibility.yml+++ b/.github/workflows/compatibility.yml@@ -201,6 +201,7 @@ jobs:-e FLOCI_SERVICES_LAMBDA_HOT_RELOAD_ENABLED=true \-e FLOCI_TLS_ENABLED=true \-e FLOCI_SERVICES_EC2_MOCK=true \+ -e FLOCI_SERVICES_REDSHIFT_ENDPOINT_HOST=floci \floci:test-native- name: Wait for floci to be readydiff --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.javaindex e8380e3554..0d8f044e0b 100644--- 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@@ -16,6 +16,7 @@ import software.amazon.awssdk.services.redshift.model.DeleteClusterResponse;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 {@@ -44,8 +45,13 @@ public class RedshiftTest {Cluster cluster = describeRes.clusters().get(0);assertEquals("test-cluster", cluster.clusterIdentifier());assertNotNull(cluster.endpoint());- // No JDBC connection here: the endpoint carries the backing container's own host/port- // (Redshift has no RDS-style auth proxy yet), which isn't reachable from the harness.+ String address = cluster.endpoint().address();+ int port = cluster.endpoint().port();+ String jdbcUrl = "jdbc:postgresql://" + address + ":" + port + "/dev";+ try (java.sql.Connection conn =+ java.sql.DriverManager.getConnection(jdbcUrl, "admin", "Password123")) {+ assertTrue(conn.isValid(5));+ }}@Testdiff --git a/docs/services/redshift.md b/docs/services/redshift.mdindex 0d632298b0..5e1a295b6e 100644--- a/docs/services/redshift.md+++ b/docs/services/redshift.md@@ -2,9 +2,9 @@**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)+**Data Endpoint:** Floci's auth proxy on 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`, …).+Floci emulates Amazon Redshift by managing a real [PostgreSQL](https://www.postgresql.org/) Docker container per cluster behind a Redshift-shaped control plane. Each cluster sits behind a lightweight auth proxy on the Floci host, so the endpoint is reachable from outside Docker and the master password is validated at the proxy — a `ModifyCluster` password change takes effect for new connections immediately. 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.@@ -45,6 +45,9 @@ The container has **no persistent volume**: if the physical container survives a| `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`) |+| `FLOCI_SERVICES_REDSHIFT_PROXY_BASE_PORT` | `7100` | Lowest host port the per-cluster auth proxies bind |+| `FLOCI_SERVICES_REDSHIFT_PROXY_MAX_PORT` | `7199` | Highest host port the per-cluster auth proxies bind |+| `FLOCI_SERVICES_REDSHIFT_ENDPOINT_HOST` | _(unset)_ | Hostname advertised in `DescribeClusters`; unset resolves from the Docker host |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`.@@ -139,3 +142,5 @@ print(cluster["Cluster"]["Endpoint"])- 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.+- The auth proxy validates only the master user's password. Non-master users pass straight through to PostgreSQL, which remains the authority for their credentials.+- IAM database authentication (`GetClusterCredentials`), and `sslmode=verify-full` against the self-signed proxy certificate.diff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex 1772952a7b..3a56d9cb1e 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -1131,6 +1131,17 @@ public interface EmulatorConfig {@WithDefault("postgres:15-alpine")String imageVersion();Optional<String> dockerNetwork();++ // Port range the per-cluster auth proxies bind on the Floci host. Disjoint from+ // every other service's range (RDS uses 7001-7099).+ @WithDefault("7100")+ int proxyBasePort();+ @WithDefault("7199")+ int proxyMaxPort();++ // Hostname clients use to reach a cluster endpoint. Empty -> resolved from+ // DockerHostResolver (falls back to "localhost").+ Optional<String> endpointHost();}interface RdsServiceConfig {diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/proxy/RdsAuthProxy.java b/src/main/java/io/github/hectorvent/floci/services/rds/proxy/RdsAuthProxy.javaindex 9f5a542982..a72a261419 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/proxy/RdsAuthProxy.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/proxy/RdsAuthProxy.java@@ -93,9 +93,10 @@ public class RdsAuthProxy {}private void handleConnection(Socket client) {+ Socket backend = null;try {client.setTcpNoDelay(true);- Socket backend = new Socket(backendHost, backendPort);+ backend = new Socket(backendHost, backendPort);backend.setTcpNoDelay(true);switch (engine) {@@ -108,7 +109,14 @@ public class RdsAuthProxy {}} catch (Exception e) {LOG.debugv("RDS connection error for instance {0}: {1}", instanceId, e.getMessage());+ } finally {+ // A handler's success path bridges then closes both sockets; every other path+ // (early return on a bare probe, auth failure, thrown IOException) can leave the+ // backend DB connection open. Closing here is idempotent.closeQuietly(client);+ if (backend != null) {+ closeQuietly(backend);+ }}}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.javaindex 40cc75c875..997d381b65 100644--- a/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftService.java+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftService.java@@ -4,7 +4,10 @@ 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.common.docker.DockerHostResolver;import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;+import io.github.hectorvent.floci.services.rds.proxy.RdsAuthProxy;+import io.github.hectorvent.floci.services.redshift.proxy.RedshiftProxyManager;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;@@ -31,6 +34,8 @@ import java.util.LinkedHashMap;import java.util.List;import java.util.Map;import java.util.Optional;+import java.util.Set;+import java.util.concurrent.ConcurrentHashMap;import java.util.function.Consumer;@ApplicationScoped@@ -44,10 +49,15 @@ public class RedshiftService {private final RedshiftContainerManager containerManager;private final EmulatorConfig config;private final RegionResolver regionResolver;+ private final RedshiftProxyManager proxyManager;+ private final DockerHostResolver dockerHostResolver;+ // Proxy ports currently handed out, so allocateProxyPort never double-assigns within this JVM.+ private final Set<Integer> usedPorts = ConcurrentHashMap.newKeySet();@Injectpublic RedshiftService(StorageFactory storageFactory, RedshiftContainerManager containerManager,- EmulatorConfig config, RegionResolver regionResolver) {+ EmulatorConfig config, RegionResolver regionResolver,+ RedshiftProxyManager proxyManager, DockerHostResolver dockerHostResolver) {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>>() {});@@ -55,6 +65,8 @@ public class RedshiftService {this.containerManager = containerManager;this.config = config;this.regionResolver = regionResolver;+ this.proxyManager = proxyManager;+ this.dockerHostResolver = dockerHostResolver;}// Recreate Docker containers for persisted clusters on app restart (across every account, not just default)@@ -73,14 +85,36 @@ public class RedshiftService {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());++ // A cluster persisted before the auth proxy existed has proxyPort == 0. Allocate one+ // now; its endpoint changes exactly once after this upgrade. Existing clusters keep+ // their stored port so the endpoint is stable across restarts.+ int proxyPort = cluster.getProxyPort() > 0 ? cluster.getProxyPort() : allocateProxyPort();+ usedPorts.add(proxyPort);+ Endpoint endpoint = proxyEndpoint(proxyPort);+ cluster.setProxyPort(proxyPort);+ proxyManager.startProxy(+ relayKey(entry.accountId(), cluster.getClusterIdentifier()), proxyPort,+ handle.getHost(), handle.getPort(), endpoint.getAddress(),+ cluster.getMasterUsername(), password, CLUSTER_DB_NAME,+ passwordValidatorFor(entry.accountId(), cluster.getClusterIdentifier()));+ cluster.setContainerHost(handle.getHost());+ cluster.setContainerPort(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());+ try {+ proxyManager.stopProxy(relayKey(entry.accountId(), cluster.getClusterIdentifier()));+ } catch (Exception ex) {+ LOG.warnv(ex, "Failed to stop proxy during recovery rollback for cluster {0}", cluster.getClusterIdentifier());+ }+ try {+ containerManager.stop(entry.accountId(), cluster.getClusterIdentifier());+ } catch (Exception ex) {+ LOG.warnv(ex, "Failed to stop container during recovery rollback for cluster {0}", cluster.getClusterIdentifier());+ }cluster.setClusterStatus("unavailable");clusters.putForAccount(entry.accountId(), entry.key(), cluster);}@@ -92,7 +126,9 @@ public class RedshiftService {return createCluster(identifier, nodeType, username, password, null, List.of());}- public Cluster createCluster(String identifier, String nodeType, String username, String password,+ // synchronized like modify/reboot: the container + proxy + port steps must not+ // interleave with another admin call on the same cluster.+ public synchronized 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);@@ -109,16 +145,44 @@ public class RedshiftService {clusters.put(identifier, cluster);clusters.flush();- // Start container+ // Start container, then front it with an auth proxy so the advertised endpoint is+ // reachable from outside the Docker network.+ // Hoisted out of the try so a failure after allocateProxyPort() still returns the port.+ int proxyPort = -1;try {- RedshiftContainerHandle handle = containerManager.start(clusters.accountId(), identifier, username, password);- Endpoint endpoint = new Endpoint();- endpoint.setAddress(handle.getHost());- endpoint.setPort(handle.getPort());+ String accountId = clusters.accountId();+ RedshiftContainerHandle handle = containerManager.start(accountId, identifier, username, password);+ proxyPort = allocateProxyPort();+ Endpoint endpoint = proxyEndpoint(proxyPort);+ cluster.setProxyPort(proxyPort);+ proxyManager.startProxy(relayKey(accountId, identifier), proxyPort,+ handle.getHost(), handle.getPort(), endpoint.getAddress(),+ username, password, CLUSTER_DB_NAME,+ passwordValidatorFor(accountId, identifier));+ cluster.setContainerHost(handle.getHost());+ cluster.setContainerPort(handle.getPort());cluster.setEndpoint(endpoint);cluster.setClusterStatus("available");+ } catch (AwsException e) {+ boolean proxyStopped = stopProxyAndReleasePortSafely(identifier, proxyPort);+ try { containerManager.stop(clusters.accountId(), identifier); } catch (Exception ex) { LOG.warnv(ex, "Failed to stop container during rollback of cluster {0}", identifier); }+ if (proxyStopped) {+ clusters.delete(identifier);+ } else {+ cluster.setClusterStatus("failed");+ clusters.put(identifier, cluster);+ }+ clusters.flush();+ throw e;} catch (Exception e) {- cluster.setClusterStatus("failed");+ boolean proxyStopped = stopProxyAndReleasePortSafely(identifier, proxyPort);+ try { containerManager.stop(clusters.accountId(), identifier); } catch (Exception ex) { LOG.warnv(ex, "Failed to stop container during rollback of cluster {0}", identifier); }+ if (proxyStopped) {+ clusters.delete(identifier);+ } else {+ cluster.setClusterStatus("failed");+ clusters.put(identifier, cluster);+ }clusters.flush();throw new AwsException("InternalFailure", "Failed to start container: " + e.getMessage(), 500);}@@ -139,13 +203,20 @@ public class RedshiftService {return clusters.scan(k -> true);}- public Cluster deleteCluster(String identifier) {+ public synchronized 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();-++ // Tear down the auth proxy and return its port before stopping the container.+ // If it fails, abort deletion so the metadata remains and the user can retry.+ if (!stopProxyAndReleasePortSafely(identifier, cluster.getProxyPort())) {+ throw new AwsException("InternalFailure",+ "Failed to stop auth proxy; cluster " + identifier + " was not deleted", 500);+ }+containerManager.stop(clusters.accountId(), identifier);clusters.delete(identifier);clusters.flush();@@ -166,6 +237,9 @@ public class RedshiftService {containerManager.alterUserPassword(clusters.accountId(), clusterIdentifier,cluster.getMasterUsername(), masterUserPassword);cluster.setMasterPassword(masterUserPassword);+ // Keep the proxy's password check in sync so new connections use the new secret.+ proxyManager.updateMasterPassword(+ relayKey(clusters.accountId(), clusterIdentifier), masterUserPassword);}// NodeType only updates metadata — it does not resize the underlying Postgres container@@ -201,34 +275,74 @@ public class RedshiftService {throw new AwsException("InternalFailure", "Failed to prepare reboot dump file: " + e.getMessage(), 500);}+ // Hoisted so a failure after the proxy is (re)started still tears it down and+ // returns the port, matching createCluster/restoreFromClusterSnapshot rollback.+ int proxyPort = cluster.getProxyPort() > 0 ? cluster.getProxyPort() : -1;+ boolean originalTornDown = false; // original proxy + container already stopped+ boolean rebooted = false;try {- containerManager.takeSnapshot(clusters.accountId(), clusterIdentifier, cluster.getMasterUsername(), tempDump);- containerManager.stop(clusters.accountId(), clusterIdentifier);+ String accountId = clusters.accountId();+ String key = relayKey(accountId, clusterIdentifier);++ containerManager.takeSnapshot(accountId, clusterIdentifier, cluster.getMasterUsername(), tempDump);+ proxyManager.stopProxy(key);+ containerManager.stop(accountId, clusterIdentifier);+ originalTornDown = true;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);+ accountId, clusterIdentifier, cluster.getMasterUsername(), password);- containerManager.restoreSnapshot(clusters.accountId(), clusterIdentifier, cluster.getMasterUsername(), tempDump);+ // Reuse the stored proxy port so the advertised endpoint is unchanged by a reboot.+ if (proxyPort < 0) {+ proxyPort = allocateProxyPort();+ }+ usedPorts.add(proxyPort);+ Endpoint endpoint = proxyEndpoint(proxyPort);+ cluster.setProxyPort(proxyPort);+ proxyManager.startProxy(key, proxyPort, handle.getHost(), handle.getPort(),+ endpoint.getAddress(), cluster.getMasterUsername(), password, CLUSTER_DB_NAME,+ passwordValidatorFor(accountId, clusterIdentifier));+ cluster.setContainerHost(handle.getHost());+ cluster.setContainerPort(handle.getPort());+ cluster.setEndpoint(endpoint);+ containerManager.restoreSnapshot(accountId, clusterIdentifier, cluster.getMasterUsername(), tempDump);cluster.setClusterStatus("available");+ rebooted = true;} catch (AwsException e) {- cluster.setClusterStatus("failed");+ rollbackReboot(clusterIdentifier, originalTornDown);+ if (originalTornDown) {+ cluster.setClusterStatus("failed");+ }clusters.flush();throw e;} catch (Exception e) {- cluster.setClusterStatus("failed");+ rollbackReboot(clusterIdentifier, originalTornDown);+ if (originalTornDown) {+ 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+ if (rebooted) {+ try {+ Files.deleteIfExists(tempDump);+ } catch (IOException ex) {+ LOG.warnv(ex, "Failed to clean up temporary dump file {0} after rebooting cluster {1}", tempDump, clusterIdentifier);+ }+ } else {+ if (originalTornDown) {+ // Once the original container is torn down it holds no volume, so this dump can+ // be the only surviving copy of the cluster's data — keep it for manual recovery.+ LOG.warnv("Reboot of cluster {0} did not complete; retained pre-reboot data dump at {1}",+ clusterIdentifier, tempDump);+ } else {+ try {+ Files.deleteIfExists(tempDump);+ } catch (IOException ignored) {+ }+ }}}@@ -366,7 +480,7 @@ public class RedshiftService {return restoreFromClusterSnapshot(clusterIdentifier, snapshotIdentifier, null);}- public Cluster restoreFromClusterSnapshot(String clusterIdentifier, String snapshotIdentifier, String nodeType) {+ public synchronized Cluster restoreFromClusterSnapshot(String clusterIdentifier, String snapshotIdentifier, String nodeType) {if (clusters.get(clusterIdentifier).isPresent()) {throw new AwsException("ClusterAlreadyExists", "Cluster " + clusterIdentifier + " already exists", 400);}@@ -407,11 +521,20 @@ public class RedshiftService {clusters.put(clusterIdentifier, cluster);clusters.flush();+ // Hoisted out of the try so a failure after allocateProxyPort() still returns the port.+ int proxyPort = -1;try {- RedshiftContainerHandle handle = containerManager.start(clusters.accountId(), clusterIdentifier, username, password);- Endpoint endpoint = new Endpoint();- endpoint.setAddress(handle.getHost());- endpoint.setPort(handle.getPort());+ String accountId = clusters.accountId();+ RedshiftContainerHandle handle = containerManager.start(accountId, clusterIdentifier, username, password);+ proxyPort = allocateProxyPort();+ Endpoint endpoint = proxyEndpoint(proxyPort);+ cluster.setProxyPort(proxyPort);+ proxyManager.startProxy(relayKey(accountId, clusterIdentifier), proxyPort,+ handle.getHost(), handle.getPort(), endpoint.getAddress(),+ username, password, CLUSTER_DB_NAME,+ passwordValidatorFor(accountId, clusterIdentifier));+ cluster.setContainerHost(handle.getHost());+ cluster.setContainerPort(handle.getPort());cluster.setEndpoint(endpoint);if (hasDump) {@@ -420,11 +543,25 @@ public class RedshiftService {cluster.setClusterStatus("available");} catch (AwsException e) {- cluster.setClusterStatus("failed");+ boolean proxyStopped = stopProxyAndReleasePortSafely(clusterIdentifier, proxyPort);+ try { containerManager.stop(clusters.accountId(), clusterIdentifier); } catch (Exception ex) { LOG.warnv(ex, "Failed to stop container during rollback of cluster {0}", clusterIdentifier); }+ if (proxyStopped) {+ clusters.delete(clusterIdentifier);+ } else {+ cluster.setClusterStatus("failed");+ clusters.put(clusterIdentifier, cluster);+ }clusters.flush();throw e;} catch (Exception e) {- cluster.setClusterStatus("failed");+ boolean proxyStopped = stopProxyAndReleasePortSafely(clusterIdentifier, proxyPort);+ try { containerManager.stop(clusters.accountId(), clusterIdentifier); } catch (Exception ex) { LOG.warnv(ex, "Failed to stop container during rollback of cluster {0}", clusterIdentifier); }+ if (proxyStopped) {+ clusters.delete(clusterIdentifier);+ } else {+ cluster.setClusterStatus("failed");+ clusters.put(clusterIdentifier, cluster);+ }clusters.flush();throw new AwsException("InternalFailure", "Failed to restore cluster from snapshot: " + e.getMessage(), 500);}@@ -725,4 +862,85 @@ public class RedshiftService {"Tagging for resource type '" + type + "' is not supported: " + resourceName, 400);};}++ // ── Proxy Helpers (shared with modify/reboot/restore) ────────────────────++ private static final String CLUSTER_DB_NAME = "dev";++ private int allocateProxyPort() {+ int base = config.services().redshift().proxyBasePort();+ int max = config.services().redshift().proxyMaxPort();+ for (int port = base; port <= max; port++) {+ if (usedPorts.add(port)) {+ return port;+ }+ }+ throw new AwsException("InsufficientClusterCapacity",+ "No available Redshift proxy ports in range " + base + "-" + max, 503);+ }++ private boolean stopProxyAndReleasePortSafely(String identifier, int proxyPort) {+ boolean proxyStopped = false;+ try {+ proxyManager.stopProxy(relayKey(clusters.accountId(), identifier));+ proxyStopped = true;+ } catch (Exception ex) {+ LOG.warnv(ex, "Failed to stop proxy for cluster {0}; leaking proxy port {1} to prevent reallocation", identifier, proxyPort);+ }+ if (proxyStopped) {+ releaseProxyPort(proxyPort);+ }+ return proxyStopped;+ }++ /**+ * Undo a failed reboot. If {@code originalTornDown} is false the reboot failed before+ * the original proxy + container were stopped, so the original data-bearing container+ * is still running and nothing must be touched. Once it is true the original is gone:+ * tear down the (replacement's) proxy and return its port, and remove any container+ * running under the cluster's name — {@code containerManager.stop} works by name, so+ * this also cleans a replacement that {@code containerManager.start} created before+ * throwing (e.g. its readiness check timed out). The pre-reboot data dump is kept by+ * the caller.+ */+ private void rollbackReboot(String identifier, boolean originalTornDown) {+ if (!originalTornDown) {+ return;+ }+ try {+ proxyManager.stopProxy(relayKey(clusters.accountId(), identifier));+ } catch (Exception ex) {+ LOG.warnv(ex, "Failed to stop proxy during reboot rollback for cluster {0}", identifier);+ }+ try {+ containerManager.stop(clusters.accountId(), identifier);+ } catch (Exception ex) {+ LOG.warnv(ex, "Failed to stop replacement container during rollback of reboot for cluster {0}", identifier);+ }+ }++ private void releaseProxyPort(int port) {+ if (port > 0) {+ usedPorts.remove(port);+ }+ }++ private Endpoint proxyEndpoint(int proxyPort) {+ String host = config.services().redshift().endpointHost()+ .filter(h -> !h.isBlank())+ .orElseGet(dockerHostResolver::resolve);+ return new Endpoint(host, proxyPort);+ }++ private String relayKey(String accountId, String clusterIdentifier) {+ return accountId + ":" + clusterIdentifier;+ }++ // Validates the master password at the proxy against current cluster state, so a+ // ModifyCluster password change is reflected for new connections without a proxy restart.+ private RdsAuthProxy.PasswordValidator passwordValidatorFor(String accountId, String clusterIdentifier) {+ return (user, password) -> clusters.getForAccount(accountId, clusterIdentifier)+ .map(c -> user.equals(c.getMasterUsername()) && password.equals(c.getMasterPassword()))+ .orElse(false);+ }}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.javaindex 002c0059e8..215d927975 100644--- 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@@ -99,11 +99,7 @@ public class RedshiftContainerManager {LOG.warnv("Failed to stream logs for {0}", containerName);}- try {- Thread.sleep(3000);- } catch (InterruptedException e) {- Thread.currentThread().interrupt();- }+ waitForReady(containerName, info.containerId(), masterUsername, "dev");containers.put(containerKey(accountId, clusterIdentifier), handle);return handle;@@ -143,6 +139,8 @@ public class RedshiftContainerManager {LOG.warnv("Failed to stream logs for {0}", containerName);}+ waitForReady(containerName, info.containerId(), masterUsername, "dev");+containers.put(containerKey(accountId, clusterIdentifier), handle);return handle;}@@ -381,6 +379,41 @@ public class RedshiftContainerManager {}return bos.toByteArray();}+ private void waitForReady(String containerName, String containerId, String username, String dbName) {+ String effectiveUser = (username != null && !username.isBlank()) ? username : "postgres";+ String[] cmd = {+ "psql",+ "-h", "127.0.0.1",+ "-v", "ON_ERROR_STOP=1",+ "-U", effectiveUser,+ "-d", dbName,+ "-c", "SELECT 1"+ };+ execUntilSuccess(containerName, containerId, cmd, "PostgreSQL readiness check");+ }++ private void execUntilSuccess(String containerName, String containerId, String[] cmd, String description) {+ String lastOutput = "";+ for (int attempt = 1; attempt <= 60; attempt++) {+ try {+ ExecResult result = execInContainer(containerId, cmd, 5);+ lastOutput = result.stderr();+ if (result.exitCode() == 0) {+ LOG.infov("Initialized {0} in Redshift container {1}", description, containerName);+ return;+ }+ } catch (Exception e) {+ lastOutput = e.getMessage();+ }+ try {+ java.util.concurrent.TimeUnit.SECONDS.sleep(1);+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ throw new IllegalStateException("Interrupted initializing " + description + " in " + containerName, e);+ }+ }+ throw new IllegalStateException("Timed out initializing " + description + " in " + containerName + ": " + lastOutput);+ }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.javaindex cd518fabbe..24c2107b5d 100644--- 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@@ -37,6 +37,23 @@ public class Cluster {public List<String> getVpcSecurityGroupIds() { return vpcSecurityGroupIds; }public void setVpcSecurityGroupIds(List<String> vpcSecurityGroupIds) { this.vpcSecurityGroupIds = vpcSecurityGroupIds; }+ // Real backend address of this cluster's PostgreSQL container. `endpoint` now points at the+ // auth proxy, not the container, so the container address is kept here for proxy wiring and+ // for restarting the proxy after a reboot or an adopt-on-startup.+ private String containerHost = null;+ private int containerPort = 0;++ // Host port the cluster's auth proxy binds. Kept stable across reboot and adopt so the+ // advertised endpoint does not change.+ private int proxyPort = 0;++ public String getContainerHost() { return containerHost; }+ public void setContainerHost(String containerHost) { this.containerHost = containerHost; }+ public int getContainerPort() { return containerPort; }+ public void setContainerPort(int containerPort) { this.containerPort = containerPort; }+ public int getProxyPort() { return proxyPort; }+ public void setProxyPort(int proxyPort) { this.proxyPort = proxyPort; }+private Map<String, String> tags = new LinkedHashMap<>();public Map<String, String> getTags() { return tags; }diff --git a/src/main/java/io/github/hectorvent/floci/services/redshift/proxy/RedshiftAuthProxy.java b/src/main/java/io/github/hectorvent/floci/services/redshift/proxy/RedshiftAuthProxy.javanew file mode 100644index 0000000000..4de297185e--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/proxy/RedshiftAuthProxy.java@@ -0,0 +1,164 @@+package io.github.hectorvent.floci.services.redshift.proxy;++import io.github.hectorvent.floci.services.rds.proxy.PostgresProtocolHandler;+import io.github.hectorvent.floci.services.rds.proxy.RdsAuthProxy;+import io.github.hectorvent.floci.services.rds.proxy.RdsProxyTlsCertificates;+import io.github.hectorvent.floci.services.rds.proxy.RdsSigV4Validator;+import org.jboss.logging.Logger;++import java.io.IOException;+import java.net.BindException;+import java.net.InetSocketAddress;+import java.net.ServerSocket;+import java.net.Socket;++/**+ * TCP auth proxy for a single Redshift cluster's backing PostgreSQL container.+ * Redshift speaks the PostgreSQL wire protocol, so the RDS PostgreSQL protocol+ * handler is reused verbatim for the auth intercept; client and backend are then+ * bridged transparently. IAM auth is never enabled for Redshift, so the SigV4+ * validator is carried only to satisfy the shared handler signature.+ */+public class RedshiftAuthProxy {++ private static final Logger LOG = Logger.getLogger(RedshiftAuthProxy.class);++ private final String clusterKey;+ private final String backendHost;+ private final int backendPort;+ private final String masterUsername;+ private volatile String masterPassword;+ private final String dbName;+ private final RdsSigV4Validator sigV4;+ private final RdsProxyTlsCertificates tlsCertificates;+ private final RdsAuthProxy.PasswordValidator passwordValidator;++ private volatile boolean running;+ private ServerSocket serverSocket;++ public RedshiftAuthProxy(String clusterKey, String backendHost, int backendPort,+ String masterUsername, String masterPassword, String dbName,+ RdsSigV4Validator sigV4, RdsProxyTlsCertificates tlsCertificates,+ RdsAuthProxy.PasswordValidator passwordValidator) {+ this.clusterKey = clusterKey;+ this.backendHost = backendHost;+ this.backendPort = backendPort;+ this.masterUsername = masterUsername;+ this.masterPassword = masterPassword;+ this.dbName = dbName;+ this.sigV4 = sigV4;+ this.tlsCertificates = tlsCertificates;+ this.passwordValidator = passwordValidator;+ }++ public void start(int proxyPort) throws IOException {+ serverSocket = bindListener(proxyPort);+ running = true;+ Thread.ofVirtual().name("redshift-proxy-accept-" + clusterKey).start(this::acceptLoop);+ LOG.infov("Redshift proxy started for cluster {0} on port {1} -> {2}:{3}",+ clusterKey, String.valueOf(proxyPort), backendHost, String.valueOf(backendPort));+ }++ /**+ * Bind the listener, retrying briefly on {@link BindException}. A reboot keeps the+ * cluster's proxy port fixed so the advertised endpoint is stable, which means the+ * old listener is closed and the same port rebound milliseconds later; under load+ * the kernel may not have released it yet and {@code SO_REUSEADDR} does not help+ * while the previous accept loop is still tearing down. ~1s of retry absorbs that+ * window; any other {@link IOException} propagates immediately.+ */+ private ServerSocket bindListener(int proxyPort) throws IOException {+ BindException lastFailure = null;+ for (int attempt = 0; attempt < 40; attempt++) {+ ServerSocket socket = new ServerSocket();+ try {+ socket.setReuseAddress(true);+ socket.bind(new InetSocketAddress(proxyPort));+ return socket;+ } catch (BindException e) {+ closeQuietly(socket);+ lastFailure = e;+ } catch (IOException e) {+ closeQuietly(socket);+ throw e;+ }+ try {+ Thread.sleep(25);+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ throw new IOException("Interrupted while binding Redshift proxy port " + proxyPort, e);+ }+ }+ throw lastFailure;+ }++ private static void closeQuietly(ServerSocket s) {+ try {+ s.close();+ } catch (IOException e) {+ LOG.debugv(e, "Error closing a discarded Redshift proxy listener socket");+ }+ }++ /** Swap the master-password snapshot after a rotation; new connections authenticate against it. */+ public void updateMasterPassword(String newPassword) {+ this.masterPassword = newPassword;+ }++ public void stop() {+ running = false;+ try {+ if (serverSocket != null) {+ serverSocket.close();+ }+ } catch (IOException e) {+ LOG.warnv(e, "Error closing Redshift proxy server socket for cluster {0}", clusterKey);+ throw new RuntimeException("Failed to stop Redshift proxy for cluster " + clusterKey, e);+ }+ }++ private void acceptLoop() {+ while (running) {+ try {+ Socket client = serverSocket.accept();+ Thread.ofVirtual().name("redshift-proxy-conn-" + clusterKey)+ .start(() -> handleConnection(client));+ } catch (IOException e) {+ if (running) {+ LOG.warnv("Accept error for Redshift cluster {0}: {1}", clusterKey, e.getMessage());+ }+ }+ }+ }++ private void handleConnection(Socket client) {+ Socket backend = null;+ try {+ client.setTcpNoDelay(true);+ backend = new Socket(backendHost, backendPort);+ backend.setTcpNoDelay(true);+ // iamEnabled = false: the SigV4 branch inside handleAuth is never taken.+ PostgresProtocolHandler.handleAuth(+ client, backend, masterUsername, masterPassword, dbName,+ false, sigV4, tlsCertificates, passwordValidator::validate);+ } catch (Exception e) {+ LOG.debugv("Redshift connection error for cluster {0}: {1}", clusterKey, e.getMessage());+ } finally {+ // handleAuth's success path bridges then closes both sockets; every other path+ // (early return on a bare probe, auth failure, thrown IOException) can leave the+ // backend connection to Postgres open. Closing here is idempotent.+ closeQuietly(client);+ if (backend != null) {+ closeQuietly(backend);+ }+ }+ }++ private static void closeQuietly(Socket s) {+ try {+ s.close();+ } catch (IOException e) {+ LOG.debugv(e, "Error closing Redshift proxy client socket");+ }+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/redshift/proxy/RedshiftProxyManager.java b/src/main/java/io/github/hectorvent/floci/services/redshift/proxy/RedshiftProxyManager.javanew file mode 100644index 0000000000..a51b8c7ae2--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/proxy/RedshiftProxyManager.java@@ -0,0 +1,134 @@+package io.github.hectorvent.floci.services.redshift.proxy;++import io.github.hectorvent.floci.services.rds.proxy.RdsAuthProxy;+import io.github.hectorvent.floci.services.rds.proxy.RdsProxyTlsCertificates;+import io.github.hectorvent.floci.services.rds.proxy.RdsSigV4Validator;+import io.quarkus.runtime.ShutdownEvent;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.enterprise.event.Observes;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;++import java.io.IOException;+import java.util.concurrent.ConcurrentHashMap;++/**+ * Registry of all active Redshift auth proxies. One proxy per cluster, keyed by+ * the relay key "{accountId}:{clusterId}". Mirrors RdsProxyManager; Redshift is+ * always PostgreSQL and never IAM-enabled, so those parameters are dropped.+ */+@ApplicationScoped+public class RedshiftProxyManager {++ private static final Logger LOG = Logger.getLogger(RedshiftProxyManager.class);++ private final RdsSigV4Validator sigV4Validator;+ private final RdsProxyTlsCertificates tlsCertificates;+ private final ConcurrentHashMap<String, RedshiftAuthProxy> proxies = new ConcurrentHashMap<>();+ /**+ * Proxies whose listener could not be closed during a failed start or replace. The+ * reference is kept (not discarded) so a later {@link #stopProxy}/{@link #stopAll}+ * can retry the close; until one succeeds, {@code stopProxy} keeps throwing so the+ * caller leaves the port reserved rather than handing it out to another cluster.+ */+ private final ConcurrentHashMap<String, RedshiftAuthProxy> unclosableProxies = new ConcurrentHashMap<>();++ @Inject+ public RedshiftProxyManager(RdsSigV4Validator sigV4Validator, RdsProxyTlsCertificates tlsCertificates) {+ this.sigV4Validator = sigV4Validator;+ this.tlsCertificates = tlsCertificates;+ }++ public synchronized void startProxy(String relayKey, int proxyPort,+ String backendHost, int backendPort, String advertisedHost,+ String masterUsername, String masterPassword, String dbName,+ RdsAuthProxy.PasswordValidator passwordValidator) {+ // A prior unclosable entry for this key is left in place: its listener may still+ // be bound, and only a successful stop (never a fresh start) may drop it.+ // Make sure the self-signed proxy certificate covers the host clients will connect to,+ // so sslmode=prefer/require handshakes succeed.+ tlsCertificates.ensureHost(advertisedHost);+ RedshiftAuthProxy proxy = new RedshiftAuthProxy(+ relayKey, backendHost, backendPort, masterUsername, masterPassword, dbName,+ sigV4Validator, tlsCertificates, passwordValidator);+ try {+ proxy.start(proxyPort);+ } catch (IOException | RuntimeException e) {+ RuntimeException failure = new RuntimeException(+ "Failed to start Redshift proxy for cluster " + relayKey + " on port " + proxyPort, e);+ cleanupFailedStart(relayKey, proxy, failure);+ throw failure;+ }+ RedshiftAuthProxy previous = proxies.put(relayKey, proxy);+ if (previous != null) {+ try {+ previous.stop();+ } catch (RuntimeException e) {+ proxies.put(relayKey, previous);+ RuntimeException failure = new RuntimeException(+ "Failed to replace Redshift proxy for cluster " + relayKey, e);+ cleanupFailedStart(relayKey, proxy, failure);+ throw failure;+ }+ }+ }++ public synchronized void updateMasterPassword(String relayKey, String newPassword) {+ RedshiftAuthProxy proxy = proxies.get(relayKey);+ if (proxy != null) {+ proxy.updateMasterPassword(newPassword);+ LOG.infov("Updated Redshift proxy master password for cluster {0}", relayKey);+ }+ }++ public synchronized void stopProxy(String relayKey) {+ // Retry any listener a previous failed start/replace could not close. If it still+ // cannot be closed this throws, and the entry stays for the next retry.+ RedshiftAuthProxy unclosable = unclosableProxies.get(relayKey);+ if (unclosable != null) {+ unclosable.stop();+ unclosableProxies.remove(relayKey);+ LOG.infov("Recovered previously unclosable Redshift proxy for cluster {0}", relayKey);+ }+ RedshiftAuthProxy proxy = proxies.get(relayKey);+ if (proxy != null) {+ proxy.stop();+ proxies.remove(relayKey);+ LOG.infov("Stopped Redshift proxy for cluster {0}", relayKey);+ }+ }++ public synchronized void stopAll() {+ proxies.forEach((relayKey, proxy) -> {+ try {+ proxy.stop();+ proxies.remove(relayKey, proxy);+ } catch (RuntimeException e) {+ LOG.warnv(e, "Failed to stop Redshift proxy for cluster {0} during shutdown", relayKey);+ }+ });+ unclosableProxies.forEach((relayKey, proxy) -> {+ try {+ proxy.stop();+ unclosableProxies.remove(relayKey, proxy);+ } catch (RuntimeException e) {+ LOG.warnv(e, "Failed to close leaked Redshift proxy for cluster {0} during shutdown", relayKey);+ }+ });+ LOG.info("Stopped all Redshift proxies");+ }++ void onShutdown(@Observes ShutdownEvent event) {+ stopAll();+ }++ private void cleanupFailedStart(String relayKey, RedshiftAuthProxy proxy, RuntimeException failure) {+ try {+ proxy.stop();+ } catch (RuntimeException cleanupFailure) {+ // Keep the listener reachable so stopProxy/stopAll can retry closing it later.+ unclosableProxies.put(relayKey, proxy);+ failure.addSuppressed(cleanupFailure);+ }+ }+}diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex e232b035a8..96cc8ace1b 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -318,6 +318,9 @@ floci:enabled: truedefault-port: 5439image-version: postgres:15-alpine+ proxy-base-port: 7100+ proxy-max-port: 7199+ # endpoint-host: localhost # Hostname clients use; empty -> DockerHostResolverrds:enabled: truemock: false # FLOCI_SERVICES_RDS_MOCK — true = metadata only, no Docker (useful for CI)diff --git a/src/test/java/io/github/hectorvent/floci/config/RedshiftProxyConfigTest.java b/src/test/java/io/github/hectorvent/floci/config/RedshiftProxyConfigTest.javanew file mode 100644index 0000000000..2bb3a8c0c3--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/config/RedshiftProxyConfigTest.java@@ -0,0 +1,27 @@+package io.github.hectorvent.floci.config;++import io.quarkus.test.junit.QuarkusTest;+import jakarta.inject.Inject;+import org.junit.jupiter.api.Test;++import java.util.Optional;++import static org.junit.jupiter.api.Assertions.assertEquals;++@QuarkusTest+class RedshiftProxyConfigTest {++ @Inject+ EmulatorConfig config;++ @Test+ void redshiftProxyPortRangeHasDefaults() {+ assertEquals(7100, config.services().redshift().proxyBasePort());+ assertEquals(7199, config.services().redshift().proxyMaxPort());+ }++ @Test+ void redshiftEndpointHostDefaultsToEmpty() {+ assertEquals(Optional.empty(), config.services().redshift().endpointHost());+ }+}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.javaindex 8c969c2b54..c6a15db510 100644--- a/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftOperationsTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftOperationsTest.java@@ -9,6 +9,10 @@ import org.junit.jupiter.api.Order;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.TestMethodOrder;+import java.nio.file.Files;+import java.nio.file.Path;+import java.util.Optional;+import static io.restassured.RestAssured.given;import static org.hamcrest.Matchers.containsString;import static org.mockito.ArgumentMatchers.any;@@ -107,10 +111,10 @@ public class RedshiftOperationsTest {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;");+ Path p = invocation.getArgument(3);+ 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).takeSnapshot(any(), eq("cluster-src"), eq("admin"), any(Path.class));when(containerManager.start(any(), eq("cluster-restored"), any(), any())).thenReturn(new RedshiftContainerHandle("c2", "cluster-restored", "localhost", 5440));@@ -133,7 +137,7 @@ public class RedshiftOperationsTest {// 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)));+ .thenReturn(Optional.of(new RedshiftContainerHandle("c1", "cluster-src", "localhost", 5439)));given().contentType("application/x-www-form-urlencoded").header("Authorization", AUTH_HEADER)@@ -216,8 +220,7 @@ public class RedshiftOperationsTest {.statusCode(200).contentType("application/xml").body(containsString("<ClusterIdentifier>cluster-restored</ClusterIdentifier>"))- .body(containsString("<ClusterStatus>available</ClusterStatus>"))- .body(containsString("<Port>5440</Port>"));+ .body(containsString("<ClusterStatus>available</ClusterStatus>"));// 6. DeleteClusterSnapshotgiven()diff --git a/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftProxyIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftProxyIntegrationTest.javanew file mode 100644index 0000000000..97f1677144--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftProxyIntegrationTest.java@@ -0,0 +1,127 @@+package io.github.hectorvent.floci.services.redshift;++import io.github.hectorvent.floci.services.redshift.model.Cluster;+import io.quarkus.test.junit.QuarkusTest;+import jakarta.inject.Inject;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.Test;++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.util.Objects;+import org.awaitility.Awaitility;+import org.awaitility.core.ConditionTimeoutException;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;++@QuarkusTest+class RedshiftProxyIntegrationTest {++ @Inject+ RedshiftService service;++ private String clusterId;++ @AfterEach+ void cleanUp() {+ if (clusterId != null) {+ service.deleteCluster(clusterId);+ }+ }++ private static String jdbcUrl(Cluster c) {+ // Use 127.0.0.1 explicitly instead of c.getEndpoint().getAddress() to avoid UnknownHostException+ // in CI environments where floci.emulator.hostname is set to host.docker.internal.+ return "jdbc:postgresql://127.0.0.1:" + c.getEndpoint().getPort() + "/dev";+ }++ private static Connection waitForConnection(Cluster cluster, String username, String password) throws SQLException {+ try {+ return Awaitility.await()+ .atMost(Duration.ofSeconds(30))+ .pollInterval(Duration.ofMillis(500))+ .ignoreExceptions()+ .until(() -> DriverManager.getConnection(jdbcUrl(cluster), username, password), Objects::nonNull);+ } catch (ConditionTimeoutException e) {+ return DriverManager.getConnection(jdbcUrl(cluster), username, password); // throw original+ }+ }++ @Test+ void roundTripsSqlThroughTheAdvertisedEndpoint() throws SQLException {+ clusterId = "it-proxy-roundtrip";+ Cluster cluster = service.createCluster(clusterId, "dc2.large", "admin", "Secret123");++ try (Connection conn = waitForConnection(cluster, "admin", "Secret123");+ Statement st = conn.createStatement()) {+ st.execute("CREATE TABLE people (name text)");+ st.execute("INSERT INTO people VALUES ('Alice')");+ try (ResultSet rs = st.executeQuery("SELECT count(*) FROM people")) {+ assertTrue(rs.next());+ assertEquals(1, rs.getInt(1));+ }+ }+ }++ @Test+ void rejectsAWrongPasswordAtTheProxy() throws SQLException {+ clusterId = "it-proxy-badpass";+ Cluster cluster = service.createCluster(clusterId, "dc2.large", "admin", "Secret123");++ // Ensure it's ready first+ try (Connection conn = waitForConnection(cluster, "admin", "Secret123")) {+ assertTrue(conn.isValid(5));+ }++ assertThrows(SQLException.class, () ->+ DriverManager.getConnection(jdbcUrl(cluster), "admin", "wrong-password"));+ }++ @Test+ void reflectsAPasswordChangeForNewConnections() throws SQLException {+ clusterId = "it-proxy-rotate";+ Cluster cluster = service.createCluster(clusterId, "dc2.large", "admin", "Secret123");++ // Ensure it's ready before testing rotation+ try (Connection conn = waitForConnection(cluster, "admin", "Secret123")) {+ assertTrue(conn.isValid(5));+ }++ service.modifyCluster(clusterId, null, null, "Rotated123", null, null);++ assertThrows(SQLException.class, () ->+ DriverManager.getConnection(jdbcUrl(cluster), "admin", "Secret123"));+ try (Connection conn = DriverManager.getConnection(jdbcUrl(cluster), "admin", "Rotated123")) {+ assertTrue(conn.isValid(5));+ }+ }++ @Test+ void keepsTheEndpointStableAndDataIntactAcrossAReboot() throws SQLException {+ clusterId = "it-proxy-reboot";+ Cluster cluster = service.createCluster(clusterId, "dc2.large", "admin", "Secret123");+ int portBefore = cluster.getEndpoint().getPort();++ try (Connection conn = waitForConnection(cluster, "admin", "Secret123");+ Statement st = conn.createStatement()) {+ st.execute("CREATE TABLE t (n int)");+ st.execute("INSERT INTO t VALUES (42)");+ }++ Cluster rebooted = service.rebootCluster(clusterId);+ assertEquals(portBefore, rebooted.getEndpoint().getPort());++ try (Connection conn = waitForConnection(rebooted, "admin", "Secret123");+ Statement st = conn.createStatement();+ ResultSet rs = st.executeQuery("SELECT n FROM t")) {+ assertTrue(rs.next());+ assertEquals(42, rs.getInt(1));+ }+ }+}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.javaindex 23f4bca6d3..64850dc194 100644--- a/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftServiceTest.java@@ -15,6 +15,11 @@ import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;import org.mockito.ArgumentCaptor;+import java.nio.file.Files;+import java.nio.file.Path;+import java.nio.file.Paths;+import java.util.ArrayList;+import java.util.LinkedHashMap;import java.util.List;import java.util.Map;import java.util.Optional;@@ -35,6 +40,8 @@ class RedshiftServiceTest {private AccountAwareStorageBackend<ClusterSubnetGroup> subnetGroupBackend;private RedshiftContainerManager cm;private io.github.hectorvent.floci.core.common.RegionResolver regionResolver;+ private io.github.hectorvent.floci.services.redshift.proxy.RedshiftProxyManager proxyManager;+ private io.github.hectorvent.floci.core.common.docker.DockerHostResolver dockerHostResolver;private RedshiftService service;@BeforeEach@@ -47,12 +54,25 @@ class RedshiftServiceTest {parameterGroupBackend = mock(AccountAwareStorageBackend.class);subnetGroupBackend = mock(AccountAwareStorageBackend.class);cm = mock(RedshiftContainerManager.class);-+ proxyManager = mock(io.github.hectorvent.floci.services.redshift.proxy.RedshiftProxyManager.class);+ dockerHostResolver = mock(io.github.hectorvent.floci.core.common.docker.DockerHostResolver.class);+ when(dockerHostResolver.resolve()).thenReturn("localhost");+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");+ io.github.hectorvent.floci.config.EmulatorConfig.ServicesConfig servicesConfig =+ mock(io.github.hectorvent.floci.config.EmulatorConfig.ServicesConfig.class);+ io.github.hectorvent.floci.config.EmulatorConfig.RedshiftServiceConfig redshiftConfig =+ mock(io.github.hectorvent.floci.config.EmulatorConfig.RedshiftServiceConfig.class);+ when(config.services()).thenReturn(servicesConfig);+ when(servicesConfig.redshift()).thenReturn(redshiftConfig);+ when(redshiftConfig.proxyBasePort()).thenReturn(7100);+ when(redshiftConfig.proxyMaxPort()).thenReturn(7199);+ when(redshiftConfig.endpointHost()).thenReturn(Optional.empty());+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);@@ -61,12 +81,12 @@ class RedshiftServiceTest {regionResolver = new io.github.hectorvent.floci.core.common.RegionResolver("us-east-1", "111111111111");- service = new RedshiftService(sf, cm, config, regionResolver);+ service = new RedshiftService(sf, cm, config, regionResolver, proxyManager, dockerHostResolver);}/** 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")+ return Paths.get("target/test-data", "redshift-dumps", "111111111111", snapshotId + ".sql").toAbsolutePath().normalize().toString();}@@ -138,6 +158,34 @@ class RedshiftServiceTest {assertEquals("unavailable", captor.getValue().getClusterStatus());}+ @Test+ @SuppressWarnings("unchecked")+ void onStartRestartsTheProxyForAnAdoptedCluster() {+ Cluster persisted = new Cluster();+ persisted.setClusterIdentifier("c1");+ persisted.setMasterUsername("admin");+ persisted.setMasterPassword("Secret123");+ persisted.setClusterStatus("available");+ persisted.setProxyPort(7108);++ var entry = mock(AccountAwareStorageBackend.AccountEntry.class);+ when(entry.value()).thenReturn(persisted);+ when(entry.accountId()).thenReturn("111111111111");+ when(entry.key()).thenReturn("c1");+ when(clusterBackend.scanAllAccountEntries(any())).thenReturn(List.of(entry));+ when(cm.getContainer("111111111111", "c1")).thenReturn(Optional.empty());+ RedshiftContainerHandle handle = mock(RedshiftContainerHandle.class);+ when(handle.getHost()).thenReturn("172.17.0.12");+ when(handle.getPort()).thenReturn(32830);+ when(cm.adoptOrStart("111111111111", "c1", "admin", "Secret123")).thenReturn(handle);++ service.onStart(null);++ verify(proxyManager).startProxy(eq("111111111111:c1"), eq(7108),+ eq("172.17.0.12"), eq(32830), eq("localhost"),+ eq("admin"), eq("Secret123"), eq("dev"), any());+ }+@Testvoid testCreateCluster() {when(clusterBackend.get(anyString())).thenReturn(Optional.empty());@@ -163,6 +211,29 @@ class RedshiftServiceTest {assertEquals(List.of("sg-1", "sg-2"), cluster.getVpcSecurityGroupIds());}+ @Test+ void createClusterStartsAProxyAndAdvertisesTheProxyEndpoint() {+ when(clusterBackend.get("c1")).thenReturn(Optional.empty());+ when(clusterBackend.accountId()).thenReturn("111111111111");+ RedshiftContainerHandle handle = mock(RedshiftContainerHandle.class);+ when(handle.getHost()).thenReturn("172.17.0.9");+ when(handle.getPort()).thenReturn(32800);+ when(cm.start(eq("111111111111"), eq("c1"), eq("admin"), eq("Secret123"))).thenReturn(handle);++ Cluster cluster = service.createCluster("c1", "dc2.large", "admin", "Secret123");++ // Endpoint is the proxy, not the container.+ assertEquals("localhost", cluster.getEndpoint().getAddress());+ assertTrue(cluster.getEndpoint().getPort() >= 7100 && cluster.getEndpoint().getPort() <= 7199);+ assertEquals("172.17.0.9", cluster.getContainerHost());+ assertEquals(32800, cluster.getContainerPort());+ assertEquals(cluster.getEndpoint().getPort(), cluster.getProxyPort());++ verify(proxyManager).startProxy(eq("111111111111:c1"), eq(cluster.getProxyPort()),+ eq("172.17.0.9"), eq(32800), eq("localhost"),+ eq("admin"), eq("Secret123"), eq("dev"), any());+ }+@Testvoid testCreateClusterAlreadyExists() {when(clusterBackend.get("existing-cluster")).thenReturn(Optional.of(new Cluster()));@@ -171,6 +242,84 @@ class RedshiftServiceTest {service.createCluster("existing-cluster", "dc2.large", "admin", "password123"));}+ @Test+ void createClusterRemovesMetadataOnFailure() {+ when(clusterBackend.accountId()).thenReturn("111111111111");+ when(clusterBackend.get("c1")).thenReturn(Optional.empty());+ when(cm.start(eq("111111111111"), eq("c1"), eq("admin"), eq("password123")))+ .thenThrow(new RuntimeException("startup failed"));++ assertThrows(AwsException.class, () ->+ service.createCluster("c1", "dc2.large", "admin", "password123"));++ verify(clusterBackend).delete("c1");+ verify(clusterBackend, atLeastOnce()).flush();+ }++ @Test+ void createClusterKeepsMetadataWhenProxyStopFails() {+ when(clusterBackend.accountId()).thenReturn("111111111111");+ when(clusterBackend.get("c1")).thenReturn(Optional.empty());+ when(cm.start(eq("111111111111"), eq("c1"), eq("admin"), eq("password123")))+ .thenThrow(new RuntimeException("startup failed"));+ doThrow(new RuntimeException("proxy stop failed"))+ .when(proxyManager).stopProxy("111111111111:c1");++ assertThrows(AwsException.class, () ->+ service.createCluster("c1", "dc2.large", "admin", "password123"));++ verify(clusterBackend, never()).delete("c1");+ verify(clusterBackend, atLeast(1)).put(eq("c1"), argThat(c -> "failed".equals(c.getClusterStatus())));+ verify(clusterBackend, atLeastOnce()).flush();+ }++ @Test+ void restoreFromClusterSnapshotRemovesMetadataOnFailure() {+ when(clusterBackend.accountId()).thenReturn("111111111111");+ Snapshot snapshot = new Snapshot();+ snapshot.setSnapshotIdentifier("snap-1");+ snapshot.setClusterIdentifier("source-c1");+ snapshot.setMasterUsername("admin");+ snapshot.setMasterPassword("password123");+ snapshot.setSqlDump(null);++ when(clusterBackend.get("c1")).thenReturn(Optional.empty());+ when(snapshotBackend.get("snap-1")).thenReturn(Optional.of(snapshot));+ when(cm.start(eq("111111111111"), eq("c1"), eq("admin"), eq("password123")))+ .thenThrow(new RuntimeException("startup failed"));++ assertThrows(AwsException.class, () ->+ service.restoreFromClusterSnapshot("c1", "snap-1"));++ verify(clusterBackend).delete("c1");+ verify(clusterBackend, atLeastOnce()).flush();+ }++ @Test+ void restoreFromClusterSnapshotKeepsMetadataWhenProxyStopFails() {+ when(clusterBackend.accountId()).thenReturn("111111111111");+ Snapshot snapshot = new Snapshot();+ snapshot.setSnapshotIdentifier("snap-1");+ snapshot.setClusterIdentifier("source-c1");+ snapshot.setMasterUsername("admin");+ snapshot.setMasterPassword("password123");+ snapshot.setSqlDump(null);++ when(clusterBackend.get("c1")).thenReturn(Optional.empty());+ when(snapshotBackend.get("snap-1")).thenReturn(Optional.of(snapshot));+ when(cm.start(eq("111111111111"), eq("c1"), eq("admin"), eq("password123")))+ .thenThrow(new RuntimeException("startup failed"));+ doThrow(new RuntimeException("proxy stop failed"))+ .when(proxyManager).stopProxy("111111111111:c1");++ assertThrows(AwsException.class, () ->+ service.restoreFromClusterSnapshot("c1", "snap-1"));++ verify(clusterBackend, never()).delete("c1");+ verify(clusterBackend, atLeast(1)).put(eq("c1"), argThat(c -> "failed".equals(c.getClusterStatus())));+ verify(clusterBackend, atLeastOnce()).flush();+ }+@Testvoid testDescribeClusters() {Cluster c = new Cluster();@@ -194,6 +343,41 @@ class RedshiftServiceTest {verify(clusterBackend).delete("test-c");}+ @Test+ void deleteClusterAbortsAndKeepsMetadataWhenTheProxyWontStop() {+ Cluster c = new Cluster();+ c.setClusterIdentifier("test-c");+ c.setProxyPort(7107);+ when(clusterBackend.get("test-c")).thenReturn(Optional.of(c));+ doThrow(new RuntimeException("listener close failed"))+ .when(proxyManager).stopProxy("111111111111:test-c");++ AwsException ex = assertThrows(AwsException.class, () -> service.deleteCluster("test-c"));+ assertEquals("InternalFailure", ex.getErrorCode());++ // Container and metadata are left intact so the deletion can be retried.+ verify(cm, never()).stop(anyString(), anyString());+ verify(clusterBackend, never()).delete(anyString());+ }++ @Test+ void deleteClusterRetrySucceedsOnceTheProxyStops() {+ Cluster c = new Cluster();+ c.setClusterIdentifier("test-c");+ c.setProxyPort(7107);+ when(clusterBackend.get("test-c")).thenReturn(Optional.of(c));+ doThrow(new RuntimeException("listener close failed"))+ .doNothing()+ .when(proxyManager).stopProxy("111111111111:test-c");++ assertThrows(AwsException.class, () -> service.deleteCluster("test-c"));+ Cluster deleted = service.deleteCluster("test-c");++ assertEquals("deleting", deleted.getClusterStatus());+ verify(cm).stop("111111111111", "test-c");+ verify(clusterBackend).delete("test-c");+ }+@Testvoid testRebootClusterDumpsAndRestoresData() throws Exception {Cluster cluster = new Cluster();@@ -205,18 +389,46 @@ class RedshiftServiceTest {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");+ Path dumpFile = invocation.getArgument(3);+ Files.writeString(dumpFile, "-- dump");return null;- }).when(cm).takeSnapshot(eq("111111111111"), eq("my-cluster"), eq("admin"), any(java.nio.file.Path.class));+ }).when(cm).takeSnapshot(eq("111111111111"), eq("my-cluster"), eq("admin"), any(Path.class));Cluster rebooted = service.rebootCluster("my-cluster");assertEquals("available", rebooted.getClusterStatus());- assertEquals(5555, rebooted.getEndpoint().getPort());+ // Endpoint now advertises the auth proxy; the restarted container is tracked separately.+ assertEquals(5555, rebooted.getContainerPort());+ assertTrue(rebooted.getEndpoint().getPort() >= 7100 && rebooted.getEndpoint().getPort() <= 7199);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));+ verify(cm).restoreSnapshot(eq("111111111111"), eq("my-cluster"), eq("admin"), any(Path.class));+ }++ @Test+ void rebootClusterRestartsTheProxyOnTheSamePort() {+ Cluster cluster = new Cluster();+ cluster.setClusterIdentifier("c1");+ cluster.setMasterUsername("admin");+ cluster.setMasterPassword("Secret123");+ cluster.setProxyPort(7107);+ cluster.setEndpoint(new Endpoint("localhost", 7107));+ when(clusterBackend.get("c1")).thenReturn(Optional.of(cluster));+ when(clusterBackend.accountId()).thenReturn("111111111111");+ RedshiftContainerHandle handle = mock(RedshiftContainerHandle.class);+ when(handle.getHost()).thenReturn("172.17.0.11");+ when(handle.getPort()).thenReturn(32820);+ when(cm.start(eq("111111111111"), eq("c1"), eq("admin"), eq("Secret123"))).thenReturn(handle);++ Cluster rebooted = service.rebootCluster("c1");++ assertEquals(7107, rebooted.getEndpoint().getPort());+ assertEquals("localhost", rebooted.getEndpoint().getAddress());+ assertEquals("172.17.0.11", rebooted.getContainerHost());+ verify(proxyManager).stopProxy("111111111111:c1");+ verify(proxyManager).startProxy(eq("111111111111:c1"), eq(7107),+ eq("172.17.0.11"), eq(32820), eq("localhost"),+ eq("admin"), eq("Secret123"), eq("dev"), any());}@Test@@ -226,6 +438,94 @@ class RedshiftServiceTest {assertThrows(AwsException.class, () -> service.rebootCluster("missing"));}+ @Test+ void rebootClusterTearsDownTheProxyWhenRestoreFails() {+ Cluster cluster = new Cluster();+ cluster.setClusterIdentifier("c1");+ cluster.setMasterUsername("admin");+ cluster.setMasterPassword("Secret123");+ cluster.setProxyPort(7107);+ when(clusterBackend.get("c1")).thenReturn(Optional.of(cluster));+ RedshiftContainerHandle handle = mock(RedshiftContainerHandle.class);+ when(handle.getHost()).thenReturn("172.17.0.11");+ when(handle.getPort()).thenReturn(32820);+ when(cm.start(eq("111111111111"), eq("c1"), eq("admin"), eq("Secret123"))).thenReturn(handle);+ doThrow(new RuntimeException("restore boom"))+ .when(cm).restoreSnapshot(eq("111111111111"), eq("c1"), eq("admin"), any(Path.class));++ assertThrows(AwsException.class, () -> service.rebootCluster("c1"));++ // The proxy started during the reboot must be stopped again on failure, and the+ // replacement container must be stopped too — once before the restart, once in+ // rollback — so it is not left running behind a "failed" cluster.+ verify(proxyManager).startProxy(eq("111111111111:c1"), eq(7107), any(), anyInt(),+ any(), any(), any(), any(), any());+ verify(proxyManager, times(2)).stopProxy("111111111111:c1");+ verify(cm, times(2)).stop("111111111111", "c1");+ }++ @Test+ void rebootClusterLeavesTheOriginalContainerAloneWhenTheDumpFails() {+ Cluster cluster = new Cluster();+ cluster.setClusterIdentifier("c1");+ cluster.setMasterUsername("admin");+ cluster.setMasterPassword("Secret123");+ cluster.setProxyPort(7107);+ when(clusterBackend.get("c1")).thenReturn(Optional.of(cluster));+ doThrow(new RuntimeException("dump boom"))+ .when(cm).takeSnapshot(eq("111111111111"), eq("c1"), eq("admin"), any(Path.class));++ assertThrows(AwsException.class, () -> service.rebootCluster("c1"));++ // The dump failed before the original was torn down: rollback must not stop the+ // still-running original container or touch its proxy.+ verify(cm, never()).stop(anyString(), anyString());+ verify(proxyManager, never()).stopProxy(anyString());+ }++ @Test+ void rebootClusterRemovesTheReplacementWhenItsStartupThrows() {+ Cluster cluster = new Cluster();+ cluster.setClusterIdentifier("c1");+ cluster.setMasterUsername("admin");+ cluster.setMasterPassword("Secret123");+ cluster.setProxyPort(7107);+ when(clusterBackend.get("c1")).thenReturn(Optional.of(cluster));+ when(cm.start(eq("111111111111"), eq("c1"), eq("admin"), eq("Secret123")))+ .thenThrow(new RuntimeException("readiness timed out"));++ assertThrows(AwsException.class, () -> service.rebootCluster("c1"));++ // start() can create the container before throwing (readiness check); the+ // original is already gone, so rollback removes anything under the name —+ // once for the original teardown, once for the possible orphan.+ verify(cm, times(2)).stop("111111111111", "c1");++ // The reserved port belongs to the cluster and is not released by reboot rollback;+ // it is released only when the cluster is successfully deleted.+ assertEquals(7107, cluster.getProxyPort());+ }++ @Test+ void rebootClusterKeepsProxyPortWhenRollbackStopFails() {+ Cluster cluster = new Cluster();+ cluster.setClusterIdentifier("c1");+ cluster.setMasterUsername("admin");+ cluster.setMasterPassword("Secret123");+ cluster.setProxyPort(7107);+ when(clusterBackend.accountId()).thenReturn("111111111111");+ when(clusterBackend.get("c1")).thenReturn(Optional.of(cluster));+ when(cm.start(eq("111111111111"), eq("c1"), eq("admin"), eq("Secret123")))+ .thenThrow(new RuntimeException("readiness timed out"));++ // The first call stops the proxy during takeSnapshot; the second call happens in rollback.+ doNothing().doThrow(new RuntimeException("stop failed")).when(proxyManager).stopProxy(anyString());++ assertThrows(AwsException.class, () -> service.rebootCluster("c1"));++ assertEquals(7107, cluster.getProxyPort());+ }+@Testvoid testCreateSnapshot() {Cluster cluster = new Cluster();@@ -236,7 +536,7 @@ class RedshiftServiceTest {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));+ doNothing().when(cm).takeSnapshot(eq("111111111111"), eq("my-cluster"), eq("admin"), any(Path.class));Snapshot snapshot = service.createSnapshot("my-snapshot", "my-cluster");assertNotNull(snapshot);@@ -252,7 +552,7 @@ class RedshiftServiceTest {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));+ verify(cm).takeSnapshot(eq("111111111111"), eq("my-cluster"), eq("admin"), any(Path.class));}@Test@@ -292,7 +592,7 @@ class RedshiftServiceTest {assertEquals("InvalidParameterValue", ex.getErrorCode(), id);assertEquals(400, ex.getHttpStatus(), id);}- verify(cm, never()).takeSnapshot(any(), any(), any(), any(java.nio.file.Path.class));+ verify(cm, never()).takeSnapshot(any(), any(), any(), any(Path.class));verify(snapshotBackend, never()).put(anyString(), any(Snapshot.class));}@@ -386,7 +686,7 @@ class RedshiftServiceTest {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));+ doNothing().when(cm).restoreSnapshot(eq("111111111111"), eq("restored-cluster"), eq("admin"), any(Path.class));Cluster cluster = service.restoreFromClusterSnapshot("restored-cluster", "my-snapshot", "dc2.large");assertNotNull(cluster);@@ -399,7 +699,7 @@ class RedshiftServiceTest {// Restore must use the source cluster's actual password, not a hardcoded oneverify(cm).start("111111111111", "restored-cluster", "admin", "password123");- verify(cm).restoreSnapshot(eq("111111111111"), eq("restored-cluster"), eq("admin"), any(java.nio.file.Path.class));+ verify(cm).restoreSnapshot(eq("111111111111"), eq("restored-cluster"), eq("admin"), any(Path.class));verify(clusterBackend, times(2)).put(eq("restored-cluster"), any(Cluster.class));verify(clusterBackend, times(2)).flush();}@@ -415,7 +715,7 @@ class RedshiftServiceTest {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));+ doNothing().when(cm).restoreSnapshot(eq("111111111111"), eq("restored-cluster"), eq("admin"), any(Path.class));Cluster cluster = service.restoreFromClusterSnapshot("restored-cluster", "my-snapshot", "dc2.large");assertEquals("original-secret", cluster.getMasterPassword());@@ -431,7 +731,7 @@ class RedshiftServiceTest {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));+ doNothing().when(cm).restoreSnapshot(eq("111111111111"), eq("restored-cluster"), eq("admin"), any(Path.class));Cluster cluster = service.restoreFromClusterSnapshot("restored-cluster", "my-snapshot", "dc2.large");assertEquals("admin", cluster.getMasterPassword());@@ -483,6 +783,58 @@ class RedshiftServiceTest {verify(clusterBackend, never()).put(anyString(), any(Cluster.class));}+ @Test+ void deleteClusterStopsTheProxyAndReleasesThePort() {+ Cluster cluster = new Cluster();+ cluster.setClusterIdentifier("c1");+ cluster.setProxyPort(7105);+ when(clusterBackend.get("c1")).thenReturn(Optional.of(cluster));+ when(clusterBackend.accountId()).thenReturn("111111111111");++ service.deleteCluster("c1");++ verify(proxyManager).stopProxy("111111111111:c1");+ }++ @Test+ void modifyClusterPasswordUpdatesTheProxySnapshot() {+ Cluster cluster = new Cluster();+ cluster.setClusterIdentifier("c1");+ cluster.setMasterUsername("admin");+ cluster.setMasterPassword("old");+ when(clusterBackend.get("c1")).thenReturn(Optional.of(cluster));+ when(clusterBackend.accountId()).thenReturn("111111111111");++ service.modifyCluster("c1", null, null, "NewSecret1", null, null);++ verify(proxyManager).updateMasterPassword("111111111111:c1", "NewSecret1");+ }++ @Test+ void restoreFromSnapshotStartsAProxyForTheNewCluster() {+ Snapshot snap = new Snapshot();+ snap.setSnapshotIdentifier("s1");+ snap.setClusterIdentifier("src");+ snap.setMasterUsername("admin");+ snap.setMasterPassword("Secret123");+ snap.setSqlDump(null);+ when(snapshotBackend.get("s1")).thenReturn(Optional.of(snap));+ when(clusterBackend.get("restored")).thenReturn(Optional.empty());+ when(clusterBackend.accountId()).thenReturn("111111111111");+ RedshiftContainerHandle handle = mock(RedshiftContainerHandle.class);+ when(handle.getHost()).thenReturn("172.17.0.10");+ when(handle.getPort()).thenReturn(32810);+ when(cm.start(eq("111111111111"), eq("restored"), eq("admin"), eq("Secret123"))).thenReturn(handle);++ Cluster restored = service.restoreFromClusterSnapshot("restored", "s1");++ assertEquals("localhost", restored.getEndpoint().getAddress());+ assertEquals(restored.getEndpoint().getPort(), restored.getProxyPort());+ verify(proxyManager).startProxy(eq("111111111111:restored"), anyInt(),+ eq("172.17.0.10"), eq(32810), eq("localhost"),+ eq("admin"), eq("Secret123"), eq("dev"), any());+ }+@Testvoid testCreateClusterParameterGroup() {when(parameterGroupBackend.get("my-pg")).thenReturn(Optional.empty());@@ -580,7 +932,7 @@ class RedshiftServiceTest {@Testvoid 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"))));+ group.setParameters(new ArrayList<>(List.of(new Parameter("statement_timeout", "5000"))));when(parameterGroupBackend.get("my-pg")).thenReturn(Optional.of(group));List<Parameter> params = service.describeClusterParameters("my-pg");@@ -614,7 +966,7 @@ class RedshiftServiceTest {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"));+ Map.of("env", "test"));assertEquals("test", cluster.getTags().get("env"));verify(clusterBackend).put(eq("my-cluster"), any(Cluster.class));@@ -624,31 +976,31 @@ class RedshiftServiceTest {void testDeleteTagsForCluster() {Cluster cluster = new Cluster();cluster.setClusterIdentifier("my-cluster");- cluster.setTags(new java.util.LinkedHashMap<>(java.util.Map.of("env", "test", "team", "data")));+ cluster.setTags(new LinkedHashMap<>(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"));+ service.deleteTags("arn:aws:redshift:us-east-1:111111111111:cluster:my-cluster", List.of("env"));- assertEquals(java.util.Map.of("team", "data"), cluster.getTags());+ assertEquals(Map.of("team", "data"), cluster.getTags());}@Testvoid testCreateTagsRejectsNonArnResourceName() {assertThrows(AwsException.class, () ->- service.createTags("my-cluster", java.util.Map.of("env", "test")));+ service.createTags("my-cluster", Map.of("env", "test")));}@Testvoid testCreateTagsRejectsUnknownResourceType() {assertThrows(AwsException.class, () ->- service.createTags("arn:aws:redshift:us-east-1:111111111111:reservednode:foo", java.util.Map.of("env", "test")));+ service.createTags("arn:aws:redshift:us-east-1:111111111111:reservednode:foo", Map.of("env", "test")));}@Testvoid testDescribeTagsForSpecificResource() {Cluster cluster = new Cluster();cluster.setClusterIdentifier("my-cluster");- cluster.setTags(new java.util.LinkedHashMap<>(java.util.Map.of("env", "test")));+ cluster.setTags(new LinkedHashMap<>(Map.of("env", "test")));when(clusterBackend.get("my-cluster")).thenReturn(Optional.of(cluster));List<RedshiftService.TaggedResource> tagged =@@ -664,14 +1016,14 @@ class RedshiftServiceTest {void testDescribeTagsScansAllResourcesOfType() {Cluster a = new Cluster();a.setClusterIdentifier("cluster-a");- a.setTags(new java.util.LinkedHashMap<>(java.util.Map.of("env", "prod")));+ a.setTags(new LinkedHashMap<>(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());+ b.setTags(new LinkedHashMap<>());+ when(clusterBackend.scan(any())).thenReturn(List.of(a, b));+ when(snapshotBackend.scan(any())).thenReturn(List.of());+ when(parameterGroupBackend.scan(any())).thenReturn(List.of());+ when(subnetGroupBackend.scan(any())).thenReturn(List.of());List<RedshiftService.TaggedResource> tagged = service.describeTags(null, "cluster", null);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.javaindex e6da56d53f..209b2bb62a 100644--- 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@@ -23,10 +23,15 @@ import io.github.hectorvent.floci.services.redshift.model.Cluster;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;+import java.io.ByteArrayInputStream;+import java.io.ByteArrayOutputStream;import java.io.Closeable;import java.io.InputStream;import java.nio.charset.StandardCharsets;+import java.nio.file.Files;+import java.nio.file.Path;import java.util.Map;+import com.github.dockerjava.api.command.CopyArchiveFromContainerCmd;import java.util.Optional;import static org.junit.jupiter.api.Assertions.assertEquals;@@ -65,6 +70,28 @@ class RedshiftContainerManagerTest {when(config.services().redshift().imageVersion()).thenReturn("postgres:16-alpine");when(config.services().redshift().dockerNetwork()).thenReturn(Optional.empty());+ // Default mock for execCreateCmd/execStartCmd/inspectExecCmd to make waitForReady succeed instantly+ ExecCreateCmd defaultCreateCmd = mock(ExecCreateCmd.class, org.mockito.Mockito.RETURNS_SELF);+ ExecCreateCmdResponse defaultCreateResponse = mock(ExecCreateCmdResponse.class);+ when(defaultCreateResponse.getId()).thenReturn("exec-default");+ when(defaultCreateCmd.exec()).thenReturn(defaultCreateResponse);+ when(dockerClient.execCreateCmd(anyString())).thenReturn(defaultCreateCmd);++ ExecStartCmd defaultStartCmd = mock(ExecStartCmd.class);+ when(defaultStartCmd.exec(any())).thenAnswer(invocation -> {+ @SuppressWarnings("unchecked")+ ResultCallback.Adapter<Frame> adapter = invocation.getArgument(0);+ adapter.onComplete();+ return adapter;+ });+ when(dockerClient.execStartCmd(anyString())).thenReturn(defaultStartCmd);++ InspectExecCmd defaultInspectCmd = mock(InspectExecCmd.class);+ InspectExecResponse defaultInspectResponse = mock(InspectExecResponse.class);+ when(defaultInspectResponse.getExitCodeLong()).thenReturn(0L);+ when(defaultInspectCmd.exec()).thenReturn(defaultInspectResponse);+ when(dockerClient.inspectExecCmd(anyString())).thenReturn(defaultInspectCmd);+manager = new RedshiftContainerManager(containerBuilder,lifecycleManager,@@ -79,7 +106,7 @@ class RedshiftContainerManagerTest {@Testvoid testTakeSnapshotContainerNotFound() {AwsException ex = assertThrows(AwsException.class, () ->- manager.takeSnapshot(ACCOUNT_ID, "non-existent-cluster", "admin", "dev", java.nio.file.Path.of("dummy.sql")));+ manager.takeSnapshot(ACCOUNT_ID, "non-existent-cluster", "admin", "dev", Path.of("dummy.sql")));assertEquals("ClusterNotFound", ex.getErrorCode());assertEquals(404, ex.getHttpStatus());}@@ -87,7 +114,7 @@ class RedshiftContainerManagerTest {@Testvoid testRestoreSnapshotContainerNotFound() {AwsException ex = assertThrows(AwsException.class, () ->- manager.restoreSnapshot(ACCOUNT_ID, "non-existent-cluster", "admin", "dev", java.nio.file.Path.of("dummy.sql")));+ manager.restoreSnapshot(ACCOUNT_ID, "non-existent-cluster", "admin", "dev", Path.of("dummy.sql")));assertEquals("ClusterNotFound", ex.getErrorCode());assertEquals(404, ex.getHttpStatus());}@@ -95,7 +122,7 @@ class RedshiftContainerManagerTest {@Testvoid testCreateSnapshotNullCluster() {AwsException ex = assertThrows(AwsException.class, () ->- manager.createSnapshot(ACCOUNT_ID, null, java.nio.file.Path.of("dummy.sql")));+ manager.createSnapshot(ACCOUNT_ID, null, Path.of("dummy.sql")));assertEquals("InvalidParameterValue", ex.getErrorCode());assertEquals(400, ex.getHttpStatus());}@@ -103,7 +130,7 @@ class RedshiftContainerManagerTest {@Testvoid testRestoreSnapshotNullCluster() {AwsException ex = assertThrows(AwsException.class, () ->- manager.restoreSnapshot(ACCOUNT_ID, (Cluster) null, java.nio.file.Path.of("dummy.sql")));+ manager.restoreSnapshot(ACCOUNT_ID, (Cluster) null, Path.of("dummy.sql")));assertEquals("InvalidParameterValue", ex.getErrorCode());assertEquals(400, ex.getHttpStatus());}@@ -143,9 +170,9 @@ class RedshiftContainerManagerTest {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);+ CopyArchiveFromContainerCmd copyCmd = mock(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();+ ByteArrayOutputStream bos = new 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);@@ -153,17 +180,17 @@ class RedshiftContainerManagerTest {tar.write(tarBytes);tar.closeArchiveEntry();}- when(copyCmd.exec()).thenReturn(new java.io.ByteArrayInputStream(bos.toByteArray()));+ when(copyCmd.exec()).thenReturn(new 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");+ Path tempFile = Files.createTempFile("test-take-snapshot", ".sql");try {manager.takeSnapshot(ACCOUNT_ID, "test-cluster", "admin", "dev",tempFile);- String dump = java.nio.file.Files.readString(tempFile);+ String dump = Files.readString(tempFile);assertTrue(dump.contains("PostgreSQL dump"));assertTrue(dump.contains("CREATE TABLE foo"));} finally {- java.nio.file.Files.deleteIfExists(tempFile);+ Files.deleteIfExists(tempFile);}}@@ -200,7 +227,7 @@ class RedshiftContainerManagerTest {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")));+ manager.takeSnapshot(ACCOUNT_ID, "test-cluster", "admin", "dev",Path.of("dummy.sql")));assertEquals("InternalFailure", ex.getErrorCode());assertEquals(500, ex.getHttpStatus());}@@ -215,8 +242,8 @@ class RedshiftContainerManagerTest {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);+ manager.restoreSnapshot(ACCOUNT_ID, "test-cluster", "admin", "dev",Path.of("non-existent-dump.sql"));+ manager.restoreSnapshot(ACCOUNT_ID, "test-cluster", "admin", "dev",(Path) null);}@Test@@ -254,13 +281,13 @@ class RedshiftContainerManagerTest {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");+ Path tempFile = 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");+ verify(dockerClient, org.mockito.Mockito.times(2)).execCreateCmd("cont-123");} finally {- java.nio.file.Files.deleteIfExists(tempFile);+ Files.deleteIfExists(tempFile);}}@@ -363,7 +390,7 @@ class RedshiftContainerManagerTest {manager.alterUserPassword(ACCOUNT_ID, "test-cluster", "admin", "NewSecret1");- verify(dockerClient).execCreateCmd("cont-123");+ verify(dockerClient, org.mockito.Mockito.times(2)).execCreateCmd("cont-123");}@Testdiff --git a/src/test/java/io/github/hectorvent/floci/services/redshift/model/ClusterTest.java b/src/test/java/io/github/hectorvent/floci/services/redshift/model/ClusterTest.javanew file mode 100644index 0000000000..dfc7028f6e--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/redshift/model/ClusterTest.java@@ -0,0 +1,45 @@+package io.github.hectorvent.floci.services.redshift.model;++import com.fasterxml.jackson.databind.ObjectMapper;+import org.junit.jupiter.api.Test;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNull;++class ClusterTest {++ @Test+ void proxyAndContainerFieldsDefaultToEmpty() {+ Cluster cluster = new Cluster();+ assertNull(cluster.getContainerHost());+ assertEquals(0, cluster.getContainerPort());+ assertEquals(0, cluster.getProxyPort());+ }++ @Test+ void proxyAndContainerFieldsRoundTripThroughJackson() throws Exception {+ ObjectMapper mapper = new ObjectMapper();+ Cluster cluster = new Cluster();+ cluster.setClusterIdentifier("c1");+ cluster.setContainerHost("172.17.0.4");+ cluster.setContainerPort(32771);+ cluster.setProxyPort(7100);++ Cluster restored = mapper.readValue(mapper.writeValueAsString(cluster), Cluster.class);++ assertEquals("172.17.0.4", restored.getContainerHost());+ assertEquals(32771, restored.getContainerPort());+ assertEquals(7100, restored.getProxyPort());+ }++ @Test+ void jsonWithoutNewFieldsDeserializesWithDefaults() throws Exception {+ ObjectMapper mapper = new ObjectMapper();+ Cluster restored = mapper.readValue(+ "{\"clusterIdentifier\":\"legacy\",\"clusterStatus\":\"available\"}", Cluster.class);++ assertNull(restored.getContainerHost());+ assertEquals(0, restored.getContainerPort());+ assertEquals(0, restored.getProxyPort());+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/redshift/proxy/RedshiftAuthProxyTest.java b/src/test/java/io/github/hectorvent/floci/services/redshift/proxy/RedshiftAuthProxyTest.javanew file mode 100644index 0000000000..804e5d3a08--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/redshift/proxy/RedshiftAuthProxyTest.java@@ -0,0 +1,205 @@+package io.github.hectorvent.floci.services.redshift.proxy;++import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.services.acm.CertificateGenerator;+import io.github.hectorvent.floci.services.rds.proxy.RdsProxyTlsCertificates;+import io.github.hectorvent.floci.services.rds.proxy.RdsSigV4Validator;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.io.TempDir;++import java.io.IOException;+import java.io.InputStream;+import java.io.OutputStream;+import java.lang.reflect.Field;+import java.net.ServerSocket;+import java.net.Socket;+import java.nio.charset.StandardCharsets;+import java.nio.file.Path;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.TimeUnit;+import java.util.concurrent.atomic.AtomicReference;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.when;++class RedshiftAuthProxyTest {++ @TempDir+ Path tempDir;++ private RedshiftAuthProxy proxy;+ private ServerSocket fakeBackend;++ @AfterEach+ void tearDown() throws IOException {+ if (proxy != null) {+ proxy.stop();+ }+ if (fakeBackend != null && !fakeBackend.isClosed()) {+ fakeBackend.close();+ }+ }++ @Test+ void bridgesClientBytesToTheBackendAfterASuccessfulPasswordAuth() throws Exception {+ // The fake backend accepts one connection and records the first bytes it receives+ // from the proxy (the forwarded PostgreSQL startup packet).+ fakeBackend = new ServerSocket(0);+ AtomicReference<byte[]> seenByBackend = new AtomicReference<>();+ CountDownLatch backendDone = new CountDownLatch(1);+ Thread.ofVirtual().start(() -> {+ try (Socket s = fakeBackend.accept()) {+ InputStream in = s.getInputStream();+ byte[] buf = new byte[256];+ int n = in.read(buf);+ byte[] out = new byte[Math.max(n, 0)];+ System.arraycopy(buf, 0, out, 0, out.length);+ seenByBackend.set(out);+ backendDone.countDown();+ } catch (IOException ignored) {+ backendDone.countDown();+ }+ });++ int proxyPort = freePort();+ proxy = new RedshiftAuthProxy("111111111111:c1", "localhost", fakeBackend.getLocalPort(),+ "admin", "Secret123", "dev",+ mock(RdsSigV4Validator.class), realTls(), (user, pw) -> true);+ proxy.start(proxyPort);++ try (Socket client = new Socket("localhost", proxyPort)) {+ // Minimal PostgreSQL v3 startup: length(4) + protocol(4) + "user\0admin\0\0"+ OutputStream out = client.getOutputStream();+ byte[] params = "user\0admin\0\0".getBytes(StandardCharsets.UTF_8);+ int len = 8 + params.length;+ out.write(new byte[]{(byte) (len >>> 24), (byte) (len >>> 16), (byte) (len >>> 8), (byte) len});+ out.write(new byte[]{0, 3, 0, 0}); // protocol 196608+ out.write(params);+ out.flush();++ // Read the AuthenticationCleartextPassword request ('R') and reply with a password message.+ InputStream in = client.getInputStream();+ assertEquals('R', in.read());+ in.readNBytes(7); // remaining length(4) + auth code(3 of the 4-byte int)++ OutputStream pw = client.getOutputStream();+ byte[] pwBytes = "Secret123\0".getBytes(StandardCharsets.UTF_8);+ pw.write('p');+ int pwLen = 4 + pwBytes.length;+ pw.write(new byte[]{(byte) (pwLen >>> 24), (byte) (pwLen >>> 16), (byte) (pwLen >>> 8), (byte) pwLen});+ pw.write(pwBytes);+ pw.flush();++ assertTrue(backendDone.await(5, TimeUnit.SECONDS), "backend never saw the forwarded startup packet");+ byte[] forwarded = seenByBackend.get();+ assertTrue(forwarded != null && forwarded.length > 0, "proxy forwarded no bytes to the backend");+ }+ }++ @Test+ void closesTheBackendConnectionWhenTheClientDropsMidHandshake() throws Exception {+ fakeBackend = new ServerSocket(0);+ CountDownLatch backendClosed = new CountDownLatch(1);+ Thread.ofVirtual().start(() -> {+ try (Socket s = fakeBackend.accept()) {+ // The proxy opens this before reading the client's startup packet; if the+ // client vanishes, the proxy must close this too — surfaced here as EOF.+ InputStream in = s.getInputStream();+ while (in.read() != -1) {+ // drain until the proxy closes its end+ }+ backendClosed.countDown();+ } catch (IOException e) {+ backendClosed.countDown();+ }+ });++ int proxyPort = freePort();+ proxy = new RedshiftAuthProxy("111111111111:c1", "localhost", fakeBackend.getLocalPort(),+ "admin", "Secret123", "dev",+ mock(RdsSigV4Validator.class), realTls(), (user, pw) -> true);+ proxy.start(proxyPort);++ // Connect, then drop without ever sending a startup packet.+ new Socket("localhost", proxyPort).close();++ assertTrue(backendClosed.await(5, TimeUnit.SECONDS),+ "proxy leaked the backend connection after the client dropped");+ }++ @Test+ void startRetriesTheBindWhileThePortIsMomentarilyStillInUse() throws Exception {+ fakeBackend = new ServerSocket(0);+ int proxyPort = freePort();++ // Hold the port, mimicking a just-closed predecessor the kernel has not released+ // yet; free it shortly after so the retrying bind can finally take it.+ ServerSocket squatter = new ServerSocket();+ squatter.setReuseAddress(true);+ squatter.bind(new java.net.InetSocketAddress(proxyPort));+ Thread.ofVirtual().start(() -> {+ try {+ Thread.sleep(200);+ squatter.close();+ } catch (Exception ignored) {+ }+ });++ proxy = new RedshiftAuthProxy("111111111111:c1", "localhost", fakeBackend.getLocalPort(),+ "admin", "Secret123", "dev",+ mock(RdsSigV4Validator.class), realTls(), (user, pw) -> true);+ proxy.start(proxyPort); // must not throw despite the port being busy at first++ assertTrue(portAccepts(proxyPort), "proxy never bound the port after the squatter released it");+ }++ @Test+ void updateMasterPasswordSwapsTheSnapshotUsedForNewConnections() throws Exception {+ fakeBackend = new ServerSocket(0);+ int proxyPort = freePort();+ proxy = new RedshiftAuthProxy("111111111111:c1", "localhost", fakeBackend.getLocalPort(),+ "admin", "old", "dev",+ mock(RdsSigV4Validator.class), realTls(), (user, pw) -> true);+ proxy.start(proxyPort);++ proxy.updateMasterPassword("rotated");++ Field f = RedshiftAuthProxy.class.getDeclaredField("masterPassword");+ f.setAccessible(true);+ assertEquals("rotated", f.get(proxy));+ }++ private RdsProxyTlsCertificates realTls() {+ // The real bean generates a self-signed cert on demand; no Docker or network needed.+ EmulatorConfig.StorageConfig storage = mock(EmulatorConfig.StorageConfig.class);+ when(storage.persistentPath()).thenReturn(tempDir.toString());+ EmulatorConfig config = mock(EmulatorConfig.class);+ when(config.storage()).thenReturn(storage);+ return new RdsProxyTlsCertificates(config, new CertificateGenerator());+ }++ private static int freePort() throws IOException {+ try (ServerSocket s = new ServerSocket(0)) {+ return s.getLocalPort();+ }+ }++ private static boolean portAccepts(int port) {+ for (int attempt = 0; attempt < 50; attempt++) {+ try (Socket ignored = new Socket("localhost", port)) {+ return true;+ } catch (IOException e) {+ try {+ Thread.sleep(20);+ } catch (InterruptedException ie) {+ Thread.currentThread().interrupt();+ return false;+ }+ }+ }+ return false;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/redshift/proxy/RedshiftProxyManagerTest.java b/src/test/java/io/github/hectorvent/floci/services/redshift/proxy/RedshiftProxyManagerTest.javanew file mode 100644index 0000000000..0c07c91cb7--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/redshift/proxy/RedshiftProxyManagerTest.java@@ -0,0 +1,287 @@+package io.github.hectorvent.floci.services.redshift.proxy;++import io.github.hectorvent.floci.services.rds.proxy.RdsProxyTlsCertificates;+import io.github.hectorvent.floci.services.rds.proxy.RdsSigV4Validator;+import org.junit.jupiter.api.Test;++import java.io.IOException;+import java.lang.reflect.Field;+import java.net.InetSocketAddress;+import java.net.ServerSocket;+import java.util.concurrent.ConcurrentHashMap;++import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertSame;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.junit.jupiter.api.Assertions.fail;+import static org.mockito.Mockito.doNothing;+import static org.mockito.Mockito.doThrow;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.times;+import static org.mockito.Mockito.verify;++class RedshiftProxyManagerTest {++ private RedshiftProxyManager newManager() {+ return new RedshiftProxyManager(+ mock(RdsSigV4Validator.class), mock(RdsProxyTlsCertificates.class));+ }++ private static void start(RedshiftProxyManager manager, String key, int proxyPort) {+ manager.startProxy(key, proxyPort, "localhost", 1, "localhost",+ "admin", "secret", "dev", (user, password) -> true);+ }++ @Test+ void startRegistersTheKeyAndBindsThePort() throws Exception {+ RedshiftProxyManager manager = newManager();+ int port = availablePort();+ try {+ start(manager, "111111111111:c1", port);+ assertTrue(registry(manager).containsKey("111111111111:c1"));+ assertPortUnavailable(port);+ } finally {+ manager.stopAll();+ }+ }++ @Test+ void stopProxyRemovesTheKeyAndReleasesThePort() throws Exception {+ RedshiftProxyManager manager = newManager();+ int port = availablePort();+ start(manager, "k", port);++ manager.stopProxy("k");++ assertFalse(registry(manager).containsKey("k"));+ assertPortAvailable(port);+ }++ @Test+ void startingAnExistingKeyStopsTheOldProxyAndInstallsTheNewOne() throws IOException {+ RedshiftProxyManager manager = newManager();+ int firstPort = availablePort();+ try {+ start(manager, "k", firstPort);+ int replacementPort = availablePort();++ start(manager, "k", replacementPort);++ assertPortAvailable(firstPort);+ assertPortUnavailable(replacementPort);+ } finally {+ manager.stopAll();+ }+ }+++ @Test+ void updateMasterPasswordForUnknownKeyIsANoOp() {+ RedshiftProxyManager manager = newManager();+ assertDoesNotThrow(() -> manager.updateMasterPassword("missing", "rotated"));+ }++ @Test+ void updateMasterPasswordSwapsTheRunningSnapshot() throws Exception {+ RedshiftProxyManager manager = newManager();+ int port = availablePort();+ try {+ start(manager, "k", port);+ manager.updateMasterPassword("k", "rotated");+ assertEquals("rotated", masterPassword(registry(manager).get("k")));+ } finally {+ manager.stopAll();+ }+ }++ @Test+ void stopAllReleasesEveryListenerAndIsIdempotent() throws IOException {+ RedshiftProxyManager manager = newManager();+ int a = availablePort();+ start(manager, "a", a);+ int b = availablePort();+ start(manager, "b", b);++ manager.stopAll();++ assertPortAvailable(a);+ assertPortAvailable(b);+ assertDoesNotThrow(manager::stopAll);+ }++ @Test+ void failedStartOnABusyPortLeavesNoRegistryEntry() throws Exception {+ RedshiftProxyManager manager = newManager();+ try (ServerSocket occupied = new ServerSocket(0)) {+ assertThrows(RuntimeException.class,+ () -> start(manager, "k", occupied.getLocalPort()));+ assertFalse(registry(manager).containsKey("k"));+ } finally {+ manager.stopAll();+ }+ }++ @Test+ void stopProxyRetainsTheProxyWhenItsListenerCloseFails() throws Exception {+ RedshiftProxyManager manager = newManager();+ RedshiftAuthProxy badProxy = mock(RedshiftAuthProxy.class);+ doThrow(new RuntimeException("close failed")).when(badProxy).stop();+ registry(manager).put("k", badProxy);++ assertThrows(RuntimeException.class, () -> manager.stopProxy("k"));++ // Proxy stays registered so a later cleanup attempt can still reach it and retry.+ assertSame(badProxy, registry(manager).get("k"));+ }++ @Test+ void stopProxyRetryClosesTheSameProxyAndThenDeregistersIt() throws Exception {+ RedshiftProxyManager manager = newManager();+ RedshiftAuthProxy proxy = mock(RedshiftAuthProxy.class);+ doThrow(new RuntimeException("close failed")).doNothing().when(proxy).stop();+ registry(manager).put("k", proxy);++ assertThrows(RuntimeException.class, () -> manager.stopProxy("k"));+ assertDoesNotThrow(() -> manager.stopProxy("k"));++ assertFalse(registry(manager).containsKey("k"));+ verify(proxy, times(2)).stop();+ }++ @Test+ void stopProxyRefusesWhileAFailedStartupListenerStillCannotBeClosed() throws Exception {+ RedshiftProxyManager manager = newManager();+ RedshiftAuthProxy stuck = mock(RedshiftAuthProxy.class);+ doThrow(new RuntimeException("close failed")).when(stuck).stop();+ unclosable(manager).put("k", stuck);++ assertThrows(RuntimeException.class, () -> manager.stopProxy("k"));++ // Reference retained so the next attempt can retry the close.+ assertSame(stuck, unclosable(manager).get("k"));+ }++ @Test+ void stopProxyKeepsRetryingTheSameUnclosableListenerOnEveryCall() throws Exception {+ RedshiftProxyManager manager = newManager();+ RedshiftAuthProxy stuck = mock(RedshiftAuthProxy.class);+ doThrow(new RuntimeException("close failed")).when(stuck).stop();+ unclosable(manager).put("k", stuck);++ assertThrows(RuntimeException.class, () -> manager.stopProxy("k"));+ assertThrows(RuntimeException.class, () -> manager.stopProxy("k"));++ verify(stuck, times(2)).stop();+ assertTrue(unclosable(manager).containsKey("k"));+ }++ @Test+ void stopProxyRecoversTheUnclosableEntryOnceTheListenerFinallyCloses() throws Exception {+ RedshiftProxyManager manager = newManager();+ RedshiftAuthProxy recovering = mock(RedshiftAuthProxy.class);+ doThrow(new RuntimeException("close failed")).doNothing().when(recovering).stop();+ unclosable(manager).put("k", recovering);++ assertThrows(RuntimeException.class, () -> manager.stopProxy("k"));+ assertDoesNotThrow(() -> manager.stopProxy("k"));++ assertFalse(unclosable(manager).containsKey("k"));+ }++ @Test+ void startProxyLeavesAnUnclosableEntryInPlace() throws Exception {+ RedshiftProxyManager manager = newManager();+ RedshiftAuthProxy stuck = mock(RedshiftAuthProxy.class);+ doThrow(new RuntimeException("close failed")).when(stuck).stop();+ unclosable(manager).put("k", stuck);+ int port = availablePort();+ try {+ // A fresh start for the same key must not silently drop the leaked listener.+ start(manager, "k", port);+ assertSame(stuck, unclosable(manager).get("k"));+ } finally {+ manager.stopAll();+ }+ }++ @Test+ void stopAllAlsoDrainsUnclosableProxies() throws Exception {+ RedshiftProxyManager manager = newManager();+ RedshiftAuthProxy recovered = mock(RedshiftAuthProxy.class);+ RedshiftAuthProxy stillStuck = mock(RedshiftAuthProxy.class);+ doThrow(new RuntimeException("close failed")).when(stillStuck).stop();+ unclosable(manager).put("a", recovered);+ unclosable(manager).put("b", stillStuck);++ manager.stopAll();++ assertFalse(unclosable(manager).containsKey("a"));+ assertTrue(unclosable(manager).containsKey("b"));+ }++ // --- reflection + port helpers copied from RdsProxyManagerTest ---++ @SuppressWarnings("unchecked")+ private static ConcurrentHashMap<String, RedshiftAuthProxy> registry(RedshiftProxyManager manager)+ throws Exception {+ Field field = RedshiftProxyManager.class.getDeclaredField("proxies");+ field.setAccessible(true);+ return (ConcurrentHashMap<String, RedshiftAuthProxy>) field.get(manager);+ }++ @SuppressWarnings("unchecked")+ private static ConcurrentHashMap<String, RedshiftAuthProxy> unclosable(RedshiftProxyManager manager)+ throws Exception {+ Field field = RedshiftProxyManager.class.getDeclaredField("unclosableProxies");+ field.setAccessible(true);+ return (ConcurrentHashMap<String, RedshiftAuthProxy>) field.get(manager);+ }++ private static String masterPassword(RedshiftAuthProxy proxy) throws Exception {+ Field field = RedshiftAuthProxy.class.getDeclaredField("masterPassword");+ field.setAccessible(true);+ return (String) field.get(proxy);+ }++ private static int availablePort() throws IOException {+ try (ServerSocket socket = new ServerSocket(0)) {+ return socket.getLocalPort();+ }+ }++ private static void assertPortAvailable(int port) {+ IOException last = null;+ for (int attempt = 0; attempt < 50; attempt++) {+ try (ServerSocket ignored = reusableSocket(port)) {+ return;+ } catch (IOException e) {+ last = e;+ }+ try {+ Thread.sleep(10);+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ fail("Interrupted waiting for port " + port, e);+ }+ }+ fail("Proxy port " + port + " was not released", last);+ }++ private static void assertPortUnavailable(int port) {+ assertThrows(IOException.class, () -> {+ try (ServerSocket ignored = reusableSocket(port)) {+ // active proxy owns this listener+ }+ });+ }++ private static ServerSocket reusableSocket(int port) throws IOException {+ ServerSocket socket = new ServerSocket();+ socket.setReuseAddress(true);+ socket.bind(new InetSocketAddress(port));+ return socket;+ }+}diff --git a/src/test/resources/application.yml b/src/test/resources/application.ymlindex efffba7e3e..0954f2fcaf 100644--- a/src/test/resources/application.yml+++ b/src/test/resources/application.yml@@ -167,6 +167,8 @@ floci:enabled: truedefault-port: 5439image-version: postgres:15-alpine+ proxy-base-port: 7100+ proxy-max-port: 7199rds:enabled: truemock: false