1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package mediaconnect 4 5import ( 6 "context" 7 "errors" 8 "fmt" 9 awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" 10 "github.com/aws/aws-sdk-go-v2/aws/signer/v4" 11 "github.com/aws/aws-sdk-go-v2/service/mediaconnect/types" 12 "github.com/aws/smithy-go/middleware" 13 smithytime "github.com/aws/smithy-go/time" 14 smithyhttp "github.com/aws/smithy-go/transport/http" 15 smithywaiter "github.com/aws/smithy-go/waiter" 16 "github.com/jmespath/go-jmespath" 17 "time" 18) 19 20// Displays the details of a flow. The response includes the flow ARN, name, and 21// Availability Zone, as well as details about the source, outputs, and 22// entitlements. 23func (c *Client) DescribeFlow(ctx context.Context, params *DescribeFlowInput, optFns ...func(*Options)) (*DescribeFlowOutput, error) { 24 if params == nil { 25 params = &DescribeFlowInput{} 26 } 27 28 result, metadata, err := c.invokeOperation(ctx, "DescribeFlow", params, optFns, addOperationDescribeFlowMiddlewares) 29 if err != nil { 30 return nil, err 31 } 32 33 out := result.(*DescribeFlowOutput) 34 out.ResultMetadata = metadata 35 return out, nil 36} 37 38type DescribeFlowInput struct { 39 40 // The ARN of the flow that you want to describe. 41 // 42 // This member is required. 43 FlowArn *string 44} 45 46type DescribeFlowOutput struct { 47 48 // The settings for a flow, including its source, outputs, and entitlements. 49 Flow *types.Flow 50 51 // Messages that provide the state of the flow. 52 Messages *types.Messages 53 54 // Metadata pertaining to the operation's result. 55 ResultMetadata middleware.Metadata 56} 57 58func addOperationDescribeFlowMiddlewares(stack *middleware.Stack, options Options) (err error) { 59 err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeFlow{}, middleware.After) 60 if err != nil { 61 return err 62 } 63 err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeFlow{}, middleware.After) 64 if err != nil { 65 return err 66 } 67 if err = addSetLoggerMiddleware(stack, options); err != nil { 68 return err 69 } 70 if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { 71 return err 72 } 73 if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { 74 return err 75 } 76 if err = addResolveEndpointMiddleware(stack, options); err != nil { 77 return err 78 } 79 if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { 80 return err 81 } 82 if err = addRetryMiddlewares(stack, options); err != nil { 83 return err 84 } 85 if err = addHTTPSignerV4Middleware(stack, options); err != nil { 86 return err 87 } 88 if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { 89 return err 90 } 91 if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { 92 return err 93 } 94 if err = addClientUserAgent(stack); err != nil { 95 return err 96 } 97 if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { 98 return err 99 } 100 if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { 101 return err 102 } 103 if err = addOpDescribeFlowValidationMiddleware(stack); err != nil { 104 return err 105 } 106 if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeFlow(options.Region), middleware.Before); err != nil { 107 return err 108 } 109 if err = addRequestIDRetrieverMiddleware(stack); err != nil { 110 return err 111 } 112 if err = addResponseErrorMiddleware(stack); err != nil { 113 return err 114 } 115 if err = addRequestResponseLogging(stack, options); err != nil { 116 return err 117 } 118 return nil 119} 120 121// DescribeFlowAPIClient is a client that implements the DescribeFlow operation. 122type DescribeFlowAPIClient interface { 123 DescribeFlow(context.Context, *DescribeFlowInput, ...func(*Options)) (*DescribeFlowOutput, error) 124} 125 126var _ DescribeFlowAPIClient = (*Client)(nil) 127 128// FlowActiveWaiterOptions are waiter options for FlowActiveWaiter 129type FlowActiveWaiterOptions struct { 130 131 // Set of options to modify how an operation is invoked. These apply to all 132 // operations invoked for this client. Use functional options on operation call to 133 // modify this list for per operation behavior. 134 APIOptions []func(*middleware.Stack) error 135 136 // MinDelay is the minimum amount of time to delay between retries. If unset, 137 // FlowActiveWaiter will use default minimum delay of 3 seconds. Note that MinDelay 138 // must resolve to a value lesser than or equal to the MaxDelay. 139 MinDelay time.Duration 140 141 // MaxDelay is the maximum amount of time to delay between retries. If unset or set 142 // to zero, FlowActiveWaiter will use default max delay of 120 seconds. Note that 143 // MaxDelay must resolve to value greater than or equal to the MinDelay. 144 MaxDelay time.Duration 145 146 // LogWaitAttempts is used to enable logging for waiter retry attempts 147 LogWaitAttempts bool 148 149 // Retryable is function that can be used to override the service defined 150 // waiter-behavior based on operation output, or returned error. This function is 151 // used by the waiter to decide if a state is retryable or a terminal state. By 152 // default service-modeled logic will populate this option. This option can thus be 153 // used to define a custom waiter state with fall-back to service-modeled waiter 154 // state mutators.The function returns an error in case of a failure state. In case 155 // of retry state, this function returns a bool value of true and nil error, while 156 // in case of success it returns a bool value of false and nil error. 157 Retryable func(context.Context, *DescribeFlowInput, *DescribeFlowOutput, error) (bool, error) 158} 159 160// FlowActiveWaiter defines the waiters for FlowActive 161type FlowActiveWaiter struct { 162 client DescribeFlowAPIClient 163 164 options FlowActiveWaiterOptions 165} 166 167// NewFlowActiveWaiter constructs a FlowActiveWaiter. 168func NewFlowActiveWaiter(client DescribeFlowAPIClient, optFns ...func(*FlowActiveWaiterOptions)) *FlowActiveWaiter { 169 options := FlowActiveWaiterOptions{} 170 options.MinDelay = 3 * time.Second 171 options.MaxDelay = 120 * time.Second 172 options.Retryable = flowActiveStateRetryable 173 174 for _, fn := range optFns { 175 fn(&options) 176 } 177 return &FlowActiveWaiter{ 178 client: client, 179 options: options, 180 } 181} 182 183// Wait calls the waiter function for FlowActive waiter. The maxWaitDur is the 184// maximum wait duration the waiter will wait. The maxWaitDur is required and must 185// be greater than zero. 186func (w *FlowActiveWaiter) Wait(ctx context.Context, params *DescribeFlowInput, maxWaitDur time.Duration, optFns ...func(*FlowActiveWaiterOptions)) error { 187 if maxWaitDur <= 0 { 188 return fmt.Errorf("maximum wait time for waiter must be greater than zero") 189 } 190 191 options := w.options 192 for _, fn := range optFns { 193 fn(&options) 194 } 195 196 if options.MaxDelay <= 0 { 197 options.MaxDelay = 120 * time.Second 198 } 199 200 if options.MinDelay > options.MaxDelay { 201 return fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay) 202 } 203 204 ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur) 205 defer cancelFn() 206 207 logger := smithywaiter.Logger{} 208 remainingTime := maxWaitDur 209 210 var attempt int64 211 for { 212 213 attempt++ 214 apiOptions := options.APIOptions 215 start := time.Now() 216 217 if options.LogWaitAttempts { 218 logger.Attempt = attempt 219 apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...) 220 apiOptions = append(apiOptions, logger.AddLogger) 221 } 222 223 out, err := w.client.DescribeFlow(ctx, params, func(o *Options) { 224 o.APIOptions = append(o.APIOptions, apiOptions...) 225 }) 226 227 retryable, err := options.Retryable(ctx, params, out, err) 228 if err != nil { 229 return err 230 } 231 if !retryable { 232 return nil 233 } 234 235 remainingTime -= time.Since(start) 236 if remainingTime < options.MinDelay || remainingTime <= 0 { 237 break 238 } 239 240 // compute exponential backoff between waiter retries 241 delay, err := smithywaiter.ComputeDelay( 242 attempt, options.MinDelay, options.MaxDelay, remainingTime, 243 ) 244 if err != nil { 245 return fmt.Errorf("error computing waiter delay, %w", err) 246 } 247 248 remainingTime -= delay 249 // sleep for the delay amount before invoking a request 250 if err := smithytime.SleepWithContext(ctx, delay); err != nil { 251 return fmt.Errorf("request cancelled while waiting, %w", err) 252 } 253 } 254 return fmt.Errorf("exceeded max wait time for FlowActive waiter") 255} 256 257func flowActiveStateRetryable(ctx context.Context, input *DescribeFlowInput, output *DescribeFlowOutput, err error) (bool, error) { 258 259 if err == nil { 260 pathValue, err := jmespath.Search("Flow.Status", output) 261 if err != nil { 262 return false, fmt.Errorf("error evaluating waiter state: %w", err) 263 } 264 265 expectedValue := "ACTIVE" 266 value, ok := pathValue.(types.Status) 267 if !ok { 268 return false, fmt.Errorf("waiter comparator expected types.Status value, got %T", pathValue) 269 } 270 271 if string(value) == expectedValue { 272 return false, nil 273 } 274 } 275 276 if err == nil { 277 pathValue, err := jmespath.Search("Flow.Status", output) 278 if err != nil { 279 return false, fmt.Errorf("error evaluating waiter state: %w", err) 280 } 281 282 expectedValue := "STARTING" 283 value, ok := pathValue.(types.Status) 284 if !ok { 285 return false, fmt.Errorf("waiter comparator expected types.Status value, got %T", pathValue) 286 } 287 288 if string(value) == expectedValue { 289 return true, nil 290 } 291 } 292 293 if err == nil { 294 pathValue, err := jmespath.Search("Flow.Status", output) 295 if err != nil { 296 return false, fmt.Errorf("error evaluating waiter state: %w", err) 297 } 298 299 expectedValue := "UPDATING" 300 value, ok := pathValue.(types.Status) 301 if !ok { 302 return false, fmt.Errorf("waiter comparator expected types.Status value, got %T", pathValue) 303 } 304 305 if string(value) == expectedValue { 306 return true, nil 307 } 308 } 309 310 if err != nil { 311 var errorType *types.InternalServerErrorException 312 if errors.As(err, &errorType) { 313 return true, nil 314 } 315 } 316 317 if err != nil { 318 var errorType *types.ServiceUnavailableException 319 if errors.As(err, &errorType) { 320 return true, nil 321 } 322 } 323 324 if err == nil { 325 pathValue, err := jmespath.Search("Flow.Status", output) 326 if err != nil { 327 return false, fmt.Errorf("error evaluating waiter state: %w", err) 328 } 329 330 expectedValue := "ERROR" 331 value, ok := pathValue.(types.Status) 332 if !ok { 333 return false, fmt.Errorf("waiter comparator expected types.Status value, got %T", pathValue) 334 } 335 336 if string(value) == expectedValue { 337 return false, fmt.Errorf("waiter state transitioned to Failure") 338 } 339 } 340 341 return true, nil 342} 343 344// FlowDeletedWaiterOptions are waiter options for FlowDeletedWaiter 345type FlowDeletedWaiterOptions struct { 346 347 // Set of options to modify how an operation is invoked. These apply to all 348 // operations invoked for this client. Use functional options on operation call to 349 // modify this list for per operation behavior. 350 APIOptions []func(*middleware.Stack) error 351 352 // MinDelay is the minimum amount of time to delay between retries. If unset, 353 // FlowDeletedWaiter will use default minimum delay of 3 seconds. Note that 354 // MinDelay must resolve to a value lesser than or equal to the MaxDelay. 355 MinDelay time.Duration 356 357 // MaxDelay is the maximum amount of time to delay between retries. If unset or set 358 // to zero, FlowDeletedWaiter will use default max delay of 120 seconds. Note that 359 // MaxDelay must resolve to value greater than or equal to the MinDelay. 360 MaxDelay time.Duration 361 362 // LogWaitAttempts is used to enable logging for waiter retry attempts 363 LogWaitAttempts bool 364 365 // Retryable is function that can be used to override the service defined 366 // waiter-behavior based on operation output, or returned error. This function is 367 // used by the waiter to decide if a state is retryable or a terminal state. By 368 // default service-modeled logic will populate this option. This option can thus be 369 // used to define a custom waiter state with fall-back to service-modeled waiter 370 // state mutators.The function returns an error in case of a failure state. In case 371 // of retry state, this function returns a bool value of true and nil error, while 372 // in case of success it returns a bool value of false and nil error. 373 Retryable func(context.Context, *DescribeFlowInput, *DescribeFlowOutput, error) (bool, error) 374} 375 376// FlowDeletedWaiter defines the waiters for FlowDeleted 377type FlowDeletedWaiter struct { 378 client DescribeFlowAPIClient 379 380 options FlowDeletedWaiterOptions 381} 382 383// NewFlowDeletedWaiter constructs a FlowDeletedWaiter. 384func NewFlowDeletedWaiter(client DescribeFlowAPIClient, optFns ...func(*FlowDeletedWaiterOptions)) *FlowDeletedWaiter { 385 options := FlowDeletedWaiterOptions{} 386 options.MinDelay = 3 * time.Second 387 options.MaxDelay = 120 * time.Second 388 options.Retryable = flowDeletedStateRetryable 389 390 for _, fn := range optFns { 391 fn(&options) 392 } 393 return &FlowDeletedWaiter{ 394 client: client, 395 options: options, 396 } 397} 398 399// Wait calls the waiter function for FlowDeleted waiter. The maxWaitDur is the 400// maximum wait duration the waiter will wait. The maxWaitDur is required and must 401// be greater than zero. 402func (w *FlowDeletedWaiter) Wait(ctx context.Context, params *DescribeFlowInput, maxWaitDur time.Duration, optFns ...func(*FlowDeletedWaiterOptions)) error { 403 if maxWaitDur <= 0 { 404 return fmt.Errorf("maximum wait time for waiter must be greater than zero") 405 } 406 407 options := w.options 408 for _, fn := range optFns { 409 fn(&options) 410 } 411 412 if options.MaxDelay <= 0 { 413 options.MaxDelay = 120 * time.Second 414 } 415 416 if options.MinDelay > options.MaxDelay { 417 return fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay) 418 } 419 420 ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur) 421 defer cancelFn() 422 423 logger := smithywaiter.Logger{} 424 remainingTime := maxWaitDur 425 426 var attempt int64 427 for { 428 429 attempt++ 430 apiOptions := options.APIOptions 431 start := time.Now() 432 433 if options.LogWaitAttempts { 434 logger.Attempt = attempt 435 apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...) 436 apiOptions = append(apiOptions, logger.AddLogger) 437 } 438 439 out, err := w.client.DescribeFlow(ctx, params, func(o *Options) { 440 o.APIOptions = append(o.APIOptions, apiOptions...) 441 }) 442 443 retryable, err := options.Retryable(ctx, params, out, err) 444 if err != nil { 445 return err 446 } 447 if !retryable { 448 return nil 449 } 450 451 remainingTime -= time.Since(start) 452 if remainingTime < options.MinDelay || remainingTime <= 0 { 453 break 454 } 455 456 // compute exponential backoff between waiter retries 457 delay, err := smithywaiter.ComputeDelay( 458 attempt, options.MinDelay, options.MaxDelay, remainingTime, 459 ) 460 if err != nil { 461 return fmt.Errorf("error computing waiter delay, %w", err) 462 } 463 464 remainingTime -= delay 465 // sleep for the delay amount before invoking a request 466 if err := smithytime.SleepWithContext(ctx, delay); err != nil { 467 return fmt.Errorf("request cancelled while waiting, %w", err) 468 } 469 } 470 return fmt.Errorf("exceeded max wait time for FlowDeleted waiter") 471} 472 473func flowDeletedStateRetryable(ctx context.Context, input *DescribeFlowInput, output *DescribeFlowOutput, err error) (bool, error) { 474 475 if err != nil { 476 var errorType *types.NotFoundException 477 if errors.As(err, &errorType) { 478 return false, nil 479 } 480 } 481 482 if err == nil { 483 pathValue, err := jmespath.Search("Flow.Status", output) 484 if err != nil { 485 return false, fmt.Errorf("error evaluating waiter state: %w", err) 486 } 487 488 expectedValue := "DELETING" 489 value, ok := pathValue.(types.Status) 490 if !ok { 491 return false, fmt.Errorf("waiter comparator expected types.Status value, got %T", pathValue) 492 } 493 494 if string(value) == expectedValue { 495 return true, nil 496 } 497 } 498 499 if err != nil { 500 var errorType *types.InternalServerErrorException 501 if errors.As(err, &errorType) { 502 return true, nil 503 } 504 } 505 506 if err != nil { 507 var errorType *types.ServiceUnavailableException 508 if errors.As(err, &errorType) { 509 return true, nil 510 } 511 } 512 513 if err == nil { 514 pathValue, err := jmespath.Search("Flow.Status", output) 515 if err != nil { 516 return false, fmt.Errorf("error evaluating waiter state: %w", err) 517 } 518 519 expectedValue := "ERROR" 520 value, ok := pathValue.(types.Status) 521 if !ok { 522 return false, fmt.Errorf("waiter comparator expected types.Status value, got %T", pathValue) 523 } 524 525 if string(value) == expectedValue { 526 return false, fmt.Errorf("waiter state transitioned to Failure") 527 } 528 } 529 530 return true, nil 531} 532 533// FlowStandbyWaiterOptions are waiter options for FlowStandbyWaiter 534type FlowStandbyWaiterOptions struct { 535 536 // Set of options to modify how an operation is invoked. These apply to all 537 // operations invoked for this client. Use functional options on operation call to 538 // modify this list for per operation behavior. 539 APIOptions []func(*middleware.Stack) error 540 541 // MinDelay is the minimum amount of time to delay between retries. If unset, 542 // FlowStandbyWaiter will use default minimum delay of 3 seconds. Note that 543 // MinDelay must resolve to a value lesser than or equal to the MaxDelay. 544 MinDelay time.Duration 545 546 // MaxDelay is the maximum amount of time to delay between retries. If unset or set 547 // to zero, FlowStandbyWaiter will use default max delay of 120 seconds. Note that 548 // MaxDelay must resolve to value greater than or equal to the MinDelay. 549 MaxDelay time.Duration 550 551 // LogWaitAttempts is used to enable logging for waiter retry attempts 552 LogWaitAttempts bool 553 554 // Retryable is function that can be used to override the service defined 555 // waiter-behavior based on operation output, or returned error. This function is 556 // used by the waiter to decide if a state is retryable or a terminal state. By 557 // default service-modeled logic will populate this option. This option can thus be 558 // used to define a custom waiter state with fall-back to service-modeled waiter 559 // state mutators.The function returns an error in case of a failure state. In case 560 // of retry state, this function returns a bool value of true and nil error, while 561 // in case of success it returns a bool value of false and nil error. 562 Retryable func(context.Context, *DescribeFlowInput, *DescribeFlowOutput, error) (bool, error) 563} 564 565// FlowStandbyWaiter defines the waiters for FlowStandby 566type FlowStandbyWaiter struct { 567 client DescribeFlowAPIClient 568 569 options FlowStandbyWaiterOptions 570} 571 572// NewFlowStandbyWaiter constructs a FlowStandbyWaiter. 573func NewFlowStandbyWaiter(client DescribeFlowAPIClient, optFns ...func(*FlowStandbyWaiterOptions)) *FlowStandbyWaiter { 574 options := FlowStandbyWaiterOptions{} 575 options.MinDelay = 3 * time.Second 576 options.MaxDelay = 120 * time.Second 577 options.Retryable = flowStandbyStateRetryable 578 579 for _, fn := range optFns { 580 fn(&options) 581 } 582 return &FlowStandbyWaiter{ 583 client: client, 584 options: options, 585 } 586} 587 588// Wait calls the waiter function for FlowStandby waiter. The maxWaitDur is the 589// maximum wait duration the waiter will wait. The maxWaitDur is required and must 590// be greater than zero. 591func (w *FlowStandbyWaiter) Wait(ctx context.Context, params *DescribeFlowInput, maxWaitDur time.Duration, optFns ...func(*FlowStandbyWaiterOptions)) error { 592 if maxWaitDur <= 0 { 593 return fmt.Errorf("maximum wait time for waiter must be greater than zero") 594 } 595 596 options := w.options 597 for _, fn := range optFns { 598 fn(&options) 599 } 600 601 if options.MaxDelay <= 0 { 602 options.MaxDelay = 120 * time.Second 603 } 604 605 if options.MinDelay > options.MaxDelay { 606 return fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay) 607 } 608 609 ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur) 610 defer cancelFn() 611 612 logger := smithywaiter.Logger{} 613 remainingTime := maxWaitDur 614 615 var attempt int64 616 for { 617 618 attempt++ 619 apiOptions := options.APIOptions 620 start := time.Now() 621 622 if options.LogWaitAttempts { 623 logger.Attempt = attempt 624 apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...) 625 apiOptions = append(apiOptions, logger.AddLogger) 626 } 627 628 out, err := w.client.DescribeFlow(ctx, params, func(o *Options) { 629 o.APIOptions = append(o.APIOptions, apiOptions...) 630 }) 631 632 retryable, err := options.Retryable(ctx, params, out, err) 633 if err != nil { 634 return err 635 } 636 if !retryable { 637 return nil 638 } 639 640 remainingTime -= time.Since(start) 641 if remainingTime < options.MinDelay || remainingTime <= 0 { 642 break 643 } 644 645 // compute exponential backoff between waiter retries 646 delay, err := smithywaiter.ComputeDelay( 647 attempt, options.MinDelay, options.MaxDelay, remainingTime, 648 ) 649 if err != nil { 650 return fmt.Errorf("error computing waiter delay, %w", err) 651 } 652 653 remainingTime -= delay 654 // sleep for the delay amount before invoking a request 655 if err := smithytime.SleepWithContext(ctx, delay); err != nil { 656 return fmt.Errorf("request cancelled while waiting, %w", err) 657 } 658 } 659 return fmt.Errorf("exceeded max wait time for FlowStandby waiter") 660} 661 662func flowStandbyStateRetryable(ctx context.Context, input *DescribeFlowInput, output *DescribeFlowOutput, err error) (bool, error) { 663 664 if err == nil { 665 pathValue, err := jmespath.Search("Flow.Status", output) 666 if err != nil { 667 return false, fmt.Errorf("error evaluating waiter state: %w", err) 668 } 669 670 expectedValue := "STANDBY" 671 value, ok := pathValue.(types.Status) 672 if !ok { 673 return false, fmt.Errorf("waiter comparator expected types.Status value, got %T", pathValue) 674 } 675 676 if string(value) == expectedValue { 677 return false, nil 678 } 679 } 680 681 if err == nil { 682 pathValue, err := jmespath.Search("Flow.Status", output) 683 if err != nil { 684 return false, fmt.Errorf("error evaluating waiter state: %w", err) 685 } 686 687 expectedValue := "STOPPING" 688 value, ok := pathValue.(types.Status) 689 if !ok { 690 return false, fmt.Errorf("waiter comparator expected types.Status value, got %T", pathValue) 691 } 692 693 if string(value) == expectedValue { 694 return true, nil 695 } 696 } 697 698 if err != nil { 699 var errorType *types.InternalServerErrorException 700 if errors.As(err, &errorType) { 701 return true, nil 702 } 703 } 704 705 if err != nil { 706 var errorType *types.ServiceUnavailableException 707 if errors.As(err, &errorType) { 708 return true, nil 709 } 710 } 711 712 if err == nil { 713 pathValue, err := jmespath.Search("Flow.Status", output) 714 if err != nil { 715 return false, fmt.Errorf("error evaluating waiter state: %w", err) 716 } 717 718 expectedValue := "ERROR" 719 value, ok := pathValue.(types.Status) 720 if !ok { 721 return false, fmt.Errorf("waiter comparator expected types.Status value, got %T", pathValue) 722 } 723 724 if string(value) == expectedValue { 725 return false, fmt.Errorf("waiter state transitioned to Failure") 726 } 727 } 728 729 return true, nil 730} 731 732func newServiceMetadataMiddleware_opDescribeFlow(region string) *awsmiddleware.RegisterServiceMetadata { 733 return &awsmiddleware.RegisterServiceMetadata{ 734 Region: region, 735 ServiceID: ServiceID, 736 SigningName: "mediaconnect", 737 OperationName: "DescribeFlow", 738 } 739} 740