com.amazonaws.services.stepfunctions.AWSStepFunctionsAsync Maven / Gradle / Ivy
/*
* Copyright 2015-2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package com.amazonaws.services.stepfunctions;
import javax.annotation.Generated;
import com.amazonaws.services.stepfunctions.model.*;
/**
* Interface for accessing AWS SFN asynchronously. Each asynchronous method will return a Java Future object
* representing the asynchronous operation; overloads which accept an {@code AsyncHandler} can be used to receive
* notification when an asynchronous operation completes.
*
* Note: Do not directly implement this interface, new methods are added to it regularly. Extend from
* {@link com.amazonaws.services.stepfunctions.AbstractAWSStepFunctionsAsync} instead.
*
*
* AWS Step Functions
*
* AWS Step Functions is a service that lets you coordinate the components of distributed applications and microservices
* using visual workflows.
*
*
* You can use Step Functions to build applications from individual components, each of which performs a discrete
* function, or task, allowing you to scale and change applications quickly. Step Functions provides a console
* that helps visualize the components of your application as a series of steps. Step Functions automatically triggers
* and tracks each step, and retries steps when there are errors, so your application executes predictably and in the
* right order every time. Step Functions logs the state of each step, so you can quickly diagnose and debug any issues.
*
*
* Step Functions manages operations and underlying infrastructure to ensure your application is available at any scale.
* You can run tasks on AWS, your own servers, or any system that has access to AWS. You can access and use Step
* Functions using the console, the AWS SDKs, or an HTTP API. For more information about Step Functions, see the AWS Step Functions Developer Guide .
*
*/
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public interface AWSStepFunctionsAsync extends AWSStepFunctions {
/**
*
* Creates an activity. An activity is a task that you write in any programming language and host on any machine
* that has access to AWS Step Functions. Activities must poll Step Functions using the GetActivityTask
* API action and respond using SendTask* API actions. This function lets Step Functions know the
* existence of your activity and returns an identifier for use in a state machine and when polling from the
* activity.
*
*
*
* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and
* changes.
*
*
*
* CreateActivity is an idempotent API. Subsequent requests won’t create a duplicate resource if it was
* already created. CreateActivity's idempotency check is based on the activity name. If a
* following request has different tags values, Step Functions will ignore these differences and treat
* it as an idempotent request of the previous. In this case, tags will not be updated, even if they
* are different.
*
*
*
* @param createActivityRequest
* @return A Java Future containing the result of the CreateActivity operation returned by the service.
* @sample AWSStepFunctionsAsync.CreateActivity
* @see AWS API
* Documentation
*/
java.util.concurrent.Future createActivityAsync(CreateActivityRequest createActivityRequest);
/**
*
* Creates an activity. An activity is a task that you write in any programming language and host on any machine
* that has access to AWS Step Functions. Activities must poll Step Functions using the GetActivityTask
* API action and respond using SendTask* API actions. This function lets Step Functions know the
* existence of your activity and returns an identifier for use in a state machine and when polling from the
* activity.
*
*
*
* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and
* changes.
*
*
*
* CreateActivity is an idempotent API. Subsequent requests won’t create a duplicate resource if it was
* already created. CreateActivity's idempotency check is based on the activity name. If a
* following request has different tags values, Step Functions will ignore these differences and treat
* it as an idempotent request of the previous. In this case, tags will not be updated, even if they
* are different.
*
*
*
* @param createActivityRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the CreateActivity operation returned by the service.
* @sample AWSStepFunctionsAsyncHandler.CreateActivity
* @see AWS API
* Documentation
*/
java.util.concurrent.Future createActivityAsync(CreateActivityRequest createActivityRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Creates a state machine. A state machine consists of a collection of states that can do work (Task
* states), determine to which states to transition next (Choice states), stop an execution with an
* error (Fail states), and so on. State machines are specified using a JSON-based, structured
* language. For more information, see Amazon States
* Language in the AWS Step Functions User Guide.
*
*
*
* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and
* changes.
*
*
*
* CreateStateMachine is an idempotent API. Subsequent requests won’t create a duplicate resource if it
* was already created. CreateStateMachine's idempotency check is based on the state machine
* name, definition, type, and LoggingConfiguration. If a
* following request has a different roleArn or tags, Step Functions will ignore these
* differences and treat it as an idempotent request of the previous. In this case, roleArn and
* tags will not be updated, even if they are different.
*
*
*
* @param createStateMachineRequest
* @return A Java Future containing the result of the CreateStateMachine operation returned by the service.
* @sample AWSStepFunctionsAsync.CreateStateMachine
* @see AWS API
* Documentation
*/
java.util.concurrent.Future createStateMachineAsync(CreateStateMachineRequest createStateMachineRequest);
/**
*
* Creates a state machine. A state machine consists of a collection of states that can do work (Task
* states), determine to which states to transition next (Choice states), stop an execution with an
* error (Fail states), and so on. State machines are specified using a JSON-based, structured
* language. For more information, see Amazon States
* Language in the AWS Step Functions User Guide.
*
*
*
* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and
* changes.
*
*
*
* CreateStateMachine is an idempotent API. Subsequent requests won’t create a duplicate resource if it
* was already created. CreateStateMachine's idempotency check is based on the state machine
* name, definition, type, and LoggingConfiguration. If a
* following request has a different roleArn or tags, Step Functions will ignore these
* differences and treat it as an idempotent request of the previous. In this case, roleArn and
* tags will not be updated, even if they are different.
*
*
*
* @param createStateMachineRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the CreateStateMachine operation returned by the service.
* @sample AWSStepFunctionsAsyncHandler.CreateStateMachine
* @see AWS API
* Documentation
*/
java.util.concurrent.Future createStateMachineAsync(CreateStateMachineRequest createStateMachineRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deletes an activity.
*
*
* @param deleteActivityRequest
* @return A Java Future containing the result of the DeleteActivity operation returned by the service.
* @sample AWSStepFunctionsAsync.DeleteActivity
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteActivityAsync(DeleteActivityRequest deleteActivityRequest);
/**
*
* Deletes an activity.
*
*
* @param deleteActivityRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteActivity operation returned by the service.
* @sample AWSStepFunctionsAsyncHandler.DeleteActivity
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteActivityAsync(DeleteActivityRequest deleteActivityRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deletes a state machine. This is an asynchronous operation: It sets the state machine's status to
* DELETING and begins the deletion process.
*
*
*
* For EXPRESSstate machines, the deletion will happen eventually (usually less than a minute). Running
* executions may emit logs after DeleteStateMachine API is called.
*
*
*
* @param deleteStateMachineRequest
* @return A Java Future containing the result of the DeleteStateMachine operation returned by the service.
* @sample AWSStepFunctionsAsync.DeleteStateMachine
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteStateMachineAsync(DeleteStateMachineRequest deleteStateMachineRequest);
/**
*
* Deletes a state machine. This is an asynchronous operation: It sets the state machine's status to
* DELETING and begins the deletion process.
*
*
*
* For EXPRESSstate machines, the deletion will happen eventually (usually less than a minute). Running
* executions may emit logs after DeleteStateMachine API is called.
*
*
*
* @param deleteStateMachineRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteStateMachine operation returned by the service.
* @sample AWSStepFunctionsAsyncHandler.DeleteStateMachine
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteStateMachineAsync(DeleteStateMachineRequest deleteStateMachineRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Describes an activity.
*
*
*
* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and
* changes.
*
*
*
* @param describeActivityRequest
* @return A Java Future containing the result of the DescribeActivity operation returned by the service.
* @sample AWSStepFunctionsAsync.DescribeActivity
* @see AWS API
* Documentation
*/
java.util.concurrent.Future describeActivityAsync(DescribeActivityRequest describeActivityRequest);
/**
*
* Describes an activity.
*
*
*
* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and
* changes.
*
*
*
* @param describeActivityRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DescribeActivity operation returned by the service.
* @sample AWSStepFunctionsAsyncHandler.DescribeActivity
* @see AWS API
* Documentation
*/
java.util.concurrent.Future describeActivityAsync(DescribeActivityRequest describeActivityRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Describes an execution.
*
*
*
* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and
* changes.
*
*
*
* This API action is not supported by EXPRESS state machines.
*
*
* @param describeExecutionRequest
* @return A Java Future containing the result of the DescribeExecution operation returned by the service.
* @sample AWSStepFunctionsAsync.DescribeExecution
* @see AWS API
* Documentation
*/
java.util.concurrent.Future describeExecutionAsync(DescribeExecutionRequest describeExecutionRequest);
/**
*
* Describes an execution.
*
*
*
* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and
* changes.
*
*
*
* This API action is not supported by EXPRESS state machines.
*
*
* @param describeExecutionRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DescribeExecution operation returned by the service.
* @sample AWSStepFunctionsAsyncHandler.DescribeExecution
* @see AWS API
* Documentation
*/
java.util.concurrent.Future describeExecutionAsync(DescribeExecutionRequest describeExecutionRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Describes a state machine.
*
*
*
* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and
* changes.
*
*
*
* @param describeStateMachineRequest
* @return A Java Future containing the result of the DescribeStateMachine operation returned by the service.
* @sample AWSStepFunctionsAsync.DescribeStateMachine
* @see AWS
* API Documentation
*/
java.util.concurrent.Future describeStateMachineAsync(DescribeStateMachineRequest describeStateMachineRequest);
/**
*
* Describes a state machine.
*
*
*
* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and
* changes.
*
*
*
* @param describeStateMachineRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DescribeStateMachine operation returned by the service.
* @sample AWSStepFunctionsAsyncHandler.DescribeStateMachine
* @see AWS
* API Documentation
*/
java.util.concurrent.Future describeStateMachineAsync(DescribeStateMachineRequest describeStateMachineRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Describes the state machine associated with a specific execution.
*
*
*
* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and
* changes.
*
*
*
* This API action is not supported by EXPRESS state machines.
*
*
* @param describeStateMachineForExecutionRequest
* @return A Java Future containing the result of the DescribeStateMachineForExecution operation returned by the
* service.
* @sample AWSStepFunctionsAsync.DescribeStateMachineForExecution
* @see AWS API Documentation
*/
java.util.concurrent.Future describeStateMachineForExecutionAsync(
DescribeStateMachineForExecutionRequest describeStateMachineForExecutionRequest);
/**
*
* Describes the state machine associated with a specific execution.
*
*
*
* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and
* changes.
*
*
*
* This API action is not supported by EXPRESS state machines.
*
*
* @param describeStateMachineForExecutionRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DescribeStateMachineForExecution operation returned by the
* service.
* @sample AWSStepFunctionsAsyncHandler.DescribeStateMachineForExecution
* @see AWS API Documentation
*/
java.util.concurrent.Future describeStateMachineForExecutionAsync(
DescribeStateMachineForExecutionRequest describeStateMachineForExecutionRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Used by workers to retrieve a task (with the specified activity ARN) which has been scheduled for execution by a
* running state machine. This initiates a long poll, where the service holds the HTTP connection open and responds
* as soon as a task becomes available (i.e. an execution of a task of this type is needed.) The maximum time the
* service holds on to the request before responding is 60 seconds. If no task is available within 60 seconds, the
* poll returns a taskToken with a null string.
*
*
*
* Workers should set their client side socket timeout to at least 65 seconds (5 seconds higher than the maximum
* time the service may hold the poll request).
*
*
* Polling with GetActivityTask can cause latency in some implementations. See Avoid Latency When Polling
* for Activity Tasks in the Step Functions Developer Guide.
*
*
*
* @param getActivityTaskRequest
* @return A Java Future containing the result of the GetActivityTask operation returned by the service.
* @sample AWSStepFunctionsAsync.GetActivityTask
* @see AWS API
* Documentation
*/
java.util.concurrent.Future getActivityTaskAsync(GetActivityTaskRequest getActivityTaskRequest);
/**
*
* Used by workers to retrieve a task (with the specified activity ARN) which has been scheduled for execution by a
* running state machine. This initiates a long poll, where the service holds the HTTP connection open and responds
* as soon as a task becomes available (i.e. an execution of a task of this type is needed.) The maximum time the
* service holds on to the request before responding is 60 seconds. If no task is available within 60 seconds, the
* poll returns a taskToken with a null string.
*
*
*
* Workers should set their client side socket timeout to at least 65 seconds (5 seconds higher than the maximum
* time the service may hold the poll request).
*
*
* Polling with GetActivityTask can cause latency in some implementations. See Avoid Latency When Polling
* for Activity Tasks in the Step Functions Developer Guide.
*
*
*
* @param getActivityTaskRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the GetActivityTask operation returned by the service.
* @sample AWSStepFunctionsAsyncHandler.GetActivityTask
* @see AWS API
* Documentation
*/
java.util.concurrent.Future getActivityTaskAsync(GetActivityTaskRequest getActivityTaskRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns the history of the specified execution as a list of events. By default, the results are returned in
* ascending order of the timeStamp of the events. Use the reverseOrder parameter to get
* the latest events first.
*
*
* If nextToken is returned, there are more results available. The value of nextToken is a
* unique pagination token for each page. Make the call again using the returned token to retrieve the next page.
* Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination
* token will return an HTTP 400 InvalidToken error.
*
*
* This API action is not supported by EXPRESS state machines.
*
*
* @param getExecutionHistoryRequest
* @return A Java Future containing the result of the GetExecutionHistory operation returned by the service.
* @sample AWSStepFunctionsAsync.GetExecutionHistory
* @see AWS API
* Documentation
*/
java.util.concurrent.Future getExecutionHistoryAsync(GetExecutionHistoryRequest getExecutionHistoryRequest);
/**
*
* Returns the history of the specified execution as a list of events. By default, the results are returned in
* ascending order of the timeStamp of the events. Use the reverseOrder parameter to get
* the latest events first.
*
*
* If nextToken is returned, there are more results available. The value of nextToken is a
* unique pagination token for each page. Make the call again using the returned token to retrieve the next page.
* Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination
* token will return an HTTP 400 InvalidToken error.
*
*
* This API action is not supported by EXPRESS state machines.
*
*
* @param getExecutionHistoryRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the GetExecutionHistory operation returned by the service.
* @sample AWSStepFunctionsAsyncHandler.GetExecutionHistory
* @see AWS API
* Documentation
*/
java.util.concurrent.Future getExecutionHistoryAsync(GetExecutionHistoryRequest getExecutionHistoryRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Lists the existing activities.
*
*
* If nextToken is returned, there are more results available. The value of nextToken is a
* unique pagination token for each page. Make the call again using the returned token to retrieve the next page.
* Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination
* token will return an HTTP 400 InvalidToken error.
*
*
*
* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and
* changes.
*
*
*
* @param listActivitiesRequest
* @return A Java Future containing the result of the ListActivities operation returned by the service.
* @sample AWSStepFunctionsAsync.ListActivities
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listActivitiesAsync(ListActivitiesRequest listActivitiesRequest);
/**
*
* Lists the existing activities.
*
*
* If nextToken is returned, there are more results available. The value of nextToken is a
* unique pagination token for each page. Make the call again using the returned token to retrieve the next page.
* Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination
* token will return an HTTP 400 InvalidToken error.
*
*
*
* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and
* changes.
*
*
*
* @param listActivitiesRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListActivities operation returned by the service.
* @sample AWSStepFunctionsAsyncHandler.ListActivities
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listActivitiesAsync(ListActivitiesRequest listActivitiesRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Lists the executions of a state machine that meet the filtering criteria. Results are sorted by time, with the
* most recent execution first.
*
*
* If nextToken is returned, there are more results available. The value of nextToken is a
* unique pagination token for each page. Make the call again using the returned token to retrieve the next page.
* Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination
* token will return an HTTP 400 InvalidToken error.
*
*
*
* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and
* changes.
*
*
*
* This API action is not supported by EXPRESS state machines.
*
*
* @param listExecutionsRequest
* @return A Java Future containing the result of the ListExecutions operation returned by the service.
* @sample AWSStepFunctionsAsync.ListExecutions
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listExecutionsAsync(ListExecutionsRequest listExecutionsRequest);
/**
*
* Lists the executions of a state machine that meet the filtering criteria. Results are sorted by time, with the
* most recent execution first.
*
*
* If nextToken is returned, there are more results available. The value of nextToken is a
* unique pagination token for each page. Make the call again using the returned token to retrieve the next page.
* Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination
* token will return an HTTP 400 InvalidToken error.
*
*
*
* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and
* changes.
*
*
*
* This API action is not supported by EXPRESS state machines.
*
*
* @param listExecutionsRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListExecutions operation returned by the service.
* @sample AWSStepFunctionsAsyncHandler.ListExecutions
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listExecutionsAsync(ListExecutionsRequest listExecutionsRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Lists the existing state machines.
*
*
* If nextToken is returned, there are more results available. The value of nextToken is a
* unique pagination token for each page. Make the call again using the returned token to retrieve the next page.
* Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination
* token will return an HTTP 400 InvalidToken error.
*
*
*
* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and
* changes.
*
*
*
* @param listStateMachinesRequest
* @return A Java Future containing the result of the ListStateMachines operation returned by the service.
* @sample AWSStepFunctionsAsync.ListStateMachines
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listStateMachinesAsync(ListStateMachinesRequest listStateMachinesRequest);
/**
*
* Lists the existing state machines.
*
*
* If nextToken is returned, there are more results available. The value of nextToken is a
* unique pagination token for each page. Make the call again using the returned token to retrieve the next page.
* Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination
* token will return an HTTP 400 InvalidToken error.
*
*
*
* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and
* changes.
*
*
*
* @param listStateMachinesRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListStateMachines operation returned by the service.
* @sample AWSStepFunctionsAsyncHandler.ListStateMachines
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listStateMachinesAsync(ListStateMachinesRequest listStateMachinesRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* List tags for a given resource.
*
*
* Tags may only contain Unicode letters, digits, white space, or these symbols: _ . : / = + - @.
*
*
* @param listTagsForResourceRequest
* @return A Java Future containing the result of the ListTagsForResource operation returned by the service.
* @sample AWSStepFunctionsAsync.ListTagsForResource
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listTagsForResourceAsync(ListTagsForResourceRequest listTagsForResourceRequest);
/**
*
* List tags for a given resource.
*
*
* Tags may only contain Unicode letters, digits, white space, or these symbols: _ . : / = + - @.
*
*
* @param listTagsForResourceRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListTagsForResource operation returned by the service.
* @sample AWSStepFunctionsAsyncHandler.ListTagsForResource
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listTagsForResourceAsync(ListTagsForResourceRequest listTagsForResourceRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Used by activity workers and task states using the callback pattern to report that the task identified by the taskToken failed.
*
*
* @param sendTaskFailureRequest
* @return A Java Future containing the result of the SendTaskFailure operation returned by the service.
* @sample AWSStepFunctionsAsync.SendTaskFailure
* @see AWS API
* Documentation
*/
java.util.concurrent.Future sendTaskFailureAsync(SendTaskFailureRequest sendTaskFailureRequest);
/**
*
* Used by activity workers and task states using the callback pattern to report that the task identified by the taskToken failed.
*
*
* @param sendTaskFailureRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the SendTaskFailure operation returned by the service.
* @sample AWSStepFunctionsAsyncHandler.SendTaskFailure
* @see AWS API
* Documentation
*/
java.util.concurrent.Future sendTaskFailureAsync(SendTaskFailureRequest sendTaskFailureRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Used by activity workers and task states using the callback pattern to report to Step Functions that the task represented by the specified
* taskToken is still making progress. This action resets the Heartbeat clock. The
* Heartbeat threshold is specified in the state machine's Amazon States Language definition (
* HeartbeatSeconds). This action does not in itself create an event in the execution history. However,
* if the task times out, the execution history contains an ActivityTimedOut entry for activities, or a
* TaskTimedOut entry for for tasks using the job run or
*
* callback pattern.
*
*
*
* The Timeout of a task, defined in the state machine's Amazon States Language definition, is its
* maximum allowed duration, regardless of the number of SendTaskHeartbeat requests received. Use
* HeartbeatSeconds to configure the timeout interval for heartbeats.
*
*
*
* @param sendTaskHeartbeatRequest
* @return A Java Future containing the result of the SendTaskHeartbeat operation returned by the service.
* @sample AWSStepFunctionsAsync.SendTaskHeartbeat
* @see AWS API
* Documentation
*/
java.util.concurrent.Future sendTaskHeartbeatAsync(SendTaskHeartbeatRequest sendTaskHeartbeatRequest);
/**
*
* Used by activity workers and task states using the callback pattern to report to Step Functions that the task represented by the specified
* taskToken is still making progress. This action resets the Heartbeat clock. The
* Heartbeat threshold is specified in the state machine's Amazon States Language definition (
* HeartbeatSeconds). This action does not in itself create an event in the execution history. However,
* if the task times out, the execution history contains an ActivityTimedOut entry for activities, or a
* TaskTimedOut entry for for tasks using the job run or
*
* callback pattern.
*
*
*
* The Timeout of a task, defined in the state machine's Amazon States Language definition, is its
* maximum allowed duration, regardless of the number of SendTaskHeartbeat requests received. Use
* HeartbeatSeconds to configure the timeout interval for heartbeats.
*
*
*
* @param sendTaskHeartbeatRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the SendTaskHeartbeat operation returned by the service.
* @sample AWSStepFunctionsAsyncHandler.SendTaskHeartbeat
* @see AWS API
* Documentation
*/
java.util.concurrent.Future sendTaskHeartbeatAsync(SendTaskHeartbeatRequest sendTaskHeartbeatRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Used by activity workers and task states using the callback pattern to report that the task identified by the taskToken completed successfully.
*
*
* @param sendTaskSuccessRequest
* @return A Java Future containing the result of the SendTaskSuccess operation returned by the service.
* @sample AWSStepFunctionsAsync.SendTaskSuccess
* @see AWS API
* Documentation
*/
java.util.concurrent.Future sendTaskSuccessAsync(SendTaskSuccessRequest sendTaskSuccessRequest);
/**
*
* Used by activity workers and task states using the callback pattern to report that the task identified by the taskToken completed successfully.
*
*
* @param sendTaskSuccessRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the SendTaskSuccess operation returned by the service.
* @sample AWSStepFunctionsAsyncHandler.SendTaskSuccess
* @see AWS API
* Documentation
*/
java.util.concurrent.Future sendTaskSuccessAsync(SendTaskSuccessRequest sendTaskSuccessRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Starts a state machine execution.
*
*
*
* StartExecution is idempotent. If StartExecution is called with the same name and input
* as a running execution, the call will succeed and return the same response as the original request. If the
* execution is closed or if the input is different, it will return a 400 ExecutionAlreadyExists error.
* Names can be reused after 90 days.
*
*
*
* @param startExecutionRequest
* @return A Java Future containing the result of the StartExecution operation returned by the service.
* @sample AWSStepFunctionsAsync.StartExecution
* @see AWS API
* Documentation
*/
java.util.concurrent.Future startExecutionAsync(StartExecutionRequest startExecutionRequest);
/**
*
* Starts a state machine execution.
*
*
*
* StartExecution is idempotent. If StartExecution is called with the same name and input
* as a running execution, the call will succeed and return the same response as the original request. If the
* execution is closed or if the input is different, it will return a 400 ExecutionAlreadyExists error.
* Names can be reused after 90 days.
*
*
*
* @param startExecutionRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the StartExecution operation returned by the service.
* @sample AWSStepFunctionsAsyncHandler.StartExecution
* @see AWS API
* Documentation
*/
java.util.concurrent.Future startExecutionAsync(StartExecutionRequest startExecutionRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Stops an execution.
*
*
* This API action is not supported by EXPRESS state machines.
*
*
* @param stopExecutionRequest
* @return A Java Future containing the result of the StopExecution operation returned by the service.
* @sample AWSStepFunctionsAsync.StopExecution
* @see AWS API
* Documentation
*/
java.util.concurrent.Future stopExecutionAsync(StopExecutionRequest stopExecutionRequest);
/**
*
* Stops an execution.
*
*
* This API action is not supported by EXPRESS state machines.
*
*
* @param stopExecutionRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the StopExecution operation returned by the service.
* @sample AWSStepFunctionsAsyncHandler.StopExecution
* @see AWS API
* Documentation
*/
java.util.concurrent.Future stopExecutionAsync(StopExecutionRequest stopExecutionRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Add a tag to a Step Functions resource.
*
*
* An array of key-value pairs. For more information, see Using Cost Allocation
* Tags in the AWS Billing and Cost Management User Guide, and Controlling Access Using IAM
* Tags.
*
*
* Tags may only contain Unicode letters, digits, white space, or these symbols: _ . : / = + - @.
*
*
* @param tagResourceRequest
* @return A Java Future containing the result of the TagResource operation returned by the service.
* @sample AWSStepFunctionsAsync.TagResource
* @see AWS API
* Documentation
*/
java.util.concurrent.Future tagResourceAsync(TagResourceRequest tagResourceRequest);
/**
*
* Add a tag to a Step Functions resource.
*
*
* An array of key-value pairs. For more information, see Using Cost Allocation
* Tags in the AWS Billing and Cost Management User Guide, and Controlling Access Using IAM
* Tags.
*
*
* Tags may only contain Unicode letters, digits, white space, or these symbols: _ . : / = + - @.
*
*
* @param tagResourceRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the TagResource operation returned by the service.
* @sample AWSStepFunctionsAsyncHandler.TagResource
* @see AWS API
* Documentation
*/
java.util.concurrent.Future tagResourceAsync(TagResourceRequest tagResourceRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Remove a tag from a Step Functions resource
*
*
* @param untagResourceRequest
* @return A Java Future containing the result of the UntagResource operation returned by the service.
* @sample AWSStepFunctionsAsync.UntagResource
* @see AWS API
* Documentation
*/
java.util.concurrent.Future untagResourceAsync(UntagResourceRequest untagResourceRequest);
/**
*
* Remove a tag from a Step Functions resource
*
*
* @param untagResourceRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the UntagResource operation returned by the service.
* @sample AWSStepFunctionsAsyncHandler.UntagResource
* @see AWS API
* Documentation
*/
java.util.concurrent.Future untagResourceAsync(UntagResourceRequest untagResourceRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Updates an existing state machine by modifying its definition, roleArn, or
* loggingConfiguration. Running executions will continue to use the previous definition
* and roleArn. You must include at least one of definition or roleArn or you
* will receive a MissingRequiredParameter error.
*
*
*
* All StartExecution calls within a few seconds will use the updated definition and
* roleArn. Executions started immediately after calling UpdateStateMachine may use the
* previous state machine definition and roleArn.
*
*
*
* @param updateStateMachineRequest
* @return A Java Future containing the result of the UpdateStateMachine operation returned by the service.
* @sample AWSStepFunctionsAsync.UpdateStateMachine
* @see AWS API
* Documentation
*/
java.util.concurrent.Future updateStateMachineAsync(UpdateStateMachineRequest updateStateMachineRequest);
/**
*
* Updates an existing state machine by modifying its definition, roleArn, or
* loggingConfiguration. Running executions will continue to use the previous definition
* and roleArn. You must include at least one of definition or roleArn or you
* will receive a MissingRequiredParameter error.
*
*
*
* All StartExecution calls within a few seconds will use the updated definition and
* roleArn. Executions started immediately after calling UpdateStateMachine may use the
* previous state machine definition and roleArn.
*
*
*
* @param updateStateMachineRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the UpdateStateMachine operation returned by the service.
* @sample AWSStepFunctionsAsyncHandler.UpdateStateMachine
* @see AWS API
* Documentation
*/
java.util.concurrent.Future updateStateMachineAsync(UpdateStateMachineRequest updateStateMachineRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
}