/
api_op_CreateBackup.go
205 lines (186 loc) · 7.06 KB
/
api_op_CreateBackup.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
196
197
198
199
200
201
202
203
204
205
// 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 backup of an existing Amazon FSx file system. Creating regular backups
// for your file system is a best practice, enabling you to restore a file system
// from a backup if an issue arises with the original file system. For Amazon FSx
// for Lustre file systems, you can create a backup only for file systems with the
// following configuration:
//
// * a Persistent deployment type
//
// * is not linked to a
// data respository.
//
// For more information about backing up Amazon FSx for Lustre
// file systems, see Working with FSx for Lustre backups
// (https://docs.aws.amazon.com/fsx/latest/LustreGuide/using-backups-fsx.html). For
// more information about backing up Amazon FSx for Windows file systems, see
// Working with FSx for Windows backups
// (https://docs.aws.amazon.com/fsx/latest/WindowsGuide/using-backups.html). If a
// backup with the specified client request token exists, and the parameters match,
// this operation returns the description of the existing backup. If a backup
// specified client request token exists, and the parameters don't match, this
// operation returns IncompatibleParameterError. If a backup with the specified
// client request token doesn't exist, CreateBackup does the following:
//
// * Creates
// a new Amazon FSx backup with an assigned ID, and an initial lifecycle state of
// CREATING.
//
// * Returns the description of the backup.
//
// By using the idempotent
// operation, you can retry a CreateBackup operation without the risk of creating
// an extra backup. This approach can be useful when an initial call fails in a way
// that makes it unclear whether a backup was created. If you use the same client
// request token and the initial call created a backup, the operation returns a
// successful result because all the parameters are the same. The CreateBackup
// operation returns while the backup's lifecycle state is still CREATING. You can
// check the backup creation status by calling the DescribeBackups operation, which
// returns the backup state along with other information.
func (c *Client) CreateBackup(ctx context.Context, params *CreateBackupInput, optFns ...func(*Options)) (*CreateBackupOutput, error) {
if params == nil {
params = &CreateBackupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateBackup", params, optFns, c.addOperationCreateBackupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateBackupOutput)
out.ResultMetadata = metadata
return out, nil
}
// The request object for the CreateBackup operation.
type CreateBackupInput struct {
// The ID of the file system to back up.
//
// This member is required.
FileSystemId *string
// (Optional) A string of up to 64 ASCII characters that Amazon FSx uses to ensure
// idempotent creation. This string is automatically filled on your behalf when you
// use the AWS Command Line Interface (AWS CLI) or an AWS SDK.
ClientRequestToken *string
// (Optional) The tags to apply to the backup at backup creation. The key value of
// the Name tag appears in the console as the backup name. If you have set
// CopyTagsToBackups to true, and you specify one or more tags using the
// CreateBackup action, no existing file system tags are copied from the file
// system to the backup.
Tags []types.Tag
}
// The response object for the CreateBackup operation.
type CreateBackupOutput struct {
// A description of the backup.
Backup *types.Backup
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
}
func (c *Client) addOperationCreateBackupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateBackup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateBackup{}, 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_opCreateBackupMiddleware(stack, options); err != nil {
return err
}
if err = addOpCreateBackupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateBackup(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_initializeOpCreateBackup struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpCreateBackup) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpCreateBackup) 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.(*CreateBackupInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateBackupInput ")
}
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_opCreateBackupMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpCreateBackup{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opCreateBackup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fsx",
OperationName: "CreateBackup",
}
}