aws-cdk-lib 2.115.0__py3-none-any.whl → 2.116.1__py3-none-any.whl

aws_cdk/custom_resources/__init__.py

@@ -737,6 +737,7 @@ from ..aws_ec2 import (
     SubnetSelection as _SubnetSelection_e57d76df,
 )
 from ..aws_iam import (
+    Grant as _Grant_a7ae64f8,
     IGrantable as _IGrantable_71c4f5de,
     IPrincipal as _IPrincipal_539bb2fd,
     IRole as _IRole_235f5d8e,
@@ -744,7 +745,10 @@ from ..aws_iam import (
 )
 from ..aws_kms import IKey as _IKey_5f11635f
 from ..aws_lambda import IFunction as _IFunction_6adb0ab8
-from ..aws_logs import RetentionDays as _RetentionDays_070f99f0
+from ..aws_logs import (
+    ILogGroup as _ILogGroup_3c4fa718, RetentionDays as _RetentionDays_070f99f0
+)
+from ..aws_stepfunctions import LogLevel as _LogLevel_be1990fe
 
 
 @jsii.implements(_IGrantable_71c4f5de)
@@ -1497,6 +1501,99 @@ class AwsSdkCall:
         )
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.custom_resources.LogOptions",
+    jsii_struct_bases=[],
+    name_mapping={
+        "destination": "destination",
+        "include_execution_data": "includeExecutionData",
+        "level": "level",
+    },
+)
+class LogOptions:
+    def __init__(
+        self,
+        *,
+        destination: typing.Optional[_ILogGroup_3c4fa718] = None,
+        include_execution_data: typing.Optional[builtins.bool] = None,
+        level: typing.Optional[_LogLevel_be1990fe] = None,
+    ) -> None:
+        '''Log Options for the state machine.
+
+        :param destination: The log group where the execution history events will be logged. Default: - a new log group will be created
+        :param include_execution_data: Determines whether execution data is included in your log. Default: - false
+        :param level: Defines which category of execution history events are logged. Default: - ERROR
+
+        :exampleMetadata: fixture=_generated
+
+        Example::
+
+            # The code below shows an example of how to instantiate this type.
+            # The values are placeholders you should change.
+            from aws_cdk import aws_logs as logs
+            from aws_cdk import aws_stepfunctions as stepfunctions
+            from aws_cdk import custom_resources
+            
+            # log_group: logs.LogGroup
+            
+            log_options = custom_resources.LogOptions(
+                destination=log_group,
+                include_execution_data=False,
+                level=stepfunctions.LogLevel.OFF
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__2622296f61199d2b10825c21d976c0578e9488ad1b2b7635565f604c598734b7)
+            check_type(argname="argument destination", value=destination, expected_type=type_hints["destination"])
+            check_type(argname="argument include_execution_data", value=include_execution_data, expected_type=type_hints["include_execution_data"])
+            check_type(argname="argument level", value=level, expected_type=type_hints["level"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if destination is not None:
+            self._values["destination"] = destination
+        if include_execution_data is not None:
+            self._values["include_execution_data"] = include_execution_data
+        if level is not None:
+            self._values["level"] = level
+
+    @builtins.property
+    def destination(self) -> typing.Optional[_ILogGroup_3c4fa718]:
+        '''The log group where the execution history events will be logged.
+
+        :default: - a new log group will be created
+        '''
+        result = self._values.get("destination")
+        return typing.cast(typing.Optional[_ILogGroup_3c4fa718], result)
+
+    @builtins.property
+    def include_execution_data(self) -> typing.Optional[builtins.bool]:
+        '''Determines whether execution data is included in your log.
+
+        :default: - false
+        '''
+        result = self._values.get("include_execution_data")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def level(self) -> typing.Optional[_LogLevel_be1990fe]:
+        '''Defines which category of execution history events are logged.
+
+        :default: - ERROR
+        '''
+        result = self._values.get("level")
+        return typing.cast(typing.Optional[_LogLevel_be1990fe], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "LogOptions(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 class PhysicalResourceId(
     metaclass=jsii.JSIIMeta,
     jsii_type="aws-cdk-lib.custom_resources.PhysicalResourceId",
@@ -1667,6 +1764,7 @@ class Provider(
         id: builtins.str,
         *,
         on_event_handler: _IFunction_6adb0ab8,
+        disable_waiter_state_machine_logging: typing.Optional[builtins.bool] = None,
         is_complete_handler: typing.Optional[_IFunction_6adb0ab8] = None,
         log_retention: typing.Optional[_RetentionDays_070f99f0] = None,
         provider_function_env_encryption: typing.Optional[_IKey_5f11635f] = None,
@@ -1677,11 +1775,13 @@ class Provider(
         total_timeout: typing.Optional[_Duration_4839e8c3] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
         vpc_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
+        waiter_state_machine_log_options: typing.Optional[typing.Union[LogOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     ) -> None:
         '''
         :param scope: -
         :param id: -
         :param on_event_handler: The AWS Lambda function to invoke for all resource lifecycle operations (CREATE/UPDATE/DELETE). This function is responsible to begin the requested resource operation (CREATE/UPDATE/DELETE) and return any additional properties to add to the event, which will later be passed to ``isComplete``. The ``PhysicalResourceId`` property must be included in the response.
