/
api_op_CreateSnapshot.go
195 lines (173 loc) · 6.35 KB
/
api_op_CreateSnapshot.go
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
// Code generated by smithy-go-codegen DO NOT EDIT.
package fsx
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/fsx/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a snapshot of an existing Amazon FSx for OpenZFS volume. With snapshots,
// you can easily undo file changes and compare file versions by restoring the
// volume to a previous version. If a snapshot with the specified client request
// token exists, and the parameters match, this operation returns the description
// of the existing snapshot. If a snapshot with the specified client request token
// exists, and the parameters don't match, this operation returns
// IncompatibleParameterError. If a snapshot with the specified client request
// token doesn't exist, CreateSnapshot does the following:
//
// * Creates a new OpenZFS
// snapshot with an assigned ID, and an initial lifecycle state of CREATING.
//
// *
// Returns the description of the snapshot.
//
// By using the idempotent operation, you
// can retry a CreateSnapshot operation without the risk of creating an extra
// snapshot. This approach can be useful when an initial call fails in a way that
// makes it unclear whether a snapshot was created. If you use the same client
// request token and the initial call created a snapshot, the operation returns a
// successful result because all the parameters are the same. The CreateSnapshot
// operation returns while the snapshot's lifecycle state is still CREATING. You
// can check the snapshot creation status by calling the DescribeSnapshots
// (https://docs.aws.amazon.com/fsx/latest/APIReference/API_DescribeSnapshots.html)
// operation, which returns the snapshot state along with other information.
func (c *Client) CreateSnapshot(ctx context.Context, params *CreateSnapshotInput, optFns ...func(*Options)) (*CreateSnapshotOutput, error) {
if params == nil {
params = &CreateSnapshotInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateSnapshot", params, optFns, c.addOperationCreateSnapshotMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateSnapshotOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateSnapshotInput struct {
// The name of the snapshot.
//
// This member is required.
Name *string
// The ID of the volume that you are taking a snapshot of.
//
// This member is required.
VolumeId *string
// (Optional) An idempotency token for resource creation, in a string of up to 64
// ASCII characters. This token is automatically filled on your behalf when you use
// the Command Line Interface (CLI) or an Amazon Web Services SDK.
ClientRequestToken *string
// A list of Tag values, with a maximum of 50 elements.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateSnapshotOutput struct {
// A description of the snapshot.
Snapshot *types.Snapshot
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateSnapshotMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateSnapshot{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateSnapshot{}, 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 = addIdempotencyToken_opCreateSnapshotMiddleware(stack, options); err != nil {
return err
}
if err = addOpCreateSnapshotValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateSnapshot(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
}
type idempotencyToken_initializeOpCreateSnapshot struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpCreateSnapshot) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpCreateSnapshot) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*CreateSnapshotInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateSnapshotInput ")
}
if input.ClientRequestToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientRequestToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opCreateSnapshotMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpCreateSnapshot{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opCreateSnapshot(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fsx",
OperationName: "CreateSnapshot",
}
}