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(cfn): support Lambda event invoke configs (#1146)
robert-pitt-foodhub6bdee8a0b2e7
diff --git a/README.md b/README.mdindex 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.pyindex 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.pyindex 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"] = eicreturn 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"] = Nonereturn 204, {}, b""diff --git a/tests/test_cfn.py b/tests/test_cfn.pyindex 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.pyindex 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 {}"