Class: Aws::States::Client
- Inherits:
-
Seahorse::Client::Base
- Object
- Seahorse::Client::Base
- Aws::States::Client
- Includes:
- ClientStubs
- Defined in:
- lib/aws-sdk-states/client.rb
Overview
An API client for States. To construct a client, you need to configure a ‘:region` and `:credentials`.
client = Aws::States::Client.new(
region: region_name,
credentials: credentials,
# ...
)
For details on configuring region and credentials see the [developer guide](/sdk-for-ruby/v3/developer-guide/setup-config.html).
See #initialize for a full list of supported configuration options.
Class Attribute Summary collapse
- .identifier ⇒ Object readonly private
API Operations collapse
-
#create_activity(params = {}) ⇒ Types::CreateActivityOutput
Creates an activity.
-
#create_state_machine(params = {}) ⇒ Types::CreateStateMachineOutput
Creates a state machine.
- #create_state_machine_alias(params = {}) ⇒ Types::CreateStateMachineAliasOutput
-
#delete_activity(params = {}) ⇒ Struct
Deletes an activity.
-
#delete_state_machine(params = {}) ⇒ Struct
Deletes a state machine.
-
#delete_state_machine_alias(params = {}) ⇒ Struct
Deletes a state machine [alias].
-
#delete_state_machine_version(params = {}) ⇒ Struct
Deletes a state machine [version].
-
#describe_activity(params = {}) ⇒ Types::DescribeActivityOutput
Describes an activity.
-
#describe_execution(params = {}) ⇒ Types::DescribeExecutionOutput
Provides information about a state machine execution, such as the state machine associated with the execution, the execution input and output, and relevant execution metadata.
-
#describe_map_run(params = {}) ⇒ Types::DescribeMapRunOutput
Provides information about a Map Run’s configuration, progress, and results.
-
#describe_state_machine(params = {}) ⇒ Types::DescribeStateMachineOutput
Provides information about a state machine’s definition, its IAM role Amazon Resource Name (ARN), and configuration.
-
#describe_state_machine_alias(params = {}) ⇒ Types::DescribeStateMachineAliasOutput
Returns details about a state machine [alias].
-
#describe_state_machine_for_execution(params = {}) ⇒ Types::DescribeStateMachineForExecutionOutput
Provides information about a state machine’s definition, its execution role ARN, and configuration.
-
#get_activity_task(params = {}) ⇒ Types::GetActivityTaskOutput
Used by workers to retrieve a task (with the specified activity ARN) which has been scheduled for execution by a running state machine.
-
#get_execution_history(params = {}) ⇒ Types::GetExecutionHistoryOutput
Returns the history of the specified execution as a list of events.
-
#list_activities(params = {}) ⇒ Types::ListActivitiesOutput
Lists the existing activities.
-
#list_executions(params = {}) ⇒ Types::ListExecutionsOutput
Lists all executions of a state machine or a Map Run.
-
#list_map_runs(params = {}) ⇒ Types::ListMapRunsOutput
Lists all Map Runs that were started by a given state machine execution.
-
#list_state_machine_aliases(params = {}) ⇒ Types::ListStateMachineAliasesOutput
Lists [aliases] for a specified state machine ARN.
-
#list_state_machine_versions(params = {}) ⇒ Types::ListStateMachineVersionsOutput
Lists [versions] for the specified state machine Amazon Resource Name (ARN).
-
#list_state_machines(params = {}) ⇒ Types::ListStateMachinesOutput
Lists the existing state machines.
-
#list_tags_for_resource(params = {}) ⇒ Types::ListTagsForResourceOutput
List tags for a given resource.
-
#publish_state_machine_version(params = {}) ⇒ Types::PublishStateMachineVersionOutput
Creates a [version] from the current revision of a state machine.
-
#redrive_execution(params = {}) ⇒ Types::RedriveExecutionOutput
Restarts unsuccessful executions of Standard workflows that didn’t complete successfully in the last 14 days.
- #send_task_failure(params = {}) ⇒ Struct
- #send_task_heartbeat(params = {}) ⇒ Struct
- #send_task_success(params = {}) ⇒ Struct
-
#start_execution(params = {}) ⇒ Types::StartExecutionOutput
Starts a state machine execution.
-
#start_sync_execution(params = {}) ⇒ Types::StartSyncExecutionOutput
Starts a Synchronous Express state machine execution.
-
#stop_execution(params = {}) ⇒ Types::StopExecutionOutput
Stops an execution.
-
#tag_resource(params = {}) ⇒ Struct
Add a tag to a Step Functions resource.
-
#test_state(params = {}) ⇒ Types::TestStateOutput
Accepts the definition of a single state and executes it.
-
#untag_resource(params = {}) ⇒ Struct
Remove a tag from a Step Functions resource.
-
#update_map_run(params = {}) ⇒ Struct
Updates an in-progress Map Run’s configuration to include changes to the settings that control maximum concurrency and Map Run failure.
-
#update_state_machine(params = {}) ⇒ Types::UpdateStateMachineOutput
Updates an existing state machine by modifying its ‘definition`, `roleArn`, `loggingConfiguration`, or `EncryptionConfiguration`.
-
#update_state_machine_alias(params = {}) ⇒ Types::UpdateStateMachineAliasOutput
Updates the configuration of an existing state machine [alias] by modifying its ‘description` or `routingConfiguration`.
-
#validate_state_machine_definition(params = {}) ⇒ Types::ValidateStateMachineDefinitionOutput
Validates the syntax of a state machine definition specified in [Amazon States Language] (ASL), a JSON-based, structured language.
Class Method Summary collapse
- .errors_module ⇒ Object private
Instance Method Summary collapse
- #build_request(operation_name, params = {}) ⇒ Object private
-
#initialize(options) ⇒ Client
constructor
A new instance of Client.
- #waiter_names ⇒ Object deprecated private Deprecated.
Constructor Details
#initialize(options) ⇒ Client
Returns a new instance of Client.
474 475 476 |
# File 'lib/aws-sdk-states/client.rb', line 474 def initialize(*args) super end |
Class Attribute Details
.identifier ⇒ Object (readonly)
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
3499 3500 3501 |
# File 'lib/aws-sdk-states/client.rb', line 3499 def identifier @identifier end |
Class Method Details
.errors_module ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
3502 3503 3504 |
# File 'lib/aws-sdk-states/client.rb', line 3502 def errors_module Errors end |
Instance Method Details
#build_request(operation_name, params = {}) ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 |
# File 'lib/aws-sdk-states/client.rb', line 3472 def build_request(operation_name, params = {}) handlers = @handlers.for(operation_name) tracer = config.telemetry_provider.tracer_provider.tracer( Aws::Telemetry.module_to_tracer_name('Aws::States') ) context = Seahorse::Client::RequestContext.new( operation_name: operation_name, operation: config.api.operation(operation_name), client: self, params: params, config: config, tracer: tracer ) context[:gem_name] = 'aws-sdk-states' context[:gem_version] = '1.87.0' Seahorse::Client::Request.new(handlers, context) end |
#create_activity(params = {}) ⇒ Types::CreateActivityOutput
Creates an activity. An activity is a task that you write in any programming language and host on any machine that has access to 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.
<note markdown=“1”> This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
</note>
<note markdown=“1”> ‘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.
</note>
577 578 579 580 |
# File 'lib/aws-sdk-states/client.rb', line 577 def create_activity(params = {}, = {}) req = build_request(:create_activity, params) req.send_request() end |
#create_state_machine(params = {}) ⇒ Types::CreateStateMachineOutput
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 Step Functions User Guide.
If you set the ‘publish` parameter of this API action to `true`, it publishes version `1` as the first revision of the state machine.
For additional control over security, you can encrypt your data using a **customer-managed key** for Step Functions state machines. You can configure a symmetric KMS key and data key reuse period when creating or updating a **State Machine**. The execution history and state machine definition will be encrypted with the key applied to the State Machine.
<note markdown=“1”> This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
</note>
<note markdown=“1”> ‘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`, `LoggingConfiguration`, `TracingConfiguration`, and `EncryptionConfiguration` The check is also based on the `publish` and `versionDescription` parameters. 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.
</note>
[1]: docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html
752 753 754 755 |
# File 'lib/aws-sdk-states/client.rb', line 752 def create_state_machine(params = {}, = {}) req = build_request(:create_state_machine, params) req.send_request() end |
#create_state_machine_alias(params = {}) ⇒ Types::CreateStateMachineAliasOutput
Creates an [alias] for a state machine that points to one or two
- versions][2
-
of the same state machine. You can set your application
to call StartExecution with an alias and update the version the alias uses without changing the client’s code.
You can also map an alias to split StartExecution requests between two versions of a state machine. To do this, add a second ‘RoutingConfig` object in the `routingConfiguration` parameter. You must also specify the percentage of execution run requests each version should receive in both `RoutingConfig` objects. Step Functions randomly chooses which version runs a given execution based on the percentage you specify.
To create an alias that points to a single version, specify a single ‘RoutingConfig` object with a `weight` set to 100.
You can create up to 100 aliases for each state machine. You must delete unused aliases using the DeleteStateMachineAlias API action.
‘CreateStateMachineAlias` is an idempotent API. Step Functions bases the idempotency check on the `stateMachineArn`, `description`, `name`, and `routingConfiguration` parameters. Requests that contain the same values for these parameters return a successful idempotent response without creating a duplicate resource.
**Related operations:**
-
DescribeStateMachineAlias
-
ListStateMachineAliases
-
UpdateStateMachineAlias
-
DeleteStateMachineAlias
[1]: docs.aws.amazon.com/step-functions/latest/dg/concepts-state-machine-alias.html [2]: docs.aws.amazon.com/step-functions/latest/dg/concepts-state-machine-version.html
840 841 842 843 |
# File 'lib/aws-sdk-states/client.rb', line 840 def create_state_machine_alias(params = {}, = {}) req = build_request(:create_state_machine_alias, params) req.send_request() end |
#delete_activity(params = {}) ⇒ Struct
Deletes an activity.
862 863 864 865 |
# File 'lib/aws-sdk-states/client.rb', line 862 def delete_activity(params = {}, = {}) req = build_request(:delete_activity, params) req.send_request() end |
#delete_state_machine(params = {}) ⇒ Struct
Deletes a state machine. This is an asynchronous operation. It sets the state machine’s status to ‘DELETING` and begins the deletion process. A state machine is deleted only when all its executions are completed. On the next state transition, the state machine’s executions are terminated.
A qualified state machine ARN can either refer to a *Distributed Map state* defined within a state machine, a version ARN, or an alias ARN.
The following are some examples of qualified and unqualified state machine ARNs:
-
The following qualified state machine ARN refers to a *Distributed Map state* with a label ‘mapStateLabel` in a state machine named `myStateMachine`.
‘arn:partition:states:region:account-id:stateMachine:myStateMachine/mapStateLabel`
<note markdown=“1”> If you provide a qualified state machine ARN that refers to a *Distributed Map state*, the request fails with ‘ValidationException`.
</note>
-
The following unqualified state machine ARN refers to a state machine named ‘myStateMachine`.
‘arn:partition:states:region:account-id:stateMachine:myStateMachine`
This API action also deletes all [versions] and [aliases] associated with a state machine.
<note markdown=“1”> For ‘EXPRESS` state machines, the deletion happens eventually (usually in less than a minute). Running executions may emit logs after `DeleteStateMachine` API is called.
</note>
[1]: docs.aws.amazon.com/step-functions/latest/dg/concepts-state-machine-version.html [2]: docs.aws.amazon.com/step-functions/latest/dg/concepts-state-machine-alias.html
925 926 927 928 |
# File 'lib/aws-sdk-states/client.rb', line 925 def delete_state_machine(params = {}, = {}) req = build_request(:delete_state_machine, params) req.send_request() end |
#delete_state_machine_alias(params = {}) ⇒ Struct
Deletes a state machine [alias].
After you delete a state machine alias, you can’t use it to start executions. When you delete a state machine alias, Step Functions doesn’t delete the state machine versions that alias references.
**Related operations:**
-
CreateStateMachineAlias
-
DescribeStateMachineAlias
-
ListStateMachineAliases
-
UpdateStateMachineAlias
[1]: docs.aws.amazon.com/step-functions/latest/dg/concepts-state-machine-alias.html
965 966 967 968 |
# File 'lib/aws-sdk-states/client.rb', line 965 def delete_state_machine_alias(params = {}, = {}) req = build_request(:delete_state_machine_alias, params) req.send_request() end |
#delete_state_machine_version(params = {}) ⇒ Struct
Deletes a state machine [version]. After you delete a version, you can’t call StartExecution using that version’s ARN or use the version with a state machine [alias].
<note markdown=“1”> Deleting a state machine version won’t terminate its in-progress executions.
</note>
<note markdown=“1”> You can’t delete a state machine version currently referenced by one or more aliases. Before you delete a version, you must either delete the aliases or update them to point to another state machine version.
</note>
**Related operations:**
-
PublishStateMachineVersion
-
ListStateMachineVersions
[1]: docs.aws.amazon.com/step-functions/latest/dg/concepts-state-machine-version.html [2]: docs.aws.amazon.com/step-functions/latest/dg/concepts-state-machine-alias.html
1011 1012 1013 1014 |
# File 'lib/aws-sdk-states/client.rb', line 1011 def delete_state_machine_version(params = {}, = {}) req = build_request(:delete_state_machine_version, params) req.send_request() end |
#describe_activity(params = {}) ⇒ Types::DescribeActivityOutput
Describes an activity.
<note markdown=“1”> This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
</note>
1052 1053 1054 1055 |
# File 'lib/aws-sdk-states/client.rb', line 1052 def describe_activity(params = {}, = {}) req = build_request(:describe_activity, params) req.send_request() end |
#describe_execution(params = {}) ⇒ Types::DescribeExecutionOutput
Provides information about a state machine execution, such as the state machine associated with the execution, the execution input and output, and relevant execution metadata. If you’ve [redriven] an execution, you can use this API action to return information about the redrives of that execution. In addition, you can use this API action to return the Map Run Amazon Resource Name (ARN) if the execution was dispatched by a Map Run.
If you specify a version or alias ARN when you call the StartExecution API action, ‘DescribeExecution` returns that ARN.
<note markdown=“1”> This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
</note>
Executions of an ‘EXPRESS` state machine aren’t supported by ‘DescribeExecution` unless a Map Run dispatched them.
[1]: docs.aws.amazon.com/step-functions/latest/dg/redrive-executions.html
1147 1148 1149 1150 |
# File 'lib/aws-sdk-states/client.rb', line 1147 def describe_execution(params = {}, = {}) req = build_request(:describe_execution, params) req.send_request() end |
#describe_map_run(params = {}) ⇒ Types::DescribeMapRunOutput
Provides information about a Map Run’s configuration, progress, and results. If you’ve [redriven] a Map Run, this API action also returns information about the redrives of that Map Run. For more information, see [Examining Map Run] in the *Step Functions Developer Guide*.
[1]: docs.aws.amazon.com/step-functions/latest/dg/redrive-map-run.html [2]: docs.aws.amazon.com/step-functions/latest/dg/concepts-examine-map-run.html
1224 1225 1226 1227 |
# File 'lib/aws-sdk-states/client.rb', line 1224 def describe_map_run(params = {}, = {}) req = build_request(:describe_map_run, params) req.send_request() end |
#describe_state_machine(params = {}) ⇒ Types::DescribeStateMachineOutput
Provides information about a state machine’s definition, its IAM role Amazon Resource Name (ARN), and configuration.
A qualified state machine ARN can either refer to a *Distributed Map state* defined within a state machine, a version ARN, or an alias ARN.
The following are some examples of qualified and unqualified state machine ARNs:
-
The following qualified state machine ARN refers to a *Distributed Map state* with a label ‘mapStateLabel` in a state machine named `myStateMachine`.
‘arn:partition:states:region:account-id:stateMachine:myStateMachine/mapStateLabel`
<note markdown=“1”> If you provide a qualified state machine ARN that refers to a *Distributed Map state*, the request fails with ‘ValidationException`.
</note>
-
The following qualified state machine ARN refers to an alias named ‘PROD`.
‘arn:<partition>:states:<region>:<account-id>:stateMachine:<myStateMachine:PROD>`
<note markdown=“1”> If you provide a qualified state machine ARN that refers to a version ARN or an alias ARN, the request starts execution for that version or alias.
</note>
-
The following unqualified state machine ARN refers to a state machine named ‘myStateMachine`.
‘arn:<partition>:states:<region>:<account-id>:stateMachine:<myStateMachine>`
This API action returns the details for a state machine version if the ‘stateMachineArn` you specify is a state machine version ARN.
<note markdown=“1”> This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
</note>
1350 1351 1352 1353 |
# File 'lib/aws-sdk-states/client.rb', line 1350 def describe_state_machine(params = {}, = {}) req = build_request(:describe_state_machine, params) req.send_request() end |
#describe_state_machine_alias(params = {}) ⇒ Types::DescribeStateMachineAliasOutput
Returns details about a state machine [alias].
**Related operations:**
-
CreateStateMachineAlias
-
ListStateMachineAliases
-
UpdateStateMachineAlias
-
DeleteStateMachineAlias
[1]: docs.aws.amazon.com/step-functions/latest/dg/concepts-state-machine-alias.html
1404 1405 1406 1407 |
# File 'lib/aws-sdk-states/client.rb', line 1404 def describe_state_machine_alias(params = {}, = {}) req = build_request(:describe_state_machine_alias, params) req.send_request() end |
#describe_state_machine_for_execution(params = {}) ⇒ Types::DescribeStateMachineForExecutionOutput
Provides information about a state machine’s definition, its execution role ARN, and configuration. If a Map Run dispatched the execution, this action returns the Map Run Amazon Resource Name (ARN) in the response. The state machine returned is the state machine associated with the Map Run.
<note markdown=“1”> This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
</note>
This API action is not supported by ‘EXPRESS` state machines.
1481 1482 1483 1484 |
# File 'lib/aws-sdk-states/client.rb', line 1481 def describe_state_machine_for_execution(params = {}, = {}) req = build_request(:describe_state_machine_for_execution, params) req.send_request() end |
#get_activity_task(params = {}) ⇒ Types::GetActivityTaskOutput
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.
<note markdown=“1”> This API action isn’t logged in CloudTrail.
</note>
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.
[1]: docs.aws.amazon.com/step-functions/latest/dg/bp-activity-pollers.html
1541 1542 1543 1544 |
# File 'lib/aws-sdk-states/client.rb', line 1541 def get_activity_task(params = {}, = {}) req = build_request(:get_activity_task, params) req.send_request() end |
#get_execution_history(params = {}) ⇒ Types::GetExecutionHistoryOutput
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.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
1719 1720 1721 1722 |
# File 'lib/aws-sdk-states/client.rb', line 1719 def get_execution_history(params = {}, = {}) req = build_request(:get_execution_history, params) req.send_request() end |
#list_activities(params = {}) ⇒ Types::ListActivitiesOutput
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.
<note markdown=“1”> This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
</note>
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
1780 1781 1782 1783 |
# File 'lib/aws-sdk-states/client.rb', line 1780 def list_activities(params = {}, = {}) req = build_request(:list_activities, params) req.send_request() end |
#list_executions(params = {}) ⇒ Types::ListExecutionsOutput
Lists all executions of a state machine or a Map Run. You can list all executions related to a state machine by specifying a state machine Amazon Resource Name (ARN), or those related to a Map Run by specifying a Map Run ARN. Using this API action, you can also list all
- redriven][1
-
executions.
You can also provide a state machine [alias] ARN or [version] ARN to list the executions associated with a specific alias or version.
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.
<note markdown=“1”> This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
</note>
This API action is not supported by ‘EXPRESS` state machines.
[1]: docs.aws.amazon.com/step-functions/latest/dg/redrive-executions.html [2]: docs.aws.amazon.com/step-functions/latest/dg/concepts-state-machine-alias.html [3]: docs.aws.amazon.com/step-functions/latest/dg/concepts-state-machine-version.html
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
1919 1920 1921 1922 |
# File 'lib/aws-sdk-states/client.rb', line 1919 def list_executions(params = {}, = {}) req = build_request(:list_executions, params) req.send_request() end |
#list_map_runs(params = {}) ⇒ Types::ListMapRunsOutput
Lists all Map Runs that were started by a given state machine execution. Use this API action to obtain Map Run ARNs, and then call ‘DescribeMapRun` to obtain more information, if needed.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
1977 1978 1979 1980 |
# File 'lib/aws-sdk-states/client.rb', line 1977 def list_map_runs(params = {}, = {}) req = build_request(:list_map_runs, params) req.send_request() end |
#list_state_machine_aliases(params = {}) ⇒ Types::ListStateMachineAliasesOutput
Lists [aliases] for a specified state machine ARN. Results are sorted by time, with the most recently created aliases listed first.
To list aliases that reference a state machine [version], you can specify the version ARN in the ‘stateMachineArn` parameter.
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.
**Related operations:**
-
CreateStateMachineAlias
-
DescribeStateMachineAlias
-
UpdateStateMachineAlias
-
DeleteStateMachineAlias
[1]: docs.aws.amazon.com/step-functions/latest/dg/concepts-state-machine-alias.html [2]: docs.aws.amazon.com/step-functions/latest/dg/concepts-state-machine-version.html
2057 2058 2059 2060 |
# File 'lib/aws-sdk-states/client.rb', line 2057 def list_state_machine_aliases(params = {}, = {}) req = build_request(:list_state_machine_aliases, params) req.send_request() end |
#list_state_machine_versions(params = {}) ⇒ Types::ListStateMachineVersionsOutput
Lists [versions] for the specified state machine Amazon Resource Name (ARN).
The results are sorted in descending order of the version creation time.
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.
**Related operations:**
-
PublishStateMachineVersion
-
DeleteStateMachineVersion
[1]: docs.aws.amazon.com/step-functions/latest/dg/concepts-state-machine-version.html
2128 2129 2130 2131 |
# File 'lib/aws-sdk-states/client.rb', line 2128 def list_state_machine_versions(params = {}, = {}) req = build_request(:list_state_machine_versions, params) req.send_request() end |
#list_state_machines(params = {}) ⇒ Types::ListStateMachinesOutput
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.
<note markdown=“1”> This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
</note>
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
2190 2191 2192 2193 |
# File 'lib/aws-sdk-states/client.rb', line 2190 def list_state_machines(params = {}, = {}) req = build_request(:list_state_machines, params) req.send_request() end |
#list_tags_for_resource(params = {}) ⇒ Types::ListTagsForResourceOutput
List tags for a given resource.
Tags may only contain Unicode letters, digits, white space, or these symbols: ‘_ . : / = + - @`.
2224 2225 2226 2227 |
# File 'lib/aws-sdk-states/client.rb', line 2224 def (params = {}, = {}) req = build_request(:list_tags_for_resource, params) req.send_request() end |
#publish_state_machine_version(params = {}) ⇒ Types::PublishStateMachineVersionOutput
Creates a [version] from the current revision of a state machine. Use versions to create immutable snapshots of your state machine. You can start executions from versions either directly or with an alias. To create an alias, use CreateStateMachineAlias.
You can publish up to 1000 versions for each state machine. You must manually delete unused versions using the DeleteStateMachineVersion API action.
‘PublishStateMachineVersion` is an idempotent API. It doesn’t create a duplicate state machine version if it already exists for the current revision. Step Functions bases ‘PublishStateMachineVersion`’s idempotency check on the ‘stateMachineArn`, `name`, and `revisionId` parameters. Requests with the same parameters return a successful idempotent response. If you don’t specify a ‘revisionId`, Step Functions checks for a previously published version of the state machine’s current revision.
**Related operations:**
-
DeleteStateMachineVersion
-
ListStateMachineVersions
[1]: docs.aws.amazon.com/step-functions/latest/dg/concepts-state-machine-version.html
2302 2303 2304 2305 |
# File 'lib/aws-sdk-states/client.rb', line 2302 def publish_state_machine_version(params = {}, = {}) req = build_request(:publish_state_machine_version, params) req.send_request() end |
#redrive_execution(params = {}) ⇒ Types::RedriveExecutionOutput
Restarts unsuccessful executions of Standard workflows that didn’t complete successfully in the last 14 days. These include failed, aborted, or timed out executions. When you [redrive] an execution, it continues the failed execution from the unsuccessful step and uses the same input. Step Functions preserves the results and execution history of the successful steps, and doesn’t rerun these steps when you redrive an execution. Redriven executions use the same state machine definition and execution ARN as the original execution attempt.
For workflows that include an [Inline Map] or [Parallel] state, ‘RedriveExecution` API action reschedules and redrives only the iterations and branches that failed or aborted.
To redrive a workflow that includes a Distributed Map state whose Map Run failed, you must redrive the [parent workflow]. The parent workflow redrives all the unsuccessful states, including a failed Map Run. If a Map Run was not started in the original execution attempt, the redriven parent workflow starts the Map Run.
<note markdown=“1”> This API action is not supported by ‘EXPRESS` state machines.
However, you can restart the unsuccessful executions of Express child
workflows in a Distributed Map by redriving its Map Run. When you redrive a Map Run, the Express child workflows are rerun using the StartExecution API action. For more information, see [Redriving Map Runs].
</note>
You can redrive executions if your original execution meets the following conditions:
-
The execution status isn’t ‘SUCCEEDED`.
-
Your workflow execution has not exceeded the redrivable period of 14 days. Redrivable period refers to the time during which you can redrive a given execution. This period starts from the day a state machine completes its execution.
-
The workflow execution has not exceeded the maximum open time of one year. For more information about state machine quotas, see [Quotas related to state machine executions].
-
The execution event history count is less than 24,999. Redriven executions append their event history to the existing event history. Make sure your workflow execution contains less than 24,999 events to accommodate the ‘ExecutionRedriven` history event and at least one other history event.
[1]: docs.aws.amazon.com/step-functions/latest/dg/redrive-executions.html [2]: docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-map-state.html [3]: docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-parallel-state.html [4]: docs.aws.amazon.com/step-functions/latest/dg/use-dist-map-orchestrate-large-scale-parallel-workloads.html#dist-map-orchestrate-parallel-workloads-key-terms [5]: docs.aws.amazon.com/step-functions/latest/dg/redrive-map-run.html [6]: docs.aws.amazon.com/step-functions/latest/dg/limits-overview.html#service-limits-state-machine-executions
2400 2401 2402 2403 |
# File 'lib/aws-sdk-states/client.rb', line 2400 def redrive_execution(params = {}, = {}) req = build_request(:redrive_execution, params) req.send_request() end |
#send_task_failure(params = {}) ⇒ Struct
Used by activity workers, Task states using the [callback] pattern, and optionally Task states using the [job run] pattern to report that the task identified by the ‘taskToken` failed.
For an execution with encryption enabled, Step Functions will encrypt the error and cause fields using the KMS key for the execution role.
A caller can mark a task as fail without using any KMS permissions in the execution role if the caller provides a null value for both ‘error` and `cause` fields because no data needs to be encrypted.
[1]: docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-wait-token [2]: docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-sync
2451 2452 2453 2454 |
# File 'lib/aws-sdk-states/client.rb', line 2451 def send_task_failure(params = {}, = {}) req = build_request(:send_task_failure, params) req.send_request() end |
#send_task_heartbeat(params = {}) ⇒ Struct
Used by activity workers and Task states using the [callback] pattern, and optionally Task states using the [job run] 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 tasks using the [job run] or [callback] pattern.
<note markdown=“1”> 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.
</note>
[1]: docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-wait-token [2]: docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-sync
2502 2503 2504 2505 |
# File 'lib/aws-sdk-states/client.rb', line 2502 def send_task_heartbeat(params = {}, = {}) req = build_request(:send_task_heartbeat, params) req.send_request() end |
#send_task_success(params = {}) ⇒ Struct
Used by activity workers, Task states using the [callback] pattern, and optionally Task states using the [job run] pattern to report that the task identified by the ‘taskToken` completed successfully.
[1]: docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-wait-token [2]: docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-sync
2543 2544 2545 2546 |
# File 'lib/aws-sdk-states/client.rb', line 2543 def send_task_success(params = {}, = {}) req = build_request(:send_task_success, params) req.send_request() end |
#start_execution(params = {}) ⇒ Types::StartExecutionOutput
Starts a state machine execution.
A qualified state machine ARN can either refer to a *Distributed Map state* defined within a state machine, a version ARN, or an alias ARN.
The following are some examples of qualified and unqualified state machine ARNs:
-
The following qualified state machine ARN refers to a *Distributed Map state* with a label ‘mapStateLabel` in a state machine named `myStateMachine`.
‘arn:partition:states:region:account-id:stateMachine:myStateMachine/mapStateLabel`
<note markdown=“1”> If you provide a qualified state machine ARN that refers to a *Distributed Map state*, the request fails with ‘ValidationException`.
</note>
-
The following qualified state machine ARN refers to an alias named ‘PROD`.
‘arn:<partition>:states:<region>:<account-id>:stateMachine:<myStateMachine:PROD>`
<note markdown=“1”> If you provide a qualified state machine ARN that refers to a version ARN or an alias ARN, the request starts execution for that version or alias.
</note>
-
The following unqualified state machine ARN refers to a state machine named ‘myStateMachine`.
‘arn:<partition>:states:<region>:<account-id>:stateMachine:<myStateMachine>`
If you start an execution with an unqualified state machine ARN, Step Functions uses the latest revision of the state machine for the execution.
To start executions of a state machine [version], call ‘StartExecution` and provide the version ARN or the ARN of an
- alias][2
-
that points to the version.
<note markdown=“1”> ‘StartExecution` is idempotent for `STANDARD` workflows. For a `STANDARD` workflow, if you call `StartExecution` with the same name and input as a running execution, the call succeeds and return the same response as the original request. If the execution is closed or if the input is different, it returns a `400 ExecutionAlreadyExists` error. You can reuse names after 90 days.
`StartExecution` isn't idempotent for `EXPRESS` workflows.
</note>
[1]: docs.aws.amazon.com/step-functions/latest/dg/concepts-state-machine-version.html [2]: docs.aws.amazon.com/step-functions/latest/dg/concepts-state-machine-alias.html
2714 2715 2716 2717 |
# File 'lib/aws-sdk-states/client.rb', line 2714 def start_execution(params = {}, = {}) req = build_request(:start_execution, params) req.send_request() end |
#start_sync_execution(params = {}) ⇒ Types::StartSyncExecutionOutput
Starts a Synchronous Express state machine execution. ‘StartSyncExecution` is not available for `STANDARD` workflows.
<note markdown=“1”> ‘StartSyncExecution` will return a `200 OK` response, even if your execution fails, because the status code in the API response doesn’t reflect function errors. Error codes are reserved for errors that prevent your execution from running, such as permissions errors, limit errors, or issues with your state machine code and configuration.
</note>
<note markdown=“1”> This API action isn’t logged in CloudTrail.
</note>
2814 2815 2816 2817 |
# File 'lib/aws-sdk-states/client.rb', line 2814 def start_sync_execution(params = {}, = {}) req = build_request(:start_sync_execution, params) req.send_request() end |
#stop_execution(params = {}) ⇒ Types::StopExecutionOutput
Stops an execution.
This API action is not supported by ‘EXPRESS` state machines.
For an execution with encryption enabled, Step Functions will encrypt the error and cause fields using the KMS key for the execution role.
A caller can stop an execution without using any KMS permissions in the execution role if the caller provides a null value for both ‘error` and `cause` fields because no data needs to be encrypted.
2859 2860 2861 2862 |
# File 'lib/aws-sdk-states/client.rb', line 2859 def stop_execution(params = {}, = {}) req = build_request(:stop_execution, params) req.send_request() end |
#tag_resource(params = {}) ⇒ Struct
Add a tag to a Step Functions resource.
An array of key-value pairs. For more information, see [Using Cost Allocation Tags] in the *Amazon Web Services Billing and Cost Management User Guide*, and [Controlling Access Using IAM Tags].
Tags may only contain Unicode letters, digits, white space, or these symbols: ‘_ . : / = + - @`.
[1]: docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html [2]: docs.aws.amazon.com/IAM/latest/UserGuide/access_iam-tags.html
2906 2907 2908 2909 |
# File 'lib/aws-sdk-states/client.rb', line 2906 def tag_resource(params = {}, = {}) req = build_request(:tag_resource, params) req.send_request() end |
#test_state(params = {}) ⇒ Types::TestStateOutput
Accepts the definition of a single state and executes it. You can test a state without creating a state machine or updating an existing state machine. Using this API, you can test the following:
-
A state’s [input and output processing] data flow
-
An [Amazon Web Services service integration] request and response
-
An [HTTP Task] request and response
You can call this API on only one state at a time. The states that you can test include the following:
- All Task types][4
-
except [Activity]
- Pass][6
- Wait][7
- Choice][8
- Succeed][9
- Fail][10
The ‘TestState` API assumes an IAM role which must contain the required IAM permissions for the resources your state is accessing. For information about the permissions a state might need, see [IAM permissions to test a state].
The ‘TestState` API can run for up to five minutes. If the execution of a state exceeds this duration, it fails with the `States.Timeout` error.
‘TestState` doesn’t support [Activity tasks], ‘.sync` or `.waitForTaskToken` [service integration patterns],
- Parallel], or [Map][14
-
states.
[1]: docs.aws.amazon.com/step-functions/latest/dg/test-state-isolation.html#test-state-input-output-dataflow [2]: docs.aws.amazon.com/step-functions/latest/dg/connect-to-services.html [3]: docs.aws.amazon.com/step-functions/latest/dg/connect-third-party-apis.html [4]: docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-task-state.html#task-types [5]: docs.aws.amazon.com/step-functions/latest/dg/concepts-activities.html [6]: docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-pass-state.html [7]: docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-wait-state.html [8]: docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-choice-state.html [9]: docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-succeed-state.html [10]: docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-fail-state.html [11]: docs.aws.amazon.com/step-functions/latest/dg/test-state-isolation.html#test-state-permissions [12]: docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html [13]: docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-parallel-state.html [14]: docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-map-state.html
3071 3072 3073 3074 |
# File 'lib/aws-sdk-states/client.rb', line 3071 def test_state(params = {}, = {}) req = build_request(:test_state, params) req.send_request() end |
#untag_resource(params = {}) ⇒ Struct
Remove a tag from a Step Functions resource
3098 3099 3100 3101 |
# File 'lib/aws-sdk-states/client.rb', line 3098 def untag_resource(params = {}, = {}) req = build_request(:untag_resource, params) req.send_request() end |
#update_map_run(params = {}) ⇒ Struct
Updates an in-progress Map Run’s configuration to include changes to the settings that control maximum concurrency and Map Run failure.
3134 3135 3136 3137 |
# File 'lib/aws-sdk-states/client.rb', line 3134 def update_map_run(params = {}, = {}) req = build_request(:update_map_run, params) req.send_request() end |
#update_state_machine(params = {}) ⇒ Types::UpdateStateMachineOutput
Updates an existing state machine by modifying its ‘definition`, `roleArn`, `loggingConfiguration`, or `EncryptionConfiguration`. 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.
A qualified state machine ARN refers to a *Distributed Map state* defined within a state machine. For example, the qualified state machine ARN ‘arn:partition:states:region:account-id:stateMachine:stateMachineName/mapStateLabel` refers to a *Distributed Map state* with a label `mapStateLabel` in the state machine named `stateMachineName`.
A qualified state machine ARN can either refer to a *Distributed Map state* defined within a state machine, a version ARN, or an alias ARN.
The following are some examples of qualified and unqualified state machine ARNs:
-
The following qualified state machine ARN refers to a *Distributed Map state* with a label ‘mapStateLabel` in a state machine named `myStateMachine`.
‘arn:partition:states:region:account-id:stateMachine:myStateMachine/mapStateLabel`
<note markdown=“1”> If you provide a qualified state machine ARN that refers to a *Distributed Map state*, the request fails with ‘ValidationException`.
</note>
-
The following qualified state machine ARN refers to an alias named ‘PROD`.
‘arn:<partition>:states:<region>:<account-id>:stateMachine:<myStateMachine:PROD>`
<note markdown=“1”> If you provide a qualified state machine ARN that refers to a version ARN or an alias ARN, the request starts execution for that version or alias.
</note>
-
The following unqualified state machine ARN refers to a state machine named ‘myStateMachine`.
‘arn:<partition>:states:<region>:<account-id>:stateMachine:<myStateMachine>`
After you update your state machine, you can set the ‘publish` parameter to `true` in the same action to publish a new [version]. This way, you can opt-in to strict versioning of your state machine.
<note markdown=“1”> Step Functions assigns monotonically increasing integers for state machine versions, starting at version number 1.
</note>
<note markdown=“1”> All ‘StartExecution` calls within a few seconds use the updated `definition` and `roleArn`. Executions started immediately after you call `UpdateStateMachine` may use the previous state machine `definition` and `roleArn`.
</note>
[1]: docs.aws.amazon.com/step-functions/latest/dg/concepts-state-machine-version.html
3286 3287 3288 3289 |
# File 'lib/aws-sdk-states/client.rb', line 3286 def update_state_machine(params = {}, = {}) req = build_request(:update_state_machine, params) req.send_request() end |
#update_state_machine_alias(params = {}) ⇒ Types::UpdateStateMachineAliasOutput
Updates the configuration of an existing state machine [alias] by modifying its ‘description` or `routingConfiguration`.
You must specify at least one of the ‘description` or `routingConfiguration` parameters to update a state machine alias.
<note markdown=“1”> ‘UpdateStateMachineAlias` is an idempotent API. Step Functions bases the idempotency check on the `stateMachineAliasArn`, `description`, and `routingConfiguration` parameters. Requests with the same parameters return an idempotent response.
</note>
<note markdown=“1”> This operation is eventually consistent. All StartExecution requests made within a few seconds use the latest alias configuration. Executions started immediately after calling ‘UpdateStateMachineAlias` may use the previous routing configuration.
</note>
**Related operations:**
-
CreateStateMachineAlias
-
DescribeStateMachineAlias
-
ListStateMachineAliases
-
DeleteStateMachineAlias
[1]: docs.aws.amazon.com/step-functions/latest/dg/concepts-state-machine-alias.html
3362 3363 3364 3365 |
# File 'lib/aws-sdk-states/client.rb', line 3362 def update_state_machine_alias(params = {}, = {}) req = build_request(:update_state_machine_alias, params) req.send_request() end |
#validate_state_machine_definition(params = {}) ⇒ Types::ValidateStateMachineDefinitionOutput
Validates the syntax of a state machine definition specified in
- Amazon States Language][1
-
(ASL), a JSON-based, structured language.
You can validate that a state machine definition is correct without creating a state machine resource.
Suggested uses for ‘ValidateStateMachineDefinition`:
-
Integrate automated checks into your code review or Continuous Integration (CI) process to check state machine definitions before starting deployments.
-
Run validation from a Git pre-commit hook to verify the definition before committing to your source repository.
Validation will look for problems in your state machine definition and return a result and a list of **diagnostic elements**.
The result value will be ‘OK` when your workflow definition can be successfully created or updated. Note the result can be `OK` even when diagnostic warnings are present in the response. The result value will be `FAIL` when the workflow definition contains errors that would prevent you from creating or updating your state machine.
The list of [ValidateStateMachineDefinitionDiagnostic] data elements can contain zero or more WARNING and/or ERROR elements.
<note markdown=“1”> The **ValidateStateMachineDefinition API** might add new diagnostics in the future, adjust diagnostic codes, or change the message wording. Your automated processes should only rely on the value of the result field value (OK, FAIL). Do not rely on the exact order, count, or wording of diagnostic messages.
</note>
[1]: docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html [2]: docs.aws.amazon.com/step-functions/latest/apireference/API_ValidateStateMachineDefinitionDiagnostic.html
3463 3464 3465 3466 |
# File 'lib/aws-sdk-states/client.rb', line 3463 def validate_state_machine_definition(params = {}, = {}) req = build_request(:validate_state_machine_definition, params) req.send_request() end |
#waiter_names ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
3492 3493 3494 |
# File 'lib/aws-sdk-states/client.rb', line 3492 def waiter_names [] end |