Light, fluffy, and always free - The AWS Local Emulator alternative
feat(sfn): publish history events for Parallel branches and Map iterations (#3167)
TATSUNO “Taz” Yasuhirofd21ac9a6d74
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/StepFunctionsExecutionHistoryTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/StepFunctionsExecutionHistoryTest.javaindex 5339e90e35..b90565cbcc 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/StepFunctionsExecutionHistoryTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/StepFunctionsExecutionHistoryTest.java@@ -126,6 +126,149 @@ class StepFunctionsExecutionHistoryTest {}}+ /**+ * Issue #2868: the states inside a Parallel branch and an inline Map iteration publish into the+ * execution's history, chained through previousEventId to the Started event that opened them.+ * The SDK reads each event's details under the field named for its type, which is what this+ * test pins. Shapes verified against real AWS in us-east-1.+ */+ @Test+ void parallelBranchesAndMapIterationsPublishTheirEvents() throws Exception {+ var smDef = """+ {+ "StartAt": "P",+ "States": {+ "P": {+ "Type": "Parallel",+ "Branches": [+ {"StartAt": "A1", "States": {"A1": {"Type": "Pass", "End": true}}}+ ],+ "Next": "M"+ },+ "M": {+ "Type": "Map",+ "ItemsPath": "$[0].items",+ "MaxConcurrency": 1,+ "ItemProcessor": {+ "ProcessorConfig": {"Mode": "INLINE"},+ "StartAt": "I1",+ "States": {"I1": {"Type": "Pass", "End": true}}+ },+ "End": true+ }+ }+ }+ """;++ var smArn = sfn.createStateMachine(b -> b+ .name(TestFixtures.uniqueName("sfn-history-branches-sm"))+ .definition(smDef)+ .roleArn(ROLE_ARN)).stateMachineArn();++ try {+ var execArn = sfn.startExecution(b -> b+ .stateMachineArn(smArn)+ .input("{\"items\": [1, 2]}")).executionArn();++ var execution = pollUntilDone(execArn);+ assertThat(execution.status()).isEqualTo(ExecutionStatus.SUCCEEDED);++ var events = sfn.getExecutionHistory(b -> b+ .executionArn(execArn)+ .includeExecutionData(true)).events();++ var types = events.stream().map(HistoryEvent::type).toList();+ assertThat(types).containsExactly(+ HistoryEventType.EXECUTION_STARTED,+ HistoryEventType.PARALLEL_STATE_ENTERED,+ HistoryEventType.PARALLEL_STATE_STARTED,+ HistoryEventType.PASS_STATE_ENTERED,+ HistoryEventType.PASS_STATE_EXITED,+ HistoryEventType.PARALLEL_STATE_SUCCEEDED,+ HistoryEventType.PARALLEL_STATE_EXITED,+ HistoryEventType.MAP_STATE_ENTERED,+ HistoryEventType.MAP_STATE_STARTED,+ HistoryEventType.MAP_ITERATION_STARTED,+ HistoryEventType.PASS_STATE_ENTERED,+ HistoryEventType.PASS_STATE_EXITED,+ HistoryEventType.MAP_ITERATION_SUCCEEDED,+ HistoryEventType.MAP_ITERATION_STARTED,+ HistoryEventType.PASS_STATE_ENTERED,+ HistoryEventType.PASS_STATE_EXITED,+ HistoryEventType.MAP_ITERATION_SUCCEEDED,+ HistoryEventType.MAP_STATE_SUCCEEDED,+ HistoryEventType.MAP_STATE_EXITED,+ HistoryEventType.EXECUTION_SUCCEEDED);++ var expectedPreviousEventIds = List.of(0L, 0L, 2L, 3L, 4L, 5L, 5L, 7L, 8L, 9L, 10L, 11L, 12L,+ 9L, 14L, 15L, 16L, 17L, 17L, 19L);+ for (var i = 0; i < events.size(); i++) {+ var event = events.get(i);+ assertThat(event.id()).isEqualTo(i + 1L);+ assertThat(event.previousEventId()).as("previousEventId of event %d", i + 1)+ .isEqualTo(expectedPreviousEventIds.get(i));+ }++ assertThat(events.get(8).mapStateStartedEventDetails().length()).isEqualTo(2);+ assertThat(events.get(9).mapIterationStartedEventDetails().name()).isEqualTo("M");+ assertThat(events.get(9).mapIterationStartedEventDetails().index()).isEqualTo(0);+ assertThat(events.get(16).mapIterationSucceededEventDetails().name()).isEqualTo("M");+ assertThat(events.get(16).mapIterationSucceededEventDetails().index()).isEqualTo(1);+ assertThat(events.get(18).stateExitedEventDetails().output()).isEqualTo("[1,2]");+ } finally {+ try { sfn.deleteStateMachine(b -> b.stateMachineArn(smArn)); } catch (Exception ignored) {}+ }+ }++ /** Issue #2868: the cause of a failure inside a branch names the branch state, as on AWS. */+ @Test+ void failureInsideABranchNamesTheBranchStateInItsCause() throws Exception {+ var smDef = """+ {+ "StartAt": "P",+ "States": {+ "P": {+ "Type": "Parallel",+ "Branches": [+ {"StartAt": "Fast", "States": {"Fast": {"Type": "Pass", "Parameters": {"m.$": "$.nope"}, "End": true}}}+ ],+ "End": true+ }+ }+ }+ """;++ var smArn = sfn.createStateMachine(b -> b+ .name(TestFixtures.uniqueName("sfn-history-branch-failure-sm"))+ .definition(smDef)+ .roleArn(ROLE_ARN)).stateMachineArn();++ try {+ var execArn = sfn.startExecution(b -> b+ .stateMachineArn(smArn)+ .input("{\"x\":\"a\"}")).executionArn();++ var execution = pollUntilDone(execArn);+ assertThat(execution.status()).isEqualTo(ExecutionStatus.FAILED);+ assertThat(execution.error()).isEqualTo("States.Runtime");+ assertThat(execution.cause()).isEqualTo(+ "An error occurred while executing the state 'Fast' (entered at the event id #4). "+ + "The JSONPath '$.nope' specified for the field 'm.$' could not be found in the input '{\"x\":\"a\"}'");++ var events = sfn.getExecutionHistory(b -> b.executionArn(execArn)).events();+ assertThat(events.stream().map(HistoryEvent::type).toList()).containsExactly(+ HistoryEventType.EXECUTION_STARTED,+ HistoryEventType.PARALLEL_STATE_ENTERED,+ HistoryEventType.PARALLEL_STATE_STARTED,+ HistoryEventType.PASS_STATE_ENTERED,+ HistoryEventType.EXECUTION_FAILED);+ assertThat(events.get(3).stateEnteredEventDetails().name()).isEqualTo("Fast");+ assertThat(events.get(4).executionFailedEventDetails().cause()).isEqualTo(execution.cause());+ } finally {+ try { sfn.deleteStateMachine(b -> b.stateMachineArn(smArn)); } catch (Exception ignored) {}+ }+ }+private DescribeExecutionResponse pollUntilDone(String execArn) throws InterruptedException {for (var i = 0; i < 120; i++) {var resp = sfn.describeExecution(b -> b.executionArn(execArn));diff --git a/docs/services/step-functions.md b/docs/services/step-functions.mdindex 6be5dd56e2..fefadadd35 100644--- a/docs/services/step-functions.md+++ b/docs/services/step-functions.md@@ -62,9 +62,34 @@ A `Retry` re-entry emits its own Scheduled, Started, and Failed triple for eachmocked Task (`SFN_MOCK_CONFIG`) emits the same events as a real one, because Step FunctionsLocal does the same.-Every event's `previousEventId` points to the id of the event right before it. The one-exception is the first state's `*StateEntered` event. Its `previousEventId` is `0`. That-matches `ExecutionStarted`, which is always `id: 1, previousEventId: 0`.+Every event's `previousEventId` points to the id of the event right before it on the same+chain of states. The one exception is the first state's `*StateEntered` event. Its+`previousEventId` is `0`. That matches `ExecutionStarted`, which is always+`id: 1, previousEventId: 0`.++### Parallel branches and Map iterations++The states inside a `Parallel` branch or an inline `Map` iteration publish their events into+the parent execution's history, as on AWS. A `Parallel` records `ParallelStateStarted`,+`ParallelStateSucceeded` and `ParallelStateFailed`. An inline `Map` records `MapStateStarted`,+`MapIterationStarted`, `MapIterationSucceeded`, `MapIterationFailed`, `MapStateSucceeded` and+`MapStateFailed`. A Distributed `Map` records `MapRunStarted`, `MapRunSucceeded` and+`MapRunFailed` instead. Its items are child executions and publish nothing into the parent+history. A `Task` whose failure ends its branch also records `TaskStateAborted`.++Branches and iterations run concurrently, so the order in which their events interleave differs+from run to run. Each branch chains its own events through `previousEventId`, and that chain is+the same every time.++### The cause of a failure++The `cause` of a failure the interpreter raises starts with+`An error occurred while executing the state '<name>' (entered at the event id #<n>). `, as on+AWS. The prefix is added once, at the innermost state. A `Fail` state's `Cause` and a cause a+task's resource answered with pass through unchanged. A `Choice` that matches no rule and has+no `Default`, and a payload template path that matches nothing, fail with `States.Runtime`.+A JSONata expression that fails also records an `EvaluationFailed` event with `error`, `cause`,+`location` and `state`, once per attempt.`inputDetails` appears on `ExecutionStarted`, on `stateEnteredEventDetails`, and on`LambdaFunctionScheduled`/`ActivityScheduled`. `outputDetails` appears on@@ -76,9 +101,12 @@ When the request sets `includeExecutionData` to false, the details objects stay`taskScheduledEventDetails.parameters`. This matches AWS.A few gaps remain. `TaskStarted`, `LambdaFunctionStarted`, and `ActivityStarted` fire at-scheduling time, not when a worker actually picks up the task. Events inside a `Parallel` or-`Map` branch are not recorded in the parent execution's history. `TaskSubmitted`, which real-AWS emits for `.sync` and `.waitForTaskToken` integrations, is not emitted yet.+scheduling time, not when a worker actually picks up the task. `TaskSubmitted`, which real+AWS emits for `.sync` and `.waitForTaskToken` integrations, is not emitted yet. When a+branch fails, AWS records `*StateAborted` and `MapIterationAborted` events for the states its+sibling branches were in; Floci cancels the siblings without recording them. A Distributed+`Map` whose item fails reports the item's own error rather than AWS's+`States.ExceedToleratedFailureThreshold`, and emits `MapRunFailed` with that error.## Map concurrency@@ -187,9 +215,8 @@ index: `Output`, `Output/a/b[0]`, `Assign/x`, `Arguments/MessageGroupId`, `Choic`Choices[1]/Output/v`, `Choices[0]/Assign/x`, `Catch[1]/Output/v`. A `Choice` stops at the first rulethat matches, so an undefined condition in a later rule is never evaluated.-One deviation. AWS prefixes the cause of a real execution with-`An error occurred while executing the state '<name>' (entered at the event id #<n>).`; Floci-returns the cause without it, which is the form AWS's own `TestState` returns.+The cause of a real execution carries the state prefix described under+[The cause of a failure](#the-cause-of-a-failure).## JSONata functionsdiff --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 cf1a5189f8..f0ffc9dec1 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@@ -94,6 +94,7 @@ import java.util.concurrent.Executors;import java.util.concurrent.Future;import java.util.concurrent.ThreadLocalRandom;import java.util.concurrent.TimeUnit;+import java.util.concurrent.atomic.AtomicInteger;import java.util.concurrent.atomic.AtomicLong;import java.util.function.BiConsumer;import java.util.stream.Collectors;@@ -125,6 +126,10 @@ public class AslExecutor {private static final String HISTORY_EVENT_LIMIT_CAUSE ="The execution reached the maximum number of history events (" + MAX_HISTORY_EVENTS + ").";+ /** AWS wording, verified against us-east-1. */+ private static final String NO_NEXT_STATE_CAUSE =+ "Failed to transition out of the state. The state does not point to a next state.";+private static final int INLINE_MAP_MAX_CONCURRENCY = 40;private static final int DISTRIBUTED_MAP_MAX_CONCURRENCY = 10_000;@@ -379,11 +384,7 @@ public class AslExecutor {private void doExecute(StateMachine sm, Execution exec, List<HistoryEvent> history,BiConsumer<Execution, List<HistoryEvent>> onUpdate) {- // Shared with every Parallel branch and every inline Map iteration of this execution: the- // 25,000-event limit is the execution's, not the thread's. It starts where the history- // already is, because ExecutionStarted is an event of this execution too.- AtomicLong producedEventCount = new AtomicLong(history.size());- var firstState = true;+ var chain = HistoryChain.of(history);try {JsonNode definition = objectMapper.readTree(sm.getDefinition());JsonNode states = definition.path("States");@@ -411,73 +412,30 @@ public class AslExecutor {throw new RuntimeException("State not found: " + currentStateName);}- String type = stateDef.path("Type").asText();- publishStateEnteredEvent(history, producedEventCount, stateEnteredEventType(type),- firstState ? 0L : history.size(),- Map.of("name", currentStateName, "input", currentInput.toString(),- "inputDetails", Map.of("truncated", false)));- firstState = false;-- // Update per-state context fields- updateStateContext(execContext, currentStateName);-- var jsonata = isJsonata(stateDef, topLevelQueryLanguage);+ StateResult stateResult;try {- var stateResult = executeStateWithRetry(currentStateName, type, stateDef, currentInput,- history, producedEventCount, sm, jsonata, topLevelQueryLanguage, execContext,- variables, executionDeadlineNanos);- publishEvent(history, producedEventCount, stateExitedEventType(type),- Map.of("name", currentStateName, "output", stateResult.output().toString(),- "outputDetails", Map.of("truncated", false)));-- currentInput = stateResult.output();- currentStateName = stateResult.nextState();-- if ("Succeed".equals(type) || stateDef.path("End").asBoolean(false)) {- currentStateName = null;- }+ stateResult = runState(chain, currentStateName, stateDef, currentInput, sm,+ topLevelQueryLanguage, execContext, variables, executionDeadlineNanos);} catch (FailStateException e) {- StateResult caught = null;- FailStateException failure = e;- try {- caught = handleCatch(stateDef, currentInput, e, jsonata, execContext, variables);- } catch (FailStateException catchClauseFailure) {- // A matching Catch clause carries its own Assign and Output, and an- // expression there can fail. AWS reports that failure, not the error the- // clause was catching, and no later clause catches it.- failure = catchClauseFailure;- }- if (caught != null) {- publishEvent(history, producedEventCount, stateExitedEventType(type),- Map.of("name", currentStateName, "output", caught.output().toString(),- "outputDetails", Map.of("truncated", false)));- currentInput = caught.output();- currentStateName = caught.nextState();- continue;- }- failExecution(exec, history, failure);+ failExecution(exec, chain, e);onUpdate.accept(exec, history);return;}+ currentInput = stateResult.output();+ currentStateName = stateResult.nextState();}- succeedExecution(exec, history, currentInput);+ succeedExecution(exec, chain, currentInput);onUpdate.accept(exec, history);} catch (ExecutionTimedOutException e) {- timeOutExecution(exec, history);- onUpdate.accept(exec, history);- } catch (FailStateException e) {- // A state's own failure is handled inside the loop, where its Catch clauses apply. What- // reaches here is a failure raised while recording a state's entered event, outside the- // per-state try: the execution hit the history-event limit.- failExecution(exec, history, e);+ timeOutExecution(exec, chain);onUpdate.accept(exec, history);} catch (Exception e) {LOG.warnv("ASL execution failed for {0}: {1}", exec.getExecutionArn(), e.getMessage());// This path previously set only the status, leaving error and cause null forever on an// execution DescribeExecution reports as FAILED.- failExecution(exec, history, "States.Runtime",+ failExecution(exec, chain, "States.Runtime",e.getMessage() != null ? e.getMessage() : "Unknown error");onUpdate.accept(exec, history);} catch (Error e) {@@ -487,7 +445,7 @@ public class AslExecutor {// and the rethrow keeps the Error itself from being swallowed here. The cause carries// toString() rather than getMessage(), because an Error's message is often null and// the type name is the whole diagnostic.- failExecution(exec, history, "States.Runtime", e.toString());+ failExecution(exec, chain, "States.Runtime", e.toString());onUpdate.accept(exec, history);throw e;} finally {@@ -495,6 +453,69 @@ public class AslExecutor {}}+ private StateResult runState(HistoryChain chain, String name, JsonNode stateDef, JsonNode input,+ StateMachine sm, String topLevelQueryLanguage, JsonNode context,+ ObjectNode variables, long executionDeadlineNanos) throws Exception {+ var type = stateDef.path("Type").asText();+ var enteredEventId = chain.publish(stateEnteredEventType(type),+ Map.of("name", name, "input", input.toString(), "inputDetails", Map.of("truncated", false)));+ updateStateContext(context, name);+ var jsonata = isJsonata(stateDef, topLevelQueryLanguage);+ StateResult result;+ try {+ result = executeStateWithRetry(name, enteredEventId, type, stateDef, input, chain, sm, jsonata,+ topLevelQueryLanguage, context, variables, executionDeadlineNanos);+ if ("Succeed".equals(type) || stateDef.path("End").asBoolean(false)) {+ result = new StateResult(result.output(), null);+ }+ } catch (FailStateException failure) {+ var beforeFailed = chain.lastEventId();+ publishStateFailedEvent(chain, type, failure);+ try {+ result = handleCatch(stateDef, input, failure, jsonata, context, variables);+ } catch (FailStateException catchClauseFailure) {+ // AWS reports a failure inside the Catch clause itself, and no later clause catches+ // it. The clause's EvaluationFailed is recorded from before the state's Failed event.+ var clauseFailure = catchClauseFailure.attributedTo(name, enteredEventId);+ chain.continueFrom(beforeFailed);+ publishEvaluationFailedEvent(chain, name, clauseFailure);+ publishStateFailedEvent(chain, type, clauseFailure);+ throw clauseFailure;+ }+ if (result == null) {+ if (chain.isBranch() && "Task".equals(type) && !failure.isRuntimeError()) {+ // AWS records this after TaskFailed when the failure ends the branch.+ chain.publishAside("TaskStateAborted", null);+ }+ throw failure;+ }+ }+ chain.publish(stateExitedEventType(type),+ Map.of("name", name, "output", result.output().toString(),+ "outputDetails", Map.of("truncated", false)));+ return result;+ }++ /** AWS records no *StateFailed event for States.Runtime. */+ private void publishStateFailedEvent(HistoryChain chain, String type, FailStateException failure) {+ if (("Parallel".equals(type) || "Map".equals(type)) && !failure.isRuntimeError()) {+ chain.publish(type + "StateFailed", null);+ }+ }++ /** Recorded once per attempt, before Retry and Catch, as on AWS. */+ private void publishEvaluationFailedEvent(HistoryChain chain, String stateName, FailStateException failure) {+ if (!"States.QueryEvaluationError".equals(failure.error)) {+ return;+ }+ var details = failureDetails(failure);+ if (failure.location != null) {+ details.put("location", failure.location);+ }+ details.put("state", stateName);+ chain.publish("EvaluationFailed", details);+ }+private void registerMocks(Execution exec, MockedTestCase mockedTestCase) {if (mockedTestCase != null) {activeMocks.put(exec.getExecutionArn(), mockedTestCase);@@ -507,19 +528,23 @@ public class AslExecutor {* used up. Errors that no retrier matches (or that exhaust their retrier) propagate to the* caller's Catch handling, preserving Retry-before-Catch order.*/- private StateResult executeStateWithRetry(String name, String type, JsonNode stateDef, JsonNode input,- List<HistoryEvent> history, AtomicLong producedEventCount,- StateMachine sm, boolean jsonata, String topLevelQueryLanguage,- JsonNode context, ObjectNode variables,- long executionDeadlineNanos) throws Exception {+ private StateResult executeStateWithRetry(String name, long enteredEventId, String type, JsonNode stateDef,+ JsonNode input, HistoryChain chain, StateMachine sm, boolean jsonata,+ String topLevelQueryLanguage, JsonNode context,+ ObjectNode variables, long executionDeadlineNanos)+ throws Exception {var retriers = stateDef.path("Retry");var attemptsPerRetrier = new HashMap<Integer, Integer>();var attempt = 0;while (true) {try {- return executeState(name, type, stateDef, input, history, producedEventCount, sm, jsonata,+ return executeState(name, type, stateDef, input, chain, sm, jsonata,topLevelQueryLanguage, context, variables, attempt, executionDeadlineNanos);- } catch (FailStateException e) {+ } catch (FailStateException raised) {+ var e = raised.attributedTo(name, enteredEventId);+ if (!raised.hasFinalCause()) {+ publishEvaluationFailedEvent(chain, name, e);+ }var retrierIndex = findMatchingRetrier(retriers, e);if (retrierIndex < 0) {throw e;@@ -586,21 +611,20 @@ public class AslExecutor {}private StateResult executeState(String name, String type, JsonNode stateDef, JsonNode input,- List<HistoryEvent> history, AtomicLong producedEventCount,- StateMachine sm, boolean jsonata, String topLevelQueryLanguage,- JsonNode context, ObjectNode variables, int attempt,- long executionDeadlineNanos) throws Exception {+ HistoryChain chain, StateMachine sm, boolean jsonata,+ String topLevelQueryLanguage, JsonNode context, ObjectNode variables,+ int attempt, long executionDeadlineNanos) throws Exception {return switch (type) {case "Pass" -> executePassState(stateDef, input, jsonata, context, variables);- case "Task" -> executeTaskState(name, stateDef, input, history, producedEventCount, sm,+ case "Task" -> executeTaskState(name, stateDef, input, chain, sm,jsonata, context, variables, attempt, executionDeadlineNanos);case "Choice" -> executeChoiceState(stateDef, input, jsonata, context, variables);case "Wait" -> executeWaitState(stateDef, input, jsonata, context, variables, executionDeadlineNanos);case "Succeed" -> executeSucceedState(stateDef, input, jsonata, context, variables);case "Fail" -> executeFail(stateDef, input, jsonata, context, variables);- case "Parallel" -> executeParallelState(name, stateDef, input, producedEventCount, sm, jsonata,+ case "Parallel" -> executeParallelState(name, stateDef, input, chain, sm, jsonata,topLevelQueryLanguage, context, variables, executionDeadlineNanos);- case "Map" -> executeMapState(name, stateDef, input, producedEventCount, sm, jsonata,+ case "Map" -> executeMapState(name, stateDef, input, chain, sm, jsonata,topLevelQueryLanguage, context, variables, executionDeadlineNanos);default -> new StateResult(input, stateDef.path("Next").asText(null));};@@ -632,9 +656,8 @@ public class AslExecutor {}private StateResult executeTaskState(String stateName, JsonNode stateDef, JsonNode input,- List<HistoryEvent> history, AtomicLong producedEventCount,- StateMachine sm, boolean jsonata, JsonNode context,- ObjectNode variables, int attempt,+ HistoryChain chain, StateMachine sm, boolean jsonata,+ JsonNode context, ObjectNode variables, int attempt,long executionDeadlineNanos) throws Exception {var resource = stateDef.path("Resource").asText();var isWaitForToken = resource.endsWith(".waitForTaskToken");@@ -648,11 +671,9 @@ public class AslExecutor {var needsToken = mockedSteps == null && (isWaitForToken || isActivity);String taskToken = null;- CompletableFuture<JsonNode> tokenFuture = null;if (needsToken) {taskToken = UUID.randomUUID().toString();((ObjectNode) context.get("Task")).put("Token", taskToken);- tokenFuture = sfnService.get().registerPendingToken(taskToken);}JsonNode effectiveInput;@@ -670,11 +691,13 @@ public class AslExecutor {}}+ // Registered after the input template resolved, so a template failure leaves no token behind.+ var tokenFuture = needsToken ? sfnService.get().registerPendingToken(taskToken) : null;var profile = taskEventProfile(resource, isActivity);JsonNode taskResult;try {- addTaskScheduledEvent(history, producedEventCount, profile, stateDef, effectiveInput, sm);- addTaskStartedEvent(history, producedEventCount, profile);+ addTaskScheduledEvent(chain, profile, stateDef, effectiveInput, sm);+ addTaskStartedEvent(chain, profile);try {taskResult = mockedSteps != null? mockedTaskResult(mockedSteps, stateName, attempt)@@ -690,14 +713,18 @@ public class AslExecutor {// ActivityScheduled, ExecutionTimedOut, with no TaskFailed and no TaskTimedOut.throw e;} catch (TaskTimedOutException e) {- addTaskTimedOutEvent(history, producedEventCount, profile);+ addTaskTimedOutEvent(chain, profile);+ throw e;+ } catch (InterruptedException e) {+ // The task of a branch that was cut. AWS records nothing for it.throw e;} catch (Exception e) {var failure = e instanceof FailStateException f ? f : null;- addTaskFailedEvent(history, producedEventCount, profile,+ addTaskFailedEvent(chain, profile,failure != null && failure.error != null ? failure.error : "States.Runtime",failure != null ? failure.cause : e.getMessage());- throw e;+ // AWS does not prefix a cause the resource answered with.+ throw failure != null ? failure.withFinalCause() : e;}} catch (Exception e) {// A token registered above is normally discarded by awaitToken's own finally. Anything@@ -709,7 +736,7 @@ public class AslExecutor {}throw e;}- addTaskSucceededEvent(history, producedEventCount, profile, taskResult);+ addTaskSucceededEvent(chain, profile, taskResult);if (jsonata) {JsonNode output = applyJsonataOutput(stateDef, input, taskResult, context, variables);@@ -1897,7 +1924,7 @@ public class AslExecutor {JsonNode output = applyJsonataAssignAndOutput(stateDef, "", statesVar, input, variables);return new StateResult(output, defaultState);}- throw new FailStateException("States.NoChoiceMatched", "No choice rule matched and no default state");+ throw new FailStateException("States.Runtime", NO_NEXT_STATE_CAUSE);}JsonNode choices = stateDef.path("Choices");@@ -1911,7 +1938,7 @@ public class AslExecutor {if (defaultState != null) {return new StateResult(input, defaultState);}- throw new FailStateException("States.NoChoiceMatched", "No choice rule matched and no default state");+ throw new FailStateException("States.Runtime", NO_NEXT_STATE_CAUSE);}private boolean evaluateCondition(JsonNode rule, JsonNode input) throws Exception {@@ -2002,15 +2029,18 @@ public class AslExecutor {cause = jsonataEvaluator.evaluateField(cause, "Cause", statesVar, variables).asText();}}- throw new FailStateException(error, cause);+ // AWS does not prefix a Fail state's Cause.+ throw new FailStateException(error, cause, true);}private StateResult executeParallelState(String name, JsonNode stateDef, JsonNode input,- AtomicLong producedEventCount, StateMachine sm, boolean jsonata,+ HistoryChain chain, StateMachine sm, boolean jsonata,String topLevelQueryLanguage, JsonNode context,ObjectNode variables, long executionDeadlineNanos)throws Exception {JsonNode branches = stateDef.path("Branches");+ chain.publish("ParallelStateStarted", null);+ var branchChains = new ArrayList<HistoryChain>();List<Future<JsonNode>> futures = new ArrayList<>();for (JsonNode branch : branches) {@@ -2023,6 +2053,8 @@ public class AslExecutor {// Each branch also gets its own copy of the context object so State.RetryCount and// Task.Token writes cannot race across concurrent branches.var branchContext = ((ObjectNode) context).deepCopy();+ var branchChain = chain.fork();+ branchChains.add(branchChain);// Run each branch on its own worker thread under the execution's account: the request// scope is thread-bound, so without this a branch's Task integrations would resolve to@@ -2031,7 +2063,7 @@ public class AslExecutor {// this Parallel's: the ASL specification calls the two independent, so what travels// into the branch is topLevelQueryLanguage. https://states-language.net/spec.htmlfutures.add(executor.submit(() -> callUnderExecutionAccount(sm,- () -> executeBranch(startAt, branchStates, capturedInput, producedEventCount, sm,+ () -> executeBranch(startAt, branchStates, capturedInput, branchChain, sm,topLevelQueryLanguage, branchContext, branchVariables))));}@@ -2044,6 +2076,7 @@ public class AslExecutor {long joinDeadlineNanos = Math.min(stateDeadlineNanos, executionDeadlineNanos);ArrayNode results = objectMapper.createArrayNode();+ var joined = 0;try {for (Future<JsonNode> future : futures) {long remainingNanos = joinDeadlineNanos - System.nanoTime();@@ -2055,13 +2088,15 @@ public class AslExecutor {} catch (java.util.concurrent.TimeoutException e) {throw parallelJoinExpired(stateDeadlineNanos, timeoutSeconds);}+ joined++;}} catch (InterruptedException e) {- futures.forEach(future -> future.cancel(true));+ abandon(branchChains, futures);Thread.currentThread().interrupt();throw e;} catch (ExecutionException e) {- futures.forEach(future -> future.cancel(true));+ abandon(branchChains, futures);+ chain.continueFrom(branchChains.get(joined).lastEventId());// Unwrap so a branch's FailStateException reaches the Parallel state's own Retry and// Catch handling instead of surfacing as States.Runtime, and so an Error reaches the// execution-level handler as itself rather than as an ExecutionException wrapper. The@@ -2076,10 +2111,13 @@ public class AslExecutor {}throw e;} catch (Exception | Error e) {- futures.forEach(future -> future.cancel(true));+ abandon(branchChains, futures);throw e;}+ chain.continueAfter(branchChains);+ chain.publishAside("ParallelStateSucceeded", null);+if (jsonata) {JsonNode output = applyJsonataOutput(stateDef, input, results, context, variables);return new StateResult(output, stateDef.path("Next").asText(null));@@ -2094,6 +2132,11 @@ public class AslExecutor {return new StateResult(output, stateDef.path("Next").asText(null));}+ private static void abandon(List<HistoryChain> chains, List<? extends Future<?>> futures) {+ chains.forEach(HistoryChain::abandon);+ futures.forEach(future -> future.cancel(true));+ }+/*** Names the clock that ended a Parallel's join. The state's own {@code TimeoutSeconds} fails* the state, so its Retry and Catch still apply; the state machine's budget ends the whole@@ -2104,11 +2147,11 @@ public class AslExecutor {return new ExecutionTimedOutException();}return new FailStateException("States.Timeout",- "Parallel state timed out after " + timeoutSeconds + " seconds");+ "Parallel state timed out after " + timeoutSeconds + " seconds", true);}private StateResult executeMapState(String name, JsonNode stateDef, JsonNode input,- AtomicLong producedEventCount, StateMachine sm, boolean jsonata,+ HistoryChain chain, StateMachine sm, boolean jsonata,String topLevelQueryLanguage, JsonNode context,ObjectNode variables, long executionDeadlineNanos)throws Exception {@@ -2151,7 +2194,23 @@ public class AslExecutor {int effectiveConcurrency = effectiveMapConcurrency(itemCount, requestedConcurrency, distributed);+ chain.publish("MapStateStarted", Map.of("length", itemCount));+ MapRunIdentity mapRun = null;+ MapRun mapRunRecord = null;+ if (distributed) {+ mapRun = newMapRunIdentity(stateDef, sm, context);+ mapRunRecord = newMapRun(mapRun, context, itemCount, requestedConcurrency);+ chain.publish("MapRunStarted", Map.of("mapRunArn", mapRun.arn()));+ }+ var succeededItems = new AtomicInteger();+ var failedItems = new AtomicInteger();+ var iterationChains = new ArrayList<HistoryChain>(itemCount);+ for (var i = 0; i < itemCount; i++) {+ iterationChains.add(distributed ? HistoryChain.ofChildExecution() : chain.fork());+ }+java.util.function.IntFunction<Callable<JsonNode>> makeTask = (i) -> () -> {+ var iterationChain = iterationChains.get(i);JsonNode item = items.get(i);ObjectNode iterContext = ((ObjectNode) context).deepCopy();ObjectNode mapCtx = objectMapper.createObjectNode();@@ -2166,27 +2225,38 @@ public class AslExecutor {mapCtx.set("Item", mapItem);iterContext.set("Map", mapCtx);- JsonNode iterInput = item;- if (itemTransform != null) {- // $ in ItemSelector resolves against the Map state's effective input, not the item.- iterInput = resolveParameters(itemTransform, mapInput, iterContext);- }- // Each iteration gets an isolated copy of the current variables; assignments inside an- // iteration are scoped to that iteration and do not leak back to the parent scope. An- // isolated copy per worker also keeps concurrent iterations from racing on shared state.long startMs = hasResultWriter ? System.currentTimeMillis() : 0L;- if (hasResultWriter) {- childInputsByIndex[i] = iterInput;- }- // A Distributed Map runs each item as a child execution, and a child execution has a- // history of its own: the item's events count against its own limit, not the parent's.- // An inline Map's iterations are part of this execution and count here.- AtomicLong childExecutionEventCount = distributed ? new AtomicLong() : producedEventCount;- // Same rule as the Parallel branches above: an ItemProcessor state declaring no- // QueryLanguage runs as the state machine's, never as this Map's.- JsonNode branchOutput = executeBranch(startAt, iteratorStates, iterInput,- childExecutionEventCount, sm, topLevelQueryLanguage, iterContext,- variables.deepCopy());+ JsonNode branchOutput;+ try {+ if (!distributed) {+ iterationChain.publish("MapIterationStarted", Map.of("name", name, "index", i));+ }+ JsonNode iterInput = item;+ if (itemTransform != null) {+ // $ in ItemSelector resolves against the Map state's effective input, not the item.+ iterInput = resolveParameters(itemTransform, mapInput, iterContext);+ }+ if (hasResultWriter) {+ childInputsByIndex[i] = iterInput;+ }+ // Each iteration gets an isolated copy of the current variables; assignments inside an+ // iteration are scoped to that iteration and do not leak back to the parent scope. An+ // isolated copy per worker also keeps concurrent iterations from racing on shared state.+ // Same rule as the Parallel branches above: an ItemProcessor state declaring no+ // QueryLanguage runs as the state machine's, never as this Map's.+ branchOutput = executeBranch(startAt, iteratorStates, iterInput, iterationChain, sm,+ topLevelQueryLanguage, iterContext, variables.deepCopy());+ } catch (FailStateException e) {+ failedItems.incrementAndGet();+ if (!distributed && !e.isRuntimeError()) {+ iterationChain.publishAside("MapIterationFailed", Map.of("name", name, "index", i));+ }+ throw new IterationFailure(i, e);+ }+ succeededItems.incrementAndGet();+ if (!distributed) {+ iterationChain.publish("MapIterationSucceeded", Map.of("name", name, "index", i));+ }if (hasResultWriter) {childTimingsByIndex[i] = new long[]{startMs, System.currentTimeMillis()};}@@ -2204,6 +2274,17 @@ public class AslExecutor {// The only deadline the scheduler is given is the state machine's budget, so its// expiry ends the execution rather than failing the Map state.throw new ExecutionTimedOutException();+ } catch (IterationFailure e) {+ // A Distributed Map's chain stays at MapRunStarted, as on AWS.+ if (!distributed) {+ chain.continueFrom(iterationChains.get(e.index).lastEventId());+ } else {+ publishMapRunFailedEvent(chain, e.failure);+ recordMapRun(mapRunRecord, "FAILED", succeededItems.get(), failedItems.get());+ }+ throw e.failure;+ } finally {+ iterationChains.forEach(HistoryChain::abandon);}results.addAll(itemOutputs);}@@ -2216,10 +2297,24 @@ public class AslExecutor {childInputs.add(childInputsByIndex[i]);childTimings.add(childTimingsByIndex[i]);}- mapResult = applyResultWriter(name, stateDef, mapInput, results, childInputs, childTimings,- sm, context, jsonata, variables);- recordMapRun(mapResult, context, childTimings, requestedConcurrency);+ try {+ mapResult = applyResultWriter(name, stateDef, mapInput, results, childInputs, childTimings,+ sm, context, jsonata, variables, mapRun);+ } catch (FailStateException e) {+ // A ResultWriter failure fails the Map run on AWS.+ publishMapRunFailedEvent(chain, e);+ recordMapRun(mapRunRecord, "FAILED", succeededItems.get(), failedItems.get());+ throw e;+ }+ }++ if (distributed) {+ recordMapRun(mapRunRecord, "SUCCEEDED", succeededItems.get(), failedItems.get());+ chain.publishAside("MapRunSucceeded", null);+ } else {+ chain.continueAfter(iterationChains);}+ chain.publishAside("MapStateSucceeded", null);if (jsonata) {JsonNode output = applyJsonataOutput(stateDef, input, mapResult, context, variables);@@ -2255,7 +2350,7 @@ public class AslExecutor {if (!value.isIntegralNumber() || value.bigIntegerValue().signum() < 0) {throw new FailStateException(jsonataExpression ? "States.QueryEvaluationError" : "States.Runtime",- "MaxConcurrency must resolve to a non-negative integer");+ "MaxConcurrency must resolve to a non-negative integer", "MaxConcurrency");}return value.bigIntegerValue().compareTo(java.math.BigInteger.valueOf(Integer.MAX_VALUE)) > 0? Integer.MAX_VALUE@@ -2282,28 +2377,26 @@ public class AslExecutor {* a Map run's window on the export rather than on the last item. A run over no items starts and* stops at that same instant.*/- private void recordMapRun(JsonNode mapResult, JsonNode context, List<long[]> childTimings,- int requestedConcurrency) {- String mapRunArn = mapResult.path("MapRunArn").asText(null);- if (mapRunArn == null) {- return;- }- long stop = System.currentTimeMillis();- long start = stop;- for (long[] timing : childTimings) {- start = Math.min(start, timing[0]);- }-- MapRun mapRun = new MapRun();- mapRun.setMapRunArn(mapRunArn);+ private static MapRun newMapRun(MapRunIdentity identity, JsonNode context, int itemCount,+ int requestedConcurrency) {+ var mapRun = new MapRun();+ mapRun.setMapRunArn(identity.arn());mapRun.setExecutionArn(context.path("Execution").path("Id").asText(null));- mapRun.setStartDate(start / 1000.0);- mapRun.setStopDate(stop / 1000.0);- mapRun.setItemCount(childTimings.size());+ mapRun.setStartDate(System.currentTimeMillis() / 1000.0);+ mapRun.setItemCount(itemCount);// ASL spells an unbounded Map as MaxConcurrency 0, or by omitting it; DescribeMapRun// reports that same run as Integer.MAX_VALUE.mapRun.setMaxConcurrency(requestedConcurrency == 0 ? Integer.MAX_VALUE : requestedConcurrency);+ return mapRun;+ }++ /** Kept for every Distributed Map, so the mapRunArn in the history resolves through DescribeMapRun. */+ private void recordMapRun(MapRun mapRun, String status, int succeededItems, int failedItems) {+ mapRun.setStopDate(System.currentTimeMillis() / 1000.0);+ mapRun.setStatus(status);+ mapRun.setSucceededCount(succeededItems);+ mapRun.setFailedCount(failedItems);sfnService.get().recordMapRun(mapRun);}@@ -2331,13 +2424,29 @@ public class AslExecutor {ArrayNode results, ArrayNode childInputs, List<long[]> childTimings,StateMachine sm, JsonNode context, boolean jsonata) throws Exception {return applyResultWriter(mapStateName, stateDef, input, results, childInputs, childTimings,- sm, context, jsonata, objectMapper.createObjectNode());+ sm, context, jsonata, objectMapper.createObjectNode(), newMapRunIdentity(stateDef, sm, context));+ }++ private record MapRunIdentity(String label, String id, String arn) {+ }++ private MapRunIdentity newMapRunIdentity(JsonNode stateDef, StateMachine sm, JsonNode context) {+ var region = extractRegionFromArn(sm.getStateMachineArn());+ var account = AwsArnUtils.accountOrDefault(sm.getStateMachineArn(), null);+ var smName = context.path("StateMachine").path("Name").asText(sm.getName());+ var label = stateDef.path("Label").asText(null);+ if (label == null || label.isBlank()) {+ label = UUID.randomUUID().toString();+ }+ var id = UUID.randomUUID().toString();+ return new MapRunIdentity(label, id, "arn:aws:states:" + region + ":" + account + ":mapRun:"+ + smName + "/" + label + ":" + id);}private JsonNode applyResultWriter(String mapStateName, JsonNode stateDef, JsonNode input,ArrayNode results, ArrayNode childInputs, List<long[]> childTimings,StateMachine sm, JsonNode context, boolean jsonata,- ObjectNode variables) throws Exception {+ ObjectNode variables, MapRunIdentity mapRun) throws Exception {JsonNode writer = stateDef.get("ResultWriter");JsonNode writerConfig = writer.path("WriterConfig");boolean export = writer.hasNonNull("Resource");@@ -2350,13 +2459,9 @@ public class AslExecutor {String region = extractRegionFromArn(sm.getStateMachineArn());String account = AwsArnUtils.accountOrDefault(sm.getStateMachineArn(), null);String smName = context.path("StateMachine").path("Name").asText(sm.getName());- String mapRunLabel = stateDef.path("Label").asText(null);- if (mapRunLabel == null || mapRunLabel.isBlank()) {- mapRunLabel = UUID.randomUUID().toString();- }JsonNode formatted = formatMapResults(transformation, results, childInputs, childTimings,- region, account, smName, mapRunLabel);+ region, account, smName, mapRun.label());if (!export) {// WriterConfig only: return the formatted results to the next state (no S3 write).@@ -2380,7 +2485,7 @@ public class AslExecutor {throw new FailStateException(jsonata ? "States.QueryEvaluationError" : "States.ResultWriterFailed","ResultWriter " + (jsonata ? "Arguments" : "Parameters")- + " must resolve to an object");+ + " must resolve to an object", "ResultWriter/Arguments");}JsonNode bucketNode = loc.get("Bucket");if (bucketNode == null) {@@ -2390,7 +2495,7 @@ public class AslExecutor {if (!bucketNode.isTextual()) {throw new FailStateException(jsonata ? "States.QueryEvaluationError" : "States.ResultWriterFailed",- "ResultWriter Bucket must resolve to a string");+ "ResultWriter Bucket must resolve to a string", "ResultWriter/Arguments/Bucket");}String bucket = bucketNode.asText();if (bucket.isBlank()) {@@ -2401,7 +2506,7 @@ public class AslExecutor {if (prefixNode != null && !prefixNode.isTextual()) {throw new FailStateException(jsonata ? "States.QueryEvaluationError" : "States.ResultWriterFailed",- "ResultWriter Prefix must resolve to a string");+ "ResultWriter Prefix must resolve to a string", "ResultWriter/Arguments/Prefix");}String prefix = prefixNode == null ? "" : prefixNode.asText();@@ -2414,11 +2519,9 @@ public class AslExecutor {+ "as the state machine");}- // AWS includes the Map label (or an automatically generated label) before the run id.// The run id alone keys the exported result set under the user-supplied S3 prefix.- String mapRunId = UUID.randomUUID().toString();- String mapRunArn = "arn:aws:states:" + region + ":" + account + ":mapRun:"- + smName + "/" + mapRunLabel + ":" + mapRunId;+ var mapRunId = mapRun.id();+ var mapRunArn = mapRun.arn();String base = prefix.isEmpty()? mapRunId + "/": prefix + (prefix.endsWith("/") ? "" : "/") + mapRunId + "/";@@ -2638,16 +2741,12 @@ public class AslExecutor {}/**- * Runs the states of one Parallel branch or one Map iteration. floci does not publish their- * events, but they are events of the execution all the same, so each one is counted against its- * history-event limit: a branch that never reaches a terminal state ends the whole execution at- * event 25,000, exactly as one in the top-level flow does. A null history is what tells the- * states below they are running inside a branch.+ * Runs the states of one Parallel branch or one Map iteration. Their events count against the+ * execution's history-event limit, as on AWS.*/- private JsonNode executeBranch(String startAt, JsonNode states, JsonNode input,- AtomicLong producedEventCount, StateMachine sm,- String topLevelQueryLanguage, JsonNode context,- ObjectNode variables) throws Exception {+ private JsonNode executeBranch(String startAt, JsonNode states, JsonNode input, HistoryChain chain,+ StateMachine sm, String topLevelQueryLanguage, JsonNode context,+ ObjectNode variables) throws Exception {JsonNode currentInput = input;String currentState = startAt;@@ -2659,31 +2758,13 @@ public class AslExecutor {if (stateDef.isMissingNode()) {throw new RuntimeException("State not found: " + currentState);}- String type = stateDef.path("Type").asText();- boolean stateJsonata = isJsonata(stateDef, topLevelQueryLanguage);- updateStateContext(context, currentState);- countTowardsHistoryEventLimit(producedEventCount);- StateResult result;- try {- // A Parallel or Map branch runs on its own thread and is not cut mid-state by the- // execution's TimeoutSeconds: the state loop that resumes once the branch returns- // is where the budget is enforced.- result = executeStateWithRetry(currentState, type, stateDef, currentInput,- null, producedEventCount, sm, stateJsonata, topLevelQueryLanguage, context,- variables, Long.MAX_VALUE);- } catch (FailStateException e) {- StateResult caught = handleCatch(stateDef, currentInput, e, stateJsonata, context, variables);- if (caught == null) {- throw e;- }- result = caught;- }- countTowardsHistoryEventLimit(producedEventCount);+ // A Parallel or Map branch runs on its own thread and is not cut mid-state by the+ // execution's TimeoutSeconds: the state loop that resumes once the branch returns+ // is where the budget is enforced.+ var result = runState(chain, currentState, stateDef, currentInput, sm, topLevelQueryLanguage,+ context, variables, Long.MAX_VALUE);currentInput = result.output();currentState = result.nextState();- if ("Succeed".equals(type) || stateDef.path("End").asBoolean(false)) {- currentState = null;- }}return currentInput;}@@ -3913,63 +3994,7 @@ public class AslExecutor {*/static void countTowardsHistoryEventLimit(AtomicLong producedEventCount) {if (producedEventCount.incrementAndGet() >= MAX_HISTORY_EVENTS) {- throw new FailStateException("States.Runtime", HISTORY_EVENT_LIMIT_CAUSE);- }- }-- /**- * Records an event the state machine produced: counted against the history-event limit, then- * published.- *- * <p>{@code history} is null inside a Parallel branch or a Map iteration. Their states are- * states of this execution and their events count against its limit, but floci does not publish- * them, so there is nothing to build for them beyond the count.- */- private void publishEvent(List<HistoryEvent> history, AtomicLong producedEventCount, String type,- Map<String, Object> details) {- countTowardsHistoryEventLimit(producedEventCount);- if (history == null) {- return;- }- appendEvent(history, type, history.size(), details);- }-- /**- * Records a state's Entered event with the previousEventId the top-level flow works out: AWS- * leaves the Entered event of the state an execution starts in unchained, at previousEventId 0,- * rather than pointing it at the ExecutionStarted event before it. Only the top-level flow- * publishes these, so its history is never null.- */- private void publishStateEnteredEvent(List<HistoryEvent> history, AtomicLong producedEventCount,- String type, long previousEventId,- Map<String, Object> details) {- countTowardsHistoryEventLimit(producedEventCount);- appendEvent(history, type, previousEventId, details);- }-- /**- * Records the event that ends the execution. It does not count towards the history-event limit:- * an execution always gets to say how it ended, in the slot {@link #publishEvent} leaves free.- */- private void publishTerminalEvent(List<HistoryEvent> history, String type, Map<String, Object> details) {- appendEvent(history, type, history.size(), details);- }-- /**- * Appends an event and numbers it from the end of the history: the published history is the one- * authority for an event's id, so an event's id is its position in the list. Held under the- * history's own monitor, because StopExecution appends the terminal event of an aborted- * execution from another thread and seals the history against anything after it.- */- private void appendEvent(List<HistoryEvent> history, String type, long previousEventId,- Map<String, Object> details) {- synchronized (history) {- var event = new HistoryEvent();- event.setId(history.size() + 1L);- event.setPreviousEventId(previousEventId);- event.setType(type);- event.setDetails(details);- history.add(event);+ throw new FailStateException("States.Runtime", HISTORY_EVENT_LIMIT_CAUSE, true);}}@@ -3993,9 +4018,8 @@ public class AslExecutor {return new TaskEventProfile("Task", resource, resource);}- private void addTaskScheduledEvent(List<HistoryEvent> history, AtomicLong producedEventCount,- TaskEventProfile profile, JsonNode stateDef, JsonNode effectiveInput,- StateMachine sm) {+ private void addTaskScheduledEvent(HistoryChain chain, TaskEventProfile profile, JsonNode stateDef,+ JsonNode effectiveInput, StateMachine sm) {var details = new LinkedHashMap<String, Object>();if (profile.resourceType() != null) {details.put("resourceType", profile.resourceType());@@ -4014,34 +4038,31 @@ public class AslExecutor {if (stateDef.path("HeartbeatSeconds").isNumber()) {details.put("heartbeatInSeconds", stateDef.path("HeartbeatSeconds").asLong());}- publishEvent(history, producedEventCount, profile.prefix() + "Scheduled", details);+ chain.publish(profile.prefix() + "Scheduled", details);}- private void addTaskStartedEvent(List<HistoryEvent> history, AtomicLong producedEventCount,- TaskEventProfile profile) {+ private void addTaskStartedEvent(HistoryChain chain, TaskEventProfile profile) {if ("Task".equals(profile.prefix())) {- publishEvent(history, producedEventCount, profile.prefix() + "Started",+ chain.publish(profile.prefix() + "Started",Map.of("resourceType", profile.resourceType(), "resource", profile.resource()));} else {- publishEvent(history, producedEventCount, profile.prefix() + "Started", null);+ chain.publish(profile.prefix() + "Started", null);}}- private void addTaskSucceededEvent(List<HistoryEvent> history, AtomicLong producedEventCount,- TaskEventProfile profile, JsonNode taskResult) {+ private void addTaskSucceededEvent(HistoryChain chain, TaskEventProfile profile, JsonNode taskResult) {var output = taskResult.toString();if ("Task".equals(profile.prefix())) {- publishEvent(history, producedEventCount, profile.prefix() + "Succeeded",+ chain.publish(profile.prefix() + "Succeeded",Map.of("resourceType", profile.resourceType(), "resource", profile.resource(),"output", output, "outputDetails", Map.of("truncated", false)));} else {- publishEvent(history, producedEventCount, profile.prefix() + "Succeeded",+ chain.publish(profile.prefix() + "Succeeded",Map.of("output", output, "outputDetails", Map.of("truncated", false)));}}- private void addTaskFailedEvent(List<HistoryEvent> history, AtomicLong producedEventCount,- TaskEventProfile profile, String error, String cause) {+ private void addTaskFailedEvent(HistoryChain chain, TaskEventProfile profile, String error, String cause) {var details = new LinkedHashMap<String, Object>();if ("Task".equals(profile.prefix())) {details.put("resourceType", profile.resourceType());@@ -4053,26 +4074,25 @@ public class AslExecutor {if (cause != null) {details.put("cause", cause);}- publishEvent(history, producedEventCount, profile.prefix() + "Failed", details);+ chain.publish(profile.prefix() + "Failed", details);}/*** The event a Task leaves when one of its clocks runs out. It names {@code States.Timeout} for* both {@code TimeoutSeconds} and {@code HeartbeatSeconds}, and carries no cause.*/- private void addTaskTimedOutEvent(List<HistoryEvent> history, AtomicLong producedEventCount,- TaskEventProfile profile) {+ private void addTaskTimedOutEvent(HistoryChain chain, TaskEventProfile profile) {var details = new LinkedHashMap<String, Object>();if ("Task".equals(profile.prefix())) {details.put("resourceType", profile.resourceType());details.put("resource", profile.resource());}details.put("error", "States.Timeout");- publishEvent(history, producedEventCount, profile.prefix() + "TimedOut", details);+ chain.publish(profile.prefix() + "TimedOut", details);}- private void failExecution(Execution exec, List<HistoryEvent> history, FailStateException e) {- failExecution(exec, history, e.error != null ? e.error : "States.Runtime", e.cause);+ private void failExecution(Execution exec, HistoryChain chain, FailStateException e) {+ failExecution(exec, chain, e.error != null ? e.error : "States.Runtime", e.cause);}/**@@ -4084,7 +4104,7 @@ public class AslExecutor {* ExecutionFailed event leave the key out rather than reporting it empty. Only a task that ran* out of its TimeoutSeconds or HeartbeatSeconds budget arrives here without one.*/- private void failExecution(Execution exec, List<HistoryEvent> history, String error, String cause) {+ private void failExecution(Execution exec, HistoryChain chain, String error, String cause) {synchronized (exec) {if (abortedByCaller(exec)) {return;@@ -4094,12 +4114,26 @@ public class AslExecutor {exec.setStopDate(System.currentTimeMillis() / 1000.0);exec.setStatus("FAILED");}+ chain.end("ExecutionFailed", failureDetails(error, cause));+ }++ private static void publishMapRunFailedEvent(HistoryChain chain, FailStateException failure) {+ if (!failure.isRuntimeError()) {+ chain.publish("MapRunFailed", failureDetails(failure));+ }+ }++ private static Map<String, Object> failureDetails(FailStateException failure) {+ return failureDetails(failure.error, failure.cause);+ }++ private static Map<String, Object> failureDetails(String error, String cause) {var details = new LinkedHashMap<String, Object>();details.put("error", error);if (cause != null) {details.put("cause", cause);}- publishTerminalEvent(history, "ExecutionFailed", details);+ return details;}/**@@ -4109,7 +4143,7 @@ public class AslExecutor {* it cut. The event is appended rather than published, because it is what ends the execution* and the history-event limit leaves the last slot free for exactly that.*/- private void timeOutExecution(Execution exec, List<HistoryEvent> history) {+ private void timeOutExecution(Execution exec, HistoryChain chain) {synchronized (exec) {if (abortedByCaller(exec)) {return;@@ -4117,7 +4151,7 @@ public class AslExecutor {exec.setStopDate(System.currentTimeMillis() / 1000.0);exec.setStatus("TIMED_OUT");}- appendEvent(history, "ExecutionTimedOut", 0L, Map.of("error", "States.Timeout"));+ chain.end("ExecutionTimedOut", 0L, Map.of("error", "States.Timeout"));}/**@@ -4127,7 +4161,7 @@ public class AslExecutor {* live Execution, so a client polling for SUCCEEDED between setStatus and setOutput would read* a terminal execution with a null output, which real Step Functions never returns.*/- private void succeedExecution(Execution exec, List<HistoryEvent> history, JsonNode output) {+ private void succeedExecution(Execution exec, HistoryChain chain, JsonNode output) {synchronized (exec) {if (abortedByCaller(exec)) {return;@@ -4136,7 +4170,7 @@ public class AslExecutor {exec.setStopDate(System.currentTimeMillis() / 1000.0);exec.setStatus("SUCCEEDED");}- publishTerminalEvent(history, "ExecutionSucceeded",+ chain.end("ExecutionSucceeded",Map.of("output", output.toString(), "outputDetails", Map.of("truncated", false)));}@@ -4255,13 +4289,60 @@ public class AslExecutor {}static class FailStateException extends RuntimeException {+ static final String ATTRIBUTION_PREFIX = "An error occurred while executing the state '%s' (entered at the event id #%d). ";+final String error;final String cause;+ /** The field of the failed JSONata expression, as the cause names it. */+ final String location;+ private final boolean causeFinal;FailStateException(String error, String cause) {+ this(error, cause, false);+ }++ FailStateException(String error, String cause, boolean causeFinal) {+ this(error, cause, causeFinal, null);+ }++ FailStateException(String error, String cause, String location) {+ this(error, cause, false, location);+ }++ /**+ * A Fail state's Cause and a cause a resource answered with are final. AWS prefixes every+ * other cause with the state name, once, at the innermost state.+ */+ private FailStateException(String error, String cause, boolean causeFinal, String location) {super(error + ": " + cause);this.error = error;this.cause = cause;+ this.causeFinal = causeFinal;+ this.location = location;+ }++ boolean hasFinalCause() {+ return causeFinal || cause == null;+ }++ /** States.Runtime skips Retry, Catch and the *StateFailed event on AWS. */+ boolean isRuntimeError() {+ return error == null || "States.Runtime".equals(error);+ }++ FailStateException attributedTo(String stateName, long enteredEventId) {+ if (hasFinalCause()) {+ return this;+ }+ return new FailStateException(error,+ ATTRIBUTION_PREFIX.formatted(stateName, enteredEventId) + cause, true, location);+ }++ FailStateException withFinalCause() {+ if (hasFinalCause()) {+ return this;+ }+ return new FailStateException(error, cause, true, location);}/**@@ -4274,6 +4355,17 @@ public class AslExecutor {}}+ private static final class IterationFailure extends RuntimeException {+ final int index;+ final FailStateException failure;++ IterationFailure(int index, FailStateException failure) {+ super(failure.getMessage(), failure, false, false);+ this.index = index;+ this.failure = failure;+ }+ }+/*** Thrown when a Task ran out of one of the two clocks bounding its wait for a task token. Both* report {@code States.Timeout} with no cause and emit a {@code TimedOut} history event; adiff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/HistoryChain.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/HistoryChain.javanew file mode 100644index 0000000000..8849960c65--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/HistoryChain.java@@ -0,0 +1,169 @@+package io.github.hectorvent.floci.services.stepfunctions;++import io.github.hectorvent.floci.services.stepfunctions.model.HistoryEvent;++import java.util.AbstractList;+import java.util.Collection;+import java.util.List;+import java.util.Map;+import java.util.concurrent.atomic.AtomicBoolean;+import java.util.concurrent.atomic.AtomicLong;++/**+ * One {@code previousEventId} chain of an execution's history: the top-level state loop, a Parallel+ * branch, or a Map iteration. All chains share the execution's history and event limit.+ */+final class HistoryChain {++ private final List<HistoryEvent> history;+ private final AtomicLong producedEventCount;+ private final AtomicBoolean ended;+ private final HistoryChain parent;+ private volatile boolean abandoned;+ private long lastEventId;+ private long tailEventId;++ private HistoryChain(List<HistoryEvent> history, AtomicLong producedEventCount, AtomicBoolean ended,+ HistoryChain parent, long lastEventId) {+ this.history = history;+ this.producedEventCount = producedEventCount;+ this.ended = ended;+ this.parent = parent;+ this.lastEventId = lastEventId;+ this.tailEventId = lastEventId;+ }++ /** Starts at 0, not at ExecutionStarted. AWS leaves the first state's Entered event unchained. */+ static HistoryChain of(List<HistoryEvent> history) {+ return new HistoryChain(history, new AtomicLong(history.size()), new AtomicBoolean(), null, 0L);+ }++ /** A Distributed Map item is a child execution. Its events are counted, not kept. */+ static HistoryChain ofChildExecution() {+ return new HistoryChain(new CountOnlyHistory(), new AtomicLong(), new AtomicBoolean(), null, 0L);+ }++ HistoryChain fork() {+ return new HistoryChain(history, producedEventCount, ended, this, lastEventId);+ }++ boolean isBranch() {+ return parent != null;+ }++ long lastEventId() {+ return lastEventId;+ }++ void continueFrom(long eventId) {+ lastEventId = eventId;+ tailEventId = eventId;+ }++ void continueAfter(Collection<HistoryChain> chains) {+ var last = lastEventId;+ for (HistoryChain chain : chains) {+ last = Math.max(last, chain.lastEventId);+ }+ continueFrom(last);+ }++ /** AWS records nothing of a branch it cut. */+ void abandon() {+ abandoned = true;+ }++ private boolean isAbandoned() {+ for (var chain = this; chain != null; chain = chain.parent) {+ if (chain.abandoned) {+ return true;+ }+ }+ return false;+ }++ /** Returns the event id, or 0 once the execution has ended. */+ long publish(String type, Map<String, Object> details) {+ if (isAbandoned()) {+ return 0L;+ }+ long id = append(type, lastEventId, details, true);+ if (id > 0) {+ lastEventId = id;+ tailEventId = id;+ }+ return id;+ }++ /**+ * The event does not become the chain's tail. AWS records {@code *StateSucceeded},+ * {@code MapRunSucceeded}, {@code MapIterationFailed} and {@code TaskStateAborted} this way.+ */+ void publishAside(String type, Map<String, Object> details) {+ if (isAbandoned()) {+ return;+ }+ long id = append(type, tailEventId, details, true);+ if (id > 0) {+ tailEventId = id;+ }+ }++ /** The terminal event does not count towards the limit, and nothing is recorded after it. */+ void end(String type, Map<String, Object> details) {+ end(type, tailEventId, details);+ }++ /** ExecutionTimedOut points at 0. */+ void end(String type, long previousEventId, Map<String, Object> details) {+ synchronized (history) {+ append(type, previousEventId, details, false);+ ended.set(true);+ }+ }++ /**+ * Synchronized on the history because StopExecution appends the terminal event from another+ * thread. An event counts towards the limit only once the history is known to take it.+ */+ private long append(String type, long previousEventId, Map<String, Object> details, boolean counted) {+ synchronized (history) {+ if (ended.get()) {+ return 0L;+ }+ if (counted) {+ AslExecutor.countTowardsHistoryEventLimit(producedEventCount);+ }+ var event = new HistoryEvent();+ event.setId(history.size() + 1L);+ event.setPreviousEventId(previousEventId);+ event.setType(type);+ event.setDetails(details);+ if (!history.add(event)) {+ ended.set(true);+ return 0L;+ }+ return event.getId();+ }+ }++ private static final class CountOnlyHistory extends AbstractList<HistoryEvent> {+ private int size;++ @Override+ public boolean add(HistoryEvent event) {+ size++;+ return true;+ }++ @Override+ public HistoryEvent get(int index) {+ throw new IndexOutOfBoundsException(index);+ }++ @Override+ public int size() {+ return size;+ }+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/JsonataEvaluator.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/JsonataEvaluator.javaindex 63f84d5544..b4f59d9ae7 100644--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/JsonataEvaluator.java+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/JsonataEvaluator.java@@ -477,12 +477,13 @@ public class JsonataEvaluator {} catch (QueryEvaluationFailure failure) {throw new FailStateException(failure.error,"The JSONata expression '" + expr + "' specified for the field '" + field- + "' threw an error during evaluation" + failure.sentenceSeparator + failure.cause);+ + "' threw an error during evaluation" + failure.sentenceSeparator + failure.cause,+ field);}if (value.isMissingNode()) {throw new FailStateException("States.QueryEvaluationError","The JSONata expression '" + expr + "' specified for the field '" + field- + "' returned nothing (undefined).");+ + "' returned nothing (undefined).", field);}return value;}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.javaindex fe51d8bd4c..11b57b8faf 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@@ -16,6 +16,7 @@ import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import jakarta.ws.rs.core.Response;+import java.util.ArrayList;import java.util.HashMap;import java.util.LinkedHashMap;import java.util.List;@@ -301,37 +302,38 @@ public class StepFunctionsJsonHandler {* {@code arn:aws:states:::aws-sdk:sfn:describeMapRun} Task integration renders the same node in* PascalCase, so this is the one place the response is described.*- * <p>A retained run is one whose every item succeeded, because a Map fails on the first item- * that fails. That fixes {@code status}, both zero tolerances and {@code redriveCount}:- * {@code redriveDate} is absent until a run is redriven, and no run here ever is.+ * <p>Both tolerances and {@code redriveCount} are zero because Floci implements neither, and+ * {@code redriveDate} is absent until a run is redriven, which no run here ever is.*/static ObjectNode describeMapRunResponse(ObjectMapper objectMapper, MapRun mapRun) {ObjectNode response = objectMapper.createObjectNode();response.put("mapRunArn", mapRun.getMapRunArn());response.put("executionArn", mapRun.getExecutionArn());- response.put("status", "SUCCEEDED");+ response.put("status", mapRun.getStatus());response.put("startDate", mapRun.getStartDate());response.put("stopDate", mapRun.getStopDate());response.put("maxConcurrency", mapRun.getMaxConcurrency());response.put("toleratedFailurePercentage", 0.0);response.put("toleratedFailureCount", 0);- putMapRunCounts(response.putObject("itemCounts"), mapRun.getItemCount());+ putMapRunCounts(response.putObject("itemCounts"), mapRun);// One child execution per item: ItemBatcher is not applied, so no execution covers a batch.- putMapRunCounts(response.putObject("executionCounts"), mapRun.getItemCount());+ putMapRunCounts(response.putObject("executionCounts"), mapRun);response.put("redriveCount", 0);return response;}- /** The ten counters of a run whose every item succeeded and was written to the result set. */- private static void putMapRunCounts(ObjectNode counts, int items) {+ /** A failed item's result counts as written, as on AWS. */+ private static void putMapRunCounts(ObjectNode counts, MapRun mapRun) {+ var succeeded = mapRun.getSucceededCount();+ var failed = mapRun.getFailedCount();counts.put("pending", 0);counts.put("running", 0);- counts.put("succeeded", items);- counts.put("failed", 0);+ counts.put("succeeded", succeeded);+ counts.put("failed", failed);counts.put("timedOut", 0);- counts.put("aborted", 0);- counts.put("total", items);- counts.put("resultsWritten", items);+ counts.put("aborted", mapRun.getItemCount() - succeeded - failed);+ counts.put("total", mapRun.getItemCount());+ counts.put("resultsWritten", succeeded + failed);counts.put("failuresNotRedrivable", 0);counts.put("pendingRedrive", 0);}@@ -367,7 +369,12 @@ public class StepFunctionsJsonHandler {var arn = request.path("executionArn").asText();var includeExecutionData = request.path("includeExecutionData").asBoolean(true);- List<HistoryEvent> events = service.getExecutionHistory(arn);+ var live = service.getExecutionHistory(arn);+ List<HistoryEvent> events;+ // Branch and iteration threads append under the history's own monitor while a client reads.+ synchronized (live) {+ events = new ArrayList<>(live);+ }ObjectNode response = objectMapper.createObjectNode();ArrayNode array = response.putArray("events");for (HistoryEvent e : events) {diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/MapRun.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/MapRun.javaindex 9dc3e54cae..a45a5e8bd2 100644--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/MapRun.java+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/MapRun.java@@ -4,23 +4,24 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties;import io.quarkus.runtime.annotations.RegisterForReflection;/**- * A distributed Map run that has finished, keyed by its Map run ARN.- *- * <p>A Map fails on the first item that fails, so a run only reaches the {@code ResultWriter} that- * mints its ARN once every item has succeeded. That is why a run carries a single {@code itemCount}- * rather than the ten counters {@code DescribeMapRun} reports: the other nine are zero, and- * {@code succeeded}, {@code total} and {@code resultsWritten} are all this count.+ * A distributed Map run that has finished, keyed by its Map run ARN. It is kept on success and on+ * failure, so the {@code mapRunArn} of a {@code MapRunStarted} event resolves through+ * {@code DescribeMapRun}. A Map cancels the remaining items on the first failure, so a failed run+ * reports those as aborted.*/@RegisterForReflection@JsonIgnoreProperties(ignoreUnknown = true)public class MapRun {private String mapRunArn;+ private String status;/** The execution of the state machine whose Map state opened this run. */private String executionArn;private double startDate;private double stopDate;- /** Items processed by the run, which is also the number of child executions it ran. */+ /** Items of the run, which is also the number of child executions it ran. */private int itemCount;+ private int succeededCount;+ private int failedCount;/** The Map's declared MaxConcurrency, with an unbounded Map held as Integer.MAX_VALUE. */private int maxConcurrency;@@ -38,6 +39,13 @@ public class MapRun {public int getItemCount() { return itemCount; }public void setItemCount(int itemCount) { this.itemCount = itemCount; }+ /** A run recorded before the status was kept is one whose every item succeeded. */+ public String getStatus() { return status == null ? "SUCCEEDED" : status; }+ public void setStatus(String status) { this.status = status; }+ public int getSucceededCount() { return status == null ? itemCount : succeededCount; }+ public void setSucceededCount(int succeededCount) { this.succeededCount = succeededCount; }+ public int getFailedCount() { return failedCount; }+ public void setFailedCount(int failedCount) { this.failedCount = failedCount; }public int getMaxConcurrency() { return maxConcurrency; }public void setMaxConcurrency(int maxConcurrency) { this.maxConcurrency = maxConcurrency; }diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorBranchHistoryEventsTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorBranchHistoryEventsTest.javanew file mode 100644index 0000000000..471853b27d--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorBranchHistoryEventsTest.java@@ -0,0 +1,614 @@+package io.github.hectorvent.floci.services.stepfunctions;++import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.services.dynamodb.DynamoDbJsonHandler;+import io.github.hectorvent.floci.services.dynamodb.DynamoDbService;+import io.github.hectorvent.floci.services.lambda.LambdaExecutorService;+import io.github.hectorvent.floci.services.lambda.LambdaFunctionStore;+import io.github.hectorvent.floci.services.s3.S3Service;+import io.github.hectorvent.floci.services.sqs.SqsJsonHandler;+import io.github.hectorvent.floci.services.stepfunctions.model.Execution;+import io.github.hectorvent.floci.services.stepfunctions.model.HistoryEvent;+import io.github.hectorvent.floci.services.stepfunctions.model.MockedResponseStep;+import io.github.hectorvent.floci.services.stepfunctions.model.MockedTestCase;+import io.github.hectorvent.floci.services.stepfunctions.model.StateMachine;+import io.quarkus.test.junit.QuarkusTest;+import io.vertx.mutiny.core.Vertx;+import jakarta.enterprise.inject.Instance;+import jakarta.inject.Inject;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.util.ArrayList;+import java.util.List;+import java.util.Map;+import java.util.Set;+import java.util.stream.Collectors;++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;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.when;++/**+ * The history events of the states inside a Parallel branch or a Map iteration, and the cause a+ * failure inside one reports. Every shape here was read off real Step Functions in us-east-1 for+ * issue #2868: the event families a Parallel and a Map publish around their branches, how+ * {@code previousEventId} chains a branch's events to each other and to the state that started+ * them, which failures leave a {@code *StateFailed} event, and the+ * {@code An error occurred while executing the state ...} prefix a cause carries.+ *+ * <p>Branches run concurrently, so the order in which their events interleave is not asserted.+ * What is asserted is what a reader needs to follow each branch: the chain.+ */+@QuarkusTest+class AslExecutorBranchHistoryEventsTest {++ private static final String REGION = "us-east-1";+ private static final String ACCOUNT = "000000000000";++ private final ObjectMapper objectMapper = new ObjectMapper();+ private AslExecutor executor;++ @Inject+ Vertx vertx;++ @BeforeEach+ void setUp() {+ Instance<StepFunctionsService> sfnService = mock(Instance.class);+ when(sfnService.get()).thenReturn(mock(StepFunctionsService.class));+ executor = new AslExecutor(+ mock(LambdaExecutorService.class),+ mock(LambdaFunctionStore.class),+ mock(DynamoDbService.class),+ mock(DynamoDbJsonHandler.class),+ mock(SqsJsonHandler.class),+ mock(io.github.hectorvent.floci.services.cloudformation.CloudFormationQueryHandler.class),+ mock(io.github.hectorvent.floci.services.ec2.Ec2Service.class),+ mock(S3Service.class),+ mock(io.github.hectorvent.floci.services.ecs.EcsService.class),+ mock(io.github.hectorvent.floci.services.ecs.EcsJsonHandler.class),+ mock(io.github.hectorvent.floci.services.eventbridge.EventBridgeHandler.class),+ mock(io.github.hectorvent.floci.services.scheduler.SchedulerService.class),+ mock(io.github.hectorvent.floci.services.scheduler.SchedulerController.class),+ objectMapper,+ new JsonataEvaluator(objectMapper),+ sfnService, mock(EmulatorConfig.class), vertx,+ mock(io.github.hectorvent.floci.core.common.CustomResourceLiveness.class));+ }++ @Test+ void parallelBranchesPublishTheirStatesOnChainsOfTheirOwn() {+ var history = run("""+ {"StartAt":"P","States":{+ "P":{"Type":"Parallel","Branches":[+ {"StartAt":"A1","States":{"A1":{"Type":"Pass","Next":"A2"},"A2":{"Type":"Pass","End":true}}},+ {"StartAt":"B1","States":{"B1":{"Type":"Pass","Next":"B2"},"B2":{"Type":"Pass","End":true}}}+ ],"Next":"After"},+ "After":{"Type":"Pass","End":true}}}+ """, "{\"x\":\"a\"}");++ assertEquals("SUCCEEDED", status(history), typesOf(history).toString());+ assertEquals(16, history.size(), typesOf(history).toString());+ assertIdsAreConsecutive(history);+ assertEquals(List.of("ExecutionStarted", "ParallelStateEntered", "ParallelStateStarted"),+ typesOf(history.subList(0, 3)));+ assertEquals(List.of("ParallelStateSucceeded", "ParallelStateExited", "PassStateEntered",+ "PassStateExited", "ExecutionSucceeded"),+ typesOf(history.subList(11, 16)));++ var started = eventOfType(history, "ParallelStateStarted");+ assertEquals(2L, started.getPreviousEventId());+ assertNull(started.getDetails());+ // Each branch's first state starts from ParallelStateStarted, and the branch chains on from+ // there: A1 exited points at A1 entered, A2 entered at A1 exited.+ for (String branch : List.of("A", "B")) {+ var firstEntered = stateEvent(history, "PassStateEntered", branch + "1");+ var firstExited = stateEvent(history, "PassStateExited", branch + "1");+ var secondEntered = stateEvent(history, "PassStateEntered", branch + "2");+ var secondExited = stateEvent(history, "PassStateExited", branch + "2");+ assertEquals(started.getId(), firstEntered.getPreviousEventId());+ assertEquals(firstEntered.getId(), firstExited.getPreviousEventId());+ assertEquals(firstExited.getId(), secondEntered.getPreviousEventId());+ assertEquals(secondEntered.getId(), secondExited.getPreviousEventId());+ }+ // The Parallel continues from the last event a branch published. ParallelStateSucceeded+ // points at it and is passed by: ParallelStateExited points at it too.+ long lastBranchEvent = history.get(10).getId();+ var succeeded = eventOfType(history, "ParallelStateSucceeded");+ var exited = eventOfType(history, "ParallelStateExited");+ assertEquals(lastBranchEvent, succeeded.getPreviousEventId());+ assertNull(succeeded.getDetails());+ assertEquals(lastBranchEvent, exited.getPreviousEventId());+ assertEquals("[{\"x\":\"a\"},{\"x\":\"a\"}]", exited.getDetails().get("output"));+ assertEquals(exited.getId(), stateEvent(history, "PassStateEntered", "After").getPreviousEventId());+ }++ /** The shape reported in issue #2868, with the branch that never fails left out. */+ @Test+ void runtimeErrorInABranchNamesTheBranchStateAndItsEnteredEvent() {+ var history = run("""+ {"StartAt":"P","States":{+ "P":{"Type":"Parallel","Branches":[+ {"StartAt":"Fast","States":{"Fast":{"Type":"Pass","Parameters":{"m.$":"$.nope"},"End":true}}}+ ],"End":true}}}+ """, "{\"x\":\"a\"}");++ assertEquals(List.of("ExecutionStarted", "ParallelStateEntered", "ParallelStateStarted",+ "PassStateEntered", "ExecutionFailed"), typesOf(history));+ assertEquals(List.of(0L, 0L, 2L, 3L, 4L), previousEventIdsOf(history));+ var failed = history.get(4);+ assertEquals("States.Runtime", failed.getDetails().get("error"));+ assertEquals("An error occurred while executing the state 'Fast' (entered at the event id #4). "+ + "The JSONPath '$.nope' specified for the field 'm.$' could not be found in the input '{\"x\":\"a\"}'",+ failed.getDetails().get("cause"));+ }++ @Test+ void failStateInABranchPassesItsCauseThroughAndLeavesAParallelStateFailedEvent() {+ var history = run("""+ {"StartAt":"P","States":{+ "P":{"Type":"Parallel","Branches":[+ {"StartAt":"Boom","States":{"Boom":{"Type":"Fail","Error":"MyError","Cause":"my cause"}}}+ ],"End":true}}}+ """, "{\"x\":\"a\"}");++ assertEquals(List.of("ExecutionStarted", "ParallelStateEntered", "ParallelStateStarted",+ "FailStateEntered", "ParallelStateFailed", "ExecutionFailed"), typesOf(history));+ assertEquals(List.of(0L, 0L, 2L, 3L, 4L, 5L), previousEventIdsOf(history));+ assertNull(history.get(4).getDetails());+ assertEquals(Map.of("error", "MyError", "cause", "my cause"), history.get(5).getDetails());+ }++ @Test+ void caughtBranchFailureExitsTheParallelWithTheErrorOutput() {+ var history = run("""+ {"QueryLanguage":"JSONata","StartAt":"P","States":{+ "P":{"Type":"Parallel","Branches":[+ {"StartAt":"Undef","States":{"Undef":{"Type":"Pass","Output":{"v":"{% $states.input.missing %}"},"End":true}}}+ ],"Catch":[{"ErrorEquals":["States.ALL"],"Next":"Handled"}],"End":true},+ "Handled":{"Type":"Pass","End":true}}}+ """, "{\"x\":\"a\"}");++ assertEquals(List.of("ExecutionStarted", "ParallelStateEntered", "ParallelStateStarted",+ "PassStateEntered", "EvaluationFailed", "ParallelStateFailed", "ParallelStateExited",+ "PassStateEntered", "PassStateExited", "ExecutionSucceeded"), typesOf(history));+ assertEquals(List.of(0L, 0L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L), previousEventIdsOf(history));+ var cause = "An error occurred while executing the state 'Undef' (entered at the event id #4). "+ + "The JSONata expression '$states.input.missing' specified for the field 'Output/v' "+ + "returned nothing (undefined).";+ assertEquals(Map.of("error", "States.QueryEvaluationError", "cause", cause, "location", "Output/v",+ "state", "Undef"), history.get(4).getDetails());+ var errorOutput = "{\"Error\":\"States.QueryEvaluationError\",\"Cause\":\"" + cause.replace("\"", "\\\"") + "\"}";+ assertEquals(errorOutput, history.get(6).getDetails().get("output"));+ assertEquals(errorOutput, history.get(9).getDetails().get("output"));+ }++ @Test+ void retriedParallelStartsAgainAndFailsOnceItsRetryIsUsedUp() {+ var history = run("""+ {"StartAt":"P","States":{+ "P":{"Type":"Parallel","Branches":[+ {"StartAt":"Boom","States":{"Boom":{"Type":"Fail","Error":"MyError","Cause":"my cause"}}}+ ],"Retry":[{"ErrorEquals":["States.ALL"],"MaxAttempts":1,"IntervalSeconds":0}],"End":true}}}+ """, "{\"x\":\"a\"}");++ assertEquals(List.of("ExecutionStarted", "ParallelStateEntered", "ParallelStateStarted",+ "FailStateEntered", "ParallelStateStarted", "FailStateEntered", "ParallelStateFailed",+ "ExecutionFailed"), typesOf(history));+ assertEquals(List.of(0L, 0L, 2L, 3L, 4L, 5L, 6L, 7L), previousEventIdsOf(history));+ }++ @Test+ void parallelOwnFailureIsAttributedToTheParallelAfterItsBranchesSucceeded() {+ var history = run("""+ {"StartAt":"P","States":{+ "P":{"Type":"Parallel","Branches":[+ {"StartAt":"Ok","States":{"Ok":{"Type":"Pass","End":true}}}+ ],"ResultSelector":{"m.$":"$.nope"},"End":true}}}+ """, "{\"x\":\"a\"}");++ assertEquals(List.of("ExecutionStarted", "ParallelStateEntered", "ParallelStateStarted",+ "PassStateEntered", "PassStateExited", "ParallelStateSucceeded", "ExecutionFailed"),+ typesOf(history));+ assertEquals(List.of(0L, 0L, 2L, 3L, 4L, 5L, 6L), previousEventIdsOf(history));+ assertEquals("An error occurred while executing the state 'P' (entered at the event id #2). "+ + "The JSONPath '$.nope' specified for the field 'm.$' could not be found in the input '[{\"x\":\"a\"}]'",+ history.get(6).getDetails().get("cause"));+ }++ @Test+ void taskFailureEndingABranchIsRecordedAsAbortedAndPassesItsCauseThrough() {+ var mocks = new MockedTestCase("branch-history-test", "Case", Map.of("Send", List.of(+ new MockedResponseStep(0, 0, null, "SQS.QueueDoesNotExistException", "The specified queue does not exist."))));+ var history = run("""+ {"StartAt":"P","States":{+ "P":{"Type":"Parallel","Branches":[+ {"StartAt":"Send","States":{"Send":{"Type":"Task","Resource":"arn:aws:states:::sqs:sendMessage",+ "Parameters":{"QueueUrl":"https://sqs.us-east-1.amazonaws.com/000000000000/missing","MessageBody":"hi"},"End":true}}}+ ],"Catch":[{"ErrorEquals":["States.ALL"],"Next":"Handled"}],"End":true},+ "Handled":{"Type":"Pass","End":true}}}+ """, "{\"x\":\"a\"}", mocks);++ assertEquals(List.of("ExecutionStarted", "ParallelStateEntered", "ParallelStateStarted",+ "TaskStateEntered", "TaskScheduled", "TaskStarted", "TaskFailed", "TaskStateAborted",+ "ParallelStateFailed", "ParallelStateExited", "PassStateEntered", "PassStateExited",+ "ExecutionSucceeded"), typesOf(history));+ assertEquals(List.of(0L, 0L, 2L, 3L, 4L, 5L, 6L, 7L, 7L, 9L, 10L, 11L, 12L), previousEventIdsOf(history));+ assertNull(history.get(7).getDetails());+ assertEquals("{\"Error\":\"SQS.QueueDoesNotExistException\",\"Cause\":\"The specified queue does not exist.\"}",+ history.get(9).getDetails().get("output"));+ }++ @Test+ void mapIterationsPublishTheirStatesUnderIterationEvents() {+ var history = run("""+ {"StartAt":"M","States":{+ "M":{"Type":"Map","ItemsPath":"$.items","ItemProcessor":{"ProcessorConfig":{"Mode":"INLINE"},+ "StartAt":"I1","States":{"I1":{"Type":"Pass","Next":"I2"},"I2":{"Type":"Pass","End":true}}},+ "Next":"After"},+ "After":{"Type":"Pass","End":true}}}+ """, "{\"items\":[1,2]}");++ assertEquals("SUCCEEDED", status(history), typesOf(history).toString());+ assertEquals(20, history.size(), typesOf(history).toString());+ assertIdsAreConsecutive(history);+ assertEquals(List.of("ExecutionStarted", "MapStateEntered", "MapStateStarted"), typesOf(history.subList(0, 3)));+ var started = history.get(2);+ assertEquals(2L, started.getPreviousEventId());+ assertEquals(Map.of("length", 2), started.getDetails());++ for (int index = 0; index < 2; index++) {+ var iterationStarted = iterationEvent(history, "MapIterationStarted", index);+ var iterationSucceeded = iterationEvent(history, "MapIterationSucceeded", index);+ var input = String.valueOf(index + 1);+ var firstEntered = stateEventWithInput(history, "PassStateEntered", "I1", input);+ var firstExited = stateEventWithOutput(history, "PassStateExited", "I1", input);+ var secondEntered = stateEventWithInput(history, "PassStateEntered", "I2", input);+ var secondExited = stateEventWithOutput(history, "PassStateExited", "I2", input);+ assertEquals(Map.of("name", "M", "index", index), iterationStarted.getDetails());+ assertEquals(started.getId(), iterationStarted.getPreviousEventId());+ assertEquals(iterationStarted.getId(), firstEntered.getPreviousEventId());+ assertEquals(firstEntered.getId(), firstExited.getPreviousEventId());+ assertEquals(firstExited.getId(), secondEntered.getPreviousEventId());+ assertEquals(secondEntered.getId(), secondExited.getPreviousEventId());+ assertEquals(secondExited.getId(), iterationSucceeded.getPreviousEventId());+ assertEquals(Map.of("name", "M", "index", index), iterationSucceeded.getDetails());+ }+ assertEquals(List.of("MapStateSucceeded", "MapStateExited", "PassStateEntered", "PassStateExited",+ "ExecutionSucceeded"), typesOf(history.subList(15, 20)));+ long lastIterationEvent = history.get(14).getId();+ assertEquals("MapIterationSucceeded", history.get(14).getType());+ assertEquals(lastIterationEvent, history.get(15).getPreviousEventId());+ assertNull(history.get(15).getDetails());+ assertEquals(lastIterationEvent, history.get(16).getPreviousEventId());+ assertEquals("[1,2]", history.get(16).getDetails().get("output"));+ }++ @Test+ void mapOverNoItemsExitsFromItsStartedEvent() {+ var history = run("""+ {"StartAt":"M","States":{+ "M":{"Type":"Map","ItemsPath":"$.items",+ "ItemProcessor":{"StartAt":"I","States":{"I":{"Type":"Pass","End":true}}},"End":true}}}+ """, "{\"items\":[]}");++ assertEquals(List.of("ExecutionStarted", "MapStateEntered", "MapStateStarted", "MapStateSucceeded",+ "MapStateExited", "ExecutionSucceeded"), typesOf(history));+ assertEquals(List.of(0L, 0L, 2L, 3L, 3L, 5L), previousEventIdsOf(history));+ }++ @Test+ void runtimeErrorInABranchTaskLeavesNoAbortedEvent() {+ var history = run("""+ {"StartAt":"P","States":{+ "P":{"Type":"Parallel","Branches":[+ {"StartAt":"Send","States":{"Send":{"Type":"Task","Resource":"arn:aws:states:::sqs:sendMessage",+ "Parameters":{"QueueUrl.$":"$.nope","MessageBody":"hi"},"End":true}}}+ ],"End":true}}}+ """, "{\"x\":\"a\"}");++ assertEquals(List.of("ExecutionStarted", "ParallelStateEntered", "ParallelStateStarted",+ "TaskStateEntered", "ExecutionFailed"), typesOf(history));+ assertEquals(List.of(0L, 0L, 2L, 3L, 4L), previousEventIdsOf(history));+ }++ @Test+ void mapIterationFailureLeavesIterationAndStateFailedEventsBehind() {+ var history = run("""+ {"QueryLanguage":"JSONata","StartAt":"M","States":{+ "M":{"Type":"Map","Items":"{% $states.input.items %}","MaxConcurrency":1,+ "ItemProcessor":{"ProcessorConfig":{"Mode":"INLINE"},"StartAt":"Undef",+ "States":{"Undef":{"Type":"Pass","Output":{"v":"{% $states.input.missing %}"},"End":true}}},+ "End":true}}}+ """, "{\"items\":[1,2]}");++ assertEquals(List.of("ExecutionStarted", "MapStateEntered", "MapStateStarted", "MapIterationStarted",+ "PassStateEntered", "EvaluationFailed", "MapIterationFailed", "MapStateFailed", "ExecutionFailed"),+ typesOf(history));+ // MapIterationFailed points at the iteration's last event and is passed by: MapStateFailed+ // points at that same event.+ assertEquals(List.of(0L, 0L, 2L, 3L, 4L, 5L, 6L, 6L, 8L), previousEventIdsOf(history));+ var cause = "An error occurred while executing the state 'Undef' (entered at the event id #5). "+ + "The JSONata expression '$states.input.missing' specified for the field 'Output/v' "+ + "returned nothing (undefined).";+ assertEquals("Undef", history.get(5).getDetails().get("state"));+ assertEquals(Map.of("name", "M", "index", 0), history.get(6).getDetails());+ assertNull(history.get(7).getDetails());+ assertEquals(cause, history.get(8).getDetails().get("cause"));+ }++ @Test+ void runtimeErrorInAMapIterationLeavesNoFailedEvents() {+ var history = run("""+ {"StartAt":"M","States":{+ "M":{"Type":"Map","ItemsPath":"$.items","MaxConcurrency":1,+ "ItemProcessor":{"ProcessorConfig":{"Mode":"INLINE"},"StartAt":"Fast",+ "States":{"Fast":{"Type":"Pass","Parameters":{"m.$":"$.nope"},"End":true}}},+ "End":true}}}+ """, "{\"items\":[1,2]}");++ assertEquals(List.of("ExecutionStarted", "MapStateEntered", "MapStateStarted", "MapIterationStarted",+ "PassStateEntered", "ExecutionFailed"), typesOf(history));+ assertEquals(List.of(0L, 0L, 2L, 3L, 4L, 5L), previousEventIdsOf(history));+ assertEquals("An error occurred while executing the state 'Fast' (entered at the event id #5). "+ + "The JSONPath '$.nope' specified for the field 'm.$' could not be found in the input '1'",+ history.get(5).getDetails().get("cause"));+ }++ @Test+ void distributedMapNamesItsRunAndPublishesNoItemEvents() {+ var history = run("""+ {"StartAt":"D","States":{+ "D":{"Type":"Map","ItemsPath":"$.items","ItemProcessor":{+ "ProcessorConfig":{"Mode":"DISTRIBUTED","ExecutionType":"STANDARD"},+ "StartAt":"I1","States":{"I1":{"Type":"Pass","End":true}}},+ "End":true}}}+ """, "{\"items\":[1,2]}");++ assertEquals(List.of("ExecutionStarted", "MapStateEntered", "MapStateStarted", "MapRunStarted",+ "MapRunSucceeded", "MapStateSucceeded", "MapStateExited", "ExecutionSucceeded"), typesOf(history));+ // The parent chain stays at MapRunStarted: MapStateExited points at it, past both Succeeded events.+ assertEquals(List.of(0L, 0L, 2L, 3L, 4L, 5L, 4L, 7L), previousEventIdsOf(history));+ var mapRunArn = (String) history.get(3).getDetails().get("mapRunArn");+ assertTrue(mapRunArn.startsWith("arn:aws:states:us-east-1:000000000000:mapRun:branch-history-test/"), mapRunArn);+ assertEquals("[1,2]", history.get(6).getDetails().get("output"));+ }++ @Test+ void nestedMapInsideAParallelBranchChainsToTheBranch() {+ var history = run("""+ {"StartAt":"P","States":{+ "P":{"Type":"Parallel","Branches":[+ {"StartAt":"M","States":{"M":{"Type":"Map","ItemsPath":"$.items","ItemProcessor":{+ "ProcessorConfig":{"Mode":"INLINE"},"StartAt":"I1","States":{"I1":{"Type":"Pass","End":true}}},+ "End":true}}},+ {"StartAt":"B1","States":{"B1":{"Type":"Pass","End":true}}}+ ],"End":true}}}+ """, "{\"items\":[1,2]}");++ assertEquals("SUCCEEDED", status(history), typesOf(history).toString());+ assertEquals(20, history.size(), typesOf(history).toString());+ assertIdsAreConsecutive(history);+ var parallelStarted = eventOfType(history, "ParallelStateStarted");+ var mapEntered = eventOfType(history, "MapStateEntered");+ var mapStarted = eventOfType(history, "MapStateStarted");+ var mapSucceeded = eventOfType(history, "MapStateSucceeded");+ var mapExited = eventOfType(history, "MapStateExited");+ assertEquals(parallelStarted.getId(), mapEntered.getPreviousEventId());+ assertEquals(parallelStarted.getId(), stateEvent(history, "PassStateEntered", "B1").getPreviousEventId());+ assertEquals(mapEntered.getId(), mapStarted.getPreviousEventId());+ for (int index = 0; index < 2; index++) {+ assertEquals(mapStarted.getId(), iterationEvent(history, "MapIterationStarted", index).getPreviousEventId());+ }+ long lastIterationEvent = Math.max(iterationEvent(history, "MapIterationSucceeded", 0).getId(),+ iterationEvent(history, "MapIterationSucceeded", 1).getId());+ assertEquals(lastIterationEvent, mapSucceeded.getPreviousEventId());+ assertEquals(lastIterationEvent, mapExited.getPreviousEventId());+ var parallelExited = eventOfType(history, "ParallelStateExited");+ long lastBranchEvent = Math.max(mapExited.getId(), stateEvent(history, "PassStateExited", "B1").getId());+ assertEquals(lastBranchEvent, eventOfType(history, "ParallelStateSucceeded").getPreviousEventId());+ assertEquals(lastBranchEvent, parallelExited.getPreviousEventId());+ assertEquals("ExecutionSucceeded", history.get(19).getType());+ }++ @Test+ void jsonataFailureRecordsAnEvaluationFailedEventPerAttempt() {+ var history = run("""+ {"QueryLanguage":"JSONata","StartAt":"Send","States":{+ "Send":{"Type":"Task","Resource":"arn:aws:states:::sqs:sendMessage",+ "Arguments":{"QueueUrl":"https://sqs.us-east-1.amazonaws.com/000000000000/q","MessageBody":"{% $states.input.missing %}"},+ "Retry":[{"ErrorEquals":["States.ALL"],"MaxAttempts":1,"IntervalSeconds":0}],"End":true}}}+ """, "{\"x\":\"a\"}");++ assertEquals(List.of("ExecutionStarted", "TaskStateEntered", "EvaluationFailed", "EvaluationFailed",+ "ExecutionFailed"), typesOf(history));+ assertEquals(List.of(0L, 0L, 2L, 3L, 4L), previousEventIdsOf(history));+ var cause = "An error occurred while executing the state 'Send' (entered at the event id #2). "+ + "The JSONata expression '$states.input.missing' specified for the field 'Arguments/MessageBody' "+ + "returned nothing (undefined).";+ var expected = Map.of("error", "States.QueryEvaluationError", "cause", cause,+ "location", "Arguments/MessageBody", "state", "Send");+ assertEquals(expected, history.get(2).getDetails());+ assertEquals(expected, history.get(3).getDetails());+ assertEquals(Map.of("error", "States.QueryEvaluationError", "cause", cause), history.get(4).getDetails());+ }++ @Test+ void mapItemsExpressionFailureIsRecordedBeforeTheMapStarts() {+ var history = run("""+ {"QueryLanguage":"JSONata","StartAt":"Fan","States":{+ "Fan":{"Type":"Map","Items":"{% $states.input.missing %}",+ "ItemProcessor":{"ProcessorConfig":{"Mode":"INLINE"},"StartAt":"I","States":{"I":{"Type":"Pass","End":true}}},+ "End":true}}}+ """, "{\"x\":\"a\"}");++ assertEquals(List.of("ExecutionStarted", "MapStateEntered", "EvaluationFailed", "MapStateFailed",+ "ExecutionFailed"), typesOf(history));+ assertEquals(List.of(0L, 0L, 2L, 3L, 4L), previousEventIdsOf(history));+ assertEquals("Items", history.get(2).getDetails().get("location"));+ }++ /**+ * A Catch clause whose own Output fails. AWS records the clause's EvaluationFailed from where the+ * state stood before its first Failed event, then fails the state a second time.+ */+ @Test+ void catchClauseOutputFailureIsRecordedFromBeforeTheStateFailedEvent() {+ var history = run("""+ {"QueryLanguage":"JSONata","StartAt":"P","States":{+ "P":{"Type":"Parallel","Branches":[+ {"StartAt":"Boom","States":{"Boom":{"Type":"Fail","Error":"MyError","Cause":"my cause"}}}+ ],"Catch":[{"ErrorEquals":["Other"],"Next":"Done"},+ {"ErrorEquals":["States.ALL"],"Output":{"v":"{% $states.input.missing %}"},"Next":"Done"}],+ "End":true},+ "Done":{"Type":"Pass","End":true}}}+ """, "{\"x\":\"a\"}");++ assertEquals(List.of("ExecutionStarted", "ParallelStateEntered", "ParallelStateStarted", "FailStateEntered",+ "ParallelStateFailed", "EvaluationFailed", "ParallelStateFailed", "ExecutionFailed"), typesOf(history));+ assertEquals(List.of(0L, 0L, 2L, 3L, 4L, 4L, 6L, 7L), previousEventIdsOf(history));+ var cause = "An error occurred while executing the state 'P' (entered at the event id #2). "+ + "The JSONata expression '$states.input.missing' specified for the field 'Catch[1]/Output/v' "+ + "returned nothing (undefined).";+ assertEquals(Map.of("error", "States.QueryEvaluationError", "cause", cause,+ "location", "Catch[1]/Output/v", "state", "P"), history.get(5).getDetails());+ assertEquals(Map.of("error", "States.QueryEvaluationError", "cause", cause), history.get(7).getDetails());+ }++ @Test+ void choiceWithNoMatchingRuleAndNoDefaultFailsAsAwsDoes() {+ var history = run("""+ {"StartAt":"C","States":{+ "C":{"Type":"Choice","Choices":[{"Variable":"$.x","StringEquals":"never","Next":"Done"}]},+ "Done":{"Type":"Pass","End":true}}}+ """, "{\"x\":\"a\"}");++ assertEquals(List.of("ExecutionStarted", "ChoiceStateEntered", "ExecutionFailed"), typesOf(history));+ assertEquals(Map.of("error", "States.Runtime",+ "cause", "An error occurred while executing the state 'C' (entered at the event id #2). "+ + "Failed to transition out of the state. The state does not point to a next state."),+ history.get(2).getDetails());+ }++ @Test+ void catchInsideABranchTakesItsNextEvenOnAnEndState() {+ var mocks = new MockedTestCase("branch-history-test", "Case", Map.of("Send", List.of(+ new MockedResponseStep(0, 0, null, "MyError", "boom"))));+ var history = run("""+ {"StartAt":"P","States":{+ "P":{"Type":"Parallel","Branches":[+ {"StartAt":"Send","States":{+ "Send":{"Type":"Task","Resource":"arn:aws:states:::sqs:sendMessage",+ "Parameters":{"QueueUrl":"https://sqs.us-east-1.amazonaws.com/000000000000/q","MessageBody":"hi"},+ "Catch":[{"ErrorEquals":["States.ALL"],"Next":"Recover"}],"End":true},+ "Recover":{"Type":"Pass","Result":{"recovered":true},"End":true}}}+ ],"End":true}}}+ """, "{}", mocks);++ assertEquals("SUCCEEDED", status(history), typesOf(history).toString());+ assertEquals("[{\"recovered\":true}]", eventOfType(history, "ExecutionSucceeded").getDetails().get("output"));+ assertFalse(typesOf(history).contains("TaskStateAborted"));+ }++ private static String status(List<HistoryEvent> history) {+ var last = history.get(history.size() - 1).getType();+ return switch (last) {+ case "ExecutionSucceeded" -> "SUCCEEDED";+ case "ExecutionFailed" -> "FAILED";+ default -> last;+ };+ }++ private static List<String> typesOf(List<HistoryEvent> history) {+ return history.stream().map(HistoryEvent::getType).toList();+ }++ private static List<Long> previousEventIdsOf(List<HistoryEvent> history) {+ return history.stream().map(HistoryEvent::getPreviousEventId).toList();+ }++ private static void assertIdsAreConsecutive(List<HistoryEvent> history) {+ for (var i = 0; i < history.size(); i++) {+ assertEquals(i + 1L, history.get(i).getId(), "unexpected id at index " + i);+ }+ var referenced = history.stream().map(HistoryEvent::getPreviousEventId).collect(Collectors.toSet());+ referenced.remove(0L);+ assertTrue(referenced.stream().allMatch(id -> id < history.size()),+ "previousEventId points past the history: " + Set.copyOf(referenced));+ }++ private static HistoryEvent eventOfType(List<HistoryEvent> history, String type) {+ return history.stream()+ .filter(event -> type.equals(event.getType()))+ .findFirst()+ .orElseThrow(() -> new AssertionError("history has no " + type + " event: " + typesOf(history)));+ }++ private static HistoryEvent stateEvent(List<HistoryEvent> history, String type, String name) {+ return history.stream()+ .filter(event -> type.equals(event.getType()) && name.equals(event.getDetails().get("name")))+ .findFirst()+ .orElseThrow(() -> new AssertionError("history has no " + type + " for " + name + ": " + typesOf(history)));+ }++ private static HistoryEvent stateEventWithInput(List<HistoryEvent> history, String type, String name, String input) {+ return history.stream()+ .filter(event -> type.equals(event.getType()) && name.equals(event.getDetails().get("name"))+ && input.equals(event.getDetails().get("input")))+ .findFirst()+ .orElseThrow(() -> new AssertionError("history has no " + type + " for " + name + " with input "+ + input + ": " + typesOf(history)));+ }++ private static HistoryEvent stateEventWithOutput(List<HistoryEvent> history, String type, String name, String output) {+ return history.stream()+ .filter(event -> type.equals(event.getType()) && name.equals(event.getDetails().get("name"))+ && output.equals(event.getDetails().get("output")))+ .findFirst()+ .orElseThrow(() -> new AssertionError("history has no " + type + " for " + name + " with output "+ + output + ": " + typesOf(history)));+ }++ private static HistoryEvent iterationEvent(List<HistoryEvent> history, String type, int index) {+ return history.stream()+ .filter(event -> type.equals(event.getType()) && Integer.valueOf(index).equals(event.getDetails().get("index")))+ .findFirst()+ .orElseThrow(() -> new AssertionError("history has no " + type + " for index " + index + ": " + typesOf(history)));+ }++ private List<HistoryEvent> run(String definition, String input) {+ return run(definition, input, null);+ }++ /** Runs the definition the way StartExecution does: the history already holds ExecutionStarted as event 1. */+ private List<HistoryEvent> run(String definition, String input, MockedTestCase mocks) {+ var stateMachine = new StateMachine();+ stateMachine.setName("branch-history-test");+ stateMachine.setStateMachineArn("arn:aws:states:%s:%s:stateMachine:branch-history-test".formatted(REGION, ACCOUNT));+ stateMachine.setRoleArn("arn:aws:iam::%s:role/test-role".formatted(ACCOUNT));+ stateMachine.setDefinition(definition);++ var execution = new Execution();+ execution.setName("branch-history-execution");+ execution.setExecutionArn(+ "arn:aws:states:%s:%s:execution:branch-history-test:branch-history-execution".formatted(REGION, ACCOUNT));+ execution.setStateMachineArn(stateMachine.getStateMachineArn());+ execution.setInput(input);++ var history = new ArrayList<HistoryEvent>();+ var started = new HistoryEvent();+ started.setId(1L);+ started.setPreviousEventId(0L);+ started.setType("ExecutionStarted");+ started.setDetails(Map.of("input", input, "inputDetails", Map.of("truncated", false)));+ history.add(started);++ executor.executeSync(stateMachine, execution, history, mocks, (updated, events) -> {+ });+ return history;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorHistoryEventLimitTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorHistoryEventLimitTest.javaindex 49c3a225d0..e45639fa36 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorHistoryEventLimitTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorHistoryEventLimitTest.java@@ -29,6 +29,7 @@ import static org.junit.jupiter.api.Assertions.assertNotEquals;import static org.junit.jupiter.api.Assertions.assertNotNull;import static org.junit.jupiter.api.Assertions.assertTrue;import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.when;/*** Guards the bound AWS puts on a running execution: a state machine that never reaches a terminal@@ -183,6 +184,8 @@ class AslExecutorHistoryEventLimitTest {@BeforeEachvoid setUp() {+ Instance<StepFunctionsService> sfnService = mock(Instance.class);+ when(sfnService.get()).thenReturn(mock(StepFunctionsService.class));executor = new AslExecutor(mock(LambdaExecutorService.class),mock(LambdaFunctionStore.class),@@ -199,7 +202,7 @@ class AslExecutorHistoryEventLimitTest {mock(io.github.hectorvent.floci.services.scheduler.SchedulerController.class),objectMapper,new JsonataEvaluator(objectMapper),- mock(Instance.class), mock(EmulatorConfig.class), vertx, null);+ sfnService, mock(EmulatorConfig.class), vertx, null);}@Test@@ -238,17 +241,20 @@ class AslExecutorHistoryEventLimitTest {}/**- * The branch produced the events that ran the execution out of them, and floci publishes none- * of them. What the caller reads back is the four events the top-level flow did produce, ending- * in the failure: an unbroken chain, not four events numbered as if 25,000 had happened.+ * The branch produced the events that ran the execution out of them, and they are published+ * into the execution's history like any other: what the caller reads back is one history,+ * numbered without a gap and ending in the failure.*/@Testvoid aParallelBranchLeavesThePublishedHistoryUnbroken() {run(RUNAWAY_PARALLEL_BRANCH);assertEquals(List.of("PassStateEntered", "PassStateExited", "ParallelStateEntered",- "ExecutionFailed"),- history.stream().map(HistoryEvent::getType).toList());+ "ParallelStateStarted", "ChoiceStateEntered"),+ history.subList(0, 5).stream().map(HistoryEvent::getType).toList());+ HistoryEvent last = history.get(history.size() - 1);+ assertEquals("ExecutionFailed", last.getType());+ assertEquals(25_000, history.size());for (int index = 0; index < history.size(); index++) {assertEquals(index + 1L, history.get(index).getId(), "unexpected id at index " + index);assertEquals((long) index, history.get(index).getPreviousEventId(),diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorIntrinsicMissingArgumentTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorIntrinsicMissingArgumentTest.javaindex 6a6441fe92..7e7332d653 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorIntrinsicMissingArgumentTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorIntrinsicMissingArgumentTest.java@@ -14,6 +14,7 @@ import org.junit.jupiter.api.Test;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;import static org.mockito.Mockito.mock;/**@@ -164,6 +165,14 @@ class AslExecutorIntrinsicMissingArgumentTest {+ "input '{\"items\":[1,2]}'", failure.cause);}+ /** The plain form of the same path is not a miss. AWS resolves it to null and the execution succeeds. */+ @Test+ void plainReferencePastTheEndOfAnArrayResolvesToNull() throws Exception {+ var resolved = resolve("{\"v.$\":\"$.items[5]\"}", "{\"items\":[1,2]}");++ assertTrue(resolved.path("v").isNull());+ }+/** Reading a field off the absent element fails alike. */@Testvoid navigatingPastAnOutOfRangeIndexFails() throws Exception {diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorTaskHistoryEventsTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorTaskHistoryEventsTest.javaindex 57c54717ad..7ead5529b2 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorTaskHistoryEventsTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorTaskHistoryEventsTest.java@@ -281,6 +281,7 @@ class AslExecutorTaskHistoryEventsTest {"Iterate": {"Type": "Map","ItemsPath": "$[0].items",+ "MaxConcurrency": 1,"ItemProcessor": {"StartAt": "ItemStep","States": {"ItemStep": {"Type": "Pass", "End": true}}@@ -293,10 +294,23 @@ class AslExecutorTaskHistoryEventsTest {assertEquals("SUCCEEDED", execution.getStatus(), "history: " + typesOf(history));assertEquals(- List.of("ParallelStateEntered", "ParallelStateExited",- "MapStateEntered", "MapStateExited", "ExecutionSucceeded"),+ List.of("ParallelStateEntered", "ParallelStateStarted",+ "PassStateEntered", "PassStateExited", "PassStateEntered", "PassStateExited",+ "ParallelStateSucceeded", "ParallelStateExited",+ "MapStateEntered", "MapStateStarted",+ "MapIterationStarted", "PassStateEntered", "PassStateExited", "MapIterationSucceeded",+ "MapIterationStarted", "PassStateEntered", "PassStateExited", "MapIterationSucceeded",+ "MapStateSucceeded", "MapStateExited", "ExecutionSucceeded"),typesOf(history));- assertChain(history);+ // The branch and the iterations chain to the Started event that opened them, and a+ // Succeeded event is passed by: the Exited event after it points where it pointed.+ assertEquals(+ List.of(0L, 1L, 2L, 3L, 4L, 5L, 6L, 6L,+ 8L, 9L, 10L, 11L, 12L, 13L, 10L, 15L, 16L, 17L, 18L, 18L, 20L),+ history.stream().map(HistoryEvent::getPreviousEventId).toList());+ for (var i = 0; i < history.size(); i++) {+ assertEquals(i + 1L, history.get(i).getId(), "unexpected id at index " + i);+ }}private static List<String> typesOf(List<HistoryEvent> history) {diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/HistoryChainTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/HistoryChainTest.javanew file mode 100644index 0000000000..523216d4cb--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/HistoryChainTest.java@@ -0,0 +1,48 @@+package io.github.hectorvent.floci.services.stepfunctions;++import io.github.hectorvent.floci.services.stepfunctions.model.HistoryEvent;+import org.junit.jupiter.api.Test;++import java.util.ArrayList;+import java.util.List;+import java.util.Map;++import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;+import static org.junit.jupiter.api.Assertions.assertEquals;++class HistoryChainTest {++ /** The history-event limit of AslExecutor. A counted event past it fails the execution. */+ private static final int MAX_HISTORY_EVENTS = 25_000;++ @Test+ void publishingAfterTheExecutionEndedRecordsNothingAndDoesNotCountTowardsTheLimit() {+ List<HistoryEvent> history = new ArrayList<>();+ var chain = HistoryChain.of(history);+ chain.end("ExecutionSucceeded", Map.of());++ assertDoesNotThrow(() -> {+ for (var i = 0; i < MAX_HISTORY_EVENTS; i++) {+ assertEquals(0L, chain.publish("PassStateEntered", null));+ chain.publishAside("PassStateSucceeded", null);+ }+ });+ assertEquals(1, history.size());+ }++ @Test+ void publishingIntoAHistorySealedByStopExecutionStopsCountingAsWell() {+ var history = new StepFunctionsService.ExecutionHistory();+ var chain = HistoryChain.of(history);+ var branch = chain.fork();+ history.sealWith("ExecutionAborted", Map.of());++ assertDoesNotThrow(() -> {+ for (var i = 0; i < MAX_HISTORY_EVENTS; i++) {+ assertEquals(0L, chain.publish("PassStateEntered", null));+ assertEquals(0L, branch.publish("PassStateEntered", null));+ }+ });+ assertEquals(1, history.size());+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsDescribeMapRunIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsDescribeMapRunIntegrationTest.javaindex 5baee890bf..d87f041b5a 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsDescribeMapRunIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsDescribeMapRunIntegrationTest.java@@ -22,8 +22,8 @@ import static org.junit.jupiter.api.Assertions.fail;* the {@code arn:aws:states:::aws-sdk:sfn:describeMapRun} Task integration.** <p>Every asserted value was measured against us-east-1 with a distributed Map run of the same- * shape. A Map run only becomes describable once its {@code ResultWriter} has minted the Map run- * ARN and returned it in the Map result, which is also the only way an ASL author obtains it.+ * shape. Every run is describable through the {@code mapRunArn} of its {@code MapRunStarted}+ * event. A run with a {@code ResultWriter} also returns that ARN in the Map result.*/@QuarkusTest@TestMethodOrder(MethodOrderer.OrderAnnotation.class)@@ -240,6 +240,44 @@ class StepFunctionsDescribeMapRunIntegrationTest {assertEquals(0, response.jsonPath().getInt(set + ".pendingRedrive"));}+ @Test+ @Order(10)+ void describeMapRunResolvesTheArnOfAMapWithoutResultWriter() throws Exception {+ var smArn = createStateMachine("describe-map-run-no-writer", distributedMapWithoutWriter(+ "[1, 2]", "Keep", "{\"Keep\": {\"Type\": \"Pass\", \"End\": true}}"));+ var execArn = startExecution(smArn, "{}");+ var describe = waitForTerminalState(execArn);+ assertEquals("SUCCEEDED", describe.jsonPath().getString("status"),+ "cause: " + describe.jsonPath().getString("cause"));++ var mapRunArn = mapRunArnFromHistory(execArn);+ var response = describeMapRun(mapRunArn);+ response.then().statusCode(200);+ assertEquals(mapRunArn, response.jsonPath().getString("mapRunArn"));+ assertEquals(execArn, response.jsonPath().getString("executionArn"));+ assertEquals("SUCCEEDED", response.jsonPath().getString("status"));+ assertCounters(response, "itemCounts", 2);+ assertCounters(response, "executionCounts", 2);+ }++ @Test+ @Order(11)+ void describeMapRunReportsARunWhoseItemFailed() throws Exception {+ var smArn = createStateMachine("describe-map-run-failed", distributedMapWithoutWriter(+ "[1]", "Boom", "{\"Boom\": {\"Type\": \"Fail\", \"Error\": \"Boom\", \"Cause\": \"item failed\"}}"));+ var execArn = startExecution(smArn, "{}");+ assertEquals("FAILED", waitForTerminalState(execArn).jsonPath().getString("status"));++ var response = describeMapRun(mapRunArnFromHistory(execArn));+ response.then().statusCode(200);+ assertEquals("FAILED", response.jsonPath().getString("status"));+ assertEquals(0, response.jsonPath().getInt("itemCounts.succeeded"));+ assertEquals(1, response.jsonPath().getInt("itemCounts.failed"));+ assertEquals(0, response.jsonPath().getInt("itemCounts.aborted"));+ assertEquals(1, response.jsonPath().getInt("itemCounts.total"));+ assertEquals(1, response.jsonPath().getInt("itemCounts.resultsWritten"));+ }+private static void assertTaskCounters(JsonNode counts, int items) {assertEquals(0, counts.path("Pending").asInt());assertEquals(0, counts.path("Running").asInt());@@ -284,6 +322,44 @@ class StepFunctionsDescribeMapRunIntegrationTest {.replace("BUCKET", bucket);}+ private static String distributedMapWithoutWriter(String items, String startAt, String states) {+ return """+ {+ "QueryLanguage": "JSONata",+ "StartAt": "Fan",+ "States": {+ "Fan": {+ "Type": "Map",+ "End": true,+ "Items": ITEMS,+ "ItemProcessor": {+ "ProcessorConfig": {"Mode": "DISTRIBUTED", "ExecutionType": "STANDARD"},+ "StartAt": "START_AT",+ "States": STATES+ }+ }+ }+ }+ """.replace("ITEMS", items).replace("START_AT", startAt).replace("STATES", states);+ }++ private static String mapRunArnFromHistory(String execArn) throws Exception {+ var history = given()+ .header("X-Amz-Target", "AWSStepFunctions.GetExecutionHistory")+ .contentType(SFN_CONTENT_TYPE)+ .body("""+ {"executionArn": "%s"}+ """.formatted(execArn))+ .when().post("/");+ history.then().statusCode(200);+ for (JsonNode event : mapper.readTree(history.asString()).path("events")) {+ if ("MapRunStarted".equals(event.path("type").asText())) {+ return event.path("mapRunStartedEventDetails").path("mapRunArn").asText();+ }+ }+ return fail("no MapRunStarted event in the history of " + execArn);+ }+private static Response describeMapRun(String mapRunArn) {return given().header("X-Amz-Target", "AWSStepFunctions.DescribeMapRun")diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsExecutionHistoryIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsExecutionHistoryIntegrationTest.javaindex 8901d0896d..53c4607a40 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsExecutionHistoryIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsExecutionHistoryIntegrationTest.java@@ -220,6 +220,136 @@ class StepFunctionsExecutionHistoryIntegrationTest {}}+ /**+ * The events of the states inside a Parallel branch and a Map iteration reach the caller through+ * GetExecutionHistory under the details field the SDK names for each event type. Shapes read+ * off real Step Functions in us-east-1 for issue #2868.+ */+ @Test+ void getExecutionHistory_publishesParallelBranchAndMapIterationEvents() throws Exception {+ String definition = """+ {+ "StartAt": "P",+ "States": {+ "P": {+ "Type": "Parallel",+ "Branches": [+ {"StartAt": "A1", "States": {"A1": {"Type": "Pass", "End": true}}}+ ],+ "Next": "M"+ },+ "M": {+ "Type": "Map",+ "ItemsPath": "$[0].items",+ "MaxConcurrency": 1,+ "ItemProcessor": {+ "ProcessorConfig": {"Mode": "INLINE"},+ "StartAt": "I1",+ "States": {"I1": {"Type": "Pass", "End": true}}+ },+ "End": true+ }+ }+ }+ """;++ String stateMachineArn = createStateMachine("execution-history-branches-test", definition);+ String executionArn = startExecution(stateMachineArn, "{\"items\": [1, 2]}");+ waitForExecution(executionArn);++ var events = MAPPER.readTree(getExecutionHistory(executionArn).body().asString()).path("events");+ var types = new ArrayList<String>();+ events.forEach(event -> types.add(event.path("type").asText()));+ assertEquals(List.of("ExecutionStarted", "ParallelStateEntered", "ParallelStateStarted",+ "PassStateEntered", "PassStateExited", "ParallelStateSucceeded", "ParallelStateExited",+ "MapStateEntered", "MapStateStarted",+ "MapIterationStarted", "PassStateEntered", "PassStateExited", "MapIterationSucceeded",+ "MapIterationStarted", "PassStateEntered", "PassStateExited", "MapIterationSucceeded",+ "MapStateSucceeded", "MapStateExited", "ExecutionSucceeded"), types);+ var expectedPreviousEventIds = List.of(0L, 0L, 2L, 3L, 4L, 5L, 5L, 7L, 8L, 9L, 10L, 11L, 12L,+ 9L, 14L, 15L, 16L, 17L, 17L, 19L);+ for (var i = 0; i < events.size(); i++) {+ assertEquals(i + 1L, events.get(i).path("id").asLong());+ assertEquals(expectedPreviousEventIds.get(i), events.get(i).path("previousEventId").asLong(),+ "previousEventId of event " + (i + 1) + " in " + events);+ }+ assertFalse(events.get(2).has("parallelStateStartedEventDetails"));+ assertEquals(2, events.get(8).path("mapStateStartedEventDetails").path("length").asInt());+ assertEquals("M", events.get(9).path("mapIterationStartedEventDetails").path("name").asText());+ assertEquals(0, events.get(9).path("mapIterationStartedEventDetails").path("index").asInt());+ assertEquals("M", events.get(16).path("mapIterationSucceededEventDetails").path("name").asText());+ assertEquals(1, events.get(16).path("mapIterationSucceededEventDetails").path("index").asInt());+ assertEquals("[1,2]", events.get(18).path("stateExitedEventDetails").path("output").asText());+ }++ /** The shape reported in issue #2868, verified against us-east-1. */+ @Test+ void getExecutionHistory_namesTheBranchStateAFailureBelongsTo() throws Exception {+ String definition = """+ {+ "StartAt": "P",+ "States": {+ "P": {+ "Type": "Parallel",+ "Branches": [+ {"StartAt": "Fast", "States": {"Fast": {"Type": "Pass", "Parameters": {"m.$": "$.nope"}, "End": true}}}+ ],+ "End": true+ }+ }+ }+ """;++ String stateMachineArn = createStateMachine("execution-history-branch-failure-test", definition);+ String executionArn = startExecution(stateMachineArn, "{\"x\": \"a\"}");+ var cause = "An error occurred while executing the state 'Fast' (entered at the event id #4). "+ + "The JSONPath '$.nope' specified for the field 'm.$' could not be found in the input '{\"x\":\"a\"}'";+ await().atMost(Duration.ofSeconds(5)).pollInterval(Duration.ofMillis(100)).untilAsserted(() -> {+ var described = describeExecution(executionArn);+ assertEquals("FAILED", described.jsonPath().getString("status"), described.body().asString());+ assertEquals("States.Runtime", described.jsonPath().getString("error"));+ assertEquals(cause, described.jsonPath().getString("cause"));+ });++ var events = MAPPER.readTree(getExecutionHistory(executionArn).body().asString()).path("events");+ var types = new ArrayList<String>();+ events.forEach(event -> types.add(event.path("type").asText()));+ assertEquals(List.of("ExecutionStarted", "ParallelStateEntered", "ParallelStateStarted",+ "PassStateEntered", "ExecutionFailed"), types);+ assertEquals("Fast", events.get(3).path("stateEnteredEventDetails").path("name").asText());+ assertEquals(cause, events.get(4).path("executionFailedEventDetails").path("cause").asText());+ assertEquals(4L, events.get(4).path("previousEventId").asLong());+ }++ private Response getExecutionHistory(String executionArn) {+ Response response = given()+ .header("X-Amz-Target", "AWSStepFunctions.GetExecutionHistory")+ .contentType(SFN_CONTENT_TYPE)+ .body(String.format("""+ {+ "executionArn": "%s",+ "includeExecutionData": true+ }+ """, executionArn))+ .when()+ .post("/");+ response.then().statusCode(200);+ return response;+ }++ private Response describeExecution(String executionArn) {+ Response response = given()+ .header("X-Amz-Target", "AWSStepFunctions.DescribeExecution")+ .contentType(SFN_CONTENT_TYPE)+ .body(String.format("""+ { "executionArn": "%s" }+ """, executionArn))+ .when()+ .post("/");+ response.then().statusCode(200);+ return response;+ }+private static String createQueue(String queueName) {var response = given().header("X-Amz-Target", "AmazonSQS.CreateQueue")@@ -278,6 +408,22 @@ class StepFunctionsExecutionHistoryIntegrationTest {return response.jsonPath().getString("executionArn");}+ private String startExecution(String stateMachineArn, String input) {+ Response response = given()+ .header("X-Amz-Target", "AWSStepFunctions.StartExecution")+ .contentType(SFN_CONTENT_TYPE)+ .body(String.format("""+ {+ "stateMachineArn": "%s",+ "input": %s+ }+ """, stateMachineArn, quote(input)))+ .when()+ .post("/");+ response.then().statusCode(200);+ return response.jsonPath().getString("executionArn");+ }+private void waitForExecution(String executionArn) {await().atMost(Duration.ofSeconds(5))diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsIntrinsicMissingArgumentIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsIntrinsicMissingArgumentIntegrationTest.javaindex bc292afca1..083c1be933 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsIntrinsicMissingArgumentIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsIntrinsicMissingArgumentIntegrationTest.java@@ -39,7 +39,8 @@ class StepFunctionsIntrinsicMissingArgumentIntegrationTest {assertEquals("FAILED", describe.jsonPath().getString("status"), describe.body().asString());assertEquals("States.Runtime", describe.jsonPath().getString("error"));- assertEquals("The function 'States.Format('{}', $.nope)' had the following error: "+ assertEquals("An error occurred while executing the state 'Pick' (entered at the event id #2). "+ + "The function 'States.Format('{}', $.nope)' had the following error: "+ "The JsonPath argument for the field '$.nope' could not be found in the input "+ "'{\"other\":1}'",describe.jsonPath().getString("cause"));@@ -58,7 +59,8 @@ class StepFunctionsIntrinsicMissingArgumentIntegrationTest {var describe = run("nested-intrinsic", definition, "{\"other\":1}");assertEquals("FAILED", describe.jsonPath().getString("status"), describe.body().asString());- assertEquals("The function 'States.Format('{}', States.Format('{}', $.nope))' had the "+ assertEquals("An error occurred while executing the state 'Pick' (entered at the event id #2). "+ + "The function 'States.Format('{}', States.Format('{}', $.nope))' had the "+ "following error: The JsonPath argument for the field '$.nope' could not be "+ "found in the input '{\"other\":1}'",describe.jsonPath().getString("cause"));@@ -79,7 +81,8 @@ class StepFunctionsIntrinsicMissingArgumentIntegrationTest {var describe = run("intrinsic-index-out-of-range", definition, "{\"items\":[1,2]}");assertEquals("FAILED", describe.jsonPath().getString("status"), describe.body().asString());- assertEquals("The function 'States.Format('{}', $.items[5])' had the following error: "+ assertEquals("An error occurred while executing the state 'Pick' (entered at the event id #2). "+ + "The function 'States.Format('{}', $.items[5])' had the following error: "+ "The JsonPath argument for the field '$.items[5]' could not be found in the "+ "input '{\"items\":[1,2]}'",describe.jsonPath().getString("cause"));@@ -101,7 +104,8 @@ class StepFunctionsIntrinsicMissingArgumentIntegrationTest {assertEquals("FAILED", describe.jsonPath().getString("status"), describe.body().asString());assertEquals("States.Runtime", describe.jsonPath().getString("error"));- assertEquals("The function 'States.Format('{}', $.nope)' had the following error: "+ assertEquals("An error occurred while executing the state 'M' (entered at the event id #2). "+ + "The function 'States.Format('{}', $.nope)' had the following error: "+ "The JsonPath argument for the field '$.nope' could not be found in the input "+ "'{\"items\":[1,2]}'",describe.jsonPath().getString("cause"));diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonataFunctionsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonataFunctionsIntegrationTest.javaindex bb6aebb812..e8df324d36 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonataFunctionsIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonataFunctionsIntegrationTest.java@@ -247,7 +247,8 @@ class StepFunctionsJsonataFunctionsIntegrationTest {Response resp = waitForExecutionFailure(startExecution(smArn, "{}"));assertEquals("States.QueryEvaluationError", resp.jsonPath().getString("error"));- assertEquals("The JSONata expression '$sum(['a'])' specified for the field 'Output/v' threw an error "+ assertEquals("An error occurred while executing the state 'Sum' (entered at the event id #2). "+ + "The JSONata expression '$sum(['a'])' specified for the field 'Output/v' threw an error "+ "during evaluation. T0412: Argument [\"a\"] must be an array of \"numbers\"",resp.jsonPath().getString("cause"));}@@ -277,7 +278,8 @@ class StepFunctionsJsonataFunctionsIntegrationTest {Response resp = waitForExecutionFailure(startExecution(smArn, "{}"));assertEquals("States.QueryEvaluationError", resp.jsonPath().getString("error"));- assertEquals("The JSONata expression '$abs(\"x\")' specified for the field 'Output/v' threw an error "+ assertEquals("An error occurred while executing the state 'Abs' (entered at the event id #2). "+ + "The JSONata expression '$abs(\"x\")' specified for the field 'Output/v' threw an error "+ "during evaluation. T0410: Argument 1 of function \"abs\" does not match function signature",resp.jsonPath().getString("cause"));}diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonataIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonataIntegrationTest.javaindex bb61192e00..cea67f39b3 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonataIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonataIntegrationTest.java@@ -619,7 +619,8 @@ class StepFunctionsJsonataIntegrationTest {assertEquals("FAILED", failure.jsonPath().getString("status"));assertEquals("States.ItemReaderFailed", failure.jsonPath().getString("error"));- assertEquals("The provided ReaderConfig.ItemsPointer does not match any valid path in the JSON structure.",+ assertEquals("An error occurred while executing the state 'ProcessWorkers' (entered at the event id #2). "+ + "The provided ReaderConfig.ItemsPointer does not match any valid path in the JSON structure.",failure.jsonPath().getString("cause"));}@@ -672,7 +673,8 @@ class StepFunctionsJsonataIntegrationTest {assertEquals("FAILED", failure.jsonPath().getString("status"));assertEquals("States.ItemReaderFailed", failure.jsonPath().getString("error"));- assertEquals("Attempting to map over non-iterable node.", failure.jsonPath().getString("cause"));+ assertEquals("An error occurred while executing the state 'ProcessWorkers' (entered at the event id #2). "+ + "Attempting to map over non-iterable node.", failure.jsonPath().getString("cause"));}@Test@@ -770,7 +772,8 @@ class StepFunctionsJsonataIntegrationTest {assertEquals("FAILED", failure.jsonPath().getString("status"));assertEquals("States.Runtime", failure.jsonPath().getString("error"));- assertEquals("The ItemReader, ItemBatcher and ResultWriter fields are not supported for INLINE maps",+ assertEquals("An error occurred while executing the state 'ProcessWorkers' (entered at the event id #2). "+ + "The ItemReader, ItemBatcher and ResultWriter fields are not supported for INLINE maps",failure.jsonPath().getString("cause"));}@@ -1295,7 +1298,8 @@ class StepFunctionsJsonataIntegrationTest {Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));- assertEquals("The JSONata expression '$states.input.missing' specified for the field 'Output/v' "+ assertEquals("An error occurred while executing the state 'Transform' (entered at the event id #2). "+ + "The JSONata expression '$states.input.missing' specified for the field 'Output/v' "+ "returned nothing (undefined).", failure.jsonPath().getString("cause"));String catching = definition.replace("\"End\": true",@@ -1390,7 +1394,8 @@ class StepFunctionsJsonataIntegrationTest {Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));- assertEquals("The JSONata expression '$states.input.missing' specified for the field 'Assign/x' "+ assertEquals("An error occurred while executing the state 'Bind' (entered at the event id #2). "+ + "The JSONata expression '$states.input.missing' specified for the field 'Assign/x' "+ "returned nothing (undefined).", failure.jsonPath().getString("cause"));}@@ -1421,7 +1426,8 @@ class StepFunctionsJsonataIntegrationTest {Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));- assertEquals("The JSONata expression '$states.input.missing' specified for the field "+ assertEquals("An error occurred while executing the state 'Send' (entered at the event id #2). "+ + "The JSONata expression '$states.input.missing' specified for the field "+ "'Arguments/MessageGroupId' returned nothing (undefined).",failure.jsonPath().getString("cause"));}@@ -1454,7 +1460,8 @@ class StepFunctionsJsonataIntegrationTest {Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));- assertEquals("The JSONata expression '$states.input.missing' specified for the field "+ assertEquals("An error occurred while executing the state 'Pick' (entered at the event id #2). "+ + "The JSONata expression '$states.input.missing' specified for the field "+ "'Choices[1]/Condition' returned nothing (undefined).", failure.jsonPath().getString("cause"));}@@ -1516,7 +1523,8 @@ class StepFunctionsJsonataIntegrationTest {Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));- assertEquals("The JSONata expression '$states.input.missing' specified for the field "+ assertEquals("An error occurred while executing the state 'Pick' (entered at the event id #2). "+ + "The JSONata expression '$states.input.missing' specified for the field "+ "'Choices[1]/Output/v' returned nothing (undefined).", failure.jsonPath().getString("cause"));}@@ -1546,7 +1554,8 @@ class StepFunctionsJsonataIntegrationTest {Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));- assertEquals("The JSONata expression '$states.input.missing' specified for the field "+ assertEquals("An error occurred while executing the state 'Pick' (entered at the event id #2). "+ + "The JSONata expression '$states.input.missing' specified for the field "+ "'Choices[0]/Assign/x' returned nothing (undefined).", failure.jsonPath().getString("cause"));}@@ -1586,7 +1595,8 @@ class StepFunctionsJsonataIntegrationTest {Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));- assertEquals("The JSONata expression '$states.input.missing' specified for the field "+ assertEquals("An error occurred while executing the state 'Boom' (entered at the event id #2). "+ + "The JSONata expression '$states.input.missing' specified for the field "+ "'Catch[1]/Output/v' returned nothing (undefined).", failure.jsonPath().getString("cause"));}@@ -1608,7 +1618,8 @@ class StepFunctionsJsonataIntegrationTest {Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));- assertEquals("The JSONata expression '$states.input.missing' specified for the field 'Seconds' "+ assertEquals("An error occurred while executing the state 'Pause' (entered at the event id #2). "+ + "The JSONata expression '$states.input.missing' specified for the field 'Seconds' "+ "returned nothing (undefined).", failure.jsonPath().getString("cause"));}@@ -1631,14 +1642,16 @@ class StepFunctionsJsonataIntegrationTest {createStateMachine("jsonata-fail-error-returned-nothing-test",definition.formatted("{% $states.input.missing %}", "boom")), "{}"));assertEquals("States.QueryEvaluationError", errorFailure.jsonPath().getString("error"));- assertEquals("The JSONata expression '$states.input.missing' specified for the field 'Error' "+ assertEquals("An error occurred while executing the state 'Stop' (entered at the event id #2). "+ + "The JSONata expression '$states.input.missing' specified for the field 'Error' "+ "returned nothing (undefined).", errorFailure.jsonPath().getString("cause"));Response causeFailure = waitForExecutionFailure(startExecution(createStateMachine("jsonata-fail-cause-returned-nothing-test",definition.formatted("Boom", "{% $states.input.missing %}")), "{}"));assertEquals("States.QueryEvaluationError", causeFailure.jsonPath().getString("error"));- assertEquals("The JSONata expression '$states.input.missing' specified for the field 'Cause' "+ assertEquals("An error occurred while executing the state 'Stop' (entered at the event id #2). "+ + "The JSONata expression '$states.input.missing' specified for the field 'Cause' "+ "returned nothing (undefined).", causeFailure.jsonPath().getString("cause"));}@@ -1667,7 +1680,8 @@ class StepFunctionsJsonataIntegrationTest {Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));- assertEquals("The JSONata expression '$states.input.missing' specified for the field 'Items' "+ assertEquals("An error occurred while executing the state 'Fan' (entered at the event id #2). "+ + "The JSONata expression '$states.input.missing' specified for the field 'Items' "+ "returned nothing (undefined).", failure.jsonPath().getString("cause"));}@@ -1698,7 +1712,8 @@ class StepFunctionsJsonataIntegrationTest {Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));- assertEquals("The JSONata expression '$states.input.missing' specified for the field "+ assertEquals("An error occurred while executing the state 'Fan' (entered at the event id #2). "+ + "The JSONata expression '$states.input.missing' specified for the field "+ "'MaxConcurrency' returned nothing (undefined).", failure.jsonPath().getString("cause"));}@@ -1758,7 +1773,8 @@ class StepFunctionsJsonataIntegrationTest {Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));- assertEquals("The JSONata expression '$states.input.missing' specified for the field 'Output' "+ assertEquals("An error occurred while executing the state 'Transform' (entered at the event id #2). "+ + "The JSONata expression '$states.input.missing' specified for the field 'Output' "+ "returned nothing (undefined).", failure.jsonPath().getString("cause"));}diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsTimeoutSecondsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsTimeoutSecondsIntegrationTest.javaindex 746be51b18..bf6ce1c12e 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsTimeoutSecondsIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsTimeoutSecondsIntegrationTest.java@@ -117,7 +117,9 @@ class StepFunctionsTimeoutSecondsIntegrationTest {assertTrue(elapsedMillis < 3_000,"the branch's 3-second Wait outlasted the 1-second budget: " + elapsedMillis + " ms");JsonNode events = mapper.readTree(getExecutionHistory(execArn).body().asString()).path("events");- assertEquals(List.of("ExecutionStarted", "ParallelStateEntered", "ExecutionTimedOut"),+ // The branch's Wait was entered and never exited: the budget cut it.+ assertEquals(List.of("ExecutionStarted", "ParallelStateEntered", "ParallelStateStarted",+ "WaitStateEntered", "ExecutionTimedOut"),eventTypes(events), "history was " + events);}@@ -224,8 +226,14 @@ class StepFunctionsTimeoutSecondsIntegrationTest {assertTrue(elapsedMillis < 5_000,"the iterations' 10-second Wait outlasted the 1-second budget: " + elapsedMillis + " ms");JsonNode events = mapper.readTree(getExecutionHistory(execArn).body().asString()).path("events");- assertEquals(List.of("ExecutionStarted", "MapStateEntered", "ExecutionTimedOut"),- eventTypes(events), "history was " + events);+ // Both iterations entered their Wait and neither exited it. They run concurrently, so+ // the order their events interleave in is theirs to choose.+ List<String> types = eventTypes(events);+ assertEquals(List.of("ExecutionStarted", "MapStateEntered", "MapStateStarted"), types.subList(0, 3),+ "history was " + events);+ assertEquals(List.of("MapIterationStarted", "MapIterationStarted", "WaitStateEntered", "WaitStateEntered"),+ types.subList(3, 7).stream().sorted().toList(), "history was " + events);+ assertEquals(List.of("ExecutionTimedOut"), types.subList(7, types.size()), "history was " + events);}@Test@@ -259,7 +267,8 @@ class StepFunctionsTimeoutSecondsIntegrationTest {assertTrue(elapsedMillis < 5_000,"the single iteration's 10-second Wait outlasted the 1-second budget: " + elapsedMillis + " ms");JsonNode events = mapper.readTree(getExecutionHistory(execArn).body().asString()).path("events");- assertEquals(List.of("ExecutionStarted", "MapStateEntered", "ExecutionTimedOut"),+ assertEquals(List.of("ExecutionStarted", "MapStateEntered", "MapStateStarted", "MapIterationStarted",+ "WaitStateEntered", "ExecutionTimedOut"),eventTypes(events), "history was " + events);}diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsUnresolvableJsonPathIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsUnresolvableJsonPathIntegrationTest.javaindex 195767f10b..4f08040139 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsUnresolvableJsonPathIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsUnresolvableJsonPathIntegrationTest.java@@ -38,7 +38,8 @@ class StepFunctionsUnresolvableJsonPathIntegrationTest {assertEquals("FAILED", describe.jsonPath().getString("status"), describe.body().asString());assertEquals("States.Runtime", describe.jsonPath().getString("error"));- assertEquals("The JSONPath '$.nope.deep' specified for the field 'missing.$' could not "+ assertEquals("An error occurred while executing the state 'Pick' (entered at the event id #2). "+ + "The JSONPath '$.nope.deep' specified for the field 'missing.$' could not "+ "be found in the input '{\"other\":1}'",describe.jsonPath().getString("cause"));}@@ -92,7 +93,8 @@ class StepFunctionsUnresolvableJsonPathIntegrationTest {assertEquals("FAILED", describe.jsonPath().getString("status"), describe.body().asString());assertEquals("States.Runtime", describe.jsonPath().getString("error"));- assertEquals("The JSONPath '$.nope' specified for the field 'missing.$' could not be "+ assertEquals("An error occurred while executing the state 'M' (entered at the event id #2). "+ + "The JSONPath '$.nope' specified for the field 'missing.$' could not be "+ "found in the input '[1,2]'",describe.jsonPath().getString("cause"));}