// Code generated by smithy-go-codegen DO NOT EDIT. package nimble 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/nimble/types" "github.com/aws/smithy-go/middleware" smithytime "github.com/aws/smithy-go/time" smithyhttp "github.com/aws/smithy-go/transport/http" smithywaiter "github.com/aws/smithy-go/waiter" "github.com/jmespath/go-jmespath" "time" ) // Get a launch profile. func (c *Client) GetLaunchProfile(ctx context.Context, params *GetLaunchProfileInput, optFns ...func(*Options)) (*GetLaunchProfileOutput, error) { if params == nil { params = &GetLaunchProfileInput{} } result, metadata, err := c.invokeOperation(ctx, "GetLaunchProfile", params, optFns, c.addOperationGetLaunchProfileMiddlewares) if err != nil { return nil, err } out := result.(*GetLaunchProfileOutput) out.ResultMetadata = metadata return out, nil } type GetLaunchProfileInput struct { // The ID of the launch profile used to control access from the streaming session. // // This member is required. LaunchProfileId *string // The studio ID. // // This member is required. StudioId *string noSmithyDocumentSerde } type GetLaunchProfileOutput struct { // The launch profile. LaunchProfile *types.LaunchProfile // Metadata pertaining to the operation's result. ResultMetadata middleware.Metadata noSmithyDocumentSerde } func (c *Client) addOperationGetLaunchProfileMiddlewares(stack *middleware.Stack, options Options) (err error) { err = stack.Serialize.Add(&awsRestjson1_serializeOpGetLaunchProfile{}, middleware.After) if err != nil { return err } err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetLaunchProfile{}, 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, options); err != nil { return err } if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { return err } if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } if err = addOpGetLaunchProfileValidationMiddleware(stack); err != nil { return err } if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetLaunchProfile(options.Region), middleware.Before); err != nil { return err } if err = awsmiddleware.AddRecursionDetection(stack); 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 } // GetLaunchProfileAPIClient is a client that implements the GetLaunchProfile // operation. type GetLaunchProfileAPIClient interface { GetLaunchProfile(context.Context, *GetLaunchProfileInput, ...func(*Options)) (*GetLaunchProfileOutput, error) } var _ GetLaunchProfileAPIClient = (*Client)(nil) // LaunchProfileReadyWaiterOptions are waiter options for LaunchProfileReadyWaiter type LaunchProfileReadyWaiterOptions struct { // Set of options to modify how an operation is invoked. These apply to all // operations invoked for this client. Use functional options on operation call to // modify this list for per operation behavior. APIOptions []func(*middleware.Stack) error // MinDelay is the minimum amount of time to delay between retries. If unset, // LaunchProfileReadyWaiter will use default minimum delay of 5 seconds. Note that // MinDelay must resolve to a value lesser than or equal to the MaxDelay. MinDelay time.Duration // MaxDelay is the maximum amount of time to delay between retries. If unset or // set to zero, LaunchProfileReadyWaiter will use default max delay of 750 seconds. // Note that MaxDelay must resolve to value greater than or equal to the MinDelay. MaxDelay time.Duration // LogWaitAttempts is used to enable logging for waiter retry attempts LogWaitAttempts bool // Retryable is function that can be used to override the service defined // waiter-behavior based on operation output, or returned error. This function is // used by the waiter to decide if a state is retryable or a terminal state. By // default service-modeled logic will populate this option. This option can thus be // used to define a custom waiter state with fall-back to service-modeled waiter // state mutators.The function returns an error in case of a failure state. In case // of retry state, this function returns a bool value of true and nil error, while // in case of success it returns a bool value of false and nil error. Retryable func(context.Context, *GetLaunchProfileInput, *GetLaunchProfileOutput, error) (bool, error) } // LaunchProfileReadyWaiter defines the waiters for LaunchProfileReady type LaunchProfileReadyWaiter struct { client GetLaunchProfileAPIClient options LaunchProfileReadyWaiterOptions } // NewLaunchProfileReadyWaiter constructs a LaunchProfileReadyWaiter. func NewLaunchProfileReadyWaiter(client GetLaunchProfileAPIClient, optFns ...func(*LaunchProfileReadyWaiterOptions)) *LaunchProfileReadyWaiter { options := LaunchProfileReadyWaiterOptions{} options.MinDelay = 5 * time.Second options.MaxDelay = 750 * time.Second options.Retryable = launchProfileReadyStateRetryable for _, fn := range optFns { fn(&options) } return &LaunchProfileReadyWaiter{ client: client, options: options, } } // Wait calls the waiter function for LaunchProfileReady waiter. The maxWaitDur is // the maximum wait duration the waiter will wait. The maxWaitDur is required and // must be greater than zero. func (w *LaunchProfileReadyWaiter) Wait(ctx context.Context, params *GetLaunchProfileInput, maxWaitDur time.Duration, optFns ...func(*LaunchProfileReadyWaiterOptions)) error { _, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...) return err } // WaitForOutput calls the waiter function for LaunchProfileReady waiter and // returns the output of the successful operation. The maxWaitDur is the maximum // wait duration the waiter will wait. The maxWaitDur is required and must be // greater than zero. func (w *LaunchProfileReadyWaiter) WaitForOutput(ctx context.Context, params *GetLaunchProfileInput, maxWaitDur time.Duration, optFns ...func(*LaunchProfileReadyWaiterOptions)) (*GetLaunchProfileOutput, error) { if maxWaitDur <= 0 { return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero") } options := w.options for _, fn := range optFns { fn(&options) } if options.MaxDelay <= 0 { options.MaxDelay = 750 * time.Second } if options.MinDelay > options.MaxDelay { return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay) } ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur) defer cancelFn() logger := smithywaiter.Logger{} remainingTime := maxWaitDur var attempt int64 for { attempt++ apiOptions := options.APIOptions start := time.Now() if options.LogWaitAttempts { logger.Attempt = attempt apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...) apiOptions = append(apiOptions, logger.AddLogger) } out, err := w.client.GetLaunchProfile(ctx, params, func(o *Options) { o.APIOptions = append(o.APIOptions, apiOptions...) }) retryable, err := options.Retryable(ctx, params, out, err) if err != nil { return nil, err } if !retryable { return out, nil } remainingTime -= time.Since(start) if remainingTime < options.MinDelay || remainingTime <= 0 { break } // compute exponential backoff between waiter retries delay, err := smithywaiter.ComputeDelay( attempt, options.MinDelay, options.MaxDelay, remainingTime, ) if err != nil { return nil, fmt.Errorf("error computing waiter delay, %w", err) } remainingTime -= delay // sleep for the delay amount before invoking a request if err := smithytime.SleepWithContext(ctx, delay); err != nil { return nil, fmt.Errorf("request cancelled while waiting, %w", err) } } return nil, fmt.Errorf("exceeded max wait time for LaunchProfileReady waiter") } func launchProfileReadyStateRetryable(ctx context.Context, input *GetLaunchProfileInput, output *GetLaunchProfileOutput, err error) (bool, error) { if err == nil { pathValue, err := jmespath.Search("launchProfile.state", output) if err != nil { return false, fmt.Errorf("error evaluating waiter state: %w", err) } expectedValue := "READY" value, ok := pathValue.(types.LaunchProfileState) if !ok { return false, fmt.Errorf("waiter comparator expected types.LaunchProfileState value, got %T", pathValue) } if string(value) == expectedValue { return false, nil } } if err == nil { pathValue, err := jmespath.Search("launchProfile.state", output) if err != nil { return false, fmt.Errorf("error evaluating waiter state: %w", err) } expectedValue := "CREATE_FAILED" value, ok := pathValue.(types.LaunchProfileState) if !ok { return false, fmt.Errorf("waiter comparator expected types.LaunchProfileState value, got %T", pathValue) } if string(value) == expectedValue { return false, fmt.Errorf("waiter state transitioned to Failure") } } if err == nil { pathValue, err := jmespath.Search("launchProfile.state", output) if err != nil { return false, fmt.Errorf("error evaluating waiter state: %w", err) } expectedValue := "UPDATE_FAILED" value, ok := pathValue.(types.LaunchProfileState) if !ok { return false, fmt.Errorf("waiter comparator expected types.LaunchProfileState value, got %T", pathValue) } if string(value) == expectedValue { return false, fmt.Errorf("waiter state transitioned to Failure") } } return true, nil } // LaunchProfileDeletedWaiterOptions are waiter options for // LaunchProfileDeletedWaiter type LaunchProfileDeletedWaiterOptions struct { // Set of options to modify how an operation is invoked. These apply to all // operations invoked for this client. Use functional options on operation call to // modify this list for per operation behavior. APIOptions []func(*middleware.Stack) error // MinDelay is the minimum amount of time to delay between retries. If unset, // LaunchProfileDeletedWaiter will use default minimum delay of 5 seconds. Note // that MinDelay must resolve to a value lesser than or equal to the MaxDelay. MinDelay time.Duration // MaxDelay is the maximum amount of time to delay between retries. If unset or // set to zero, LaunchProfileDeletedWaiter will use default max delay of 750 // seconds. Note that MaxDelay must resolve to value greater than or equal to the // MinDelay. MaxDelay time.Duration // LogWaitAttempts is used to enable logging for waiter retry attempts LogWaitAttempts bool // Retryable is function that can be used to override the service defined // waiter-behavior based on operation output, or returned error. This function is // used by the waiter to decide if a state is retryable or a terminal state. By // default service-modeled logic will populate this option. This option can thus be // used to define a custom waiter state with fall-back to service-modeled waiter // state mutators.The function returns an error in case of a failure state. In case // of retry state, this function returns a bool value of true and nil error, while // in case of success it returns a bool value of false and nil error. Retryable func(context.Context, *GetLaunchProfileInput, *GetLaunchProfileOutput, error) (bool, error) } // LaunchProfileDeletedWaiter defines the waiters for LaunchProfileDeleted type LaunchProfileDeletedWaiter struct { client GetLaunchProfileAPIClient options LaunchProfileDeletedWaiterOptions } // NewLaunchProfileDeletedWaiter constructs a LaunchProfileDeletedWaiter. func NewLaunchProfileDeletedWaiter(client GetLaunchProfileAPIClient, optFns ...func(*LaunchProfileDeletedWaiterOptions)) *LaunchProfileDeletedWaiter { options := LaunchProfileDeletedWaiterOptions{} options.MinDelay = 5 * time.Second options.MaxDelay = 750 * time.Second options.Retryable = launchProfileDeletedStateRetryable for _, fn := range optFns { fn(&options) } return &LaunchProfileDeletedWaiter{ client: client, options: options, } } // Wait calls the waiter function for LaunchProfileDeleted waiter. The maxWaitDur // is the maximum wait duration the waiter will wait. The maxWaitDur is required // and must be greater than zero. func (w *LaunchProfileDeletedWaiter) Wait(ctx context.Context, params *GetLaunchProfileInput, maxWaitDur time.Duration, optFns ...func(*LaunchProfileDeletedWaiterOptions)) error { _, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...) return err } // WaitForOutput calls the waiter function for LaunchProfileDeleted waiter and // returns the output of the successful operation. The maxWaitDur is the maximum // wait duration the waiter will wait. The maxWaitDur is required and must be // greater than zero. func (w *LaunchProfileDeletedWaiter) WaitForOutput(ctx context.Context, params *GetLaunchProfileInput, maxWaitDur time.Duration, optFns ...func(*LaunchProfileDeletedWaiterOptions)) (*GetLaunchProfileOutput, error) { if maxWaitDur <= 0 { return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero") } options := w.options for _, fn := range optFns { fn(&options) } if options.MaxDelay <= 0 { options.MaxDelay = 750 * time.Second } if options.MinDelay > options.MaxDelay { return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay) } ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur) defer cancelFn() logger := smithywaiter.Logger{} remainingTime := maxWaitDur var attempt int64 for { attempt++ apiOptions := options.APIOptions start := time.Now() if options.LogWaitAttempts { logger.Attempt = attempt apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...) apiOptions = append(apiOptions, logger.AddLogger) } out, err := w.client.GetLaunchProfile(ctx, params, func(o *Options) { o.APIOptions = append(o.APIOptions, apiOptions...) }) retryable, err := options.Retryable(ctx, params, out, err) if err != nil { return nil, err } if !retryable { return out, nil } remainingTime -= time.Since(start) if remainingTime < options.MinDelay || remainingTime <= 0 { break } // compute exponential backoff between waiter retries delay, err := smithywaiter.ComputeDelay( attempt, options.MinDelay, options.MaxDelay, remainingTime, ) if err != nil { return nil, fmt.Errorf("error computing waiter delay, %w", err) } remainingTime -= delay // sleep for the delay amount before invoking a request if err := smithytime.SleepWithContext(ctx, delay); err != nil { return nil, fmt.Errorf("request cancelled while waiting, %w", err) } } return nil, fmt.Errorf("exceeded max wait time for LaunchProfileDeleted waiter") } func launchProfileDeletedStateRetryable(ctx context.Context, input *GetLaunchProfileInput, output *GetLaunchProfileOutput, err error) (bool, error) { if err == nil { pathValue, err := jmespath.Search("launchProfile.state", output) if err != nil { return false, fmt.Errorf("error evaluating waiter state: %w", err) } expectedValue := "DELETED" value, ok := pathValue.(types.LaunchProfileState) if !ok { return false, fmt.Errorf("waiter comparator expected types.LaunchProfileState value, got %T", pathValue) } if string(value) == expectedValue { return false, nil } } if err == nil { pathValue, err := jmespath.Search("launchProfile.state", output) if err != nil { return false, fmt.Errorf("error evaluating waiter state: %w", err) } expectedValue := "DELETE_FAILED" value, ok := pathValue.(types.LaunchProfileState) if !ok { return false, fmt.Errorf("waiter comparator expected types.LaunchProfileState value, got %T", pathValue) } if string(value) == expectedValue { return false, fmt.Errorf("waiter state transitioned to Failure") } } return true, nil } func newServiceMetadataMiddleware_opGetLaunchProfile(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, ServiceID: ServiceID, SigningName: "nimble", OperationName: "GetLaunchProfile", } }