Ministack: Free, open-source local AWS emulator - 60+ services, Terraform compatible, real databases. Free forever. MIT licensed.
Python awsaws-emulatoraws-localaws-sdkdevtoolsdockerdynamodbec2emulatorlambdalocalstacklocalstack-alternativeministackmock-awsopen-sourcepythons3sqsterraform
feat(iot): dispatch the sqs topic-rule action (#1396)
iot-rocketfb6ea83b612e
diff --git a/ministack/services/iot.py b/ministack/services/iot.pyindex 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.pyindex 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 Nonedef 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)# ---------------------------------------------------------------------------