Light, fluffy, and always free - The AWS Local Emulator alternative
fix(rds): forward a PostgreSQL CancelRequest to the backend (#6127)
Robin Baeckmanb806f76f1bde
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 2a2b261bea..efcdb33bae 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@@ -127,7 +127,10 @@ public class PostgresProtocolHandler {handshakeTimeoutMillis, forwardStartupParameters, true);}- /** Standard DB Proxy IAM does not enroll the backend role in database-native IAM. */+ /**+ * {@code databaseIamAuthentication} is false on a standard DB Proxy endpoint, which neither+ * enrolls the backend role in database-native IAM nor forwards a client's CancelRequest.+ */public static AuthenticatedSession authenticate(Socket client, BackendConnector backendConnector,String masterUsername, String masterPassword, String dbName,boolean iamEnabled, RdsSigV4Validator sigV4,@@ -140,7 +143,8 @@ public class PostgresProtocolHandler {client.setSoTimeout(handshakeTimeoutMillis);// Phase 1: Read client startup message (possibly preceded by SSL request)- StartupMessage startup = readStartupMessage(client, tlsCertificates, handshakeTimeoutMillis);+ StartupMessage startup = readStartupMessage(client, backendConnector, databaseIamAuthentication,+ tlsCertificates, handshakeTimeoutMillis);if (startup == null) {closeQuietly(client);return null;@@ -471,7 +475,8 @@ public class PostgresProtocolHandler {// ── Startup ───────────────────────────────────────────────────────────────- private static StartupMessage readStartupMessage(Socket socket, RdsProxyTlsCertificates tlsCertificates,+ private static StartupMessage readStartupMessage(Socket socket, BackendConnector backendConnector,+ boolean forwardCancel, RdsProxyTlsCertificates tlsCertificates,int handshakeTimeoutMillis) throws IOException {Socket currentSocket = socket;while (true) {@@ -489,6 +494,19 @@ public class PostgresProtocolHandler {continue;}+ if (startup.code() == PostgresWire.CANCEL_REQUEST) {+ if (!forwardCancel) {+ // RDS Proxy does not support a CancelRequest from a client, so it drops one.+ LOG.debugv("Dropping a PostgreSQL CancelRequest sent to a DB proxy endpoint");+ } else if (startup.body().length == 8) {+ forwardCancelRequest(startup.body(), backendConnector);+ } else {+ LOG.warnv("Dropping a PostgreSQL CancelRequest of length {0}; it must be 16",+ startup.body().length + 8);+ }+ return null;+ }+if (startup.code() != PostgresWire.PROTOCOL_3) {LOG.warnv("Unexpected PostgreSQL startup protocol version: {0}", startup.code());return null;@@ -502,6 +520,22 @@ public class PostgresProtocolHandler {}}+ /**+ * Relays a CancelRequest to the backend on a connection of its own, as PostgreSQL expects.+ * The client holds the backend's own process id and key from its BackendKeyData, so the+ * request goes through unchanged. Nothing is answered: the server never replies to one.+ */+ private static void forwardCancelRequest(byte[] key, BackendConnector backendConnector)+ throws IOException {+ try (Socket backend = backendConnector.connect()) {+ OutputStream out = backend.getOutputStream();+ PostgresWire.writeInt32(out, 16);+ PostgresWire.writeInt32(out, PostgresWire.CANCEL_REQUEST);+ out.write(key);+ out.flush();+ }+ }+static Socket acceptSsl(Socket socket, RdsProxyTlsCertificates tlsCertificates) throws IOException {try {SSLSocket sslSocket = (SSLSocket) tlsCertificates.sslContext().getSocketFactory()diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/proxy/PostgresHandshakeFramingTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/PostgresHandshakeFramingTest.javaindex 1dbe0958c4..8dbc196d32 100644--- a/src/test/java/io/github/hectorvent/floci/services/rds/proxy/PostgresHandshakeFramingTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/PostgresHandshakeFramingTest.java@@ -1,5 +1,6 @@package io.github.hectorvent.floci.services.rds.proxy;+import org.junit.jupiter.api.Test;import org.junit.jupiter.params.ParameterizedTest;import org.junit.jupiter.params.provider.ValueSource;@@ -20,6 +21,8 @@ import static org.junit.jupiter.api.Assertions.assertArrayEquals;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertNotNull;import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;class PostgresHandshakeFramingTest {@@ -64,6 +67,81 @@ class PostgresHandshakeFramingTest {}}+ @Test+ void cancelRequestIsForwardedToTheBackendUnchanged() throws Exception {+ byte[] cancel = cancelRequest(16, 4242, 0x5eed);+ RecordingOutputStream clientOutput = new RecordingOutputStream();+ RecordingOutputStream backendOutput = new RecordingOutputStream();+ Socket client = new MemorySocket(cancel, clientOutput);+ Socket backend = new MemorySocket(new byte[0], backendOutput);+ AtomicInteger backendConnections = new AtomicInteger();+ try (client; backend) {+ PostgresProtocolHandler.AuthenticatedSession session = authenticate(client, () -> {+ backendConnections.incrementAndGet();+ return backend;+ });++ assertNull(session);+ assertEquals(1, backendConnections.get());+ assertArrayEquals(cancel, backendOutput.toByteArray());+ assertEquals(0, clientOutput.size());+ assertTrue(backend.isClosed());+ }+ }++ @Test+ void cancelRequestToADbProxyEndpointReachesNoBackend() throws Exception {+ Socket client = new MemorySocket(cancelRequest(16, 4242, 0x5eed), new RecordingOutputStream());+ AtomicInteger backendConnections = new AtomicInteger();+ try (client) {+ assertNull(PostgresProtocolHandler.authenticate(client, () -> {+ backendConnections.incrementAndGet();+ return new MemorySocket(new byte[0], new RecordingOutputStream());+ }, "master", "password", "appdb", false, null, null, null,+ (user, password) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT, 5000, true, false));+ assertEquals(0, backendConnections.get());+ }+ }++ @Test+ void cancelRequestOfTheWrongLengthReachesNoBackend() throws Exception {+ Socket client = new MemorySocket(cancelRequest(20, 4242, 0x5eed), new RecordingOutputStream());+ AtomicInteger backendConnections = new AtomicInteger();+ try (client) {+ assertNull(authenticate(client, () -> {+ backendConnections.incrementAndGet();+ return new MemorySocket(new byte[0], new RecordingOutputStream());+ }));+ assertEquals(0, backendConnections.get());+ }+ }++ @Test+ void truncatedCancelRequestReachesNoBackend() throws Exception {+ Socket client = new MemorySocket(Arrays.copyOf(cancelRequest(16, 4242, 0x5eed), 12),+ new RecordingOutputStream());+ AtomicInteger backendConnections = new AtomicInteger();+ try (client) {+ assertThrows(IOException.class, () -> authenticate(client, () -> {+ backendConnections.incrementAndGet();+ return new MemorySocket(new byte[0], new RecordingOutputStream());+ }));+ assertEquals(0, backendConnections.get());+ }+ }++ private static PostgresProtocolHandler.AuthenticatedSession authenticate(+ Socket client, PostgresProtocolHandler.BackendConnector backend) throws IOException {+ return PostgresProtocolHandler.authenticate(client, backend, "master", "password", "appdb",+ false, null, null, null, (user, password) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT,+ 5000);+ }++ private static byte[] cancelRequest(int length, int processId, int secretKey) {+ return ByteBuffer.allocate(length).putInt(length).putInt(80877102)+ .putInt(processId).putInt(secretKey).array();+ }+private static byte[] startupAndPassword() throws IOException {ByteArrayOutputStream input = new ByteArrayOutputStream();DataOutputStream out = new DataOutputStream(input);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 4f13a7722b..da825da505 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@@ -26,6 +26,7 @@ import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.IOException;import java.io.InputStream;+import java.io.UncheckedIOException;import java.net.ServerSocket;import java.net.Socket;import java.nio.charset.StandardCharsets;@@ -527,6 +528,56 @@ class PostgresProtocolHandlerTest {}}+ @Test+ void cancelRequestInsideTlsIsForwardedToTheBackend() throws Exception {+ try (ServerSocket backendServer = new ServerSocket(0);+ ServerSocket clientServer = new ServerSocket(0);+ Socket ourClient = new Socket("localhost", clientServer.getLocalPort());+ Socket proxyClient = clientServer.accept()) {++ RdsProxyTlsCertificates tlsCertificates = testTlsCertificates();+ tlsCertificates.ensureHost("localhost");+ Path trustedCaFile = Files.copy(tempDir.resolve("tls/rds-ca.crt"), tempDir.resolve("trusted-ca.crt"));+ Thread authThread = Thread.ofVirtual().start(() -> {+ try {+ PostgresProtocolHandler.authenticate(+ proxyClient, () -> new Socket("localhost", backendServer.getLocalPort()),+ "dbadmin", "adminpass", "postgres",+ false, testSigV4Validator(), testBinding(), tlsCertificates,+ (user, pass) -> PasswordValidator.AuthResult.MASTER_EQUIVALENT, 5000);+ } catch (IOException e) {+ throw new UncheckedIOException(e);+ }+ });++ DataOutputStream clientOut = new DataOutputStream(ourClient.getOutputStream());+ writeSslRequest(clientOut);+ assertEquals('S', new DataInputStream(ourClient.getInputStream()).readUnsignedByte());+ try (SSLSocket sslClient = verifyingClientSocket(ourClient, trustedCaFile, "localhost")) {+ DataOutputStream tlsOut = new DataOutputStream(sslClient.getOutputStream());+ tlsOut.writeInt(16);+ tlsOut.writeInt(80877102);+ tlsOut.writeInt(4242);+ tlsOut.writeInt(0x5eed);+ tlsOut.flush();++ backendServer.setSoTimeout(5000);+ try (Socket backend = backendServer.accept()) {+ backend.setSoTimeout(5000);+ DataInputStream backendIn = new DataInputStream(backend.getInputStream());+ assertEquals(16, backendIn.readInt());+ assertEquals(80877102, backendIn.readInt());+ assertEquals(4242, backendIn.readInt());+ assertEquals(0x5eed, backendIn.readInt());+ assertEquals(-1, backendIn.read(), "the proxy closes the cancel connection");+ }+ } finally {+ authThread.join(5_000);+ assertFalse(authThread.isAlive(), "authThread did not terminate");+ }+ }+ }+@Testvoid closesClientWhenBackendClosesDuringBridge() throws Exception {try (ServerSocket backendServer = new ServerSocket(0);diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsAuthProxyBackendResolutionTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsAuthProxyBackendResolutionTest.javaindex 33f6911c8c..5dc6f2ee6d 100644--- a/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsAuthProxyBackendResolutionTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsAuthProxyBackendResolutionTest.java@@ -18,9 +18,11 @@ import java.nio.charset.StandardCharsets;import java.time.Duration;import java.util.ArrayList;import java.util.List;+import java.util.concurrent.atomic.AtomicInteger;import java.util.concurrent.atomic.AtomicReference;import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;import static org.mockito.Mockito.mock;@@ -159,6 +161,35 @@ class RdsAuthProxyBackendResolutionTest {}}+ @Test+ void onlyADatabaseEndpointForwardsACancelRequest() throws Exception {+ assertTrue(cancelReachesBackend(RdsAuthProxy.EndpointKind.DATABASE));+ assertFalse(cancelReachesBackend(RdsAuthProxy.EndpointKind.STANDARD_DB_PROXY));+ }++ private boolean cancelReachesBackend(RdsAuthProxy.EndpointKind endpointKind) throws Exception {+ ServerSocket backend = backendAt(0);+ AtomicInteger resolved = new AtomicInteger();+ int proxyPort = FreePorts.anyInterfacePort();+ proxy("db-a", backend.getLocalPort(), () -> {+ resolved.incrementAndGet();+ return endpoint(backend.getLocalPort());+ }, DatabaseEngine.POSTGRES, endpointKind).start(proxyPort);++ try (Socket client = new Socket("127.0.0.1", proxyPort)) {+ client.setSoTimeout(5000);+ DataOutputStream request = new DataOutputStream(client.getOutputStream());+ request.writeInt(16);+ request.writeInt(80877102);+ request.writeInt(4242);+ request.writeInt(0x5eed);+ request.flush();+ // The proxy closes the client only after it has forwarded or dropped the cancel.+ assertEquals(-1, client.getInputStream().read());+ }+ return resolved.get() > 0;+ }+private RdsAuthProxy proxy(String id, int initialBackendPort,RdsAuthProxy.BackendEndpointResolver endpointResolver) {return proxy(id, initialBackendPort, endpointResolver, DatabaseEngine.SQLSERVER);@@ -167,12 +198,18 @@ class RdsAuthProxyBackendResolutionTest {private RdsAuthProxy proxy(String id, int initialBackendPort,RdsAuthProxy.BackendEndpointResolver endpointResolver,DatabaseEngine engine) {+ return proxy(id, initialBackendPort, endpointResolver, engine, RdsAuthProxy.EndpointKind.DATABASE);+ }++ private RdsAuthProxy proxy(String id, int initialBackendPort,+ RdsAuthProxy.BackendEndpointResolver endpointResolver,+ DatabaseEngine engine, RdsAuthProxy.EndpointKind endpointKind) {RdsAuthProxy proxy = new RdsAuthProxy(id, "127.0.0.1", initialBackendPort, endpointResolver, "runtime:" + id,engine, false, "sa", "Secret123", null,mock(RdsSigV4Validator.class), mock(RdsProxyTlsCertificates.class),(user, password) -> true, 5000, 5000, 100, null,- username -> false, RdsBackendGate.OPEN, RdsAuthProxy.EndpointKind.DATABASE);+ username -> false, RdsBackendGate.OPEN, endpointKind);proxies.add(proxy);return proxy;}diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsPostgresCancelIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsPostgresCancelIntegrationTest.javanew file mode 100644index 0000000000..bf9e7c5f20--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsPostgresCancelIntegrationTest.java@@ -0,0 +1,85 @@+package io.github.hectorvent.floci.services.rds.proxy;++import io.quarkus.test.junit.QuarkusTest;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Tag;+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.Properties;+import java.util.concurrent.CompletableFuture;+import java.util.concurrent.CompletionException;+import java.util.concurrent.TimeUnit;++import static io.github.hectorvent.floci.testing.RdsRequests.assumeDocker;+import static io.github.hectorvent.floci.testing.RdsRequests.createPostgresInstance;+import static io.github.hectorvent.floci.testing.RdsRequests.deleteInstance;+import static org.awaitility.Awaitility.await;+import static org.hamcrest.MatcherAssert.assertThat;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.instanceOf;+import static org.hamcrest.Matchers.lessThan;+import static org.junit.jupiter.api.Assertions.assertThrows;++/** A client cancels a running query through the proxy, as it does on an RDS for PostgreSQL endpoint. */+@QuarkusTest+@Tag("docker")+class RdsPostgresCancelIntegrationTest {++ private static final String SLEEP = "SELECT pg_sleep(30)";++ @BeforeEach+ void checkDocker() throws InterruptedException {+ assumeDocker();+ }++ @Test+ void aCancelledQueryStopsOnTheInstance() throws Exception {+ String dbId = "pg-cancel-" + Long.toString(System.nanoTime(), 36);+ int port = createPostgresInstance(dbId, "master", "Master123!", false);+ try (Connection connection = connect(port);+ Statement statement = connection.createStatement();+ Connection observer = connect(port)) {+ long started = System.nanoTime();+ CompletableFuture<Void> query = CompletableFuture.runAsync(() -> {+ try {+ statement.execute(SLEEP);+ } catch (SQLException e) {+ throw new CompletionException(e);+ }+ });+ await().atMost(Duration.ofSeconds(10)).until(() -> sleeping(observer));++ statement.cancel();++ CompletionException failed = assertThrows(CompletionException.class, query::join);+ assertThat(failed.getCause(), instanceOf(SQLException.class));+ assertThat(((SQLException) failed.getCause()).getSQLState(), equalTo("57014"));+ assertThat(TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - started), lessThan(10L));+ } finally {+ deleteInstance(dbId);+ }+ }++ private static Connection connect(int port) throws SQLException {+ Properties properties = new Properties();+ properties.setProperty("user", "master");+ properties.setProperty("password", "Master123!");+ properties.setProperty("sslmode", "disable");+ return DriverManager.getConnection("jdbc:postgresql://127.0.0.1:" + port + "/appdb", properties);+ }++ /** Whether the backend runs the sleep, so a cancel sent now has a query to stop. */+ private static boolean sleeping(Connection observer) throws SQLException {+ try (Statement statement = observer.createStatement();+ ResultSet row = statement.executeQuery("SELECT count(*) FROM pg_stat_activity"+ + " WHERE state = 'active' AND query = '" + SLEEP + "'")) {+ return row.next() && row.getInt(1) > 0;+ }+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsPostgresIamRoleIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsPostgresIamRoleIntegrationTest.javaindex b0cd292e0c..2a47882e34 100644--- a/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsPostgresIamRoleIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsPostgresIamRoleIntegrationTest.java@@ -24,6 +24,8 @@ import java.util.Map;import java.util.Properties;import static io.github.hectorvent.floci.testing.Ec2Requests.ec2;+import static io.github.hectorvent.floci.testing.RdsRequests.createPostgresInstance;+import static io.github.hectorvent.floci.testing.RdsRequests.deleteInstance;import static io.github.hectorvent.floci.testing.RdsRequests.rds;import static io.restassured.RestAssured.given;import static org.junit.jupiter.api.Assertions.*;@@ -49,8 +51,8 @@ class RdsPostgresIamRoleIntegrationTest {String role = id + "-policy";List<Runnable> cleanup = new ArrayList<>();try {- int databasePort = create(id);- cleanup.add(0, () -> delete(id));+ int databasePort = createPostgresInstance(id, MASTER, PASSWORD, true);+ cleanup.add(0, () -> deleteInstance(id));asMaster(databasePort, "CREATE ROLE app_user LOGIN PASSWORD '" + APP_PASSWORD + "'");String vpc = ec2("CreateVpc", "test", "us-east-1").formParam("CidrBlock", "10.97.0.0/16").post("/").then().statusCode(200).extract().xmlPath().getString("CreateVpcResponse.vpc.vpcId");@@ -126,7 +128,7 @@ class RdsPostgresIamRoleIntegrationTest {void iamLoginRequiresMembershipAndTheRolesOwnLoginAttribute() throws Exception {String id = uniqueId();try {- int port = create(id);+ int port = createPostgresInstance(id, MASTER, PASSWORD, true);asMaster(port, "CREATE ROLE app_user LOGIN PASSWORD '" + APP_PASSWORD + "'");Properties token = token(port, "app_user");refused(port, token);@@ -139,7 +141,7 @@ class RdsPostgresIamRoleIntegrationTest {asMaster(port, "ALTER ROLE app_user LOGIN");assertUser(port, token, "app_user");} finally {- delete(id);+ deleteInstance(id);}}@@ -147,7 +149,7 @@ class RdsPostgresIamRoleIntegrationTest {void iamMembershipTakesPrecedenceOverAnApplicationPassword() throws Exception {String id = uniqueId();try {- int port = create(id);+ int port = createPostgresInstance(id, MASTER, PASSWORD, true);asMaster(port, "CREATE ROLE app_user LOGIN PASSWORD '" + APP_PASSWORD + "'");Properties password = login("app_user", APP_PASSWORD);assertUser(port, password, "app_user");@@ -163,7 +165,7 @@ class RdsPostgresIamRoleIntegrationTest {asMaster(port, "REVOKE rds_iam FROM app_user");assertUser(port, password, "app_user");} finally {- delete(id);+ deleteInstance(id);}}@@ -171,7 +173,7 @@ class RdsPostgresIamRoleIntegrationTest {void theMasterNeedsAnActualGrantAndThenUsesIamInsteadOfItsPassword() throws Exception {String id = uniqueId();try {- int port = create(id);+ int port = createPostgresInstance(id, MASTER, PASSWORD, true);Properties iam = token(port, MASTER);refused(port, iam);try (Connection admin = connect(port, login(MASTER, PASSWORD));@@ -184,7 +186,7 @@ class RdsPostgresIamRoleIntegrationTest {}assertUser(port, login(MASTER, PASSWORD), MASTER);} finally {- delete(id);+ deleteInstance(id);}}@@ -192,7 +194,7 @@ class RdsPostgresIamRoleIntegrationTest {void indirectMembershipWorksWithoutPrivilegeInheritance() throws Exception {String id = uniqueId();try {- int port = create(id);+ int port = createPostgresInstance(id, MASTER, PASSWORD, true);asMaster(port, "CREATE ROLE iam_group NOLOGIN", "GRANT rds_iam TO iam_group","CREATE ROLE app_user LOGIN NOINHERIT PASSWORD '" + APP_PASSWORD + "'","GRANT iam_group TO app_user");@@ -203,7 +205,7 @@ class RdsPostgresIamRoleIntegrationTest {refused(port, iam);assertUser(port, login("app_user", APP_PASSWORD), "app_user");} finally {- delete(id);+ deleteInstance(id);}}@@ -212,7 +214,7 @@ class RdsPostgresIamRoleIntegrationTest {String id = uniqueId();String name = "café\"reader";try {- int port = create(id);+ int port = createPostgresInstance(id, MASTER, PASSWORD, true);asMaster(port, "CREATE ROLE \"café\"\"reader\" LOGIN PASSWORD '" + APP_PASSWORD + "'","GRANT rds_iam TO \"café\"\"reader\"", "CREATE SCHEMA shadow","CREATE TABLE shadow.pg_roles (oid oid, rolname name, rolcanlogin boolean)",@@ -229,7 +231,7 @@ class RdsPostgresIamRoleIntegrationTest {iam.setProperty("allowEncodingChanges", "true");assertUser(port, iam, name);} finally {- delete(id);+ deleteInstance(id);}}@@ -286,18 +288,4 @@ class RdsPostgresIamRoleIntegrationTest {private static String uniqueId() {return "iam-role-" + Long.toString(System.nanoTime(), 36);}-- private static int create(String id) {- return rds("CreateDBInstance").formParam("DBInstanceIdentifier", id).formParam("Engine", "postgres")- .formParam("MasterUsername", MASTER).formParam("MasterUserPassword", PASSWORD)- .formParam("DBName", "appdb").formParam("AllocatedStorage", 20)- .formParam("DBInstanceClass", "db.t3.micro").formParam("EnableIAMDatabaseAuthentication", true)- .post("/").then().statusCode(200).extract().xmlPath()- .getInt("CreateDBInstanceResponse.CreateDBInstanceResult.DBInstance.Endpoint.Port");- }-- private static void delete(String id) {- rds("DeleteDBInstance").formParam("DBInstanceIdentifier", id).formParam("SkipFinalSnapshot", true)- .post("/").then().statusCode(200);- }}diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsPostgresStartupParametersIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsPostgresStartupParametersIntegrationTest.javaindex 16ed1df5ac..c691f812a3 100644--- a/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsPostgresStartupParametersIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsPostgresStartupParametersIntegrationTest.java@@ -1,9 +1,7 @@package io.github.hectorvent.floci.services.rds.proxy;-import com.github.dockerjava.api.DockerClient;import io.github.hectorvent.floci.testutil.SigV4TokenTestHelper;import io.quarkus.test.junit.QuarkusTest;-import jakarta.inject.Inject;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Tag;import org.junit.jupiter.api.Test;@@ -16,11 +14,12 @@ import java.sql.Statement;import java.time.Instant;import java.util.Properties;-import static io.github.hectorvent.floci.testing.RdsRequests.rds;+import static io.github.hectorvent.floci.testing.RdsRequests.assumeDocker;+import static io.github.hectorvent.floci.testing.RdsRequests.createPostgresInstance;+import static io.github.hectorvent.floci.testing.RdsRequests.deleteInstance;import static org.hamcrest.MatcherAssert.assertThat;import static org.hamcrest.Matchers.equalTo;import static org.junit.jupiter.api.Assertions.assertThrows;-import static org.junit.jupiter.api.Assumptions.assumeTrue;/*** The parameters a client puts in its PostgreSQL StartupMessage reach the instance through the@@ -35,32 +34,15 @@ class RdsPostgresStartupParametersIntegrationTest {private static final String MASTER_USER = "master";private static final String MASTER_PASSWORD = "Master123!";- @Inject- DockerClient dockerClient;-@BeforeEach- void checkDocker() {- try {- dockerClient.pingCmd().exec();- } catch (Exception e) {- assumeTrue(false, "Docker is not available: " + e.getMessage());- }+ void checkDocker() throws InterruptedException {+ assumeDocker();}@Testvoid clientStartupParametersApplyToTheSession() throws Exception {String dbId = "startup-params-" + Long.toString(System.nanoTime(), 36);- int port = rds("CreateDBInstance")- .formParam("DBInstanceIdentifier", dbId)- .formParam("Engine", "postgres")- .formParam("MasterUsername", MASTER_USER)- .formParam("MasterUserPassword", MASTER_PASSWORD)- .formParam("DBName", "appdb")- .formParam("AllocatedStorage", "20")- .formParam("DBInstanceClass", "db.t3.micro")- .when().post("/").then().statusCode(200)- .extract().xmlPath()- .getInt("CreateDBInstanceResponse.CreateDBInstanceResult.DBInstance.Endpoint.Port");+ int port = createPostgresInstance(dbId, MASTER_USER, MASTER_PASSWORD, false);try {Properties properties = new Properties();properties.setProperty("user", MASTER_USER);@@ -76,17 +58,14 @@ class RdsPostgresStartupParametersIntegrationTest {assertThat(show(connection, "application_name"), equalTo("floci-startup-params"));}} finally {- rds("DeleteDBInstance")- .formParam("DBInstanceIdentifier", dbId)- .formParam("SkipFinalSnapshot", "true")- .when().post("/");+ deleteInstance(dbId);}}@Testvoid clientStartupParametersApplyToAnIamSessionAsTheTokenRole() throws Exception {String dbId = "startup-params-iam-" + Long.toString(System.nanoTime(), 36);- int port = createIamInstance(dbId);+ int port = createPostgresInstance(dbId, MASTER_USER, MASTER_PASSWORD, true);try {asMaster(port,"CREATE ROLE app_user LOGIN",@@ -113,7 +92,7 @@ class RdsPostgresStartupParametersIntegrationTest {@Testvoid anIamSessionCannotTakeTheMasterIdentityThroughStartupParameters() throws Exception {String dbId = "startup-params-iam-escalation-" + Long.toString(System.nanoTime(), 36);- int port = createIamInstance(dbId);+ int port = createPostgresInstance(dbId, MASTER_USER, MASTER_PASSWORD, true);try {asMaster(port, "CREATE ROLE app_user LOGIN", "GRANT rds_iam TO app_user");@@ -135,7 +114,7 @@ class RdsPostgresStartupParametersIntegrationTest {@Testvoid anIamSessionLoadsTheTokenRolesOwnDefaultsBeneathTheClientsParameters() throws Exception {String dbId = "startup-params-iam-defaults-" + Long.toString(System.nanoTime(), 36);- int port = createIamInstance(dbId);+ int port = createPostgresInstance(dbId, MASTER_USER, MASTER_PASSWORD, true);try {asMaster(port,"CREATE ROLE reader NOLOGIN",@@ -177,29 +156,6 @@ class RdsPostgresStartupParametersIntegrationTest {}}- /** Creates a PostgreSQL instance with IAM database authentication and returns its proxy port. */- private static int createIamInstance(String dbId) {- return rds("CreateDBInstance")- .formParam("DBInstanceIdentifier", dbId)- .formParam("Engine", "postgres")- .formParam("MasterUsername", MASTER_USER)- .formParam("MasterUserPassword", MASTER_PASSWORD)- .formParam("DBName", "appdb")- .formParam("AllocatedStorage", "20")- .formParam("DBInstanceClass", "db.t3.micro")- .formParam("EnableIAMDatabaseAuthentication", "true")- .when().post("/").then().statusCode(200)- .extract().xmlPath()- .getInt("CreateDBInstanceResponse.CreateDBInstanceResult.DBInstance.Endpoint.Port");- }-- private static void deleteInstance(String dbId) {- rds("DeleteDBInstance")- .formParam("DBInstanceIdentifier", dbId)- .formParam("SkipFinalSnapshot", "true")- .when().post("/");- }-/** Runs {@code statements} in order as the master user. */private static void asMaster(int port, String... statements) throws SQLException {Properties master = new Properties();diff --git a/src/test/java/io/github/hectorvent/floci/testing/RdsRequests.java b/src/test/java/io/github/hectorvent/floci/testing/RdsRequests.javaindex 4dff874c75..d0e0ca5869 100644--- a/src/test/java/io/github/hectorvent/floci/testing/RdsRequests.java+++ b/src/test/java/io/github/hectorvent/floci/testing/RdsRequests.java@@ -12,6 +12,7 @@ import java.net.URI;import static io.restassured.RestAssured.given;import static io.restassured.http.ContentType.URLENC;+import static org.junit.jupiter.api.Assumptions.assumeTrue;public final class RdsRequests {private RdsRequests() {}@@ -30,4 +31,33 @@ public final class RdsRequests {.credentialsProvider(StaticCredentialsProvider.create(AwsBasicCredentials.create(account, "test-secret-key"))).build();}++ /** Skips the test when no Docker daemon answers, which a real PostgreSQL instance needs. */+ public static void assumeDocker() throws InterruptedException {+ assumeTrue(DockerAvailability.isAvailable(), "Docker is not available");+ }++ /** Creates a PostgreSQL instance with database {@code appdb} and returns its endpoint port. */+ public static int createPostgresInstance(String id, String masterUsername, String masterPassword,+ boolean iamDatabaseAuthentication) {+ return rds("CreateDBInstance")+ .formParam("DBInstanceIdentifier", id)+ .formParam("Engine", "postgres")+ .formParam("MasterUsername", masterUsername)+ .formParam("MasterUserPassword", masterPassword)+ .formParam("DBName", "appdb")+ .formParam("AllocatedStorage", "20")+ .formParam("DBInstanceClass", "db.t3.micro")+ .formParam("EnableIAMDatabaseAuthentication", iamDatabaseAuthentication)+ .when().post("/").then().statusCode(200)+ .extract().xmlPath()+ .getInt("CreateDBInstanceResponse.CreateDBInstanceResult.DBInstance.Endpoint.Port");+ }++ public static void deleteInstance(String id) {+ rds("DeleteDBInstance")+ .formParam("DBInstanceIdentifier", id)+ .formParam("SkipFinalSnapshot", "true")+ .when().post("/");+ }}