Light, fluffy, and always free - The AWS Local Emulator alternative
feat(scheduler): start Step Functions targets (#3936)
vamsiakbc018afad079
diff --git a/docs/services/scheduler.md b/docs/services/scheduler.mdindex da21742be2..2dbf4c7cef 100644--- a/docs/services/scheduler.md+++ b/docs/services/scheduler.md@@ -36,7 +36,11 @@ background dispatcher fires schedule targets on time. Supported expressions:window are skipped. The dispatcher ticks every`floci.services.scheduler.tick-interval-seconds` (default `10`).-Supported target types: SQS, Lambda, SNS, EventBridge `PutEvents`.+Supported target types: SQS, Lambda, SNS, ECS `RunTask`, EventBridge+`PutEvents`, and unqualified Step Functions state machine ARNs. A Step Functions+target starts an asynchronous execution with the schedule target's `Input`, or+`{}` when `Input` is absent. Scheduler delivery succeeds when `StartExecution`+is accepted; a later workflow failure does not trigger Scheduler retries.### Retries and dead-letter queuesdiff --git a/src/main/java/io/github/hectorvent/floci/services/scheduler/ScheduleInvoker.java b/src/main/java/io/github/hectorvent/floci/services/scheduler/ScheduleInvoker.javaindex 10a8619ddf..f2b96296d9 100644--- a/src/main/java/io/github/hectorvent/floci/services/scheduler/ScheduleInvoker.java+++ b/src/main/java/io/github/hectorvent/floci/services/scheduler/ScheduleInvoker.java@@ -5,6 +5,7 @@ import com.fasterxml.jackson.databind.ObjectMapper;import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.AwsArnUtils;import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RequestScopes;import io.github.hectorvent.floci.services.ecs.EcsService;import io.github.hectorvent.floci.services.ecs.model.LaunchType;import io.github.hectorvent.floci.services.eventbridge.EventBridgeService;@@ -17,6 +18,7 @@ import io.github.hectorvent.floci.services.sns.SnsMessageAttributes;import io.github.hectorvent.floci.services.sns.SnsService;import io.github.hectorvent.floci.services.sqs.SqsService;import io.github.hectorvent.floci.services.sqs.model.MessageAttributeValue;+import io.github.hectorvent.floci.services.stepfunctions.StepFunctionsService;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import org.jboss.logging.Logger;@@ -29,7 +31,7 @@ import java.util.Map;/*** Delivers an EventBridge Scheduler target invocation to the underlying service.- * Supports templated SQS, Lambda, SNS, and EventBridge PutEvents targets, plus+ * Supports templated SQS, Lambda, SNS, Step Functions, and EventBridge PutEvents targets, plus* universal targets ({@code arn:aws:scheduler:::aws-sdk:<service>:<action>}) for* {@code sns:publish} and {@code sqs:sendMessage}. Mirrors the subset handled by* {@code EventBridgeInvoker} but using Scheduler's {@link Target} model (raw@@ -45,6 +47,7 @@ public class ScheduleInvoker {private final SnsService snsService;private final EventBridgeService eventBridgeService;private final EcsService ecsService;+ private final StepFunctionsService stepFunctionsService;private final ObjectMapper objectMapper;private final String baseUrl;@@ -54,6 +57,7 @@ public class ScheduleInvoker {SnsService snsService,EventBridgeService eventBridgeService,EcsService ecsService,+ StepFunctionsService stepFunctionsService,ObjectMapper objectMapper,EmulatorConfig config) {this.sqsService = sqsService;@@ -61,6 +65,7 @@ public class ScheduleInvoker {this.snsService = snsService;this.eventBridgeService = eventBridgeService;this.ecsService = ecsService;+ this.stepFunctionsService = stepFunctionsService;this.objectMapper = objectMapper;this.baseUrl = config.baseUrl();}@@ -99,6 +104,11 @@ public class ScheduleInvoker {} else if (arn.contains(":ecs:") && target.getEcsParameters() != null) {deliverToEcsRunTask(target, targetRegion);LOG.debugv("Scheduler delivered to ECS RunTask: {0}", arn);+ } else if (isStateMachineArn(arn)) {+ String targetAccount = AwsArnUtils.parse(arn).accountId();+ RequestScopes.runAs(targetAccount,+ () -> stepFunctionsService.startExecution(arn, null, payload, targetRegion));+ LOG.debugv("Scheduler started Step Functions execution: {0}", arn);} else if (isEventBridgePutEventsArn(arn)) {deliverToEventBridge(target, payload, targetRegion);LOG.debugv("Scheduler delivered to EventBridge: {0}", arn);@@ -277,6 +287,15 @@ public class ScheduleInvoker {return arn.contains(":events:") && arn.contains(":event-bus/");}+ private static boolean isStateMachineArn(String arn) {+ if (!AwsArnUtils.isArnFor(arn, "states")) {+ return false;+ }+ String resource = AwsArnUtils.parse(arn).resource();+ String prefix = "stateMachine:";+ return resource.startsWith(prefix) && resource.indexOf(':', prefix.length()) < 0;+ }+private void deliverToEventBridge(Target target, String payload, String region) {String busArn = target.getArn();String busName = busArn.substring(busArn.indexOf(":event-bus/") + ":event-bus/".length());diff --git a/src/test/java/io/github/hectorvent/floci/services/scheduler/ScheduleInvokerTest.java b/src/test/java/io/github/hectorvent/floci/services/scheduler/ScheduleInvokerTest.javaindex 67b1617541..00e1ef6869 100644--- a/src/test/java/io/github/hectorvent/floci/services/scheduler/ScheduleInvokerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/scheduler/ScheduleInvokerTest.java@@ -17,6 +17,7 @@ import io.github.hectorvent.floci.services.scheduler.model.Target;import io.github.hectorvent.floci.services.sns.SnsService;import io.github.hectorvent.floci.services.sqs.SqsService;import io.github.hectorvent.floci.services.sqs.model.MessageAttributeValue;+import io.github.hectorvent.floci.services.stepfunctions.StepFunctionsService;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;import org.mockito.ArgumentCaptor;@@ -50,6 +51,7 @@ class ScheduleInvokerTest {private SnsService snsService;private EventBridgeService eventBridgeService;private EcsService ecsService;+ private StepFunctionsService stepFunctionsService;private ScheduleInvoker invoker;@BeforeEach@@ -59,10 +61,11 @@ class ScheduleInvokerTest {snsService = mock(SnsService.class);eventBridgeService = mock(EventBridgeService.class);ecsService = mock(EcsService.class);+ stepFunctionsService = mock(StepFunctionsService.class);EmulatorConfig config = mock(EmulatorConfig.class);when(config.baseUrl()).thenReturn("http://localhost:4566");invoker = new ScheduleInvoker(sqsService, lambdaService, snsService,- eventBridgeService, ecsService, new ObjectMapper(), config);+ eventBridgeService, ecsService, stepFunctionsService, new ObjectMapper(), config);}@Test@@ -279,6 +282,55 @@ class ScheduleInvokerTest {eq("Scheduler"), eq("us-east-1"));}+ @Test+ void stateMachineTargetStartsExecutionWithInputAndArnRegion() {+ String stateMachineArn = "arn:aws:states:eu-west-1:000000000000:stateMachine:scheduled-workflow";+ String input = "{\"order\":{\"id\":42}}";+ Target target = new Target();+ target.setArn(stateMachineArn);+ target.setRoleArn("arn:aws:iam::000000000000:role/scheduler-role");+ target.setInput(input);++ invoker.invoke(target, "us-east-1");++ verify(stepFunctionsService).startExecution(stateMachineArn, null, input, "eu-west-1");+ }++ @Test+ void stateMachineTargetWithoutInputUsesEmptyObject() {+ String stateMachineArn = "arn:aws:states:us-east-1:000000000000:stateMachine:scheduled-workflow";+ Target target = new Target();+ target.setArn(stateMachineArn);++ invoker.invoke(target, "us-east-1");++ verify(stepFunctionsService).startExecution(stateMachineArn, null, "{}", "us-east-1");+ }++ @Test+ void stateMachineStartFailurePropagatesToSchedulerDeliveryHandling() {+ String stateMachineArn = "arn:aws:states:us-east-1:000000000000:stateMachine:missing";+ Target target = new Target();+ target.setArn(stateMachineArn);+ when(stepFunctionsService.startExecution(stateMachineArn, null, "{}", "us-east-1"))+ .thenThrow(new AwsException("StateMachineDoesNotExist", "State machine does not exist", 400));++ AwsException error = assertThrows(AwsException.class,+ () -> invoker.invoke(target, "us-east-1"));++ assertEquals("StateMachineDoesNotExist", error.getErrorCode());+ }++ @Test+ void qualifiedStateMachineTargetRemainsUnsupported() {+ Target target = new Target();+ target.setArn("arn:aws:states:us-east-1:000000000000:stateMachine:scheduled-workflow:PROD");++ assertThrows(UnsupportedOperationException.class,+ () -> invoker.invoke(target, "us-east-1"));+ verifyNoInteractions(stepFunctionsService);+ }+@Test@SuppressWarnings("unchecked")void eventBusTargetUsesDeclaredDetailTypeAndSource() {diff --git a/src/test/java/io/github/hectorvent/floci/services/scheduler/SchedulerStepFunctionsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/scheduler/SchedulerStepFunctionsIntegrationTest.javanew file mode 100644index 0000000000..da19a6263c--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/scheduler/SchedulerStepFunctionsIntegrationTest.java@@ -0,0 +1,220 @@+package io.github.hectorvent.floci.services.scheduler;++import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.scheduler.model.Schedule;+import io.github.hectorvent.floci.services.sqs.SqsService;+import io.github.hectorvent.floci.services.stepfunctions.StepFunctionsService;+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.Response;+import jakarta.inject.Inject;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;++import java.time.Duration;+import java.time.Instant;+import java.time.ZoneOffset;+import java.time.format.DateTimeFormatter;+import java.time.temporal.ChronoUnit;+import java.util.ArrayList;+import java.util.List;+import java.util.Map;+import java.util.UUID;++import static io.restassured.RestAssured.given;+import static org.awaitility.Awaitility.await;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.when;++@QuarkusTest+class SchedulerStepFunctionsIntegrationTest {++ private static final String REGION = "us-east-1";+ private static final String SFN_CONTENT_TYPE = "application/x-amz-json-1.0";+ private static final String ROLE_ARN = "arn:aws:iam::000000000000:role/scheduler-role";+ private static final ObjectMapper MAPPER = new ObjectMapper();+ private static final DateTimeFormatter SCHEDULE_TIME =+ DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss").withZone(ZoneOffset.UTC);++ @Inject+ ScheduleInvoker scheduleInvoker;++ @Inject+ SchedulerService schedulerService;++ @Inject+ StepFunctionsService stepFunctionsService;++ @Inject+ SqsService sqsService;++ @Inject+ EmulatorConfig config;++ private final List<String> scheduleNames = new ArrayList<>();+ private final List<String> stateMachineArns = new ArrayList<>();+ private final List<ScheduleDispatcher> testDispatchers = new ArrayList<>();++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @AfterEach+ void cleanUp() {+ for (String scheduleName : scheduleNames) {+ try {+ schedulerService.deleteSchedule(scheduleName, null, REGION);+ } catch (AwsException expected) {+ // A schedule with ActionAfterCompletion=DELETE may already be gone.+ }+ }+ for (String stateMachineArn : stateMachineArns) {+ stepFunctionsService.deleteStateMachine(stateMachineArn);+ }+ for (ScheduleDispatcher dispatcher : testDispatchers) {+ dispatcher.onStop(null);+ }+ }++ @Test+ void oneTimeScheduleStartsStateMachineWithExactInput() {+ String stateMachineArn = createPassStateMachine();+ String scheduleName = uniqueName("sfn-at");+ String input = "{\"order\":{\"id\":42},\"items\":[\"a\",\"b\"]}";+ Instant fireAt = Instant.now().plus(1, ChronoUnit.DAYS).truncatedTo(ChronoUnit.SECONDS);+ createSchedule(scheduleName, "at(" + SCHEDULE_TIME.format(fireAt) + ")", "ENABLED",+ stateMachineArn, input);++ dispatcherFor(scheduleName).tick(fireAt);++ List<Map<String, Object>> executions = listExecutions(stateMachineArn);+ assertEquals(1, executions.size());+ Response execution = waitForTerminalExecution((String) executions.get(0).get("executionArn"));+ assertEquals("SUCCEEDED", execution.jsonPath().getString("status"));+ assertEquals(input, execution.jsonPath().getString("input"));+ assertEquals(input, execution.jsonPath().getString("output"));+ }++ @Test+ void recurringScheduleStartsOneExecutionPerOccurrence() {+ String stateMachineArn = createPassStateMachine();+ String scheduleName = uniqueName("sfn-rate");+ createSchedule(scheduleName, "rate(1 minute)", "ENABLED", stateMachineArn, "{\"kind\":\"recurring\"}");+ Schedule schedule = schedulerService.getSchedule(scheduleName, null, REGION);+ Instant firstFire = schedule.getCreationDate().plus(61, ChronoUnit.SECONDS);+ ScheduleDispatcher dispatcher = dispatcherFor(scheduleName);++ dispatcher.tick(firstFire);+ dispatcher.tick(firstFire.plus(61, ChronoUnit.SECONDS));++ assertEquals(2, listExecutions(stateMachineArn).size());+ }++ @Test+ void disabledScheduleDoesNotStartStateMachine() {+ String stateMachineArn = createPassStateMachine();+ String scheduleName = uniqueName("sfn-disabled");+ Instant fireAt = Instant.now().plus(1, ChronoUnit.DAYS).truncatedTo(ChronoUnit.SECONDS);+ createSchedule(scheduleName, "at(" + SCHEDULE_TIME.format(fireAt) + ")", "DISABLED",+ stateMachineArn, "{\"disabled\":true}");++ dispatcherFor(scheduleName).tick(fireAt);++ assertEquals(0, listExecutions(stateMachineArn).size());+ }++ private String createPassStateMachine() {+ String name = uniqueName("scheduled-workflow");+ String definition = "{\"StartAt\":\"Pass\",\"States\":{\"Pass\":{\"Type\":\"Pass\",\"End\":true}}}";+ ObjectNode request = MAPPER.createObjectNode();+ request.put("name", name);+ request.put("definition", definition);+ request.put("roleArn", ROLE_ARN);++ Response response = given()+ .header("X-Amz-Target", "AWSStepFunctions.CreateStateMachine")+ .contentType(SFN_CONTENT_TYPE)+ .body(request.toString())+ .when()+ .post("/");+ response.then().statusCode(200);+ String stateMachineArn = response.jsonPath().getString("stateMachineArn");+ stateMachineArns.add(stateMachineArn);+ return stateMachineArn;+ }++ private void createSchedule(String name, String expression, String state,+ String targetArn, String input) {+ ObjectNode request = MAPPER.createObjectNode();+ request.put("ScheduleExpression", expression);+ request.putObject("FlexibleTimeWindow").put("Mode", "OFF");+ request.put("State", state);+ ObjectNode target = request.putObject("Target");+ target.put("Arn", targetArn);+ target.put("RoleArn", ROLE_ARN);+ target.put("Input", input);++ given()+ .contentType("application/json")+ .body(request.toString())+ .when()+ .post("/schedules/" + name)+ .then()+ .statusCode(200);+ scheduleNames.add(name);+ }++ private ScheduleDispatcher dispatcherFor(String scheduleName) {+ Schedule schedule = schedulerService.getSchedule(scheduleName, null, REGION);+ SchedulerService scopedSchedulerService = mock(SchedulerService.class);+ when(scopedSchedulerService.listAllSchedules()).thenReturn(List.of(schedule));+ ScheduleDispatcher dispatcher = new ScheduleDispatcher(+ scopedSchedulerService, scheduleInvoker, sqsService, config);+ testDispatchers.add(dispatcher);+ return dispatcher;+ }++ private List<Map<String, Object>> listExecutions(String stateMachineArn) {+ ObjectNode request = MAPPER.createObjectNode();+ request.put("stateMachineArn", stateMachineArn);+ Response response = given()+ .header("X-Amz-Target", "AWSStepFunctions.ListExecutions")+ .contentType(SFN_CONTENT_TYPE)+ .body(request.toString())+ .when()+ .post("/");+ response.then().statusCode(200);+ return response.jsonPath().getList("executions");+ }++ private Response waitForTerminalExecution(String executionArn) {+ await()+ .atMost(Duration.ofSeconds(5))+ .pollInterval(Duration.ofMillis(100))+ .until(() -> !"RUNNING".equals(describeExecution(executionArn).jsonPath().getString("status")));+ return describeExecution(executionArn);+ }++ private Response describeExecution(String executionArn) {+ ObjectNode request = MAPPER.createObjectNode();+ request.put("executionArn", executionArn);+ Response response = given()+ .header("X-Amz-Target", "AWSStepFunctions.DescribeExecution")+ .contentType(SFN_CONTENT_TYPE)+ .body(request.toString())+ .when()+ .post("/");+ response.then().statusCode(200);+ return response;+ }++ private static String uniqueName(String prefix) {+ return prefix + "-" + UUID.randomUUID().toString().substring(0, 8);+ }+}