Light, fluffy, and always free - The AWS Local Emulator alternative
feat(redshift-data): support session reuse (#6396)
Vũ Thế Huy348874766f7a
diff --git a/docs/services/redshift-data.md b/docs/services/redshift-data.mdindex 0ff6337ba9..4628485dbb 100644--- a/docs/services/redshift-data.md+++ b/docs/services/redshift-data.md@@ -43,6 +43,69 @@ A request identifies its target cluster or serverless workgroup one of three wayA statement run against a workgroup reports `WorkgroupName` and omits `ClusterIdentifier`, and the reverse holds for a cluster statement. `ListDatabases`, `ListSchemas`, `ListTables` and `DescribeTable` accept `WorkgroupName` the same way.+## Session reuse++`ExecuteStatement` and `BatchExecuteStatement` accept `SessionKeepAliveSeconds`, an integer from+0 to 86400. A positive value retains the JDBC connection after the statement completes and+returns its `SessionId`. Subsequent execute or batch calls can send just that `SessionId` and+their SQL. The database, cluster or workgroup, database user and secret are inherited from the+first request. Optional target fields on a reuse request must match the original session.+Temporary tables and session settings survive between calls, and Execute and Batch can share+the same session. Metadata operations such as `ListTables` still open independent connections.++`BEGIN` or `START TRANSACTION` opens an explicit transaction for later Execute calls;+`COMMIT`/`END` commits it, and `ROLLBACK`/`ABORT` rolls it back. SQL errors and accepted running cancellation+leave an explicit transaction aborted: later Execute calls fail until COMMIT or ROLLBACK ends+the block, rolling back its changes. A batch remains a transaction boundary: its success commits the+connection and its failure rolls it back, including any transaction opened by earlier Execute+calls on that session. Transaction-control modifiers beyond optional `WORK` or `TRANSACTION`+are rejected before execution. These cross-call transaction details have not been verified against live AWS.++An omitted keep-alive on a reuse request preserves the previous idle timeout. A supplied value+replaces it after successful admission, and the idle deadline starts when the query completes.+Sending 0 with an existing `SessionId` closes the connection after that query. Omitting both+fields, or sending 0 without a session id, keeps the existing connection-per-request behavior.++Only one query can be admitted to a session at a time, including while that query waits for a+worker. A different query against a busy session returns `ValidationException`; it is not queued+behind the first query. Retrying the first query's `ClientToken` returns its original statement+and session ids. Queue or admission-storage failures release their reservation without changing+an existing session's idle deadline. Each cluster or workgroup supports up to 500 retained+sessions, shared across callers and database names.++Sessions are scoped to the signing account, Region and caller independently of `WithEvent`.+Floci resolves the caller's IAM ARN when possible and otherwise uses the access key identity;+an internal caller can supply its captured principal. A foreign, expired or reset session returns+`ResourceNotFoundException`. These exact error choices and optional-field matching rules have+not been compared with live AWS. A running session lasts at most 24 hours from creation;+a one-second sweep cancels active work and closes connections at that deadline.++Session ids appear in Execute, Batch, DescribeStatement and ListStatements responses. The id+is saved with statement metadata and idempotency receipts, but live connections are runtime-only:+reset and shutdown close them, and restarting Floci never reopens a session. A session request+with an existing receipt can still replay its original response after the connection expires or+after restart, subject to the normal receipt lifetime and caller ownership. `ListSessions` is+not implemented.++Unexpected synchronous connection-cleanup failures are reported to the affected operation.+Reset still attempts to close the remaining sessions and clear statement and receipt state before+reporting cleanup errors. Background expiration failures are logged without stopping later sweeps.+An already-closed connection (`SQLSTATE 08003`) is a benign cleanup outcome.++```python+created = data.execute_statement(+ WorkgroupName="analytics", Database="dev", SessionKeepAliveSeconds=60,+ Sql="CREATE TEMP TABLE staging(id integer)")+# Poll DescribeStatement until FINISHED before submitting another query in this session.+session_id = created["SessionId"]+inserted = data.execute_statement(SessionId=session_id, Sql="INSERT INTO staging VALUES (42)")+# Poll inserted["Id"] before the next call.+selected = data.execute_statement(SessionId=session_id, Sql="SELECT * FROM staging")+```++See [AWS session reuse guidance](https://docs.aws.amazon.com/redshift/latest/mgmt/data-api.html)+for the idle timeout, 24-hour lifetime and single-query constraints.+## Compatibility Notes- **Execution is asynchronous.** `ExecuteStatement` and `BatchExecuteStatement` return an `Id` after admission to the shared bounded worker pool. `DescribeStatement` progresses through `SUBMITTED`, `STARTED`, and `FINISHED`, `FAILED` or `ABORTED`. Poll before reading results. Optional `WaitTimeSeconds` accepts integers from 1 to 30 and waits up to that duration. HTTP, Step Functions and Scheduler use the same executor. Saturation returns `ActiveStatementsExceededException`.@@ -72,7 +135,7 @@ reported storage errors and queue-admission failures do not consume the token. Aadmission does consume it. `WaitTimeSeconds` on a retry can wait for the original execution withoutsubmitting another one.-Request validation and database-target resolution run before admission coordination. Only requests+Request validation and database-target resolution run before admission coordination for new connections. Only requestssharing an account, region, execute operation and token share an admission lock; tokenless requestsuse no token lock. The executor reserves queue capacity before writing admission state, so a fullqueue cannot create a receipt that reappears after restart. Workers run SQL only after admission@@ -91,8 +154,10 @@ The token deadline is independent of result retention: if a configured result TT8 hours removes the statement, its receipt still returns the original admission response untilthe token expires, without restoring results.-Floci scopes tokens by account, region and execute operation. It validates the request and resolves-the database target before looking up a receipt, including on retries. Within that scope, reusing+Floci scopes tokens by account, region and execute operation. Requests for new connections validate+and resolve the database target before looking up a receipt, including on retries. SessionId-only+retries check an existing receipt first so a closed connection does not prevent replay; receipts+for retained sessions additionally check caller ownership. Within that scope, reusinga token with changed SQL, parameters or event settings replays the original operation; it does notchange that operation. The precise AWS behavior for changed payloads, different IAM principals,cross-operation reuse and responses after result eviction has not been verified against a live@@ -121,8 +186,7 @@ failure rolls back the batch. External read or preparation failures are stored areported by `DescribeStatement`, as other SQL execution failures are.Create external schemas and tables outside a batch: `CREATE EXTERNAL TABLE` cannot run inside a transaction block on AWS, and a batch runs as one transaction, so both statements are rejected there.-Data API session reuse is not supported. The legacy Phase 1 catalog-is not the Glue-backed relational path.+The legacy Phase 1 catalog is not the Glue-backed relational path.## Configurationdiff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataExecution.java b/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataExecution.javaindex 582dd51580..24e2080736 100644--- a/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataExecution.java+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataExecution.java@@ -95,13 +95,10 @@ final class RedshiftDataExecution {return true;}- void signalCancellation() {- Statement activeStatement;- Connection activeConnection;- synchronized (this) {- activeStatement = statement;- activeConnection = connection;- }+ synchronized void signalCancellation() {+ // terminal() must wait until the old cancellation reaches JDBC before the connection can be reused.+ Statement activeStatement = statement;+ Connection activeConnection = connection;try {if (activeStatement != null) {activeStatement.cancel();diff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataIdempotencyStore.java b/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataIdempotencyStore.javaindex ec8a92a1c6..b35562c50f 100644--- a/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataIdempotencyStore.java+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataIdempotencyStore.java@@ -62,10 +62,15 @@ class RedshiftDataIdempotencyStore {}void put(Scope scope, ObjectNode response) {+ put(scope, response, null);+ }++ void put(Scope scope, ObjectNode response, String sessionOwner) {Receipt receipt = new Receipt();receipt.acceptedAt = clock.instant();receipt.expiresAt = receipt.acceptedAt.plus(TOKEN_TTL);receipt.response = response.deepCopy();+ receipt.sessionOwner = sessionOwner;mutations.readLock().lock();try {receipts.putAllAtomicallyForAccount(scope.accountId(), Map.of(scope.key(), receipt));@@ -137,12 +142,14 @@ class RedshiftDataIdempotencyStore {Instant acceptedAt;Instant expiresAt;ObjectNode response;+ String sessionOwner;Receipt snapshot() {Receipt copy = new Receipt();copy.acceptedAt = acceptedAt;copy.expiresAt = expiresAt;copy.response = response.deepCopy();+ copy.sessionOwner = sessionOwner;return copy;}}diff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataService.java b/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataService.javaindex 9919789763..335464f487 100644--- a/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataService.java+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataService.java@@ -32,11 +32,14 @@ import java.util.ArrayList;import java.util.Base64;import java.util.Comparator;import java.util.List;+import java.util.Locale;import java.util.Map;+import java.util.Objects;import java.util.UUID;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.locks.ReentrantLock;-import java.util.function.Consumer;+import java.util.function.BiConsumer;+import java.util.regex.Matcher;import java.util.regex.Pattern;@ApplicationScoped@@ -48,6 +51,10 @@ public class RedshiftDataService implements Resettable {+ "(?:VACUUM\\b|(?:CREATE|DROP)\\s+(?:DATABASE|TABLESPACE)\\b|ALTER\\s+SYSTEM\\b"+ "|CREATE\\s+(?:UNIQUE\\s+)?INDEX\\s+CONCURRENTLY\\b|DROP\\s+INDEX\\s+CONCURRENTLY\\b"+ "|REINDEX\\b[^;]*?\\bCONCURRENTLY\\b)");+ private static final Pattern TRANSACTION_CONTROL = Pattern.compile(+ "(?is)\\A(BEGIN|START\\s+TRANSACTION|COMMIT|END|ROLLBACK|ABORT)(?:\\s+(?:WORK|TRANSACTION))?\\s*;?\\s*\\z");+ private static final Pattern TRANSACTION_PREFIX = Pattern.compile("(?is)\\A(?:BEGIN|START|COMMIT|END|ROLLBACK|ABORT)\\b");+ private static final Pattern TRANSACTION_COMMENTS = Pattern.compile("(?s)/\\*.*?\\*/|--[^\\r\\n]*");private final RedshiftDataResourceResolver resolver;private final RedshiftDataConnectionFactory connectionFactory;@@ -59,6 +66,7 @@ public class RedshiftDataService implements Resettable {private final RequestContext requestContext;private final IamService iamService;private final RedshiftDataIdempotencyStore idempotency;+ private final RedshiftDataSessions sessions;private final ConcurrentHashMap<RedshiftDataIdempotencyStore.Scope, AdmissionLock> admissionLocks = new ConcurrentHashMap<>();RedshiftDataService(RedshiftDataResourceResolver resolver, RedshiftDataConnectionFactory connectionFactory,@@ -69,11 +77,20 @@ public class RedshiftDataService implements Resettable {Clock.systemUTC()));}+ RedshiftDataService(RedshiftDataResourceResolver resolver, RedshiftDataConnectionFactory connectionFactory,+ RedshiftDataStatementStore store, ObjectMapper objectMapper, SpectrumQueryPreparation preparation,+ RedshiftDataExecutor executor, RedshiftDataEventPublisher publisher,+ RequestContext requestContext, IamService iamService, RedshiftDataIdempotencyStore idempotency) {+ this(resolver, connectionFactory, store, objectMapper, preparation, executor, publisher,+ requestContext, iamService, idempotency, new RedshiftDataSessions());+ }+@Injectpublic RedshiftDataService(RedshiftDataResourceResolver resolver, RedshiftDataConnectionFactory connectionFactory,RedshiftDataStatementStore store, ObjectMapper objectMapper, SpectrumQueryPreparation preparation,RedshiftDataExecutor executor, RedshiftDataEventPublisher publisher,- RequestContext requestContext, IamService iamService, RedshiftDataIdempotencyStore idempotency) {+ RequestContext requestContext, IamService iamService, RedshiftDataIdempotencyStore idempotency,+ RedshiftDataSessions sessions) {this.resolver = resolver;this.connectionFactory = connectionFactory;this.store = store;@@ -84,23 +101,33 @@ public class RedshiftDataService implements Resettable {this.requestContext = requestContext;this.iamService = iamService;this.idempotency = idempotency;+ this.sessions = sessions;}@Overridepublic void clear() {executor.clear(() -> {RuntimeException failure = null;+ try {+ sessions.clear();+ } catch (RuntimeException sessionFailure) {+ failure = sessionFailure;+ }try {store.clear();} catch (RuntimeException storageFailure) {- failure = storageFailure;+ if (failure == null) {+ failure = storageFailure;+ } else if (failure != storageFailure) {+ failure.addSuppressed(storageFailure);+ }}try {idempotency.clear();} catch (RuntimeException receiptFailure) {if (failure == null) {failure = receiptFailure;- } else {+ } else if (failure != receiptFailure) {failure.addSuppressed(receiptFailure);}}@@ -123,12 +150,31 @@ public class RedshiftDataService implements Resettable {private ObjectNode execute(JsonNode request, String region, String principal, boolean batch) {String token = RedshiftDataIdempotencyStore.clientToken(request);int waitSeconds = waitSeconds(request);- PendingStatement pending = batch ? prepareBatch(request, region) : prepareStatement(request, region);+ RedshiftDataSessions.validate(request);+ boolean retained = request.has("SessionId") || request.path("SessionKeepAliveSeconds").asInt() > 0;+ RedshiftDataSessions.Scope owner = retained ? sessionScope(region, principal)+ : new RedshiftDataSessions.Scope(store.accountId(), region, null);+ if (token != null && request.has("SessionId")) {+ RedshiftDataIdempotencyStore.Scope retryScope = new RedshiftDataIdempotencyStore.Scope(+ owner.accountId(), region, batch ? "BatchExecuteStatement" : "ExecuteStatement", token);+ Admission replay = executor.admitting(() -> {+ RedshiftDataIdempotencyStore.Receipt receipt = idempotency.find(retryScope);+ return receipt == null ? null : replay(receipt, retryScope, owner, principal);+ });+ if (replay != null) {+ return awaitAdmission(replay, waitSeconds);+ }+ }+ PendingStatement pending = batch ? prepareBatch(request, region, owner) : prepareStatement(request, region, owner);RedshiftDataStatementStore.StoredStatement stored = pending.statement();RedshiftDataIdempotencyStore.Scope scope = token == null ? null : new RedshiftDataIdempotencyStore.Scope(stored.accountId, region, batch ? "BatchExecuteStatement" : "ExecuteStatement", token);Admission admission = executor.admitting(() -> scope == null ? submit(pending, principal, null): admitScoped(pending, principal, scope));+ return awaitAdmission(admission, waitSeconds);+ }++ private ObjectNode awaitAdmission(Admission admission, int waitSeconds) {if (waitSeconds > 0 && admission.execution() != null) {admission.execution().await(Duration.ofSeconds(waitSeconds));RedshiftDataStatementStore.StoredStatement current = store.getForAccount(admission.accountId(), admission.id());@@ -139,6 +185,30 @@ public class RedshiftDataService implements Resettable {return admission.response();}+ private RedshiftDataSessions.Scope sessionScope(String region, String principal) {+ String caller = principal;+ if (caller == null && requestContext != null && requestContext.getAccessKeyId() != null) {+ String accessKey = requestContext.getAccessKeyId();+ caller = iamService == null ? "access-key:" + accessKey+ : iamService.resolveCallerArn(accessKey).orElse("access-key:" + accessKey);+ }+ return new RedshiftDataSessions.Scope(store.accountId(), region, caller == null ? "anonymous" : caller);+ }++ private Admission replay(RedshiftDataIdempotencyStore.Receipt receipt, RedshiftDataIdempotencyStore.Scope scope,+ RedshiftDataSessions.Scope owner, String principal) {+ if (receipt.sessionOwner != null) {+ String caller = owner.caller() == null ? sessionScope(scope.region(), principal).caller() : owner.caller();+ if (!Objects.equals(receipt.sessionOwner, caller)) {+ throw new AwsException("ResourceNotFoundException", "Session was not found", 400);+ }+ }+ String id = receipt.response.path("Id").asText();+ RedshiftDataStatementStore.StoredStatement current = store.getForAccount(scope.accountId(), id);+ return new Admission(scope.accountId(), id, current == null ? receipt.response : executeResponse(current),+ executor.execution(scope.accountId(), id));+ }+private record Admission(String accountId, String id, ObjectNode response, RedshiftDataExecution execution) { }private static final class AdmissionLock {@@ -158,10 +228,7 @@ public class RedshiftDataService implements Resettable {if (receipt == null) {return submit(pending, principal, scope);}- String id = receipt.response.path("Id").asText();- RedshiftDataStatementStore.StoredStatement current = store.getForAccount(scope.accountId(), id);- return new Admission(scope.accountId(), id, current == null ? receipt.response : executeResponse(current),- executor.execution(scope.accountId(), id));+ return replay(receipt, scope, pending.owner(), principal);} finally {scoped.lock.unlock();admissionLocks.compute(scope, (key, existing) -> --scoped.users == 0 ? null : scoped);@@ -173,6 +240,10 @@ public class RedshiftDataService implements Resettable {if (principal != null) {stored.principal = principal;}+ RedshiftDataSessions.Reservation session = sessions.reserve(pending.owner(), pending.request(), pending.target());+ if (session != null) {+ stored.sessionId = session.id();+ }ObjectNode response = executeResponse(stored.snapshot());RedshiftDataExecution handle;try {@@ -182,23 +253,41 @@ public class RedshiftDataService implements Resettable {store.putForAccount(stored.accountId, stored);} else {store.admitForAccount(stored.accountId, stored);- idempotency.put(scope, response);+ if (session == null) {+ idempotency.put(scope, response);+ } else {+ idempotency.put(scope, response, pending.owner().caller());+ }+ }+ if (session != null) {+ session.admitted();}},execution -> {try {execution.checkCancellation();+ if (session != null) {+ session.bind(execution);+ }stored.status = RedshiftDataStatementStore.Status.STARTED;executor.publish(execution, () -> store.putForAccount(stored.accountId, stored));- pending.run().accept(execution);+ pending.run().accept(execution, session);} catch (Exception failure) {stored.status = RedshiftDataStatementStore.Status.FAILED;stored.error = failure.getMessage();+ } finally {+ execution.terminal();+ if (session != null) {+ session.finish();+ }}complete(stored, execution);},(execution, failure) -> recoverStatement(stored, execution, failure));} catch (RuntimeException failure) {+ if (session != null) {+ session.abort();+ }try {if (scope != null) {idempotency.removeIfStatement(scope, stored.id);@@ -275,54 +364,121 @@ public class RedshiftDataService implements Resettable {}}- private PendingStatement prepareStatement(JsonNode request, String region) {+ private PendingStatement prepareStatement(JsonNode request, String region, RedshiftDataSessions.Scope owner) {String sql = requiredText(request, "Sql");rejectMultiStatement(sql);Map<String, String> parameters = RedshiftDataSqlParameters.parseParameters(request, "Parameters");- RedshiftDataResourceResolver.DatabaseTarget target = resolver.resolve(request, region);+ ResolvedTarget resolved = resolveTarget(request, region, owner);+ RedshiftDataResourceResolver.DatabaseTarget target = resolved.target();RedshiftDataStatementStore.StoredStatement stored = newStatement(request);stored.sql = sql;stored.sqls = List.of(sql);- stored.clusterIdentifier = clusterIdentifierOrNull(request);- stored.workgroupName = workgroupNameOrNull(request);+ stored.clusterIdentifier = clusterIdentifierOrNull(resolved.parameters());+ stored.workgroupName = workgroupNameOrNull(resolved.parameters());stored.dbUser = target.user();stored.database = target.database();stored.resultFormat = request.path("ResultFormat").asText("JSON");capture(stored, target, region, request);- return new PendingStatement(stored, execution -> runStatement(stored, target, sql, parameters, execution));+ return new PendingStatement(stored, (execution, session) -> runStatement(stored, target, sql, parameters, execution, session),+ target, request.deepCopy(), owner);}private record PendingStatement(RedshiftDataStatementStore.StoredStatement statement,- Consumer<RedshiftDataExecution> run) { }+ BiConsumer<RedshiftDataExecution, RedshiftDataSessions.Reservation> run,+ RedshiftDataResourceResolver.DatabaseTarget target, JsonNode request,+ RedshiftDataSessions.Scope owner) { }++ private record ResolvedTarget(RedshiftDataResourceResolver.DatabaseTarget target, JsonNode parameters) { }++ private ResolvedTarget resolveTarget(JsonNode request, String region, RedshiftDataSessions.Scope owner) {+ if (request.has("SessionId")) {+ RedshiftDataSessions.Session session = sessions.find(owner, request.get("SessionId").asText());+ return new ResolvedTarget(session.target(request), session.parameters());+ }+ return new ResolvedTarget(resolver.resolve(request, region), request);+ }++ private ConnectionUse connection(RedshiftDataResourceResolver.DatabaseTarget target,+ RedshiftDataSessions.Reservation session) throws SQLException {+ return new ConnectionUse(session == null ? connectionFactory.open(target) : session.connection(connectionFactory), session);+ }++ private record ConnectionUse(Connection connection, RedshiftDataSessions.Reservation session) implements AutoCloseable {+ @Override+ public void close() throws SQLException {+ if (session == null) {+ connection.close();+ return;+ }+ try {+ if (connection.isClosed()) {+ session.discard();+ } else if (!session.inTransaction() && !connection.getAutoCommit()) {+ // A failed batch or worker must not leak an open transaction to the next request.+ connection.rollback();+ connection.setAutoCommit(true);+ }+ } catch (SQLException | RuntimeException failure) {+ try {+ session.discard();+ } catch (RuntimeException cleanupFailure) {+ failure.addSuppressed(cleanupFailure);+ }+ throw failure;+ }+ }+ }private void runStatement(RedshiftDataStatementStore.StoredStatement stored,RedshiftDataResourceResolver.DatabaseTarget target,- String sql, Map<String, String> parameters, RedshiftDataExecution execution) {- try (Connection connection = connectionFactory.open(target)) {+ String sql, Map<String, String> parameters, RedshiftDataExecution execution,+ RedshiftDataSessions.Reservation session) {+ try (ConnectionUse use = connection(target, session)) {+ Connection connection = use.connection();execution.track(connection);try {+ if (session != null && transactionControl(stored, sql, connection, session, execution)) {+ return;+ }+ if (session != null && session.transactionFailed()) {+ throw new SQLException("Current transaction is aborted; use COMMIT or ROLLBACK to end it", "25P02");+ }boolean autoCommit = AUTO_COMMIT_SQL.matcher(sql).find()|| preparation != null && target.spectrum() != null&& preparation.handlesDdl(sql, target.spectrum());if (autoCommit) {+ if (session != null && session.inTransaction()) {+ throw new SQLException("Statement cannot run inside a transaction block", "25001");+ }execution.commit(() -> runOnConnection(stored, connection, sql, parameters,target.spectrum(), execution, true));} else {runOnConnection(stored, connection, sql, parameters, target.spectrum(), execution, false);execution.commit(() -> {- if (!connection.getAutoCommit()) {+ if ((session == null || !session.inTransaction()) && !connection.getAutoCommit()) {connection.commit();}});}} catch (SQLException failure) {- if (!connection.getAutoCommit()) {+ if (session != null && failure.getSQLState() != null && failure.getSQLState().startsWith("08")) {+ session.discard();+ throw failure;+ }+ if (session != null && session.inTransaction()) {+ session.failTransaction();+ } else if (!connection.getAutoCommit()) {connection.rollback();}throw failure;+ } catch (RuntimeException failure) {+ if (session != null && session.inTransaction()) {+ session.failTransaction();+ }+ throw failure;}} catch (SQLException e) {stored.status = RedshiftDataStatementStore.Status.FAILED;@@ -331,6 +487,52 @@ public class RedshiftDataService implements Resettable {stored.updatedAt = Instant.now();}+ private boolean transactionControl(RedshiftDataStatementStore.StoredStatement stored, String sql,+ Connection connection, RedshiftDataSessions.Reservation session,+ RedshiftDataExecution execution) throws SQLException {+ String normalized = TRANSACTION_COMMENTS.matcher(sql).replaceAll(" ").trim();+ Matcher control = TRANSACTION_CONTROL.matcher(normalized);+ if (!control.matches()) {+ if (TRANSACTION_PREFIX.matcher(normalized).find()) {+ throw new SQLException("Transaction control modifiers are not supported", "0A000");+ }+ return false;+ }+ String command = control.group(1).toUpperCase(Locale.ROOT).split("\\s+")[0];+ execution.commit(() -> {+ switch (command) {+ case "BEGIN", "START" -> {+ if (session.transactionFailed()) {+ throw new SQLException("Current transaction is aborted; use COMMIT or ROLLBACK to end it", "25P02");+ }+ connection.setAutoCommit(false);+ session.transaction(true);+ }+ case "COMMIT", "END" -> {+ if (!connection.getAutoCommit()) {+ if (session.transactionFailed()) {+ connection.rollback();+ } else {+ connection.commit();+ }+ }+ session.transaction(false);+ connection.setAutoCommit(true);+ }+ default -> {+ if (!connection.getAutoCommit()) {+ connection.rollback();+ }+ session.transaction(false);+ connection.setAutoCommit(true);+ }+ }+ });+ stored.status = RedshiftDataStatementStore.Status.FINISHED;+ stored.updatedAt = Instant.now();+ return true;+ }+/*** Redshift has no line, json or jsonb type and fails a statement that produces one with* exactly these messages (checked on a real cluster 2026-09-13).@@ -419,7 +621,11 @@ public class RedshiftDataService implements Resettable {response.putArray("DbGroups");putWorkgroupName(response, stored);response.put("HasResultSet", stored.hasResultSet);- response.putNull("SessionId");+ if (stored.sessionId == null) {+ response.putNull("SessionId");+ } else {+ response.put("SessionId", stored.sessionId);+ }return response;}@@ -428,6 +634,9 @@ public class RedshiftDataService implements Resettable {public ObjectNode describeStatement(JsonNode request) {RedshiftDataStatementStore.StoredStatement stored = require(request);ObjectNode response = objectMapper.createObjectNode();+ if (stored.sessionId != null) {+ response.put("SessionId", stored.sessionId);+ }response.put("Id", stored.id);response.put("Status", stored.status.name());response.put("CreatedAt", epochSeconds(stored.createdAt));@@ -566,7 +775,7 @@ public class RedshiftDataService implements Resettable {return execute(request, region, principal, true);}- private PendingStatement prepareBatch(JsonNode request, String region) {+ private PendingStatement prepareBatch(JsonNode request, String region, RedshiftDataSessions.Scope owner) {JsonNode sqlsNode = request.get("Sqls");if (sqlsNode == null || !sqlsNode.isArray() || sqlsNode.isEmpty()) {throw new AwsException("ValidationException", "Sqls must be a non-empty array of SQL statements.", 400);@@ -576,27 +785,40 @@ public class RedshiftDataService implements Resettable {sqls.add(n.asText());}- RedshiftDataResourceResolver.DatabaseTarget target = resolver.resolve(request, region);+ ResolvedTarget resolved = resolveTarget(request, region, owner);+ RedshiftDataResourceResolver.DatabaseTarget target = resolved.target();RedshiftDataStatementStore.StoredStatement parent = newStatement(request);parent.batch = true;parent.sql = String.join("; ", sqls);parent.sqls = sqls;- parent.clusterIdentifier = clusterIdentifierOrNull(request);- parent.workgroupName = workgroupNameOrNull(request);+ parent.clusterIdentifier = clusterIdentifierOrNull(resolved.parameters());+ parent.workgroupName = workgroupNameOrNull(resolved.parameters());parent.dbUser = target.user();parent.database = target.database();parent.resultFormat = request.path("ResultFormat").asText("JSON");parent.subStatements = new ArrayList<>();capture(parent, target, region, request);- return new PendingStatement(parent, execution -> runBatch(parent, sqls, target, execution));+ return new PendingStatement(parent, (execution, session) -> runBatch(parent, sqls, target, execution, session),+ target, request.deepCopy(), owner);}private void runBatch(RedshiftDataStatementStore.StoredStatement parent, List<String> sqls,- RedshiftDataResourceResolver.DatabaseTarget target, RedshiftDataExecution execution) {+ RedshiftDataResourceResolver.DatabaseTarget target, RedshiftDataExecution execution,+ RedshiftDataSessions.Reservation session) {long totalDuration = 0;- try (Connection connection = connectionFactory.open(target)) {+ if (session != null) {+ if (session.transactionFailed()) {+ parent.status = RedshiftDataStatementStore.Status.FAILED;+ parent.error = "Current transaction is aborted; use COMMIT or ROLLBACK to end it";+ parent.updatedAt = Instant.now();+ return;+ }+ session.transaction(false);+ }+ try (ConnectionUse use = connection(target, session)) {+ Connection connection = use.connection();execution.track(connection);BackendSql batchBackend = new RedshiftDataBackendSql(connection, execution);boolean committed = false;@@ -612,6 +834,7 @@ public class RedshiftDataService implements Resettable {sub.workgroupName = parent.workgroupName;sub.database = parent.database;sub.dbUser = parent.dbUser;+ sub.sessionId = parent.sessionId;sub.resultFormat = parent.resultFormat;Instant now = Instant.now();sub.createdAt = now;@@ -628,6 +851,10 @@ public class RedshiftDataService implements Resettable {totalDuration += sub.durationNanos;parent.status = RedshiftDataStatementStore.Status.FAILED;parent.error = e.getMessage();+ if (session != null && e.getSQLState() != null && e.getSQLState().startsWith("08")) {+ session.discard();+ throw e;+ }connection.rollback();failed = true;break;@@ -703,6 +930,9 @@ public class RedshiftDataService implements Resettable {RedshiftDataStatementStore.StoredStatement s = all.get(i);ObjectNode node = statements.addObject();node.put("Id", s.id);+ if (s.sessionId != null) {+ node.put("SessionId", s.sessionId);+ }node.put("QueryString", s.sql);ArrayNode queryStrings = node.putArray("QueryStrings");for (String sql : s.sqls != null ? s.sqls : List.of(s.sql)) {diff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataSessions.java b/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataSessions.javanew file mode 100644index 0000000000..2466343f5e--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataSessions.java@@ -0,0 +1,423 @@+package io.github.hectorvent.floci.services.redshiftdata;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.AwsException;+import jakarta.annotation.PostConstruct;+import jakarta.annotation.PreDestroy;+import jakarta.enterprise.context.ApplicationScoped;+import org.jboss.logging.Logger;++import java.sql.Connection;+import java.sql.SQLException;+import java.time.Clock;+import java.time.Duration;+import java.time.Instant;+import java.util.List;+import java.util.Objects;+import java.util.UUID;+import java.util.concurrent.ConcurrentHashMap;+import java.util.concurrent.Executors;+import java.util.concurrent.ScheduledExecutorService;+import java.util.concurrent.TimeUnit;+import java.util.concurrent.atomic.AtomicBoolean;+import java.util.regex.Pattern;++@ApplicationScoped+class RedshiftDataSessions implements AutoCloseable {+ private static final Logger LOG = Logger.getLogger(RedshiftDataSessions.class);+ private static final Pattern SESSION_ID = Pattern.compile("[a-z0-9]{8}(-[a-z0-9]{4}){3}-[a-z0-9]{12}(:\\d{0,2})?");+ private static final Duration MAX_AGE = Duration.ofHours(24);+ private static final List<String> TARGET_FIELDS = List.of("ClusterIdentifier", "WorkgroupName", "Database", "DbUser", "SecretArn");++ private final ConcurrentHashMap<String, Session> sessions = new ConcurrentHashMap<>();+ private final Clock clock;+ private ScheduledExecutorService sweeper;+ private boolean closed;++ RedshiftDataSessions() {+ this(Clock.systemUTC());+ }++ RedshiftDataSessions(Clock clock) {+ this.clock = clock;+ }++ @PostConstruct+ void start() {+ sweeper = Executors.newSingleThreadScheduledExecutor(task -> {+ Thread thread = new Thread(task, "redshift-data-session-sweep");+ thread.setDaemon(true);+ return thread;+ });+ sweeper.scheduleAtFixedRate(this::sweepSafely, 1, 1, TimeUnit.SECONDS);+ }++ static void validate(JsonNode request) {+ keepAlive(request);+ JsonNode id = request.get("SessionId");+ if (id != null && (!id.isTextual() || !SESSION_ID.matcher(id.textValue()).matches())) {+ throw validation("SessionId must be a valid session identifier");+ }+ }++ private static Integer keepAlive(JsonNode request) {+ JsonNode seconds = request.get("SessionKeepAliveSeconds");+ if (seconds == null) {+ return null;+ }+ if (!seconds.isIntegralNumber() || !seconds.canConvertToInt() || seconds.intValue() < 0 || seconds.intValue() > 86400) {+ throw validation("SessionKeepAliveSeconds must be an integer between 0 and 86400");+ }+ return seconds.intValue();+ }++ Session find(Scope owner, String id) {+ Session session = sessions.get(id);+ if (session == null || !session.owner.equals(owner)) {+ throw missing();+ }+ synchronized (session) {+ if (!session.closed && !expired(session)) {+ return session;+ }+ }+ retire(session);+ throw missing();+ }++ Reservation reserve(Scope owner, JsonNode request, RedshiftDataResourceResolver.DatabaseTarget target) {+ Integer seconds = keepAlive(request);+ String id = request.has("SessionId") ? request.get("SessionId").asText() : null;+ if (id == null && (seconds == null || seconds == 0)) {+ return null;+ }+ Session session;+ boolean created = id == null;+ if (created) {+ sweepSafely();+ synchronized (this) {+ if (closed) {+ throw validation("Data API sessions are shutting down");+ }+ long count = sessions.values().stream().filter(existing -> existing.target.arn().equals(target.arn())+ && existing.owner.accountId().equals(owner.accountId()) && existing.owner.region().equals(owner.region())).count();+ if (count >= 500) {+ throw new AwsException("ActiveSessionsExceededException", "Too many active sessions for this resource", 400);+ }+ session = new Session(owner, target, request, clock.instant());+ sessions.put(session.id, session);+ }+ } else {+ session = find(owner, id);+ }+ synchronized (session) {+ if (session.closed || expired(session)) {+ throw missing();+ }+ if (session.active != null) {+ throw validation("Session is busy; wait for its current statement to finish");+ }+ Reservation reservation = new Reservation(session, created, seconds == null ? session.keepAlive : seconds);+ session.active = reservation;+ return reservation;+ }+ }++ void sweep() {+ RuntimeException failure = null;+ for (Session session : sessions.values()) {+ boolean expire;+ synchronized (session) {+ expire = expired(session);+ }+ if (expire) {+ try {+ retire(session);+ } catch (RuntimeException cleanupFailure) {+ failure = accumulate(failure, cleanupFailure);+ }+ }+ }+ if (failure != null) {+ throw failure;+ }+ }++ private void sweepSafely() {+ try {+ sweep();+ } catch (RuntimeException failure) {+ // Maintenance has no request to report to; keep future sweeps running and report the failure.+ LOG.errorv(failure, "Failed to clean up expired Redshift Data API sessions");+ }+ }++ private boolean expired(Session session) {+ Instant now = clock.instant();+ return !now.isBefore(session.createdAt.plus(MAX_AGE))+ || session.active == null && !now.isBefore(session.idleUntil);+ }++ private void retire(Session session) {+ retire(session, true);+ }++ private void retire(Session session, boolean cancel) {+ Retirement retirement;+ synchronized (session) {+ retirement = retireLocked(session, cancel);+ }+ cleanUp(retirement);+ }++ private Retirement retireLocked(Session session, boolean cancel) {+ if (session.closed) {+ return null;+ }+ session.closed = true;+ sessions.remove(session.id, session);+ Retirement retirement = new Retirement(session.id, session.connection, cancel ? session.execution : null);+ session.active = null;+ session.execution = null;+ session.connection = null;+ return retirement;+ }++ private record Retirement(String id, Connection connection, RedshiftDataExecution execution) { }++ private static void cleanUp(Retirement retirement) {+ if (retirement == null) {+ return;+ }+ Runnable cleanup = () -> {+ try {+ if (retirement.execution() != null) {+ retirement.execution().cancel();+ }+ } finally {+ closeConnection(retirement.connection(), retirement.id());+ }+ };+ if (retirement.execution() == null) {+ cleanup.run();+ } else {+ Thread.startVirtualThread(() -> {+ try {+ cleanup.run();+ } catch (RuntimeException failure) {+ // Expiration/reset cancellation finishes asynchronously after the session is unavailable.+ LOG.errorv(failure, "Failed to clean up Redshift Data API session {0}", retirement.id());+ }+ });+ }+ }++ private static void closeConnection(Connection connection, String id) {+ if (connection != null) {+ try {+ connection.close();+ } catch (SQLException | RuntimeException failure) {+ if (failure instanceof SQLException sql && "08003".equals(sql.getSQLState())) {+ LOG.debugv("Redshift Data API session {0} connection was already closed", id);+ } else {+ throw new IllegalStateException("Unable to close Redshift Data API session " + id + ": " + failure.getMessage(), failure);+ }+ }+ }+ }++ synchronized void clear() {+ RuntimeException failure = null;+ for (Session session : sessions.values()) {+ try {+ retire(session);+ } catch (RuntimeException cleanupFailure) {+ failure = accumulate(failure, cleanupFailure);+ }+ }+ if (failure != null) {+ throw failure;+ }+ }++ private static RuntimeException accumulate(RuntimeException first, RuntimeException next) {+ if (first == null) {+ return next;+ }+ if (first != next) {+ first.addSuppressed(next);+ }+ return first;+ }++ @Override+ @PreDestroy+ public synchronized void close() {+ closed = true;+ if (sweeper != null) {+ sweeper.shutdownNow();+ }+ clear();+ }++ record Scope(String accountId, String region, String caller) { }++ static final class Session {+ private final String id = UUID.randomUUID().toString();+ private final Scope owner;+ private final RedshiftDataResourceResolver.DatabaseTarget target;+ private final ObjectNode parameters;+ private final Instant createdAt;+ private Instant idleUntil;+ private int keepAlive;+ private boolean closed;+ private boolean transaction;+ private boolean transactionFailed;+ private Connection connection;+ private RedshiftDataExecution execution;+ private Reservation active;++ private Session(Scope owner, RedshiftDataResourceResolver.DatabaseTarget target, JsonNode request, Instant createdAt) {+ this.owner = owner;+ this.target = target;+ this.parameters = ((ObjectNode) request).objectNode();+ for (String field : TARGET_FIELDS) {+ if (request.has(field)) {+ parameters.set(field, request.get(field).deepCopy());+ }+ }+ this.createdAt = createdAt;+ this.idleUntil = createdAt.plus(MAX_AGE);+ }++ RedshiftDataResourceResolver.DatabaseTarget target(JsonNode request) {+ for (String field : TARGET_FIELDS) {+ JsonNode value = request.get(field);+ if (value != null && !Objects.equals(value, parameters.get(field))+ && !("WorkgroupName".equals(field) && value.isTextual() && target.arn().equals(value.textValue()))) {+ throw validation(field + " does not match the session");+ }+ }+ return target;+ }++ ObjectNode parameters() {+ return parameters.deepCopy();+ }+ }++ final class Reservation {+ private final Session session;+ private final boolean created;+ private final int seconds;+ private final AtomicBoolean released = new AtomicBoolean();+ private boolean admitted;++ private Reservation(Session session, boolean created, int seconds) {+ this.session = session;+ this.created = created;+ this.seconds = seconds;+ }++ String id() {+ return session.id;+ }++ void admitted() {+ admitted = true;+ }++ void bind(RedshiftDataExecution execution) throws SQLException {+ synchronized (session) {+ if (session.closed || expired(session)) {+ throw new SQLException("Session has expired", "08003");+ }+ session.execution = execution;+ }+ }++ Connection connection(RedshiftDataConnectionFactory factory) throws SQLException {+ synchronized (session) {+ if (session.closed) {+ throw new SQLException("Session has expired", "08003");+ }+ if (session.connection != null) {+ return session.connection;+ }+ }+ Connection opened = factory.open(session.target);+ synchronized (session) {+ if (!session.closed && !expired(session)) {+ session.connection = opened;+ return opened;+ }+ }+ closeConnection(opened, session.id);+ throw new SQLException("Session has expired", "08003");+ }++ boolean inTransaction() {+ return session.transaction;+ }++ void transaction(boolean active) {+ session.transaction = active;+ if (!active) {+ session.transactionFailed = false;+ }+ }++ boolean transactionFailed() {+ return session.transactionFailed;+ }++ void failTransaction() {+ session.transactionFailed = true;+ }++ void abort() {+ release(false);+ }++ void finish() {+ release(admitted);+ }++ void discard() {+ retire(session, false);+ }++ private void release(boolean completed) {+ if (!released.compareAndSet(false, true)) {+ return;+ }+ Retirement retirement = null;+ synchronized (session) {+ if (session.active != this) {+ return;+ }+ boolean remove = !completed && created || completed && (seconds == 0 || session.connection == null);+ if (remove) {+ retirement = retireLocked(session, false);+ } else {+ session.active = null;+ session.execution = null;+ if (completed) {+ session.keepAlive = seconds;+ session.idleUntil = clock.instant().plusSeconds(seconds);+ }+ }+ }+ cleanUp(retirement);+ }+ }++ private static AwsException validation(String message) {+ return new AwsException("ValidationException", message, 400);+ }++ private static AwsException missing() {+ return new AwsException("ResourceNotFoundException", "Session was not found or is no longer available", 400);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataStatementStore.java b/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataStatementStore.javaindex c420032f81..879952d86f 100644--- a/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataStatementStore.java+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataStatementStore.java@@ -130,6 +130,10 @@ class RedshiftDataStatementStore {statements.clear();}+ String accountId() {+ return statements.accountId();+ }+void sweep() {if (idempotency != null) {try {@@ -171,6 +175,7 @@ class RedshiftDataStatementStore {String workgroupName;String database;String dbUser;+ String sessionId;String resultFormat = "JSON";Status status;String error;@@ -214,6 +219,7 @@ class RedshiftDataStatementStore {copy.workgroupName = workgroupName;copy.database = database;copy.dbUser = dbUser;+ copy.sessionId = sessionId;copy.resultFormat = resultFormat;copy.status = status;copy.error = error;diff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataApiIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataApiIntegrationTest.javaindex 5e66ec0b30..1cab126483 100644--- a/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataApiIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataApiIntegrationTest.java@@ -2,6 +2,7 @@ package io.github.hectorvent.floci.services.redshiftdata;import io.github.hectorvent.floci.services.redshift.RedshiftService;import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.common.http.TestHTTPResource;import io.quarkus.test.junit.QuarkusTest;import io.restassured.response.ExtractableResponse;import io.restassured.response.Response;@@ -12,7 +13,14 @@ import org.junit.jupiter.api.Assumptions;import org.junit.jupiter.api.BeforeAll;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.TestInstance;-+import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;+import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;+import software.amazon.awssdk.regions.Region;+import software.amazon.awssdk.services.redshiftdata.RedshiftDataClient;+import software.amazon.awssdk.services.redshiftdata.model.ExecuteStatementResponse;+import software.amazon.awssdk.services.redshiftdata.model.ResourceNotFoundException;++import java.net.URI;import java.time.Duration;import java.util.List;@@ -20,6 +28,8 @@ import static org.hamcrest.Matchers.containsString;import static org.hamcrest.Matchers.hasItem;import static org.hamcrest.Matchers.is;import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;@QuarkusTest@@ -31,6 +41,9 @@ class RedshiftDataApiIntegrationTest {@InjectRedshiftService redshift;+ @TestHTTPResource("/")+ URI endpoint;+private String clusterId;@BeforeAll@@ -87,6 +100,34 @@ class RedshiftDataApiIntegrationTest {return ((Number) value).intValue();}+ @Test+ void sdkSessionPreservesPostgresTemporaryTablesAcrossExecuteAndBatch() {+ try (RedshiftDataClient data = RedshiftDataClient.builder().endpointOverride(endpoint).region(Region.US_EAST_1)+ .credentialsProvider(StaticCredentialsProvider.create(AwsBasicCredentials.create("test", "test"))).build()) {+ ExecuteStatementResponse created = data.executeStatement(request -> request.clusterIdentifier(clusterId)+ .dbUser("admin").database("dev").sessionKeepAliveSeconds(60)+ .sql("CREATE TEMP TABLE session_rows(id integer)"));+ assertNotNull(created.sessionId());+ awaitFinished(created.id());+ String session = created.sessionId();+ awaitFinished(data.batchExecuteStatement(request -> request.sessionId(session)+ .sqls("INSERT INTO session_rows VALUES (41)", "INSERT INTO session_rows VALUES (42)")).id());+ awaitFinished(data.executeStatement(request -> request.sessionId(session).sql("VACUUM")).id());+ awaitFinished(data.executeStatement(request -> request.sessionId(session).sql("BEGIN")).id());+ awaitFinished(data.executeStatement(request -> request.sessionId(session).sql("INSERT INTO session_rows VALUES (99)")).id());+ awaitFinished(data.executeStatement(request -> request.sessionId(session).sql("ROLLBACK")).id());+ String query = data.executeStatement(request -> request.sessionId(session).sql("SELECT id FROM session_rows ORDER BY id")).id();+ awaitFinished(query);+ assertEquals(session, data.describeStatement(request -> request.id(query)).sessionId());+ assertEquals(2L, data.getStatementResult(request -> request.id(query)).totalNumRows());+ assertEquals(41L, data.getStatementResult(request -> request.id(query)).records().getFirst().getFirst().longValue());+ String last = data.executeStatement(request -> request.sessionId(session).sessionKeepAliveSeconds(0).sql("SELECT 1")).id();+ awaitFinished(last);+ assertThrows(ResourceNotFoundException.class,+ () -> data.executeStatement(request -> request.sessionId(session).sql("SELECT 1")));+ }+ }+@Testvoid vacuumPreservesAutoCommitExecution() {executeAndWait("VACUUM");diff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataExecutionTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataExecutionTest.javaindex c2a3915051..bbf32674cd 100644--- a/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataExecutionTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataExecutionTest.java@@ -42,6 +42,24 @@ class RedshiftDataExecutionTest {}}+ @Test+ void cancellationSignalHoldsExecutionMonitor() throws Exception {+ RedshiftDataExecution execution = new RedshiftDataExecution(0);+ Statement statement = mock(Statement.class);+ execution.track(statement);+ assertTrue(execution.requestCancellation());+ doAnswer(invocation -> {+ assertTrue(Thread.holdsLock(execution));+ return null;+ }).when(statement).cancel();++ execution.signalCancellation();+ execution.terminal();+ execution.signalCancellation();+ verify(statement).cancel();+ execution.completed();+ }+@Testvoid successfulCommitWinsOverCancellation() throws Exception {try (RedshiftDataExecutor executor = new RedshiftDataExecutor(1, 1, 1)) {diff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataSessionIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataSessionIntegrationTest.javanew file mode 100644index 0000000000..4d9b4449d4--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataSessionIntegrationTest.java@@ -0,0 +1,147 @@+package io.github.hectorvent.floci.services.redshiftdata;++import com.fasterxml.jackson.databind.JsonNode;+import io.github.hectorvent.floci.core.common.AwsArnUtils;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.quarkus.test.InjectMock;+import io.quarkus.test.common.http.TestHTTPResource;+import io.quarkus.test.junit.QuarkusTest;+import jakarta.inject.Inject;+import org.h2.Driver;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.ValueSource;+import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;+import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;+import software.amazon.awssdk.regions.Region;+import software.amazon.awssdk.services.redshiftdata.RedshiftDataClient;+import software.amazon.awssdk.services.redshiftdata.model.DescribeStatementResponse;+import software.amazon.awssdk.services.redshiftdata.model.ExecuteStatementRequest;+import software.amazon.awssdk.services.redshiftdata.model.ExecuteStatementResponse;+import software.amazon.awssdk.services.redshiftdata.model.ResourceNotFoundException;+import software.amazon.awssdk.services.redshiftdata.model.StatusString;+import software.amazon.awssdk.services.redshiftdata.model.ValidationException;++import java.net.URI;+import java.sql.DriverManager;+import java.util.UUID;++import static org.junit.jupiter.api.Assertions.*;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.Mockito.*;++@QuarkusTest+class RedshiftDataSessionIntegrationTest {+ @TestHTTPResource("/")+ URI endpoint;+ @InjectMock+ RedshiftDataResourceResolver resolver;+ @InjectMock+ RedshiftDataConnectionFactory factory;+ @Inject+ RedshiftDataService service;+ @Inject+ RegionResolver regions;++ private RedshiftDataClient data;++ @BeforeEach+ void setup() throws Exception {+ Driver.load();+ String url = "jdbc:h2:mem:" + UUID.randomUUID();+ when(factory.open(any())).thenAnswer(invocation -> DriverManager.getConnection(url));+ when(resolver.resolve(any(), any())).thenAnswer(invocation -> {+ JsonNode request = invocation.getArgument(0);+ String region = invocation.getArgument(1);+ boolean serverless = request.has("WorkgroupName");+ String arn = AwsArnUtils.Arn.of(serverless ? "redshift-serverless" : "redshift", region,+ regions.getAccountId(), serverless ? "workgroup/12345678-1234-1234-1234-123456789012" : "cluster:warehouse").toString();+ return new RedshiftDataResourceResolver.DatabaseTarget(arn, "localhost", 5439, "dev", "admin", "password");+ });+ data = client("test", Region.US_EAST_1);+ }++ @AfterEach+ void cleanup() {+ service.clear();+ if (data != null) {+ data.close();+ }+ }++ @ParameterizedTest+ @ValueSource(booleans = {false, true})+ void sdkReusesSessionForSingleAndBatchStatements(boolean serverless) throws Exception {+ ExecuteStatementRequest.Builder request = ExecuteStatementRequest.builder().waitTimeSeconds(30).database("dev")+ .sessionKeepAliveSeconds(60).sql("CREATE LOCAL TEMPORARY TABLE staging(id integer)");+ if (serverless) {+ request.workgroupName("analytics");+ } else {+ request.clusterIdentifier("warehouse").dbUser("admin");+ }+ ExecuteStatementResponse created = data.executeStatement(request.build());+ assertNotNull(created.sessionId());+ finished(created.id());+ String batch = data.batchExecuteStatement(r -> r.waitTimeSeconds(30).sessionId(created.sessionId())+ .sqls("INSERT INTO staging VALUES (41)", "INSERT INTO staging VALUES (42)")).id();+ finished(batch);+ ExecuteStatementResponse query = data.executeStatement(r -> r.waitTimeSeconds(30).sessionId(created.sessionId()).sql("SELECT id FROM staging ORDER BY id"));+ DescribeStatementResponse described = finished(query.id());++ assertEquals(created.sessionId(), described.sessionId());+ assertEquals(created.sessionId(), query.sessionId());+ assertEquals(41L, data.getStatementResult(r -> r.id(query.id())).records().getFirst().getFirst().longValue());+ assertEquals(2L, data.getStatementResult(r -> r.id(query.id())).totalNumRows());+ assertTrue(data.listStatements(r -> r.maxResults(100)).statements().stream()+ .anyMatch(statement -> created.sessionId().equals(statement.sessionId())));+ verify(factory).open(any());+ }++ @Test+ void sdkSessionIsIsolatedByCallerAccountAndRegion() {+ ExecuteStatementResponse created = data.executeStatement(r -> r.waitTimeSeconds(30).clusterIdentifier("warehouse").dbUser("admin")+ .database("dev").sessionKeepAliveSeconds(60).sql("SELECT 1"));+ finished(created.id());+ for (String key : new String[]{"another-caller", "111111111111"}) {+ try (RedshiftDataClient other = client(key, Region.US_EAST_1)) {+ assertThrows(ResourceNotFoundException.class, () -> other.executeStatement(r -> r.waitTimeSeconds(30).sessionId(created.sessionId()).sql("SELECT 2")));+ }+ }+ try (RedshiftDataClient otherRegion = client("test", Region.US_WEST_2)) {+ assertThrows(ResourceNotFoundException.class, () -> otherRegion.executeStatement(r -> r.waitTimeSeconds(30).sessionId(created.sessionId()).sql("SELECT 2")));+ }+ finished(data.executeStatement(r -> r.waitTimeSeconds(30).sessionId(created.sessionId()).sql("SELECT 3")).id());+ }++ @Test+ void sdkValidatesKeepAliveAndReplaysAClosedSessionReceipt() {+ assertThrows(ValidationException.class, () -> data.executeStatement(r -> r.waitTimeSeconds(30).clusterIdentifier("warehouse")+ .dbUser("admin").database("dev").sessionKeepAliveSeconds(86401).sql("SELECT 1")));+ ExecuteStatementResponse created = data.executeStatement(r -> r.waitTimeSeconds(30).clusterIdentifier("warehouse").dbUser("admin")+ .database("dev").sessionKeepAliveSeconds(60).sql("SELECT 1"));+ finished(created.id());+ ExecuteStatementRequest last = ExecuteStatementRequest.builder().waitTimeSeconds(30).sessionId(created.sessionId()).sessionKeepAliveSeconds(0)+ .clientToken(UUID.randomUUID().toString()).sql("SELECT 2").build();+ ExecuteStatementResponse closed = data.executeStatement(last);+ finished(closed.id());+ assertEquals(closed.id(), data.executeStatement(last).id());+ assertEquals(closed.sessionId(), data.executeStatement(last).sessionId());+ try (RedshiftDataClient other = client("another-caller", Region.US_EAST_1)) {+ assertThrows(ResourceNotFoundException.class, () -> other.executeStatement(last));+ }+ assertThrows(ResourceNotFoundException.class, () -> data.executeStatement(r -> r.waitTimeSeconds(30).sessionId(created.sessionId()).sql("SELECT 3")));+ }++ private RedshiftDataClient client(String key, Region region) {+ return RedshiftDataClient.builder().endpointOverride(endpoint).region(region)+ .credentialsProvider(StaticCredentialsProvider.create(AwsBasicCredentials.create(key, "test"))).build();+ }++ private DescribeStatementResponse finished(String id) {+ DescribeStatementResponse statement = data.describeStatement(r -> r.id(id));+ assertEquals(StatusString.FINISHED, statement.status(), statement.error());+ return statement;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataSessionServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataSessionServiceTest.javanew file mode 100644index 0000000000..cdca3ca55b--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataSessionServiceTest.java@@ -0,0 +1,537 @@+package io.github.hectorvent.floci.services.redshiftdata;++import com.fasterxml.jackson.databind.JsonNode;+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.RequestContext;+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;+import io.github.hectorvent.floci.services.iam.IamService;+import org.h2.Driver;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.ValueSource;++import java.sql.Connection;+import java.sql.DriverManager;+import java.sql.PreparedStatement;+import java.sql.ResultSet;+import java.sql.SQLException;+import java.sql.Statement;+import java.time.Clock;+import java.time.Duration;+import java.util.ArrayList;+import java.util.List;+import java.util.Optional;+import java.util.UUID;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.TimeUnit;++import static org.junit.jupiter.api.Assertions.*;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.Mockito.*;++class RedshiftDataSessionServiceTest {++ @Test+ void sessionOnlyRequestsShareTemporaryTablesAndReportSessionMetadata() throws Exception {+ try (Fixture fixture = new Fixture()) {+ ObjectNode created = fixture.service.executeStatement(fixture.request(+ "CREATE LOCAL TEMPORARY TABLE staging(id integer)").put("SessionKeepAliveSeconds", 60), "us-east-1");+ assertTrue(created.path("SessionId").isTextual(), "A retained session must have an id");+ String session = created.path("SessionId").asText();+ fixture.service.executeStatement(fixture.reuse(session, "INSERT INTO staging VALUES (42)"), "us-east-1");+ ObjectNode query = fixture.service.executeStatement(fixture.reuse(session, "SELECT id FROM staging"), "us-east-1");+ ObjectNode described = fixture.service.describeStatement(fixture.mapper.createObjectNode().put("Id", query.path("Id").asText()));++ assertEquals("FINISHED", described.path("Status").asText(), described.toString());+ assertEquals(session, described.path("SessionId").asText());+ ObjectNode result = fixture.service.getStatementResult(fixture.mapper.createObjectNode().put("Id", query.path("Id").asText()));+ assertEquals(42, result.path("Records").get(0).get(0).path("longValue").asInt());+ assertEquals(session, fixture.service.listStatements(fixture.mapper.createObjectNode())+ .path("Statements").get(0).path("SessionId").asText());+ verify(fixture.factory).open(any());+ }+ }++ @Test+ void batchAndSingleStatementCanShareOneSession() throws Exception {+ try (Fixture fixture = new Fixture()) {+ ObjectNode request = fixture.request("unused").put("SessionKeepAliveSeconds", 60);+ request.remove("Sql");+ request.putArray("Sqls").add("CREATE LOCAL TEMPORARY TABLE staging(id integer)")+ .add("INSERT INTO staging VALUES (7)");+ ObjectNode batch = fixture.service.batchExecuteStatement(request, "us-east-1");+ String session = batch.path("SessionId").asText();+ ObjectNode query = fixture.service.executeStatement(fixture.reuse(session, "SELECT id FROM staging"), "us-east-1");+ ObjectNode result = fixture.service.getStatementResult(fixture.mapper.createObjectNode().put("Id", query.path("Id").asText()));++ assertEquals(7, result.path("Records").get(0).get(0).path("longValue").asInt());+ verify(fixture.factory).open(any());+ }+ }++ @Test+ void clientTokenRetryKeepsTheOriginalSessionAndExecutesOnce() throws Exception {+ try (Fixture fixture = new Fixture()) {+ ObjectNode request = fixture.request("CREATE LOCAL TEMPORARY TABLE staging(id integer)")+ .put("SessionKeepAliveSeconds", 60).put("ClientToken", "retained-session");+ ObjectNode first = fixture.service.executeStatement(request, "us-east-1");+ ObjectNode retry = fixture.service.executeStatement(request, "us-east-1");++ assertTrue(first.path("SessionId").isTextual());+ assertEquals(first.path("SessionId"), retry.path("SessionId"));+ assertEquals(first.path("Id"), retry.path("Id"));+ verify(fixture.factory).open(any());+ }+ }++ @Test+ void explicitTransactionCanBeRolledBackAcrossCalls() throws Exception {+ try (Fixture fixture = new Fixture()) {+ String session = fixture.service.executeStatement(fixture.request("CREATE TABLE changes(id integer)")+ .put("SessionKeepAliveSeconds", 60), "us-east-1").path("SessionId").asText();+ fixture.service.executeStatement(fixture.reuse(session, "BEGIN"), "us-east-1");+ fixture.service.executeStatement(fixture.reuse(session, "INSERT INTO changes VALUES (1)"), "us-east-1");+ assertEquals(0, fixture.count("changes"));+ fixture.service.executeStatement(fixture.reuse(session, "ROLLBACK"), "us-east-1");+ assertEquals(0, fixture.count("changes"));+ fixture.service.executeStatement(fixture.reuse(session, "BEGIN TRANSACTION"), "us-east-1");+ fixture.service.executeStatement(fixture.reuse(session, "INSERT INTO changes VALUES (2)"), "us-east-1");+ fixture.service.executeStatement(fixture.reuse(session, "COMMIT"), "us-east-1");+ assertEquals(1, fixture.count("changes"));+ fixture.service.executeStatement(fixture.reuse(session, "BEGIN"), "us-east-1");+ fixture.service.executeStatement(fixture.reuse(session, "INSERT INTO changes VALUES (3)"), "us-east-1");+ ObjectNode batch = fixture.reuse(session, "unused");+ batch.remove("Sql");+ batch.putArray("Sqls").add("INSERT INTO changes VALUES (4)");+ fixture.service.batchExecuteStatement(batch, "us-east-1");+ assertEquals(3, fixture.count("changes"));+ }+ }++ @Test+ void failedExplicitTransactionCannotAccidentallyCommitLaterStatements() throws Exception {+ try (Fixture fixture = new Fixture()) {+ String session = fixture.service.executeStatement(fixture.request("CREATE TABLE changes(id integer)")+ .put("SessionKeepAliveSeconds", 60), "us-east-1").path("SessionId").asText();+ fixture.service.executeStatement(fixture.reuse(session, "BEGIN -- keep this transaction open"), "us-east-1");+ fixture.service.executeStatement(fixture.reuse(session, "INSERT INTO changes VALUES (1)"), "us-east-1");+ assertEquals(0, fixture.count("changes"));+ fixture.service.executeStatement(fixture.reuse(session, "INSERT INTO missing_table VALUES (2)"), "us-east-1");+ ObjectNode later = fixture.service.executeStatement(fixture.reuse(session, "INSERT INTO changes VALUES (3)"), "us-east-1");+ assertEquals("FAILED", fixture.service.describeStatement(fixture.mapper.createObjectNode()+ .put("Id", later.path("Id").asText())).path("Status").asText());+ ObjectNode batch = fixture.reuse(session, "unused");+ batch.remove("Sql");+ batch.putArray("Sqls").add("INSERT INTO changes VALUES (9)");+ String batchId = fixture.service.batchExecuteStatement(batch, "us-east-1").path("Id").asText();+ assertEquals("FAILED", fixture.service.describeStatement(fixture.mapper.createObjectNode()+ .put("Id", batchId)).path("Status").asText());+ fixture.service.executeStatement(fixture.reuse(session, "ROLLBACK"), "us-east-1");+ assertEquals(0, fixture.count("changes"));+ fixture.service.executeStatement(fixture.reuse(session, "INSERT INTO changes VALUES (4)"), "us-east-1");+ assertEquals(1, fixture.count("changes"));+ }+ }++ @ParameterizedTest+ @ValueSource(booleans = {false, true})+ void connectionFailureRetiresTheSessionWithoutReportingCancellation(boolean batch) throws Exception {+ try (Fixture fixture = new Fixture()) {+ Connection connection = spy(DriverManager.getConnection(fixture.url));+ doThrow(new SQLException("broken connection", "08006")).when(connection).prepareStatement("SELECT broken");+ when(fixture.factory.open(any())).thenReturn(connection);+ String session = fixture.service.executeStatement(fixture.request("SELECT 1")+ .put("SessionKeepAliveSeconds", 60), "us-east-1").path("SessionId").asText();+ ObjectNode request = fixture.reuse(session, "SELECT broken");+ if (batch) {+ request.remove("Sql");+ request.putArray("Sqls").add("SELECT broken");+ }+ String failed = (batch ? fixture.service.batchExecuteStatement(request, "us-east-1")+ : fixture.service.executeStatement(request, "us-east-1")).path("Id").asText();+ ObjectNode described = fixture.service.describeStatement(fixture.mapper.createObjectNode().put("Id", failed));+ assertEquals("FAILED", described.path("Status").asText());+ assertTrue(connection.isClosed());+ assertThrows(AwsException.class, () -> fixture.service.executeStatement(fixture.reuse(session, "SELECT 2"), "us-east-1"));+ }+ }++ @Test+ void unsupportedTransactionModesFailInsteadOfSilentlyCommitting() throws Exception {+ try (Fixture fixture = new Fixture()) {+ String session = fixture.service.executeStatement(fixture.request("SELECT 1")+ .put("SessionKeepAliveSeconds", 60), "us-east-1").path("SessionId").asText();+ for (String sql : new String[]{"BEGIN ISOLATION LEVEL SERIALIZABLE", "START TRANSACTION READ ONLY", "COMMIT AND CHAIN"}) {+ ObjectNode response = fixture.service.executeStatement(fixture.reuse(session, sql), "us-east-1");+ ObjectNode described = fixture.service.describeStatement(fixture.mapper.createObjectNode().put("Id", response.path("Id").asText()));+ assertEquals("FAILED", described.path("Status").asText());+ assertTrue(described.path("Error").asText().contains("not supported"));+ }+ }+ }++ @Test+ void failedBatchRollsBackWithoutClosingTheReusableConnection() throws Exception {+ try (Fixture fixture = new Fixture()) {+ String session = fixture.service.executeStatement(fixture.request("CREATE LOCAL TEMPORARY TABLE staging(id integer)")+ .put("SessionKeepAliveSeconds", 60), "us-east-1").path("SessionId").asText();+ ObjectNode batch = fixture.reuse(session, "unused");+ batch.remove("Sql");+ batch.putArray("Sqls").add("INSERT INTO staging VALUES (42)").add("INSERT INTO missing_table VALUES (1)");+ String id = fixture.service.batchExecuteStatement(batch, "us-east-1").path("Id").asText();+ assertEquals("FAILED", fixture.service.describeStatement(fixture.mapper.createObjectNode().put("Id", id))+ .path("Status").asText());+ ObjectNode query = fixture.service.executeStatement(fixture.reuse(session, "SELECT COUNT(*) FROM staging"), "us-east-1");+ ObjectNode result = fixture.service.getStatementResult(fixture.mapper.createObjectNode().put("Id", query.path("Id").asText()));+ assertEquals(0, result.path("Records").get(0).get(0).path("longValue").asInt());+ verify(fixture.factory).open(any());+ }+ }++ @Test+ void explicitSessionTerminationStillAllowsIdempotentReplay() throws Exception {+ try (Fixture fixture = new Fixture()) {+ String session = fixture.service.executeStatement(fixture.request("SELECT 1")+ .put("SessionKeepAliveSeconds", 60), "us-east-1").path("SessionId").asText();+ ObjectNode request = fixture.reuse(session, "SELECT 2").put("SessionKeepAliveSeconds", 0).put("ClientToken", "last");+ ObjectNode first = fixture.service.executeStatement(request, "us-east-1");+ ObjectNode retry = fixture.service.executeStatement(request, "us-east-1");+ assertEquals(first.path("Id"), retry.path("Id"));+ AwsException gone = assertThrows(AwsException.class, () -> fixture.service.executeStatement(+ fixture.reuse(session, "SELECT 3"), "us-east-1"));+ assertEquals("ResourceNotFoundException", gone.getErrorCode());+ }+ }++ @Test+ void busySessionRejectsNewQueriesButAllowsClientTokenRetriesAndQueuedCancellation() throws Exception {+ try (Fixture fixture = new Fixture()) {+ String session = fixture.service.executeStatement(fixture.request("SELECT 1")+ .put("SessionKeepAliveSeconds", 60), "us-east-1").path("SessionId").asText();+ CountDownLatch started = new CountDownLatch(2);+ CountDownLatch release = new CountDownLatch(1);+ for (int n = 0; n < 2; n++) {+ fixture.executor.submit("000000000000", "us-east-1", "block-" + n, execution -> {+ started.countDown();+ try {+ release.await(5, TimeUnit.SECONDS);+ } catch (InterruptedException expected) {+ Thread.currentThread().interrupt();+ }+ });+ }+ try {+ assertTrue(started.await(5, TimeUnit.SECONDS));+ ObjectNode request = fixture.reuse(session, "SELECT 2").put("ClientToken", "queued");+ request.remove("WaitTimeSeconds");+ ObjectNode queued = fixture.service.executeStatement(request, "us-east-1");+ assertEquals(queued.path("Id"), fixture.service.executeStatement(request, "us-east-1").path("Id"));+ AwsException busy = assertThrows(AwsException.class, () -> fixture.service.executeStatement(+ fixture.reuse(session, "SELECT 3"), "us-east-1"));+ assertEquals("ValidationException", busy.getErrorCode());+ assertTrue(fixture.service.cancelStatement(fixture.mapper.createObjectNode()+ .put("Id", queued.path("Id").asText())).path("Status").asBoolean());+ } finally {+ release.countDown();+ }+ ObjectNode query = fixture.service.executeStatement(fixture.reuse(session, "SELECT 4"), "us-east-1");+ assertEquals("FINISHED", fixture.service.describeStatement(fixture.mapper.createObjectNode()+ .put("Id", query.path("Id").asText())).path("Status").asText());+ }+ }++ @Test+ void mismatchedTargetsAndResetSessionsAreRejected() throws Exception {+ try (Fixture fixture = new Fixture()) {+ String session = fixture.service.executeStatement(fixture.request("SELECT 1")+ .put("SessionKeepAliveSeconds", 60), "us-east-1").path("SessionId").asText();+ for (String field : new String[]{"Database", "DbUser", "ClusterIdentifier", "WorkgroupName", "SecretArn"}) {+ assertThrows(AwsException.class, () -> fixture.service.executeStatement(+ fixture.reuse(session, "SELECT 2").put(field, "different"), "us-east-1"));+ }+ fixture.service.clear();+ assertThrows(AwsException.class, () -> fixture.service.executeStatement(fixture.reuse(session, "SELECT 2"), "us-east-1"));+ }+ }++ @Test+ void fullExecutorQueueDoesNotLeaveTheSessionBusy() throws Exception {+ try (Fixture fixture = new Fixture()) {+ String session = fixture.service.executeStatement(fixture.request("SELECT 1")+ .put("SessionKeepAliveSeconds", 60), "us-east-1").path("SessionId").asText();+ CountDownLatch started = new CountDownLatch(2);+ CountDownLatch release = new CountDownLatch(1);+ List<RedshiftDataExecution> executions = new ArrayList<>();+ for (int n = 0; n < 2; n++) {+ executions.add(fixture.executor.submit("000000000000", "us-east-1", "block-" + n, execution -> {+ started.countDown();+ try {+ release.await(5, TimeUnit.SECONDS);+ } catch (InterruptedException expected) {+ Thread.currentThread().interrupt();+ }+ }));+ }+ try {+ assertTrue(started.await(5, TimeUnit.SECONDS));+ for (int n = 0; n < 8; n++) {+ executions.add(fixture.executor.submit("000000000000", "us-east-1", "queued-" + n, execution -> { }));+ }+ AwsException full = assertThrows(AwsException.class, () -> fixture.service.executeStatement(+ fixture.reuse(session, "SELECT 2"), "us-east-1"));+ assertEquals("ActiveStatementsExceededException", full.getErrorCode());+ } finally {+ release.countDown();+ }+ for (RedshiftDataExecution execution : executions) {+ execution.await(Duration.ofSeconds(5));+ assertTrue(execution.isDone());+ }+ String query = fixture.service.executeStatement(fixture.reuse(session, "SELECT 3"), "us-east-1").path("Id").asText();+ assertEquals("FINISHED", fixture.service.describeStatement(fixture.mapper.createObjectNode().put("Id", query)).path("Status").asText());+ verify(fixture.factory).open(any());+ }+ }++ @Test+ void rejectedAdmissionReleasesAnExistingSessionWithoutOpeningAnotherConnection() throws Exception {+ try (Fixture fixture = new Fixture()) {+ String session = fixture.service.executeStatement(fixture.request("SELECT 1")+ .put("SessionKeepAliveSeconds", 60), "us-east-1").path("SessionId").asText();+ doThrow(new IllegalStateException("statement storage unavailable")).when(fixture.statements)+ .putForAccount(any(), any());+ assertThrows(IllegalStateException.class, () -> fixture.service.executeStatement(+ fixture.reuse(session, "SELECT 2"), "us-east-1"));+ doCallRealMethod().when(fixture.statements).putForAccount(any(), any());+ doThrow(new IllegalStateException("receipt storage unavailable")).when(fixture.receipts).put(any(), any(), any());+ assertThrows(IllegalStateException.class, () -> fixture.service.executeStatement(+ fixture.reuse(session, "SELECT 2").put("ClientToken", "rejected"), "us-east-1"));+ doCallRealMethod().when(fixture.receipts).put(any(), any(), any());+ ObjectNode retried = fixture.service.executeStatement(fixture.reuse(session, "SELECT 2")+ .put("ClientToken", "rejected"), "us-east-1");+ assertEquals("FINISHED", fixture.service.describeStatement(fixture.mapper.createObjectNode()+ .put("Id", retried.path("Id").asText())).path("Status").asText());+ verify(fixture.factory).open(any());+ }+ }++ @Test+ void receiptReplaysAfterLosingLiveSessionsAndEvictingStatementResults() throws Exception {+ try (Fixture fixture = new Fixture()) {+ String session = fixture.service.executeStatement(fixture.request("SELECT 1")+ .put("SessionKeepAliveSeconds", 60), "us-east-1").path("SessionId").asText();+ ObjectNode request = fixture.reuse(session, "SELECT 2").put("ClientToken", "restart-replay");+ ObjectNode first = fixture.service.executeStatement(request, "us-east-1");+ fixture.statements.deleteForAccount("000000000000", first.path("Id").asText());+ RedshiftDataService restarted = new RedshiftDataService(fixture.resolver, fixture.factory, fixture.statements,+ fixture.mapper, null, fixture.executor, null, null, null, fixture.receipts);++ ObjectNode replay = restarted.executeStatement(request, "us-east-1");+ assertEquals(first.path("Id"), replay.path("Id"));+ assertEquals(first.path("SessionId"), replay.path("SessionId"));+ verify(fixture.factory).open(any());+ }+ }++ @Test+ void uncheckedFailureAfterSqlExecutionAbortsTheExplicitTransaction() throws Exception {+ try (Fixture fixture = new Fixture()) {+ Connection connection = spy(DriverManager.getConnection(fixture.url));+ when(fixture.factory.open(any())).thenReturn(connection);+ String session = fixture.service.executeStatement(fixture.request("CREATE TABLE changes(id integer)")+ .put("SessionKeepAliveSeconds", 60), "us-east-1").path("SessionId").asText();+ PreparedStatement insert = spy(connection.prepareStatement("INSERT INTO changes VALUES (1)"));+ doAnswer(invocation -> {+ invocation.callRealMethod();+ throw new IllegalStateException("result conversion failed");+ }).when(insert).execute();+ doReturn(insert).when(connection).prepareStatement("INSERT INTO changes VALUES (1)");+ fixture.service.executeStatement(fixture.reuse(session, "BEGIN"), "us-east-1");+ String failed = fixture.service.executeStatement(fixture.reuse(session, "INSERT INTO changes VALUES (1)"), "us-east-1")+ .path("Id").asText();+ ObjectNode described = fixture.service.describeStatement(fixture.mapper.createObjectNode().put("Id", failed));+ assertEquals("FAILED", described.path("Status").asText());+ assertTrue(described.path("Error").asText().contains("result conversion failed"), described.toString());+ String committed = fixture.service.executeStatement(fixture.reuse(session, "COMMIT"), "us-east-1").path("Id").asText();+ assertEquals("FINISHED", fixture.service.describeStatement(fixture.mapper.createObjectNode().put("Id", committed))+ .path("Status").asText());+ assertEquals(0, fixture.count("changes"));+ }+ }++ @ParameterizedTest+ @ValueSource(booleans = {false, true})+ void malformedSessionIdentifiersFailBeforeTargetLookup(boolean batch) throws Exception {+ try (Fixture fixture = new Fixture()) {+ for (String raw : new String[]{"\"malformed\"", "7", "true", "null", "[]", "{}"}) {+ ObjectNode request = fixture.request("SELECT 1");+ JsonNode invalid = fixture.mapper.readTree(raw);+ request.set("SessionId", invalid);+ if (batch) {+ request.remove("Sql");+ request.putArray("Sqls").add("SELECT 1");+ }+ AwsException error = assertThrows(AwsException.class, () -> {+ if (batch) {+ fixture.service.batchExecuteStatement(request, "us-east-1");+ } else {+ fixture.service.executeStatement(request, "us-east-1");+ }+ });+ assertEquals("ValidationException", error.getErrorCode());+ }+ verifyNoInteractions(fixture.factory, fixture.resolver);+ }+ }++ @ParameterizedTest+ @ValueSource(booleans = {false, true})+ void ordinaryRequestsDoNotResolveSessionCaller(boolean batch) throws Exception {+ RequestContext context = new RequestContext();+ context.setAccessKeyId("caller-key");+ IamService iam = mock(IamService.class);+ when(iam.resolveCallerArn("caller-key")).thenReturn(Optional.of("caller-arn"));+ try (Fixture fixture = new Fixture(context, iam)) {+ for (boolean token : new boolean[]{false, true}) {+ ObjectNode request = fixture.request("SELECT 1").put("SessionKeepAliveSeconds", 0);+ if (token) {+ request.put("ClientToken", "ordinary");+ }+ if (batch) {+ request.remove("Sql");+ request.putArray("Sqls").add("SELECT 1");+ fixture.service.batchExecuteStatement(request, "us-east-1");+ } else {+ fixture.service.executeStatement(request, "us-east-1");+ }+ }+ verifyNoInteractions(iam);+ }+ }++ @Test+ void cleanupFailureIsReportedWithoutSkippingResetOfStatementAndReceiptState() throws Exception {+ try (Fixture fixture = new Fixture(); Connection connection = spy(DriverManager.getConnection(fixture.url))) {+ when(fixture.factory.open(any())).thenReturn(connection);+ ObjectNode request = fixture.request("SELECT 1").put("ClientToken", "cleanup-reset").put("SessionKeepAliveSeconds", 60);+ String id = fixture.service.executeStatement(request, "us-east-1").path("Id").asText();+ doThrow(new IllegalStateException("unexpected close failure")).doCallRealMethod().when(connection).close();++ assertThrows(IllegalStateException.class, fixture.service::clear);++ assertNull(fixture.statements.getForAccount("000000000000", id));+ assertNull(fixture.receipts.find(new RedshiftDataIdempotencyStore.Scope("000000000000", "us-east-1",+ "ExecuteStatement", "cleanup-reset")));+ }+ }++ @Test+ void terminatingSessionReportsUnexpectedConnectionCleanupFailure() throws Exception {+ try (Fixture fixture = new Fixture(); Connection connection = spy(DriverManager.getConnection(fixture.url))) {+ when(fixture.factory.open(any())).thenReturn(connection);+ String session = fixture.service.executeStatement(fixture.request("SELECT 1")+ .put("SessionKeepAliveSeconds", 60), "us-east-1").path("SessionId").asText();+ doThrow(new IllegalStateException("unexpected close failure")).doCallRealMethod().when(connection).close();+ String id = fixture.service.executeStatement(fixture.reuse(session, "SELECT 2")+ .put("SessionKeepAliveSeconds", 0), "us-east-1").path("Id").asText();+ ObjectNode described = fixture.service.describeStatement(fixture.mapper.createObjectNode().put("Id", id));+ assertEquals("FAILED", described.path("Status").asText());+ assertTrue(described.path("Error").asText().contains("unexpected close failure"), described.toString());+ }+ }++ @Test+ void replayWithoutSessionFieldsStillChecksRetainedReceiptOwnership() throws Exception {+ RequestContext context = new RequestContext();+ context.setAccessKeyId("owner");+ IamService iam = mock(IamService.class);+ when(iam.resolveCallerArn("owner")).thenReturn(Optional.of("owner-principal"));+ when(iam.resolveCallerArn("other")).thenReturn(Optional.of("other-principal"));+ try (Fixture fixture = new Fixture(context, iam)) {+ ObjectNode request = fixture.request("SELECT 1").put("ClientToken", "retained-replay")+ .put("SessionKeepAliveSeconds", 60);+ String id = fixture.service.executeStatement(request, "us-east-1").path("Id").asText();+ request.remove("SessionKeepAliveSeconds");+ context.setAccessKeyId("other");+ AwsException denied = assertThrows(AwsException.class, () -> fixture.service.executeStatement(request, "us-east-1"));+ assertEquals("ResourceNotFoundException", denied.getErrorCode());+ context.setAccessKeyId("owner");+ assertEquals(id, fixture.service.executeStatement(request, "us-east-1").path("Id").asText());+ verify(fixture.factory).open(any());+ }+ }++ @Test+ void malformedKeepAliveValuesAreRejectedBeforeOpeningAConnection() throws Exception {+ try (Fixture fixture = new Fixture()) {+ for (int seconds : new int[]{-1, 86401}) {+ AwsException error = assertThrows(AwsException.class, () -> fixture.service.executeStatement(+ fixture.request("SELECT 1").put("SessionKeepAliveSeconds", seconds), "us-east-1"));+ assertEquals("ValidationException", error.getErrorCode());+ }+ assertThrows(AwsException.class, () -> fixture.service.executeStatement(+ fixture.request("SELECT 1").put("SessionKeepAliveSeconds", "60"), "us-east-1"));+ assertThrows(AwsException.class, () -> fixture.service.executeStatement(+ fixture.request("SELECT 1").put("SessionKeepAliveSeconds", 0.5), "us-east-1"));+ verifyNoInteractions(fixture.factory);+ }+ }++ private static final class Fixture implements AutoCloseable {+ private final ObjectMapper mapper = new ObjectMapper();+ private final RedshiftDataResourceResolver resolver = mock(RedshiftDataResourceResolver.class);+ private final RedshiftDataConnectionFactory factory = mock(RedshiftDataConnectionFactory.class);+ private final RedshiftDataExecutor executor = new RedshiftDataExecutor(2, 8, 1);+ private final RedshiftDataStatementStore statements = spy(new RedshiftDataStatementStore(24, Clock.systemUTC()));+ private final RedshiftDataIdempotencyStore receipts = spy(new RedshiftDataIdempotencyStore(+ AccountAwareStorageBackend.inMemory("000000000000"), Clock.systemUTC()));+ private final RedshiftDataService service;+ private final String url = "jdbc:h2:mem:" + UUID.randomUUID();++ private Fixture() throws Exception {+ this(null, null);+ }++ private Fixture(RequestContext context, IamService iam) throws Exception {+ Driver.load();+ when(resolver.resolve(any(), any())).thenAnswer(invocation -> {+ ObjectNode request = invocation.getArgument(0);+ if (!request.has("Database")) {+ throw new AwsException("ValidationException", "Database is required", 400);+ }+ return new RedshiftDataResourceResolver.DatabaseTarget(+ "arn:aws:redshift:us-east-1:000000000000:cluster:warehouse", "localhost", 5439,+ "dev", "admin", "password");+ });+ when(factory.open(any())).thenAnswer(invocation -> DriverManager.getConnection(url));+ service = new RedshiftDataService(resolver, factory, statements, mapper, null, executor, null,+ context, iam, receipts);+ }++ private ObjectNode request(String sql) {+ return mapper.createObjectNode().put("Sql", sql).put("WaitTimeSeconds", 5)+ .put("ClusterIdentifier", "warehouse").put("Database", "dev").put("DbUser", "admin");+ }++ private ObjectNode reuse(String session, String sql) {+ return mapper.createObjectNode().put("Sql", sql).put("SessionId", session).put("WaitTimeSeconds", 5);+ }++ private int count(String table) throws Exception {+ try (Connection connection = DriverManager.getConnection(url);+ Statement statement = connection.createStatement();+ ResultSet rows = statement.executeQuery("SELECT COUNT(*) FROM " + table)) {+ assertTrue(rows.next());+ return rows.getInt(1);+ }+ }++ @Override+ public void close() {+ service.clear();+ executor.close();+ }+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataSessionsTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataSessionsTest.javanew file mode 100644index 0000000000..0bbb6e0473--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataSessionsTest.java@@ -0,0 +1,295 @@+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 org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.ValueSource;++import java.sql.Connection;+import java.sql.SQLException;+import java.time.Clock;+import java.time.Duration;+import java.time.Instant;+import java.time.ZoneId;+import java.time.ZoneOffset;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.ExecutionException;+import java.util.concurrent.ExecutorService;+import java.util.concurrent.Executors;+import java.util.concurrent.Future;+import java.util.concurrent.TimeUnit;++import static org.awaitility.Awaitility.await;+import static org.junit.jupiter.api.Assertions.*;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.Mockito.*;++class RedshiftDataSessionsTest {+ private static final ObjectMapper MAPPER = new ObjectMapper();+ private static final RedshiftDataSessions.Scope OWNER = new RedshiftDataSessions.Scope("000000000000", "us-east-1", "caller");+ private static final RedshiftDataResourceResolver.DatabaseTarget TARGET = new RedshiftDataResourceResolver.DatabaseTarget(+ "arn:aws:redshift:us-east-1:000000000000:cluster:warehouse", "localhost", 5439, "dev", "admin", "password");++ @Test+ void failedConnectionOpeningCannotAdmitAReplacementReservation() throws Exception {+ try (RedshiftDataSessions sessions = new RedshiftDataSessions(Clock.systemUTC());+ ExecutorService workers = Executors.newFixedThreadPool(2)) {+ RedshiftDataConnectionFactory factory = mock(RedshiftDataConnectionFactory.class);+ when(factory.open(any())).thenThrow(new SQLException("connection refused", "08001"));+ for (int attempt = 0; attempt < 2000; attempt++) {+ RedshiftDataSessions.Reservation first = sessions.reserve(OWNER,+ request().put("SessionKeepAliveSeconds", 60), TARGET);+ first.admitted();+ assertThrows(SQLException.class, () -> first.connection(factory));+ ObjectNode reuse = MAPPER.createObjectNode().put("SessionId", first.id());+ CountDownLatch start = new CountDownLatch(1);+ Future<?> finishing = workers.submit(() -> {+ assertTrue(start.await(5, TimeUnit.SECONDS));+ first.finish();+ return null;+ });+ Future<Boolean> admitted = workers.submit(() -> {+ assertTrue(start.await(5, TimeUnit.SECONDS));+ while (!Thread.currentThread().isInterrupted()) {+ try {+ sessions.reserve(OWNER, reuse, TARGET);+ return true;+ } catch (AwsException expected) {+ if ("ResourceNotFoundException".equals(expected.getErrorCode())) {+ return false;+ }+ assertEquals("ValidationException", expected.getErrorCode());+ Thread.onSpinWait();+ }+ }+ return false;+ });+ start.countDown();+ try {+ assertFalse(admitted.get(5, TimeUnit.SECONDS), "A failed session admitted a new query at attempt " + attempt);+ finishing.get(5, TimeUnit.SECONDS);+ } finally {+ admitted.cancel(true);+ }+ }+ }+ }++ @ParameterizedTest+ @ValueSource(booleans = {false, true})+ void clearSurfacesUnexpectedCleanupFailuresAndStillClosesOtherConnections(boolean unchecked) throws Exception {+ try (RedshiftDataSessions sessions = new RedshiftDataSessions(Clock.systemUTC())) {+ Connection broken = mock(Connection.class);+ Connection healthy = mock(Connection.class);+ Throwable failure = unchecked ? new IllegalStateException("close failed") : new SQLException("close failed", "08006");+ doThrow(failure).when(broken).close();+ RedshiftDataConnectionFactory factory = mock(RedshiftDataConnectionFactory.class);+ when(factory.open(any())).thenReturn(broken, healthy);+ for (int n = 0; n < 2; n++) {+ RedshiftDataSessions.Reservation reservation = sessions.reserve(OWNER,+ request().put("SessionKeepAliveSeconds", 60), TARGET);+ reservation.admitted();+ reservation.connection(factory);+ reservation.finish();+ }+ RuntimeException observed = assertThrows(RuntimeException.class, sessions::clear);+ assertSame(failure, observed.getCause());+ verify(healthy).close();+ }+ }++ @Test+ void alreadyClosedConnectionIsABenignCleanupOutcome() throws Exception {+ try (RedshiftDataSessions sessions = new RedshiftDataSessions(Clock.systemUTC())) {+ Connection connection = mock(Connection.class);+ doThrow(new SQLException("connection already closed", "08003")).when(connection).close();+ RedshiftDataConnectionFactory factory = mock(RedshiftDataConnectionFactory.class);+ when(factory.open(any())).thenReturn(connection);+ RedshiftDataSessions.Reservation reservation = sessions.reserve(OWNER,+ request().put("SessionKeepAliveSeconds", 60), TARGET);+ reservation.admitted();+ reservation.connection(factory);+ reservation.finish();+ assertDoesNotThrow(sessions::clear);+ verify(connection).close();+ }+ }++ @Test+ void clearClosesAConnectionThatFinishesOpeningAfterReset() throws Exception {+ try (RedshiftDataSessions sessions = new RedshiftDataSessions(Clock.systemUTC());+ ExecutorService worker = Executors.newSingleThreadExecutor()) {+ Connection connection = mock(Connection.class);+ CountDownLatch opening = new CountDownLatch(1);+ CountDownLatch release = new CountDownLatch(1);+ RedshiftDataConnectionFactory factory = mock(RedshiftDataConnectionFactory.class);+ when(factory.open(any())).thenAnswer(invocation -> {+ opening.countDown();+ assertTrue(release.await(5, TimeUnit.SECONDS));+ return connection;+ });+ RedshiftDataSessions.Reservation reservation = sessions.reserve(OWNER, request().put("SessionKeepAliveSeconds", 10), TARGET);+ reservation.admitted();+ Future<Connection> late = worker.submit(() -> reservation.connection(factory));+ try {+ assertTrue(opening.await(5, TimeUnit.SECONDS));+ sessions.clear();+ release.countDown();+ assertThrows(ExecutionException.class, () -> late.get(5, TimeUnit.SECONDS));+ verify(connection).close();+ assertThrows(AwsException.class, () -> sessions.find(OWNER, reservation.id()));+ } finally {+ release.countDown();+ }+ }+ }++ @Test+ void idleDeadlineStartsAfterCompletionAndUnspecifiedTimeoutIsRetained() throws Exception {+ MutableClock clock = new MutableClock();+ try (RedshiftDataSessions sessions = new RedshiftDataSessions(clock)) {+ Connection connection = mock(Connection.class);+ RedshiftDataConnectionFactory factory = mock(RedshiftDataConnectionFactory.class);+ when(factory.open(any())).thenReturn(connection);+ RedshiftDataSessions.Reservation first = sessions.reserve(OWNER, request().put("SessionKeepAliveSeconds", 10), TARGET);+ first.admitted();+ first.connection(factory);+ clock.advance(Duration.ofSeconds(20));+ sessions.sweep();+ verify(connection, never()).close();+ first.finish();+ clock.advance(Duration.ofSeconds(9));+ ObjectNode reuse = MAPPER.createObjectNode().put("SessionId", first.id());+ RedshiftDataSessions.Reservation next = sessions.reserve(OWNER, reuse, TARGET);+ next.admitted();+ assertSame(connection, next.connection(factory));+ next.finish();+ clock.advance(Duration.ofSeconds(9));+ assertNotNull(sessions.find(OWNER, first.id()));+ clock.advance(Duration.ofSeconds(1));+ sessions.sweep();+ verify(connection).close();+ assertThrows(AwsException.class, () -> sessions.find(OWNER, first.id()));+ }+ }++ @Test+ void busySessionsRejectNewWorkAndFailedAdmissionDoesNotExtendIdleTime() throws Exception {+ MutableClock clock = new MutableClock();+ try (RedshiftDataSessions sessions = new RedshiftDataSessions(clock)) {+ RedshiftDataConnectionFactory factory = mock(RedshiftDataConnectionFactory.class);+ when(factory.open(any())).thenReturn(mock(Connection.class));+ RedshiftDataSessions.Reservation first = sessions.reserve(OWNER, request().put("SessionKeepAliveSeconds", 10), TARGET);+ first.admitted();+ first.connection(factory);+ ObjectNode reuse = MAPPER.createObjectNode().put("SessionId", first.id());+ assertThrows(AwsException.class, () -> sessions.reserve(OWNER, reuse, TARGET));+ first.finish();+ clock.advance(Duration.ofSeconds(9));+ RedshiftDataSessions.Reservation rejected = sessions.reserve(OWNER, reuse.put("SessionKeepAliveSeconds", 100), TARGET);+ rejected.abort();+ clock.advance(Duration.ofSeconds(1));+ assertThrows(AwsException.class, () -> sessions.find(OWNER, first.id()));+ }+ }++ @Test+ void sessionsAreScopedToAccountRegionAndCaller() throws Exception {+ try (RedshiftDataSessions sessions = new RedshiftDataSessions(Clock.systemUTC())) {+ RedshiftDataSessions.Reservation first = sessions.reserve(OWNER, request().put("SessionKeepAliveSeconds", 10), TARGET);+ for (RedshiftDataSessions.Scope foreign : new RedshiftDataSessions.Scope[]{+ new RedshiftDataSessions.Scope("111111111111", "us-east-1", "caller"),+ new RedshiftDataSessions.Scope("000000000000", "us-west-2", "caller"),+ new RedshiftDataSessions.Scope("000000000000", "us-east-1", "another-caller")}) {+ assertThrows(AwsException.class, () -> sessions.find(foreign, first.id()));+ }+ assertNotNull(sessions.find(OWNER, first.id()));+ first.abort();+ }+ }++ @Test+ void zeroTimeoutClosesTheSessionAfterItsLastQuery() throws Exception {+ try (RedshiftDataSessions sessions = new RedshiftDataSessions(Clock.systemUTC())) {+ Connection connection = mock(Connection.class);+ RedshiftDataConnectionFactory factory = mock(RedshiftDataConnectionFactory.class);+ when(factory.open(any())).thenReturn(connection);+ RedshiftDataSessions.Reservation first = sessions.reserve(OWNER, request().put("SessionKeepAliveSeconds", 10), TARGET);+ first.admitted();+ first.connection(factory);+ first.finish();+ RedshiftDataSessions.Reservation last = sessions.reserve(OWNER,+ MAPPER.createObjectNode().put("SessionId", first.id()).put("SessionKeepAliveSeconds", 0), TARGET);+ last.admitted();+ last.connection(factory);+ last.finish();+ verify(connection).close();+ assertThrows(AwsException.class, () -> sessions.find(OWNER, first.id()));+ }+ }++ @Test+ void absoluteDeadlineClosesAnActiveConnectionAndCannotBeExtended() throws Exception {+ MutableClock clock = new MutableClock();+ try (RedshiftDataSessions sessions = new RedshiftDataSessions(clock)) {+ Connection connection = mock(Connection.class);+ RedshiftDataConnectionFactory factory = mock(RedshiftDataConnectionFactory.class);+ when(factory.open(any())).thenReturn(connection);+ RedshiftDataSessions.Reservation first = sessions.reserve(OWNER, request().put("SessionKeepAliveSeconds", 86400), TARGET);+ first.admitted();+ RedshiftDataExecution execution = new RedshiftDataExecution(0);+ first.bind(execution);+ first.connection(factory);+ clock.advance(Duration.ofHours(24));+ sessions.sweep();+ await().atMost(Duration.ofSeconds(2)).untilAsserted(() -> verify(connection).close());+ execution.completed();+ assertThrows(AwsException.class, () -> sessions.find(OWNER, first.id()));+ }+ }++ @Test+ void sessionLimitIsSharedAcrossCallersAndAbortedReservationsReleaseCapacity() {+ try (RedshiftDataSessions sessions = new RedshiftDataSessions(Clock.systemUTC())) {+ RedshiftDataSessions.Reservation first = sessions.reserve(OWNER, request().put("SessionKeepAliveSeconds", 10), TARGET);+ for (int n = 1; n < 500; n++) {+ sessions.reserve(new RedshiftDataSessions.Scope("000000000000", "us-east-1", "caller-" + n),+ request().put("SessionKeepAliveSeconds", 10), TARGET);+ }+ AwsException full = assertThrows(AwsException.class, () -> sessions.reserve(OWNER,+ request().put("SessionKeepAliveSeconds", 10), TARGET));+ assertEquals("ActiveSessionsExceededException", full.getErrorCode());+ first.abort();+ assertNotNull(sessions.reserve(OWNER, request().put("SessionKeepAliveSeconds", 10), TARGET));+ }+ }++ private static ObjectNode request() {+ return MAPPER.createObjectNode().put("ClusterIdentifier", "warehouse").put("Database", "dev").put("DbUser", "admin");+ }++ private static final class MutableClock extends Clock {+ private Instant now = Instant.parse("2026-10-24T00:00:00Z");++ void advance(Duration duration) {+ now = now.plus(duration);+ }++ @Override+ public ZoneId getZone() {+ return ZoneOffset.UTC;+ }++ @Override+ public Clock withZone(ZoneId zone) {+ return this;+ }++ @Override+ public Instant instant() {+ return now;+ }+ }+}