Skip to content

Ministack: Free, open-source local AWS emulator - 60+ services, Terraform compatible, real databases. Free forever. MIT licensed.

feat(iot): dispatch the sqs topic-rule action (#1396)

iot-rocketfb6ea83b612e
diff --git a/ministack/services/iot.py b/ministack/services/iot.py
index 61cf96c4..45c6b0d2 100644
--- a/ministack/services/iot.py
+++ b/ministack/services/iot.py
@@ -3479,6 +3479,56 @@ def _dispatch_rule_sns(account_id: str, region: str, rule_name: str, spec: dict,
_broker_logger.debug("IoT rule %s → SNS %s", rule_name, target)
+def _dispatch_rule_sqs(account_id: str, region: str, rule_name: str, spec: dict, event) -> None:
+ from ministack.services import sqs as _sqs
+
+ queue_url = spec.get("queueUrl") or ""
+ if not queue_url:
+ _broker_logger.warning(
+ "IoT rule %s: sqs action has no queueUrl — skipped", rule_name
+ )
+ return
+ body = event if isinstance(event, str) else json.dumps(event)
+ if spec.get("useBase64"):
+ # useBase64 encodes the message *body*: the consumer receives Base64 text
+ # and has to decode it. It is not a transport hint.
+ body = base64.b64encode(body.encode("utf-8")).decode("ascii")
+ # roleArn is accepted and ignored, as everywhere else here — no IAM to fail.
+ with request_scope(account_id, region):
+ # _get_q matches the URL as stored and then by queue name, which is what
+ # lets a rule written against localhost reach a queue created through a
+ # different host alias, and refuses a URL naming another account rather
+ # than silently resolving to a same-account queue of that name.
+ try:
+ queue = _sqs._get_q(queue_url)
+ if queue["is_fifo"]:
+ # AWS documents FIFO queues as unsupported for this action: the
+ # rules engine is distributed, so it cannot promise the ordering
+ # a FIFO queue exists to provide, and enqueuing anyway would need
+ # a MessageGroupId we would have to invent.
+ _broker_logger.warning(
+ "IoT rule %s: sqs target %s is a FIFO queue, which the AWS SQS "
+ "rule action does not support — nothing delivered",
+ rule_name,
+ queue_url,
+ )
+ return
+ # Through SQS's own SendMessage body, so the queue's DelaySeconds and
+ # MaximumMessageSize apply and the MessageId is minted the way every
+ # other producer's is.
+ result = _sqs._act_send_message({"MessageBody": body}, queue_url)
+ except _sqs._Err as exc:
+ # SQS raises in its wire vocabulary; the action collector and the
+ # rule's errorAction want a plain exception, so translate at the
+ # boundary as stepfunctions does for the same call.
+ raise RuntimeError(
+ f"SQS SendMessage to {queue_url} failed: {exc.code}: {exc.message}"
+ ) from exc
+ _broker_logger.debug(
+ "IoT rule %s → SQS %s (%s)", rule_name, queue_url, result["MessageId"]
+ )
+
+
async def _dispatch_rule_action(
account_id: str, region: str, rule_name: str, action: dict, event
) -> None:
@@ -3500,6 +3550,8 @@ async def _dispatch_rule_action(
)
elif "sns" in action:
_dispatch_rule_sns(account_id, region, rule_name, action["sns"] or {}, event)
+ elif "sqs" in action:
+ _dispatch_rule_sqs(account_id, region, rule_name, action["sqs"] or {}, event)
else:
_broker_logger.debug(
"IoT rule %s: unsupported action type %s — skipped",
diff --git a/tests/test_iot_data.py b/tests/test_iot_data.py
index cf54a9a4..000bc4ba 100644
--- a/tests/test_iot_data.py
+++ b/tests/test_iot_data.py
@@ -728,12 +728,8 @@ def _make_sink_lambda(lam, sink_url):
def _poll_sink(sqs, url, timeout=12):
- deadline = time.time() + timeout
- while time.time() < deadline:
- msgs = sqs.receive_message(QueueUrl=url, MaxNumberOfMessages=1, WaitTimeSeconds=1)
- if msgs.get("Messages"):
- return json.loads(msgs["Messages"][0]["Body"])
- return None
+ body = _poll_body(sqs, url, timeout)
+ return json.loads(body) if body is not None else None
def test_iot_topic_rule_routes_publish_to_lambda(iot_client, iot_data_client, lam, sqs):
@@ -1117,6 +1113,196 @@ def test_iot_rule_sns_action_publishes_to_topic(iot_client, iot_data_client, sns
# ---------------------------------------------------------------------------
+# Topic-rule `sqs` action (publish → rule → SQS queue)
+# ---------------------------------------------------------------------------
+
+
+def _poll_message(sqs, url, timeout=10):
+ """The first message on the queue, or None."""
+ deadline = time.time() + timeout
+ while time.time() < deadline:
+ msgs = sqs.receive_message(QueueUrl=url, MaxNumberOfMessages=1, WaitTimeSeconds=1)
+ if msgs.get("Messages"):
+ return msgs["Messages"][0]
+ return None
+
+
+def _poll_body(sqs, url, timeout=10):
+ """The raw body of the first message on the queue, or None."""
+ msg = _poll_message(sqs, url, timeout)
+ return msg["Body"] if msg else None
+
+
+def test_iot_rule_sqs_action_delivers_payload(iot_client, iot_data_client, sqs):
+ queue = sqs.create_queue(QueueName=_unique("rule-sqs"))["QueueUrl"]
+ rule = _unique("tosqs").replace("-", "_")
+ iot_client.create_topic_rule(
+ ruleName=rule,
+ topicRulePayload={
+ "sql": "SELECT * FROM 'sensors/+/telemetry'",
+ "actions": [{"sqs": {
+ "queueUrl": queue,
+ "roleArn": "arn:aws:iam::000000000000:role/aws_iot_sqs",
+ }}],
+ },
+ )
+
+ iot_data_client.publish(
+ topic="sensors/a1/telemetry",
+ payload=json.dumps({"temp": 22, "missedReadings": 3}).encode(),
+ )
+ assert json.loads(_poll_body(sqs, queue)) == {"temp": 22, "missedReadings": 3}
+
+ iot_client.delete_topic_rule(ruleName=rule)
+
+
+def test_iot_rule_sqs_action_use_base64_encodes_body(iot_client, iot_data_client, sqs):
+ """``useBase64`` means the *body* is Base64 text, not a transport hint."""
+ queue = sqs.create_queue(QueueName=_unique("rule-sqs-b64"))["QueueUrl"]
+ rule = _unique("sqsb64").replace("-", "_")
+ iot_client.create_topic_rule(
+ ruleName=rule,
+ topicRulePayload={
+ "sql": "SELECT * FROM 'sensors/+/telemetry'",
+ "actions": [{"sqs": {
+ "queueUrl": queue,
+ "useBase64": True,
+ "roleArn": "arn:aws:iam::000000000000:role/aws_iot_sqs",
+ }}],
+ },
+ )
+
+ iot_data_client.publish(
+ topic="sensors/a1/telemetry", payload=json.dumps({"temp": 7}).encode()
+ )
+ body = _poll_body(sqs, queue)
+ assert json.loads(base64.b64decode(body)) == {"temp": 7}
+
+ iot_client.delete_topic_rule(ruleName=rule)
+
+
+def test_iot_rule_sqs_action_applies_select_projection(iot_client, iot_data_client, sqs):
+ """The SELECT clause is evaluated once and applies to every action alike."""
+ queue = sqs.create_queue(QueueName=_unique("rule-sqs-proj"))["QueueUrl"]
+ rule = _unique("sqsproj").replace("-", "_")
+ iot_client.create_topic_rule(
+ ruleName=rule,
+ topicRulePayload={
+ "sql": "SELECT deviceId AS id, topic(2) AS device "
+ "FROM 'sensors/+/telemetry'",
+ "actions": [{"sqs": {"queueUrl": queue, "roleArn": "arn:aws:iam::000000000000:role/aws_iot_sqs"}}],
+ },
+ )
+
+ iot_data_client.publish(
+ topic="sensors/a1/telemetry",
+ payload=json.dumps({"deviceId": "d1", "temp": 22}).encode(),
+ )
+ assert json.loads(_poll_body(sqs, queue)) == {"id": "d1", "device": "a1"}
+
+ iot_client.delete_topic_rule(ruleName=rule)
+
+
+def test_iot_rule_sqs_action_missing_queue_does_not_stop_the_rule(
+ iot_client, iot_data_client, sqs
+):
+ """The rule's other actions still run — and the failure is a failure like
+ any other, so it reaches the rule's errorAction rather than being swallowed
+ where only a log line would show it."""
+ queue = sqs.create_queue(QueueName=_unique("rule-sqs-live"))["QueueUrl"]
+ dlq = sqs.create_queue(QueueName=_unique("rule-sqs-dlq"))["QueueUrl"]
+ gone = queue.rsplit("/", 1)[0] + "/" + _unique("no-such-queue")
+ rule = _unique("sqsfail").replace("-", "_")
+ iot_client.create_topic_rule(
+ ruleName=rule,
+ topicRulePayload={
+ "sql": "SELECT * FROM 'sensors/+/telemetry'",
+ "actions": [
+ {"sqs": {"queueUrl": gone, "roleArn": "arn:aws:iam::000000000000:role/aws_iot_sqs"}},
+ {"sqs": {"queueUrl": queue, "roleArn": "arn:aws:iam::000000000000:role/aws_iot_sqs"}},
+ ],
+ "errorAction": {
+ "sqs": {"queueUrl": dlq, "roleArn": "arn:aws:iam::000000000000:role/aws_iot_sqs"}
+ },
+ },
+ )
+
+ iot_data_client.publish(
+ topic="sensors/a1/telemetry", payload=json.dumps({"temp": 1}).encode()
+ )
+ assert json.loads(_poll_body(sqs, queue)) == {"temp": 1}
+
+ doc = json.loads(_poll_body(sqs, dlq))
+ assert doc["ruleName"] == rule
+ assert doc["topic"] == "sensors/a1/telemetry"
+ assert [f["action"] for f in doc["failures"]] == ["sqs"]
+ assert "QueueDoesNotExist" in doc["failures"][0]["errorMessage"]
+
+ iot_client.delete_topic_rule(ruleName=rule)
+
+
+def test_iot_rule_sqs_action_message_is_an_ordinary_sqs_message(
+ iot_client, iot_data_client, sqs
+):
+ """Delivery goes through SQS's own SendMessage, so what lands on the queue is
+ indistinguishable from any other producer's message — starting with a
+ MessageId in the canonical dashed form a consumer may parse or key on."""
+ queue = sqs.create_queue(QueueName=_unique("rule-sqs-mid"))["QueueUrl"]
+ rule = _unique("sqsmid").replace("-", "_")
+ iot_client.create_topic_rule(
+ ruleName=rule,
+ topicRulePayload={
+ "sql": "SELECT * FROM 'sensors/+/telemetry'",
+ "actions": [{"sqs": {"queueUrl": queue, "roleArn": "arn:aws:iam::000000000000:role/aws_iot_sqs"}}],
+ },
+ )
+
+ iot_data_client.publish(
+ topic="sensors/a1/telemetry", payload=json.dumps({"temp": 11}).encode()
+ )
+ msg = _poll_message(sqs, queue)
+ assert msg is not None
+ # uuid.UUID() also accepts the 32-char undashed form, so parsing alone would
+ # not notice a hand-minted id; the round-trip is what pins the real shape.
+ assert msg["MessageId"] == str(uuid.UUID(msg["MessageId"]))
+
+ iot_client.delete_topic_rule(ruleName=rule)
+
+
+def test_iot_rule_sqs_action_refuses_fifo_queue(iot_client, iot_data_client, sqs):
+ """AWS does not support FIFO queues as an ``sqs`` action destination.
+
+ The refusal is a deliberate skip, not a delivery failure: nothing lands
+ on the FIFO queue AND the rule's ``errorAction`` stays quiet. Without the
+ DLQ assertion this test could not tell the skip apart from the
+ missing-queue case, which does fire the errorAction.
+ """
+ queue = sqs.create_queue(
+ QueueName=_unique("rule-sqs")[:70] + ".fifo",
+ Attributes={"FifoQueue": "true", "ContentBasedDeduplication": "true"},
+ )["QueueUrl"]
+ dlq = sqs.create_queue(QueueName=_unique("rule-fifo-dlq"))["QueueUrl"]
+ rule = _unique("sqsfifo").replace("-", "_")
+ iot_client.create_topic_rule(
+ ruleName=rule,
+ topicRulePayload={
+ "sql": "SELECT * FROM 'sensors/+/telemetry'",
+ "actions": [{"sqs": {"queueUrl": queue, "roleArn": "arn:aws:iam::000000000000:role/aws_iot_sqs"}}],
+ "errorAction": {
+ "sqs": {"queueUrl": dlq, "roleArn": "arn:aws:iam::000000000000:role/aws_iot_sqs"}
+ },
+ },
+ )
+
+ iot_data_client.publish(
+ topic="sensors/a1/telemetry", payload=json.dumps({"temp": 3}).encode()
+ )
+ assert _poll_body(sqs, queue, timeout=4) is None
+ assert _poll_body(sqs, dlq, timeout=2) is None, (
+ "a FIFO destination is skipped, not failed - the errorAction must not fire"
+ )
+
+ iot_client.delete_topic_rule(ruleName=rule)
# Device Shadow over MQTT (reserved $aws/things/.../shadow/... topics)
# ---------------------------------------------------------------------------