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.
-
#send_task_failure(params = {}) ⇒ Struct
Used by activity workers and task states using the [callback] pattern to report that the task identified by the ‘taskToken` failed.
-
#send_task_heartbeat(params = {}) ⇒ Struct
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.
-
#send_task_success(params = {}) ⇒ Struct
Used by activity workers and task states using the [callback] pattern to report that the task identified by the ‘taskToken` completed successfully.
-
#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.
-
#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`, or `loggingConfiguration`.
-
#update_state_machine_alias(params = {}) ⇒ Types::UpdateStateMachineAliasOutput
Updates the configuration of an existing state machine [alias] by modifying its ‘description` or `routingConfiguration`.
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.
395 396 397 |
# File 'lib/aws-sdk-states/client.rb', line 395 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.
2883 2884 2885 |
# File 'lib/aws-sdk-states/client.rb', line 2883 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.
2886 2887 2888 |
# File 'lib/aws-sdk-states/client.rb', line 2886 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.
2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 |
# File 'lib/aws-sdk-states/client.rb', line 2861 def build_request(operation_name, params = {}) handlers = @handlers.for(operation_name) context = Seahorse::Client::RequestContext.new( operation_name: operation_name, operation: config.api.operation(operation_name), client: self, params: params, config: config) context[:gem_name] = 'aws-sdk-states' context[:gem_version] = '1.59.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>
490 491 492 493 |
# File 'lib/aws-sdk-states/client.rb', line 490 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.
<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`, and `TracingConfiguration`. 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
650 651 652 653 |
# File 'lib/aws-sdk-states/client.rb', line 650 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
738 739 740 741 |
# File 'lib/aws-sdk-states/client.rb', line 738 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.
760 761 762 763 |
# File 'lib/aws-sdk-states/client.rb', line 760 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 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
821 822 823 824 |
# File 'lib/aws-sdk-states/client.rb', line 821 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
861 862 863 864 |
# File 'lib/aws-sdk-states/client.rb', line 861 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
907 908 909 910 |
# File 'lib/aws-sdk-states/client.rb', line 907 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>
944 945 946 947 |
# File 'lib/aws-sdk-states/client.rb', line 944 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. 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 machinearen’t supported by ‘DescribeExecution` unless a Map Run dispatched them.
1017 1018 1019 1020 |
# File 'lib/aws-sdk-states/client.rb', line 1017 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. For more information, see [Examining Map Run] in the *Step Functions Developer Guide*.
[1]: docs.aws.amazon.com/step-functions/latest/dg/concepts-examine-map-run.html
1083 1084 1085 1086 |
# File 'lib/aws-sdk-states/client.rb', line 1083 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>
1185 1186 1187 1188 |
# File 'lib/aws-sdk-states/client.rb', line 1185 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
1239 1240 1241 1242 |
# File 'lib/aws-sdk-states/client.rb', line 1239 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.
1300 1301 1302 1303 |
# File 'lib/aws-sdk-states/client.rb', line 1300 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
1360 1361 1362 1363 |
# File 'lib/aws-sdk-states/client.rb', line 1360 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.
1528 1529 1530 1531 |
# File 'lib/aws-sdk-states/client.rb', line 1528 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.
1589 1590 1591 1592 |
# File 'lib/aws-sdk-states/client.rb', line 1589 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.
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/concepts-state-machine-alias.html [2]: 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.
1710 1711 1712 1713 |
# File 'lib/aws-sdk-states/client.rb', line 1710 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.
1768 1769 1770 1771 |
# File 'lib/aws-sdk-states/client.rb', line 1768 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
1848 1849 1850 1851 |
# File 'lib/aws-sdk-states/client.rb', line 1848 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
1919 1920 1921 1922 |
# File 'lib/aws-sdk-states/client.rb', line 1919 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.
1981 1982 1983 1984 |
# File 'lib/aws-sdk-states/client.rb', line 1981 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: ‘_ . : / = + - @`.
2015 2016 2017 2018 |
# File 'lib/aws-sdk-states/client.rb', line 2015 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
2093 2094 2095 2096 |
# File 'lib/aws-sdk-states/client.rb', line 2093 def publish_state_machine_version(params = {}, = {}) req = build_request(:publish_state_machine_version, params) req.send_request() end |
#send_task_failure(params = {}) ⇒ Struct
Used by activity workers and task states using the [callback] pattern to report that the task identified by the ‘taskToken` failed.
[1]: docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-wait-token
2135 2136 2137 2138 |
# File 'lib/aws-sdk-states/client.rb', line 2135 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 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][1
-
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
2185 2186 2187 2188 |
# File 'lib/aws-sdk-states/client.rb', line 2185 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 and task states using the [callback] 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
2225 2226 2227 2228 |
# File 'lib/aws-sdk-states/client.rb', line 2225 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
2392 2393 2394 2395 |
# File 'lib/aws-sdk-states/client.rb', line 2392 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>
2484 2485 2486 2487 |
# File 'lib/aws-sdk-states/client.rb', line 2484 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.
2522 2523 2524 2525 |
# File 'lib/aws-sdk-states/client.rb', line 2522 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
2569 2570 2571 2572 |
# File 'lib/aws-sdk-states/client.rb', line 2569 def tag_resource(params = {}, = {}) req = build_request(:tag_resource, params) req.send_request() end |
#untag_resource(params = {}) ⇒ Struct
Remove a tag from a Step Functions resource
2596 2597 2598 2599 |
# File 'lib/aws-sdk-states/client.rb', line 2596 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.
2632 2633 2634 2635 |
# File 'lib/aws-sdk-states/client.rb', line 2632 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`, 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.
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
2776 2777 2778 2779 |
# File 'lib/aws-sdk-states/client.rb', line 2776 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
2852 2853 2854 2855 |
# File 'lib/aws-sdk-states/client.rb', line 2852 def update_state_machine_alias(params = {}, = {}) req = build_request(:update_state_machine_alias, 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.
2876 2877 2878 |
# File 'lib/aws-sdk-states/client.rb', line 2876 def waiter_names [] end |