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
|
// Code generated by smithy-go-codegen DO NOT EDIT.
package efs
import (
"context"
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/efs/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Use this action to manage EFS lifecycle management and intelligent tiering. A
// LifecycleConfiguration consists of one or more LifecyclePolicy objects that
// define the following:
//
// * EFS Lifecycle management - When Amazon EFS
// automatically transitions files in a file system into the lower-cost Infrequent
// Access (IA) storage class. To enable EFS Lifecycle management, set the value of
// TransitionToIA to one of the available options.
//
// * EFS Intelligent tiering -
// When Amazon EFS automatically transitions files from IA back into the file
// system's primary storage class (Standard or One Zone Standard. To enable EFS
// Intelligent Tiering, set the value of TransitionToPrimaryStorageClass to
// AFTER_1_ACCESS.
//
// For more information, see EFS Lifecycle Management
// (https://docs.aws.amazon.com/efs/latest/ug/lifecycle-management-efs.html).
//
// Each
// Amazon EFS file system supports one lifecycle configuration, which applies to
// all files in the file system. If a LifecycleConfiguration object already exists
// for the specified file system, a PutLifecycleConfiguration call modifies the
// existing configuration. A PutLifecycleConfiguration call with an empty
// LifecyclePolicies array in the request body deletes any existing
// LifecycleConfiguration and turns off lifecycle management and intelligent
// tiering for the file system.
//
// In the request, specify the following:
//
// * The ID
// for the file system for which you are enabling, disabling, or modifying
// lifecycle management and intelligent tiering.
//
// * A LifecyclePolicies array of
// LifecyclePolicy objects that define when files are moved into IA storage, and
// when they are moved back to Standard storage. Amazon EFS requires that each
// LifecyclePolicy object have only have a single transition, so the
// LifecyclePolicies array needs to be structured with separate LifecyclePolicy
// objects. See the example requests in the following section for more
// information.
//
// This operation requires permissions for the
// elasticfilesystem:PutLifecycleConfiguration operation. To apply a
// LifecycleConfiguration object to an encrypted file system, you need the same Key
// Management Service permissions as when you created the encrypted file system.
func (c *Client) PutLifecycleConfiguration(ctx context.Context, params *PutLifecycleConfigurationInput, optFns ...func(*Options)) (*PutLifecycleConfigurationOutput, error) {
if params == nil {
params = &PutLifecycleConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "PutLifecycleConfiguration", params, optFns, c.addOperationPutLifecycleConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*PutLifecycleConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type PutLifecycleConfigurationInput struct {
// The ID of the file system for which you are creating the LifecycleConfiguration
// object (String).
//
// This member is required.
FileSystemId *string
// An array of LifecyclePolicy objects that define the file system's
// LifecycleConfiguration object. A LifecycleConfiguration object informs EFS
// lifecycle management and EFS Intelligent-Tiering of the following:
//
// * When to
// move files in the file system from primary storage to the IA storage class.
//
// *
// When to move files that are in IA storage to primary storage.
//
// When using the
// put-lifecycle-configuration CLI command or the PutLifecycleConfiguration API
// action, Amazon EFS requires that each LifecyclePolicy object have only a single
// transition. This means that in a request body, LifecyclePolicies must be
// structured as an array of LifecyclePolicy objects, one object for each
// transition, TransitionToIA, TransitionToPrimaryStorageClass. See the example
// requests in the following section for more information.
//
// This member is required.
LifecyclePolicies []types.LifecyclePolicy
noSmithyDocumentSerde
}
type PutLifecycleConfigurationOutput struct {
// An array of lifecycle management policies. EFS supports a maximum of one policy
// per file system.
LifecyclePolicies []types.LifecyclePolicy
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationPutLifecycleConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpPutLifecycleConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpPutLifecycleConfiguration{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpPutLifecycleConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opPutLifecycleConfiguration(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opPutLifecycleConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "elasticfilesystem",
OperationName: "PutLifecycleConfiguration",
}
}
|
