Light, fluffy, and always free - The AWS Local Emulator alternative
feat(redshift): emulate GetClusterCredentials and GetClusterCredentialsWithIAM (#3273)
Vũ Thế Huy6b17ef2b1c13
diff --git a/compatibility-tests/sdk-test-java/src/test/java/io/github/hectorvent/floci/compat/RedshiftTest.java b/compatibility-tests/sdk-test-java/src/test/java/io/github/hectorvent/floci/compat/RedshiftTest.javaindex 69bd877dc2..a0da478d40 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@@ -14,6 +14,8 @@ import software.amazon.awssdk.services.redshift.model.DescribeClustersRequest;import software.amazon.awssdk.services.redshift.model.DescribeClustersResponse;import software.amazon.awssdk.services.redshift.model.DeleteClusterRequest;import software.amazon.awssdk.services.redshift.model.DeleteClusterResponse;+import software.amazon.awssdk.services.redshift.model.GetClusterCredentialsResponse;+import software.amazon.awssdk.services.redshift.model.GetClusterCredentialsWithIamResponse;import software.amazon.awssdk.services.s3.S3Client;import software.amazon.awssdk.services.s3.model.CreateBucketRequest;import software.amazon.awssdk.services.s3.model.GetObjectRequest;@@ -152,6 +154,39 @@ public class RedshiftTest {@Test@Order(3)+ public void testGetClusterCredentialsReturnsTemporaryCredentials() throws Exception {+ RedshiftClient client = getClient();+ GetClusterCredentialsResponse res = withRetry(() -> client.getClusterCredentials(b -> b+ .clusterIdentifier("test-cluster")+ .dbUser("analyst")+ .dbName("dev")+ .durationSeconds(900)));++ assertNotNull(res.dbUser());+ assertTrue(res.dbUser().contains("analyst"));+ assertNotNull(res.dbPassword());+ assertTrue(!res.dbPassword().isBlank());+ assertNotNull(res.expiration());+ }++ @Test+ @Order(4)+ public void testGetClusterCredentialsWithIamReturnsIamPrefixedUser() throws Exception {+ RedshiftClient client = getClient();+ GetClusterCredentialsWithIamResponse res = withRetry(() -> client.getClusterCredentialsWithIAM(b -> b+ .clusterIdentifier("test-cluster")+ .dbName("dev")+ .durationSeconds(900)));++ assertNotNull(res.dbUser());+ assertTrue(res.dbUser().startsWith("IAM"));+ assertNotNull(res.dbPassword());+ assertTrue(!res.dbPassword().isBlank());+ assertNotNull(res.expiration());+ }++ @Test+ @Order(5)public void testDeleteCluster() throws Exception {RedshiftClient client = getClient();DeleteClusterResponse res = withRetry(() -> client.deleteCluster(DeleteClusterRequest.builder()diff --git a/docs/services/index.md b/docs/services/index.mdindex b171d81282..853e04ed74 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -68,7 +68,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac| [Lake Formation](lakeformation.md) | `POST /<Action>` | REST JSON | 16 || [Neptune](neptune.md) | `POST /` with `Action=` param + Gremlin TCP proxy | Query + WebSocket | 14 || [DocumentDB](docdb.md) | `POST /` with `Action=` param + MongoDB container | Query + MongoDB wire | 8 |-| [Redshift](redshift.md) | `POST /` with `Action=` param + PostgreSQL container | Query + PostgreSQL wire | 21 |+| [Redshift](redshift.md) | `POST /` with `Action=` param + PostgreSQL container | Query + PostgreSQL wire | 23 || [Redshift Data API](redshift-data.md) | `POST /` + `X-Amz-Target: RedshiftData.*` | JSON 1.1 | 11 || [EMR](emr.md) | `POST /` + `X-Amz-Target: ElasticMapReduce.*` | JSON 1.1 | 24 || [EMR Serverless](emr-serverless.md) | `/applications/*` | REST JSON | 7 |diff --git a/docs/services/redshift-data.md b/docs/services/redshift-data.mdindex fa8b6a28d2..9d50bcfaab 100644--- a/docs/services/redshift-data.md+++ b/docs/services/redshift-data.md@@ -36,7 +36,7 @@ For the upstream API shape, see the AWS documentation:A request identifies its target cluster one of two ways:-- **`ClusterIdentifier` + `DbUser` + `Database`.** The `DbUser` must be the cluster master user. Floci connects directly to the container, so a non-master `DbUser` needs a real PostgreSQL role; until `GetClusterCredentials` is emulated, a non-master `DbUser` returns `ValidationException`.+- **`ClusterIdentifier` + `DbUser` + `Database`.** The `DbUser` is the cluster master, or the prefixed name returned by `GetClusterCredentials` / `GetClusterCredentialsWithIAM` (for example `IAM:analyst`) while that credential is unexpired. Floci connects to the container as the cluster master in both cases. Any other `DbUser` returns `ValidationException`.- **`SecretArn` + `ClusterIdentifier` + `Database`.** The secret must be a local Secrets Manager secret holding JSON credentials (`username` or `user`, plus `password`). A cross-region `SecretArn` is rejected.`WorkgroupName` (Amazon Redshift Serverless) is rejected with `ValidationException`. Redshift Serverless is not emulated.diff --git a/docs/services/redshift.md b/docs/services/redshift.mdindex c74f9cbd6f..32c24ca77f 100644--- a/docs/services/redshift.md+++ b/docs/services/redshift.md@@ -38,6 +38,8 @@ For running SQL without a PostgreSQL wire connection (the way Lambda and Step Fu| `DeleteClusterSubnetGroup` | Remove a subnet group || `ModifyCluster` | Update node type, parameter group, security groups, or the master password || `RebootCluster` | Restart a cluster's container |+| `GetClusterCredentials` | Issue a short-lived DbUser / DbPassword pair the auth proxy and Data API accept for a non-master user |+| `GetClusterCredentialsWithIAM` | Issue short-lived credentials with the DbUser derived from the caller's IAM identity |<!-- floci:actions:end -->## Configuration@@ -177,6 +179,7 @@ order) through its own S3 service and streams the rows into the backing PostgreS- The rewrite is textual (regex-based). It masks single-quoted string literals first, so `DEFAULT` / `CHECK` string values are safe, but it is **not** comment-aware and does not recognize escape strings (`E'...'`): an apostrophe inside a `--` or `/* */` comment can make the rewrite skip a Redshift clause. That fails safe: the statement then reaches PostgreSQL, which returns its own syntax error, but avoid apostrophes-in-comments in `CREATE TABLE` / `ALTER TABLE`.- A `rewrite` failure or any statement the interceptor does not recognize is forwarded unmodified (fail-open); PostgreSQL then rejects the Redshift-only syntax itself.- Simple Query ('Q') messages larger than 16 MiB bypass the interceptor and stream through verbatim without heap buffering; non-query traffic also streams through with no size limit.+- `GetClusterCredentials` / `GetClusterCredentialsWithIAM` mint a short-lived password held in memory (lost on restart). As in AWS, `GetClusterCredentials` prefixes the returned `DbUser` with `IAM:` when `AutoCreate` is false and `IAMA:` when it is true; that prefixed name is what the auth proxy and Data API accept. The returned `DbUser` is nominal: the session runs as the cluster master, not a distinct PostgreSQL role, so `current_user`, `GRANT`, and object ownership are the master's.### UNLOAD to S3@@ -220,5 +223,5 @@ the result to S3 as one or more objects under `<prefix>`.- 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.+- The auth proxy validates the master user's password and any live `GetClusterCredentials` credential. Other non-master users pass straight through to PostgreSQL, which remains the authority for their credentials.+- IAM database authentication over the wire, 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 8e16db4c42..86d88ed727 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -1312,6 +1312,11 @@ public interface EmulatorConfig {// Hostname clients use to reach a cluster endpoint. Empty -> resolved from// DockerHostResolver (falls back to "localhost").Optional<String> endpointHost();++ // Default lifetime for GetClusterCredentials / GetClusterCredentialsWithIAM when+ // DurationSeconds is omitted. AWS allows 900 to 3600.+ @WithDefault("900")+ int defaultCredentialDurationSeconds();}interface RdsServiceConfig {diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.javaindex 0cb0bd9300..78241e481a 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java@@ -356,7 +356,7 @@ public class AwsQueryController {: elbV2QueryHandler.handle(action, formParams, region);case "autoscaling" -> autoScalingQueryHandler.handle(action, formParams, region);case "elasticbeanstalk" -> elasticBeanstalkQueryHandler.handle(action, formParams, region);- case "redshift" -> redshiftQueryHandler.handle(action, formParams);+ case "redshift" -> redshiftQueryHandler.handle(action, formParams, authorization);default -> xmlErrorResponse("UnknownService","Unknown or unsupported service: " + service, 400);};@@ -605,7 +605,8 @@ public class AwsQueryController {"CreateClusterParameterGroup", "DescribeClusterParameterGroups", "DescribeClusterParameters", "DeleteClusterParameterGroup","ModifyClusterParameterGroup","CreateClusterSubnetGroup", "DescribeClusterSubnetGroups", "ModifyClusterSubnetGroup", "DeleteClusterSubnetGroup",- "CreateTags", "DeleteTags", "DescribeTags"+ "CreateTags", "DeleteTags", "DescribeTags",+ "GetClusterCredentials", "GetClusterCredentialsWithIAM");private String resolveService(String authorization, String action) {diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/proxy/PasswordValidator.java b/src/main/java/io/github/hectorvent/floci/services/rds/proxy/PasswordValidator.javaindex bc4a36812f..87e228d39d 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/proxy/PasswordValidator.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/proxy/PasswordValidator.java@@ -1,6 +1,17 @@package io.github.hectorvent.floci.services.rds.proxy;@FunctionalInterface- public interface PasswordValidator {- boolean validate(String username, String password);- }\ No newline at end of file+public interface PasswordValidator {++ AuthResult validate(String username, String password);++ /**+ * REJECT : refuse the client.+ * PASSTHROUGH : the proxy does not vouch for this user; forward the+ * client's own credentials so the backend enforces them+ * (legacy non-master behaviour).+ * MASTER_EQUIVALENT: the proxy has validated the client; open the backend+ * connection as the cluster master.+ */+ enum AuthResult { REJECT, PASSTHROUGH, MASTER_EQUIVALENT }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/proxy/PostgresProtocolHandler.java b/src/main/java/io/github/hectorvent/floci/services/rds/proxy/PostgresProtocolHandler.javaindex 824d482298..60972bcbda 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/proxy/PostgresProtocolHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/proxy/PostgresProtocolHandler.java@@ -54,6 +54,26 @@ public class PostgresProtocolHandler {*/public record AuthenticatedSession(Socket client, String iamRole) {}+ /** The username/password the proxy opens the backend PostgreSQL connection with. */+ record BackendLogin(String user, String password) {}++ /**+ * Picks the backend login: the cluster master whenever the proxy is the authority for this+ * connection (an IAM token, the master user itself, or a client the validator vouched for),+ * otherwise the client's own credentials so the backend enforces its ACLs.+ */+ static BackendLogin resolveBackendLogin(boolean isMaster, boolean isIam,+ PasswordValidator.AuthResult result,+ String masterUsername, String masterPassword,+ String clientUsername, String clientPassword) {+ boolean useMaster = isIam || isMaster+ || result == PasswordValidator.AuthResult.MASTER_EQUIVALENT;+ if (useMaster) {+ return new BackendLogin(masterUsername, masterPassword);+ }+ return new BackendLogin(clientUsername, clientPassword);+ }+public static AuthenticatedSession authenticate(Socket client, Socket backend,String masterUsername, String masterPassword, String dbName,boolean iamEnabled, RdsSigV4Validator sigV4,@@ -84,12 +104,15 @@ public class PostgresProtocolHandler {// Phase 4: Validate credentials.// - IAM tokens: validated locally via SigV4.- // - Master user (plain password): validated at the proxy via passwordValidator, which- // reads from RdsService and therefore reflects modifyDBInstance password changes.- // - Non-master users: pass through — the backend is the authority for their passwords.+ // - Every non-IAM client: classified by passwordValidator into REJECT / PASSTHROUGH /+ // MASTER_EQUIVALENT. PASSTHROUGH keeps the legacy non-master behaviour (the backend is+ // the authority for the password); MASTER_EQUIVALENT means the proxy vouched for the+ // client, so the backend leg runs as the cluster master. The RDS validator reads from+ // RdsService, so a master login still reflects modifyDBInstance password changes.boolean isIam = iamEnabled && clientPassword.contains("X-Amz-Signature");boolean isMaster = masterUsername.equals(clientUsername);+ PasswordValidator.AuthResult authResult = PasswordValidator.AuthResult.PASSTHROUGH;if (isIam) {if (!sigV4.validate(clientPassword, clientUsername)) {sendErrorResponse(clientOut, "FATAL", "28P01",@@ -99,8 +122,9 @@ public class PostgresProtocolHandler {closeQuietly(backend);return null;}- } else if (isMaster) {- if (!passwordValidator.validate(clientUsername, clientPassword)) {+ } else {+ authResult = passwordValidator.validate(clientUsername, clientPassword);+ if (authResult == PasswordValidator.AuthResult.REJECT) {sendErrorResponse(clientOut, "FATAL", "28P01","password authentication failed for user \"" + clientUsername + "\"");clientOut.flush();@@ -113,13 +137,16 @@ public class PostgresProtocolHandler {// Phase 5: Connect to backend PostgreSQL.// IAM and master: use master credentials — the backend has the original container password// and is never updated directly, so the proxy always authenticates as master.- // Non-master: forward the client's own credentials so the backend enforces its own ACLs.+ // Non-master: forward the client's own credentials so the backend enforces its own ACLs,+ // unless the proxy vouched for the client (MASTER_EQUIVALENT).InputStream backendIn = backend.getInputStream();OutputStream backendOut = backend.getOutputStream();String effectiveDbName = resolveEffectiveDbName(startup.database(), dbName);- String backendUser = (isIam || isMaster) ? masterUsername : clientUsername;- String backendPass = (isIam || isMaster) ? masterPassword : clientPassword;+ BackendLogin backendLogin = resolveBackendLogin(isMaster, isIam, authResult,+ masterUsername, masterPassword, clientUsername, clientPassword);+ String backendUser = backendLogin.user();+ String backendPass = backendLogin.password();sendStartupToBackend(backendOut, backendUser, effectiveDbName);backendOut.flush();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 96bf83430a..205ba02f70 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@@ -27,7 +27,7 @@ public class RdsAuthProxy {private final DatabaseEngine engine;private final RdsSigV4Validator sigV4;private final RdsProxyTlsCertificates tlsCertificates;- private final PasswordValidator passwordValidator;+ private final MasterPasswordCheck passwordValidator;private volatile boolean running;private ServerSocket serverSocket;@@ -36,7 +36,7 @@ public class RdsAuthProxy {DatabaseEngine engine, boolean iamEnabled,String masterUsername, String masterPassword, String dbName,RdsSigV4Validator sigV4, RdsProxyTlsCertificates tlsCertificates,- PasswordValidator passwordValidator) {+ MasterPasswordCheck passwordValidator) {this.instanceId = instanceId;this.backendHost = backendHost;this.backendPort = backendPort;@@ -99,19 +99,30 @@ public class RdsAuthProxy {backend = new Socket(backendHost, backendPort);backend.setTcpNoDelay(true);+ // RDS only proxy-validates the master user; a non-master user passes through so the+ // backend enforces its own credentials.+ PasswordValidator authAdapter = (user, pass) -> {+ if (!masterUsername.equals(user)) {+ return PasswordValidator.AuthResult.PASSTHROUGH;+ }+ return passwordValidator.validate(user, pass)+ ? PasswordValidator.AuthResult.MASTER_EQUIVALENT+ : PasswordValidator.AuthResult.REJECT;+ };+switch (engine) {case POSTGRES -> {PostgresProtocolHandler.AuthenticatedSession session =PostgresProtocolHandler.authenticate(client, backend, masterUsername, masterPassword, dbName,- iamEnabled, sigV4, tlsCertificates, passwordValidator::validate);+ iamEnabled, sigV4, tlsCertificates, authAdapter);if (session != null) {PostgresProtocolHandler.bridge(session, backend);}}case MYSQL, MARIADB -> MySqlProtocolHandler.handleAuth(client, backend, masterUsername, masterPassword,- iamEnabled, sigV4, tlsCertificates, passwordValidator::validate);+ iamEnabled, sigV4, tlsCertificates, authAdapter);}} catch (Exception e) {LOG.debugv("RDS connection error for instance {0}: {1}", instanceId, e.getMessage());@@ -135,10 +146,12 @@ public class RdsAuthProxy {}/**- * Callback for password validation — implemented by RdsService.+ * Callback for master-password validation, implemented by RdsService. Returns true when the+ * supplied master credentials are current. Non-master users are never asked here: the backend+ * database is the authority for their passwords.*/@FunctionalInterface- public interface PasswordValidator {+ public interface MasterPasswordCheck {boolean validate(String username, String password);}}diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/proxy/RdsProxyManager.java b/src/main/java/io/github/hectorvent/floci/services/rds/proxy/RdsProxyManager.javaindex 75eb0f0ae3..778d1c35ae 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/proxy/RdsProxyManager.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/proxy/RdsProxyManager.java@@ -30,7 +30,7 @@ public class RdsProxyManager {int proxyPort, String backendHost, int backendPort,String advertisedHost,String masterUsername, String masterPassword, String dbName,- RdsAuthProxy.PasswordValidator passwordValidator) {+ RdsAuthProxy.MasterPasswordCheck passwordValidator) {tlsCertificates.ensureHost(advertisedHost);RdsAuthProxy proxy = new RdsAuthProxy(instanceId, backendHost, backendPort, engine, iamEnabled,diff --git a/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftCredentialBroker.java b/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftCredentialBroker.javanew file mode 100644index 0000000000..3ce5bf642e--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftCredentialBroker.java@@ -0,0 +1,108 @@+package io.github.hectorvent.floci.services.redshift;++import io.github.hectorvent.floci.core.common.Resettable;+import jakarta.enterprise.context.ApplicationScoped;++import java.security.SecureRandom;+import java.time.Instant;+import java.util.List;+import java.util.Optional;+import java.util.concurrent.ConcurrentHashMap;+import java.util.concurrent.CopyOnWriteArrayList;++/**+ * Holds the short-lived credentials minted by GetClusterCredentials /+ * GetClusterCredentialsWithIAM. No real PostgreSQL role is created: a live+ * credential is a signal to the auth proxy and the Data API resolver that the+ * connection should run as the cluster master (the DbUser is nominal).+ *+ * <p>AWS keeps every issued credential valid until its own expiry, so a second+ * call for the same DbUser does not invalidate the first: each key holds a list+ * of unexpired credentials.+ */+@ApplicationScoped+public class RedshiftCredentialBroker implements Resettable {++ public enum Match { MASTER_EQUIVALENT, REJECT, PASSTHROUGH }++ private static final String PASSWORD_ALPHABET =+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";+ private static final int PASSWORD_LENGTH = 32;++ private final SecureRandom random = new SecureRandom();+ private final ConcurrentHashMap<String, CopyOnWriteArrayList<TempCredential>> store = new ConcurrentHashMap<>();++ public TempCredential issue(String accountId, String clusterId, String dbUser,+ List<String> dbGroups, int durationSeconds) {+ String password = randomPassword();+ Instant expiresAt = Instant.now().plusSeconds(durationSeconds);+ List<String> groups = dbGroups == null ? List.of() : List.copyOf(dbGroups);+ TempCredential credential = new TempCredential(dbUser, password, expiresAt, groups);+ store.compute(key(accountId, clusterId, dbUser), (k, existing) -> {+ CopyOnWriteArrayList<TempCredential> list =+ existing == null ? new CopyOnWriteArrayList<>() : existing;+ list.removeIf(RedshiftCredentialBroker::isExpired);+ list.add(credential);+ return list;+ });+ return credential;+ }++ public Optional<TempCredential> resolve(String accountId, String clusterId, String dbUser) {+ return liveCredentials(key(accountId, clusterId, dbUser)).stream().findFirst();+ }++ public Match classify(String accountId, String clusterId, String username, String password) {+ List<TempCredential> live = liveCredentials(key(accountId, clusterId, username));+ if (live.isEmpty()) {+ return Match.PASSTHROUGH;+ }+ return live.stream().anyMatch(c -> c.password().equals(password))+ ? Match.MASTER_EQUIVALENT+ : Match.REJECT;+ }++ /**+ * Drops every credential minted for a cluster. Called when a cluster is deleted so a+ * later cluster created with the same identifier does not inherit master-equivalent+ * access from a stale credential.+ */+ public void revokeCluster(String accountId, String clusterId) {+ String prefix = accountId + ":" + clusterId + ":";+ store.keySet().removeIf(k -> k.startsWith(prefix));+ }++ @Override+ public void clear() {+ store.clear();+ }++ // Package-private hook for tests: number of unexpired credentials held for a DbUser.+ int liveCredentialCountForTesting(String accountId, String clusterId, String dbUser) {+ return liveCredentials(key(accountId, clusterId, dbUser)).size();+ }++ private List<TempCredential> liveCredentials(String key) {+ CopyOnWriteArrayList<TempCredential> list = store.get(key);+ if (list == null) {+ return List.of();+ }+ return list.stream().filter(c -> !isExpired(c)).toList();+ }++ private static boolean isExpired(TempCredential credential) {+ return !credential.expiresAt().isAfter(Instant.now());+ }++ private String randomPassword() {+ StringBuilder sb = new StringBuilder(PASSWORD_LENGTH);+ for (int i = 0; i < PASSWORD_LENGTH; i++) {+ sb.append(PASSWORD_ALPHABET.charAt(random.nextInt(PASSWORD_ALPHABET.length())));+ }+ return sb.toString();+ }++ private static String key(String accountId, String clusterId, String dbUser) {+ return accountId + ":" + clusterId + ":" + dbUser;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftIamDbUserResolver.java b/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftIamDbUserResolver.javanew file mode 100644index 0000000000..b322fcbab6--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftIamDbUserResolver.java@@ -0,0 +1,53 @@+package io.github.hectorvent.floci.services.redshift;++import io.github.hectorvent.floci.core.common.AccountResolver;+import io.github.hectorvent.floci.services.iam.IamService;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;++import java.util.Optional;++/**+ * Derives the Redshift Data API DbUser name for GetClusterCredentialsWithIAM from+ * the caller's IAM identity: an IAM user becomes "IAM:<name>", an assumed role+ * becomes "IAMR:<role>". When the caller cannot be resolved (for example a bare+ * test key with no registered identity) the call still succeeds with a fixed+ * fallback so local and CI flows are not blocked.+ */+@ApplicationScoped+public class RedshiftIamDbUserResolver {++ private static final Logger LOG = Logger.getLogger(RedshiftIamDbUserResolver.class);+ private static final String FALLBACK_DB_USER = "IAMR:floci";++ private final IamService iamService;+ private final AccountResolver accountResolver;++ @Inject+ public RedshiftIamDbUserResolver(IamService iamService, AccountResolver accountResolver) {+ this.iamService = iamService;+ this.accountResolver = accountResolver;+ }++ public String resolveDbUser(String authorizationHeader) {+ String accessKeyId = accountResolver.extractAccessKeyId(authorizationHeader);+ Optional<String> arn = iamService.resolveCallerArn(accessKeyId);+ if (arn.isEmpty()) {+ LOG.warnv("GetClusterCredentialsWithIAM caller could not be resolved; using {0}", FALLBACK_DB_USER);+ return FALLBACK_DB_USER;+ }+ String resource = arn.get().substring(arn.get().lastIndexOf(':') + 1);+ if (resource.startsWith("assumed-role/")) {+ String[] parts = resource.split("/");+ return parts.length >= 2 ? "IAMR:" + parts[1] : FALLBACK_DB_USER;+ }+ if (resource.startsWith("user/")) {+ // Drop any IAM path prefix (user/team/alice -> alice), matching how AWS names the DbUser.+ return "IAM:" + resource.substring(resource.lastIndexOf('/') + 1);+ }+ LOG.warnv("GetClusterCredentialsWithIAM caller ARN {0} is not a user or role; using {1}",+ arn.get(), FALLBACK_DB_USER);+ return FALLBACK_DB_USER;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandler.javaindex b974fa0729..3e236a8fdd 100644--- a/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandler.java@@ -1,6 +1,8 @@package io.github.hectorvent.floci.services.redshift;+import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;import io.github.hectorvent.floci.core.common.XmlBuilder;import io.github.hectorvent.floci.services.redshift.model.Cluster;import io.github.hectorvent.floci.services.redshift.model.ClusterParameterGroup;@@ -12,7 +14,9 @@ import jakarta.inject.Inject;import jakarta.ws.rs.core.MediaType;import jakarta.ws.rs.core.MultivaluedMap;import jakarta.ws.rs.core.Response;+import org.jboss.logging.Logger;+import java.time.format.DateTimeFormatter;import java.util.ArrayList;import java.util.Comparator;import java.util.LinkedHashMap;@@ -22,14 +26,35 @@ import java.util.regex.Pattern;@ApplicationScopedpublic class RedshiftQueryHandler {++ private static final Logger LOG = Logger.getLogger(RedshiftQueryHandler.class);++ // GetClusterCredentials DurationSeconds bounds, inclusive (AWS: 900 to 3600).+ private static final int MIN_CREDENTIAL_DURATION_SECONDS = 900;+ private static final int MAX_CREDENTIAL_DURATION_SECONDS = 3600;+private final RedshiftService service;+ private final RedshiftCredentialBroker credentialBroker;+ private final EmulatorConfig config;+ private final RedshiftIamDbUserResolver iamDbUserResolver;+ private final RegionResolver regionResolver;@Inject- public RedshiftQueryHandler(RedshiftService service) {+ public RedshiftQueryHandler(RedshiftService service, RedshiftCredentialBroker credentialBroker,+ EmulatorConfig config, RedshiftIamDbUserResolver iamDbUserResolver,+ RegionResolver regionResolver) {this.service = service;+ this.credentialBroker = credentialBroker;+ this.config = config;+ this.iamDbUserResolver = iamDbUserResolver;+ this.regionResolver = regionResolver;}public Response handle(String action, MultivaluedMap<String, String> params) {+ return handle(action, params, null);+ }++ public Response handle(String action, MultivaluedMap<String, String> params, String authorizationHeader) {switch (action) {case "CreateCluster" -> {String identifier = params.getFirst("ClusterIdentifier");@@ -414,10 +439,102 @@ public class RedshiftQueryHandler {.build();return Response.ok(xml).type(MediaType.APPLICATION_XML).build();}+ case "GetClusterCredentials" -> {+ String clusterId = requireParam(params, "ClusterIdentifier");+ String dbUser = requireParam(params, "DbUser");+ // describeClusters throws ClusterNotFound (404) for an unknown id.+ service.describeClusters(clusterId);+ // AWS prefixes the returned name IAMA: when AutoCreate is true, IAM: when it is false.+ boolean autoCreate = Boolean.parseBoolean(params.getFirst("AutoCreate"));+ String effectiveDbUser = (autoCreate ? "IAMA:" : "IAM:") + dbUser;+ int duration = resolveDurationSeconds(params);+ List<String> dbGroups = memberList(params, "DbGroups");++ TempCredential credential = credentialBroker.issue(+ regionResolver.getAccountId(), clusterId, effectiveDbUser, dbGroups, duration);+ return Response.ok(getClusterCredentialsXml("GetClusterCredentials", credential))+ .type(MediaType.APPLICATION_XML).build();+ }+ case "GetClusterCredentialsWithIAM" -> {+ String clusterId = requireParam(params, "ClusterIdentifier");+ service.describeClusters(clusterId);+ String dbUser = iamDbUserResolver.resolveDbUser(authorizationHeader);+ int duration = resolveDurationSeconds(params);+ List<String> dbGroups = memberList(params, "DbGroups");++ TempCredential credential = credentialBroker.issue(+ regionResolver.getAccountId(), clusterId, dbUser, dbGroups, duration);+ return Response.ok(getClusterCredentialsXml("GetClusterCredentialsWithIAM", credential))+ .type(MediaType.APPLICATION_XML).build();+ }default -> throw new AwsException("InvalidAction", "Action " + action + " is not supported", 400);}}+ private static String requireParam(MultivaluedMap<String, String> params, String name) {+ String value = params.getFirst(name);+ if (value == null || value.isBlank()) {+ throw new AwsException("InvalidParameterValue", name + " is required", 400);+ }+ return value;+ }++ private int resolveDurationSeconds(MultivaluedMap<String, String> params) {+ String raw = params.getFirst("DurationSeconds");+ if (raw == null || raw.isBlank()) {+ return defaultDurationSeconds();+ }+ int duration;+ try {+ duration = Integer.parseInt(raw);+ } catch (NumberFormatException e) {+ throw new AwsException("InvalidParameterValue", "DurationSeconds must be an integer", 400);+ }+ if (duration < MIN_CREDENTIAL_DURATION_SECONDS || duration > MAX_CREDENTIAL_DURATION_SECONDS) {+ throw new AwsException("InvalidParameterValue",+ "DurationSeconds must be between " + MIN_CREDENTIAL_DURATION_SECONDS+ + " and " + MAX_CREDENTIAL_DURATION_SECONDS, 400);+ }+ return duration;+ }++ // The YAML default is operator-supplied, so hold it to the same AWS bounds as a request+ // value: an out-of-range override falls back to the AWS minimum rather than minting a+ // credential that is already expired or outlives the documented range.+ private int defaultDurationSeconds() {+ int configured = config.services().redshift().defaultCredentialDurationSeconds();+ if (configured < MIN_CREDENTIAL_DURATION_SECONDS || configured > MAX_CREDENTIAL_DURATION_SECONDS) {+ LOG.warnv("floci.services.redshift.default-credential-duration-seconds={0} is outside the "+ + "AWS range {1} to {2}; using {1}", configured,+ MIN_CREDENTIAL_DURATION_SECONDS, MAX_CREDENTIAL_DURATION_SECONDS);+ return MIN_CREDENTIAL_DURATION_SECONDS;+ }+ return configured;+ }++ private String getClusterCredentialsXml(String operation, TempCredential credential) {+ XmlBuilder builder = new XmlBuilder()+ .start(operation + "Response")+ .start(operation + "Result")+ .elem("DbUser", credential.dbUser())+ .elem("DbPassword", credential.password())+ .elem("Expiration", DateTimeFormatter.ISO_INSTANT.format(credential.expiresAt()));+ if (!credential.dbGroups().isEmpty()) {+ builder.start("DbGroups");+ for (String group : credential.dbGroups()) {+ builder.elem("DbGroup", group);+ }+ builder.end("DbGroups");+ }+ return builder+ .end(operation + "Result")+ .start("ResponseMetadata")+ .elem("RequestId", "test-req-id")+ .end("ResponseMetadata")+ .end(operation + "Response")+ .build();+ }+private String buildClusterXml(Cluster cluster) {XmlBuilder builder = new XmlBuilder().start("Cluster")@@ -549,6 +666,7 @@ public class RedshiftQueryHandler {case "SubnetIds" -> quoted + "(\\.member|\\.SubnetIdentifier)?\\.\\d+";case "VpcSecurityGroupIds" -> quoted + "(\\.member|\\.VpcSecurityGroupId)?\\.\\d+";case "TagKeys" -> quoted + "(\\.member|\\.TagKey)?\\.\\d+";+ case "DbGroups" -> quoted + "(\\.member|\\.DbGroup)?\\.\\d+";default -> quoted + "(\\.member)?\\.\\d+";};}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 997d381b65..570d101d80 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@@ -6,7 +6,7 @@ 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.rds.proxy.PasswordValidator;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;@@ -51,13 +51,15 @@ public class RedshiftService {private final RegionResolver regionResolver;private final RedshiftProxyManager proxyManager;private final DockerHostResolver dockerHostResolver;+ private final RedshiftCredentialBroker credentialBroker;// 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,- RedshiftProxyManager proxyManager, DockerHostResolver dockerHostResolver) {+ RedshiftProxyManager proxyManager, DockerHostResolver dockerHostResolver,+ RedshiftCredentialBroker credentialBroker) {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>>() {});@@ -67,6 +69,7 @@ public class RedshiftService {this.regionResolver = regionResolver;this.proxyManager = proxyManager;this.dockerHostResolver = dockerHostResolver;+ this.credentialBroker = credentialBroker;}// Recreate Docker containers for persisted clusters on app restart (across every account, not just default)@@ -133,6 +136,9 @@ public class RedshiftService {if (clusters.get(identifier).isPresent()) {throw new AwsException("ClusterAlreadyExists", "Cluster " + identifier + " already exists", 400);}+ // A previous cluster with this identifier may have been deleted without its temp+ // credentials being cleared; drop them so the new cluster starts with none.+ credentialBroker.revokeCluster(clusters.accountId(), identifier);Cluster cluster = new Cluster();cluster.setClusterIdentifier(identifier);@@ -168,6 +174,7 @@ public class RedshiftService {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);+ credentialBroker.revokeCluster(clusters.accountId(), identifier);} else {cluster.setClusterStatus("failed");clusters.put(identifier, cluster);@@ -179,6 +186,7 @@ public class RedshiftService {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);+ credentialBroker.revokeCluster(clusters.accountId(), identifier);} else {cluster.setClusterStatus("failed");clusters.put(identifier, cluster);@@ -220,7 +228,10 @@ public class RedshiftService {containerManager.stop(clusters.accountId(), identifier);clusters.delete(identifier);clusters.flush();-+ // Invalidate any GetClusterCredentials passwords so a cluster later recreated with this+ // identifier does not accept them as master-equivalent.+ credentialBroker.revokeCluster(clusters.accountId(), identifier);+cluster.setClusterStatus("deleting");return cluster;}@@ -936,11 +947,40 @@ public class RedshiftService {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);+ // Classifies a proxy login against current cluster state: the master pair and any live+ // GetClusterCredentials credential both run the backend leg as the cluster master, a known+ // broker user with a stale password is rejected, everyone else passes through to the backend.+ // Reading cluster state per call means a ModifyCluster password change takes effect for new+ // connections without a proxy restart.+ private PasswordValidator passwordValidatorFor(String accountId, String clusterIdentifier) {+ return (user, password) -> {+ Optional<Cluster> cluster = clusters.getForAccount(accountId, clusterIdentifier);+ if (cluster.isEmpty()) {+ // No cluster row to validate against: vouch for nothing. Falling through to the+ // broker would classify an unknown user as PASSTHROUGH, and the wire proxy reads+ // isMaster from its own start-time config, so a PASSTHROUGH there still opens the+ // backend as master, authenticating any password for the master username.+ return PasswordValidator.AuthResult.REJECT;+ }+ Cluster c = cluster.get();+ if (user.equals(c.getMasterUsername())) {+ // The master username is authoritative here: a wrong password must be rejected,+ // never handed to the broker (which only knows minted DbUsers) and never passed+ // through as if the user were unknown.+ return password.equals(c.getMasterPassword())+ ? PasswordValidator.AuthResult.MASTER_EQUIVALENT+ : PasswordValidator.AuthResult.REJECT;+ }+ return switch (credentialBroker.classify(accountId, clusterIdentifier, user, password)) {+ case MASTER_EQUIVALENT -> PasswordValidator.AuthResult.MASTER_EQUIVALENT;+ case REJECT -> PasswordValidator.AuthResult.REJECT;+ case PASSTHROUGH -> PasswordValidator.AuthResult.PASSTHROUGH;+ };+ };+ }++ // Package-private hook for tests: passwordValidatorFor is otherwise private.+ PasswordValidator passwordValidatorForTesting(String accountId, String clusterIdentifier) {+ return passwordValidatorFor(accountId, clusterIdentifier);}}diff --git a/src/main/java/io/github/hectorvent/floci/services/redshift/TempCredential.java b/src/main/java/io/github/hectorvent/floci/services/redshift/TempCredential.javanew file mode 100644index 0000000000..88ab85326f--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/TempCredential.java@@ -0,0 +1,7 @@+package io.github.hectorvent.floci.services.redshift;++import java.time.Instant;+import java.util.List;++public record TempCredential(String dbUser, String password, Instant expiresAt, List<String> dbGroups) {+}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.javaindex a2591315c1..dec3429c19 100644--- 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.java@@ -1,7 +1,7 @@package io.github.hectorvent.floci.services.redshift.proxy;+import io.github.hectorvent.floci.services.rds.proxy.PasswordValidator;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 io.github.hectorvent.floci.services.s3.S3Service;@@ -32,7 +32,7 @@ public class RedshiftAuthProxy {private final String dbName;private final RdsSigV4Validator sigV4;private final RdsProxyTlsCertificates tlsCertificates;- private final RdsAuthProxy.PasswordValidator passwordValidator;+ private final PasswordValidator passwordValidator;private final S3Service s3Service;private volatile boolean running;@@ -41,7 +41,7 @@ public class RedshiftAuthProxy {public RedshiftAuthProxy(String clusterKey, String backendHost, int backendPort,String masterUsername, String masterPassword, String dbName,RdsSigV4Validator sigV4, RdsProxyTlsCertificates tlsCertificates,- RdsAuthProxy.PasswordValidator passwordValidator,+ PasswordValidator passwordValidator,S3Service s3Service) {this.clusterKey = clusterKey;this.backendHost = backendHost;@@ -145,7 +145,7 @@ public class RedshiftAuthProxy {PostgresProtocolHandler.AuthenticatedSession session =PostgresProtocolHandler.authenticate(client, backend, masterUsername, masterPassword, dbName,- false, sigV4, tlsCertificates, passwordValidator::validate);+ false, sigV4, tlsCertificates, passwordValidator);if (session != null) {// Redshift-only DDL (DISTKEY/SORTKEY/ENCODE/...) is rewritten for the plain// PostgreSQL backend on the way through; every other message is relayed verbatim.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.javaindex aebaa1d340..630a91b4e7 100644--- 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.java@@ -1,6 +1,6 @@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.PasswordValidator;import io.github.hectorvent.floci.services.rds.proxy.RdsProxyTlsCertificates;import io.github.hectorvent.floci.services.rds.proxy.RdsSigV4Validator;import io.github.hectorvent.floci.services.s3.S3Service;@@ -46,7 +46,7 @@ public class RedshiftProxyManager {public synchronized void startProxy(String relayKey, int proxyPort,String backendHost, int backendPort, String advertisedHost,String masterUsername, String masterPassword, String dbName,- RdsAuthProxy.PasswordValidator passwordValidator) {+ 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,diff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataResourceResolver.java b/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataResourceResolver.javaindex e3181a5077..51c53273d2 100644--- a/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataResourceResolver.java+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataResourceResolver.java@@ -4,6 +4,8 @@ import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.databind.ObjectMapper;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.services.redshift.RedshiftCredentialBroker;import io.github.hectorvent.floci.services.redshift.RedshiftService;import io.github.hectorvent.floci.services.redshift.model.Cluster;import io.github.hectorvent.floci.services.secretsmanager.SecretsManagerService;@@ -20,14 +22,20 @@ class RedshiftDataResourceResolver {private final RedshiftService redshiftService;private final SecretsManagerService secretsManagerService;private final ObjectMapper objectMapper;+ private final RedshiftCredentialBroker credentialBroker;+ private final RegionResolver regionResolver;@InjectRedshiftDataResourceResolver(RedshiftService redshiftService,SecretsManagerService secretsManagerService,- ObjectMapper objectMapper) {+ ObjectMapper objectMapper,+ RedshiftCredentialBroker credentialBroker,+ RegionResolver regionResolver) {this.redshiftService = redshiftService;this.secretsManagerService = secretsManagerService;this.objectMapper = objectMapper;+ this.credentialBroker = credentialBroker;+ this.regionResolver = regionResolver;}DatabaseTarget resolve(JsonNode request, String region) {@@ -71,11 +79,19 @@ class RedshiftDataResourceResolver {String clusterId = requiredText(request, "ClusterIdentifier");String dbUser = requiredText(request, "DbUser");Cluster cluster = cluster(clusterId);- if (!dbUser.equals(cluster.getMasterUsername())) {- throw validation("DbUser " + dbUser + " is not the cluster master; create it first or use "- + "GetClusterCredentials (not yet emulated).");++ if (dbUser.equals(cluster.getMasterUsername())) {+ return target(clusterArn(clusterId, null), cluster, database, dbUser, cluster.getMasterPassword());+ }+ boolean liveCredential = credentialBroker+ .resolve(regionResolver.getAccountId(), clusterId, dbUser)+ .isPresent();+ if (liveCredential) {+ // The minted DbUser is nominal: connect as the cluster master.+ return target(clusterArn(clusterId, null), cluster, database,+ cluster.getMasterUsername(), cluster.getMasterPassword());}- return target(clusterArn(clusterId, null), cluster, database, dbUser, cluster.getMasterPassword());+ throw validation("DbUser " + dbUser + " has no active credentials; call GetClusterCredentials first.");}private Cluster cluster(String clusterId) {diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex fc79e681c1..3b8c29f0e6 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -353,6 +353,7 @@ floci:image-version: postgres:15-alpineproxy-base-port: 7100proxy-max-port: 7199+ default-credential-duration-seconds: 900 # GetClusterCredentials default lifetime (900-3600)# endpoint-host: localhost # Hostname clients use; empty -> DockerHostResolverrds:enabled: truediff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.javaindex ab32d820c6..899d9b9241 100644--- a/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java@@ -5044,8 +5044,8 @@ class RdsServiceTest {restoredService.restorePersistedRuntime();- ArgumentCaptor<RdsAuthProxy.PasswordValidator> validator =- ArgumentCaptor.forClass(RdsAuthProxy.PasswordValidator.class);+ ArgumentCaptor<RdsAuthProxy.MasterPasswordCheck> validator =+ ArgumentCaptor.forClass(RdsAuthProxy.MasterPasswordCheck.class);verify(restoredProxyManager).startProxy(eq("db-proxy:" + proxy.getDbProxyArn()),eq(DatabaseEngine.POSTGRES),eq(false), eq(5432), eq("127.0.0.1"), eq(15432), any(), eq("admin"),diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/proxy/MySqlProtocolHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/MySqlProtocolHandlerTest.javaindex 5b0bc0268c..05469b8680 100644--- a/src/test/java/io/github/hectorvent/floci/services/rds/proxy/MySqlProtocolHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/MySqlProtocolHandlerTest.java@@ -66,7 +66,7 @@ class MySqlProtocolHandlerTest {MySqlProtocolHandler.handleAuth(proxyClient, backend, "admin", "secret",false, testSigV4Validator(), testTlsCertificates(),- (user, pass) -> true);+ (user, pass) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT);} catch (IOException e) {throw new RuntimeException(e);}@@ -128,7 +128,7 @@ class MySqlProtocolHandlerTest {MySqlProtocolHandler.handleAuth(proxyClient, backend, "admin", "secret",false, testSigV4Validator(), testTlsCertificates(),- (user, pass) -> true);+ (user, pass) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT);} catch (IOException e) {throw new RuntimeException(e);}@@ -184,7 +184,7 @@ class MySqlProtocolHandlerTest {MySqlProtocolHandler.handleAuth(proxyClient, backend, "admin", "secret",false, testSigV4Validator(), tlsCertificates,- (user, pass) -> true);+ (user, pass) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT);} catch (IOException e) {throw new RuntimeException(e);}@@ -282,7 +282,7 @@ class MySqlProtocolHandlerTest {MySqlProtocolHandler.handleAuth(proxyClient, backend, "admin", "secret",false, testSigV4Validator(), tlsCertificates,- (user, pass) -> true);+ (user, pass) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT);} catch (IOException e) {throw new RuntimeException(e);}diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/proxy/PostgresProtocolHandlerAuthResultTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/PostgresProtocolHandlerAuthResultTest.javanew file mode 100644index 0000000000..0bb8f79bd5--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/PostgresProtocolHandlerAuthResultTest.java@@ -0,0 +1,49 @@+package io.github.hectorvent.floci.services.rds.proxy;++import org.junit.jupiter.api.Test;++import static io.github.hectorvent.floci.services.rds.proxy.PasswordValidator.AuthResult;+import static org.junit.jupiter.api.Assertions.assertEquals;++class PostgresProtocolHandlerAuthResultTest {++ @Test+ void masterAlwaysUsesMasterBackendCredentials() {+ PostgresProtocolHandler.BackendLogin login = PostgresProtocolHandler.resolveBackendLogin(+ true, false, AuthResult.MASTER_EQUIVALENT,+ "master", "masterpass", "alice", "alicepass");++ assertEquals("master", login.user());+ assertEquals("masterpass", login.password());+ }++ @Test+ void iamUsesMasterBackendCredentials() {+ PostgresProtocolHandler.BackendLogin login = PostgresProtocolHandler.resolveBackendLogin(+ false, true, AuthResult.PASSTHROUGH,+ "master", "masterpass", "arn:role", "token");++ assertEquals("master", login.user());+ assertEquals("masterpass", login.password());+ }++ @Test+ void nonMasterPassthroughForwardsClientCredentials() {+ PostgresProtocolHandler.BackendLogin login = PostgresProtocolHandler.resolveBackendLogin(+ false, false, AuthResult.PASSTHROUGH,+ "master", "masterpass", "alice", "alicepass");++ assertEquals("alice", login.user());+ assertEquals("alicepass", login.password());+ }++ @Test+ void nonMasterMasterEquivalentUsesMasterBackendCredentials() {+ PostgresProtocolHandler.BackendLogin login = PostgresProtocolHandler.resolveBackendLogin(+ false, false, AuthResult.MASTER_EQUIVALENT,+ "master", "masterpass", "temp-user", "minted-pass");++ assertEquals("master", login.user());+ assertEquals("masterpass", login.password());+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/proxy/PostgresProtocolHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/PostgresProtocolHandlerTest.javaindex 0a806a4ef2..bb89291a49 100644--- a/src/test/java/io/github/hectorvent/floci/services/rds/proxy/PostgresProtocolHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/PostgresProtocolHandlerTest.java@@ -60,7 +60,7 @@ class PostgresProtocolHandlerTest {new MemorySocket(input.toByteArray()), mock(Socket.class),"dbadmin", "adminpass", "postgres",false, testSigV4Validator(), testTlsCertificates(),- (user, pass) -> true));+ (user, pass) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT));assertEquals("PostgreSQL startup message length exceeds the 1048576 byte limit: 1048577",error.getMessage());@@ -81,7 +81,7 @@ class PostgresProtocolHandlerTest {client, new MemorySocket(new byte[0]),"dbadmin", "adminpass", "postgres",false, testSigV4Validator(), testTlsCertificates(),- (user, pass) -> true));+ (user, pass) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT));}@Test@@ -95,7 +95,7 @@ class PostgresProtocolHandlerTest {new MemorySocket(input.toByteArray()), new MemorySocket(new byte[0]),"dbadmin", "adminpass", "postgres",false, testSigV4Validator(), testTlsCertificates(),- (user, pass) -> true));+ (user, pass) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT));assertEquals("PostgreSQL startup message length is below the 8 byte minimum: -1",error.getMessage());@@ -113,7 +113,7 @@ class PostgresProtocolHandlerTest {new MemorySocket(input.toByteArray()), new MemorySocket(new byte[0]),"dbadmin", "adminpass", "postgres",false, testSigV4Validator(), testTlsCertificates(),- (user, pass) -> true));+ (user, pass) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT));assertEquals("PostgreSQL password message length is below the 5 byte minimum: 4",error.getMessage());@@ -130,7 +130,7 @@ class PostgresProtocolHandlerTest {new MemorySocket(startupAndPassword()), new MemorySocket(backendInput.toByteArray()),"dbadmin", "adminpass", "postgres",false, testSigV4Validator(), testTlsCertificates(),- (user, pass) -> true));+ (user, pass) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT));assertEquals("PostgreSQL backend authentication message length exceeds the 1048576 byte limit: 1048577",error.getMessage());@@ -150,7 +150,7 @@ class PostgresProtocolHandlerTest {new MemorySocket(startupAndPassword()), new MemorySocket(backendInput.toByteArray()),"dbadmin", "adminpass", "postgres",false, testSigV4Validator(), testTlsCertificates(),- (user, pass) -> true));+ (user, pass) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT));assertEquals("PostgreSQL backend message length exceeds the 1048576 byte limit: 1048577",error.getMessage());@@ -170,7 +170,7 @@ class PostgresProtocolHandlerTest {new MemorySocket(startupAndPassword()), new MemorySocket(backendInput.toByteArray()),"dbadmin", "adminpass", "postgres",false, testSigV4Validator(), testTlsCertificates(),- (user, pass) -> true));+ (user, pass) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT));assertEquals("PostgreSQL SASL continue message length exceeds the 1048576 byte limit: 1048577",error.getMessage());@@ -217,7 +217,7 @@ class PostgresProtocolHandlerTest {proxyClient, backend,"dbadmin", "adminpass", "postgres",false, testSigV4Validator(), testTlsCertificates(),- (user, pass) -> true);+ (user, pass) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT);if (session != null) {PostgresProtocolHandler.bridge(session, backend);}@@ -275,7 +275,7 @@ class PostgresProtocolHandlerTest {proxyClient, backend,"dbadmin", "adminpass", "postgres",false, testSigV4Validator(), testTlsCertificates(),- (user, pass) -> true);+ (user, pass) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT);if (session != null) {PostgresProtocolHandler.bridge(session, backend);}@@ -333,7 +333,7 @@ class PostgresProtocolHandlerTest {proxyClient, backend,"dbadmin", "adminpass", "postgres",false, testSigV4Validator(), testTlsCertificates(),- (user, pass) -> true);+ (user, pass) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT);if (session != null) {PostgresProtocolHandler.bridge(session, backend);}@@ -400,7 +400,7 @@ class PostgresProtocolHandlerTest {proxyClient, backend,"dbadmin", "adminpass", "postgres",false, testSigV4Validator(), tlsCertificates,- (user, pass) -> true);+ (user, pass) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT);if (session != null) {PostgresProtocolHandler.bridge(session, backend);}@@ -454,7 +454,7 @@ class PostgresProtocolHandlerTest {proxyClient, backend,"dbadmin", "adminpass", "postgres",false, testSigV4Validator(), tlsCertificates,- (user, pass) -> true);+ (user, pass) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT);if (session != null) {PostgresProtocolHandler.bridge(session, backend);}@@ -504,7 +504,7 @@ class PostgresProtocolHandlerTest {proxyClient, backend,"dbadmin", "adminpass", "postgres",false, testSigV4Validator(), testTlsCertificates(),- (user, pass) -> true);+ (user, pass) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT);if (session != null) {PostgresProtocolHandler.bridge(session, backend);}@@ -856,7 +856,7 @@ class PostgresProtocolHandlerTest {proxyClient, backend,"dbadmin", "adminpass", "postgres",true, testSigV4Validator(), testTlsCertificates(),- (user, pass) -> true);+ (user, pass) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT);if (session != null) {PostgresProtocolHandler.bridge(session, backend);}diff --git a/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftCredentialBrokerTest.java b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftCredentialBrokerTest.javanew file mode 100644index 0000000000..669a69076f--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftCredentialBrokerTest.java@@ -0,0 +1,124 @@+package io.github.hectorvent.floci.services.redshift;++import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.time.Instant;+import java.util.List;+import java.util.Optional;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertTrue;++class RedshiftCredentialBrokerTest {++ private RedshiftCredentialBroker broker;++ @BeforeEach+ void setUp() {+ broker = new RedshiftCredentialBroker();+ }++ @Test+ void issueReturnsPopulatedCredentialWithFutureExpiry() {+ TempCredential cred = broker.issue("acc", "clus", "analyst", List.of("etl"), 900);++ assertEquals("analyst", cred.dbUser());+ assertFalse(cred.password().isBlank());+ assertTrue(cred.expiresAt().isAfter(Instant.now()));+ assertEquals(List.of("etl"), cred.dbGroups());+ }++ @Test+ void resolveReturnsLiveCredential() {+ broker.issue("acc", "clus", "analyst", List.of(), 900);++ Optional<TempCredential> found = broker.resolve("acc", "clus", "analyst");++ assertTrue(found.isPresent());+ assertEquals("analyst", found.get().dbUser());+ }++ @Test+ void resolveMissesForUnknownUser() {+ assertTrue(broker.resolve("acc", "clus", "nobody").isEmpty());+ }++ @Test+ void resolveEvictsExpiredCredential() {+ broker.issue("acc", "clus", "analyst", List.of(), 0);++ assertTrue(broker.resolve("acc", "clus", "analyst").isEmpty());+ }++ @Test+ void issueKeepsEveryUnexpiredCredentialForSameUser() {+ TempCredential first = broker.issue("acc", "clus", "analyst", List.of(), 900);+ TempCredential second = broker.issue("acc", "clus", "analyst", List.of(), 900);++ // AWS keeps each issued password valid until its own expiry: a reissue must not+ // invalidate a still-live credential.+ assertEquals(RedshiftCredentialBroker.Match.MASTER_EQUIVALENT,+ broker.classify("acc", "clus", "analyst", first.password()));+ assertEquals(RedshiftCredentialBroker.Match.MASTER_EQUIVALENT,+ broker.classify("acc", "clus", "analyst", second.password()));+ }++ @Test+ void issuePrunesExpiredCredentialsForSameUser() {+ broker.issue("acc", "clus", "analyst", List.of(), 0);+ TempCredential live = broker.issue("acc", "clus", "analyst", List.of(), 900);++ assertEquals(RedshiftCredentialBroker.Match.MASTER_EQUIVALENT,+ broker.classify("acc", "clus", "analyst", live.password()));+ assertEquals(1, broker.liveCredentialCountForTesting("acc", "clus", "analyst"));+ }++ @Test+ void revokeClusterDropsEveryCredentialForThatCluster() {+ TempCredential a = broker.issue("acc", "clus", "analyst", List.of(), 900);+ broker.issue("acc", "clus", "etl", List.of(), 900);+ TempCredential other = broker.issue("acc", "other", "analyst", List.of(), 900);++ broker.revokeCluster("acc", "clus");++ assertTrue(broker.resolve("acc", "clus", "analyst").isEmpty());+ assertEquals(RedshiftCredentialBroker.Match.PASSTHROUGH,+ broker.classify("acc", "clus", "analyst", a.password()));+ assertEquals(RedshiftCredentialBroker.Match.PASSTHROUGH,+ broker.classify("acc", "clus", "etl", "anything"));+ // A same-named DbUser on a different cluster is untouched.+ assertEquals(RedshiftCredentialBroker.Match.MASTER_EQUIVALENT,+ broker.classify("acc", "other", "analyst", other.password()));+ }++ @Test+ void classifyMatchesMasterEquivalentOnCorrectPassword() {+ TempCredential cred = broker.issue("acc", "clus", "analyst", List.of(), 900);++ assertEquals(RedshiftCredentialBroker.Match.MASTER_EQUIVALENT,+ broker.classify("acc", "clus", "analyst", cred.password()));+ }++ @Test+ void classifyRejectsKnownUserWithWrongPassword() {+ broker.issue("acc", "clus", "analyst", List.of(), 900);++ assertEquals(RedshiftCredentialBroker.Match.REJECT,+ broker.classify("acc", "clus", "analyst", "wrong"));+ }++ @Test+ void classifyPassesThroughUnknownUser() {+ assertEquals(RedshiftCredentialBroker.Match.PASSTHROUGH,+ broker.classify("acc", "clus", "stranger", "whatever"));+ }++ @Test+ void clearRemovesAllCredentials() {+ broker.issue("acc", "clus", "analyst", List.of(), 900);+ broker.clear();+ assertTrue(broker.resolve("acc", "clus", "analyst").isEmpty());+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftGetClusterCredentialsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftGetClusterCredentialsIntegrationTest.javanew file mode 100644index 0000000000..63d699c8a4--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftGetClusterCredentialsIntegrationTest.java@@ -0,0 +1,100 @@+package io.github.hectorvent.floci.services.redshift;++import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import jakarta.inject.Inject;+import org.awaitility.Awaitility;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.Assumptions;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;++import java.time.Duration;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * End-to-end: a non-master DbUser works for the Redshift Data API once+ * GetClusterCredentials has minted a credential for it. The wire proxy and the+ * Data API both connect to the container as the cluster master.+ */+@QuarkusTest+class RedshiftGetClusterCredentialsIntegrationTest {++ private static final String AUTH_HEADER =+ "AWS4-HMAC-SHA256 Credential=test/20260822/us-east-1/redshift/aws4_request";++ @Inject+ RedshiftService redshift;++ private String clusterId;++ @BeforeAll+ static void configure() {+ Assumptions.assumeTrue(dockerAvailable(), "Docker is required for this integration test");+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ private static boolean dockerAvailable() {+ try {+ Process p = new ProcessBuilder("docker", "version", "--format", "{{.Server.Version}}")+ .redirectErrorStream(true).start();+ return p.waitFor() == 0;+ } catch (Exception e) {+ return false;+ }+ }++ @AfterEach+ void cleanUp() {+ if (clusterId != null) {+ redshift.deleteCluster(clusterId);+ clusterId = null;+ }+ }++ private void awaitFinished(String id) {+ Awaitility.await().atMost(Duration.ofSeconds(30)).pollInterval(Duration.ofMillis(250)).until(() -> {+ String status = RestAssuredJsonUtils.awsAction("RedshiftData", "DescribeStatement",+ "{\"Id\":\"" + id + "\"}").then().statusCode(200).extract().path("Status");+ assertTrue(!"FAILED".equals(status) && !"ABORTED".equals(status),+ () -> "statement " + id + " ended " + status);+ return "FINISHED".equals(status);+ });+ }++ @Test+ void nonMasterDbUserWorksAfterGetClusterCredentials() {+ clusterId = "it-gcc-" + System.currentTimeMillis();+ redshift.createCluster(clusterId, "dc2.large", "admin", "Secret123");++ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", AUTH_HEADER)+ .formParam("Action", "GetClusterCredentials")+ .formParam("ClusterIdentifier", clusterId)+ .formParam("DbUser", "analyst")+ .formParam("DurationSeconds", "900")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .contentType("application/xml")+ .body(containsString("<DbUser>IAM:analyst</DbUser>"))+ .body(containsString("<DbPassword>"))+ .body(containsString("<Expiration>"));++ // A client passes back the exact DbUser that GetClusterCredentials returned.+ String id = RestAssuredJsonUtils.awsAction("RedshiftData", "ExecuteStatement", """+ {"Sql": "SELECT 1", "ClusterIdentifier": "%s", "DbUser": "IAM:analyst", "Database": "dev"}+ """.formatted(clusterId)).then().statusCode(200).extract().path("Id");+ awaitFinished(id);++ Object value = RestAssuredJsonUtils.awsAction("RedshiftData", "GetStatementResult",+ "{\"Id\":\"" + id + "\"}").then().statusCode(200).extract().path("Records[0][0].longValue");+ assertEquals(1, ((Number) value).intValue());+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftIamDbUserResolverTest.java b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftIamDbUserResolverTest.javanew file mode 100644index 0000000000..2152a2ec43--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftIamDbUserResolverTest.java@@ -0,0 +1,68 @@+package io.github.hectorvent.floci.services.redshift;++import io.github.hectorvent.floci.core.common.AccountResolver;+import io.github.hectorvent.floci.services.iam.IamService;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.util.Optional;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.when;++class RedshiftIamDbUserResolverTest {++ private IamService iamService;+ private AccountResolver accountResolver;+ private RedshiftIamDbUserResolver resolver;++ @BeforeEach+ void setUp() {+ iamService = mock(IamService.class);+ accountResolver = mock(AccountResolver.class);+ resolver = new RedshiftIamDbUserResolver(iamService, accountResolver);+ }++ @Test+ void mapsIamUserArnToIamPrefix() {+ when(accountResolver.extractAccessKeyId("auth")).thenReturn("AKIA123");+ when(iamService.resolveCallerArn("AKIA123"))+ .thenReturn(Optional.of("arn:aws:iam::000000000000:user/alice"));++ assertEquals("IAM:alice", resolver.resolveDbUser("auth"));+ }++ @Test+ void stripsIamPathPrefixFromUserName() {+ when(accountResolver.extractAccessKeyId("auth")).thenReturn("AKIA123");+ when(iamService.resolveCallerArn("AKIA123"))+ .thenReturn(Optional.of("arn:aws:iam::000000000000:user/team/lead/alice"));++ assertEquals("IAM:alice", resolver.resolveDbUser("auth"));+ }++ @Test+ void mapsAssumedRoleArnToIamrPrefix() {+ when(accountResolver.extractAccessKeyId("auth")).thenReturn("ASIA123");+ when(iamService.resolveCallerArn("ASIA123"))+ .thenReturn(Optional.of("arn:aws:sts::000000000000:assumed-role/Deployer/session-1"));++ assertEquals("IAMR:Deployer", resolver.resolveDbUser("auth"));+ }++ @Test+ void fallsBackWhenCallerUnresolved() {+ when(accountResolver.extractAccessKeyId("auth")).thenReturn("AKIA123");+ when(iamService.resolveCallerArn("AKIA123")).thenReturn(Optional.empty());++ assertEquals("IAMR:floci", resolver.resolveDbUser("auth"));+ }++ @Test+ void fallsBackWhenHeaderMissing() {+ when(accountResolver.extractAccessKeyId(null)).thenReturn(null);++ assertEquals("IAMR:floci", resolver.resolveDbUser(null));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandlerTest.javaindex 1fb0e2bd0f..8fcb69fa50 100644--- a/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandlerTest.java@@ -1,6 +1,8 @@package io.github.hectorvent.floci.services.redshift;+import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;import io.github.hectorvent.floci.services.redshift.model.Cluster;import io.github.hectorvent.floci.services.redshift.model.ClusterParameterGroup;import io.github.hectorvent.floci.services.redshift.model.ClusterSubnetGroup;@@ -26,11 +28,30 @@ class RedshiftQueryHandlerTest {private RedshiftQueryHandler handler;private RedshiftService service;+ private RedshiftCredentialBroker credentialBroker;+ private EmulatorConfig config;+ private RedshiftIamDbUserResolver iamDbUserResolver;+ private RegionResolver regionResolver;@BeforeEachvoid setUp() {service = mock(RedshiftService.class);- handler = new RedshiftQueryHandler(service);+ credentialBroker = new RedshiftCredentialBroker();+ config = mock(EmulatorConfig.class, RETURNS_DEEP_STUBS);+ when(config.services().redshift().defaultCredentialDurationSeconds()).thenReturn(900);+ iamDbUserResolver = mock(RedshiftIamDbUserResolver.class);+ regionResolver = mock(RegionResolver.class);+ when(regionResolver.getAccountId()).thenReturn("acc");+ handler = new RedshiftQueryHandler(service, credentialBroker, config, iamDbUserResolver, regionResolver);+ }++ private Cluster availableCluster(String id) {+ Cluster c = new Cluster();+ c.setClusterIdentifier(id);+ c.setMasterUsername("admin");+ c.setMasterPassword("SecretPass1");+ c.setClusterStatus("available");+ return c;}@Test@@ -374,4 +395,174 @@ class RedshiftQueryHandlerTest {assertTrue(xml.contains("<Key>env</Key>"));assertTrue(xml.contains("<Value>prod</Value>"));}++ // ── GetClusterCredentials ────────────────────────────────────────────────++ @Test+ void getClusterCredentialsReturnsUserPasswordAndExpiration() {+ when(service.describeClusters("c1")).thenReturn(List.of(availableCluster("c1")));+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ClusterIdentifier", "c1");+ params.putSingle("DbUser", "analyst");++ Response response = handler.handle("GetClusterCredentials", params);++ assertEquals(200, response.getStatus());+ String xml = (String) response.getEntity();+ assertTrue(xml.contains("<DbUser>IAM:analyst</DbUser>"));+ assertTrue(xml.contains("<DbPassword>"));+ assertTrue(xml.contains("<Expiration>"));+ assertTrue(xml.contains("<GetClusterCredentialsResult>"));+ }++ @Test+ void getClusterCredentialsStoresCredentialInBroker() {+ when(service.describeClusters("c1")).thenReturn(List.of(availableCluster("c1")));+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ClusterIdentifier", "c1");+ params.putSingle("DbUser", "analyst");++ handler.handle("GetClusterCredentials", params);++ assertTrue(credentialBroker.resolve("acc", "c1", "IAM:analyst").isPresent());+ }++ @Test+ void getClusterCredentialsRejectsMissingDbUser() {+ when(service.describeClusters("c1")).thenReturn(List.of(availableCluster("c1")));+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ClusterIdentifier", "c1");++ AwsException ex = assertThrows(AwsException.class,+ () -> handler.handle("GetClusterCredentials", params));+ assertEquals("InvalidParameterValue", ex.getErrorCode());+ }++ @Test+ void getClusterCredentialsClampsAnOutOfRangeConfigDefault() {+ when(config.services().redshift().defaultCredentialDurationSeconds()).thenReturn(5);+ when(service.describeClusters("c1")).thenReturn(List.of(availableCluster("c1")));+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ClusterIdentifier", "c1");+ params.putSingle("DbUser", "analyst");++ handler.handle("GetClusterCredentials", params);++ java.time.Instant expiresAt = credentialBroker.resolve("acc", "c1", "IAM:analyst").orElseThrow().expiresAt();+ assertTrue(expiresAt.isAfter(java.time.Instant.now().plusSeconds(800)),+ "an out-of-range config default must fall back to the AWS minimum, not be used as-is");+ }++ @Test+ void getClusterCredentialsRejectsDurationBelowMinimum() {+ when(service.describeClusters("c1")).thenReturn(List.of(availableCluster("c1")));+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ClusterIdentifier", "c1");+ params.putSingle("DbUser", "analyst");+ params.putSingle("DurationSeconds", "899");++ AwsException ex = assertThrows(AwsException.class,+ () -> handler.handle("GetClusterCredentials", params));+ assertEquals("InvalidParameterValue", ex.getErrorCode());+ }++ @Test+ void getClusterCredentialsRejectsDurationAboveMaximum() {+ when(service.describeClusters("c1")).thenReturn(List.of(availableCluster("c1")));+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ClusterIdentifier", "c1");+ params.putSingle("DbUser", "analyst");+ params.putSingle("DurationSeconds", "3601");++ AwsException ex = assertThrows(AwsException.class,+ () -> handler.handle("GetClusterCredentials", params));+ assertEquals("InvalidParameterValue", ex.getErrorCode());+ }++ @Test+ void getClusterCredentialsAutoCreateTruePrefixesIamaOnDbUser() {+ when(service.describeClusters("c1")).thenReturn(List.of(availableCluster("c1")));+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ClusterIdentifier", "c1");+ params.putSingle("DbUser", "analyst");+ params.putSingle("AutoCreate", "true");++ Response response = handler.handle("GetClusterCredentials", params);++ String xml = (String) response.getEntity();+ assertTrue(xml.contains("<DbUser>IAMA:analyst</DbUser>"));+ }++ @Test+ void getClusterCredentialsAutoCreateFalsePrefixesIamOnDbUser() {+ when(service.describeClusters("c1")).thenReturn(List.of(availableCluster("c1")));+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ClusterIdentifier", "c1");+ params.putSingle("DbUser", "analyst");++ Response response = handler.handle("GetClusterCredentials", params);++ String xml = (String) response.getEntity();+ assertTrue(xml.contains("<DbUser>IAM:analyst</DbUser>"));+ }++ @Test+ void getClusterCredentialsEchoesDbGroups() {+ when(service.describeClusters("c1")).thenReturn(List.of(availableCluster("c1")));+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ClusterIdentifier", "c1");+ params.putSingle("DbUser", "analyst");+ params.putSingle("DbGroups.member.1", "etl");+ params.putSingle("DbGroups.member.2", "readonly");++ Response response = handler.handle("GetClusterCredentials", params);++ String xml = (String) response.getEntity();+ assertTrue(xml.contains("<DbGroup>etl</DbGroup>"));+ assertTrue(xml.contains("<DbGroup>readonly</DbGroup>"));+ }++ @Test+ void getClusterCredentialsPropagatesClusterNotFound() {+ when(service.describeClusters("missing"))+ .thenThrow(new AwsException("ClusterNotFound", "Cluster missing not found", 404));+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ClusterIdentifier", "missing");+ params.putSingle("DbUser", "analyst");++ AwsException ex = assertThrows(AwsException.class,+ () -> handler.handle("GetClusterCredentials", params));+ assertEquals("ClusterNotFound", ex.getErrorCode());+ }++ // ── GetClusterCredentialsWithIAM ─────────────────────────────────────────++ @Test+ void getClusterCredentialsWithIamDerivesDbUserFromCaller() {+ when(service.describeClusters("c1")).thenReturn(List.of(availableCluster("c1")));+ when(iamDbUserResolver.resolveDbUser(any())).thenReturn("IAMR:Deployer");+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ClusterIdentifier", "c1");++ Response response = handler.handle("GetClusterCredentialsWithIAM", params);++ assertEquals(200, response.getStatus());+ String xml = (String) response.getEntity();+ assertTrue(xml.contains("<DbUser>IAMR:Deployer</DbUser>"));+ assertTrue(xml.contains("<GetClusterCredentialsWithIAMResult>"));+ }++ @Test+ void getClusterCredentialsWithIamIgnoresDbUserParam() {+ when(service.describeClusters("c1")).thenReturn(List.of(availableCluster("c1")));+ when(iamDbUserResolver.resolveDbUser(any())).thenReturn("IAM:alice");+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ClusterIdentifier", "c1");+ params.putSingle("DbUser", "ignored");++ Response response = handler.handle("GetClusterCredentialsWithIAM", params);++ String xml = (String) response.getEntity();+ assertTrue(xml.contains("<DbUser>IAM:alice</DbUser>"));+ }}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 0c2cebe1e3..db33ae3fab 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@@ -14,6 +14,7 @@ import io.github.hectorvent.floci.services.redshift.model.ClusterSubnetGroup;import io.github.hectorvent.floci.services.redshift.model.Endpoint;import io.github.hectorvent.floci.services.redshift.model.Parameter;import io.github.hectorvent.floci.services.redshift.model.Snapshot;+import io.github.hectorvent.floci.services.rds.proxy.PasswordValidator;import io.github.hectorvent.floci.services.redshift.proxy.RedshiftProxyManager;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;@@ -46,6 +47,7 @@ class RedshiftServiceTest {private RegionResolver regionResolver;private RedshiftProxyManager proxyManager;private DockerHostResolver dockerHostResolver;+ private RedshiftCredentialBroker credentialBroker;private RedshiftService service;@BeforeEach@@ -85,7 +87,10 @@ class RedshiftServiceTest {regionResolver = new RegionResolver("us-east-1", "111111111111");- service = new RedshiftService(sf, cm, config, regionResolver, proxyManager, dockerHostResolver);+ credentialBroker = new RedshiftCredentialBroker();++ service = new RedshiftService(sf, cm, config, regionResolver, proxyManager, dockerHostResolver,+ credentialBroker);}/** Absolute dump path as {@code createSnapshot} now stores it: under {@code <persistentPath>/redshift-dumps/<accountId>}. */@@ -250,14 +255,21 @@ class RedshiftServiceTest {void createClusterRemovesMetadataOnFailure() {when(clusterBackend.accountId()).thenReturn("111111111111");when(clusterBackend.get("c1")).thenReturn(Optional.empty());+ // Simulate a concurrent GetClusterCredentials landing while the row exists, then fail+ // container startup so the rollback path runs.when(cm.start(eq("111111111111"), eq("c1"), eq("admin"), eq("password123")))- .thenThrow(new RuntimeException("startup failed"));+ .thenAnswer(inv -> {+ credentialBroker.issue("111111111111", "c1", "analyst", List.of(), 900);+ throw new RuntimeException("startup failed");+ });assertThrows(AwsException.class, () ->service.createCluster("c1", "dc2.large", "admin", "password123"));verify(clusterBackend).delete("c1");verify(clusterBackend, atLeastOnce()).flush();+ // The rollback that removes the cluster row must also drop that credential.+ assertTrue(credentialBroker.resolve("111111111111", "c1", "analyst").isEmpty());}@Test@@ -347,6 +359,18 @@ class RedshiftServiceTest {verify(clusterBackend).delete("test-c");}+ @Test+ void deleteClusterRevokesItsGetClusterCredentialsCredentials() {+ Cluster c = new Cluster();+ c.setClusterIdentifier("test-c");+ when(clusterBackend.get("test-c")).thenReturn(Optional.of(c));+ credentialBroker.issue("111111111111", "test-c", "analyst", List.of(), 900);++ service.deleteCluster("test-c");++ assertTrue(credentialBroker.resolve("111111111111", "test-c", "analyst").isEmpty());+ }+@Testvoid deleteClusterAbortsAndKeepsMetadataWhenTheProxyWontStop() {Cluster c = new Cluster();@@ -1101,4 +1125,77 @@ class RedshiftServiceTest {String resource = arn.substring(arn.lastIndexOf(':') + 1);return resource.contains("/") ? resource.substring(resource.lastIndexOf('/') + 1) : resource;}++ // ── passwordValidatorFor / GetClusterCredentials broker wiring ─────────────++ private void seedCluster(String accountId, String clusterId) {+ Cluster cluster = new Cluster();+ cluster.setClusterIdentifier(clusterId);+ cluster.setMasterUsername("admin");+ cluster.setMasterPassword("SecretPass1");+ when(clusterBackend.getForAccount(accountId, clusterId)).thenReturn(Optional.of(cluster));+ }++ @Test+ void passwordValidatorAcceptsMasterPair() {+ seedCluster("acc", "c1");++ PasswordValidator validator =+ service.passwordValidatorForTesting("acc", "c1");++ assertEquals(PasswordValidator.AuthResult.MASTER_EQUIVALENT,+ validator.validate("admin", "SecretPass1"));+ }++ @Test+ void passwordValidatorRejectsEverythingWhenClusterRowIsAbsent() {+ when(clusterBackend.getForAccount("acc", "gone")).thenReturn(Optional.empty());++ PasswordValidator validator = service.passwordValidatorForTesting("acc", "gone");++ assertEquals(PasswordValidator.AuthResult.REJECT, validator.validate("admin", "SecretPass1"));+ assertEquals(PasswordValidator.AuthResult.REJECT, validator.validate("analyst", "anything"));+ }++ @Test+ void passwordValidatorRejectsMasterUserWithWrongPassword() {+ seedCluster("acc", "c1");++ PasswordValidator validator = service.passwordValidatorForTesting("acc", "c1");++ assertEquals(PasswordValidator.AuthResult.REJECT,+ validator.validate("admin", "not-the-master-password"));+ }++ @Test+ void passwordValidatorAcceptsLiveBrokerCredentialAsMasterEquivalent() {+ seedCluster("acc", "c1");+ TempCredential cred = credentialBroker.issue("acc", "c1", "analyst", List.of(), 900);+ PasswordValidator validator =+ service.passwordValidatorForTesting("acc", "c1");++ assertEquals(PasswordValidator.AuthResult.MASTER_EQUIVALENT,+ validator.validate("analyst", cred.password()));+ }++ @Test+ void passwordValidatorRejectsKnownBrokerUserWithWrongPassword() {+ seedCluster("acc", "c1");+ credentialBroker.issue("acc", "c1", "analyst", List.of(), 900);+ PasswordValidator validator =+ service.passwordValidatorForTesting("acc", "c1");++ assertEquals(PasswordValidator.AuthResult.REJECT,+ validator.validate("analyst", "nope"));+ }++ @Test+ void passwordValidatorPassesThroughUnknownUser() {+ seedCluster("acc", "c1");+ PasswordValidator validator =+ service.passwordValidatorForTesting("acc", "c1");++ assertEquals(PasswordValidator.AuthResult.PASSTHROUGH,+ validator.validate("someone-else", "whatever"));+ }}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.javaindex 170dd4528c..fb52b55aee 100644--- 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.java@@ -2,6 +2,7 @@ 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.PasswordValidator;import io.github.hectorvent.floci.services.rds.proxy.RdsProxyTlsCertificates;import io.github.hectorvent.floci.services.rds.proxy.RdsSigV4Validator;import io.github.hectorvent.floci.services.s3.S3Service;@@ -69,7 +70,7 @@ class RedshiftAuthProxyTest {int proxyPort = freePort();proxy = new RedshiftAuthProxy("111111111111:c1", "localhost", fakeBackend.getLocalPort(),"admin", "Secret123", "dev",- mock(RdsSigV4Validator.class), realTls(), (user, pw) -> true,+ mock(RdsSigV4Validator.class), realTls(), (user, pw) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT,mock(S3Service.class));proxy.start(proxyPort);@@ -123,7 +124,7 @@ class RedshiftAuthProxyTest {int proxyPort = freePort();proxy = new RedshiftAuthProxy("111111111111:c1", "localhost", fakeBackend.getLocalPort(),"admin", "Secret123", "dev",- mock(RdsSigV4Validator.class), realTls(), (user, pw) -> true,+ mock(RdsSigV4Validator.class), realTls(), (user, pw) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT,mock(S3Service.class));proxy.start(proxyPort);@@ -154,7 +155,7 @@ class RedshiftAuthProxyTest {proxy = new RedshiftAuthProxy("111111111111:c1", "localhost", fakeBackend.getLocalPort(),"admin", "Secret123", "dev",- mock(RdsSigV4Validator.class), realTls(), (user, pw) -> true,+ mock(RdsSigV4Validator.class), realTls(), (user, pw) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT,mock(S3Service.class));proxy.start(proxyPort); // must not throw despite the port being busy at first@@ -167,7 +168,7 @@ class RedshiftAuthProxyTest {int proxyPort = freePort();proxy = new RedshiftAuthProxy("111111111111:c1", "localhost", fakeBackend.getLocalPort(),"admin", "old", "dev",- mock(RdsSigV4Validator.class), realTls(), (user, pw) -> true,+ mock(RdsSigV4Validator.class), realTls(), (user, pw) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT,mock(S3Service.class));proxy.start(proxyPort);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.javaindex dcbc75bd2c..b477fb201a 100644--- 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.java@@ -1,5 +1,6 @@package io.github.hectorvent.floci.services.redshift.proxy;+import io.github.hectorvent.floci.services.rds.proxy.PasswordValidator;import io.github.hectorvent.floci.services.rds.proxy.RdsProxyTlsCertificates;import io.github.hectorvent.floci.services.rds.proxy.RdsSigV4Validator;import io.github.hectorvent.floci.services.s3.S3Service;@@ -34,7 +35,7 @@ class RedshiftProxyManagerTest {private static void start(RedshiftProxyManager manager, String key, int proxyPort) {manager.startProxy(key, proxyPort, "localhost", 1, "localhost",- "admin", "secret", "dev", (user, password) -> true);+ "admin", "secret", "dev", (user, password) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT);}@Testdiff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataResourceResolverTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataResourceResolverTest.javaindex 80332a0093..b24b8f8a72 100644--- a/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataResourceResolverTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataResourceResolverTest.java@@ -3,6 +3,8 @@ package io.github.hectorvent.floci.services.redshiftdata;import com.fasterxml.jackson.databind.ObjectMapper;import com.fasterxml.jackson.databind.node.ObjectNode;import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.services.redshift.RedshiftCredentialBroker;import io.github.hectorvent.floci.services.redshift.RedshiftService;import io.github.hectorvent.floci.services.redshift.model.Cluster;import io.github.hectorvent.floci.services.secretsmanager.SecretsManagerService;@@ -21,7 +23,9 @@ import static org.mockito.Mockito.when;class RedshiftDataResourceResolverTest {private static final String REGION = "us-east-1";+ private static final String ACCOUNT = "acc";private final ObjectMapper mapper = new ObjectMapper();+ private final RedshiftCredentialBroker broker = new RedshiftCredentialBroker();private static Cluster cluster() {Cluster c = new Cluster();@@ -34,7 +38,9 @@ class RedshiftDataResourceResolverTest {}private RedshiftDataResourceResolver resolver(RedshiftService redshift, SecretsManagerService secrets) {- return new RedshiftDataResourceResolver(redshift, secrets, mapper);+ RegionResolver regionResolver = mock(RegionResolver.class);+ when(regionResolver.getAccountId()).thenReturn(ACCOUNT);+ return new RedshiftDataResourceResolver(redshift, secrets, mapper, broker, regionResolver);}@Test@@ -94,6 +100,24 @@ class RedshiftDataResourceResolverTest {assertEquals("ValidationException", e.getErrorCode());}+ @Test+ void resolvesLiveMintedDbUserAsMaster() {+ RedshiftService redshift = mock(RedshiftService.class);+ when(redshift.describeClusters("wh")).thenReturn(List.of(cluster()));+ broker.issue(ACCOUNT, "wh", "analyst", List.of(), 900);++ ObjectNode req = mapper.createObjectNode();+ req.put("ClusterIdentifier", "wh");+ req.put("DbUser", "analyst");+ req.put("Database", "dev");++ RedshiftDataResourceResolver.DatabaseTarget target =+ resolver(redshift, mock(SecretsManagerService.class)).resolve(req, REGION);++ assertEquals("admin", target.user());+ assertEquals("Secret123", target.password());+ }+@Testvoid resolvesSecretArn() {RedshiftService redshift = mock(RedshiftService.class);diff --git a/src/test/resources/application.yml b/src/test/resources/application.ymlindex f7873f59c7..c539b6b4bd 100644--- a/src/test/resources/application.yml+++ b/src/test/resources/application.yml@@ -175,6 +175,7 @@ floci:image-version: postgres:15-alpineproxy-base-port: 7100proxy-max-port: 7199+ default-credential-duration-seconds: 900rds:enabled: truemock: falsediff --git a/tools/docs/services.yaml b/tools/docs/services.yamlindex e3e3dad2af..19202d5d42 100644--- a/tools/docs/services.yaml+++ b/tools/docs/services.yaml@@ -250,9 +250,10 @@ services:doc: docs/services/redshift.mdsources:- { path: src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandler.java, mode: switch }- # SubnetIds / VpcSecurityGroupIds / TagKeys are labels of an inner member-name- # switch (memberKeyRegex), not actions, same shape as the rds exclusions above.- exclude_actions: [SubnetIds, VpcSecurityGroupIds, TagKeys]+ # SubnetIds / VpcSecurityGroupIds / TagKeys / DbGroups are labels of an inner+ # member-name switch (memberKeyRegex), not actions, same shape as the rds+ # exclusions above.+ exclude_actions: [SubnetIds, VpcSecurityGroupIds, TagKeys, DbGroups]- service: redshiftdatadoc: docs/services/redshift-data.mdsources: