Skip to content

armgit / floci

Public Imported from GitHub
0

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

feat(sfn): add SQS sendMessage integrations (#409)

sf-jin-ku0c4eb1380ce2
diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java
index de809df882..a5555cd985 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
@@ -9,6 +9,7 @@ import io.github.hectorvent.floci.services.lambda.LambdaFunctionStore;
import io.github.hectorvent.floci.services.lambda.model.InvocationType;
import io.github.hectorvent.floci.services.lambda.model.InvokeResult;
import io.github.hectorvent.floci.services.lambda.model.LambdaFunction;
+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.StateMachine;
@@ -48,6 +49,7 @@ public class AslExecutor {
private final LambdaFunctionStore functionStore;
private final DynamoDbService dynamoDbService;
private final DynamoDbJsonHandler dynamoDbJsonHandler;
+ private final SqsJsonHandler sqsJsonHandler;
private final ObjectMapper objectMapper;
private final JsonataEvaluator jsonataEvaluator;
private final Instance<StepFunctionsService> sfnService;
@@ -60,12 +62,14 @@ public class AslExecutor {
@Inject
public AslExecutor(LambdaExecutorService lambdaExecutor, LambdaFunctionStore functionStore,
DynamoDbService dynamoDbService, DynamoDbJsonHandler dynamoDbJsonHandler,
+ SqsJsonHandler sqsJsonHandler,
ObjectMapper objectMapper, JsonataEvaluator jsonataEvaluator,
Instance<StepFunctionsService> sfnService) {
this.lambdaExecutor = lambdaExecutor;
this.functionStore = functionStore;
this.dynamoDbService = dynamoDbService;
this.dynamoDbJsonHandler = dynamoDbJsonHandler;
+ this.sqsJsonHandler = sqsJsonHandler;
this.objectMapper = objectMapper;
this.jsonataEvaluator = jsonataEvaluator;
this.sfnService = sfnService;
@@ -341,6 +345,18 @@ public class AslExecutor {
return invokeAwsSdkDynamoDb(camelCaseAction, input, region);
}
+ // SQS optimized integration
+ if (resource.equals("arn:aws:states:::sqs:sendMessage")) {
+ String region = extractRegionFromArn(sm.getStateMachineArn());
+ return invokeOptimizedSqsSendMessage(input, region);
+ }
+
+ // AWS SDK service integration: SQS SendMessage
+ if (resource.equals("arn:aws:states:::aws-sdk:sqs:sendMessage")) {
+ String region = extractRegionFromArn(sm.getStateMachineArn());
+ return invokeAwsSdkSqsSendMessage(input, region);
+ }
+
// Nested state machine integration
if (resource.startsWith("arn:aws:states:::states:startExecution")) {
String mode = resource.substring("arn:aws:states:::states:startExecution".length());
@@ -558,6 +574,82 @@ public class AslExecutor {
return objectMapper.createObjectNode();
}
+ private JsonNode invokeOptimizedSqsSendMessage(JsonNode input, String region) {
+ ObjectNode request = normalizeSqsSendMessageInput(input);
+ return invokeSqsAction("SendMessage", request, region, "SQS.");
+ }
+
+ private JsonNode invokeAwsSdkSqsSendMessage(JsonNode input, String region) {
+ return invokeSqsAction("SendMessage", normalizeSqsSendMessageInput(input), region, "Sqs.", true);
+ }
+
+ private ObjectNode normalizeSqsSendMessageInput(JsonNode input) {
+ ObjectNode request = input != null && input.isObject()
+ ? ((ObjectNode) input.deepCopy())
+ : objectMapper.createObjectNode();
+
+ JsonNode messageBody = request.get("MessageBody");
+ if (messageBody != null && !messageBody.isTextual() && !messageBody.isNull()) {
+ request.put("MessageBody", messageBody.toString());
+ }
+ return request;
+ }
+
+ private JsonNode invokeSqsAction(String action, JsonNode input, String region, String errorPrefix) {
+ return invokeSqsAction(action, input, region, errorPrefix, false);
+ }
+
+ private JsonNode invokeSqsAction(String action, JsonNode input, String region, String errorPrefix, boolean awsSdkStyleErrors) {
+ jakarta.ws.rs.core.Response response;
+ try {
+ response = sqsJsonHandler.handle(action, input, region);
+ } catch (AwsException e) {
+ throw new FailStateException(errorPrefix + normalizeSqsErrorCode(e.getErrorCode(), awsSdkStyleErrors), e.getMessage());
+ } catch (Exception e) {
+ throw new FailStateException(errorPrefix + "InternalServerError",
+ e.getMessage() != null ? e.getMessage() : "SQS error");
+ }
+
+ Object entity = response.getEntity();
+ int status = response.getStatus();
+
+ if (status >= 400) {
+ if (entity instanceof AwsErrorResponse err) {
+ throw new FailStateException(errorPrefix + normalizeSqsErrorCode(err.type(), awsSdkStyleErrors), err.message());
+ }
+ if (entity instanceof JsonNode errorNode) {
+ String errorName = normalizeSqsErrorCode(errorNode.path("__type").asText("UnknownError"), awsSdkStyleErrors);
+ String errorMessage = errorNode.path("message").asText(
+ errorNode.path("Message").asText("SQS operation failed"));
+ throw new FailStateException(errorPrefix + errorName, errorMessage);
+ }
+ throw new FailStateException(errorPrefix + "ServiceException", "SQS operation failed");
+ }
+
+ if (entity instanceof JsonNode jsonNode) {
+ return jsonNode;
+ }
+ return objectMapper.createObjectNode();
+ }
+
+ private String normalizeSqsErrorCode(String errorCode, boolean awsSdkStyleErrors) {
+ if (!awsSdkStyleErrors || errorCode == null || errorCode.isBlank()) {
+ return errorCode;
+ }
+ return switch (errorCode) {
+ case "AWS.SimpleQueueService.NonExistentQueue" -> "QueueDoesNotExistException";
+ case "UnsupportedOperation" -> "UnsupportedOperationException";
+ case "ReceiptHandleIsInvalid" -> "ReceiptHandleIsInvalidException";
+ case "QueueAlreadyExists" -> "QueueNameExistsException";
+ case "InvalidAddress" -> "InvalidAddressException";
+ case "InvalidSecurity" -> "InvalidSecurityException";
+ case "InvalidMessageContents" -> "InvalidMessageContentsException";
+ case "OverLimit" -> "OverLimitException";
+ case "RequestThrottled" -> "RequestThrottledException";
+ default -> errorCode;
+ };
+ }
+
private StateResult executeChoiceState(JsonNode stateDef, JsonNode input, boolean jsonata, JsonNode context) throws Exception {
if (jsonata) {
JsonNode statesVar = buildStatesVar(input, null, context);
diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsSqsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsSqsIntegrationTest.java
new file mode 100644
index 0000000000..68be3dbae2
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsSqsIntegrationTest.java
@@ -0,0 +1,341 @@
+package io.github.hectorvent.floci.services.stepfunctions;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.response.Response;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+
+import static io.restassured.RestAssured.given;
+import static org.junit.jupiter.api.Assertions.*;
+
+@QuarkusTest
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+class StepFunctionsSqsIntegrationTest {
+
+ private static final String SFN_CONTENT_TYPE = "application/x-amz-json-1.0";
+ private static final String SQS_CONTENT_TYPE = "application/x-amz-json-1.0";
+ private static final String ROLE_ARN = "arn:aws:iam::000000000000:role/test-role";
+ private static final ObjectMapper mapper = new ObjectMapper();
+
+ private static String queueUrl;
+ private static String callbackQueueUrl;
+
+ @BeforeAll
+ static void configureRestAssured() {
+ RestAssuredJsonUtils.configureAwsContentTypes();
+ }
+
+ @Test
+ @Order(0)
+ void setup_createQueues() {
+ queueUrl = createQueue("sfn-sqs-integration-queue");
+ callbackQueueUrl = createQueue("sfn-sqs-callback-queue");
+ }
+
+ @Test
+ @Order(1)
+ void optimized_sendMessage() throws Exception {
+ String output = executeSfn("optimized-send", "arn:aws:states:::sqs:sendMessage", """
+ {
+ "QueueUrl": "%s",
+ "MessageBody": "hello optimized"
+ }
+ """.formatted(queueUrl));
+
+ JsonNode result = mapper.readTree(output);
+ assertTrue(result.has("MessageId"));
+ assertTrue(result.has("MD5OfMessageBody"));
+
+ JsonNode message = receiveSingleMessage(queueUrl);
+ assertEquals("hello optimized", message.path("Body").asText());
+ deleteMessage(queueUrl, message.path("ReceiptHandle").asText());
+ }
+
+ @Test
+ @Order(2)
+ void awsSdk_sendMessage() throws Exception {
+ String output = executeSfn("aws-sdk-send", "arn:aws:states:::aws-sdk:sqs:sendMessage", """
+ {
+ "QueueUrl": "%s",
+ "MessageBody": "hello aws-sdk"
+ }
+ """.formatted(queueUrl));
+
+ JsonNode result = mapper.readTree(output);
+ assertTrue(result.has("MessageId"));
+ assertTrue(result.has("MD5OfMessageBody"));
+
+ JsonNode message = receiveSingleMessage(queueUrl);
+ assertEquals("hello aws-sdk", message.path("Body").asText());
+ deleteMessage(queueUrl, message.path("ReceiptHandle").asText());
+ }
+
+ @Test
+ @Order(3)
+ void optimized_waitForTaskToken_serializesMessageBodyObject() throws Exception {
+ String definition = buildStateMachineDefinition("arn:aws:states:::sqs:sendMessage.waitForTaskToken", """
+ {
+ "QueueUrl": "%s",
+ "MessageBody": {
+ "Message": "callback requested",
+ "TaskToken.$": "$$.Task.Token"
+ }
+ }
+ """.formatted(callbackQueueUrl));
+
+ String smArn = createStateMachine("optimized-wait-token-" + System.currentTimeMillis(), definition);
+ String execArn = startExecution(smArn, "{}");
+
+ JsonNode message = receiveSingleMessage(callbackQueueUrl);
+ JsonNode body = mapper.readTree(message.path("Body").asText());
+ assertEquals("callback requested", body.path("Message").asText());
+ String taskToken = body.path("TaskToken").asText();
+ assertFalse(taskToken.isBlank());
+
+ sendTaskSuccess(taskToken, "{\"delivered\":true}");
+ String output = waitForExecution(execArn);
+ assertTrue(mapper.readTree(output).path("delivered").asBoolean());
+
+ deleteMessage(callbackQueueUrl, message.path("ReceiptHandle").asText());
+ }
+
+ @Test
+ @Order(4)
+ void awsSdk_waitForTaskToken_serializesMessageBodyObject() throws Exception {
+ String definition = buildStateMachineDefinition("arn:aws:states:::aws-sdk:sqs:sendMessage.waitForTaskToken", """
+ {
+ "QueueUrl": "%s",
+ "MessageBody": {
+ "Message": "aws sdk callback requested",
+ "TaskToken.$": "$$.Task.Token"
+ }
+ }
+ """.formatted(callbackQueueUrl));
+
+ String smArn = createStateMachine("aws-sdk-wait-token-" + System.currentTimeMillis(), definition);
+ String execArn = startExecution(smArn, "{}");
+
+ JsonNode message = receiveSingleMessage(callbackQueueUrl);
+ JsonNode body = mapper.readTree(message.path("Body").asText());
+ assertEquals("aws sdk callback requested", body.path("Message").asText());
+ String taskToken = body.path("TaskToken").asText();
+ assertFalse(taskToken.isBlank());
+
+ sendTaskSuccess(taskToken, "{\"delivered\":true}");
+ String output = waitForExecution(execArn);
+ assertTrue(mapper.readTree(output).path("delivered").asBoolean());
+
+ deleteMessage(callbackQueueUrl, message.path("ReceiptHandle").asText());
+ }
+
+ @Test
+ @Order(5)
+ void awsSdk_nonExistentQueue_fails_withSdkStyleErrorName() throws Exception {
+ String definition = buildStateMachineDefinition("arn:aws:states:::aws-sdk:sqs:sendMessage", """
+ {
+ "QueueUrl": "http://localhost:4566/000000000000/does-not-exist",
+ "MessageBody": "noop"
+ }
+ """);
+
+ String smArn = createStateMachine("aws-sdk-sqs-missing-queue-" + System.currentTimeMillis(), definition);
+ String execArn = startExecution(smArn, "{}");
+ Response failed = waitForFailedExecution(execArn);
+ assertEquals("Sqs.QueueDoesNotExistException", failed.jsonPath().getString("error"));
+ }
+
+ @Test
+ @Order(6)
+ void cleanup_deleteQueues() {
+ deleteQueue(queueUrl);
+ deleteQueue(callbackQueueUrl);
+ }
+
+ private static String createQueue(String queueName) {
+ Response resp = given()
+ .header("X-Amz-Target", "AmazonSQS.CreateQueue")
+ .contentType(SQS_CONTENT_TYPE)
+ .body("""
+ {"QueueName":"%s"}
+ """.formatted(queueName))
+ .when()
+ .post("/");
+ resp.then().statusCode(200);
+ return resp.jsonPath().getString("QueueUrl");
+ }
+
+ private JsonNode receiveSingleMessage(String queue) throws Exception {
+ Response resp = given()
+ .header("X-Amz-Target", "AmazonSQS.ReceiveMessage")
+ .contentType(SQS_CONTENT_TYPE)
+ .body("""
+ {"QueueUrl":"%s","MaxNumberOfMessages":1,"WaitTimeSeconds":1}
+ """.formatted(queue))
+ .when()
+ .post("/");
+ resp.then().statusCode(200);
+ JsonNode messages = mapper.readTree(resp.body().asString()).path("Messages");
+ assertEquals(1, messages.size(), "Expected one message");
+ return messages.get(0);
+ }
+
+ private static void deleteMessage(String queue, String receiptHandle) {
+ given()
+ .header("X-Amz-Target", "AmazonSQS.DeleteMessage")
+ .contentType(SQS_CONTENT_TYPE)
+ .body("""
+ {"QueueUrl":"%s","ReceiptHandle":"%s"}
+ """.formatted(queue, receiptHandle))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ private static void deleteQueue(String queue) {
+ if (queue == null) {
+ return;
+ }
+ given()
+ .header("X-Amz-Target", "AmazonSQS.DeleteQueue")
+ .contentType(SQS_CONTENT_TYPE)
+ .body("""
+ {"QueueUrl":"%s"}
+ """.formatted(queue))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ private String executeSfn(String nameSuffix, String resource, String parameters) throws Exception {
+ String definition = buildStateMachineDefinition(resource, parameters);
+ String smArn = createStateMachine(nameSuffix + "-" + System.currentTimeMillis(), definition);
+ String execArn = startExecution(smArn, "{}");
+ return waitForExecution(execArn);
+ }
+
+ private String buildStateMachineDefinition(String resource, String parameters) {
+ return """
+ {
+ "StartAt": "Action",
+ "States": {
+ "Action": {
+ "Type": "Task",
+ "Resource": "%s",
+ "Parameters": %s,
+ "End": true
+ }
+ }
+ }
+ """.formatted(resource, parameters.strip());
+ }
+
+ private String createStateMachine(String name, String definition) {
+ Response resp = given()
+ .header("X-Amz-Target", "AWSStepFunctions.CreateStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("""
+ {
+ "name": "%s",
+ "definition": %s,
+ "roleArn": "%s"
+ }
+ """.formatted(name, quote(definition), ROLE_ARN))
+ .when()
+ .post("/");
+ resp.then().statusCode(200);
+ return resp.jsonPath().getString("stateMachineArn");
+ }
+
+ private String startExecution(String smArn, String input) {
+ Response resp = given()
+ .header("X-Amz-Target", "AWSStepFunctions.StartExecution")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("""
+ {
+ "stateMachineArn": "%s",
+ "input": %s
+ }
+ """.formatted(smArn, quote(input)))
+ .when()
+ .post("/");
+ resp.then().statusCode(200);
+ return resp.jsonPath().getString("executionArn");
+ }
+
+ private void sendTaskSuccess(String taskToken, String output) {
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.SendTaskSuccess")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("""
+ {
+ "taskToken": %s,
+ "output": %s
+ }
+ """.formatted(quote(taskToken), quote(output)))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ private String waitForExecution(String execArn) throws InterruptedException {
+ for (int i = 0; i < 50; i++) {
+ Response resp = describeExecution(execArn);
+ String status = resp.jsonPath().getString("status");
+ if ("SUCCEEDED".equals(status)) {
+ return resp.jsonPath().getString("output");
+ }
+ if ("FAILED".equals(status) || "ABORTED".equals(status)) {
+ fail("Execution " + status + ": " + resp.body().asString());
+ }
+ Thread.sleep(100);
+ }
+ fail("Execution did not complete within timeout");
+ return null;
+ }
+
+ private Response waitForFailedExecution(String execArn) throws InterruptedException {
+ for (int i = 0; i < 50; i++) {
+ Response resp = describeExecution(execArn);
+ String status = resp.jsonPath().getString("status");
+ if ("FAILED".equals(status)) {
+ return resp;
+ }
+ if ("SUCCEEDED".equals(status)) {
+ fail("Execution should have failed but succeeded: " + resp.body().asString());
+ }
+ Thread.sleep(100);
+ }
+ fail("Execution did not complete within timeout");
+ return null;
+ }
+
+ private Response describeExecution(String execArn) {
+ return given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeExecution")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("""
+ {"executionArn": "%s"}
+ """.formatted(execArn))
+ .when()
+ .post("/");
+ }
+
+ private static String quote(String raw) {
+ return "\"" + raw
+ .replace("\\", "\\\\")
+ .replace("\"", "\\\"")
+ .replace("\n", "\\n")
+ .replace("\r", "\\r")
+ .replace("\t", "\\t")
+ + "\"";
+ }
+}