NAME

Paws::StepFunctions - Perl Interface to AWS AWS Step Functions

SYNOPSIS

  use Paws;

  my $obj = Paws->service('StepFunctions');
  my $res = $obj->Method(
    Arg1 => $val1,
    Arg2 => [ 'V1', 'V2' ],
    # if Arg3 is an object, the HashRef will be used as arguments to the constructor
    # of the arguments type
    Arg3 => { Att1 => 'Val1' },
    # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
    # the constructor of the arguments type
    Arg4 => [ { Att1 => 'Val1'  }, { Att1 => 'Val2' } ],
  );

DESCRIPTION

AWS Step Functions

AWS Step Functions is a web service that enables you to coordinate the components of distributed applications and microservices using visual workflows. You build applications from individual components that each perform a discrete function, or task, allowing you to scale and change applications quickly. Step Functions provides a graphical console to visualize the components of your application as a series of steps. It automatically triggers and tracks each step, and retries when there are errors, so your application executes in order and as expected, every time. Step Functions logs the state of each step, so when things do go wrong, you can diagnose and debug problems quickly.

Step Functions manages the operations and underlying infrastructure for you to ensure your application is available at any scale. You can run tasks on the AWS cloud, on your own servers, or an any system that has access to AWS. Step Functions can be accessed and used with the Step Functions console, the AWS SDKs (included with your Beta release invitation email), or an HTTP API (the subject of this document).

METHODS

CreateActivity(Name => Str)

Each argument is described in detail in: Paws::StepFunctions::CreateActivity

Returns: a Paws::StepFunctions::CreateActivityOutput instance

  Creates an activity.

CreateStateMachine(Definition => Str, Name => Str, RoleArn => Str)

Each argument is described in detail in: Paws::StepFunctions::CreateStateMachine

Returns: a Paws::StepFunctions::CreateStateMachineOutput instance

  Creates a state machine.

DeleteActivity(ActivityArn => Str)

Each argument is described in detail in: Paws::StepFunctions::DeleteActivity

Returns: a Paws::StepFunctions::DeleteActivityOutput instance

  Deletes an activity.

DeleteStateMachine(StateMachineArn => Str)

Each argument is described in detail in: Paws::StepFunctions::DeleteStateMachine

Returns: a Paws::StepFunctions::DeleteStateMachineOutput instance

  Deletes a state machine. This is an asynchronous operation-- it sets
the state machine's status to "DELETING" and begins the delete process.

DescribeActivity(ActivityArn => Str)

Each argument is described in detail in: Paws::StepFunctions::DescribeActivity

Returns: a Paws::StepFunctions::DescribeActivityOutput instance

  Describes an activity.

DescribeExecution(ExecutionArn => Str)

Each argument is described in detail in: Paws::StepFunctions::DescribeExecution

Returns: a Paws::StepFunctions::DescribeExecutionOutput instance

  Describes an execution.

DescribeStateMachine(StateMachineArn => Str)

Each argument is described in detail in: Paws::StepFunctions::DescribeStateMachine

Returns: a Paws::StepFunctions::DescribeStateMachineOutput instance

  Describes a state machine.

GetActivityTask(ActivityArn => Str, [WorkerName => Str])

Each argument is described in detail in: Paws::StepFunctions::GetActivityTask

Returns: a Paws::StepFunctions::GetActivityTaskOutput instance

  Used by workers to retrieve a task (with the specified activity ARN)
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 will return an empty result, that is, the
C<taskToken> returned is an empty string.

Workers should set their client side socket timeout to at least 65 seconds (5 seconds higher than the maximum time the service may hold the poll request).

GetExecutionHistory(ExecutionArn => Str, [MaxResults => Int, NextToken => Str, ReverseOrder => Bool])

Each argument is described in detail in: Paws::StepFunctions::GetExecutionHistory

Returns: a Paws::StepFunctions::GetExecutionHistoryOutput instance

  Returns the history of the specified execution as a list of events. By
default, the results are returned in ascending order of the
C<timeStamp> of the events. Use the C<reverseOrder> parameter to get
the latest events first. The results may be split into multiple pages.
To retrieve subsequent pages, make the call again using the
C<nextToken> returned by the previous call.

ListActivities([MaxResults => Int, NextToken => Str])

Each argument is described in detail in: Paws::StepFunctions::ListActivities

Returns: a Paws::StepFunctions::ListActivitiesOutput instance

  Lists the existing activities. The results may be split into multiple
pages. To retrieve subsequent pages, make the call again using the
C<nextToken> returned by the previous call.

