Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

fix(stepfunctions): paginate state machine listings (#6717)

Jimmy Liu Jia28e72d249619
diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonHandler.java
index c4b0ce625f..393d7273dd 100644
--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonHandler.java
+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonHandler.java
@@ -37,11 +37,13 @@ import java.util.Set;
public class StepFunctionsJsonHandler {
private static final Duration HISTORY_TOKEN_LIFETIME = Duration.ofHours(24);
+ private static final Duration LIST_TOKEN_LIFETIME = Duration.ofHours(24);
private final StepFunctionsService service;
private final ObjectMapper objectMapper;
private final Clock clock;
private final SignedMarkers historyTokens = new SignedMarkers();
+ private final SignedMarkers listTokens = new SignedMarkers();
@Inject
public StepFunctionsJsonHandler(StepFunctionsService service, ObjectMapper objectMapper, Clock clock) {
@@ -289,19 +291,47 @@ public class StepFunctionsJsonHandler {
}
private Response handleListStateMachines(JsonNode request, String region) {
- List<StateMachine> list = service.listStateMachines(region);
+ Integer maxResults = parseOptionalInt(request, "maxResults");
+ String nextToken = optionalText(request, "nextToken");
+ StepFunctionsPaging.pageSize(maxResults, nextToken);
+ PaginatedResult<StateMachine> page = service.listStateMachines(region, maxResults,
+ nextToken == null ? null : listTokenPosition(nextToken, region));
ObjectNode response = objectMapper.createObjectNode();
ArrayNode array = response.putArray("stateMachines");
- for (StateMachine sm : list) {
+ for (StateMachine sm : page.items()) {
ObjectNode item = array.addObject();
item.put("stateMachineArn", sm.getStateMachineArn());
item.put("name", sm.getName());
item.put("type", sm.getType());
item.put("creationDate", sm.getCreationDate());
}
+ if (page.nextToken() != null) {
+ response.put("nextToken", listTokens.issue(
+ clock.millis() + ":" + Digests.sha256Hex(region) + ":" + page.nextToken()));
+ }
return Response.ok(response).build();
}
+ private String listTokenPosition(String nextToken, String region) {
+ String issued = listTokens.cursorOf(nextToken);
+ if (issued == null) {
+ throw new AwsException("InvalidToken", "The provided token is not valid.", 400);
+ }
+ String[] fields = issued.split(":", 3);
+ long now = clock.millis();
+ long issuedAt;
+ try {
+ issuedAt = Long.parseLong(fields[0]);
+ } catch (NumberFormatException e) {
+ throw new AwsException("InvalidToken", "The provided token is not valid.", 400);
+ }
+ if (fields.length != 3 || !fields[1].equals(Digests.sha256Hex(region))
+ || issuedAt > now || now - issuedAt > LIST_TOKEN_LIFETIME.toMillis()) {
+ throw new AwsException("InvalidToken", "The provided token is not valid.", 400);
+ }
+ return fields[2];
+ }
+
private Response handleDeleteStateMachine(JsonNode request) {
service.deleteStateMachine(request.path("stateMachineArn").asText());
return Response.ok(objectMapper.createObjectNode()).build();
diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsPaging.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsPaging.java
index d6983f0f77..09a76aac0c 100644
--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsPaging.java
+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsPaging.java
@@ -3,7 +3,7 @@ package io.github.hectorvent.floci.services.stepfunctions;
import io.github.hectorvent.floci.core.common.AwsException;
/**
- * The page request ListActivities and GetExecutionHistory check: a {@code maxResults} of 0 to 1000,
+ * The page request ListActivities, ListStateMachines and GetExecutionHistory check: a {@code maxResults} of 0 to 1000,
* where 0 or none means 100, and a {@code nextToken} of 1 to 1024 characters. Callers read both
* fields before calling it, so a wrongly typed field is reported before either bound.
*/
diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsService.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsService.java
index 70d486a708..6a80985d85 100644
--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsService.java
@@ -528,6 +528,13 @@ public class StepFunctionsService implements Resettable, ResourceProvider {
return stateMachineStore.scan(k -> k.startsWith(regionArnPrefix(region)));
}
+ public PaginatedResult<StateMachine> listStateMachines(String region, Integer maxResults, String nextToken) {
+ int pageSize = StepFunctionsPaging.pageSize(maxResults, nextToken);
+ return Pagination.paginate(listStateMachines(region), StateMachine::getStateMachineArn, pageSize, nextToken,
+ "states:state-machines:" + region + ":" + regionResolver.getAccountId(),
+ token -> new AwsException("InvalidToken", "Invalid nextToken.", 400));
+ }
+
// ── State machine versions ──────────────────────────────────────────────
public StateMachineVersion publishStateMachineVersion(String stateMachineArn) {
diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsListStateMachinesPaginationIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsListStateMachinesPaginationIntegrationTest.java
new file mode 100644
index 0000000000..b0529154bb
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsListStateMachinesPaginationIntegrationTest.java
@@ -0,0 +1,141 @@
+package io.github.hectorvent.floci.services.stepfunctions;
+
+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.response.Response;
+import jakarta.inject.Inject;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@QuarkusTest
+class StepFunctionsListStateMachinesPaginationIntegrationTest {
+
+ private static final String CONTENT_TYPE = "application/x-amz-json-1.0";
+ private static final String REGION = "me-central-1";
+ private static final String AUTHORIZATION = "AWS4-HMAC-SHA256 Credential=000000000000/20261026/"
+ + REGION + "/states/aws4_request, SignedHeaders=host, Signature=abc";
+ @Inject StepFunctionsService service;
+
+ @BeforeAll
+ static void configureRestAssured() {
+ RestAssuredJsonUtils.configureAwsContentTypes();
+ }
+
+ @Test
+ void maxResultsCapsThePage() throws Exception {
+ List<String> arns = new ArrayList<>();
+ try {
+ for (int index = 0; index < 2; index++) {
+ arns.add(service.createStateMachine(
+ "issue-page-" + UUID.randomUUID(),
+ "{\"StartAt\":\"Done\",\"States\":{\"Done\":{\"Type\":\"Succeed\"}}}",
+ "arn:aws:iam::000000000000:role/test-role", "STANDARD", REGION, null)
+ .getStateMachineArn());
+ }
+ Response firstPage = list(Map.of("maxResults", 1)).then().statusCode(200)
+ .body("stateMachines", hasSize(1))
+ .body("nextToken", notNullValue()).extract().response();
+ String nextToken = firstPage.jsonPath().getString("nextToken");
+ List<String> firstArns = firstPage.jsonPath().getList("stateMachines.stateMachineArn");
+ Response lastPage = list(Map.of("maxResults", 1, "nextToken", nextToken))
+ .then().statusCode(200).extract().response();
+ List<String> lastArns = lastPage.jsonPath().getList("stateMachines.stateMachineArn");
+ assertEquals(1, lastArns.size());
+ assertNull(lastPage.jsonPath().getString("nextToken"));
+ Set<String> listed = new HashSet<>(firstArns);
+ assertTrue(listed.addAll(lastArns), "the continuation must not repeat the first state machine");
+ assertEquals(new HashSet<>(arns), listed);
+
+ Response foreignRegion = given().contentType(CONTENT_TYPE)
+ .header("X-Amz-Target", "AWSStepFunctions.ListStateMachines")
+ .header("Authorization", "AWS4-HMAC-SHA256 Credential=000000000000/20261026/"
+ + "us-west-2/states/aws4_request, SignedHeaders=host, Signature=abc")
+ .body(Map.of("maxResults", 1, "nextToken", nextToken))
+ .post("/").then().statusCode(400).extract().response();
+ assertEquals("InvalidToken", foreignRegion.jsonPath().getString("__type"));
+
+ Response foreignAccount = given().contentType(CONTENT_TYPE)
+ .header("X-Amz-Target", "AWSStepFunctions.ListStateMachines")
+ .header("Authorization", "AWS4-HMAC-SHA256 Credential=000000000111/20261026/"
+ + REGION + "/states/aws4_request, SignedHeaders=host, Signature=abc")
+ .body(Map.of("maxResults", 1, "nextToken", nextToken))
+ .post("/").then().statusCode(400).extract().response();
+ assertEquals("InvalidToken", foreignAccount.jsonPath().getString("__type"));
+ } finally {
+ for (String arn : arns) {
+ service.deleteStateMachine(arn);
+ }
+ }
+ }
+
+ @Test
+ void zeroUsesTheDefaultPageSizeOfOneHundred() throws Exception {
+ List<String> arns = new ArrayList<>();
+ try {
+ for (int index = 0; index < 101; index++) {
+ arns.add(service.createStateMachine(
+ "issue-default-page-" + UUID.randomUUID(),
+ "{\"StartAt\":\"Done\",\"States\":{\"Done\":{\"Type\":\"Succeed\"}}}",
+ "arn:aws:iam::000000000000:role/test-role", "STANDARD", REGION, null)
+ .getStateMachineArn());
+ }
+ Response firstPage = list(Map.of("maxResults", 0)).then().statusCode(200).extract().response();
+ List<String> firstArns = firstPage.jsonPath().getList("stateMachines.stateMachineArn");
+ assertEquals(100, firstArns.size());
+ String nextToken = firstPage.jsonPath().getString("nextToken");
+ assertFalse(nextToken == null || nextToken.isEmpty());
+
+ Response lastPage = list(Map.of("maxResults", 0, "nextToken", nextToken))
+ .then().statusCode(200).extract().response();
+ List<String> lastArns = lastPage.jsonPath().getList("stateMachines.stateMachineArn");
+ assertEquals(1, lastArns.size());
+ assertNull(lastPage.jsonPath().getString("nextToken"));
+ Set<String> listed = new HashSet<>(firstArns);
+ assertTrue(listed.addAll(lastArns));
+ assertEquals(new HashSet<>(arns), listed);
+ } finally {
+ for (String arn : arns) {
+ service.deleteStateMachine(arn);
+ }
+ }
+ }
+
+ @Test
+ void rejectsInvalidPageSizeAndToken() {
+ for (Object maxResults : List.of(-1, 1001, "1", 4294967296L)) {
+ Response response = list(Map.of("maxResults", maxResults))
+ .then().statusCode(400).extract().response();
+ assertEquals("ValidationException", response.jsonPath().getString("__type"));
+ }
+ for (String nextToken : List.of("", "x".repeat(1025))) {
+ Response response = list(Map.of("nextToken", nextToken))
+ .then().statusCode(400).extract().response();
+ assertEquals("ValidationException", response.jsonPath().getString("__type"));
+ }
+ Response response = list(Map.of("nextToken", "not-a-valid-token"))
+ .then().statusCode(400).extract().response();
+ assertEquals("InvalidToken", response.jsonPath().getString("__type"));
+ }
+
+ private static Response list(Map<String, ?> request) {
+ return given().contentType(CONTENT_TYPE)
+ .header("X-Amz-Target", "AWSStepFunctions.ListStateMachines")
+ .header("Authorization", AUTHORIZATION)
+ .body(request).post("/");
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsListStateMachinesTokenTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsListStateMachinesTokenTest.java
new file mode 100644
index 0000000000..da5bcabc2c
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsListStateMachinesTokenTest.java
@@ -0,0 +1,86 @@
+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.core.common.AwsException;
+import io.github.hectorvent.floci.core.common.PaginatedResult;
+import io.github.hectorvent.floci.services.stepfunctions.model.StateMachine;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.time.Clock;
+import java.time.Duration;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class StepFunctionsListStateMachinesTokenTest {
+
+ private static final long ISSUED = 1_790_000_000_000L;
+ private static final long DAY = Duration.ofHours(24).toMillis();
+
+ private final ObjectMapper mapper = new ObjectMapper();
+ private final StepFunctionsService service = mock(StepFunctionsService.class);
+ private final Clock clock = mock(Clock.class);
+ private StepFunctionsJsonHandler handler;
+
+ @BeforeEach
+ void setUp() {
+ StateMachine machine = new StateMachine();
+ machine.setStateMachineArn("arn:aws:states:us-east-1:000000000000:stateMachine:page-one");
+ machine.setName("page-one");
+ when(service.listStateMachines("us-east-1", 1, null))
+ .thenReturn(new PaginatedResult<>(List.of(machine), "inner-token"));
+ when(service.listStateMachines("us-east-1", 1, "inner-token"))
+ .thenReturn(new PaginatedResult<>(List.of(), null));
+ when(clock.millis()).thenReturn(ISSUED);
+ handler = new StepFunctionsJsonHandler(service, mapper, clock);
+ }
+
+ @Test
+ void tokenExpiresAfterTwentyFourHours() {
+ String token = firstPageToken();
+ when(clock.millis()).thenReturn(ISSUED + DAY);
+ assertEquals(0, page(handler, "us-east-1", token).path("stateMachines").size());
+
+ when(clock.millis()).thenReturn(ISSUED + DAY + 1);
+ assertInvalid(handler, "us-east-1", token);
+ }
+
+ @Test
+ void tokenCannotBeUsedInAnotherRegionOrAfterRestart() {
+ String token = firstPageToken();
+ assertInvalid(handler, "us-west-2", token);
+ assertInvalid(new StepFunctionsJsonHandler(service, mapper, clock), "us-east-1", token);
+ }
+
+ @Test
+ void editedTokenIsRejected() {
+ String token = firstPageToken();
+ int middle = token.length() / 2;
+ String edited = token.substring(0, middle) + (token.charAt(middle) == 'A' ? 'B' : 'A')
+ + token.substring(middle + 1);
+ assertInvalid(handler, "us-east-1", edited);
+ }
+
+ private String firstPageToken() {
+ return (String) page(handler, "us-east-1", null).path("nextToken").asText();
+ }
+
+ private JsonNode page(StepFunctionsJsonHandler target, String region, String token) {
+ ObjectNode request = mapper.createObjectNode().put("maxResults", 1);
+ if (token != null) {
+ request.put("nextToken", token);
+ }
+ return (JsonNode) target.handle("ListStateMachines", request, region).getEntity();
+ }
+
+ private void assertInvalid(StepFunctionsJsonHandler target, String region, String token) {
+ AwsException error = assertThrows(AwsException.class, () -> page(target, region, token));
+ assertEquals("InvalidToken", error.getErrorCode());
+ }
+}