Skip to content

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

feat(cfn): support Lambda event invoke configs (#1146)

robert-pitt-foodhub6bdee8a0b2e7
diff --git a/README.md b/README.md
index 25e861c6..a44b4360 100644
--- a/README.md
+++ b/README.md
@@ -480,6 +480,7 @@ subnet = ec2.create_subnet(
| `AWS::Lambda::Version` | Version ARN | Version |
| `AWS::Lambda::Alias` | Alias ARN | — |
| `AWS::Lambda::EventSourceMapping` | UUID | — |
+| `AWS::Lambda::EventInvokeConfig` | Unique function/qualifier identifier | — |
| `AWS::S3::BucketPolicy` | Bucket name | — |
| `AWS::SQS::QueuePolicy` | Policy ID | — |
| `AWS::SNS::TopicPolicy` | Policy ID | — |
diff --git a/ministack/services/cloudformation/provisioners.py b/ministack/services/cloudformation/provisioners.py
index a7640ef6..f320f3a7 100644
--- a/ministack/services/cloudformation/provisioners.py
+++ b/ministack/services/cloudformation/provisioners.py
@@ -683,6 +683,8 @@ def _lambda_create(logical_id, props, stack_name):
"next_version": 1,
"tags": {},
"policy": {"Version": "2012-10-17", "Id": "default", "Statement": []},
+ "event_invoke_config": None,
+ "event_invoke_configs": {},
"aliases": {},
"concurrency": None,
"provisioned_concurrency": {},
@@ -2248,6 +2250,68 @@ def _lambda_esm_update(physical_id, old_props, new_props, stack_name):
return physical_id, {"UUID": physical_id}
+# --- Lambda EventInvokeConfig ---
+
+def _lambda_event_invoke_config_create(logical_id, props, stack_name):
+ func, func_name, _resource_arn, _embedded_qualifier = _lambda_function_for_cfn_ref(
+ props.get("FunctionName", "")
+ )
+ qualifier = props.get("Qualifier", "")
+ if func is None:
+ raise ValueError(f"Lambda function not found: {props.get('FunctionName', '')}")
+ if not qualifier or not _lambda_svc._function_qualifier_exists(func, qualifier):
+ raise ValueError(f"Lambda function qualifier not found: {func_name}:{qualifier}")
+
+ data = {
+ key: props[key]
+ for key in (
+ "DestinationConfig",
+ "MaximumEventAgeInSeconds",
+ "MaximumRetryAttempts",
+ )
+ if key in props
+ }
+ status, _headers, body = _lambda_svc._put_event_invoke_config(
+ func_name, qualifier, data
+ )
+ if status >= 400:
+ raise ValueError(
+ f"AWS::Lambda::EventInvokeConfig create failed: {body.decode('utf-8')}"
+ )
+ return f"{func_name}:{qualifier}", {}
+
+
+def _lambda_event_invoke_config_update(physical_id, old_props, new_props, stack_name):
+ replacement = any(
+ old_props.get(key) != new_props.get(key)
+ for key in ("FunctionName", "Qualifier")
+ )
+ new_id, attrs = _lambda_event_invoke_config_create(
+ physical_id, new_props, stack_name
+ )
+ if replacement:
+ _lambda_event_invoke_config_delete(physical_id, old_props)
+ return new_id, attrs
+ return physical_id, attrs
+
+
+def _lambda_event_invoke_config_delete(physical_id, props):
+ func, func_name, _resource_arn, _embedded_qualifier = _lambda_function_for_cfn_ref(
+ props.get("FunctionName", "")
+ )
+ if func is None:
+ return
+ qualifier = props.get("Qualifier", "") or None
+ status, _headers, _body = _lambda_svc._delete_event_invoke_config(
+ func_name, qualifier
+ )
+ # Stack rollback/delete is idempotent when the config has already gone.
+ if status not in (204, 404):
+ raise ValueError(
+ f"AWS::Lambda::EventInvokeConfig delete failed with status {status}"
+ )
+
+
# --- EventBridge Pipes (minimal: DynamoDB Streams -> SNS) ---
def _pipes_pipe_create(logical_id, props, stack_name):
@@ -4762,6 +4826,11 @@ _RESOURCE_HANDLERS = {
"delete": _apigw_gateway_response_delete,
},
"AWS::Lambda::EventSourceMapping": {"create": _lambda_esm_create, "update": _lambda_esm_update, "delete": _lambda_esm_delete},
+ "AWS::Lambda::EventInvokeConfig": {
+ "create": _lambda_event_invoke_config_create,
+ "update": _lambda_event_invoke_config_update,
+ "delete": _lambda_event_invoke_config_delete,
+ },
"AWS::Pipes::Pipe": {"create": _pipes_pipe_create, "delete": _pipes_pipe_delete},
"AWS::Lambda::Alias": {"create": _lambda_alias_create, "delete": _lambda_alias_delete},
"AWS::SQS::QueuePolicy": {"create": _sqs_queue_policy_create, "delete": _sqs_queue_policy_delete},
diff --git a/ministack/services/lambda_svc.py b/ministack/services/lambda_svc.py
index 890e7f8b..a217cd6c 100644
--- a/ministack/services/lambda_svc.py
+++ b/ministack/services/lambda_svc.py
@@ -13,7 +13,7 @@ Supports: CreateFunction, DeleteFunction, GetFunction, GetFunctionConfiguration,
GetLayerVersionPolicy,
CreateEventSourceMapping, DeleteEventSourceMapping,
GetEventSourceMapping, ListEventSourceMappings, UpdateEventSourceMapping,
- GetFunctionEventInvokeConfig, PutFunctionEventInvokeConfig (stub),
+ GetFunctionEventInvokeConfig, PutFunctionEventInvokeConfig,
PutFunctionConcurrency, GetFunctionConcurrency, DeleteFunctionConcurrency,
GetFunctionCodeSigningConfig (stub),
CreateFunctionUrlConfig, GetFunctionUrlConfig, UpdateFunctionUrlConfig,
@@ -1569,13 +1569,16 @@ async def handle_request(method: str, path: str, headers: dict, body: bytes, que
# --- Event Invoke Config: /2019-09-25/functions/{name}/event-invoke-config ---
if "event-invoke-config" in path:
m = re.search(r"/functions/([^/]+)/event-invoke-config", path)
- fname = _resolve_request_scoped_name(m.group(1)) if m else ""
+ fname, path_qualifier = (
+ _resolve_request_scoped_name_and_qualifier(m.group(1)) if m else ("", None)
+ )
+ qualifier = _qualifier_from_path_or_query(path_qualifier, query_params)
if method == "GET":
- return _get_event_invoke_config(fname)
+ return _get_event_invoke_config(fname, qualifier)
if method == "PUT":
- return _put_event_invoke_config(fname, data)
+ return _put_event_invoke_config(fname, qualifier, data)
if method == "DELETE":
- return _delete_event_invoke_config(fname)
+ return _delete_event_invoke_config(fname, qualifier)
# --- Provisioned Concurrency: /2019-09-30/functions/{name}/provisioned-concurrency ---
if "provisioned-concurrency" in path:
@@ -1808,6 +1811,7 @@ def _create_function(data: dict):
"tags": data.get("Tags", {}),
"policy": {"Version": "2012-10-17", "Id": "default", "Statement": []},
"event_invoke_config": None,
+ "event_invoke_configs": {},
"aliases": {},
"concurrency": None,
"provisioned_concurrency": {},
@@ -1892,25 +1896,20 @@ def _get_function_config(name: str, qualifier: str | None = None):
def _list_function_event_invoke_configs(func_name: str, query_params: dict):
- """AWS `ListFunctionEventInvokeConfigs` — returns the set of per-qualifier
- event-invoke configs for a function. We store one per function on the
- primary record (no per-qualifier split), so the result is 0 or 1 items."""
+ """AWS `ListFunctionEventInvokeConfigs` — return every qualifier config."""
if func_name not in _functions:
return error_response_json(
"ResourceNotFoundException",
f"Function not found: {_func_arn(func_name)}", 404,
)
- eic = _functions[func_name].get("event_invoke_config")
- items = []
- if eic:
- arn = _func_arn(func_name)
- items.append({
- "FunctionArn": arn,
- "LastModified": int(time.time()),
- "MaximumRetryAttempts": eic.get("MaximumRetryAttempts", 2),
- "MaximumEventAgeInSeconds": eic.get("MaximumEventAgeInSeconds", 21600),
- "DestinationConfig": eic.get("DestinationConfig", {}),
- })
+ func = _functions[func_name]
+ configs = dict(func.get("event_invoke_configs") or {})
+ # Backward compatibility for persisted state created before configs were
+ # qualifier-aware.
+ legacy = func.get("event_invoke_config")
+ if legacy and "" not in configs:
+ configs[""] = legacy
+ items = list(configs.values())
return json_response({"FunctionEventInvokeConfigs": items})
@@ -2811,7 +2810,11 @@ def invoke_async_with_retry(func: dict, event: dict) -> None:
_request_account_id.set(account_id)
_request_region.set(region)
fn_name = config.get("FunctionName", "unknown")
- eic = func.get("event_invoke_config") or {}
+ eic = (
+ func.get("event_invoke_config")
+ or (func.get("event_invoke_configs") or {}).get("$LATEST")
+ or {}
+ )
max_retries = eic.get("MaximumRetryAttempts")
if max_retries is None:
max_retries = 2
@@ -5106,34 +5109,50 @@ def serve_layer_content(
# ---------------------------------------------------------------------------
-# Event Invoke Config (stubs — enough for Terraform to not error)
+# Event Invoke Config
# ---------------------------------------------------------------------------
-def _get_event_invoke_config(func_name: str):
+def _event_invoke_config(func: dict, qualifier: str | None) -> dict | None:
+ configs = func.get("event_invoke_configs") or {}
+ key = qualifier or ""
+ if key in configs:
+ return configs[key]
+ # Read legacy unqualified state written by older MiniStack versions.
+ if not qualifier:
+ return func.get("event_invoke_config")
+ return None
+
+
+def _get_event_invoke_config(func_name: str, qualifier: str | None = None):
if func_name not in _functions:
return error_response_json(
"ResourceNotFoundException",
f"Function not found: {_func_arn(func_name)}",
404,
)
- eic = _functions[func_name].get("event_invoke_config")
+ if not _function_qualifier_exists(_functions[func_name], qualifier):
+ return _function_qualifier_not_found(func_name, qualifier)
+ eic = _event_invoke_config(_functions[func_name], qualifier)
if not eic:
+ suffix = f":{qualifier}" if qualifier else ""
return error_response_json(
"ResourceNotFoundException",
- f"The function {func_name} doesn't have an EventInvokeConfig",
+ f"The function {func_name}{suffix} doesn't have an EventInvokeConfig",
404,
)
return json_response(eic)
-def _put_event_invoke_config(func_name: str, data: dict):
+def _put_event_invoke_config(func_name: str, qualifier: str | None, data: dict):
if func_name not in _functions:
return error_response_json(
"ResourceNotFoundException",
f"Function not found: {_func_arn(func_name)}",
404,
)
+ if not _function_qualifier_exists(_functions[func_name], qualifier):
+ return _function_qualifier_not_found(func_name, qualifier)
destination_config = data.get(
"DestinationConfig",
{
@@ -5144,25 +5163,45 @@ def _put_event_invoke_config(func_name: str, data: dict):
err = _validate_destination_config(destination_config)
if err:
return err
+ function_arn = _func_arn(func_name)
+ if qualifier:
+ function_arn = f"{function_arn}:{qualifier}"
eic = {
- "FunctionArn": _func_arn(func_name),
+ "FunctionArn": function_arn,
"MaximumRetryAttempts": data.get("MaximumRetryAttempts", 2),
"MaximumEventAgeInSeconds": data.get("MaximumEventAgeInSeconds", 21600),
"LastModified": int(time.time()),
"DestinationConfig": destination_config,
}
- _functions[func_name]["event_invoke_config"] = eic
+ func = _functions[func_name]
+ func.setdefault("event_invoke_configs", {})[qualifier or ""] = eic
+ if not qualifier:
+ func["event_invoke_config"] = eic
return json_response(eic)
-def _delete_event_invoke_config(func_name: str):
+def _delete_event_invoke_config(func_name: str, qualifier: str | None = None):
if func_name not in _functions:
return error_response_json(
"ResourceNotFoundException",
f"Function not found: {_func_arn(func_name)}",
404,
)
- _functions[func_name]["event_invoke_config"] = None
+ if not _function_qualifier_exists(_functions[func_name], qualifier):
+ return _function_qualifier_not_found(func_name, qualifier)
+ func = _functions[func_name]
+ configs = func.setdefault("event_invoke_configs", {})
+ key = qualifier or ""
+ if key not in configs and not (not qualifier and func.get("event_invoke_config")):
+ suffix = f":{qualifier}" if qualifier else ""
+ return error_response_json(
+ "ResourceNotFoundException",
+ f"The function {func_name}{suffix} doesn't have an EventInvokeConfig",
+ 404,
+ )
+ configs.pop(key, None)
+ if not qualifier:
+ func["event_invoke_config"] = None
return 204, {}, b""
diff --git a/tests/test_cfn.py b/tests/test_cfn.py
index 07ffc7f7..5f1075bc 100644
--- a/tests/test_cfn.py
+++ b/tests/test_cfn.py
@@ -1186,6 +1186,91 @@ def test_cfn_lambda_version(cfn, lam):
lam.delete_function(FunctionName="cfn-ver-fn")
+def test_cfn_lambda_event_invoke_config_lifecycle(cfn, lam):
+ """AWS::Lambda::EventInvokeConfig creates, updates, and deletes cleanly."""
+ suffix = _uuid_mod.uuid4().hex[:8]
+ fn = f"cfn-event-invoke-{suffix}"
+ stack_name = f"cfn-event-invoke-{suffix}"
+ destination = f"arn:aws:sqs:us-east-1:000000000000:failure-{suffix}"
+ code = "def handler(e,c): return {}"
+ buf = io.BytesIO()
+ with zipfile.ZipFile(buf, "w") as zf:
+ zf.writestr("index.py", code)
+ lam.create_function(
+ FunctionName=fn,
+ Runtime="python3.11",
+ Role="arn:aws:iam::000000000000:role/r",
+ Handler="index.handler",
+ Code={"ZipFile": buf.getvalue()},
+ )
+
+ def template(retries, event_age):
+ return {
+ "AWSTemplateFormatVersion": "2010-09-09",
+ "Resources": {
+ "InvokeConfig": {
+ "Type": "AWS::Lambda::EventInvokeConfig",
+ "Properties": {
+ "FunctionName": fn,
+ "Qualifier": "$LATEST",
+ "MaximumRetryAttempts": retries,
+ "MaximumEventAgeInSeconds": event_age,
+ "DestinationConfig": {
+ "OnFailure": {"Destination": destination},
+ },
+ },
+ },
+ },
+ "Outputs": {
+ "InvokeConfigId": {"Value": {"Ref": "InvokeConfig"}},
+ },
+ }
+
+ try:
+ cfn.create_stack(
+ StackName=stack_name,
+ TemplateBody=json.dumps(template(1, 300)),
+ )
+ stack = _wait_stack(cfn, stack_name)
+ assert stack["StackStatus"] == "CREATE_COMPLETE", stack.get("StackStatusReason")
+ assert stack["Outputs"][0]["OutputValue"] == f"{fn}:$LATEST"
+
+ config = lam.get_function_event_invoke_config(
+ FunctionName=fn, Qualifier="$LATEST"
+ )
+ assert config["FunctionArn"].endswith(f":function:{fn}:$LATEST")
+ assert config["MaximumRetryAttempts"] == 1
+ assert config["MaximumEventAgeInSeconds"] == 300
+ assert config["DestinationConfig"]["OnFailure"]["Destination"] == destination
+
+ cfn.update_stack(
+ StackName=stack_name,
+ TemplateBody=json.dumps(template(0, 120)),
+ )
+ stack = _wait_stack(cfn, stack_name)
+ assert stack["StackStatus"] == "UPDATE_COMPLETE", stack.get("StackStatusReason")
+ updated = lam.get_function_event_invoke_config(
+ FunctionName=fn, Qualifier="$LATEST"
+ )
+ assert updated["MaximumRetryAttempts"] == 0
+ assert updated["MaximumEventAgeInSeconds"] == 120
+
+ cfn.delete_stack(StackName=stack_name)
+ _wait_stack(cfn, stack_name)
+ with pytest.raises(ClientError) as exc:
+ lam.get_function_event_invoke_config(
+ FunctionName=fn, Qualifier="$LATEST"
+ )
+ assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
+ finally:
+ try:
+ cfn.delete_stack(StackName=stack_name)
+ _wait_stack(cfn, stack_name)
+ except Exception:
+ pass
+ lam.delete_function(FunctionName=fn)
+
+
def test_cfn_esm_filter_criteria_round_trips(cfn, lam, ddb):
code = "def handler(e,c): return {'ok': True}"
buf = io.BytesIO()
diff --git a/tests/test_lambda.py b/tests/test_lambda.py
index f5fea779..dee49c72 100644
--- a/tests/test_lambda.py
+++ b/tests/test_lambda.py
@@ -3326,6 +3326,64 @@ def test_lambda_event_invoke_config_crud(lam):
lam.delete_function(FunctionName="eic-fn")
+
+def test_lambda_event_invoke_configs_are_isolated_by_qualifier(lam):
+ """Versions and $LATEST retain independent async invocation configs."""
+ suffix = _uuid_mod.uuid4().hex[:8]
+ fn = f"eic-qualified-{suffix}"
+ code = "def handler(e,c): return {}"
+ buf = io.BytesIO()
+ with zipfile.ZipFile(buf, "w") as zf:
+ zf.writestr("index.py", code)
+ lam.create_function(
+ FunctionName=fn,
+ Runtime="python3.11",
+ Role=_LAMBDA_ROLE,
+ Handler="index.handler",
+ Code={"ZipFile": buf.getvalue()},
+ )
+ version = lam.publish_version(FunctionName=fn)["Version"]
+
+ try:
+ lam.put_function_event_invoke_config(
+ FunctionName=fn,
+ Qualifier="$LATEST",
+ MaximumRetryAttempts=0,
+ )
+ lam.put_function_event_invoke_config(
+ FunctionName=fn,
+ Qualifier=version,
+ MaximumRetryAttempts=1,
+ )
+
+ latest = lam.get_function_event_invoke_config(
+ FunctionName=fn, Qualifier="$LATEST"
+ )
+ published = lam.get_function_event_invoke_config(
+ FunctionName=fn, Qualifier=version
+ )
+ assert latest["MaximumRetryAttempts"] == 0
+ assert latest["FunctionArn"].endswith(":$LATEST")
+ assert published["MaximumRetryAttempts"] == 1
+ assert published["FunctionArn"].endswith(f":{version}")
+
+ configs = lam.list_function_event_invoke_configs(FunctionName=fn)[
+ "FunctionEventInvokeConfigs"
+ ]
+ assert {config["FunctionArn"] for config in configs} == {
+ latest["FunctionArn"], published["FunctionArn"]
+ }
+
+ lam.delete_function_event_invoke_config(
+ FunctionName=fn, Qualifier="$LATEST"
+ )
+ assert lam.get_function_event_invoke_config(
+ FunctionName=fn, Qualifier=version
+ )["MaximumRetryAttempts"] == 1
+ finally:
+ lam.delete_function(FunctionName=fn)
+
+
def test_lambda_provisioned_concurrency_crud(lam):
"""Put/Get/Delete ProvisionedConcurrencyConfig lifecycle."""
code = "def handler(e,c): return {}"