+        :param disable_waiter_state_machine_logging: Whether logging for the waiter state machine is disabled. Default: - false
         :param is_complete_handler: The AWS Lambda function to invoke in order to determine if the operation is complete. This function will be called immediately after ``onEvent`` and then periodically based on the configured query interval as long as it returns ``false``. If the function still returns ``false`` and the alloted timeout has passed, the operation will fail. Default: - provider is synchronous. This means that the ``onEvent`` handler is expected to finish all lifecycle operations within the initial invocation.
         :param log_retention: The number of days framework log events are kept in CloudWatch Logs. When updating this property, unsetting it doesn't remove the log retention policy. To remove the retention policy, set the value to ``INFINITE``. Default: logs.RetentionDays.INFINITE
         :param provider_function_env_encryption: AWS KMS key used to encrypt provider lambda's environment variables. Default: - AWS Lambda creates and uses an AWS managed customer master key (CMK)
@@ -1692,6 +1792,7 @@ class Provider(
         :param total_timeout: Total timeout for the entire operation. The maximum timeout is 1 hour (yes, it can exceed the AWS Lambda 15 minutes) Default: Duration.minutes(30)
         :param vpc: The vpc to provision the lambda functions in. Default: - functions are not provisioned inside a vpc.
         :param vpc_subnets: Which subnets from the VPC to place the lambda functions in. Only used if 'vpc' is supplied. Note: internet access for Lambdas requires a NAT gateway, so picking Public subnets is not allowed. Default: - the Vpc default strategy if not specified
+        :param waiter_state_machine_log_options: Defines what execution history events of the waiter state machine are logged and where they are logged. Default: - A default log group will be created if logging for the waiter state machine is enabled.
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__29415d7bf7977fcf110b77ce69cec309dcf0404601944735020770ddfe2b01a8)
@@ -1699,6 +1800,7 @@ class Provider(
             check_type(argname="argument id", value=id, expected_type=type_hints["id"])
         props = ProviderProps(
             on_event_handler=on_event_handler,
+            disable_waiter_state_machine_logging=disable_waiter_state_machine_logging,
             is_complete_handler=is_complete_handler,
             log_retention=log_retention,
             provider_function_env_encryption=provider_function_env_encryption,
@@ -1709,6 +1811,7 @@ class Provider(
             total_timeout=total_timeout,
             vpc=vpc,
             vpc_subnets=vpc_subnets,
+            waiter_state_machine_log_options=waiter_state_machine_log_options,
         )
 
         jsii.create(self.__class__, self, [scope, id, props])
@@ -1737,6 +1840,7 @@ class Provider(
     jsii_struct_bases=[],
     name_mapping={
         "on_event_handler": "onEventHandler",
+        "disable_waiter_state_machine_logging": "disableWaiterStateMachineLogging",
         "is_complete_handler": "isCompleteHandler",
         "log_retention": "logRetention",
         "provider_function_env_encryption": "providerFunctionEnvEncryption",
@@ -1747,6 +1851,7 @@ class Provider(
         "total_timeout": "totalTimeout",
         "vpc": "vpc",
         "vpc_subnets": "vpcSubnets",
+        "waiter_state_machine_log_options": "waiterStateMachineLogOptions",
     },
 )
 class ProviderProps:
@@ -1754,6 +1859,7 @@ class ProviderProps:
         self,
         *,
         on_event_handler: _IFunction_6adb0ab8,
+        disable_waiter_state_machine_logging: typing.Optional[builtins.bool] = None,
         is_complete_handler: typing.Optional[_IFunction_6adb0ab8] = None,
         log_retention: typing.Optional[_RetentionDays_070f99f0] = None,
         provider_function_env_encryption: typing.Optional[_IKey_5f11635f] = None,
@@ -1764,10 +1870,12 @@ class ProviderProps:
         total_timeout: typing.Optional[_Duration_4839e8c3] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
         vpc_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
+        waiter_state_machine_log_options: typing.Optional[typing.Union[LogOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     ) -> None:
         '''Initialization properties for the ``Provider`` construct.
 
         :param on_event_handler: The AWS Lambda function to invoke for all resource lifecycle operations (CREATE/UPDATE/DELETE). This function is responsible to begin the requested resource operation (CREATE/UPDATE/DELETE) and return any additional properties to add to the event, which will later be passed to ``isComplete``. The ``PhysicalResourceId`` property must be included in the response.
+        :param disable_waiter_state_machine_logging: Whether logging for the waiter state machine is disabled. Default: - false
         :param is_complete_handler: The AWS Lambda function to invoke in order to determine if the operation is complete. This function will be called immediately after ``onEvent`` and then periodically based on the configured query interval as long as it returns ``false``. If the function still returns ``false`` and the alloted timeout has passed, the operation will fail. Default: - provider is synchronous. This means that the ``onEvent`` handler is expected to finish all lifecycle operations within the initial invocation.
         :param log_retention: The number of days framework log events are kept in CloudWatch Logs. When updating this property, unsetting it doesn't remove the log retention policy. To remove the retention policy, set the value to ``INFINITE``. Default: logs.RetentionDays.INFINITE
         :param provider_function_env_encryption: AWS KMS key used to encrypt provider lambda's environment variables. Default: - AWS Lambda creates and uses an AWS managed customer master key (CMK)
@@ -1778,6 +1886,7 @@ class ProviderProps:
         :param total_timeout: Total timeout for the entire operation. The maximum timeout is 1 hour (yes, it can exceed the AWS Lambda 15 minutes) Default: Duration.minutes(30)
         :param vpc: The vpc to provision the lambda functions in. Default: - functions are not provisioned inside a vpc.
         :param vpc_subnets: Which subnets from the VPC to place the lambda functions in. Only used if 'vpc' is supplied. Note: internet access for Lambdas requires a NAT gateway, so picking Public subnets is not allowed. Default: - the Vpc default strategy if not specified
+        :param waiter_state_machine_log_options: Defines what execution history events of the waiter state machine are logged and where they are logged. Default: - A default log group will be created if logging for the waiter state machine is enabled.
 
         :exampleMetadata: infused
 
@@ -1797,9 +1906,12 @@ class ProviderProps:
         '''
         if isinstance(vpc_subnets, dict):
             vpc_subnets = _SubnetSelection_e57d76df(**vpc_subnets)
+        if isinstance(waiter_state_machine_log_options, dict):
+            waiter_state_machine_log_options = LogOptions(**waiter_state_machine_log_options)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__32b03803ee02437d8d83814282c700ede5633030e4d9f7ebdaf3b9d075b0cbdb)
             check_type(argname="argument on_event_handler", value=on_event_handler, expected_type=type_hints["on_event_handler"])
+            check_type(argname="argument disable_waiter_state_machine_logging", value=disable_waiter_state_machine_logging, expected_type=type_hints["disable_waiter_state_machine_logging"])
             check_type(argname="argument is_complete_handler", value=is_complete_handler, expected_type=type_hints["is_complete_handler"])
             check_type(argname="argument log_retention", value=log_retention, expected_type=type_hints["log_retention"])
             check_type(argname="argument provider_function_env_encryption", value=provider_function_env_encryption, expected_type=type_hints["provider_function_env_encryption"])
@@ -1810,9 +1922,12 @@ class ProviderProps:
             check_type(argname="argument total_timeout", value=total_timeout, expected_type=type_hints["total_timeout"])
             check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
             check_type(argname="argument vpc_subnets", value=vpc_subnets, expected_type=type_hints["vpc_subnets"])
+            check_type(argname="argument waiter_state_machine_log_options", value=waiter_state_machine_log_options, expected_type=type_hints["waiter_state_machine_log_options"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "on_event_handler": on_event_handler,
         }
+        if disable_waiter_state_machine_logging is not None:
+            self._values["disable_waiter_state_machine_logging"] = disable_waiter_state_machine_logging
         if is_complete_handler is not None:
             self._values["is_complete_handler"] = is_complete_handler
         if log_retention is not None:
@@ -1833,6 +1948,8 @@ class ProviderProps:
             self._values["vpc"] = vpc
         if vpc_subnets is not None:
             self._values["vpc_subnets"] = vpc_subnets
+        if waiter_state_machine_log_options is not None:
+            self._values["waiter_state_machine_log_options"] = waiter_state_machine_log_options
 
     @builtins.property
     def on_event_handler(self) -> _IFunction_6adb0ab8:
@@ -1847,6 +1964,15 @@ class ProviderProps:
         assert result is not None, "Required property 'on_event_handler' is missing"
         return typing.cast(_IFunction_6adb0ab8, result)
 
+    @builtins.property
+    def disable_waiter_state_machine_logging(self) -> typing.Optional[builtins.bool]:
+        '''Whether logging for the waiter state machine is disabled.
+
+        :default: - false
+        '''
+        result = self._values.get("disable_waiter_state_machine_logging")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
     @builtins.property
     def is_complete_handler(self) -> typing.Optional[_IFunction_6adb0ab8]:
         '''The AWS Lambda function to invoke in order to determine if the operation is complete.
@@ -1968,6 +2094,15 @@ class ProviderProps:
         result = self._values.get("vpc_subnets")
         return typing.cast(typing.Optional[_SubnetSelection_e57d76df], result)
 
+    @builtins.property
+    def waiter_state_machine_log_options(self) -> typing.Optional[LogOptions]:
+        '''Defines what execution history events of the waiter state machine are logged and where they are logged.
+
+        :default: - A default log group will be created if logging for the waiter state machine is enabled.
+        '''
+        result = self._values.get("waiter_state_machine_log_options")
+        return typing.cast(typing.Optional[LogOptions], result)
+
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -2045,16 +2180,276 @@ class SdkCallsPolicyOptions:
         )
 
 
+class WaiterStateMachine(
+    _constructs_77d1e7e8.Construct,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.custom_resources.WaiterStateMachine",
+):
+    '''A very simple StateMachine construct highly customized to the provider framework.
+
+    We previously used ``CfnResource`` instead of ``CfnStateMachine`` to avoid depending
+    on ``aws-stepfunctions`` module, but now it is okay.
+
+    The state machine continuously calls the isCompleteHandler, until it succeeds or times out.
+    The handler is called ``maxAttempts`` times with an ``interval`` duration and a ``backoffRate`` rate.
+
+    :exampleMetadata: fixture=_generated
+
+    Example::
+
+        # The code below shows an example of how to instantiate this type.
+        # The values are placeholders you should change.
+        import aws_cdk as cdk
+        from aws_cdk import aws_lambda as lambda_
+        from aws_cdk import aws_logs as logs
+        from aws_cdk import aws_stepfunctions as stepfunctions
+        from aws_cdk import custom_resources
+        
+        # function_: lambda.Function
+        # log_group: logs.LogGroup
+        
+        waiter_state_machine = custom_resources.WaiterStateMachine(self, "MyWaiterStateMachine",
+            backoff_rate=123,
+            interval=cdk.Duration.minutes(30),
+            is_complete_handler=function_,
+            max_attempts=123,
+            timeout_handler=function_,
+        
+            # the properties below are optional
+            disable_logging=False,
+            log_options=custom_resources.LogOptions(
+                destination=log_group,
+                include_execution_data=False,
+                level=stepfunctions.LogLevel.OFF
+            )
+        )
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        backoff_rate: jsii.Number,
+        interval: _Duration_4839e8c3,
+        is_complete_handler: _IFunction_6adb0ab8,
+        max_attempts: jsii.Number,
+        timeout_handler: _IFunction_6adb0ab8,
+        disable_logging: typing.Optional[builtins.bool] = None,
+        log_options: typing.Optional[typing.Union[LogOptions, typing.Dict[builtins.str, typing.Any]]] = None,
+    ) -> None:
+        '''
+        :param scope: -
+        :param id: -
+        :param backoff_rate: Backoff between attempts.
+        :param interval: The interval to wait between attempts.
+        :param is_complete_handler: The main handler that notifies if the waiter to decide 'complete' or 'incomplete'.
+        :param max_attempts: Number of attempts.
+        :param timeout_handler: The handler to call if the waiter times out and is incomplete.
+        :param disable_logging: Whether logging for the state machine is disabled. Default: - false
+        :param log_options: Defines what execution history events are logged and where they are logged. Default: - A default log group will be created if logging is enabled.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__12427b739f326cdb535d2aaf4a70f10977eec5711902d4e5e395f0b8c9bb184e)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        props = WaiterStateMachineProps(
+            backoff_rate=backoff_rate,
+            interval=interval,
+            is_complete_handler=is_complete_handler,
+            max_attempts=max_attempts,
+            timeout_handler=timeout_handler,
+            disable_logging=disable_logging,
+            log_options=log_options,
+        )
+
+        jsii.create(self.__class__, self, [scope, id, props])
+
+    @jsii.member(jsii_name="grantStartExecution")
+    def grant_start_execution(self, identity: _IGrantable_71c4f5de) -> _Grant_a7ae64f8:
+        '''Grant the given identity permissions on StartExecution of the state machine.
+
+        :param identity: -
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__2c3d1c306ca04ebd1194ce4f97bed6aa9510a02067654b39f43a1ecef601e3db)
+            check_type(argname="argument identity", value=identity, expected_type=type_hints["identity"])
+        return typing.cast(_Grant_a7ae64f8, jsii.invoke(self, "grantStartExecution", [identity]))
+
+    @builtins.property
+    @jsii.member(jsii_name="stateMachineArn")
+    def state_machine_arn(self) -> builtins.str:
+        '''The ARN of the state machine.'''
+        return typing.cast(builtins.str, jsii.get(self, "stateMachineArn"))
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.custom_resources.WaiterStateMachineProps",
+    jsii_struct_bases=[],
+    name_mapping={
+        "backoff_rate": "backoffRate",
+        "interval": "interval",
+        "is_complete_handler": "isCompleteHandler",
+        "max_attempts": "maxAttempts",
+        "timeout_handler": "timeoutHandler",
+        "disable_logging": "disableLogging",
+        "log_options": "logOptions",
+    },
+)
+class WaiterStateMachineProps:
+    def __init__(
+        self,
+        *,
+        backoff_rate: jsii.Number,
+        interval: _Duration_4839e8c3,
+        is_complete_handler: _IFunction_6adb0ab8,
+        max_attempts: jsii.Number,
+        timeout_handler: _IFunction_6adb0ab8,
+        disable_logging: typing.Optional[builtins.bool] = None,
+        log_options: typing.Optional[typing.Union[LogOptions, typing.Dict[builtins.str, typing.Any]]] = None,
+    ) -> None:
+        '''Initialization properties for the ``WaiterStateMachine`` construct.
+
+        :param backoff_rate: Backoff between attempts.
+        :param interval: The interval to wait between attempts.
+        :param is_complete_handler: The main handler that notifies if the waiter to decide 'complete' or 'incomplete'.
+        :param max_attempts: Number of attempts.
+        :param timeout_handler: The handler to call if the waiter times out and is incomplete.
+        :param disable_logging: Whether logging for the state machine is disabled. Default: - false
+        :param log_options: Defines what execution history events are logged and where they are logged. Default: - A default log group will be created if logging is enabled.
+
+        :exampleMetadata: fixture=_generated
+
+        Example::
+
+            # The code below shows an example of how to instantiate this type.
+            # The values are placeholders you should change.
+            import aws_cdk as cdk
+            from aws_cdk import aws_lambda as lambda_
+            from aws_cdk import aws_logs as logs
+            from aws_cdk import aws_stepfunctions as stepfunctions
+            from aws_cdk import custom_resources
+            
+            # function_: lambda.Function
+            # log_group: logs.LogGroup
+            
+            waiter_state_machine_props = custom_resources.WaiterStateMachineProps(
+                backoff_rate=123,
+                interval=cdk.Duration.minutes(30),
+                is_complete_handler=function_,
+                max_attempts=123,
+                timeout_handler=function_,
+            
+                # the properties below are optional
+                disable_logging=False,
+                log_options=custom_resources.LogOptions(
+                    destination=log_group,
+                    include_execution_data=False,
+                    level=stepfunctions.LogLevel.OFF
+                )
+            )
+        '''
+        if isinstance(log_options, dict):
+            log_options = LogOptions(**log_options)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__569ff1333551048ad82f7261bcf43cbefe118e974cba179165c355fc9347fc13)
+            check_type(argname="argument backoff_rate", value=backoff_rate, expected_type=type_hints["backoff_rate"])
+            check_type(argname="argument interval", value=interval, expected_type=type_hints["interval"])
+            check_type(argname="argument is_complete_handler", value=is_complete_handler, expected_type=type_hints["is_complete_handler"])
+            check_type(argname="argument max_attempts", value=max_attempts, expected_type=type_hints["max_attempts"])
+            check_type(argname="argument timeout_handler", value=timeout_handler, expected_type=type_hints["timeout_handler"])
+            check_type(argname="argument disable_logging", value=disable_logging, expected_type=type_hints["disable_logging"])
+            check_type(argname="argument log_options", value=log_options, expected_type=type_hints["log_options"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "backoff_rate": backoff_rate,
+            "interval": interval,
+            "is_complete_handler": is_complete_handler,
+            "max_attempts": max_attempts,
+            "timeout_handler": timeout_handler,
+        }
+        if disable_logging is not None:
+            self._values["disable_logging"] = disable_logging
+        if log_options is not None:
+            self._values["log_options"] = log_options
+
+    @builtins.property
+    def backoff_rate(self) -> jsii.Number:
+        '''Backoff between attempts.'''
+        result = self._values.get("backoff_rate")
+        assert result is not None, "Required property 'backoff_rate' is missing"
+        return typing.cast(jsii.Number, result)
+
+    @builtins.property
+    def interval(self) -> _Duration_4839e8c3:
+        '''The interval to wait between attempts.'''
+        result = self._values.get("interval")
+        assert result is not None, "Required property 'interval' is missing"
+        return typing.cast(_Duration_4839e8c3, result)
+
+    @builtins.property
+    def is_complete_handler(self) -> _IFunction_6adb0ab8:
+        '''The main handler that notifies if the waiter to decide 'complete' or 'incomplete'.'''
+        result = self._values.get("is_complete_handler")
+        assert result is not None, "Required property 'is_complete_handler' is missing"
+        return typing.cast(_IFunction_6adb0ab8, result)
+
+    @builtins.property
+    def max_attempts(self) -> jsii.Number:
+        '''Number of attempts.'''
+        result = self._values.get("max_attempts")
+        assert result is not None, "Required property 'max_attempts' is missing"
+        return typing.cast(jsii.Number, result)
+
+    @builtins.property
+    def timeout_handler(self) -> _IFunction_6adb0ab8:
+        '''The handler to call if the waiter times out and is incomplete.'''
+        result = self._values.get("timeout_handler")
+        assert result is not None, "Required property 'timeout_handler' is missing"
+        return typing.cast(_IFunction_6adb0ab8, result)
+
+    @builtins.property
+    def disable_logging(self) -> typing.Optional[builtins.bool]:
+        '''Whether logging for the state machine is disabled.
+
+        :default: - false
+        '''
+        result = self._values.get("disable_logging")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def log_options(self) -> typing.Optional[LogOptions]:
+        '''Defines what execution history events are logged and where they are logged.
+
+        :default: - A default log group will be created if logging is enabled.
+        '''
+        result = self._values.get("log_options")
+        return typing.cast(typing.Optional[LogOptions], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "WaiterStateMachineProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 __all__ = [
     "AwsCustomResource",
     "AwsCustomResourcePolicy",
     "AwsCustomResourceProps",
     "AwsSdkCall",
+    "LogOptions",
     "PhysicalResourceId",
     "PhysicalResourceIdReference",
     "Provider",
     "ProviderProps",
     "SdkCallsPolicyOptions",
+    "WaiterStateMachine",
+    "WaiterStateMachineProps",
 ]
 
 publication.publish()
@@ -2132,6 +2527,15 @@ def _typecheckingstub__af7bb124668b93c6ce7d641df2daeabfe424e271742385a76e7e56ec9
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__2622296f61199d2b10825c21d976c0578e9488ad1b2b7635565f604c598734b7(
+    *,
+    destination: typing.Optional[_ILogGroup_3c4fa718] = None,
+    include_execution_data: typing.Optional[builtins.bool] = None,
+    level: typing.Optional[_LogLevel_be1990fe] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__6baa8764ccdf77f11bd8f80af9fafec69f56b719c1a237caae55c7f988e174b6(
     response_path: builtins.str,
 ) -> None:
@@ -2155,6 +2559,7 @@ def _typecheckingstub__29415d7bf7977fcf110b77ce69cec309dcf0404601944735020770ddf
     id: builtins.str,
     *,
     on_event_handler: _IFunction_6adb0ab8,
+    disable_waiter_state_machine_logging: typing.Optional[builtins.bool] = None,
     is_complete_handler: typing.Optional[_IFunction_6adb0ab8] = None,
     log_retention: typing.Optional[_RetentionDays_070f99f0] = None,
     provider_function_env_encryption: typing.Optional[_IKey_5f11635f] = None,
@@ -2165,6 +2570,7 @@ def _typecheckingstub__29415d7bf7977fcf110b77ce69cec309dcf0404601944735020770ddf
     total_timeout: typing.Optional[_Duration_4839e8c3] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
     vpc_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
+    waiter_state_machine_log_options: typing.Optional[typing.Union[LogOptions, typing.Dict[builtins.str, typing.Any]]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -2172,6 +2578,7 @@ def _typecheckingstub__29415d7bf7977fcf110b77ce69cec309dcf0404601944735020770ddf
 def _typecheckingstub__32b03803ee02437d8d83814282c700ede5633030e4d9f7ebdaf3b9d075b0cbdb(
     *,
     on_event_handler: _IFunction_6adb0ab8,
+    disable_waiter_state_machine_logging: typing.Optional[builtins.bool] = None,
     is_complete_handler: typing.Optional[_IFunction_6adb0ab8] = None,
     log_retention: typing.Optional[_RetentionDays_070f99f0] = None,
     provider_function_env_encryption: typing.Optional[_IKey_5f11635f] = None,
@@ -2182,6 +2589,7 @@ def _typecheckingstub__32b03803ee02437d8d83814282c700ede5633030e4d9f7ebdaf3b9d07
     total_timeout: typing.Optional[_Duration_4839e8c3] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
     vpc_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
+    waiter_state_machine_log_options: typing.Optional[typing.Union[LogOptions, typing.Dict[builtins.str, typing.Any]]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -2192,3 +2600,37 @@ def _typecheckingstub__0cd00e8add38e42b6c4d7db0390a899ccaf5bbe0367bfb387986125da
 ) -> None:
     """Type checking stubs"""
     pass
+
+def _typecheckingstub__12427b739f326cdb535d2aaf4a70f10977eec5711902d4e5e395f0b8c9bb184e(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    backoff_rate: jsii.Number,
+    interval: _Duration_4839e8c3,
+    is_complete_handler: _IFunction_6adb0ab8,
+    max_attempts: jsii.Number,
+    timeout_handler: _IFunction_6adb0ab8,
+    disable_logging: typing.Optional[builtins.bool] = None,
+    log_options: typing.Optional[typing.Union[LogOptions, typing.Dict[builtins.str, typing.Any]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__2c3d1c306ca04ebd1194ce4f97bed6aa9510a02067654b39f43a1ecef601e3db(
+    identity: _IGrantable_71c4f5de,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__569ff1333551048ad82f7261bcf43cbefe118e974cba179165c355fc9347fc13(
+    *,
+    backoff_rate: jsii.Number,
+    interval: _Duration_4839e8c3,
+    is_complete_handler: _IFunction_6adb0ab8,
+    max_attempts: jsii.Number,
+    timeout_handler: _IFunction_6adb0ab8,
+    disable_logging: typing.Optional[builtins.bool] = None,
+    log_options: typing.Optional[typing.Union[LogOptions, typing.Dict[builtins.str, typing.Any]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass

aws_cdk/triggers/__init__.py

@@ -451,7 +451,7 @@ class TriggerFunction(
         :param execute_before: Adds this trigger as a dependency on other constructs. This means that this trigger will get executed *before* the given construct(s). You can also use ``trigger.executeBefore()`` to add additional dependants. Default: []
         :param execute_on_handler_change: Re-executes the trigger every time the handler changes. This implies that the trigger is associated with the ``currentVersion`` of the handler, which gets recreated every time the handler or its configuration is updated. Default: true
         :param adot_instrumentation: Specify the configuration of AWS Distro for OpenTelemetry (ADOT) instrumentation. Default: - No ADOT instrumentation
-        :param allow_all_outbound: Whether to allow the Lambda to send all network traffic. If set to false, you must individually add traffic rules to allow the Lambda to connect to network targets. Default: true
+        :param allow_all_outbound: Whether to allow the Lambda to send all network traffic. If set to false, you must individually add traffic rules to allow the Lambda to connect to network targets. Do not specify this property if the ``securityGroups`` or ``securityGroup`` property is set. Instead, configure ``allowAllOutbound`` directly on the security group. Default: true
         :param allow_public_subnet: Lambda Functions in a public subnet can NOT access the internet. Use this property to acknowledge this limitation and still place the function in a public subnet. Default: false
         :param application_log_level: Sets the application log level for the function. Default: INFO
         :param architecture: The system architectures compatible with this lambda function. Default: Architecture.X86_64
@@ -974,7 +974,7 @@ class TriggerFunctionProps(_FunctionProps_a308e854, TriggerOptions):
         :param on_success: The destination for successful invocations. Default: - no destination
         :param retry_attempts: The maximum number of times to retry when the function returns an error. Minimum: 0 Maximum: 2 Default: 2
         :param adot_instrumentation: Specify the configuration of AWS Distro for OpenTelemetry (ADOT) instrumentation. Default: - No ADOT instrumentation
-        :param allow_all_outbound: Whether to allow the Lambda to send all network traffic. If set to false, you must individually add traffic rules to allow the Lambda to connect to network targets. Default: true
+        :param allow_all_outbound: Whether to allow the Lambda to send all network traffic. If set to false, you must individually add traffic rules to allow the Lambda to connect to network targets. Do not specify this property if the ``securityGroups`` or ``securityGroup`` property is set. Instead, configure ``allowAllOutbound`` directly on the security group. Default: true
         :param allow_public_subnet: Lambda Functions in a public subnet can NOT access the internet. Use this property to acknowledge this limitation and still place the function in a public subnet. Default: false
         :param application_log_level: Sets the application log level for the function. Default: INFO
         :param architecture: The system architectures compatible with this lambda function. Default: Architecture.X86_64
@@ -1251,6 +1251,9 @@ class TriggerFunctionProps(_FunctionProps_a308e854, TriggerOptions):
         If set to false, you must individually add traffic rules to allow the
         Lambda to connect to network targets.
 
+        Do not specify this property if the ``securityGroups`` or ``securityGroup`` property is set.
+        Instead, configure ``allowAllOutbound`` directly on the security group.
+
         :default: true
         '''
         result = self._values.get("allow_all_outbound")

{aws_cdk_lib-2.115.0.dist-info → aws_cdk_lib-2.116.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aws-cdk-lib
-Version: 2.115.0
+Version: 2.116.1
 Summary: Version 2 of the AWS Cloud Development Kit library
 Home-page: https://github.com/aws/aws-cdk
 Author: Amazon Web Services