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
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
// Code generated by smithy-go-codegen DO NOT EDIT.
package wafv2
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/aws-sdk-go-v2/service/wafv2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Defines the versions of your managed rule set that you are offering to the
// customers. Customers see your offerings as managed rule groups with versioning.
// This is intended for use only by vendors of managed rule sets. Vendors are
// Amazon Web Services and Amazon Web Services Marketplace sellers. Vendors, you
// can use the managed rule set APIs to provide controlled rollout of your
// versioned managed rule group offerings for your customers. The APIs are
// ListManagedRuleSets , GetManagedRuleSet , PutManagedRuleSetVersions , and
// UpdateManagedRuleSetVersionExpiryDate . Customers retrieve their managed rule
// group list by calling ListAvailableManagedRuleGroups . The name that you provide
// here for your managed rule set is the name the customer sees for the
// corresponding managed rule group. Customers can retrieve the available versions
// for a managed rule group by calling ListAvailableManagedRuleGroupVersions . You
// provide a rule group specification for each version. For each managed rule set,
// you must specify a version that you recommend using. To initiate the expiration
// of a managed rule group version, use UpdateManagedRuleSetVersionExpiryDate .
func (c *Client) PutManagedRuleSetVersions(ctx context.Context, params *PutManagedRuleSetVersionsInput, optFns ...func(*Options)) (*PutManagedRuleSetVersionsOutput, error) {
if params == nil {
params = &PutManagedRuleSetVersionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "PutManagedRuleSetVersions", params, optFns, c.addOperationPutManagedRuleSetVersionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*PutManagedRuleSetVersionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type PutManagedRuleSetVersionsInput struct {
// A unique identifier for the managed rule set. The ID is returned in the
// responses to commands like list . You provide it to operations like get and
// update .
//
// This member is required.
Id *string
// A token used for optimistic locking. WAF returns a token to your get and list
// requests, to mark the state of the entity at the time of the request. To make
// changes to the entity associated with the token, you provide the token to
// operations like update and delete . WAF uses the token to ensure that no changes
// have been made to the entity since you last retrieved it. If a change has been
// made, the update fails with a WAFOptimisticLockException . If this happens,
// perform another get , and use the new token returned by that operation.
//
// This member is required.
LockToken *string
// The name of the managed rule set. You use this, along with the rule set ID, to
// identify the rule set. This name is assigned to the corresponding managed rule
// group, which your customers can access and use.
//
// This member is required.
Name *string
// Specifies whether this is for an Amazon CloudFront distribution or for a
// regional application. A regional application can be an Application Load Balancer
// (ALB), an Amazon API Gateway REST API, an AppSync GraphQL API, an Amazon Cognito
// user pool, an App Runner service, or an Amazon Web Services Verified Access
// instance. To work with CloudFront, you must also specify the Region US East (N.
// Virginia) as follows:
// - CLI - Specify the Region when you use the CloudFront scope:
// --scope=CLOUDFRONT --region=us-east-1 .
// - API and SDKs - For all calls, use the Region endpoint us-east-1.
//
// This member is required.
Scope types.Scope
// The version of the named managed rule group that you'd like your customers to
// choose, from among your version offerings.
RecommendedVersion *string
// The versions of the named managed rule group that you want to offer to your
// customers.
VersionsToPublish map[string]types.VersionToPublish
noSmithyDocumentSerde
}
type PutManagedRuleSetVersionsOutput struct {
// A token used for optimistic locking. WAF returns a token to your get and list
// requests, to mark the state of the entity at the time of the request. To make
// changes to the entity associated with the token, you provide the token to
// operations like update and delete . WAF uses the token to ensure that no changes
// have been made to the entity since you last retrieved it. If a change has been
// made, the update fails with a WAFOptimisticLockException . If this happens,
// perform another get , and use the new token returned by that operation.
NextLockToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationPutManagedRuleSetVersionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil {
return err
}
err = stack.Serialize.Add(&awsAwsjson11_serializeOpPutManagedRuleSetVersions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpPutManagedRuleSetVersions{}, middleware.After)
if err != nil {
return err
}
if err := addProtocolFinalizerMiddlewares(stack, options, "PutManagedRuleSetVersions"); 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 = addOpPutManagedRuleSetVersionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opPutManagedRuleSetVersions(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_opPutManagedRuleSetVersions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
OperationName: "PutManagedRuleSetVersions",
}
}
|
