Light, fluffy, and always free - The AWS Local Emulator alternative
feat(redshift-data): implement ListSessions (#6892)
Vũ Thế Huyda8e22744b24
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftDataOperationsTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftDataOperationsTest.javaindex ef77010880..e3441cb46a 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftDataOperationsTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftDataOperationsTest.java@@ -22,6 +22,7 @@ import software.amazon.awssdk.services.redshiftdata.model.GetStatementResultRequimport software.amazon.awssdk.services.redshiftdata.model.GetStatementResultResponse;import software.amazon.awssdk.services.redshiftdata.model.GetStatementResultV2Response;import software.amazon.awssdk.services.redshiftdata.model.ResultFormatString;+import software.amazon.awssdk.services.redshiftdata.model.SessionData;import software.amazon.awssdk.services.redshiftdata.model.SqlParameter;import software.amazon.awssdk.services.redshiftdata.model.StatusString;import software.amazon.awssdk.services.redshiftdata.model.SubStatementData;@@ -86,6 +87,26 @@ class RedshiftDataOperationsTest {}}+ @Test+ @DisplayName("ListSessions exposes retained sessions and their closed history")+ void listSessionsLifecycle() throws Exception {+ String statement = data.executeStatement(r -> r.clusterIdentifier(clusterId).database(DATABASE)+ .dbUser(USERNAME).sessionKeepAliveSeconds(60).sql("SELECT 1")).id();+ awaitFinished(statement);+ String sessionId = data.describeStatement(r -> r.id(statement)).sessionId();+ SessionData session = data.listSessions(r -> r.sessionId(sessionId)).sessions().get(0);+ assertThat(session.statusAsString()).isEqualTo("AVAILABLE");+ assertThat(session.clusterIdentifier()).isEqualTo(clusterId);+ assertThat(session.database()).isEqualTo(DATABASE);+ assertThat(session.createdAt()).isNotNull();+ assertThat(session.sessionTtl()).isAfter(session.createdAt());+ String close = data.executeStatement(r -> r.sessionId(sessionId).sessionKeepAliveSeconds(0).sql("SELECT 2")).id();+ awaitFinished(close);+ assertThat(data.listSessions(r -> r.sessionId(sessionId)).sessions().get(0).statusAsString()).isEqualTo("CLOSED");+ assertThat(data.listSessions(r -> r.clusterIdentifier(clusterId)).sessions())+ .noneMatch(candidate -> sessionId.equals(candidate.sessionId()));+ }+@Test@DisplayName("explicit client token retries an INSERT without inserting twice")void executeStatementClientTokenRetry() throws Exception {diff --git a/docs/services/index.md b/docs/services/index.mdindex 3977d952bd..3fb5d86fec 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -77,7 +77,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac| [DocumentDB](docdb.md) | `POST /` with `Action=` param + MongoDB container | Query + MongoDB wire | 13 || [DMS](dms.md) | `POST /` + `X-Amz-Target: AmazonDMSv20160101.*` | JSON 1.1 | 20 || [Redshift](redshift.md) | `POST /` with `Action=` param + PostgreSQL container | Query + PostgreSQL wire (+ CFN) | 50 |-| [Redshift Data API](redshift-data.md) | `POST /` + `X-Amz-Target: RedshiftData.*` | JSON 1.1 | 11 |+| [Redshift Data API](redshift-data.md) | `POST /` + `X-Amz-Target: RedshiftData.*` | JSON 1.1 | 12 || [Redshift Serverless](redshift-serverless.md) | `POST /` + `X-Amz-Target: RedshiftServerless.*` | JSON 1.1 | 55 || [EMR](emr.md) | `POST /` + `X-Amz-Target: ElasticMapReduce.*` | JSON 1.1 | 40 || [EMR Serverless](emr-serverless.md) | `/applications/*`, `/tags/*` | REST JSON | 15 |diff --git a/docs/services/redshift-data.md b/docs/services/redshift-data.mdindex c193c28a5e..6122293721 100644--- a/docs/services/redshift-data.md+++ b/docs/services/redshift-data.md@@ -25,6 +25,7 @@ For the upstream API shape, see the AWS documentation:| `GetStatementResult` | Page through a finished statement's rows as typed `Records` || `GetStatementResultV2` | Same rows in the V2 envelope, with `CSVRecords` when the statement used `ResultFormat=CSV` || `ListStatements` | List stored statements newest first, filtered by `StatementName` or `Status` |+| `ListSessions` | List caller-owned session metadata, with lifecycle status, target filters and pagination || `CancelStatement` | Cancel queued or running SQL; returns whether cancellation was accepted, and rejects terminal statements || `ListDatabases` | List databases on the cluster (`pg_database`) || `ListSchemas` | List schemas, optionally filtered by `SchemaPattern` |@@ -91,12 +92,42 @@ Session ids appear in Execute, Batch, DescribeStatement and ListStatements respois 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 requestwith 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.+after restart, subject to the normal receipt lifetime and caller ownership.++### Listing sessions++`ListSessions` returns session metadata created in the last 24 hours. It defaults to+`AVAILABLE` and `BUSY` sessions; `Status=CLOSED` includes retained metadata for sessions+closed explicitly, expired or retired after a connection failure. `SessionId` retrieves+one visible session regardless of status and cannot be combined with `Status`,+`ClusterIdentifier`, `WorkgroupName` or `Database`. A missing or foreign session id+returns `ResourceNotFoundException`.++Filter by `ClusterIdentifier` or `WorkgroupName` (name or ARN), optionally with+`Database`. Cluster and workgroup filters are mutually exclusive. `MaxResults` accepts+0 through 100; omitted or zero uses 100. Continue with `NextToken` and the same filters+and ownership scope. Results are ordered by creation timestamp and session id; this+ordering and the default page size are Floci choices, not claims about AWS.++Sessions remain isolated by account and Region. `RoleLevel` defaults to true and+lists sessions for the caller's IAM role across assumed-role sessions. False limits+results to the current caller session. Unresolved credentials are isolated by access+key; Floci does not model Identity Center identity-enhanced session restrictions.++`CreatedAt`, `UpdatedAt` and `SessionTtl` are epoch-second timestamps with the same+millisecond precision as statement timestamps.+`CurrentStatementId` appears only while the session is `BUSY`, including admitted+work waiting for a worker. `SessionAliveSeconds` reports the selected keep-alive.+Closed history contains metadata only, does not consume the 500-live-session quota,+and expires 24 hours after session creation. History is runtime-only: reset, shutdown+and restart remove it even when statement persistence is enabled. Failed admissions+do not create session history. The exact queued-state reporting and lifecycle timestamp+choices have not been compared with live AWS.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.+reporting cleanup errors. Opportunistic expiration during `ListSessions` logs cleanup failures+without failing the listing. Background expiration failures are logged without stopping later sweeps.An already-closed connection (`SQLSTATE 08003`) is a benign cleanup outcome.```pythondiff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataJsonHandler.javaindex 69317bb688..88658cc94a 100644--- a/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataJsonHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataJsonHandler.java@@ -24,6 +24,7 @@ public class RedshiftDataJsonHandler {case "GetStatementResult" -> Response.ok(service.getStatementResult(request)).build();case "GetStatementResultV2" -> Response.ok(service.getStatementResultV2(request)).build();case "ListStatements" -> Response.ok(service.listStatements(request)).build();+ case "ListSessions" -> Response.ok(service.listSessions(request, region)).build();case "CancelStatement" -> Response.ok(service.cancelStatement(request)).build();case "ListDatabases" -> Response.ok(service.listDatabases(request, region)).build();case "ListSchemas" -> Response.ok(service.listSchemas(request, region)).build();diff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataResourceResolver.java b/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataResourceResolver.javaindex 505a9d6304..f7f9413789 100644--- a/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataResourceResolver.java+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataResourceResolver.java@@ -79,7 +79,8 @@ class RedshiftDataResourceResolver {}if (!hasText(request, "SecretArn")) {return new DatabaseTarget(workgroup.arn(), workgroup.host(), workgroup.port(), database,- workgroup.masterUsername(), workgroup.masterPassword(), spectrum);+ workgroup.masterUsername(), workgroup.masterPassword(), spectrum, null,+ workgroup.masterUsername(), workgroup.workgroupName());}String secretArn = request.get("SecretArn").asText();DatabaseSecretCredentials creds = secretCredentials(secretArn, region);@@ -88,7 +89,7 @@ class RedshiftDataResourceResolver {user = workgroup.masterUsername();}return new DatabaseTarget(workgroup.arn(), workgroup.host(), workgroup.port(), database,- user, creds.password(), spectrum);+ user, creds.password(), spectrum, null, user, workgroup.workgroupName());}private boolean isManagedAdminSecret(String secretArn, String managedSecretArn, String region) {@@ -203,7 +204,12 @@ class RedshiftDataResourceResolver {}record DatabaseTarget(String arn, String host, int port, String database, String user, String password,- SpectrumSession spectrum, Cluster cluster, String auditUser) {+ SpectrumSession spectrum, Cluster cluster, String auditUser, String workgroupName) {+ DatabaseTarget(String arn, String host, int port, String database, String user, String password,+ SpectrumSession spectrum, Cluster cluster, String auditUser) {+ this(arn, host, port, database, user, password, spectrum, cluster, auditUser, null);+ }+DatabaseTarget(String arn, String host, int port, String database, String user, String password,SpectrumSession spectrum, Cluster cluster) {this(arn, host, port, database, user, password, spectrum, cluster, user);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 6a619ac924..b079bd76c1 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@@ -209,7 +209,14 @@ public class RedshiftDataService implements Resettable {caller = iamService == null ? "access-key:" + accessKey: iamService.resolveCallerArn(accessKey).orElse("access-key:" + accessKey);}- return new RedshiftDataSessions.Scope(store.accountId(), region, caller == null ? "anonymous" : caller);+ String identity = caller == null ? "anonymous" : caller;+ String role = principal == null && requestContext != null && iamService != null+ ? iamService.resolvePrincipalArn(requestContext.getAccessKeyId()).orElse(identity) : identity;+ return new RedshiftDataSessions.Scope(store.accountId(), region, identity, role);+ }++ public ObjectNode listSessions(JsonNode request, String region) {+ return new RedshiftDataSessionListing(objectMapper, sessions).list(request, sessionScope(region, null));}private Admission replay(RedshiftDataIdempotencyStore.Receipt receipt, RedshiftDataIdempotencyStore.Scope scope,@@ -277,7 +284,7 @@ public class RedshiftDataService implements Resettable {}}if (session != null) {- session.admitted();+ session.admitted(stored.id);}},execution -> {@@ -1336,7 +1343,7 @@ public class RedshiftDataService implements Resettable {return offset;}- private static double epochSeconds(Instant instant) {+ static double epochSeconds(Instant instant) {return instant.toEpochMilli() / 1000.0;}diff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataSessionListing.java b/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataSessionListing.javanew file mode 100644index 0000000000..3895673aa1--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataSessionListing.java@@ -0,0 +1,150 @@+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.ArrayNode;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.AwsArnUtils;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.Digests;+import io.github.hectorvent.floci.core.common.PaginatedResult;+import io.github.hectorvent.floci.core.common.Pagination;+import io.github.hectorvent.floci.services.redshiftdata.RedshiftDataSessions.Scope;+import io.github.hectorvent.floci.services.redshiftdata.RedshiftDataSessions.SessionInfo;++import java.util.List;+import java.util.Objects;+import java.util.Set;+import java.util.regex.Pattern;++import static io.github.hectorvent.floci.services.redshiftdata.RedshiftDataService.epochSeconds;++final class RedshiftDataSessionListing {+ private static final Pattern CLUSTER = Pattern.compile("[a-z][a-z0-9]*(-[a-z0-9]+)*");+ private static final Pattern WORKGROUP = Pattern.compile("[a-z0-9-]{3,63}");+ private static final Pattern WORKGROUP_RESOURCE = Pattern.compile(+ "workgroup/(?:[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}|[a-z0-9-]{1,63}/[a-z0-9-]{1,63})");+ private static final Set<String> STATUSES = Set.of("AVAILABLE", "BUSY", "CLOSED");++ private final ObjectMapper mapper;+ private final RedshiftDataSessions sessions;++ RedshiftDataSessionListing(ObjectMapper mapper, RedshiftDataSessions sessions) {+ this.mapper = mapper;+ this.sessions = sessions;+ }++ ObjectNode list(JsonNode request, Scope owner) {+ RedshiftDataSessions.validate(request);+ String id = text(request, "SessionId");+ String cluster = text(request, "ClusterIdentifier");+ String workgroup = text(request, "WorkgroupName");+ String database = text(request, "Database");+ String status = text(request, "Status");+ if (id != null && (cluster != null || workgroup != null || database != null || status != null)) {+ throw validation("SessionId cannot be combined with Status, ClusterIdentifier, WorkgroupName or Database.");+ }+ if (cluster != null && workgroup != null) {+ throw validation("ClusterIdentifier and WorkgroupName cannot both be specified.");+ }+ if (cluster != null && (cluster.length() > 63 || !CLUSTER.matcher(cluster).matches())) {+ throw validation("ClusterIdentifier is not valid.");+ }+ if (workgroup != null && !validWorkgroup(workgroup)) {+ throw validation("WorkgroupName is not valid.");+ }+ if (status != null && !STATUSES.contains(status)) {+ throw validation("Status must be AVAILABLE, BUSY or CLOSED.");+ }+ JsonNode roleValue = request.get("RoleLevel");+ if (roleValue != null && !roleValue.isBoolean()) {+ throw validation("RoleLevel must be a boolean.");+ }+ boolean roleLevel = roleValue == null || roleValue.booleanValue();+ Integer maximum = Pagination.parseMaxResults(request, "MaxResults", "ValidationException");+ if (maximum != null && (maximum < 0 || maximum > 100)) {+ throw validation("MaxResults must be between 0 and 100.");+ }+ int limit = maximum == null || maximum == 0 ? 100 : maximum;+ String token = text(request, "NextToken");+ if (token != null && (token.isBlank() || token.length() > 8192)) {+ throw validation("NextToken is not valid.");+ }+ List<SessionInfo> matches = sessions.snapshots().stream()+ .filter(info -> visible(info.owner(), owner, roleLevel))+ .filter(info -> id == null || id.equals(info.id()))+ .filter(info -> id != null || (status == null ? !"CLOSED".equals(info.status()) : status.equals(info.status())))+ .filter(info -> cluster == null || cluster.equals(info.cluster()))+ .filter(info -> workgroup == null || workgroup.equals(info.workgroup()) || workgroup.equals(info.targetArn()))+ .filter(info -> database == null || database.equals(info.database()))+ .toList();+ if (id != null && matches.isEmpty()) {+ throw new AwsException("ResourceNotFoundException", "Session was not found.", 400);+ }+ ArrayNode scope = mapper.createArrayNode().add(owner.accountId()).add(owner.region())+ .add(roleLevel ? owner.principal() : owner.caller()).add(roleLevel)+ .add(id).add(cluster).add(workgroup).add(database).add(status);+ String namespace = "redshift-data-sessions-" + Digests.sha256Hex(scope.toString());+ PaginatedResult<SessionInfo> page = Pagination.paginate(matches,+ info -> info.createdAt().toString() + "/" + info.id(), limit, token, namespace,+ invalid -> validation("NextToken is not valid."));+ ObjectNode response = mapper.createObjectNode();+ ArrayNode result = response.putArray("Sessions");+ for (SessionInfo info : page.items()) {+ ObjectNode node = result.addObject();+ node.put("SessionId", info.id());+ node.put("Status", info.status());+ node.put("CreatedAt", epochSeconds(info.createdAt()));+ node.put("UpdatedAt", epochSeconds(info.updatedAt()));+ node.put("SessionTtl", epochSeconds(info.ttl()));+ node.put("SessionAliveSeconds", info.keepAlive());+ node.put("Database", info.database());+ node.put("DbUser", info.user());+ if (info.cluster() != null) {+ node.put("ClusterIdentifier", info.cluster());+ } else {+ node.put("WorkgroupName", info.workgroup());+ }+ if (info.statementId() != null) {+ node.put("CurrentStatementId", info.statementId());+ }+ }+ if (page.nextToken() != null) {+ response.put("NextToken", page.nextToken());+ }+ return response;+ }++ private static boolean visible(Scope actual, Scope requested, boolean roleLevel) {+ return actual.accountId().equals(requested.accountId()) && actual.region().equals(requested.region())+ && Objects.equals(roleLevel ? actual.principal() : actual.caller(),+ roleLevel ? requested.principal() : requested.caller());+ }++ private static boolean validWorkgroup(String value) {+ if (WORKGROUP.matcher(value).matches()) {+ return true;+ }+ if (value.length() > 128 || !AwsArnUtils.isArn(value)) {+ return false;+ }+ AwsArnUtils.Arn arn = AwsArnUtils.parse(value);+ return "redshift-serverless".equals(arn.service()) && !arn.region().isBlank()+ && arn.accountId().matches("[0-9]{12}") && WORKGROUP_RESOURCE.matcher(arn.resource()).matches();+ }++ private static String text(JsonNode request, String field) {+ JsonNode value = request.get(field);+ if (value == null) {+ return null;+ }+ if (!value.isTextual()) {+ throw validation(field + " must be a string.");+ }+ return value.textValue();+ }++ private static AwsException validation(String message) {+ return new AwsException("ValidationException", message, 400);+ }+}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.javaindex efd129ca0a..f401cb1fe0 100644--- a/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataSessions.java+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataSessions.java@@ -2,6 +2,7 @@ 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.AwsArnUtils;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.services.redshift.RedshiftAuditSql.UserChange;import io.github.hectorvent.floci.services.redshift.RedshiftAuditSql.UserChanges;@@ -15,6 +16,7 @@ import java.sql.SQLException;import java.time.Clock;import java.time.Duration;import java.time.Instant;+import java.util.ArrayList;import java.util.List;import java.util.Objects;import java.util.UUID;@@ -33,6 +35,7 @@ class RedshiftDataSessions implements AutoCloseable {private static final List<String> TARGET_FIELDS = List.of("ClusterIdentifier", "WorkgroupName", "Database", "DbUser", "SecretArn");private final ConcurrentHashMap<String, Session> sessions = new ConcurrentHashMap<>();+ private final ConcurrentHashMap<String, SessionInfo> history = new ConcurrentHashMap<>();private final Clock clock;private ScheduledExecutorService sweeper;private boolean closed;@@ -127,6 +130,7 @@ class RedshiftDataSessions implements AutoCloseable {}void sweep() {+ history.values().removeIf(info -> !clock.instant().isBefore(info.createdAt().plus(MAX_AGE)));RuntimeException failure = null;for (Session session : sessions.values()) {boolean expire;@@ -178,6 +182,10 @@ class RedshiftDataSessions implements AutoCloseable {return null;}session.closed = true;+ session.updatedAt = expired(session) ? session.deadline() : clock.instant();+ if (session.admitted && clock.instant().isBefore(session.createdAt.plus(MAX_AGE))) {+ history.put(session.id, session.info());+ }sessions.remove(session.id, session);Retirement retirement = new Retirement(session.id, session.connection, cancel ? session.execution : null,session.connectionClosed);@@ -246,6 +254,7 @@ class RedshiftDataSessions implements AutoCloseable {failure = accumulate(failure, cleanupFailure);}}+ history.clear();if (failure != null) {throw failure;}@@ -271,7 +280,29 @@ class RedshiftDataSessions implements AutoCloseable {clear();}- record Scope(String accountId, String region, String caller) { }+ List<SessionInfo> snapshots() {+ sweepSafely();+ ConcurrentHashMap<String, SessionInfo> result = new ConcurrentHashMap<>();+ for (Session session : sessions.values()) {+ synchronized (session) {+ if (session.admitted && clock.instant().isBefore(session.createdAt.plus(MAX_AGE))) {+ result.put(session.id, session.info());+ }+ }+ }+ result.putAll(history);+ return new ArrayList<>(result.values());+ }++ record Scope(String accountId, String region, String caller, String principal) {+ Scope(String accountId, String region, String caller) {+ this(accountId, region, caller, caller);+ }+ }++ record SessionInfo(String id, Scope owner, String targetArn, String cluster, String workgroup,+ String database, String user, Instant createdAt, Instant updatedAt,+ Instant ttl, int keepAlive, String status, String statementId) { }static final class Session {private final String id = UUID.randomUUID().toString();@@ -279,6 +310,8 @@ class RedshiftDataSessions implements AutoCloseable {private final RedshiftDataResourceResolver.DatabaseTarget target;private final ObjectNode parameters;private final Instant createdAt;+ private Instant updatedAt;+ private boolean admitted;private Instant idleUntil;private int keepAlive;private boolean closed;@@ -300,9 +333,28 @@ class RedshiftDataSessions implements AutoCloseable {}}this.createdAt = createdAt;+ this.updatedAt = createdAt;this.idleUntil = createdAt.plus(MAX_AGE);}+ private Instant deadline() {+ Instant maximum = createdAt.plus(MAX_AGE);+ return active != null || maximum.isBefore(idleUntil) ? maximum : idleUntil;+ }++ private SessionInfo info() {+ boolean busy = !closed && active != null;+ AwsArnUtils.Arn arn = AwsArnUtils.parse(target.arn());+ boolean serverless = "redshift-serverless".equals(arn.service());+ String cluster = serverless ? null : arn.resource().substring("cluster:".length());+ String workgroup = serverless ? target.workgroupName() != null ? target.workgroupName()+ : parameters.path("WorkgroupName").asText(target.arn()) : null;+ String user = parameters.path("DbUser").asText(target.auditUser());+ return new SessionInfo(id, owner, target.arn(), cluster, workgroup, target.database(), user,+ createdAt, updatedAt, closed ? updatedAt : deadline(), busy ? active.seconds : keepAlive,+ closed ? "CLOSED" : busy ? "BUSY" : "AVAILABLE", busy ? active.statementId : null);+ }+RedshiftDataResourceResolver.DatabaseTarget target(JsonNode request) {for (String field : TARGET_FIELDS) {JsonNode value = request.get(field);@@ -325,6 +377,7 @@ class RedshiftDataSessions implements AutoCloseable {private final int seconds;private final AtomicBoolean released = new AtomicBoolean();private boolean admitted;+ private String statementId;private Reservation(Session session, boolean created, int seconds) {this.session = session;@@ -337,7 +390,16 @@ class RedshiftDataSessions implements AutoCloseable {}void admitted() {- admitted = true;+ admitted(null);+ }++ void admitted(String id) {+ synchronized (session) {+ admitted = true;+ statementId = id;+ session.admitted = true;+ session.updatedAt = clock.instant();+ }}void bind(RedshiftDataExecution execution) throws SQLException {@@ -442,6 +504,10 @@ class RedshiftDataSessions implements AutoCloseable {return;}boolean remove = !completed && created || completed && (seconds == 0 || session.connection == null);+ if (completed) {+ session.keepAlive = seconds;+ session.updatedAt = clock.instant();+ }if (remove) {retirement = retireLocked(session, false);} else {diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.javaindex a588d57c7e..f9bbc7f6c3 100644--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java@@ -2654,7 +2654,7 @@ public class AslExecutor {private static void renderRedshiftDataTimestamps(JsonNode node) {if (node instanceof ObjectNode object) {- for (String field : List.of("CreatedAt", "UpdatedAt")) {+ for (String field : List.of("CreatedAt", "UpdatedAt", "SessionTtl")) {JsonNode value = object.get(field);if (value != null && value.isNumber()) {object.put(field, sdkTimestamp(value.asDouble()));diff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataListSessionsServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataListSessionsServiceTest.javanew file mode 100644index 0000000000..c36ec29cde--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataListSessionsServiceTest.java@@ -0,0 +1,302 @@+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.AwsArnUtils;+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 io.github.hectorvent.floci.testing.ManualClock;+import org.h2.Driver;+import org.junit.jupiter.api.Test;++import java.sql.Connection;+import java.sql.DriverManager;+import java.sql.SQLException;+import java.time.Duration;+import java.time.Instant;+import java.util.HashSet;+import java.util.Optional;+import java.util.Set;+import java.util.UUID;+import java.util.concurrent.CountDownLatch;+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 RedshiftDataListSessionsServiceTest {+ @Test+ void sessionTimestampsUseMillisecondPrecision() throws Exception {+ try (Fixture fixture = new Fixture()) {+ fixture.clock.advance(Duration.ofNanos(123_456_789));+ fixture.create("warehouse");+ JsonNode session = fixture.list().path("Sessions").get(0);++ assertEquals(1_793_232_000.123, session.path("CreatedAt").asDouble());+ assertEquals(1_793_232_000.123, session.path("UpdatedAt").asDouble());+ assertEquals(1_793_232_060.123, session.path("SessionTtl").asDouble());+ }+ }++ @Test+ void anotherCallersExpiredConnectionCleanupFailureDoesNotFailListing() throws Exception {+ try (Fixture fixture = new Fixture(); Connection broken = spy(DriverManager.getConnection(fixture.url))) {+ when(fixture.factory.open(any())).thenReturn(broken)+ .thenAnswer(invocation -> DriverManager.getConnection(fixture.url));+ fixture.context.setAccessKeyId("other");+ fixture.create("broken");+ doThrow(new SQLException("close failed", "08006")).doCallRealMethod().when(broken).close();+ fixture.clock.advance(Duration.ofSeconds(30));+ fixture.context.setAccessKeyId("owner");+ String healthy = fixture.create("warehouse");+ fixture.clock.advance(Duration.ofSeconds(30));++ ObjectNode listed = fixture.list();++ assertEquals(1, listed.path("Sessions").size());+ assertEquals(healthy, listed.path("Sessions").get(0).path("SessionId").asText());+ verify(broken).close();+ }+ }++ @Test+ void listsAvailableAndClosedSessionsWithLifecycleMetadata() throws Exception {+ try (Fixture fixture = new Fixture()) {+ String id = fixture.create("warehouse");+ JsonNode session = fixture.list().path("Sessions").get(0);+ assertEquals(id, session.path("SessionId").asText());+ assertEquals("AVAILABLE", session.path("Status").asText());+ assertEquals("warehouse", session.path("ClusterIdentifier").asText());+ assertEquals("dev", session.path("Database").asText());+ assertEquals("admin", session.path("DbUser").asText());+ assertEquals(60, session.path("SessionAliveSeconds").asInt());+ assertEquals(fixture.clock.instant().getEpochSecond(), session.path("CreatedAt").asLong());+ assertEquals(fixture.clock.instant().plusSeconds(60).getEpochSecond(), session.path("SessionTtl").asLong());+ assertFalse(session.has("CurrentStatementId"));+ assertFalse(session.has("WorkgroupName"));+ assertFalse(session.has("SecretArn"));+ assertFalse(session.toString().contains("password"));++ fixture.clock.advance(Duration.ofSeconds(10));+ fixture.service.executeStatement(fixture.json().put("SessionId", id).put("Sql", "SELECT 2")+ .put("SessionKeepAliveSeconds", 0).put("WaitTimeSeconds", 5), "us-east-1");+ assertTrue(fixture.list().path("Sessions").isEmpty());+ JsonNode closed = fixture.list(fixture.json().put("Status", "CLOSED")).path("Sessions").get(0);+ assertEquals(id, closed.path("SessionId").asText());+ assertEquals("CLOSED", closed.path("Status").asText());+ assertEquals(fixture.clock.instant().getEpochSecond(), closed.path("UpdatedAt").asLong());+ assertEquals(id, fixture.list(fixture.json().put("SessionId", id))+ .path("Sessions").get(0).path("SessionId").asText());+ fixture.service.clear();+ assertTrue(fixture.list(fixture.json().put("Status", "CLOSED")).path("Sessions").isEmpty());+ }+ }++ @Test+ void listsBusySessionsWithTheirCurrentStatement() throws Exception {+ try (Fixture fixture = new Fixture()) {+ CountDownLatch started = new CountDownLatch(1);+ CountDownLatch release = new CountDownLatch(1);+ when(fixture.factory.open(any())).thenAnswer(invocation -> {+ started.countDown();+ assertTrue(release.await(10, TimeUnit.SECONDS));+ return DriverManager.getConnection(fixture.url);+ });+ ObjectNode request = fixture.request("warehouse");+ request.remove("WaitTimeSeconds");+ ObjectNode response = fixture.service.executeStatement(request, "us-east-1");+ try {+ assertTrue(started.await(5, TimeUnit.SECONDS));+ JsonNode busy = fixture.list(fixture.json().put("Status", "BUSY")).path("Sessions").get(0);+ assertEquals(response.path("Id").asText(), busy.path("CurrentStatementId").asText());+ assertEquals(response.path("SessionId").asText(), busy.path("SessionId").asText());+ } finally {+ release.countDown();+ }+ await().atMost(Duration.ofSeconds(5)).untilAsserted(() ->+ assertEquals("AVAILABLE", fixture.list().path("Sessions").get(0).path("Status").asText()));+ }+ }++ @Test+ void expiresOnReadAndRetainsClosedHistoryOnlyWithinTheCreationWindow() throws Exception {+ try (Fixture fixture = new Fixture()) {+ String id = fixture.create("warehouse");+ fixture.clock.advance(Duration.ofSeconds(60));+ assertTrue(fixture.list().path("Sessions").isEmpty());+ assertEquals("CLOSED", fixture.list(fixture.json().put("SessionId", id))+ .path("Sessions").get(0).path("Status").asText());+ fixture.clock.advance(Duration.ofHours(24));+ assertTrue(fixture.list(fixture.json().put("Status", "CLOSED")).path("Sessions").isEmpty());+ assertEquals("ResourceNotFoundException", assertThrows(AwsException.class,+ () -> fixture.list(fixture.json().put("SessionId", id))).getErrorCode());+ }+ }++ @Test+ void filtersByComputeTargetAndDatabaseBeforePaginating() throws Exception {+ try (Fixture fixture = new Fixture()) {+ String first = fixture.create("warehouse");+ fixture.clock.advance(Duration.ofSeconds(1));+ String second = fixture.create("warehouse");+ fixture.create("other");+ ObjectNode workgroup = fixture.request("unused");+ workgroup.remove("ClusterIdentifier");+ workgroup.put("WorkgroupName", "analytics");+ fixture.service.executeStatement(workgroup, "us-east-1");+ ObjectNode filter = fixture.json().put("ClusterIdentifier", "warehouse").put("Database", "dev")+ .put("MaxResults", 1);+ ObjectNode page = fixture.list(filter);+ Set<String> ids = new HashSet<>();+ ids.add(page.path("Sessions").get(0).path("SessionId").asText());+ assertTrue(page.has("NextToken"));+ ObjectNode last = fixture.list(filter.deepCopy().put("NextToken", page.path("NextToken").asText()));+ ids.add(last.path("Sessions").get(0).path("SessionId").asText());+ assertEquals(Set.of(first, second), ids);+ assertFalse(last.has("NextToken"));+ assertTrue(fixture.list(fixture.json().put("Database", "missing")).path("Sessions").isEmpty());+ JsonNode serverless = fixture.list(fixture.json().put("WorkgroupName", "analytics")).path("Sessions");+ assertEquals(1, serverless.size());+ assertFalse(serverless.get(0).has("ClusterIdentifier"));+ String arn = AwsArnUtils.Arn.of("redshift-serverless", "us-east-1", "000000000000",+ "workgroup/12345678-1234-1234-1234-123456789012").toString();+ assertEquals(serverless, fixture.list(fixture.json().put("WorkgroupName", arn)).path("Sessions"));+ }+ }++ @Test+ void enforcesCallerRegionAndRoleLevelAndBindsTokensToTheQuery() throws Exception {+ try (Fixture fixture = new Fixture()) {+ when(fixture.iam.resolveCallerArn("owner")).thenReturn(Optional.of("session-one"));+ when(fixture.iam.resolvePrincipalArn("owner")).thenReturn(Optional.of("shared-role"));+ String id = fixture.create("warehouse");+ fixture.create("warehouse");+ String token = fixture.list(fixture.json().put("MaxResults", 1)).path("NextToken").asText();+ when(fixture.iam.resolveCallerArn("other")).thenReturn(Optional.of("session-two"));+ when(fixture.iam.resolvePrincipalArn("other")).thenReturn(Optional.of("shared-role"));+ fixture.context.setAccessKeyId("other");+ assertEquals(2, fixture.list().path("Sessions").size());+ assertTrue(fixture.list(fixture.json().put("RoleLevel", false)).path("Sessions").isEmpty());+ when(fixture.iam.resolvePrincipalArn("other")).thenReturn(Optional.of("different-role"));+ assertTrue(fixture.list().path("Sessions").isEmpty());+ assertEquals("ResourceNotFoundException", assertThrows(AwsException.class,+ () -> fixture.list(fixture.json().put("SessionId", id))).getErrorCode());+ assertThrows(AwsException.class, () -> fixture.list(fixture.json().put("NextToken", token)));+ fixture.context.setAccessKeyId("owner");+ assertThrows(AwsException.class, () -> fixture.list(fixture.json().put("NextToken", token).put("Database", "dev")));+ assertTrue(fixture.list(fixture.json(), "eu-west-1").path("Sessions").isEmpty());+ assertThrows(AwsException.class, () -> fixture.list(fixture.json().put("NextToken", token), "eu-west-1"));+ }+ }++ @Test+ void workgroupArnSessionsCanBeListedByNameAndForeignAccountsStayHidden() throws Exception {+ try (Fixture fixture = new Fixture()) {+ String arn = AwsArnUtils.Arn.of("redshift-serverless", "us-east-1", "000000000000",+ "workgroup/12345678-1234-1234-1234-123456789012").toString();+ ObjectNode request = fixture.request("unused");+ request.remove("ClusterIdentifier");+ request.put("WorkgroupName", arn);+ String id = fixture.service.executeStatement(request, "us-east-1").path("SessionId").asText();+ assertEquals(id, fixture.list(fixture.json().put("WorkgroupName", "analytics"))+ .path("Sessions").get(0).path("SessionId").asText());+ RedshiftDataSessions.Reservation foreign = fixture.sessions.reserve(new RedshiftDataSessions.Scope(+ "111111111111", "us-east-1", "access-key:owner"), fixture.request("warehouse"),+ new RedshiftDataResourceResolver.DatabaseTarget(AwsArnUtils.Arn.of("redshift", "us-east-1",+ "111111111111", "cluster:warehouse").toString(), "localhost", 5439, "dev", "admin", "password"));+ foreign.admitted();+ assertEquals(1, fixture.list().path("Sessions").size());+ assertEquals("ResourceNotFoundException", assertThrows(AwsException.class,+ () -> fixture.list(fixture.json().put("SessionId", foreign.id()))).getErrorCode());+ }+ }++ @Test+ void rejectsMalformedRequestsWithoutOpeningDatabaseConnections() throws Exception {+ try (Fixture fixture = new Fixture()) {+ for (ObjectNode request : new ObjectNode[]{fixture.json().put("Status", "FAILED"),+ fixture.json().put("RoleLevel", "false"), fixture.json().put("MaxResults", -1),+ fixture.json().put("MaxResults", 101), fixture.json().put("MaxResults", 0.5),+ fixture.json().put("SessionId", "invalid"), fixture.json().put("ClusterIdentifier", "Uppercase"),+ fixture.json().put("WorkgroupName", "x"), fixture.json().put("Database", 5),+ fixture.json().put("NextToken", "garbage"),+ fixture.json().put("ClusterIdentifier", "warehouse").put("WorkgroupName", "analytics"),+ fixture.json().put("SessionId", UUID.randomUUID().toString()).put("Status", "CLOSED")}) {+ assertEquals("ValidationException", assertThrows(AwsException.class,+ () -> fixture.list(request), request.toString()).getErrorCode());+ }+ assertTrue(fixture.list(fixture.json().put("MaxResults", 0)).path("Sessions").isEmpty());+ verifyNoInteractions(fixture.factory);+ }+ }++ private static final class Fixture implements AutoCloseable {+ private final ObjectMapper mapper = new ObjectMapper();+ private final ManualClock clock = new ManualClock(Instant.parse("2026-10-29T00:00:00Z"));+ private final RequestContext context = new RequestContext();+ private final IamService iam = mock(IamService.class);+ private final RedshiftDataConnectionFactory factory = mock(RedshiftDataConnectionFactory.class);+ private final RedshiftDataExecutor executor = new RedshiftDataExecutor(2, 8, 1);+ private final RedshiftDataSessions sessions = new RedshiftDataSessions(clock);+ private final String url = "jdbc:h2:mem:" + UUID.randomUUID();+ private final RedshiftDataService service;++ private Fixture() throws Exception {+ Driver.load();+ context.setAccessKeyId("owner");+ RedshiftDataResourceResolver resolver = mock(RedshiftDataResourceResolver.class);+ when(resolver.resolve(any(), any())).thenAnswer(invocation -> {+ JsonNode request = invocation.getArgument(0);+ String region = invocation.getArgument(1);+ boolean serverless = request.has("WorkgroupName");+ String resource = serverless ? "workgroup/12345678-1234-1234-1234-123456789012"+ : "cluster:" + request.path("ClusterIdentifier").asText();+ return new RedshiftDataResourceResolver.DatabaseTarget(AwsArnUtils.Arn.of(+ serverless ? "redshift-serverless" : "redshift", region, "000000000000", resource).toString(),+ "localhost", 5439, "dev", "admin", "password", null, null, "admin", serverless ? "analytics" : null);+ });+ when(factory.open(any())).thenAnswer(invocation -> DriverManager.getConnection(url));+ service = new RedshiftDataService(resolver, factory, new RedshiftDataStatementStore(24, clock), mapper,+ null, executor, null, context, iam, new RedshiftDataIdempotencyStore(+ AccountAwareStorageBackend.inMemory("000000000000"), clock), sessions);+ }++ private ObjectNode json() {+ return mapper.createObjectNode();+ }++ private ObjectNode request(String cluster) {+ return json().put("ClusterIdentifier", cluster).put("Database", "dev").put("DbUser", "admin")+ .put("Sql", "SELECT 1").put("SessionKeepAliveSeconds", 60).put("WaitTimeSeconds", 5);+ }++ private String create(String cluster) {+ return service.executeStatement(request(cluster), "us-east-1").path("SessionId").asText();+ }++ private ObjectNode list() {+ return list(json());+ }++ private ObjectNode list(ObjectNode request) {+ return list(request, "us-east-1");+ }++ private ObjectNode list(ObjectNode request, String region) {+ return (ObjectNode) new RedshiftDataJsonHandler(service).handle("ListSessions", request, region).getEntity();+ }++ @Override+ public void close() {+ service.clear();+ executor.close();+ sessions.close();+ }+ }++}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.javaindex 7fa9151040..25a09ab2d8 100644--- a/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataSessionIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataSessionIntegrationTest.java@@ -20,7 +20,9 @@ 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.ListSessionsResponse;import software.amazon.awssdk.services.redshiftdata.model.ResourceNotFoundException;+import software.amazon.awssdk.services.redshiftdata.model.SessionData;import software.amazon.awssdk.services.redshiftdata.model.SqlParameter;import software.amazon.awssdk.services.redshiftdata.model.StatusString;import software.amazon.awssdk.services.redshiftdata.model.ValidationException;@@ -152,6 +154,53 @@ class RedshiftDataSessionIntegrationTest {verifyNoInteractions(factory);}+ @Test+ void sdkListsSessionsWithFiltersPaginationAndClosedHistory() {+ ExecuteStatementResponse first = data.executeStatement(r -> r.waitTimeSeconds(30).clusterIdentifier("warehouse")+ .dbUser("admin").database("dev").sessionKeepAliveSeconds(60).sql("SELECT 1"));+ finished(first.id());+ ExecuteStatementResponse second = data.executeStatement(r -> r.waitTimeSeconds(30).workgroupName("analytics")+ .database("dev").sessionKeepAliveSeconds(60).sql("SELECT 2"));+ finished(second.id());++ ListSessionsResponse page = data.listSessions(r -> r.maxResults(1));+ assertEquals(1, page.sessions().size());+ assertNotNull(page.nextToken());+ ListSessionsResponse last = data.listSessions(r -> r.maxResults(1).nextToken(page.nextToken()));+ assertEquals(1, last.sessions().size());+ assertNotEquals(page.sessions().getFirst().sessionId(), last.sessions().getFirst().sessionId());+ assertNull(last.nextToken());++ SessionData cluster = data.listSessions(r -> r.clusterIdentifier("warehouse").database("dev")).sessions().getFirst();+ assertEquals(first.sessionId(), cluster.sessionId());+ assertEquals("AVAILABLE", cluster.statusAsString());+ assertEquals("admin", cluster.dbUser());+ assertEquals(60, cluster.sessionAliveSeconds());+ assertNotNull(cluster.createdAt());+ assertNotNull(cluster.updatedAt());+ assertTrue(cluster.sessionTtl().isAfter(cluster.createdAt()));+ assertNull(cluster.currentStatementId());+ assertNull(cluster.workgroupName());+ SessionData workgroup = data.listSessions(r -> r.workgroupName("analytics")).sessions().getFirst();+ assertEquals(second.sessionId(), workgroup.sessionId());+ assertNull(workgroup.clusterIdentifier());++ try (RedshiftDataClient other = client("another-caller", Region.US_EAST_1);+ RedshiftDataClient otherRegion = client("test", Region.EU_WEST_1)) {+ assertTrue(other.listSessions(r -> r.maxResults(100)).sessions().isEmpty());+ assertTrue(otherRegion.listSessions(r -> r.maxResults(100)).sessions().isEmpty());+ assertThrows(ResourceNotFoundException.class, () -> other.listSessions(r -> r.sessionId(first.sessionId())));+ }+ String closed = data.executeStatement(r -> r.waitTimeSeconds(30).sessionId(first.sessionId())+ .sessionKeepAliveSeconds(0).sql("SELECT 3")).id();+ finished(closed);+ assertTrue(data.listSessions(r -> r.clusterIdentifier("warehouse")).sessions().isEmpty());+ assertEquals(first.sessionId(), data.listSessions(r -> r.status("CLOSED")).sessions().getFirst().sessionId());+ assertEquals("CLOSED", data.listSessions(r -> r.sessionId(first.sessionId())).sessions().getFirst().statusAsString());+ assertThrows(ValidationException.class, () -> data.listSessions(r -> r.sessionId(first.sessionId()).status("CLOSED")));+ assertThrows(ValidationException.class, () -> data.listSessions(r -> r.maxResults(101)));+ }+@Testvoid sdkValidatesKeepAliveAndReplaysAClosedSessionReceipt() {assertThrows(ValidationException.class, () -> data.executeStatement(r -> r.waitTimeSeconds(30).clusterIdentifier("warehouse")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.javaindex 0bbb6e0473..cf08d3ebe1 100644--- a/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataSessionsTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataSessionsTest.java@@ -14,12 +14,15 @@ import java.time.Duration;import java.time.Instant;import java.time.ZoneId;import java.time.ZoneOffset;+import java.util.ArrayList;+import java.util.List;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 java.util.concurrent.atomic.AtomicInteger;import static org.awaitility.Awaitility.await;import static org.junit.jupiter.api.Assertions.*;@@ -32,6 +35,44 @@ class RedshiftDataSessionsTest {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 snapshotsKeepSessionsRetiredDuringTheLiveScan() throws Exception {+ Clock clock = mock(Clock.class);+ Instant now = Instant.parse("2026-10-29T00:00:00Z");+ when(clock.instant()).thenReturn(now);+ try (RedshiftDataSessions sessions = new RedshiftDataSessions(clock)) {+ RedshiftDataConnectionFactory factory = mock(RedshiftDataConnectionFactory.class);+ when(factory.open(any())).thenAnswer(invocation -> mock(Connection.class));+ List<RedshiftDataSessions.Reservation> closing = new ArrayList<>();+ for (int n = 0; n < 64; n++) {+ RedshiftDataSessions.Reservation first = sessions.reserve(OWNER,+ request().put("SessionKeepAliveSeconds", 60), 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();+ closing.add(last);+ }+ AtomicInteger reads = new AtomicInteger();+ when(clock.instant()).thenAnswer(invocation -> {+ // The sweep reads each live session's deadline. Close them at the first live metadata read,+ // after the original implementation copied history but before it finishes scanning live sessions.+ if (reads.incrementAndGet() == closing.size() + 1) {+ closing.forEach(RedshiftDataSessions.Reservation::finish);+ }+ return now;+ });++ List<RedshiftDataSessions.SessionInfo> snapshot = sessions.snapshots();++ assertEquals(closing.size(), snapshot.size(), "Retirement must not hide a session from both maps");+ assertTrue(snapshot.stream().allMatch(info -> "CLOSED".equals(info.status())));+ assertEquals(closing.size(), sessions.snapshots().size());+ }+ }+@Testvoid failedConnectionOpeningCannotAdmitAReplacementReservation() throws Exception {try (RedshiftDataSessions sessions = new RedshiftDataSessions(Clock.systemUTC());@@ -270,6 +311,27 @@ class RedshiftDataSessionsTest {return MAPPER.createObjectNode().put("ClusterIdentifier", "warehouse").put("Database", "dev").put("DbUser", "admin");}+ @Test+ void failedAdmissionCreatesNoHistoryAndClosedHistoryDoesNotConsumeCapacity() {+ try (RedshiftDataSessions sessions = new RedshiftDataSessions(Clock.systemUTC())) {+ RedshiftDataSessions.Reservation rejected = sessions.reserve(OWNER, request().put("SessionKeepAliveSeconds", 60), TARGET);+ rejected.abort();+ assertTrue(sessions.snapshots().isEmpty());+ for (int n = 0; n < 501; n++) {+ RedshiftDataSessions.Reservation reservation = sessions.reserve(OWNER,+ request().put("SessionKeepAliveSeconds", 60), TARGET);+ reservation.admitted();+ reservation.finish();+ }+ assertEquals(501, sessions.snapshots().size());+ assertTrue(sessions.snapshots().stream().allMatch(info -> "CLOSED".equals(info.status())));+ RedshiftDataSessions.Reservation next = sessions.reserve(OWNER, request().put("SessionKeepAliveSeconds", 60), TARGET);+ next.abort();+ sessions.clear();+ assertTrue(sessions.snapshots().isEmpty());+ }+ }+private static final class MutableClock extends Clock {private Instant now = Instant.parse("2026-10-24T00:00:00Z");diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorRedshiftDataSessionsTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorRedshiftDataSessionsTest.javanew file mode 100644index 0000000000..0d87be9198--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorRedshiftDataSessionsTest.java@@ -0,0 +1,76 @@+package io.github.hectorvent.floci.services.stepfunctions;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.ServiceRegistry;+import io.github.hectorvent.floci.services.redshiftdata.RedshiftDataJsonHandler;+import io.github.hectorvent.floci.services.redshiftdata.RedshiftDataService;+import io.github.hectorvent.floci.services.stepfunctions.model.Execution;+import io.github.hectorvent.floci.services.stepfunctions.model.StateMachine;+import org.junit.jupiter.api.Test;++import java.util.ArrayList;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++class AslExecutorRedshiftDataSessionsTest {+ @Test+ void listSessionsRendersEveryLifecycleTimestampWithoutChangingTheWireResponse() throws Exception {+ ObjectMapper mapper = new ObjectMapper();+ EmulatorConfig config = mock(EmulatorConfig.class, RETURNS_DEEP_STUBS);+ ServiceRegistry registry = mock(ServiceRegistry.class);+ when(registry.isServiceEnabled("redshift-data")).thenReturn(true);+ RedshiftDataService service = mock(RedshiftDataService.class);+ ObjectNode response = mapper.createObjectNode();+ ObjectNode session = response.putArray("Sessions").addObject();+ session.put("SessionId", "session-id");+ session.put("Status", "AVAILABLE");+ session.put("CreatedAt", 1_700_000_000.5);+ session.put("UpdatedAt", 1_700_000_001.0);+ session.put("SessionTtl", 1_700_000_060.25);+ session.put("SessionAliveSeconds", 60);+ when(service.listSessions(any(), eq("us-east-1"))).thenReturn(response);+ AslExecutor executor = AslExecutorFixture.builder()+ .objectMapper(mapper)+ .config(config)+ .customResourceLiveness(null)+ .redshiftDataHandler(new RedshiftDataJsonHandler(service))+ .serviceRegistry(registry)+ .build();+ StateMachine machine = new StateMachine();+ machine.setStateMachineArn("arn:aws:states:us-east-1:000000000000:stateMachine:list-sessions");+ machine.setDefinition("""+ {"StartAt":"List","States":{"List":{"Type":"Task",+ "Resource":"arn:aws:states:::aws-sdk:redshiftdata:listSessions","End":true}}}+ """);+ Execution execution = new Execution();+ execution.setExecutionArn("arn:aws:states:us-east-1:000000000000:execution:list-sessions:run");+ execution.setStateMachineArn(machine.getStateMachineArn());+ execution.setInput("{}");+ try {+ executor.executeSync(machine, execution, new ArrayList<>(), (updated, events) -> { });++ assertEquals("SUCCEEDED", execution.getStatus(), execution.getCause());+ JsonNode rendered = mapper.readTree(execution.getOutput()).path("Sessions").get(0);+ assertEquals("2023-11-14T22:13:20.500Z", rendered.path("CreatedAt").asText());+ assertEquals("2023-11-14T22:13:21.000Z", rendered.path("UpdatedAt").asText());+ assertEquals("2023-11-14T22:14:20.250Z", rendered.path("SessionTtl").asText());+ assertEquals(60, rendered.path("SessionAliveSeconds").asInt());+ assertTrue(session.path("CreatedAt").isNumber());+ assertTrue(session.path("UpdatedAt").isNumber());+ assertTrue(session.path("SessionTtl").isNumber());+ verify(service).listSessions(any(), eq("us-east-1"));+ } finally {+ executor.stop();+ }+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/testing/ManualClock.java b/src/test/java/io/github/hectorvent/floci/testing/ManualClock.javanew file mode 100644index 0000000000..f79100fd33--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/testing/ManualClock.java@@ -0,0 +1,43 @@+package io.github.hectorvent.floci.testing;++import java.time.Clock;+import java.time.Duration;+import java.time.Instant;+import java.time.ZoneId;+import java.time.ZoneOffset;+import java.util.Objects;+import java.util.concurrent.atomic.AtomicReference;++/** A thread-safe clock that moves only when advanced; zoned views share the same timeline. */+public final class ManualClock extends Clock {+ private final AtomicReference<Instant> current;+ private final ZoneId zone;++ public ManualClock(Instant initial) {+ this(new AtomicReference<>(Objects.requireNonNull(initial)), ZoneOffset.UTC);+ }++ private ManualClock(AtomicReference<Instant> current, ZoneId zone) {+ this.current = current;+ this.zone = Objects.requireNonNull(zone);+ }++ @Override+ public ZoneId getZone() {+ return zone;+ }++ @Override+ public Clock withZone(ZoneId zone) {+ return new ManualClock(current, zone);+ }++ @Override+ public Instant instant() {+ return current.get();+ }++ public void advance(Duration duration) {+ current.updateAndGet(now -> now.plus(duration));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/testing/ManualClockTest.java b/src/test/java/io/github/hectorvent/floci/testing/ManualClockTest.javanew file mode 100644index 0000000000..5608b12b3e--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/testing/ManualClockTest.java@@ -0,0 +1,38 @@+package io.github.hectorvent.floci.testing;++import org.junit.jupiter.api.Test;++import java.time.Clock;+import java.time.Duration;+import java.time.Instant;+import java.time.ZoneOffset;++import static org.junit.jupiter.api.Assertions.assertEquals;++class ManualClockTest {+ @Test+ void readsStayFrozenUntilExplicitlyAdvanced() {+ Instant start = Instant.parse("2026-10-29T00:00:00.123456789Z");+ ManualClock clock = new ManualClock(start);++ assertEquals(start, clock.instant());+ assertEquals(start, clock.instant());+ clock.advance(Duration.ofNanos(1));+ assertEquals(start.plusNanos(1), clock.instant());+ assertEquals(start.plusNanos(1), clock.instant());+ }++ @Test+ void zonedViewsShareTheManuallyAdvancedInstant() {+ Instant start = Instant.parse("2026-10-29T00:00:00Z");+ ManualClock clock = new ManualClock(start);+ Clock zoned = clock.withZone(ZoneOffset.ofHours(7));++ assertEquals(ZoneOffset.UTC, clock.getZone());+ assertEquals(ZoneOffset.ofHours(7), zoned.getZone());+ assertEquals(start, zoned.instant());+ clock.advance(Duration.ofSeconds(60));+ assertEquals(clock.instant(), zoned.instant());+ assertEquals(start.plusSeconds(60), zoned.instant());+ }+}