blib/lib/Paws/StepFunctions.pm untested

filter: Statementstmt 0.0% 0 / 164 Branchbran 0.0% 0 / 16 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 34 Podpod 0.0% 0 / 33 totaltotal 0.0% 0 / 247 CC 9 SCAR 15.8
CC
9
Cov
0%
GetAllExecutionHistory
12.0
ListAllActivities
12.0
ListAllExecutions
12.0
CRAP 4.9
1 package Paws::StepFunctions;
2 use Moose;
3 sub service { 'states' }
4 sub signing_name { 'states' }
5 sub version { '2016-11-23' }
6 sub target_prefix { 'AWSStepFunctions' }
7 sub json_version { "1.0" }
8 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
9 has retry => (is => 'ro', isa => 'HashRef', default => sub {
10 { base => 'rand', type => 'exponential', growth_factor => 2 }
11 });
12 has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
13 ] });
14  
15 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller';
16  
17
18 sub CreateActivity {
19 my $self = shift;
20 my $call_object = $self->new_with_coercions('Paws::StepFunctions::CreateActivity', @_);
21 return $self->caller->do_call($self, $call_object);
22 }
23 sub CreateStateMachine {
24 my $self = shift;
25 my $call_object = $self->new_with_coercions('Paws::StepFunctions::CreateStateMachine', @_);
26 return $self->caller->do_call($self, $call_object);
27 }
28 sub DeleteActivity {
29 my $self = shift;
30 my $call_object = $self->new_with_coercions('Paws::StepFunctions::DeleteActivity', @_);
31 return $self->caller->do_call($self, $call_object);
32 }
33 sub DeleteStateMachine {
34 my $self = shift;
35 my $call_object = $self->new_with_coercions('Paws::StepFunctions::DeleteStateMachine', @_);
36 return $self->caller->do_call($self, $call_object);
37 }
38 sub DescribeActivity {
39 my $self = shift;
40 my $call_object = $self->new_with_coercions('Paws::StepFunctions::DescribeActivity', @_);
41 return $self->caller->do_call($self, $call_object);
42 }
43 sub DescribeExecution {
44 my $self = shift;
45 my $call_object = $self->new_with_coercions('Paws::StepFunctions::DescribeExecution', @_);
46 return $self->caller->do_call($self, $call_object);
47 }
48 sub DescribeStateMachine {
49 my $self = shift;
50 my $call_object = $self->new_with_coercions('Paws::StepFunctions::DescribeStateMachine', @_);
51 return $self->caller->do_call($self, $call_object);
52 }
53 sub DescribeStateMachineForExecution {
54 my $self = shift;
55 my $call_object = $self->new_with_coercions('Paws::StepFunctions::DescribeStateMachineForExecution', @_);
56 return $self->caller->do_call($self, $call_object);
57 }
58 sub GetActivityTask {
59 my $self = shift;
60 my $call_object = $self->new_with_coercions('Paws::StepFunctions::GetActivityTask', @_);
61 return $self->caller->do_call($self, $call_object);
62 }
63 sub GetExecutionHistory {
64 my $self = shift;
65 my $call_object = $self->new_with_coercions('Paws::StepFunctions::GetExecutionHistory', @_);
66 return $self->caller->do_call($self, $call_object);
67 }
68 sub ListActivities {
69 my $self = shift;
70 my $call_object = $self->new_with_coercions('Paws::StepFunctions::ListActivities', @_);
71 return $self->caller->do_call($self, $call_object);
72 }
73 sub ListExecutions {
74 my $self = shift;
75 my $call_object = $self->new_with_coercions('Paws::StepFunctions::ListExecutions', @_);
76 return $self->caller->do_call($self, $call_object);
77 }
78 sub ListStateMachines {
79 my $self = shift;
80 my $call_object = $self->new_with_coercions('Paws::StepFunctions::ListStateMachines', @_);
81 return $self->caller->do_call($self, $call_object);
82 }
83 sub ListTagsForResource {
84 my $self = shift;
85 my $call_object = $self->new_with_coercions('Paws::StepFunctions::ListTagsForResource', @_);
86 return $self->caller->do_call($self, $call_object);
87 }
88 sub SendTaskFailure {
89 my $self = shift;
90 my $call_object = $self->new_with_coercions('Paws::StepFunctions::SendTaskFailure', @_);
91 return $self->caller->do_call($self, $call_object);
92 }
93 sub SendTaskHeartbeat {
94 my $self = shift;
95 my $call_object = $self->new_with_coercions('Paws::StepFunctions::SendTaskHeartbeat', @_);
96 return $self->caller->do_call($self, $call_object);
97 }
98 sub SendTaskSuccess {
99 my $self = shift;
100 my $call_object = $self->new_with_coercions('Paws::StepFunctions::SendTaskSuccess', @_);
101 return $self->caller->do_call($self, $call_object);
102 }
103 sub StartExecution {
104 my $self = shift;
105 my $call_object = $self->new_with_coercions('Paws::StepFunctions::StartExecution', @_);
106 return $self->caller->do_call($self, $call_object);
107 }
108 sub StartSyncExecution {
109 my $self = shift;
110 my $call_object = $self->new_with_coercions('Paws::StepFunctions::StartSyncExecution', @_);
111 return $self->caller->do_call($self, $call_object);
112 }
113 sub StopExecution {
114 my $self = shift;
115 my $call_object = $self->new_with_coercions('Paws::StepFunctions::StopExecution', @_);
116 return $self->caller->do_call($self, $call_object);
117 }
118 sub TagResource {
119 my $self = shift;
120 my $call_object = $self->new_with_coercions('Paws::StepFunctions::TagResource', @_);
121 return $self->caller->do_call($self, $call_object);
122 }
123 sub UntagResource {
124 my $self = shift;
125 my $call_object = $self->new_with_coercions('Paws::StepFunctions::UntagResource', @_);
126 return $self->caller->do_call($self, $call_object);
127 }
128 sub UpdateStateMachine {
129 my $self = shift;
130 my $call_object = $self->new_with_coercions('Paws::StepFunctions::UpdateStateMachine', @_);
131 return $self->caller->do_call($self, $call_object);
132 }
133
134 sub GetAllExecutionHistory {
135 my $self = shift;
136  
137 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
138 my $result = $self->GetExecutionHistory(@_);
139 my $next_result = $result;
140  
141 if (not defined $callback) {
142 while ($next_result->nextToken) {
143 $next_result = $self->GetExecutionHistory(@_, nextToken => $next_result->nextToken);
144 push @{ $result->events }, @{ $next_result->events };
145 }
146 return $result;
147 } else {
148 while ($result->nextToken) {
149 $callback->($_ => 'events') foreach (@{ $result->events });
150 $result = $self->GetExecutionHistory(@_, nextToken => $result->nextToken);
151 }
152 $callback->($_ => 'events') foreach (@{ $result->events });
153 }
154  
155 return undef
156 }
157 sub ListAllActivities {
158 my $self = shift;
159  
160 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
161 my $result = $self->ListActivities(@_);
162 my $next_result = $result;
163  
164 if (not defined $callback) {
165 while ($next_result->nextToken) {
166 $next_result = $self->ListActivities(@_, nextToken => $next_result->nextToken);
167 push @{ $result->activities }, @{ $next_result->activities };
168 }
169 return $result;
170 } else {
171 while ($result->nextToken) {
172 $callback->($_ => 'activities') foreach (@{ $result->activities });
173 $result = $self->ListActivities(@_, nextToken => $result->nextToken);
174 }
175 $callback->($_ => 'activities') foreach (@{ $result->activities });
176 }
177  
178 return undef
179 }
180 sub ListAllExecutions {
181 my $self = shift;
182  
183 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
184 my $result = $self->ListExecutions(@_);
185 my $next_result = $result;
186  
187 if (not defined $callback) {
188 while ($next_result->nextToken) {
189 $next_result = $self->ListExecutions(@_, nextToken => $next_result->nextToken);
190 push @{ $result->executions }, @{ $next_result->executions };
191 }
192 return $result;
193 } else {
194 while ($result->nextToken) {
195 $callback->($_ => 'executions') foreach (@{ $result->executions });
196 $result = $self->ListExecutions(@_, nextToken => $result->nextToken);
197 }
198 $callback->($_ => 'executions') foreach (@{ $result->executions });
199 }
200  
201 return undef
202 }
203 sub ListAllStateMachines {
204 my $self = shift;
205  
206 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
207 my $result = $self->ListStateMachines(@_);
208 my $next_result = $result;
209  
210 if (not defined $callback) {
211 while ($next_result->nextToken) {
212 $next_result = $self->ListStateMachines(@_, nextToken => $next_result->nextToken);
213 push @{ $result->stateMachines }, @{ $next_result->stateMachines };
214 }
215 return $result;
216 } else {
217 while ($result->nextToken) {
218 $callback->($_ => 'stateMachines') foreach (@{ $result->stateMachines });
219 $result = $self->ListStateMachines(@_, nextToken => $result->nextToken);
220 }
221 $callback->($_ => 'stateMachines') foreach (@{ $result->stateMachines });
222 }
223  
224 return undef
225 }
226  
227  
228 sub operations { qw/CreateActivity CreateStateMachine DeleteActivity DeleteStateMachine DescribeActivity DescribeExecution DescribeStateMachine DescribeStateMachineForExecution GetActivityTask GetExecutionHistory ListActivities ListExecutions ListStateMachines ListTagsForResource SendTaskFailure SendTaskHeartbeat SendTaskSuccess StartExecution StartSyncExecution StopExecution TagResource UntagResource UpdateStateMachine / }
229  
230 1;
231  
232 ### main pod documentation begin ###
233  
234 =head1 NAME
235  
236 Paws::StepFunctions - Perl Interface to AWS AWS Step Functions
237  
238 =head1 SYNOPSIS
239  
240 use Paws;
241  
242 my $obj = Paws->service('StepFunctions');
243 my $res = $obj->Method(
244 Arg1 => $val1,
245 Arg2 => [ 'V1', 'V2' ],
246 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
247 # of the arguments type
248 Arg3 => { Att1 => 'Val1' },
249 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
250 # the constructor of the arguments type
251 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
252 );
253  
254 =head1 DESCRIPTION
255  
256 AWS Step Functions
257  
258 AWS Step Functions is a service that lets you coordinate the components
259 of distributed applications and microservices using visual workflows.
260  
261 You can use Step Functions to build applications from individual
262 components, each of which performs a discrete function, or I<task>,
263 allowing you to scale and change applications quickly. Step Functions
264 provides a console that helps visualize the components of your
265 application as a series of steps. Step Functions automatically triggers
266 and tracks each step, and retries steps when there are errors, so your
267 application executes predictably and in the right order every time.
268 Step Functions logs the state of each step, so you can quickly diagnose
269 and debug any issues.
270  
271 Step Functions manages operations and underlying infrastructure to
272 ensure your application is available at any scale. You can run tasks on
273 AWS, your own servers, or any system that has access to AWS. You can
274 access and use Step Functions using the console, the AWS SDKs, or an
275 HTTP API. For more information about Step Functions, see the I< AWS
276 Step Functions Developer Guide
277 (https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html) >.
278  
279 For the AWS API documentation, see L<https://docs.aws.amazon.com/step-functions/>
280  
281  
282 =head1 METHODS
283  
284 =head2 CreateActivity
285  
286 =over
287  
288 =item Name => Str
289  
290 =item [Tags => ArrayRef[L<Paws::StepFunctions::Tag>]]
291  
292  
293 =back
294  
295 Each argument is described in detail in: L<Paws::StepFunctions::CreateActivity>
296  
297 Returns: a L<Paws::StepFunctions::CreateActivityOutput> instance
298  
299 Creates an activity. An activity is a task that you write in any
300 programming language and host on any machine that has access to AWS
301 Step Functions. Activities must poll Step Functions using the
302 C<GetActivityTask> API action and respond using C<SendTask*> API
303 actions. This function lets Step Functions know the existence of your
304 activity and returns an identifier for use in a state machine and when
305 polling from the activity.
306  
307 This operation is eventually consistent. The results are best effort
308 and may not reflect very recent updates and changes.
309  
310 C<CreateActivity> is an idempotent API. Subsequent requests
311 wonE<rsquo>t create a duplicate resource if it was already created.
312 C<CreateActivity>'s idempotency check is based on the activity C<name>.
313 If a following request has different C<tags> values, Step Functions
314 will ignore these differences and treat it as an idempotent request of
315 the previous. In this case, C<tags> will not be updated, even if they
316 are different.
317  
318  
319 =head2 CreateStateMachine
320  
321 =over
322  
323 =item Definition => Str
324  
325 =item Name => Str
326  
327 =item RoleArn => Str
328  
329 =item [LoggingConfiguration => L<Paws::StepFunctions::LoggingConfiguration>]
330  
331 =item [Tags => ArrayRef[L<Paws::StepFunctions::Tag>]]
332  
333 =item [TracingConfiguration => L<Paws::StepFunctions::TracingConfiguration>]
334  
335 =item [Type => Str]
336  
337  
338 =back
339  
340 Each argument is described in detail in: L<Paws::StepFunctions::CreateStateMachine>
341  
342 Returns: a L<Paws::StepFunctions::CreateStateMachineOutput> instance
343  
344 Creates a state machine. A state machine consists of a collection of
345 states that can do work (C<Task> states), determine to which states to
346 transition next (C<Choice> states), stop an execution with an error
347 (C<Fail> states), and so on. State machines are specified using a
348 JSON-based, structured language. For more information, see Amazon
349 States Language
350 (https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html)
351 in the AWS Step Functions User Guide.
352  
353 This operation is eventually consistent. The results are best effort
354 and may not reflect very recent updates and changes.
355  
356 C<CreateStateMachine> is an idempotent API. Subsequent requests
357 wonE<rsquo>t create a duplicate resource if it was already created.
358 C<CreateStateMachine>'s idempotency check is based on the state machine
359 C<name>, C<definition>, C<type>, C<LoggingConfiguration> and
360 C<TracingConfiguration>. If a following request has a different
361 C<roleArn> or C<tags>, Step Functions will ignore these differences and
362 treat it as an idempotent request of the previous. In this case,
363 C<roleArn> and C<tags> will not be updated, even if they are different.
364  
365  
366 =head2 DeleteActivity
367  
368 =over
369  
370 =item ActivityArn => Str
371  
372  
373 =back
374  
375 Each argument is described in detail in: L<Paws::StepFunctions::DeleteActivity>
376  
377 Returns: a L<Paws::StepFunctions::DeleteActivityOutput> instance
378  
379 Deletes an activity.
380  
381  
382 =head2 DeleteStateMachine
383  
384 =over
385  
386 =item StateMachineArn => Str
387  
388  
389 =back
390  
391 Each argument is described in detail in: L<Paws::StepFunctions::DeleteStateMachine>
392  
393 Returns: a L<Paws::StepFunctions::DeleteStateMachineOutput> instance
394  
395 Deletes a state machine. This is an asynchronous operation: It sets the
396 state machine's status to C<DELETING> and begins the deletion process.
397  
398 For C<EXPRESS>state machines, the deletion will happen eventually
399 (usually less than a minute). Running executions may emit logs after
400 C<DeleteStateMachine> API is called.
401  
402  
403 =head2 DescribeActivity
404  
405 =over
406  
407 =item ActivityArn => Str
408  
409  
410 =back
411  
412 Each argument is described in detail in: L<Paws::StepFunctions::DescribeActivity>
413  
414 Returns: a L<Paws::StepFunctions::DescribeActivityOutput> instance
415  
416 Describes an activity.
417  
418 This operation is eventually consistent. The results are best effort
419 and may not reflect very recent updates and changes.
420  
421  
422 =head2 DescribeExecution
423  
424 =over
425  
426 =item ExecutionArn => Str
427  
428  
429 =back
430  
431 Each argument is described in detail in: L<Paws::StepFunctions::DescribeExecution>
432  
433 Returns: a L<Paws::StepFunctions::DescribeExecutionOutput> instance
434  
435 Describes an execution.
436  
437 This operation is eventually consistent. The results are best effort
438 and may not reflect very recent updates and changes.
439  
440 This API action is not supported by C<EXPRESS> state machines.
441  
442  
443 =head2 DescribeStateMachine
444  
445 =over
446  
447 =item StateMachineArn => Str
448  
449  
450 =back
451  
452 Each argument is described in detail in: L<Paws::StepFunctions::DescribeStateMachine>
453  
454 Returns: a L<Paws::StepFunctions::DescribeStateMachineOutput> instance
455  
456 Describes a state machine.
457  
458 This operation is eventually consistent. The results are best effort
459 and may not reflect very recent updates and changes.
460  
461  
462 =head2 DescribeStateMachineForExecution
463  
464 =over
465  
466 =item ExecutionArn => Str
467  
468  
469 =back
470  
471 Each argument is described in detail in: L<Paws::StepFunctions::DescribeStateMachineForExecution>
472  
473 Returns: a L<Paws::StepFunctions::DescribeStateMachineForExecutionOutput> instance
474  
475 Describes the state machine associated with a specific execution.
476  
477 This operation is eventually consistent. The results are best effort
478 and may not reflect very recent updates and changes.
479  
480 This API action is not supported by C<EXPRESS> state machines.
481  
482  
483 =head2 GetActivityTask
484  
485 =over
486  
487 =item ActivityArn => Str
488  
489 =item [WorkerName => Str]
490  
491  
492 =back
493  
494 Each argument is described in detail in: L<Paws::StepFunctions::GetActivityTask>
495  
496 Returns: a L<Paws::StepFunctions::GetActivityTaskOutput> instance
497  
498 Used by workers to retrieve a task (with the specified activity ARN)
499 which has been scheduled for execution by a running state machine. This
500 initiates a long poll, where the service holds the HTTP connection open
501 and responds as soon as a task becomes available (i.e. an execution of
502 a task of this type is needed.) The maximum time the service holds on
503 to the request before responding is 60 seconds. If no task is available
504 within 60 seconds, the poll returns a C<taskToken> with a null string.
505  
506 Workers should set their client side socket timeout to at least 65
507 seconds (5 seconds higher than the maximum time the service may hold
508 the poll request).
509  
510 Polling with C<GetActivityTask> can cause latency in some
511 implementations. See Avoid Latency When Polling for Activity Tasks
512 (https://docs.aws.amazon.com/step-functions/latest/dg/bp-activity-pollers.html)
513 in the Step Functions Developer Guide.
514  
515  
516 =head2 GetExecutionHistory
517  
518 =over
519  
520 =item ExecutionArn => Str
521  
522 =item [IncludeExecutionData => Bool]
523  
524 =item [MaxResults => Int]
525  
526 =item [NextToken => Str]
527  
528 =item [ReverseOrder => Bool]
529  
530  
531 =back
532  
533 Each argument is described in detail in: L<Paws::StepFunctions::GetExecutionHistory>
534  
535 Returns: a L<Paws::StepFunctions::GetExecutionHistoryOutput> instance
536  
537 Returns the history of the specified execution as a list of events. By
538 default, the results are returned in ascending order of the
539 C<timeStamp> of the events. Use the C<reverseOrder> parameter to get
540 the latest events first.
541  
542 If C<nextToken> is returned, there are more results available. The
543 value of C<nextToken> is a unique pagination token for each page. Make
544 the call again using the returned token to retrieve the next page. Keep
545 all other arguments unchanged. Each pagination token expires after 24
546 hours. Using an expired pagination token will return an I<HTTP 400
547 InvalidToken> error.
548  
549 This API action is not supported by C<EXPRESS> state machines.
550  
551  
552 =head2 ListActivities
553  
554 =over
555  
556 =item [MaxResults => Int]
557  
558 =item [NextToken => Str]
559  
560  
561 =back
562  
563 Each argument is described in detail in: L<Paws::StepFunctions::ListActivities>
564  
565 Returns: a L<Paws::StepFunctions::ListActivitiesOutput> instance
566  
567 Lists the existing activities.
568  
569 If C<nextToken> is returned, there are more results available. The
570 value of C<nextToken> is a unique pagination token for each page. Make
571 the call again using the returned token to retrieve the next page. Keep
572 all other arguments unchanged. Each pagination token expires after 24
573 hours. Using an expired pagination token will return an I<HTTP 400
574 InvalidToken> error.
575  
576 This operation is eventually consistent. The results are best effort
577 and may not reflect very recent updates and changes.
578  
579  
580 =head2 ListExecutions
581  
582 =over
583  
584 =item StateMachineArn => Str
585  
586 =item [MaxResults => Int]
587  
588 =item [NextToken => Str]
589  
590 =item [StatusFilter => Str]
591  
592  
593 =back
594  
595 Each argument is described in detail in: L<Paws::StepFunctions::ListExecutions>
596  
597 Returns: a L<Paws::StepFunctions::ListExecutionsOutput> instance
598  
599 Lists the executions of a state machine that meet the filtering
600 criteria. Results are sorted by time, with the most recent execution
601 first.
602  
603 If C<nextToken> is returned, there are more results available. The
604 value of C<nextToken> is a unique pagination token for each page. Make
605 the call again using the returned token to retrieve the next page. Keep
606 all other arguments unchanged. Each pagination token expires after 24
607 hours. Using an expired pagination token will return an I<HTTP 400
608 InvalidToken> error.
609  
610 This operation is eventually consistent. The results are best effort
611 and may not reflect very recent updates and changes.
612  
613 This API action is not supported by C<EXPRESS> state machines.
614  
615  
616 =head2 ListStateMachines
617  
618 =over
619  
620 =item [MaxResults => Int]
621  
622 =item [NextToken => Str]
623  
624  
625 =back
626  
627 Each argument is described in detail in: L<Paws::StepFunctions::ListStateMachines>
628  
629 Returns: a L<Paws::StepFunctions::ListStateMachinesOutput> instance
630  
631 Lists the existing state machines.
632  
633 If C<nextToken> is returned, there are more results available. The
634 value of C<nextToken> is a unique pagination token for each page. Make
635 the call again using the returned token to retrieve the next page. Keep
636 all other arguments unchanged. Each pagination token expires after 24
637 hours. Using an expired pagination token will return an I<HTTP 400
638 InvalidToken> error.
639  
640 This operation is eventually consistent. The results are best effort
641 and may not reflect very recent updates and changes.
642  
643  
644 =head2 ListTagsForResource
645  
646 =over
647  
648 =item ResourceArn => Str
649  
650  
651 =back
652  
653 Each argument is described in detail in: L<Paws::StepFunctions::ListTagsForResource>
654  
655 Returns: a L<Paws::StepFunctions::ListTagsForResourceOutput> instance
656  
657 List tags for a given resource.
658  
659 Tags may only contain Unicode letters, digits, white space, or these
660 symbols: C<_ . : / = + - @>.
661  
662  
663 =head2 SendTaskFailure
664  
665 =over
666  
667 =item TaskToken => Str
668  
669 =item [Cause => Str]
670  
671 =item [Error => Str]
672  
673  
674 =back
675  
676 Each argument is described in detail in: L<Paws::StepFunctions::SendTaskFailure>
677  
678 Returns: a L<Paws::StepFunctions::SendTaskFailureOutput> instance
679  
680 Used by activity workers and task states using the callback
681 (https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-wait-token)
682 pattern to report that the task identified by the C<taskToken> failed.
683  
684  
685 =head2 SendTaskHeartbeat
686  
687 =over
688  
689 =item TaskToken => Str
690  
691  
692 =back
693  
694 Each argument is described in detail in: L<Paws::StepFunctions::SendTaskHeartbeat>
695  
696 Returns: a L<Paws::StepFunctions::SendTaskHeartbeatOutput> instance
697  
698 Used by activity workers and task states using the callback
699 (https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-wait-token)
700 pattern to report to Step Functions that the task represented by the
701 specified C<taskToken> is still making progress. This action resets the
702 C<Heartbeat> clock. The C<Heartbeat> threshold is specified in the
703 state machine's Amazon States Language definition
704 (C<HeartbeatSeconds>). This action does not in itself create an event
705 in the execution history. However, if the task times out, the execution
706 history contains an C<ActivityTimedOut> entry for activities, or a
707 C<TaskTimedOut> entry for for tasks using the job run
708 (https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-sync)
709 or callback
710 (https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-wait-token)
711 pattern.
712  
713 The C<Timeout> of a task, defined in the state machine's Amazon States
714 Language definition, is its maximum allowed duration, regardless of the
715 number of SendTaskHeartbeat requests received. Use C<HeartbeatSeconds>
716 to configure the timeout interval for heartbeats.
717  
718  
719 =head2 SendTaskSuccess
720  
721 =over
722  
723 =item Output => Str
724  
725 =item TaskToken => Str
726  
727  
728 =back
729  
730 Each argument is described in detail in: L<Paws::StepFunctions::SendTaskSuccess>
731  
732 Returns: a L<Paws::StepFunctions::SendTaskSuccessOutput> instance
733  
734 Used by activity workers and task states using the callback
735 (https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-wait-token)
736 pattern to report that the task identified by the C<taskToken>
737 completed successfully.
738  
739  
740 =head2 StartExecution
741  
742 =over
743  
744 =item StateMachineArn => Str
745  
746 =item [Input => Str]
747  
748 =item [Name => Str]
749  
750 =item [TraceHeader => Str]
751  
752  
753 =back
754  
755 Each argument is described in detail in: L<Paws::StepFunctions::StartExecution>
756  
757 Returns: a L<Paws::StepFunctions::StartExecutionOutput> instance
758  
759 Starts a state machine execution.
760  
761 C<StartExecution> is idempotent. If C<StartExecution> is called with
762 the same name and input as a running execution, the call will succeed
763 and return the same response as the original request. If the execution
764 is closed or if the input is different, it will return a 400
765 C<ExecutionAlreadyExists> error. Names can be reused after 90 days.
766  
767  
768 =head2 StartSyncExecution
769  
770 =over
771  
772 =item StateMachineArn => Str
773  
774 =item [Input => Str]
775  
776 =item [Name => Str]
777  
778 =item [TraceHeader => Str]
779  
780  
781 =back
782  
783 Each argument is described in detail in: L<Paws::StepFunctions::StartSyncExecution>
784  
785 Returns: a L<Paws::StepFunctions::StartSyncExecutionOutput> instance
786  
787 Starts a Synchronous Express state machine execution.
788  
789  
790 =head2 StopExecution
791  
792 =over
793  
794 =item ExecutionArn => Str
795  
796 =item [Cause => Str]
797  
798 =item [Error => Str]
799  
800  
801 =back
802  
803 Each argument is described in detail in: L<Paws::StepFunctions::StopExecution>
804  
805 Returns: a L<Paws::StepFunctions::StopExecutionOutput> instance
806  
807 Stops an execution.
808  
809 This API action is not supported by C<EXPRESS> state machines.
810  
811  
812 =head2 TagResource
813  
814 =over
815  
816 =item ResourceArn => Str
817  
818 =item Tags => ArrayRef[L<Paws::StepFunctions::Tag>]
819  
820  
821 =back
822  
823 Each argument is described in detail in: L<Paws::StepFunctions::TagResource>
824  
825 Returns: a L<Paws::StepFunctions::TagResourceOutput> instance
826  
827 Add a tag to a Step Functions resource.
828  
829 An array of key-value pairs. For more information, see Using Cost
830 Allocation Tags
831 (https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html)
832 in the I<AWS Billing and Cost Management User Guide>, and Controlling
833 Access Using IAM Tags
834 (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_iam-tags.html).
835  
836 Tags may only contain Unicode letters, digits, white space, or these
837 symbols: C<_ . : / = + - @>.
838  
839  
840 =head2 UntagResource
841  
842 =over
843  
844 =item ResourceArn => Str
845  
846 =item TagKeys => ArrayRef[Str|Undef]
847  
848  
849 =back
850  
851 Each argument is described in detail in: L<Paws::StepFunctions::UntagResource>
852  
853 Returns: a L<Paws::StepFunctions::UntagResourceOutput> instance
854  
855 Remove a tag from a Step Functions resource
856  
857  
858 =head2 UpdateStateMachine
859  
860 =over
861  
862 =item StateMachineArn => Str
863  
864 =item [Definition => Str]
865  
866 =item [LoggingConfiguration => L<Paws::StepFunctions::LoggingConfiguration>]
867  
868 =item [RoleArn => Str]
869  
870 =item [TracingConfiguration => L<Paws::StepFunctions::TracingConfiguration>]
871  
872  
873 =back
874  
875 Each argument is described in detail in: L<Paws::StepFunctions::UpdateStateMachine>
876  
877 Returns: a L<Paws::StepFunctions::UpdateStateMachineOutput> instance
878  
879 Updates an existing state machine by modifying its C<definition>,
880 C<roleArn>, or C<loggingConfiguration>. Running executions will
881 continue to use the previous C<definition> and C<roleArn>. You must
882 include at least one of C<definition> or C<roleArn> or you will receive
883 a C<MissingRequiredParameter> error.
884  
885 All C<StartExecution> calls within a few seconds will use the updated
886 C<definition> and C<roleArn>. Executions started immediately after
887 calling C<UpdateStateMachine> may use the previous state machine
888 C<definition> and C<roleArn>.
889  
890  
891  
892  
893 =head1 PAGINATORS
894  
895 Paginator methods are helpers that repetively call methods that return partial results
896  
897 =head2 GetAllExecutionHistory(sub { },ExecutionArn => Str, [IncludeExecutionData => Bool, MaxResults => Int, NextToken => Str, ReverseOrder => Bool])
898  
899 =head2 GetAllExecutionHistory(ExecutionArn => Str, [IncludeExecutionData => Bool, MaxResults => Int, NextToken => Str, ReverseOrder => Bool])
900  
901  
902 If passed a sub as first parameter, it will call the sub for each element found in :
903  
904 - events, passing the object as the first parameter, and the string 'events' as the second parameter
905  
906 If not, it will return a a L<Paws::StepFunctions::GetExecutionHistoryOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
907  
908  
909 =head2 ListAllActivities(sub { },[MaxResults => Int, NextToken => Str])
910  
911 =head2 ListAllActivities([MaxResults => Int, NextToken => Str])
912  
913  
914 If passed a sub as first parameter, it will call the sub for each element found in :
915  
916 - activities, passing the object as the first parameter, and the string 'activities' as the second parameter
917  
918 If not, it will return a a L<Paws::StepFunctions::ListActivitiesOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
919  
920  
921 =head2 ListAllExecutions(sub { },StateMachineArn => Str, [MaxResults => Int, NextToken => Str, StatusFilter => Str])
922  
923 =head2 ListAllExecutions(StateMachineArn => Str, [MaxResults => Int, NextToken => Str, StatusFilter => Str])
924  
925  
926 If passed a sub as first parameter, it will call the sub for each element found in :
927  
928 - executions, passing the object as the first parameter, and the string 'executions' as the second parameter
929  
930 If not, it will return a a L<Paws::StepFunctions::ListExecutionsOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
931  
932  
933 =head2 ListAllStateMachines(sub { },[MaxResults => Int, NextToken => Str])
934  
935 =head2 ListAllStateMachines([MaxResults => Int, NextToken => Str])
936  
937  
938 If passed a sub as first parameter, it will call the sub for each element found in :
939  
940 - stateMachines, passing the object as the first parameter, and the string 'stateMachines' as the second parameter
941  
942 If not, it will return a a L<Paws::StepFunctions::ListStateMachinesOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
943  
944  
945  
946  
947  
948 =head1 SEE ALSO
949  
950 This service class forms part of L<Paws>
951  
952 =head1 BUGS and CONTRIBUTIONS
953  
954 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
955  
956 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
957  
958 =cut
959