aws-cdk-lib 2.138.0__py3-none-any.whl → 2.139.1__py3-none-any.whl

aws_cdk/custom_resources/__init__.py

@@ -820,6 +820,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,
@@ -830,6 +831,7 @@ from ..aws_lambda import IFunction as _IFunction_6adb0ab8
 from ..aws_logs import (
     ILogGroup as _ILogGroup_3c4fa718, RetentionDays as _RetentionDays_070f99f0
 )
+from ..aws_stepfunctions import LogLevel as _LogLevel_be1990fe
 
 
 @jsii.implements(_IGrantable_71c4f5de)
@@ -1624,6 +1626,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 Logging(
     metaclass=jsii.JSIIAbstractClass,
     jsii_type="aws-cdk-lib.custom_resources.Logging",
@@ -1918,6 +2013,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_group: typing.Optional[_ILogGroup_3c4fa718] = None,
         log_retention: typing.Optional[_RetentionDays_070f99f0] = None,
@@ -1929,11 +2025,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_group: The Log Group used for logging of events emitted by the custom resource's lambda function. Providing a user-controlled log group was rolled out to commercial regions on 2023-11-16. If you are deploying to another type of region, please check regional availability first. Default: - a default log group created by AWS Lambda
         :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``. This is a legacy API and we strongly recommend you migrate to ``logGroup`` if you can. ``logGroup`` allows you to create a fully customizable log group and instruct the Lambda function to send logs to it. Default: logs.RetentionDays.INFINITE
@@ -1945,6 +2043,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)
@@ -1952,6 +2051,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_group=log_group,
             log_retention=log_retention,
@@ -1963,6 +2063,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])
@@ -1991,6 +2092,7 @@ class Provider(
     jsii_struct_bases=[],
     name_mapping={
         "on_event_handler": "onEventHandler",
+        "disable_waiter_state_machine_logging": "disableWaiterStateMachineLogging",
         "is_complete_handler": "isCompleteHandler",
         "log_group": "logGroup",
         "log_retention": "logRetention",
@@ -2002,6 +2104,7 @@ class Provider(
         "total_timeout": "totalTimeout",
         "vpc": "vpc",
         "vpc_subnets": "vpcSubnets",
+        "waiter_state_machine_log_options": "waiterStateMachineLogOptions",
     },
 )
 class ProviderProps:
@@ -2009,6 +2112,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_group: typing.Optional[_ILogGroup_3c4fa718] = None,
         log_retention: typing.Optional[_RetentionDays_070f99f0] = None,
@@ -2020,10 +2124,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_group: The Log Group used for logging of events emitted by the custom resource's lambda function. Providing a user-controlled log group was rolled out to commercial regions on 2023-11-16. If you are deploying to another type of region, please check regional availability first. Default: - a default log group created by AWS Lambda
         :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``. This is a legacy API and we strongly recommend you migrate to ``logGroup`` if you can. ``logGroup`` allows you to create a fully customizable log group and instruct the Lambda function to send logs to it. Default: logs.RetentionDays.INFINITE
@@ -2035,6 +2141,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
 
@@ -2056,9 +2163,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_group", value=log_group, expected_type=type_hints["log_group"])
             check_type(argname="argument log_retention", value=log_retention, expected_type=type_hints["log_retention"])
@@ -2070,9 +2180,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_group is not None:
@@ -2095,6 +2208,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:
@@ -2109,6 +2224,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.
@@ -2245,6 +2369,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
 
@@ -2322,11 +2455,269 @@ 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",
     "Logging",
     "LoggingProps",
     "PhysicalResourceId",
@@ -2334,6 +2725,8 @@ __all__ = [
     "Provider",
     "ProviderProps",
     "SdkCallsPolicyOptions",
+    "WaiterStateMachine",
+    "WaiterStateMachineProps",
 ]
 
 publication.publish()
@@ -2414,6 +2807,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__da0d46a1eb4b059395d06daee7dcb9417dffd0b4cf8e8942cbe0a6549f0faf4b(
     *,
     log_api_response_data: typing.Optional[builtins.bool] = None,
@@ -2444,6 +2846,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_group: typing.Optional[_ILogGroup_3c4fa718] = None,
     log_retention: typing.Optional[_RetentionDays_070f99f0] = None,
@@ -2455,6 +2858,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
@@ -2462,6 +2866,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_group: typing.Optional[_ILogGroup_3c4fa718] = None,
     log_retention: typing.Optional[_RetentionDays_070f99f0] = None,
@@ -2473,6 +2878,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
@@ -2483,3 +2889,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/cx_api/__init__.py

@@ -310,6 +310,23 @@ When this feature flag is enabled and calling KMS key grant method, the created
   }
 }
 ```
+
+* `@aws-cdk/aws-eks:nodegroupNameAttribute`
+
+When enabled, nodegroupName attribute of the provisioned EKS NodeGroup will not have the cluster name prefix.
+
+When this feature flag is enabled, the nodegroupName attribute will be exactly the name of the nodegroup
+without any prefix.
+
+*cdk.json*
+
+```json
+{
+  "context": {
+    "@aws-cdk/aws-eks:nodegroupNameAttribute": true
+  }
+}
+```
 '''
 from pkgutil import extend_path
 __path__ = extend_path(__path__, __name__)

{aws_cdk_lib-2.138.0.dist-info → aws_cdk_lib-2.139.1.dist-info}/METADATA

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