1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
|
// Code generated by smithy-go-codegen DO NOT EDIT.
package swf
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Used by activity workers to report to the service that the ActivityTask
// represented by the specified taskToken is still making progress. The worker can
// also specify details of the progress, for example percent complete, using the
// details parameter. This action can also be used by the worker as a mechanism to
// check if cancellation is being requested for the activity task. If a
// cancellation is being attempted for the specified task, then the boolean
// cancelRequested flag returned by the service is set to true . This action resets
// the taskHeartbeatTimeout clock. The taskHeartbeatTimeout is specified in
// RegisterActivityType . This action doesn't in itself create an event in the
// workflow execution history. However, if the task times out, the workflow
// execution history contains a ActivityTaskTimedOut event that contains the
// information from the last heartbeat generated by the activity worker. The
// taskStartToCloseTimeout of an activity type is the maximum duration of an
// activity task, regardless of the number of RecordActivityTaskHeartbeat requests
// received. The taskStartToCloseTimeout is also specified in RegisterActivityType
// . This operation is only useful for long-lived activities to report liveliness
// of the task and to determine if a cancellation is being attempted. If the
// cancelRequested flag returns true , a cancellation is being attempted. If the
// worker can cancel the activity, it should respond with
// RespondActivityTaskCanceled . Otherwise, it should ignore the cancellation
// request. Access Control You can use IAM policies to control this action's access
// to Amazon SWF resources as follows:
// - Use a Resource element with the domain name to limit the action to only
// specified domains.
// - Use an Action element to allow or deny permission to call this action.
// - You cannot use an IAM policy to constrain this action's parameters.
//
// If the caller doesn't have sufficient permissions to invoke the action, or the
// parameter values fall outside the specified constraints, the action fails. The
// associated event attribute's cause parameter is set to OPERATION_NOT_PERMITTED .
// For details and example IAM policies, see Using IAM to Manage Access to Amazon
// SWF Workflows (https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html)
// in the Amazon SWF Developer Guide.
func (c *Client) RecordActivityTaskHeartbeat(ctx context.Context, params *RecordActivityTaskHeartbeatInput, optFns ...func(*Options)) (*RecordActivityTaskHeartbeatOutput, error) {
if params == nil {
params = &RecordActivityTaskHeartbeatInput{}
}
result, metadata, err := c.invokeOperation(ctx, "RecordActivityTaskHeartbeat", params, optFns, c.addOperationRecordActivityTaskHeartbeatMiddlewares)
if err != nil {
return nil, err
}
out := result.(*RecordActivityTaskHeartbeatOutput)
out.ResultMetadata = metadata
return out, nil
}
type RecordActivityTaskHeartbeatInput struct {
// The taskToken of the ActivityTask . taskToken is generated by the service and
// should be treated as an opaque value. If the task is passed to another process,
// its taskToken must also be passed. This enables it to provide its progress and
// respond with results.
//
// This member is required.
TaskToken *string
// If specified, contains details about the progress of the task.
Details *string
noSmithyDocumentSerde
}
// Status information about an activity task.
type RecordActivityTaskHeartbeatOutput struct {
// Set to true if cancellation of the task is requested.
//
// This member is required.
CancelRequested bool
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationRecordActivityTaskHeartbeatMiddlewares(stack *middleware.Stack, options Options) (err error) {
if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil {
return err
}
err = stack.Serialize.Add(&awsAwsjson10_serializeOpRecordActivityTaskHeartbeat{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson10_deserializeOpRecordActivityTaskHeartbeat{}, middleware.After)
if err != nil {
return err
}
if err := addProtocolFinalizerMiddlewares(stack, options, "RecordActivityTaskHeartbeat"); err != nil {
return fmt.Errorf("add protocol finalizers: %v", err)
}
if err = addlegacyEndpointContextSetter(stack, options); err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack, options); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil {
return err
}
if err = addOpRecordActivityTaskHeartbeatValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opRecordActivityTaskHeartbeat(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
if err = addDisableHTTPSMiddleware(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opRecordActivityTaskHeartbeat(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
OperationName: "RecordActivityTaskHeartbeat",
}
}
|
