Package software.amazon.awscdk.integtests.alpha

Interface WaiterStateMachineOptions

All Superinterfaces:
software.amazon.jsii.JsiiSerializable
All Known Subinterfaces:
WaiterStateMachineProps
All Known Implementing Classes:
WaiterStateMachineOptions.Jsii$Proxy, WaiterStateMachineProps.Jsii$Proxy
@Generated(value="jsii-pacmak/1.116.0 (build 0eddcff)", date="2025-10-29T11:15:51.062Z") @Stability(Experimental) public interface WaiterStateMachineOptions extends software.amazon.jsii.JsiiSerializable
(experimental) Options for creating a WaiterStateMachine.

Example: 

 import path.*;
 import software.amazon.awscdk.services.kinesisfirehose.*;
 import software.amazon.awscdk.services.kms.*;
 import software.amazon.awscdk.services.lambda.nodejs.*;
 import software.amazon.awscdk.services.logs.*;
 import software.amazon.awscdk.services.s3.*;
 import software.amazon.awscdk.*;
 import software.amazon.awscdk.integtests.alpha.AwsApiCall;
 import software.amazon.awscdk.integtests.alpha.ExpectedResult;
 import software.amazon.awscdk.integtests.alpha.IntegTest;
 App app = App.Builder.create()
         .postCliContext(Map.of(
                 "@aws-cdk/aws-lambda:useCdkManagedLogGroup", false))
         .build();
 Stack stack = new Stack(app, "aws-cdk-firehose-delivery-stream-s3-all-properties");
 Bucket bucket = Bucket.Builder.create(stack, "FirehoseDeliveryStreamS3AllPropertiesBucket")
         .removalPolicy(RemovalPolicy.DESTROY)
         .autoDeleteObjects(true)
         .build();
 Bucket backupBucket = Bucket.Builder.create(stack, "FirehoseDeliveryStreamS3AllPropertiesBackupBucket")
         .removalPolicy(RemovalPolicy.DESTROY)
         .autoDeleteObjects(true)
         .build();
 LogGroup logGroup = LogGroup.Builder.create(stack, "LogGroup")
         .removalPolicy(RemovalPolicy.DESTROY)
         .build();
 NodejsFunction dataProcessorFunction = NodejsFunction.Builder.create(stack, "DataProcessorFunction")
         .entry(join(__dirname, "lambda-data-processor.js"))
         .timeout(Duration.minutes(1))
         .build();
 LambdaFunctionProcessor processor = LambdaFunctionProcessor.Builder.create(dataProcessorFunction)
         .bufferInterval(Duration.seconds(60))
         .bufferSize(Size.mebibytes(1))
         .retries(1)
         .build();
 Key key = Key.Builder.create(stack, "Key")
         .removalPolicy(RemovalPolicy.DESTROY)
         .build();
 Key backupKey = Key.Builder.create(stack, "BackupKey")
         .removalPolicy(RemovalPolicy.DESTROY)
         .build();
 DeliveryStream deliveryStream = DeliveryStream.Builder.create(stack, "DeliveryStream")
         .destination(S3Bucket.Builder.create(bucket)
                 .loggingConfig(new EnableLogging(logGroup))
                 .processor(processor)
                 .compression(Compression.GZIP)
                 .dataOutputPrefix("regularPrefix")
                 .errorOutputPrefix("errorPrefix")
                 .fileExtension(".log.gz")
                 .timeZone(TimeZone.ASIA_TOKYO)
                 .bufferingInterval(Duration.seconds(60))
                 .bufferingSize(Size.mebibytes(1))
                 .encryptionKey(key)
                 .s3Backup(DestinationS3BackupProps.builder()
                         .mode(BackupMode.ALL)
                         .bucket(backupBucket)
                         .compression(Compression.ZIP)
                         .dataOutputPrefix("backupPrefix")
                         .errorOutputPrefix("backupErrorPrefix")
                         .bufferingInterval(Duration.seconds(60))
                         .bufferingSize(Size.mebibytes(1))
                         .encryptionKey(backupKey)
                         .build())
                 .build())
         .build();
 DeliveryStream.Builder.create(stack, "ZeroBufferingDeliveryStream")
         .destination(S3Bucket.Builder.create(bucket)
                 .compression(Compression.GZIP)
                 .dataOutputPrefix("regularPrefix")
                 .errorOutputPrefix("errorPrefix")
                 .bufferingInterval(Duration.seconds(0))
                 .build())
         .build();
 IntegTest testCase = IntegTest.Builder.create(app, "integ-tests")
         .testCases(List.of(stack))
         .regions(List.of("us-east-1"))
         .build();
 testCase.assertions.awsApiCall("Firehose", "putRecord", Map.of(
         "DeliveryStreamName", deliveryStream.getDeliveryStreamName(),
         "Record", Map.of(
                 "Data", "testData123")));
 IApiCall s3ApiCall = testCase.assertions.awsApiCall("S3", "listObjectsV2", Map.of(
         "Bucket", bucket.bucketName,
         "MaxKeys", 1)).expect(ExpectedResult.objectLike(Map.of(
         "KeyCount", 1))).waitForAssertions(WaiterStateMachineOptions.builder()
         .interval(Duration.seconds(30))
         .totalTimeout(Duration.minutes(10))
         .build());
 if (s3ApiCall instanceof AwsApiCall && s3ApiCall.getWaiterProvider()) {
     s3ApiCall.waiterProvider.addToRolePolicy(Map.of(
             "Effect", "Allow",
             "Action", List.of("s3:GetObject", "s3:ListBucket"),
             "Resource", List.of("*")));
 }

  • Method Details

    • getBackoffRate

      @Stability(Experimental) @Nullable default Number getBackoffRate()
      (experimental) Backoff between attempts.

      This is the multiplier by which the retry interval increases after each retry attempt.

      By default there is no backoff. Each retry will wait the amount of time specified by interval.

      Default: 1 (no backoff)

    • getInterval

      @Stability(Experimental) @Nullable default Duration getInterval()
      (experimental) The interval (number of seconds) to wait between attempts.

      Default: Duration.seconds(5)

    • getTotalTimeout

      @Stability(Experimental) @Nullable default Duration getTotalTimeout()
      (experimental) The total time that the state machine will wait for a successful response.

      Default: Duration.minutes(30)

    • builder

      @Stability(Experimental) static WaiterStateMachineOptions.Builder builder()
      Returns:
      a WaiterStateMachineOptions.Builder of WaiterStateMachineOptions