api_op_GetChange.go (12522B)
1 // Code generated by smithy-go-codegen DO NOT EDIT. 2 3 package route53 4 5 import ( 6 "context" 7 "fmt" 8 awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" 9 "github.com/aws/aws-sdk-go-v2/service/route53/types" 10 "github.com/aws/smithy-go/middleware" 11 smithytime "github.com/aws/smithy-go/time" 12 smithyhttp "github.com/aws/smithy-go/transport/http" 13 smithywaiter "github.com/aws/smithy-go/waiter" 14 "time" 15 ) 16 17 // Returns the current status of a change batch request. The status is one of the 18 // following values: 19 // 20 // - PENDING indicates that the changes in this request have not propagated to 21 // all Amazon Route 53 DNS servers managing the hosted zone. This is the initial 22 // status of all change batch requests. 23 // 24 // - INSYNC indicates that the changes have propagated to all Route 53 DNS 25 // servers managing the hosted zone. 26 func (c *Client) GetChange(ctx context.Context, params *GetChangeInput, optFns ...func(*Options)) (*GetChangeOutput, error) { 27 if params == nil { 28 params = &GetChangeInput{} 29 } 30 31 result, metadata, err := c.invokeOperation(ctx, "GetChange", params, optFns, c.addOperationGetChangeMiddlewares) 32 if err != nil { 33 return nil, err 34 } 35 36 out := result.(*GetChangeOutput) 37 out.ResultMetadata = metadata 38 return out, nil 39 } 40 41 // The input for a GetChange request. 42 type GetChangeInput struct { 43 44 // The ID of the change batch request. The value that you specify here is the 45 // value that ChangeResourceRecordSets returned in the Id element when you 46 // submitted the request. 47 // 48 // This member is required. 49 Id *string 50 51 noSmithyDocumentSerde 52 } 53 54 // A complex type that contains the ChangeInfo element. 55 type GetChangeOutput struct { 56 57 // A complex type that contains information about the specified change batch. 58 // 59 // This member is required. 60 ChangeInfo *types.ChangeInfo 61 62 // Metadata pertaining to the operation's result. 63 ResultMetadata middleware.Metadata 64 65 noSmithyDocumentSerde 66 } 67 68 func (c *Client) addOperationGetChangeMiddlewares(stack *middleware.Stack, options Options) (err error) { 69 if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { 70 return err 71 } 72 err = stack.Serialize.Add(&awsRestxml_serializeOpGetChange{}, middleware.After) 73 if err != nil { 74 return err 75 } 76 err = stack.Deserialize.Add(&awsRestxml_deserializeOpGetChange{}, middleware.After) 77 if err != nil { 78 return err 79 } 80 if err := addProtocolFinalizerMiddlewares(stack, options, "GetChange"); err != nil { 81 return fmt.Errorf("add protocol finalizers: %v", err) 82 } 83 84 if err = addlegacyEndpointContextSetter(stack, options); err != nil { 85 return err 86 } 87 if err = addSetLoggerMiddleware(stack, options); err != nil { 88 return err 89 } 90 if err = addClientRequestID(stack); err != nil { 91 return err 92 } 93 if err = addComputeContentLength(stack); err != nil { 94 return err 95 } 96 if err = addResolveEndpointMiddleware(stack, options); err != nil { 97 return err 98 } 99 if err = addComputePayloadSHA256(stack); err != nil { 100 return err 101 } 102 if err = addRetry(stack, options); err != nil { 103 return err 104 } 105 if err = addRawResponseToMetadata(stack); err != nil { 106 return err 107 } 108 if err = addRecordResponseTiming(stack); err != nil { 109 return err 110 } 111 if err = addSpanRetryLoop(stack, options); err != nil { 112 return err 113 } 114 if err = addClientUserAgent(stack, options); err != nil { 115 return err 116 } 117 if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { 118 return err 119 } 120 if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { 121 return err 122 } 123 if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { 124 return err 125 } 126 if err = addTimeOffsetBuild(stack, c); err != nil { 127 return err 128 } 129 if err = addUserAgentRetryMode(stack, options); err != nil { 130 return err 131 } 132 if err = addCredentialSource(stack, options); err != nil { 133 return err 134 } 135 if err = addOpGetChangeValidationMiddleware(stack); err != nil { 136 return err 137 } 138 if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetChange(options.Region), middleware.Before); err != nil { 139 return err 140 } 141 if err = addRecursionDetection(stack); err != nil { 142 return err 143 } 144 if err = addRequestIDRetrieverMiddleware(stack); err != nil { 145 return err 146 } 147 if err = addResponseErrorMiddleware(stack); err != nil { 148 return err 149 } 150 if err = addSanitizeURLMiddleware(stack); err != nil { 151 return err 152 } 153 if err = addRequestResponseLogging(stack, options); err != nil { 154 return err 155 } 156 if err = addDisableHTTPSMiddleware(stack, options); err != nil { 157 return err 158 } 159 if err = addInterceptBeforeRetryLoop(stack, options); err != nil { 160 return err 161 } 162 if err = addInterceptAttempt(stack, options); err != nil { 163 return err 164 } 165 if err = addInterceptExecution(stack, options); err != nil { 166 return err 167 } 168 if err = addInterceptBeforeSerialization(stack, options); err != nil { 169 return err 170 } 171 if err = addInterceptAfterSerialization(stack, options); err != nil { 172 return err 173 } 174 if err = addInterceptBeforeSigning(stack, options); err != nil { 175 return err 176 } 177 if err = addInterceptAfterSigning(stack, options); err != nil { 178 return err 179 } 180 if err = addInterceptTransmit(stack, options); err != nil { 181 return err 182 } 183 if err = addInterceptBeforeDeserialization(stack, options); err != nil { 184 return err 185 } 186 if err = addInterceptAfterDeserialization(stack, options); err != nil { 187 return err 188 } 189 if err = addSpanInitializeStart(stack); err != nil { 190 return err 191 } 192 if err = addSpanInitializeEnd(stack); err != nil { 193 return err 194 } 195 if err = addSpanBuildRequestStart(stack); err != nil { 196 return err 197 } 198 if err = addSpanBuildRequestEnd(stack); err != nil { 199 return err 200 } 201 return nil 202 } 203 204 // ResourceRecordSetsChangedWaiterOptions are waiter options for 205 // ResourceRecordSetsChangedWaiter 206 type ResourceRecordSetsChangedWaiterOptions struct { 207 208 // Set of options to modify how an operation is invoked. These apply to all 209 // operations invoked for this client. Use functional options on operation call to 210 // modify this list for per operation behavior. 211 // 212 // Passing options here is functionally equivalent to passing values to this 213 // config's ClientOptions field that extend the inner client's APIOptions directly. 214 APIOptions []func(*middleware.Stack) error 215 216 // Functional options to be passed to all operations invoked by this client. 217 // 218 // Function values that modify the inner APIOptions are applied after the waiter 219 // config's own APIOptions modifiers. 220 ClientOptions []func(*Options) 221 222 // MinDelay is the minimum amount of time to delay between retries. If unset, 223 // ResourceRecordSetsChangedWaiter will use default minimum delay of 30 seconds. 224 // Note that MinDelay must resolve to a value lesser than or equal to the MaxDelay. 225 MinDelay time.Duration 226 227 // MaxDelay is the maximum amount of time to delay between retries. If unset or 228 // set to zero, ResourceRecordSetsChangedWaiter will use default max delay of 120 229 // seconds. Note that MaxDelay must resolve to value greater than or equal to the 230 // MinDelay. 231 MaxDelay time.Duration 232 233 // LogWaitAttempts is used to enable logging for waiter retry attempts 234 LogWaitAttempts bool 235 236 // Retryable is function that can be used to override the service defined 237 // waiter-behavior based on operation output, or returned error. This function is 238 // used by the waiter to decide if a state is retryable or a terminal state. 239 // 240 // By default service-modeled logic will populate this option. This option can 241 // thus be used to define a custom waiter state with fall-back to service-modeled 242 // waiter state mutators.The function returns an error in case of a failure state. 243 // In case of retry state, this function returns a bool value of true and nil 244 // error, while in case of success it returns a bool value of false and nil error. 245 Retryable func(context.Context, *GetChangeInput, *GetChangeOutput, error) (bool, error) 246 } 247 248 // ResourceRecordSetsChangedWaiter defines the waiters for 249 // ResourceRecordSetsChanged 250 type ResourceRecordSetsChangedWaiter struct { 251 client GetChangeAPIClient 252 253 options ResourceRecordSetsChangedWaiterOptions 254 } 255 256 // NewResourceRecordSetsChangedWaiter constructs a ResourceRecordSetsChangedWaiter. 257 func NewResourceRecordSetsChangedWaiter(client GetChangeAPIClient, optFns ...func(*ResourceRecordSetsChangedWaiterOptions)) *ResourceRecordSetsChangedWaiter { 258 options := ResourceRecordSetsChangedWaiterOptions{} 259 options.MinDelay = 30 * time.Second 260 options.MaxDelay = 120 * time.Second 261 options.Retryable = resourceRecordSetsChangedStateRetryable 262 263 for _, fn := range optFns { 264 fn(&options) 265 } 266 return &ResourceRecordSetsChangedWaiter{ 267 client: client, 268 options: options, 269 } 270 } 271 272 // Wait calls the waiter function for ResourceRecordSetsChanged waiter. The 273 // maxWaitDur is the maximum wait duration the waiter will wait. The maxWaitDur is 274 // required and must be greater than zero. 275 func (w *ResourceRecordSetsChangedWaiter) Wait(ctx context.Context, params *GetChangeInput, maxWaitDur time.Duration, optFns ...func(*ResourceRecordSetsChangedWaiterOptions)) error { 276 _, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...) 277 return err 278 } 279 280 // WaitForOutput calls the waiter function for ResourceRecordSetsChanged waiter 281 // and returns the output of the successful operation. The maxWaitDur is the 282 // maximum wait duration the waiter will wait. The maxWaitDur is required and must 283 // be greater than zero. 284 func (w *ResourceRecordSetsChangedWaiter) WaitForOutput(ctx context.Context, params *GetChangeInput, maxWaitDur time.Duration, optFns ...func(*ResourceRecordSetsChangedWaiterOptions)) (*GetChangeOutput, error) { 285 if maxWaitDur <= 0 { 286 return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero") 287 } 288 289 options := w.options 290 for _, fn := range optFns { 291 fn(&options) 292 } 293 294 if options.MaxDelay <= 0 { 295 options.MaxDelay = 120 * time.Second 296 } 297 298 if options.MinDelay > options.MaxDelay { 299 return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay) 300 } 301 302 ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur) 303 defer cancelFn() 304 305 logger := smithywaiter.Logger{} 306 remainingTime := maxWaitDur 307 308 var attempt int64 309 for { 310 311 attempt++ 312 apiOptions := options.APIOptions 313 start := time.Now() 314 315 if options.LogWaitAttempts { 316 logger.Attempt = attempt 317 apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...) 318 apiOptions = append(apiOptions, logger.AddLogger) 319 } 320 321 out, err := w.client.GetChange(ctx, params, func(o *Options) { 322 baseOpts := []func(*Options){ 323 addIsWaiterUserAgent, 324 } 325 o.APIOptions = append(o.APIOptions, apiOptions...) 326 for _, opt := range baseOpts { 327 opt(o) 328 } 329 for _, opt := range options.ClientOptions { 330 opt(o) 331 } 332 }) 333 334 retryable, err := options.Retryable(ctx, params, out, err) 335 if err != nil { 336 return nil, err 337 } 338 if !retryable { 339 return out, nil 340 } 341 342 remainingTime -= time.Since(start) 343 if remainingTime < options.MinDelay || remainingTime <= 0 { 344 break 345 } 346 347 // compute exponential backoff between waiter retries 348 delay, err := smithywaiter.ComputeDelay( 349 attempt, options.MinDelay, options.MaxDelay, remainingTime, 350 ) 351 if err != nil { 352 return nil, fmt.Errorf("error computing waiter delay, %w", err) 353 } 354 355 remainingTime -= delay 356 // sleep for the delay amount before invoking a request 357 if err := smithytime.SleepWithContext(ctx, delay); err != nil { 358 return nil, fmt.Errorf("request cancelled while waiting, %w", err) 359 } 360 } 361 return nil, fmt.Errorf("exceeded max wait time for ResourceRecordSetsChanged waiter") 362 } 363 364 func resourceRecordSetsChangedStateRetryable(ctx context.Context, input *GetChangeInput, output *GetChangeOutput, err error) (bool, error) { 365 366 if err == nil { 367 v1 := output.ChangeInfo 368 var v2 types.ChangeStatus 369 if v1 != nil { 370 v3 := v1.Status 371 v2 = v3 372 } 373 expectedValue := "INSYNC" 374 var pathValue string 375 pathValue = string(v2) 376 if pathValue == expectedValue { 377 return false, nil 378 } 379 } 380 381 if err != nil { 382 return false, err 383 } 384 return true, nil 385 } 386 387 // GetChangeAPIClient is a client that implements the GetChange operation. 388 type GetChangeAPIClient interface { 389 GetChange(context.Context, *GetChangeInput, ...func(*Options)) (*GetChangeOutput, error) 390 } 391 392 var _ GetChangeAPIClient = (*Client)(nil) 393 394 func newServiceMetadataMiddleware_opGetChange(region string) *awsmiddleware.RegisterServiceMetadata { 395 return &awsmiddleware.RegisterServiceMetadata{ 396 Region: region, 397 ServiceID: ServiceID, 398 OperationName: "GetChange", 399 } 400 }