Skip to content

armgit / floci

Public Imported from GitHub
0

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

fix(iot): isolate topic rule actions and run the error action (#3012)

Mario Toffia7ec4c89d0f84
diff --git a/docs/services/iot.md b/docs/services/iot.md
index dc2f61906d..de9c3b95ea 100644
--- a/docs/services/iot.md
+++ b/docs/services/iot.md
@@ -21,7 +21,7 @@ Current MVP 1 limitations:
- Certificate CSR handling creates emulator-local certificates; it does not perform real CA signing.
- MQTT auth remains permissive; certificate and policy resources are modeled for provisioning compatibility, not enforced as broker authorization yet.
-- Rules support basic topic filter extraction and action dispatch only; SQL projection, WHERE evaluation, substitutions, and error actions remain follow-up scope.
+- Rules support basic topic filter extraction and action dispatch only; SQL projection, WHERE evaluation, and substitutions remain follow-up scope.
## MVP 2 Coverage
@@ -148,13 +148,15 @@ Supported rule behavior:
- `sqs` action sends the original payload to an SQS queue through Floci's SQS service boundary.
- `sns` action publishes the original payload to an SNS topic through Floci's SNS service boundary.
- `s3` action writes the original payload to the configured bucket/key through Floci's S3 service boundary.
-- `dynamoDBv2` action writes JSON object payload fields as DynamoDB attribute values through Floci's DynamoDB service boundary.
+- `dynamoDBv2` action writes JSON object payload fields as DynamoDB attribute values through Floci's DynamoDB service boundary; nested objects and arrays become maps and lists.
- `kinesis` action puts the original payload into a Kinesis stream through Floci's Kinesis service boundary.
- `lambda` action invokes the configured function ARN through Floci's Lambda service boundary.
+- One failing action never fails the publish or the other actions of the rule. The failure is logged, and once every action ran the rule's `errorAction` receives the AWS failure document: `ruleName`, `topic`, `base64OriginalPayload` and `failures` with `failedAction`, `failedResource` and `errorMessage` per failed action.
+- `GetTopicRule` returns `awsIotSqlVersion` and `errorAction` as they were given to `CreateTopicRule` or `ReplaceTopicRule`.
Current limitations:
-- SQL projection, WHERE clauses, functions, substitutions, error actions, and less common AWS IoT rule action types are follow-up scope.
+- SQL projection, WHERE clauses, functions, substitutions, and less common AWS IoT rule action types are follow-up scope.
Open follow-up scope for phase 7 unless explicitly deferred:
diff --git a/src/main/java/io/github/hectorvent/floci/services/iot/IotController.java b/src/main/java/io/github/hectorvent/floci/services/iot/IotController.java
index ec33b40fe5..58329e1e2f 100644
--- a/src/main/java/io/github/hectorvent/floci/services/iot/IotController.java
+++ b/src/main/java/io/github/hectorvent/floci/services/iot/IotController.java
@@ -31,6 +31,7 @@ import jakarta.ws.rs.core.Context;
import jakarta.ws.rs.core.HttpHeaders;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
+import org.jboss.logging.Logger;
import java.time.Instant;
import java.util.ArrayList;
@@ -43,6 +44,8 @@ import java.util.Map;
@Consumes(MediaType.APPLICATION_JSON)
public class IotController {
+ private static final Logger LOG = Logger.getLogger(IotController.class);
+
private final IotService iotService;
private final IotTagHandler iotTagHandler;
private final RegionResolver regionResolver;
@@ -1119,6 +1122,16 @@ public class IotController {
} catch (JsonProcessingException e) {
response.putArray("actions");
}
+ if (rule.getAwsIotSqlVersion() != null) {
+ response.put("awsIotSqlVersion", rule.getAwsIotSqlVersion());
+ }
+ if (rule.getErrorActionJson() != null) {
+ try {
+ response.set("errorAction", objectMapper.readTree(rule.getErrorActionJson()));
+ } catch (JsonProcessingException e) {
+ LOG.warnv(e, "Stored error action of topic rule {0} is not JSON", rule.getRuleName());
+ }
+ }
return response;
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/iot/IotService.java b/src/main/java/io/github/hectorvent/floci/services/iot/IotService.java
index c7ccd7db5a..d1ae8b156f 100644
--- a/src/main/java/io/github/hectorvent/floci/services/iot/IotService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/iot/IotService.java
@@ -1,8 +1,10 @@
package io.github.hectorvent.floci.services.iot;
+import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import io.github.hectorvent.floci.config.EmulatorConfig;
import io.github.hectorvent.floci.core.common.AwsArnUtils;
@@ -29,13 +31,16 @@ import io.github.hectorvent.floci.services.sns.SnsService;
import io.github.hectorvent.floci.services.sqs.SqsService;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
+import org.jboss.logging.Logger;
import java.net.URI;
import java.nio.charset.StandardCharsets;
import java.time.Instant;
+import java.util.ArrayList;
import java.util.Base64;
import java.util.Comparator;
import java.util.HashSet;
+import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
@@ -48,6 +53,8 @@ import java.util.regex.Pattern;
@ApplicationScoped
public class IotService {
+ private static final Logger LOG = Logger.getLogger(IotService.class);
+
static final String DEFAULT_ENDPOINT_TYPE = "iot:Data-ATS";
private static final Pattern THING_NAME_PATTERN = Pattern.compile("[a-zA-Z0-9:_-]{1,128}");
@@ -861,6 +868,9 @@ public class IotService {
rule.setRuleDisabled(payload.path("ruleDisabled").asBoolean(false));
JsonNode actions = payload.path("actions");
rule.setActionsJson(actions.isArray() ? actions.toString() : "[]");
+ rule.setAwsIotSqlVersion(payload.path("awsIotSqlVersion").asText(null));
+ JsonNode errorAction = payload.path("errorAction");
+ rule.setErrorActionJson(errorAction.isObject() ? errorAction.toString() : null);
rule.setCreatedAt(createdAt == null ? Instant.now() : createdAt);
topicRuleStore.put(topicRuleKey(region, ruleName), rule);
return rule;
@@ -897,7 +907,7 @@ public class IotService {
}
for (IotTopicRule rule : rulesForPublish(region)) {
if (!rule.isRuleDisabled() && topicMatches(extractTopicPattern(rule.getSql()), topic)) {
- executeTopicRule(rule, eventPayload);
+ executeTopicRule(rule, topic, eventPayload);
}
}
}
@@ -999,75 +1009,154 @@ public class IotService {
}
}
- private void executeTopicRule(IotTopicRule rule, byte[] payload) {
+ /**
+ * Runs the actions of a matching rule. One failing action never fails the publish or the actions
+ * after it, as on AWS: the failure is logged, and once every action ran the rule's error action,
+ * if it has one, receives the failure document listing every action that failed.
+ */
+ private void executeTopicRule(IotTopicRule rule, String topic, byte[] payload) {
String ruleRegion = AwsArnUtils.regionOrDefault(rule.getRuleArn(), config.defaultRegion());
+ List<ObjectNode> failures = new ArrayList<>();
+ for (JsonNode action : storedJson(rule.getRuleName(), rule.getActionsJson())) {
+ String type = actionType(action);
+ if (type == null) {
+ LOG.warnv("Topic rule {0} has an action without a type, skipping it: {1}", rule.getRuleName(), action);
+ continue;
+ }
+ JsonNode config = action.get(type);
+ try {
+ runAction(type, config, payload, ruleRegion);
+ } catch (RuntimeException e) {
+ LOG.warnv(e, "Action {0} of topic rule {1} failed", type, rule.getRuleName());
+ failures.add(failure(type, config, e));
+ }
+ }
+ if (failures.isEmpty() || rule.getErrorActionJson() == null) {
+ return;
+ }
+ JsonNode errorAction = storedJson(rule.getRuleName(), rule.getErrorActionJson());
+ String type = actionType(errorAction);
+ if (type == null) {
+ LOG.warnv("Topic rule {0} has an error action without a type, skipping it", rule.getRuleName());
+ return;
+ }
+ try {
+ runAction(type, errorAction.get(type), failureDocument(rule, topic, payload, failures), ruleRegion);
+ } catch (RuntimeException e) {
+ LOG.warnv(e, "Error action {0} of topic rule {1} failed", type, rule.getRuleName());
+ }
+ }
+
+ private JsonNode storedJson(String ruleName, String json) {
try {
- JsonNode actions = objectMapper.readTree(rule.getActionsJson());
- if (!actions.isArray()) {
- return;
+ return objectMapper.readTree(json);
+ } catch (JsonProcessingException e) {
+ LOG.warnv(e, "Stored actions of topic rule {0} are not JSON and were skipped", ruleName);
+ return objectMapper.createArrayNode();
+ }
+ }
+
+ /** The one member an action object carries, naming its kind, or null when it carries none. */
+ private static String actionType(JsonNode action) {
+ if (action == null || !action.isObject()) {
+ return null;
+ }
+ Iterator<Map.Entry<String, JsonNode>> fields = action.fields();
+ while (fields.hasNext()) {
+ Map.Entry<String, JsonNode> field = fields.next();
+ if (field.getValue().isObject()) {
+ return field.getKey();
}
- for (JsonNode action : actions) {
- JsonNode republish = action.path("republish");
- if (republish.isObject()) {
- String targetTopic = republish.path("topic").asText(null);
- if (targetTopic != null && !targetTopic.isBlank()) {
- handlePublish(targetTopic, payload, false, ruleRegion);
- mqttBrokerService.publish(targetTopic, payload);
- }
+ }
+ return null;
+ }
+
+ private void runAction(String type, JsonNode action, byte[] payload, String region) {
+ switch (type) {
+ case "republish" -> {
+ String targetTopic = action.path("topic").asText(null);
+ if (targetTopic != null && !targetTopic.isBlank()) {
+ handlePublish(targetTopic, payload, false, region);
+ mqttBrokerService.publish(targetTopic, payload);
}
- JsonNode sqs = action.path("sqs");
- if (sqs.isObject()) {
- String queueUrl = sqs.path("queueUrl").asText(null);
- if (queueUrl != null && !queueUrl.isBlank()) {
- String body = sqs.path("useBase64").asBoolean(false)
- ? Base64.getEncoder().encodeToString(payload)
- : new String(payload, StandardCharsets.UTF_8);
- sqsService.sendMessage(queueUrl, body, 0, ruleRegion);
- }
+ }
+ case "sqs" -> {
+ String queueUrl = action.path("queueUrl").asText(null);
+ if (queueUrl != null && !queueUrl.isBlank()) {
+ String body = action.path("useBase64").asBoolean(false)
+ ? Base64.getEncoder().encodeToString(payload)
+ : new String(payload, StandardCharsets.UTF_8);
+ sqsService.sendMessage(queueUrl, body, 0, region);
}
- JsonNode sns = action.path("sns");
- if (sns.isObject()) {
- String targetArn = sns.path("targetArn").asText(null);
- if (targetArn != null && !targetArn.isBlank()) {
- snsService.publish(targetArn, null, new String(payload, StandardCharsets.UTF_8), null, ruleRegion);
- }
+ }
+ case "sns" -> {
+ String targetArn = action.path("targetArn").asText(null);
+ if (targetArn != null && !targetArn.isBlank()) {
+ snsService.publish(targetArn, null, new String(payload, StandardCharsets.UTF_8), null, region);
}
- JsonNode s3 = action.path("s3");
- if (s3.isObject()) {
- String bucketName = s3.path("bucketName").asText(null);
- String key = s3.path("key").asText(null);
- if (bucketName != null && !bucketName.isBlank() && key != null && !key.isBlank()) {
- s3Service.putObject(bucketName, key, payload, "application/octet-stream", Map.of());
- }
+ }
+ case "s3" -> {
+ String bucketName = action.path("bucketName").asText(null);
+ String key = action.path("key").asText(null);
+ if (bucketName != null && !bucketName.isBlank() && key != null && !key.isBlank()) {
+ s3Service.putObject(bucketName, key, payload, "application/octet-stream", Map.of());
}
- JsonNode kinesis = action.path("kinesis");
- if (kinesis.isObject()) {
- String streamName = kinesis.path("streamName").asText(null);
- String partitionKey = kinesis.path("partitionKey").asText("floci-iot");
- if (streamName != null && !streamName.isBlank()) {
- kinesisService.putRecord(streamName, payload, partitionKey, ruleRegion);
- }
+ }
+ case "kinesis" -> {
+ String streamName = action.path("streamName").asText(null);
+ String partitionKey = action.path("partitionKey").asText("floci-iot");
+ if (streamName != null && !streamName.isBlank()) {
+ kinesisService.putRecord(streamName, payload, partitionKey, region);
}
- JsonNode dynamoDBv2 = action.path("dynamoDBv2");
- if (dynamoDBv2.isObject()) {
- String tableName = dynamoDBv2.path("putItem").path("tableName").asText(null);
- if (tableName != null && !tableName.isBlank()) {
- dynamoDbService.putItem(tableName, toDynamoDbItem(payload), ruleRegion);
- }
+ }
+ case "dynamoDBv2" -> {
+ String tableName = action.path("putItem").path("tableName").asText(null);
+ if (tableName != null && !tableName.isBlank()) {
+ dynamoDbService.putItem(tableName, toDynamoDbItem(payload), region);
}
- JsonNode lambda = action.path("lambda");
- if (lambda.isObject()) {
- String functionArn = lambda.path("functionArn").asText(null);
- if (functionArn != null && !functionArn.isBlank()) {
- lambdaService.invoke(ruleRegion, functionArn, payload, InvocationType.Event);
- }
+ }
+ case "lambda" -> {
+ String functionArn = action.path("functionArn").asText(null);
+ if (functionArn != null && !functionArn.isBlank()) {
+ lambdaService.invoke(region, functionArn, payload, InvocationType.Event);
}
}
- } catch (Exception e) {
- throw new AwsException("InvalidRequestException", "Invalid topic rule action for " + rule.getRuleName() + ": " + e.getMessage(), 400);
+ default -> LOG.debugv("Topic rule action {0} is not supported and was skipped", type);
}
}
+ /** One entry of the failure document: the action kind and target as AWS names them. */
+ private ObjectNode failure(String type, JsonNode action, RuntimeException e) {
+ ObjectNode failure = objectMapper.createObjectNode();
+ failure.put("failedAction", Character.toUpperCase(type.charAt(0)) + type.substring(1) + "Action");
+ failure.put("failedResource", targetOf(type, action));
+ failure.put("errorMessage", e.getMessage() == null ? e.toString() : e.getMessage());
+ return failure;
+ }
+
+ private static String targetOf(String type, JsonNode action) {
+ return switch (type) {
+ case "republish" -> action.path("topic").asText("");
+ case "sqs" -> action.path("queueUrl").asText("");
+ case "sns" -> action.path("targetArn").asText("");
+ case "s3" -> action.path("bucketName").asText("");
+ case "kinesis" -> action.path("streamName").asText("");
+ case "dynamoDBv2" -> action.path("putItem").path("tableName").asText("");
+ case "lambda" -> action.path("functionArn").asText("");
+ default -> "";
+ };
+ }
+
+ private byte[] failureDocument(IotTopicRule rule, String topic, byte[] payload, List<ObjectNode> failures) {
+ ObjectNode document = objectMapper.createObjectNode();
+ document.put("ruleName", rule.getRuleName());
+ document.put("topic", topic);
+ document.put("base64OriginalPayload", Base64.getEncoder().encodeToString(payload));
+ ArrayNode list = document.putArray("failures");
+ failures.forEach(list::add);
+ return document.toString().getBytes(StandardCharsets.UTF_8);
+ }
+
private ObjectNode toDynamoDbItem(byte[] payload) {
try {
JsonNode document = objectMapper.readTree(payload);
@@ -1084,6 +1173,7 @@ public class IotService {
}
}
+ /** A JSON value as a DynamoDB attribute value; objects and arrays become maps and lists, as on AWS. */
private ObjectNode toDynamoDbAttribute(JsonNode value) {
ObjectNode attribute = objectMapper.createObjectNode();
if (value == null || value.isNull()) {
@@ -1092,6 +1182,12 @@ public class IotService {
attribute.put("BOOL", value.asBoolean());
} else if (value.isNumber()) {
attribute.put("N", value.asText());
+ } else if (value.isObject()) {
+ ObjectNode map = attribute.putObject("M");
+ value.fields().forEachRemaining(entry -> map.set(entry.getKey(), toDynamoDbAttribute(entry.getValue())));
+ } else if (value.isArray()) {
+ ArrayNode list = attribute.putArray("L");
+ value.forEach(element -> list.add(toDynamoDbAttribute(element)));
} else {
attribute.put("S", value.asText());
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/iot/model/IotTopicRule.java b/src/main/java/io/github/hectorvent/floci/services/iot/model/IotTopicRule.java
index a71527d849..353b4a45d7 100644
--- a/src/main/java/io/github/hectorvent/floci/services/iot/model/IotTopicRule.java
+++ b/src/main/java/io/github/hectorvent/floci/services/iot/model/IotTopicRule.java
@@ -14,6 +14,8 @@ public class IotTopicRule {
private String description;
private boolean ruleDisabled;
private String actionsJson = "[]";
+ private String awsIotSqlVersion;
+ private String errorActionJson;
private Instant createdAt;
private Map<String, String> tags = new TreeMap<>();
@@ -65,6 +67,22 @@ public class IotTopicRule {
this.actionsJson = actionsJson;
}
+ public String getAwsIotSqlVersion() {
+ return awsIotSqlVersion;
+ }
+
+ public void setAwsIotSqlVersion(String awsIotSqlVersion) {
+ this.awsIotSqlVersion = awsIotSqlVersion;
+ }
+
+ public String getErrorActionJson() {
+ return errorActionJson;
+ }
+
+ public void setErrorActionJson(String errorActionJson) {
+ this.errorActionJson = errorActionJson;
+ }
+
public Instant getCreatedAt() {
return createdAt;
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/iot/IotServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/iot/IotServiceTest.java
new file mode 100644
index 0000000000..86f776fa38
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/iot/IotServiceTest.java
@@ -0,0 +1,302 @@
+package io.github.hectorvent.floci.services.iot;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.github.hectorvent.floci.config.EmulatorConfig;
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.common.RegionResolver;
+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;
+import io.github.hectorvent.floci.services.dynamodb.DynamoDbService;
+import io.github.hectorvent.floci.services.iot.model.IotTopicRule;
+import io.github.hectorvent.floci.services.kinesis.KinesisService;
+import io.github.hectorvent.floci.services.lambda.LambdaService;
+import io.github.hectorvent.floci.services.lambda.model.InvocationType;
+import io.github.hectorvent.floci.services.s3.S3Service;
+import io.github.hectorvent.floci.services.sns.SnsService;
+import io.github.hectorvent.floci.services.sqs.SqsService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * Rules engine behaviour of {@link IotService} with in-memory stores and mocked action targets:
+ * one failing action never fails the publish or the other actions, and the error action receives
+ * the failure document.
+ */
+class IotServiceTest {
+
+ private static final String REGION = "us-east-1";
+ private static final String ACCOUNT = "000000000000";
+ private static final String TOPIC = "devices/d1/metrics";
+ private static final String QUEUE_URL = "http://localhost:4566/000000000000/metrics";
+ private static final String FUNCTION_ARN = "arn:aws:lambda:us-east-1:000000000000:function:handler";
+ private static final String ERROR_FUNCTION_ARN = "arn:aws:lambda:us-east-1:000000000000:function:errors";
+
+ private final ObjectMapper mapper = new ObjectMapper();
+ private final SqsService sqs = mock(SqsService.class);
+ private final LambdaService lambda = mock(LambdaService.class);
+ private final DynamoDbService dynamoDb = mock(DynamoDbService.class);
+ private IotService service;
+
+ @BeforeEach
+ void setUp() {
+ EmulatorConfig config = mock(EmulatorConfig.class);
+ when(config.defaultRegion()).thenReturn(REGION);
+ service = new IotService(
+ AccountAwareStorageBackend.inMemory(ACCOUNT),
+ AccountAwareStorageBackend.inMemory(ACCOUNT),
+ AccountAwareStorageBackend.inMemory(ACCOUNT),
+ AccountAwareStorageBackend.inMemory(ACCOUNT),
+ AccountAwareStorageBackend.inMemory(ACCOUNT),
+ AccountAwareStorageBackend.inMemory(ACCOUNT),
+ AccountAwareStorageBackend.inMemory(ACCOUNT),
+ AccountAwareStorageBackend.inMemory(ACCOUNT),
+ AccountAwareStorageBackend.inMemory(ACCOUNT),
+ AccountAwareStorageBackend.inMemory(ACCOUNT),
+ AccountAwareStorageBackend.inMemory(ACCOUNT),
+ AccountAwareStorageBackend.inMemory(ACCOUNT),
+ AccountAwareStorageBackend.inMemory(ACCOUNT),
+ config,
+ new RegionResolver(REGION, ACCOUNT),
+ mapper,
+ new IotPublishEventRecorder(),
+ mock(IotMqttBrokerService.class),
+ sqs,
+ mock(SnsService.class),
+ mock(S3Service.class),
+ mock(KinesisService.class),
+ dynamoDb,
+ lambda);
+ }
+
+ private IotTopicRule createRule(String name, String payloadJson) throws Exception {
+ return service.createTopicRule(name, mapper.readTree(payloadJson), REGION);
+ }
+
+ /** A rule whose SQS action targets a queue that does not exist and whose Lambda action works. */
+ private static String sqsThenLambdaRule(String errorActionJson) {
+ String errorAction = errorActionJson == null ? "" : ", \"errorAction\": " + errorActionJson;
+ return """
+ {
+ "sql": "SELECT * FROM 'devices/+/metrics'",
+ "actions": [
+ {"sqs": {"queueUrl": "%s", "roleArn": "arn:aws:iam::000000000000:role/rule"}},
+ {"lambda": {"functionArn": "%s"}}
+ ]%s
+ }
+ """.formatted(QUEUE_URL, FUNCTION_ARN, errorAction);
+ }
+
+ private static String lambdaErrorAction() {
+ return "{\"lambda\": {\"functionArn\": \"" + ERROR_FUNCTION_ARN + "\"}}";
+ }
+
+ private void queueIsMissing() {
+ when(sqs.sendMessage(eq(QUEUE_URL), anyString(), anyInt(), anyString()))
+ .thenThrow(new AwsException("AWS.SimpleQueueService.NonExistentQueue",
+ "The specified queue does not exist for this wsdl version.", 400));
+ }
+
+ private void publish(String payload) {
+ service.handlePublish(TOPIC, payload.getBytes(StandardCharsets.UTF_8), true, REGION);
+ }
+
+ private JsonNode capturedInvocationPayload(String functionArn) throws Exception {
+ ArgumentCaptor<byte[]> payload = ArgumentCaptor.forClass(byte[].class);
+ verify(lambda).invoke(eq(REGION), eq(functionArn), payload.capture(), eq(InvocationType.Event));
+ return mapper.readTree(payload.getValue());
+ }
+
+ @Test
+ void aFailingActionDoesNotFailThePublishOrStopTheOtherActions() throws Exception {
+ createRule("metricsRule", sqsThenLambdaRule(null));
+ queueIsMissing();
+
+ assertDoesNotThrow(() -> publish("{\"v\":1}"));
+
+ assertEquals("{\"v\":1}", capturedInvocationPayload(FUNCTION_ARN).toString());
+ }
+
+ @Test
+ void theErrorActionReceivesTheFailureDocumentWhenAnActionFails() throws Exception {
+ createRule("metricsRule", sqsThenLambdaRule(lambdaErrorAction()));
+ queueIsMissing();
+
+ publish("{\"v\":1}");
+
+ JsonNode document = capturedInvocationPayload(ERROR_FUNCTION_ARN);
+ assertEquals("metricsRule", document.get("ruleName").asText());
+ assertEquals(TOPIC, document.get("topic").asText());
+ assertEquals(Base64.getEncoder().encodeToString("{\"v\":1}".getBytes(StandardCharsets.UTF_8)),
+ document.get("base64OriginalPayload").asText());
+ assertEquals(1, document.get("failures").size());
+ JsonNode failure = document.get("failures").get(0);
+ assertEquals("SqsAction", failure.get("failedAction").asText());
+ assertEquals(QUEUE_URL, failure.get("failedResource").asText());
+ assertTrue(failure.get("errorMessage").asText().contains("does not exist"), failure.toString());
+ }
+
+ @Test
+ void theErrorActionDoesNotRunWhenEveryActionSucceeds() throws Exception {
+ createRule("metricsRule", sqsThenLambdaRule(lambdaErrorAction()));
+
+ publish("{\"v\":1}");
+
+ verify(lambda).invoke(eq(REGION), eq(FUNCTION_ARN), any(), eq(InvocationType.Event));
+ verify(lambda, never()).invoke(eq(REGION), eq(ERROR_FUNCTION_ARN), any(), any());
+ }
+
+ @Test
+ void aFailingErrorActionIsLoggedNotThrown() throws Exception {
+ createRule("metricsRule", sqsThenLambdaRule(lambdaErrorAction()));
+ queueIsMissing();
+ when(lambda.invoke(eq(REGION), eq(ERROR_FUNCTION_ARN), any(), any()))
+ .thenThrow(new AwsException("ResourceNotFoundException", "Function not found: errors", 404));
+
+ assertDoesNotThrow(() -> publish("{\"v\":1}"));
+
+ verify(lambda, times(1)).invoke(eq(REGION), eq(ERROR_FUNCTION_ARN), any(), eq(InvocationType.Event));
+ }
+
+ @Test
+ void everyFailingActionIsListedInTheFailureDocument() throws Exception {
+ createRule("metricsRule", """
+ {
+ "sql": "SELECT * FROM 'devices/+/metrics'",
+ "actions": [
+ {"sqs": {"queueUrl": "%s", "roleArn": "arn:aws:iam::000000000000:role/rule"}},
+ {"dynamoDBv2": {"putItem": {"tableName": "metrics"}, "roleArn": "arn:aws:iam::000000000000:role/rule"}}
+ ],
+ "errorAction": %s
+ }
+ """.formatted(QUEUE_URL, lambdaErrorAction()));
+ queueIsMissing();
+
+ publish("not json");
+
+ JsonNode failures = capturedInvocationPayload(ERROR_FUNCTION_ARN).get("failures");
+ assertEquals(2, failures.size());
+ assertEquals("SqsAction", failures.get(0).get("failedAction").asText());
+ assertEquals("DynamoDBv2Action", failures.get(1).get("failedAction").asText());
+ assertEquals("metrics", failures.get(1).get("failedResource").asText());
+ }
+
+ @Test
+ void topicRuleKeepsTheSqlVersionAndTheErrorAction() throws Exception {
+ createRule("versionedRule", """
+ {
+ "sql": "SELECT * FROM 'devices/+/metrics'",
+ "awsIotSqlVersion": "2016-03-23",
+ "actions": [{"lambda": {"functionArn": "%s"}}],
+ "errorAction": {"sqs": {"queueUrl": "%s", "roleArn": "arn:aws:iam::000000000000:role/rule"}}
+ }
+ """.formatted(FUNCTION_ARN, QUEUE_URL));
+
+ IotTopicRule rule = service.getTopicRule("versionedRule", REGION);
+
+ assertEquals("2016-03-23", rule.getAwsIotSqlVersion());
+ assertEquals(QUEUE_URL, mapper.readTree(rule.getErrorActionJson()).at("/sqs/queueUrl").asText());
+ }
+
+ @Test
+ void topicRuleWithoutTheOptionalMembersStoresNothingForThem() throws Exception {
+ createRule("plainRule", sqsThenLambdaRule(null));
+
+ IotTopicRule rule = service.getTopicRule("plainRule", REGION);
+
+ assertNull(rule.getAwsIotSqlVersion());
+ assertNull(rule.getErrorActionJson());
+ }
+
+ @Test
+ void replacingATopicRuleReplacesTheOptionalMembersToo() throws Exception {
+ createRule("versionedRule", """
+ {"sql": "SELECT * FROM 'a'", "awsIotSqlVersion": "2016-03-23", "actions": [],
+ "errorAction": {"sqs": {"queueUrl": "http://dlq", "roleArn": "r"}}}
+ """);
+
+ service.replaceTopicRule("versionedRule", mapper.readTree("{\"sql\": \"SELECT * FROM 'b'\", \"actions\": []}"), REGION);
+
+ IotTopicRule rule = service.getTopicRule("versionedRule", REGION);
+ assertNull(rule.getAwsIotSqlVersion());
+ assertNull(rule.getErrorActionJson());
+ }
+
+ private JsonNode capturedDynamoDbItem(String tableName) {
+ ArgumentCaptor<ObjectNode> item = ArgumentCaptor.forClass(ObjectNode.class);
+ verify(dynamoDb).putItem(eq(tableName), item.capture(), eq(REGION));
+ return item.getValue();
+ }
+
+ @Test
+ void dynamoDBv2ActionMapsNestedValuesToDynamoDbMapsAndLists() throws Exception {
+ createRule("metricsRule", """
+ {"sql": "SELECT * FROM 'devices/+/metrics'",
+ "actions": [{"dynamoDBv2": {"putItem": {"tableName": "metrics"}, "roleArn": "arn:aws:iam::000000000000:role/rule"}}]}
+ """);
+
+ publish("{\"device\": {\"id\": \"d1\", \"ok\": true}, \"readings\": [1.5, \"x\", null]}");
+
+ JsonNode item = capturedDynamoDbItem("metrics");
+ assertEquals("d1", item.at("/device/M/id/S").asText());
+ assertTrue(item.at("/device/M/ok/BOOL").asBoolean());
+ assertEquals("1.5", item.at("/readings/L/0/N").asText());
+ assertEquals("x", item.at("/readings/L/1/S").asText());
+ assertTrue(item.at("/readings/L/2/NULL").asBoolean());
+ }
+
+ @Test
+ void aDynamoDbErrorActionKeepsEveryFailureInTheItem() throws Exception {
+ createRule("metricsRule", """
+ {"sql": "SELECT * FROM 'devices/+/metrics'",
+ "actions": [{"sqs": {"queueUrl": "%s", "roleArn": "arn:aws:iam::000000000000:role/rule"}}],
+ "errorAction": {"dynamoDBv2": {"putItem": {"tableName": "rule-errors"}, "roleArn": "arn:aws:iam::000000000000:role/rule"}}}
+ """.formatted(QUEUE_URL));
+ queueIsMissing();
+
+ publish("{\"v\":1}");
+
+ JsonNode item = capturedDynamoDbItem("rule-errors");
+ assertEquals("metricsRule", item.at("/ruleName/S").asText());
+ assertEquals(TOPIC, item.at("/topic/S").asText());
+ assertEquals("SqsAction", item.at("/failures/L/0/M/failedAction/S").asText());
+ assertEquals(QUEUE_URL, item.at("/failures/L/0/M/failedResource/S").asText());
+ assertTrue(item.at("/failures/L/0/M/errorMessage/S").asText().contains("does not exist"));
+ }
+
+ @Test
+ void anActionWithoutATypeOrOfAnUnsupportedTypeIsSkippedAndTheOthersStillRun() throws Exception {
+ createRule("metricsRule", """
+ {"sql": "SELECT * FROM 'devices/+/metrics'",
+ "actions": [
+ {"comment": "not an action"},
+ {"kafka": {"destinationArn": "arn:aws:iot:us-east-1:000000000000:ruledestination/kafka/x", "topic": "t"}},
+ {"lambda": {"functionArn": "%s"}}
+ ],
+ "errorAction": {"note": "no type either"}}
+ """.formatted(FUNCTION_ARN));
+
+ assertDoesNotThrow(() -> publish("{\"v\":1}"));
+
+ verify(lambda).invoke(eq(REGION), eq(FUNCTION_ARN), any(), eq(InvocationType.Event));
+ verify(lambda, never()).invoke(eq(REGION), eq(ERROR_FUNCTION_ARN), any(), any());
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/iot/IotTopicRuleIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iot/IotTopicRuleIntegrationTest.java
index 3c2a71693e..df2d55aa9a 100644
--- a/src/test/java/io/github/hectorvent/floci/services/iot/IotTopicRuleIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/iot/IotTopicRuleIntegrationTest.java
@@ -39,6 +39,7 @@ class IotTopicRuleIntegrationTest {
"topicRulePayload": {
"sql": "SELECT * FROM 'devices/phase8/crud'",
"description": "phase 8 metadata",
+ "awsIotSqlVersion": "2016-03-23",
"ruleDisabled": false,
"actions": [
{
@@ -47,7 +48,13 @@ class IotTopicRuleIntegrationTest {
"topic": "devices/phase8/target"
}
}
- ]
+ ],
+ "errorAction": {
+ "republish": {
+ "roleArn": "arn:aws:iam::000000000000:role/iot-rule-role",
+ "topic": "devices/phase8/errors"
+ }
+ }
}
}
""")
@@ -69,6 +76,8 @@ class IotTopicRuleIntegrationTest {
.body("rule.description", equalTo("phase 8 metadata"))
.body("rule.ruleDisabled", equalTo(false))
.body("rule.actions[0].republish.topic", equalTo("devices/phase8/target"))
+ .body("rule.awsIotSqlVersion", equalTo("2016-03-23"))
+ .body("rule.errorAction.republish.topic", equalTo("devices/phase8/errors"))
.body("rule.createdAt", notNullValue());
given()
@@ -212,6 +221,44 @@ class IotTopicRuleIntegrationTest {
.body(containsString("sqs-rule-payload"));
}
+ @Test
+ void aFailingActionDoesNotFailThePublishAndTheErrorActionReceivesTheFailure() {
+ String queueUrl = createQueue("phase8-iot-rule-isolation-queue", "us-east-1");
+ String errorQueueUrl = createQueue("phase8-iot-rule-error-queue", "us-east-1");
+ given()
+ .contentType("application/json")
+ .body("""
+ {
+ "topicRulePayload": {
+ "sql": "SELECT * FROM 'devices/phase8/isolation'",
+ "actions": [
+ {"sqs": {"roleArn": "arn:aws:iam::000000000000:role/iot-rule-role", "queueUrl": "http://localhost:4566/000000000000/phase8-missing-queue"}},
+ {"sqs": {"roleArn": "arn:aws:iam::000000000000:role/iot-rule-role", "queueUrl": "%s"}}
+ ],
+ "errorAction": {"sqs": {"roleArn": "arn:aws:iam::000000000000:role/iot-rule-role", "queueUrl": "%s"}}
+ }
+ }
+ """.formatted(queueUrl, errorQueueUrl))
+ .when()
+ .put("/rules/phase8IsolationRule")
+ .then()
+ .statusCode(200);
+
+ given()
+ .contentType("text/plain")
+ .body("isolation-rule-payload")
+ .when()
+ .post("/topics/devices/phase8/isolation")
+ .then()
+ .statusCode(200);
+
+ receiveMessage(queueUrl, "us-east-1").body(containsString("isolation-rule-payload"));
+ receiveMessage(errorQueueUrl, "us-east-1")
+ .body(containsString("phase8IsolationRule"))
+ .body(containsString("SqsAction"))
+ .body(containsString("phase8-missing-queue"));
+ }
+
@Test
void matchingTopicRulePublishesPayloadToSns() {
String queueUrl = given()