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
|
// Code generated by smithy-go-codegen DO NOT EDIT.
package opsworkscm
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/opsworkscm/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Restores a backup to a server that is in a CONNECTION_LOST, HEALTHY, RUNNING,
// UNHEALTHY, or TERMINATED state. When you run RestoreServer, the server's EC2
// instance is deleted, and a new EC2 instance is configured. RestoreServer
// maintains the existing server endpoint, so configuration management of the
// server's client devices (nodes) should continue to work. Restoring from a backup
// is performed by creating a new EC2 instance. If restoration is successful, and
// the server is in a HEALTHY state, AWS OpsWorks CM switches traffic over to the
// new instance. After restoration is finished, the old EC2 instance is maintained
// in a Running or Stopped state, but is eventually terminated. This operation is
// asynchronous. An InvalidStateException is thrown when the server is not in a
// valid state. A ResourceNotFoundException is thrown when the server does not
// exist. A ValidationException is raised when parameters of the request are not
// valid.
func (c *Client) RestoreServer(ctx context.Context, params *RestoreServerInput, optFns ...func(*Options)) (*RestoreServerOutput, error) {
if params == nil {
params = &RestoreServerInput{}
}
result, metadata, err := c.invokeOperation(ctx, "RestoreServer", params, optFns, c.addOperationRestoreServerMiddlewares)
if err != nil {
return nil, err
}
out := result.(*RestoreServerOutput)
out.ResultMetadata = metadata
return out, nil
}
type RestoreServerInput struct {
// The ID of the backup that you want to use to restore a server.
//
// This member is required.
BackupId *string
// The name of the server that you want to restore.
//
// This member is required.
ServerName *string
// The type of instance to restore. Valid values must be specified in the following
// format: ^([cm][34]|t2).* For example, m5.large. Valid values are m5.large,
// r5.xlarge, and r5.2xlarge. If you do not specify this parameter, RestoreServer
// uses the instance type from the specified backup.
InstanceType *string
// The name of the key pair to set on the new EC2 instance. This can be helpful if
// the administrator no longer has the SSH key.
KeyPair *string
noSmithyDocumentSerde
}
type RestoreServerOutput struct {
// Describes a configuration management server.
Server *types.Server
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationRestoreServerMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpRestoreServer{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpRestoreServer{}, 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 = addOpRestoreServerValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opRestoreServer(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_opRestoreServer(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "opsworks-cm",
OperationName: "RestoreServer",
}
}
|