ListExecutions(StateMachineArn => Str, [MaxResults => Int, NextToken => Str, StatusFilter => Str])

Each argument is described in detail in: Paws::StepFunctions::ListExecutions

Returns: a Paws::StepFunctions::ListExecutionsOutput instance

  Lists the executions of a state machine that meet the filtering
criteria. The results may be split into multiple pages. To retrieve
subsequent pages, make the call again using the C<nextToken> returned
by the previous call.

ListStateMachines([MaxResults => Int, NextToken => Str])

Each argument is described in detail in: Paws::StepFunctions::ListStateMachines

Returns: a Paws::StepFunctions::ListStateMachinesOutput instance

  Lists the existing state machines. The results may be split into
multiple pages. To retrieve subsequent pages, make the call again using
the C<nextToken> returned by the previous call.

SendTaskFailure(TaskToken => Str, [Cause => Str, Error => Str])

Each argument is described in detail in: Paws::StepFunctions::SendTaskFailure

Returns: a Paws::StepFunctions::SendTaskFailureOutput instance

  Used by workers to report that the task identified by the C<taskToken>
failed.

SendTaskHeartbeat(TaskToken => Str)

Each argument is described in detail in: Paws::StepFunctions::SendTaskHeartbeat

Returns: a Paws::StepFunctions::SendTaskHeartbeatOutput instance

  Used by workers to report to the service that the task represented by
the specified C<taskToken> is still making progress. This action resets
the C<Heartbeat> clock. The C<Heartbeat> threshold is specified in the
state machine's Amazon States Language definition. This action does not
in itself create an event in the execution history. However, if the
task times out, the execution history will contain an
C<ActivityTimedOut> event.

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.

This operation is only useful for long-lived tasks to report the liveliness of the task.

SendTaskSuccess(Output => Str, TaskToken => Str)

Each argument is described in detail in: Paws::StepFunctions::SendTaskSuccess

Returns: a Paws::StepFunctions::SendTaskSuccessOutput instance

  Used by workers to report that the task identified by the C<taskToken>
completed successfully.

StartExecution(StateMachineArn => Str, [Input => Str, Name => Str])

Each argument is described in detail in: Paws::StepFunctions::StartExecution

Returns: a Paws::StepFunctions::StartExecutionOutput instance

  Starts a state machine execution.

StopExecution(ExecutionArn => Str, [Cause => Str, Error => Str])

Each argument is described in detail in: Paws::StepFunctions::StopExecution

Returns: a Paws::StepFunctions::StopExecutionOutput instance

  Stops an execution.

PAGINATORS

Paginator methods are helpers that repetively call methods that return partial results

GetAllExecutionHistory(sub { },ExecutionArn => Str, [MaxResults => Int, NextToken => Str, ReverseOrder => Bool])

GetAllExecutionHistory(ExecutionArn => Str, [MaxResults => Int, NextToken => Str, ReverseOrder => Bool])

If passed a sub as first parameter, it will call the sub for each element found in :

 - events, passing the object as the first parameter, and the string 'events' as the second parameter 

If not, it will return a a Paws::StepFunctions::GetExecutionHistoryOutput instance with all the params; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.

ListAllActivities(sub { },[MaxResults => Int, NextToken => Str])

ListAllActivities([MaxResults => Int, NextToken => Str])

If passed a sub as first parameter, it will call the sub for each element found in :

 - activities, passing the object as the first parameter, and the string 'activities' as the second parameter 

If not, it will return a a Paws::StepFunctions::ListActivitiesOutput instance with all the params; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.

ListAllExecutions(sub { },StateMachineArn => Str, [MaxResults => Int, NextToken => Str, StatusFilter => Str])

ListAllExecutions(StateMachineArn => Str, [MaxResults => Int, NextToken => Str, StatusFilter => Str])

If passed a sub as first parameter, it will call the sub for each element found in :

 - executions, passing the object as the first parameter, and the string 'executions' as the second parameter 

If not, it will return a a Paws::StepFunctions::ListExecutionsOutput instance with all the params; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.

ListAllStateMachines(sub { },[MaxResults => Int, NextToken => Str])

ListAllStateMachines([MaxResults => Int, NextToken => Str])

If passed a sub as first parameter, it will call the sub for each element found in :

 - stateMachines, passing the object as the first parameter, and the string 'stateMachines' as the second parameter 

If not, it will return a a Paws::StepFunctions::ListStateMachinesOutput instance with all the params; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.

SEE ALSO

This service class forms part of Paws

BUGS and CONTRIBUTIONS

The source code is located here: https://github.com/pplu/aws-sdk-perl

Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues