repo_name stringlengths 1 52 | repo_creator stringclasses 6
values | programming_language stringclasses 4
values | code stringlengths 0 9.68M | num_lines int64 1 234k |
|---|---|---|---|---|
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Permanently removes a FlexMatch matchmaking configuration. To delete, specify
// the configuration name. A matchmaking configuration cannot be deleted if it is
// being used in any active matchmaking tickets.
func (c *Client) DeleteMatchmakingConfiguration(ctx context.Context, params *DeleteMatchmakingConfigurationInput, optFns ...func(*Options)) (*DeleteMatchmakingConfigurationOutput, error) {
if params == nil {
params = &DeleteMatchmakingConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteMatchmakingConfiguration", params, optFns, c.addOperationDeleteMatchmakingConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteMatchmakingConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteMatchmakingConfigurationInput struct {
// A unique identifier for the matchmaking configuration. You can use either the
// configuration name or ARN value.
//
// This member is required.
Name *string
noSmithyDocumentSerde
}
type DeleteMatchmakingConfigurationOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteMatchmakingConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteMatchmakingConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteMatchmakingConfiguration{}, 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 = addOpDeleteMatchmakingConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteMatchmakingConfiguration(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
}
func newServiceMetadataMiddleware_opDeleteMatchmakingConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DeleteMatchmakingConfiguration",
}
}
| 123 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an existing matchmaking rule set. To delete the rule set, provide the
// rule set name. Rule sets cannot be deleted if they are currently being used by a
// matchmaking configuration. Learn more
// - Build a rule set (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-rulesets.html)
func (c *Client) DeleteMatchmakingRuleSet(ctx context.Context, params *DeleteMatchmakingRuleSetInput, optFns ...func(*Options)) (*DeleteMatchmakingRuleSetOutput, error) {
if params == nil {
params = &DeleteMatchmakingRuleSetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteMatchmakingRuleSet", params, optFns, c.addOperationDeleteMatchmakingRuleSetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteMatchmakingRuleSetOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteMatchmakingRuleSetInput struct {
// A unique identifier for the matchmaking rule set to be deleted. (Note: The rule
// set name is different from the optional "name" field in the rule set body.) You
// can use either the rule set name or ARN value.
//
// This member is required.
Name *string
noSmithyDocumentSerde
}
type DeleteMatchmakingRuleSetOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteMatchmakingRuleSetMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteMatchmakingRuleSet{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteMatchmakingRuleSet{}, 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 = addOpDeleteMatchmakingRuleSetValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteMatchmakingRuleSet(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
}
func newServiceMetadataMiddleware_opDeleteMatchmakingRuleSet(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DeleteMatchmakingRuleSet",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a fleet scaling policy. Once deleted, the policy is no longer in force
// and Amazon GameLift removes all record of it. To delete a scaling policy,
// specify both the scaling policy name and the fleet ID it is associated with. To
// temporarily suspend scaling policies, use StopFleetActions (https://docs.aws.amazon.com/gamelift/latest/apireference/API_StopFleetActions.html)
// . This operation suspends all policies for the fleet.
func (c *Client) DeleteScalingPolicy(ctx context.Context, params *DeleteScalingPolicyInput, optFns ...func(*Options)) (*DeleteScalingPolicyOutput, error) {
if params == nil {
params = &DeleteScalingPolicyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteScalingPolicy", params, optFns, c.addOperationDeleteScalingPolicyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteScalingPolicyOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteScalingPolicyInput struct {
// A unique identifier for the fleet to be deleted. You can use either the fleet
// ID or ARN value.
//
// This member is required.
FleetId *string
// A descriptive label that is associated with a fleet's scaling policy. Policy
// names do not need to be unique.
//
// This member is required.
Name *string
noSmithyDocumentSerde
}
type DeleteScalingPolicyOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteScalingPolicyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteScalingPolicy{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteScalingPolicy{}, 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 = addOpDeleteScalingPolicyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteScalingPolicy(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
}
func newServiceMetadataMiddleware_opDeleteScalingPolicy(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DeleteScalingPolicy",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a Realtime script. This operation permanently deletes the script
// record. If script files were uploaded, they are also deleted (files stored in an
// S3 bucket are not deleted). To delete a script, specify the script ID. Before
// deleting a script, be sure to terminate all fleets that are deployed with the
// script being deleted. Fleet instances periodically check for script updates, and
// if the script record no longer exists, the instance will go into an error state
// and be unable to host game sessions. Learn more Amazon GameLift Realtime Servers (https://docs.aws.amazon.com/gamelift/latest/developerguide/realtime-intro.html)
// Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) DeleteScript(ctx context.Context, params *DeleteScriptInput, optFns ...func(*Options)) (*DeleteScriptOutput, error) {
if params == nil {
params = &DeleteScriptInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteScript", params, optFns, c.addOperationDeleteScriptMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteScriptOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteScriptInput struct {
// A unique identifier for the Realtime script to delete. You can use either the
// script ID or ARN value.
//
// This member is required.
ScriptId *string
noSmithyDocumentSerde
}
type DeleteScriptOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteScriptMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteScript{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteScript{}, 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 = addOpDeleteScriptValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteScript(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
}
func newServiceMetadataMiddleware_opDeleteScript(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DeleteScript",
}
}
| 128 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Cancels a pending VPC peering authorization for the specified VPC. If you need
// to delete an existing VPC peering connection, use DeleteVpcPeeringConnection (https://docs.aws.amazon.com/gamelift/latest/apireference/API_DeleteVpcPeeringConnection.html)
// . Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) DeleteVpcPeeringAuthorization(ctx context.Context, params *DeleteVpcPeeringAuthorizationInput, optFns ...func(*Options)) (*DeleteVpcPeeringAuthorizationOutput, error) {
if params == nil {
params = &DeleteVpcPeeringAuthorizationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteVpcPeeringAuthorization", params, optFns, c.addOperationDeleteVpcPeeringAuthorizationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteVpcPeeringAuthorizationOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteVpcPeeringAuthorizationInput struct {
// A unique identifier for the Amazon Web Services account that you use to manage
// your Amazon GameLift fleet. You can find your Account ID in the Amazon Web
// Services Management Console under account settings.
//
// This member is required.
GameLiftAwsAccountId *string
// A unique identifier for a VPC with resources to be accessed by your Amazon
// GameLift fleet. The VPC must be in the same Region as your fleet. To look up a
// VPC ID, use the VPC Dashboard (https://console.aws.amazon.com/vpc/) in the
// Amazon Web Services Management Console. Learn more about VPC peering in VPC
// Peering with Amazon GameLift Fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/vpc-peering.html)
// .
//
// This member is required.
PeerVpcId *string
noSmithyDocumentSerde
}
type DeleteVpcPeeringAuthorizationOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteVpcPeeringAuthorizationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteVpcPeeringAuthorization{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteVpcPeeringAuthorization{}, 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 = addOpDeleteVpcPeeringAuthorizationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteVpcPeeringAuthorization(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
}
func newServiceMetadataMiddleware_opDeleteVpcPeeringAuthorization(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DeleteVpcPeeringAuthorization",
}
}
| 134 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Removes a VPC peering connection. To delete the connection, you must have a
// valid authorization for the VPC peering connection that you want to delete..
// Once a valid authorization exists, call this operation from the Amazon Web
// Services account that is used to manage the Amazon GameLift fleets. Identify the
// connection to delete by the connection ID and fleet ID. If successful, the
// connection is removed. Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) DeleteVpcPeeringConnection(ctx context.Context, params *DeleteVpcPeeringConnectionInput, optFns ...func(*Options)) (*DeleteVpcPeeringConnectionOutput, error) {
if params == nil {
params = &DeleteVpcPeeringConnectionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteVpcPeeringConnection", params, optFns, c.addOperationDeleteVpcPeeringConnectionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteVpcPeeringConnectionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteVpcPeeringConnectionInput struct {
// A unique identifier for the fleet. This fleet specified must match the fleet
// referenced in the VPC peering connection record. You can use either the fleet ID
// or ARN value.
//
// This member is required.
FleetId *string
// A unique identifier for a VPC peering connection.
//
// This member is required.
VpcPeeringConnectionId *string
noSmithyDocumentSerde
}
type DeleteVpcPeeringConnectionOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteVpcPeeringConnectionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteVpcPeeringConnection{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteVpcPeeringConnection{}, 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 = addOpDeleteVpcPeeringConnectionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteVpcPeeringConnection(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
}
func newServiceMetadataMiddleware_opDeleteVpcPeeringConnection(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DeleteVpcPeeringConnection",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Removes a compute resource from the specified fleet. Deregister your compute
// resources before you delete the compute.
func (c *Client) DeregisterCompute(ctx context.Context, params *DeregisterComputeInput, optFns ...func(*Options)) (*DeregisterComputeOutput, error) {
if params == nil {
params = &DeregisterComputeInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeregisterCompute", params, optFns, c.addOperationDeregisterComputeMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeregisterComputeOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeregisterComputeInput struct {
// The name of the compute resource you want to delete.
//
// This member is required.
ComputeName *string
// >A unique identifier for the fleet the compute resource is registered to.
//
// This member is required.
FleetId *string
noSmithyDocumentSerde
}
type DeregisterComputeOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeregisterComputeMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeregisterCompute{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeregisterCompute{}, 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 = addOpDeregisterComputeValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeregisterCompute(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
}
func newServiceMetadataMiddleware_opDeregisterCompute(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DeregisterCompute",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// This operation is used with the Amazon GameLift FleetIQ solution and game
// server groups. Removes the game server from a game server group. As a result of
// this operation, the deregistered game server can no longer be claimed and will
// not be returned in a list of active game servers. To deregister a game server,
// specify the game server group and game server ID. If successful, this operation
// emits a CloudWatch event with termination timestamp and reason. Learn more
// Amazon GameLift FleetIQ Guide (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
func (c *Client) DeregisterGameServer(ctx context.Context, params *DeregisterGameServerInput, optFns ...func(*Options)) (*DeregisterGameServerOutput, error) {
if params == nil {
params = &DeregisterGameServerInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeregisterGameServer", params, optFns, c.addOperationDeregisterGameServerMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeregisterGameServerOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeregisterGameServerInput struct {
// A unique identifier for the game server group where the game server is running.
//
// This member is required.
GameServerGroupName *string
// A custom string that uniquely identifies the game server to deregister.
//
// This member is required.
GameServerId *string
noSmithyDocumentSerde
}
type DeregisterGameServerOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeregisterGameServerMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeregisterGameServer{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeregisterGameServer{}, 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 = addOpDeregisterGameServerValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeregisterGameServer(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
}
func newServiceMetadataMiddleware_opDeregisterGameServer(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DeregisterGameServer",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves properties for an alias. This operation returns all alias metadata
// and settings. To get an alias's target fleet ID only, use ResolveAlias . To get
// alias properties, specify the alias ID. If successful, the requested alias
// record is returned. Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) DescribeAlias(ctx context.Context, params *DescribeAliasInput, optFns ...func(*Options)) (*DescribeAliasOutput, error) {
if params == nil {
params = &DescribeAliasInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeAlias", params, optFns, c.addOperationDescribeAliasMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeAliasOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeAliasInput struct {
// The unique identifier for the fleet alias that you want to retrieve. You can
// use either the alias ID or ARN value.
//
// This member is required.
AliasId *string
noSmithyDocumentSerde
}
type DescribeAliasOutput struct {
// The requested alias resource.
Alias *types.Alias
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeAliasMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeAlias{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeAlias{}, 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 = addOpDescribeAliasValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeAlias(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
}
func newServiceMetadataMiddleware_opDescribeAlias(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeAlias",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves properties for a custom game build. To request a build resource,
// specify a build ID. If successful, an object containing the build properties is
// returned. Learn more Upload a Custom Server Build (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-build-intro.html)
// All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) DescribeBuild(ctx context.Context, params *DescribeBuildInput, optFns ...func(*Options)) (*DescribeBuildOutput, error) {
if params == nil {
params = &DescribeBuildInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeBuild", params, optFns, c.addOperationDescribeBuildMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeBuildOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeBuildInput struct {
// A unique identifier for the build to retrieve properties for. You can use
// either the build ID or ARN value.
//
// This member is required.
BuildId *string
noSmithyDocumentSerde
}
type DescribeBuildOutput struct {
// Set of properties describing the requested build.
Build *types.Build
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeBuildMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeBuild{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeBuild{}, 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 = addOpDescribeBuildValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeBuild(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
}
func newServiceMetadataMiddleware_opDescribeBuild(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeBuild",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves properties for a compute resource. To request a compute resource
// specify the fleet ID and compute name. If successful, Amazon GameLift returns an
// object containing the build properties.
func (c *Client) DescribeCompute(ctx context.Context, params *DescribeComputeInput, optFns ...func(*Options)) (*DescribeComputeOutput, error) {
if params == nil {
params = &DescribeComputeInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeCompute", params, optFns, c.addOperationDescribeComputeMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeComputeOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeComputeInput struct {
// A descriptive label that is associated with the compute resource registered to
// your fleet.
//
// This member is required.
ComputeName *string
// A unique identifier for the fleet the compute is registered to.
//
// This member is required.
FleetId *string
noSmithyDocumentSerde
}
type DescribeComputeOutput struct {
// The details of the compute resource you registered to the specified fleet.
Compute *types.Compute
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeComputeMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeCompute{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeCompute{}, 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 = addOpDescribeComputeValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeCompute(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
}
func newServiceMetadataMiddleware_opDescribeCompute(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeCompute",
}
}
| 133 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves the instance limits and current utilization for an Amazon Web
// Services Region or location. Instance limits control the number of instances,
// per instance type, per location, that your Amazon Web Services account can use.
// Learn more at Amazon EC2 Instance Types (http://aws.amazon.com/ec2/instance-types/)
// . The information returned includes the maximum number of instances allowed and
// your account's current usage across all fleets. This information can affect your
// ability to scale your Amazon GameLift fleets. You can request a limit increase
// for your account by using the Service limits page in the Amazon GameLift
// console. Instance limits differ based on whether the instances are deployed in a
// fleet's home Region or in a remote location. For remote locations, limits also
// differ based on the combination of home Region and remote location. All requests
// must specify an Amazon Web Services Region (either explicitly or as your default
// settings). To get the limit for a remote location, you must also specify the
// location. For example, the following requests all return different results:
// - Request specifies the Region ap-northeast-1 with no location. The result is
// limits and usage data on all instance types that are deployed in us-east-2 ,
// by all of the fleets that reside in ap-northeast-1 .
// - Request specifies the Region us-east-1 with location ca-central-1 . The
// result is limits and usage data on all instance types that are deployed in
// ca-central-1 , by all of the fleets that reside in us-east-2 . These limits do
// not affect fleets in any other Regions that deploy instances to ca-central-1 .
// - Request specifies the Region eu-west-1 with location ca-central-1 . The
// result is limits and usage data on all instance types that are deployed in
// ca-central-1 , by all of the fleets that reside in eu-west-1 .
//
// This operation can be used in the following ways:
// - To get limit and usage data for all instance types that are deployed in an
// Amazon Web Services Region by fleets that reside in the same Region: Specify the
// Region only. Optionally, specify a single instance type to retrieve information
// for.
// - To get limit and usage data for all instance types that are deployed to a
// remote location by fleets that reside in different Amazon Web Services Region:
// Provide both the Amazon Web Services Region and the remote location. Optionally,
// specify a single instance type to retrieve information for.
//
// If successful, an EC2InstanceLimits object is returned with limits and usage
// data for each requested instance type. Learn more Setting up Amazon GameLift
// fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
func (c *Client) DescribeEC2InstanceLimits(ctx context.Context, params *DescribeEC2InstanceLimitsInput, optFns ...func(*Options)) (*DescribeEC2InstanceLimitsOutput, error) {
if params == nil {
params = &DescribeEC2InstanceLimitsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeEC2InstanceLimits", params, optFns, c.addOperationDescribeEC2InstanceLimitsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeEC2InstanceLimitsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeEC2InstanceLimitsInput struct {
// Name of an Amazon EC2 instance type that is supported in Amazon GameLift. A
// fleet instance type determines the computing resources of each instance in the
// fleet, including CPU, memory, storage, and networking capacity. Do not specify a
// value for this parameter to retrieve limits for all instance types.
EC2InstanceType types.EC2InstanceType
// The name of a remote location to request instance limits for, in the form of an
// Amazon Web Services Region code such as us-west-2 .
Location *string
noSmithyDocumentSerde
}
type DescribeEC2InstanceLimitsOutput struct {
// The maximum number of instances for the specified instance type.
EC2InstanceLimits []types.EC2InstanceLimit
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeEC2InstanceLimitsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeEC2InstanceLimits{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeEC2InstanceLimits{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeEC2InstanceLimits(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
}
func newServiceMetadataMiddleware_opDescribeEC2InstanceLimits(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeEC2InstanceLimits",
}
}
| 164 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves core fleet-wide properties, including the computing hardware and
// deployment configuration for all instances in the fleet. This operation can be
// used in the following ways:
// - To get attributes for one or more specific fleets, provide a list of fleet
// IDs or fleet ARNs.
// - To get attributes for all fleets, do not provide a fleet identifier.
//
// When requesting attributes for multiple fleets, use the pagination parameters
// to retrieve results as a set of sequential pages. If successful, a
// FleetAttributes object is returned for each fleet requested, unless the fleet
// identifier is not found. Some API operations limit the number of fleet IDs that
// allowed in one request. If a request exceeds this limit, the request fails and
// the error message contains the maximum allowed number. Learn more Setting up
// Amazon GameLift fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
func (c *Client) DescribeFleetAttributes(ctx context.Context, params *DescribeFleetAttributesInput, optFns ...func(*Options)) (*DescribeFleetAttributesOutput, error) {
if params == nil {
params = &DescribeFleetAttributesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeFleetAttributes", params, optFns, c.addOperationDescribeFleetAttributesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeFleetAttributesOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeFleetAttributesInput struct {
// A list of unique fleet identifiers to retrieve attributes for. You can use
// either the fleet ID or ARN value. To retrieve attributes for all current fleets,
// do not include this parameter.
FleetIds []string
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages. This parameter is ignored when the
// request specifies one or a list of fleet IDs.
Limit *int32
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, do not specify a value. This parameter is
// ignored when the request specifies one or a list of fleet IDs.
NextToken *string
noSmithyDocumentSerde
}
type DescribeFleetAttributesOutput struct {
// A collection of objects containing attribute metadata for each requested fleet
// ID. Attribute objects are returned only for fleets that currently exist.
FleetAttributes []types.FleetAttributes
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeFleetAttributesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeFleetAttributes{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeFleetAttributes{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeFleetAttributes(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
}
// DescribeFleetAttributesAPIClient is a client that implements the
// DescribeFleetAttributes operation.
type DescribeFleetAttributesAPIClient interface {
DescribeFleetAttributes(context.Context, *DescribeFleetAttributesInput, ...func(*Options)) (*DescribeFleetAttributesOutput, error)
}
var _ DescribeFleetAttributesAPIClient = (*Client)(nil)
// DescribeFleetAttributesPaginatorOptions is the paginator options for
// DescribeFleetAttributes
type DescribeFleetAttributesPaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages. This parameter is ignored when the
// request specifies one or a list of fleet IDs.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// DescribeFleetAttributesPaginator is a paginator for DescribeFleetAttributes
type DescribeFleetAttributesPaginator struct {
options DescribeFleetAttributesPaginatorOptions
client DescribeFleetAttributesAPIClient
params *DescribeFleetAttributesInput
nextToken *string
firstPage bool
}
// NewDescribeFleetAttributesPaginator returns a new
// DescribeFleetAttributesPaginator
func NewDescribeFleetAttributesPaginator(client DescribeFleetAttributesAPIClient, params *DescribeFleetAttributesInput, optFns ...func(*DescribeFleetAttributesPaginatorOptions)) *DescribeFleetAttributesPaginator {
if params == nil {
params = &DescribeFleetAttributesInput{}
}
options := DescribeFleetAttributesPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeFleetAttributesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeFleetAttributesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeFleetAttributes page.
func (p *DescribeFleetAttributesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeFleetAttributesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.DescribeFleetAttributes(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opDescribeFleetAttributes(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeFleetAttributes",
}
}
| 247 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves the resource capacity settings for one or more fleets. The data
// returned includes the current fleet capacity (number of EC2 instances), and
// settings that can control how capacity scaling. For fleets with remote
// locations, this operation retrieves data for the fleet's home Region only. This
// operation can be used in the following ways:
// - To get capacity data for one or more specific fleets, provide a list of
// fleet IDs or fleet ARNs.
// - To get capacity data for all fleets, do not provide a fleet identifier.
//
// When requesting multiple fleets, use the pagination parameters to retrieve
// results as a set of sequential pages. If successful, a FleetCapacity object is
// returned for each requested fleet ID. Each FleetCapacity object includes a
// Location property, which is set to the fleet's home Region. When a list of fleet
// IDs is provided, attribute objects are returned only for fleets that currently
// exist. Some API operations may limit the number of fleet IDs that are allowed in
// one request. If a request exceeds this limit, the request fails and the error
// message includes the maximum allowed. Learn more Setting up Amazon GameLift
// fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
// GameLift metrics for fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/monitoring-cloudwatch.html#gamelift-metrics-fleet)
func (c *Client) DescribeFleetCapacity(ctx context.Context, params *DescribeFleetCapacityInput, optFns ...func(*Options)) (*DescribeFleetCapacityOutput, error) {
if params == nil {
params = &DescribeFleetCapacityInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeFleetCapacity", params, optFns, c.addOperationDescribeFleetCapacityMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeFleetCapacityOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeFleetCapacityInput struct {
// A unique identifier for the fleet to retrieve capacity information for. You can
// use either the fleet ID or ARN value. Leave this parameter empty to retrieve
// capacity information for all fleets.
FleetIds []string
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages. This parameter is ignored when the
// request specifies one or a list of fleet IDs.
Limit *int32
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, do not specify a value. This parameter is
// ignored when the request specifies one or a list of fleet IDs.
NextToken *string
noSmithyDocumentSerde
}
type DescribeFleetCapacityOutput struct {
// A collection of objects that contains capacity information for each requested
// fleet ID. Capacity objects are returned only for fleets that currently exist.
FleetCapacity []types.FleetCapacity
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeFleetCapacityMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeFleetCapacity{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeFleetCapacity{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeFleetCapacity(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
}
// DescribeFleetCapacityAPIClient is a client that implements the
// DescribeFleetCapacity operation.
type DescribeFleetCapacityAPIClient interface {
DescribeFleetCapacity(context.Context, *DescribeFleetCapacityInput, ...func(*Options)) (*DescribeFleetCapacityOutput, error)
}
var _ DescribeFleetCapacityAPIClient = (*Client)(nil)
// DescribeFleetCapacityPaginatorOptions is the paginator options for
// DescribeFleetCapacity
type DescribeFleetCapacityPaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages. This parameter is ignored when the
// request specifies one or a list of fleet IDs.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// DescribeFleetCapacityPaginator is a paginator for DescribeFleetCapacity
type DescribeFleetCapacityPaginator struct {
options DescribeFleetCapacityPaginatorOptions
client DescribeFleetCapacityAPIClient
params *DescribeFleetCapacityInput
nextToken *string
firstPage bool
}
// NewDescribeFleetCapacityPaginator returns a new DescribeFleetCapacityPaginator
func NewDescribeFleetCapacityPaginator(client DescribeFleetCapacityAPIClient, params *DescribeFleetCapacityInput, optFns ...func(*DescribeFleetCapacityPaginatorOptions)) *DescribeFleetCapacityPaginator {
if params == nil {
params = &DescribeFleetCapacityInput{}
}
options := DescribeFleetCapacityPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeFleetCapacityPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeFleetCapacityPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeFleetCapacity page.
func (p *DescribeFleetCapacityPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeFleetCapacityOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.DescribeFleetCapacity(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opDescribeFleetCapacity(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeFleetCapacity",
}
}
| 251 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Retrieves entries from a fleet's event log. Fleet events are initiated by
// changes in status, such as during fleet creation and termination, changes in
// capacity, etc. If a fleet has multiple locations, events are also initiated by
// changes to status and capacity in remote locations. You can specify a time range
// to limit the result set. Use the pagination parameters to retrieve results as a
// set of sequential pages. If successful, a collection of event log entries
// matching the request are returned. Learn more Setting up Amazon GameLift fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
func (c *Client) DescribeFleetEvents(ctx context.Context, params *DescribeFleetEventsInput, optFns ...func(*Options)) (*DescribeFleetEventsOutput, error) {
if params == nil {
params = &DescribeFleetEventsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeFleetEvents", params, optFns, c.addOperationDescribeFleetEventsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeFleetEventsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeFleetEventsInput struct {
// A unique identifier for the fleet to get event logs for. You can use either the
// fleet ID or ARN value.
//
// This member is required.
FleetId *string
// The most recent date to retrieve event logs for. If no end time is specified,
// this call returns entries from the specified start time up to the present.
// Format is a number expressed in Unix time as milliseconds (ex:
// "1469498468.057").
EndTime *time.Time
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit *int32
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, do not specify a value.
NextToken *string
// The earliest date to retrieve event logs for. If no start time is specified,
// this call returns entries starting from when the fleet was created to the
// specified end time. Format is a number expressed in Unix time as milliseconds
// (ex: "1469498468.057").
StartTime *time.Time
noSmithyDocumentSerde
}
type DescribeFleetEventsOutput struct {
// A collection of objects containing event log entries for the specified fleet.
Events []types.Event
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeFleetEventsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeFleetEvents{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeFleetEvents{}, 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 = addOpDescribeFleetEventsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeFleetEvents(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
}
// DescribeFleetEventsAPIClient is a client that implements the
// DescribeFleetEvents operation.
type DescribeFleetEventsAPIClient interface {
DescribeFleetEvents(context.Context, *DescribeFleetEventsInput, ...func(*Options)) (*DescribeFleetEventsOutput, error)
}
var _ DescribeFleetEventsAPIClient = (*Client)(nil)
// DescribeFleetEventsPaginatorOptions is the paginator options for
// DescribeFleetEvents
type DescribeFleetEventsPaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// DescribeFleetEventsPaginator is a paginator for DescribeFleetEvents
type DescribeFleetEventsPaginator struct {
options DescribeFleetEventsPaginatorOptions
client DescribeFleetEventsAPIClient
params *DescribeFleetEventsInput
nextToken *string
firstPage bool
}
// NewDescribeFleetEventsPaginator returns a new DescribeFleetEventsPaginator
func NewDescribeFleetEventsPaginator(client DescribeFleetEventsAPIClient, params *DescribeFleetEventsInput, optFns ...func(*DescribeFleetEventsPaginatorOptions)) *DescribeFleetEventsPaginator {
if params == nil {
params = &DescribeFleetEventsInput{}
}
options := DescribeFleetEventsPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeFleetEventsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeFleetEventsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeFleetEvents page.
func (p *DescribeFleetEventsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeFleetEventsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.DescribeFleetEvents(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opDescribeFleetEvents(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeFleetEvents",
}
}
| 252 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves information on a fleet's remote locations, including life-cycle
// status and any suspended fleet activity. This operation can be used in the
// following ways:
// - To get data for specific locations, provide a fleet identifier and a list
// of locations. Location data is returned in the order that it is requested.
// - To get data for all locations, provide a fleet identifier only. Location
// data is returned in no particular order.
//
// When requesting attributes for multiple locations, use the pagination
// parameters to retrieve results as a set of sequential pages. If successful, a
// LocationAttributes object is returned for each requested location. If the fleet
// does not have a requested location, no information is returned. This operation
// does not return the home Region. To get information on a fleet's home Region,
// call DescribeFleetAttributes . Learn more Setting up Amazon GameLift fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
func (c *Client) DescribeFleetLocationAttributes(ctx context.Context, params *DescribeFleetLocationAttributesInput, optFns ...func(*Options)) (*DescribeFleetLocationAttributesOutput, error) {
if params == nil {
params = &DescribeFleetLocationAttributesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeFleetLocationAttributes", params, optFns, c.addOperationDescribeFleetLocationAttributesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeFleetLocationAttributesOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeFleetLocationAttributesInput struct {
// A unique identifier for the fleet to retrieve remote locations for. You can use
// either the fleet ID or ARN value.
//
// This member is required.
FleetId *string
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages. This limit is not currently enforced.
Limit *int32
// A list of fleet locations to retrieve information for. Specify locations in the
// form of an Amazon Web Services Region code, such as us-west-2 .
Locations []string
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, do not specify a value.
NextToken *string
noSmithyDocumentSerde
}
type DescribeFleetLocationAttributesOutput struct {
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift fleet resource and uniquely identifies
// it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 .
FleetArn *string
// A unique identifier for the fleet that location attributes were requested for.
FleetId *string
// Location-specific information on the requested fleet's remote locations.
LocationAttributes []types.LocationAttributes
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeFleetLocationAttributesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeFleetLocationAttributes{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeFleetLocationAttributes{}, 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 = addOpDescribeFleetLocationAttributesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeFleetLocationAttributes(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
}
// DescribeFleetLocationAttributesAPIClient is a client that implements the
// DescribeFleetLocationAttributes operation.
type DescribeFleetLocationAttributesAPIClient interface {
DescribeFleetLocationAttributes(context.Context, *DescribeFleetLocationAttributesInput, ...func(*Options)) (*DescribeFleetLocationAttributesOutput, error)
}
var _ DescribeFleetLocationAttributesAPIClient = (*Client)(nil)
// DescribeFleetLocationAttributesPaginatorOptions is the paginator options for
// DescribeFleetLocationAttributes
type DescribeFleetLocationAttributesPaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages. This limit is not currently enforced.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// DescribeFleetLocationAttributesPaginator is a paginator for
// DescribeFleetLocationAttributes
type DescribeFleetLocationAttributesPaginator struct {
options DescribeFleetLocationAttributesPaginatorOptions
client DescribeFleetLocationAttributesAPIClient
params *DescribeFleetLocationAttributesInput
nextToken *string
firstPage bool
}
// NewDescribeFleetLocationAttributesPaginator returns a new
// DescribeFleetLocationAttributesPaginator
func NewDescribeFleetLocationAttributesPaginator(client DescribeFleetLocationAttributesAPIClient, params *DescribeFleetLocationAttributesInput, optFns ...func(*DescribeFleetLocationAttributesPaginatorOptions)) *DescribeFleetLocationAttributesPaginator {
if params == nil {
params = &DescribeFleetLocationAttributesInput{}
}
options := DescribeFleetLocationAttributesPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeFleetLocationAttributesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeFleetLocationAttributesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeFleetLocationAttributes page.
func (p *DescribeFleetLocationAttributesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeFleetLocationAttributesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.DescribeFleetLocationAttributes(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opDescribeFleetLocationAttributes(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeFleetLocationAttributes",
}
}
| 261 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves the resource capacity settings for a fleet location. The data
// returned includes the current capacity (number of EC2 instances) and some
// scaling settings for the requested fleet location. Use this operation to
// retrieve capacity information for a fleet's remote location or home Region (you
// can also retrieve home Region capacity by calling DescribeFleetCapacity ). To
// retrieve capacity data, identify a fleet and location. If successful, a
// FleetCapacity object is returned for the requested fleet location. Learn more
// Setting up Amazon GameLift fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
// GameLift metrics for fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/monitoring-cloudwatch.html#gamelift-metrics-fleet)
func (c *Client) DescribeFleetLocationCapacity(ctx context.Context, params *DescribeFleetLocationCapacityInput, optFns ...func(*Options)) (*DescribeFleetLocationCapacityOutput, error) {
if params == nil {
params = &DescribeFleetLocationCapacityInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeFleetLocationCapacity", params, optFns, c.addOperationDescribeFleetLocationCapacityMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeFleetLocationCapacityOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeFleetLocationCapacityInput struct {
// A unique identifier for the fleet to request location capacity for. You can use
// either the fleet ID or ARN value.
//
// This member is required.
FleetId *string
// The fleet location to retrieve capacity information for. Specify a location in
// the form of an Amazon Web Services Region code, such as us-west-2 .
//
// This member is required.
Location *string
noSmithyDocumentSerde
}
type DescribeFleetLocationCapacityOutput struct {
// Resource capacity information for the requested fleet location. Capacity
// objects are returned only for fleets and locations that currently exist.
FleetCapacity *types.FleetCapacity
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeFleetLocationCapacityMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeFleetLocationCapacity{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeFleetLocationCapacity{}, 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 = addOpDescribeFleetLocationCapacityValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeFleetLocationCapacity(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
}
func newServiceMetadataMiddleware_opDescribeFleetLocationCapacity(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeFleetLocationCapacity",
}
}
| 141 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves current usage data for a fleet location. Utilization data provides a
// snapshot of current game hosting activity at the requested location. Use this
// operation to retrieve utilization information for a fleet's remote location or
// home Region (you can also retrieve home Region utilization by calling
// DescribeFleetUtilization ). To retrieve utilization data, identify a fleet and
// location. If successful, a FleetUtilization object is returned for the
// requested fleet location. Learn more Setting up Amazon GameLift fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
// GameLift metrics for fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/monitoring-cloudwatch.html#gamelift-metrics-fleet)
func (c *Client) DescribeFleetLocationUtilization(ctx context.Context, params *DescribeFleetLocationUtilizationInput, optFns ...func(*Options)) (*DescribeFleetLocationUtilizationOutput, error) {
if params == nil {
params = &DescribeFleetLocationUtilizationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeFleetLocationUtilization", params, optFns, c.addOperationDescribeFleetLocationUtilizationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeFleetLocationUtilizationOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeFleetLocationUtilizationInput struct {
// A unique identifier for the fleet to request location utilization for. You can
// use either the fleet ID or ARN value.
//
// This member is required.
FleetId *string
// The fleet location to retrieve utilization information for. Specify a location
// in the form of an Amazon Web Services Region code, such as us-west-2 .
//
// This member is required.
Location *string
noSmithyDocumentSerde
}
type DescribeFleetLocationUtilizationOutput struct {
// Utilization information for the requested fleet location. Utilization objects
// are returned only for fleets and locations that currently exist.
FleetUtilization *types.FleetUtilization
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeFleetLocationUtilizationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeFleetLocationUtilization{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeFleetLocationUtilization{}, 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 = addOpDescribeFleetLocationUtilizationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeFleetLocationUtilization(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
}
func newServiceMetadataMiddleware_opDescribeFleetLocationUtilization(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeFleetLocationUtilization",
}
}
| 140 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a fleet's inbound connection permissions. Connection permissions
// specify the range of IP addresses and port settings that incoming traffic can
// use to access server processes in the fleet. Game sessions that are running on
// instances in the fleet must use connections that fall in this range. This
// operation can be used in the following ways:
// - To retrieve the inbound connection permissions for a fleet, identify the
// fleet's unique identifier.
// - To check the status of recent updates to a fleet remote location, specify
// the fleet ID and a location. Port setting updates can take time to propagate
// across all locations.
//
// If successful, a set of IpPermission objects is returned for the requested
// fleet ID. When a location is specified, a pending status is included. If the
// requested fleet has been deleted, the result set is empty. Learn more Setting
// up Amazon GameLift fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
func (c *Client) DescribeFleetPortSettings(ctx context.Context, params *DescribeFleetPortSettingsInput, optFns ...func(*Options)) (*DescribeFleetPortSettingsOutput, error) {
if params == nil {
params = &DescribeFleetPortSettingsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeFleetPortSettings", params, optFns, c.addOperationDescribeFleetPortSettingsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeFleetPortSettingsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeFleetPortSettingsInput struct {
// A unique identifier for the fleet to retrieve port settings for. You can use
// either the fleet ID or ARN value.
//
// This member is required.
FleetId *string
// A remote location to check for status of port setting updates. Use the Amazon
// Web Services Region code format, such as us-west-2 .
Location *string
noSmithyDocumentSerde
}
type DescribeFleetPortSettingsOutput struct {
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift fleet resource and uniquely identifies
// it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 .
FleetArn *string
// A unique identifier for the fleet that was requested.
FleetId *string
// The port settings for the requested fleet ID.
InboundPermissions []types.IpPermission
// The requested fleet location, expressed as an Amazon Web Services Region code,
// such as us-west-2 .
Location *string
// The current status of updates to the fleet's port settings in the requested
// fleet location. A status of PENDING_UPDATE indicates that an update was
// requested for the fleet but has not yet been completed for the location.
UpdateStatus types.LocationUpdateStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeFleetPortSettingsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeFleetPortSettings{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeFleetPortSettings{}, 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 = addOpDescribeFleetPortSettingsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeFleetPortSettings(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
}
func newServiceMetadataMiddleware_opDescribeFleetPortSettings(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeFleetPortSettings",
}
}
| 162 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves utilization statistics for one or more fleets. Utilization data
// provides a snapshot of how the fleet's hosting resources are currently being
// used. For fleets with remote locations, this operation retrieves data for the
// fleet's home Region only. See DescribeFleetLocationUtilization (https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeFleetLocationUtilization.html)
// to get utilization statistics for a fleet's remote locations. This operation can
// be used in the following ways:
// - To get utilization data for one or more specific fleets, provide a list of
// fleet IDs or fleet ARNs.
// - To get utilization data for all fleets, do not provide a fleet identifier.
//
// When requesting multiple fleets, use the pagination parameters to retrieve
// results as a set of sequential pages. If successful, a FleetUtilization (https://docs.aws.amazon.com/gamelift/latest/apireference/API_FleetUtilization.html)
// object is returned for each requested fleet ID, unless the fleet identifier is
// not found. Each fleet utilization object includes a Location property, which is
// set to the fleet's home Region. Some API operations may limit the number of
// fleet IDs allowed in one request. If a request exceeds this limit, the request
// fails and the error message includes the maximum allowed. Learn more Setting up
// Amazon GameLift Fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
// GameLift Metrics for Fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/monitoring-cloudwatch.html#gamelift-metrics-fleet)
func (c *Client) DescribeFleetUtilization(ctx context.Context, params *DescribeFleetUtilizationInput, optFns ...func(*Options)) (*DescribeFleetUtilizationOutput, error) {
if params == nil {
params = &DescribeFleetUtilizationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeFleetUtilization", params, optFns, c.addOperationDescribeFleetUtilizationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeFleetUtilizationOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeFleetUtilizationInput struct {
// A unique identifier for the fleet to retrieve utilization data for. You can use
// either the fleet ID or ARN value. To retrieve attributes for all current fleets,
// do not include this parameter.
FleetIds []string
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages. This parameter is ignored when the
// request specifies one or a list of fleet IDs.
Limit *int32
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, do not specify a value. This parameter is
// ignored when the request specifies one or a list of fleet IDs.
NextToken *string
noSmithyDocumentSerde
}
type DescribeFleetUtilizationOutput struct {
// A collection of objects containing utilization information for each requested
// fleet ID. Utilization objects are returned only for fleets that currently exist.
FleetUtilization []types.FleetUtilization
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeFleetUtilizationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeFleetUtilization{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeFleetUtilization{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeFleetUtilization(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
}
// DescribeFleetUtilizationAPIClient is a client that implements the
// DescribeFleetUtilization operation.
type DescribeFleetUtilizationAPIClient interface {
DescribeFleetUtilization(context.Context, *DescribeFleetUtilizationInput, ...func(*Options)) (*DescribeFleetUtilizationOutput, error)
}
var _ DescribeFleetUtilizationAPIClient = (*Client)(nil)
// DescribeFleetUtilizationPaginatorOptions is the paginator options for
// DescribeFleetUtilization
type DescribeFleetUtilizationPaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages. This parameter is ignored when the
// request specifies one or a list of fleet IDs.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// DescribeFleetUtilizationPaginator is a paginator for DescribeFleetUtilization
type DescribeFleetUtilizationPaginator struct {
options DescribeFleetUtilizationPaginatorOptions
client DescribeFleetUtilizationAPIClient
params *DescribeFleetUtilizationInput
nextToken *string
firstPage bool
}
// NewDescribeFleetUtilizationPaginator returns a new
// DescribeFleetUtilizationPaginator
func NewDescribeFleetUtilizationPaginator(client DescribeFleetUtilizationAPIClient, params *DescribeFleetUtilizationInput, optFns ...func(*DescribeFleetUtilizationPaginatorOptions)) *DescribeFleetUtilizationPaginator {
if params == nil {
params = &DescribeFleetUtilizationInput{}
}
options := DescribeFleetUtilizationPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeFleetUtilizationPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeFleetUtilizationPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeFleetUtilization page.
func (p *DescribeFleetUtilizationPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeFleetUtilizationOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.DescribeFleetUtilization(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opDescribeFleetUtilization(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeFleetUtilization",
}
}
| 252 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// This operation is used with the Amazon GameLift FleetIQ solution and game
// server groups. Retrieves information for a registered game server. Information
// includes game server status, health check info, and the instance that the game
// server is running on. To retrieve game server information, specify the game
// server ID. If successful, the requested game server object is returned. Learn
// more Amazon GameLift FleetIQ Guide (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
func (c *Client) DescribeGameServer(ctx context.Context, params *DescribeGameServerInput, optFns ...func(*Options)) (*DescribeGameServerOutput, error) {
if params == nil {
params = &DescribeGameServerInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeGameServer", params, optFns, c.addOperationDescribeGameServerMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeGameServerOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeGameServerInput struct {
// A unique identifier for the game server group where the game server is running.
//
// This member is required.
GameServerGroupName *string
// A custom string that uniquely identifies the game server information to be
// retrieved.
//
// This member is required.
GameServerId *string
noSmithyDocumentSerde
}
type DescribeGameServerOutput struct {
// Object that describes the requested game server.
GameServer *types.GameServer
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeGameServerMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeGameServer{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeGameServer{}, 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 = addOpDescribeGameServerValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeGameServer(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
}
func newServiceMetadataMiddleware_opDescribeGameServer(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeGameServer",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// This operation is used with the Amazon GameLift FleetIQ solution and game
// server groups. Retrieves information on a game server group. This operation
// returns only properties related to Amazon GameLift FleetIQ. To view or update
// properties for the corresponding Auto Scaling group, such as launch template,
// auto scaling policies, and maximum/minimum group size, access the Auto Scaling
// group directly. To get attributes for a game server group, provide a group name
// or ARN value. If successful, a GameServerGroup object is returned. Learn more
// Amazon GameLift FleetIQ Guide (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
func (c *Client) DescribeGameServerGroup(ctx context.Context, params *DescribeGameServerGroupInput, optFns ...func(*Options)) (*DescribeGameServerGroupOutput, error) {
if params == nil {
params = &DescribeGameServerGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeGameServerGroup", params, optFns, c.addOperationDescribeGameServerGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeGameServerGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeGameServerGroupInput struct {
// A unique identifier for the game server group. Use either the name or ARN value.
//
// This member is required.
GameServerGroupName *string
noSmithyDocumentSerde
}
type DescribeGameServerGroupOutput struct {
// An object with the property settings for the requested game server group
// resource.
GameServerGroup *types.GameServerGroup
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeGameServerGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeGameServerGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeGameServerGroup{}, 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 = addOpDescribeGameServerGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeGameServerGroup(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
}
func newServiceMetadataMiddleware_opDescribeGameServerGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeGameServerGroup",
}
}
| 133 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// This operation is used with the Amazon GameLift FleetIQ solution and game
// server groups. Retrieves status information about the Amazon EC2 instances
// associated with a Amazon GameLift FleetIQ game server group. Use this operation
// to detect when instances are active or not available to host new game servers.
// To request status for all instances in the game server group, provide a game
// server group ID only. To request status for specific instances, provide the game
// server group ID and one or more instance IDs. Use the pagination parameters to
// retrieve results in sequential segments. If successful, a collection of
// GameServerInstance objects is returned. This operation is not designed to be
// called with every game server claim request; this practice can cause you to
// exceed your API limit, which results in errors. Instead, as a best practice,
// cache the results and refresh your cache no more than once every 10 seconds.
// Learn more Amazon GameLift FleetIQ Guide (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
func (c *Client) DescribeGameServerInstances(ctx context.Context, params *DescribeGameServerInstancesInput, optFns ...func(*Options)) (*DescribeGameServerInstancesOutput, error) {
if params == nil {
params = &DescribeGameServerInstancesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeGameServerInstances", params, optFns, c.addOperationDescribeGameServerInstancesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeGameServerInstancesOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeGameServerInstancesInput struct {
// A unique identifier for the game server group. Use either the name or ARN value.
//
// This member is required.
GameServerGroupName *string
// The Amazon EC2 instance IDs that you want to retrieve status on. Amazon EC2
// instance IDs use a 17-character format, for example: i-1234567890abcdef0 . To
// retrieve all instances in the game server group, leave this parameter empty.
InstanceIds []string
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit *int32
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, do not specify a value.
NextToken *string
noSmithyDocumentSerde
}
type DescribeGameServerInstancesOutput struct {
// The collection of requested game server instances.
GameServerInstances []types.GameServerInstance
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeGameServerInstancesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeGameServerInstances{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeGameServerInstances{}, 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 = addOpDescribeGameServerInstancesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeGameServerInstances(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
}
// DescribeGameServerInstancesAPIClient is a client that implements the
// DescribeGameServerInstances operation.
type DescribeGameServerInstancesAPIClient interface {
DescribeGameServerInstances(context.Context, *DescribeGameServerInstancesInput, ...func(*Options)) (*DescribeGameServerInstancesOutput, error)
}
var _ DescribeGameServerInstancesAPIClient = (*Client)(nil)
// DescribeGameServerInstancesPaginatorOptions is the paginator options for
// DescribeGameServerInstances
type DescribeGameServerInstancesPaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// DescribeGameServerInstancesPaginator is a paginator for
// DescribeGameServerInstances
type DescribeGameServerInstancesPaginator struct {
options DescribeGameServerInstancesPaginatorOptions
client DescribeGameServerInstancesAPIClient
params *DescribeGameServerInstancesInput
nextToken *string
firstPage bool
}
// NewDescribeGameServerInstancesPaginator returns a new
// DescribeGameServerInstancesPaginator
func NewDescribeGameServerInstancesPaginator(client DescribeGameServerInstancesAPIClient, params *DescribeGameServerInstancesInput, optFns ...func(*DescribeGameServerInstancesPaginatorOptions)) *DescribeGameServerInstancesPaginator {
if params == nil {
params = &DescribeGameServerInstancesInput{}
}
options := DescribeGameServerInstancesPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeGameServerInstancesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeGameServerInstancesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeGameServerInstances page.
func (p *DescribeGameServerInstancesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeGameServerInstancesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.DescribeGameServerInstances(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opDescribeGameServerInstances(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeGameServerInstances",
}
}
| 251 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves additional game session properties, including the game session
// protection policy in force, a set of one or more game sessions in a specific
// fleet location. You can optionally filter the results by current game session
// status. This operation can be used in the following ways:
// - To retrieve details for all game sessions that are currently running on all
// locations in a fleet, provide a fleet or alias ID, with an optional status
// filter. This approach returns details from the fleet's home Region and all
// remote locations.
// - To retrieve details for all game sessions that are currently running on a
// specific fleet location, provide a fleet or alias ID and a location name, with
// optional status filter. The location can be the fleet's home Region or any
// remote location.
// - To retrieve details for a specific game session, provide the game session
// ID. This approach looks for the game session ID in all fleets that reside in the
// Amazon Web Services Region defined in the request.
//
// Use the pagination parameters to retrieve results as a set of sequential pages.
// If successful, a GameSessionDetail object is returned for each game session
// that matches the request. Learn more Find a game session (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-client-api.html#gamelift-sdk-client-api-find)
// All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) DescribeGameSessionDetails(ctx context.Context, params *DescribeGameSessionDetailsInput, optFns ...func(*Options)) (*DescribeGameSessionDetailsOutput, error) {
if params == nil {
params = &DescribeGameSessionDetailsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeGameSessionDetails", params, optFns, c.addOperationDescribeGameSessionDetailsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeGameSessionDetailsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeGameSessionDetailsInput struct {
// A unique identifier for the alias associated with the fleet to retrieve all
// game sessions for. You can use either the alias ID or ARN value.
AliasId *string
// A unique identifier for the fleet to retrieve all game sessions active on the
// fleet. You can use either the fleet ID or ARN value.
FleetId *string
// A unique identifier for the game session to retrieve.
GameSessionId *string
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit *int32
// A fleet location to get game session details for. You can specify a fleet's
// home Region or a remote location. Use the Amazon Web Services Region code
// format, such as us-west-2 .
Location *string
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, do not specify a value.
NextToken *string
// Game session status to filter results on. Possible game session statuses
// include ACTIVE , TERMINATED , ACTIVATING and TERMINATING (the last two are
// transitory).
StatusFilter *string
noSmithyDocumentSerde
}
type DescribeGameSessionDetailsOutput struct {
// A collection of properties for each game session that matches the request.
GameSessionDetails []types.GameSessionDetail
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeGameSessionDetailsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeGameSessionDetails{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeGameSessionDetails{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeGameSessionDetails(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
}
// DescribeGameSessionDetailsAPIClient is a client that implements the
// DescribeGameSessionDetails operation.
type DescribeGameSessionDetailsAPIClient interface {
DescribeGameSessionDetails(context.Context, *DescribeGameSessionDetailsInput, ...func(*Options)) (*DescribeGameSessionDetailsOutput, error)
}
var _ DescribeGameSessionDetailsAPIClient = (*Client)(nil)
// DescribeGameSessionDetailsPaginatorOptions is the paginator options for
// DescribeGameSessionDetails
type DescribeGameSessionDetailsPaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// DescribeGameSessionDetailsPaginator is a paginator for
// DescribeGameSessionDetails
type DescribeGameSessionDetailsPaginator struct {
options DescribeGameSessionDetailsPaginatorOptions
client DescribeGameSessionDetailsAPIClient
params *DescribeGameSessionDetailsInput
nextToken *string
firstPage bool
}
// NewDescribeGameSessionDetailsPaginator returns a new
// DescribeGameSessionDetailsPaginator
func NewDescribeGameSessionDetailsPaginator(client DescribeGameSessionDetailsAPIClient, params *DescribeGameSessionDetailsInput, optFns ...func(*DescribeGameSessionDetailsPaginatorOptions)) *DescribeGameSessionDetailsPaginator {
if params == nil {
params = &DescribeGameSessionDetailsInput{}
}
options := DescribeGameSessionDetailsPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeGameSessionDetailsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeGameSessionDetailsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeGameSessionDetails page.
func (p *DescribeGameSessionDetailsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeGameSessionDetailsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.DescribeGameSessionDetails(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opDescribeGameSessionDetails(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeGameSessionDetails",
}
}
| 266 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves information, including current status, about a game session placement
// request. To get game session placement details, specify the placement ID. This
// operation is not designed to be continually called to track game session status.
// This practice can cause you to exceed your API limit, which results in errors.
// Instead, you must configure configure an Amazon Simple Notification Service
// (SNS) topic to receive notifications from FlexMatch or queues. Continuously
// polling with DescribeGameSessionPlacement should only be used for games in
// development with low game session usage.
func (c *Client) DescribeGameSessionPlacement(ctx context.Context, params *DescribeGameSessionPlacementInput, optFns ...func(*Options)) (*DescribeGameSessionPlacementOutput, error) {
if params == nil {
params = &DescribeGameSessionPlacementInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeGameSessionPlacement", params, optFns, c.addOperationDescribeGameSessionPlacementMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeGameSessionPlacementOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeGameSessionPlacementInput struct {
// A unique identifier for a game session placement to retrieve.
//
// This member is required.
PlacementId *string
noSmithyDocumentSerde
}
type DescribeGameSessionPlacementOutput struct {
// Object that describes the requested game session placement.
GameSessionPlacement *types.GameSessionPlacement
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeGameSessionPlacementMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeGameSessionPlacement{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeGameSessionPlacement{}, 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 = addOpDescribeGameSessionPlacementValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeGameSessionPlacement(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
}
func newServiceMetadataMiddleware_opDescribeGameSessionPlacement(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeGameSessionPlacement",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves the properties for one or more game session queues. When requesting
// multiple queues, use the pagination parameters to retrieve results as a set of
// sequential pages. When specifying a list of queues, objects are returned only
// for queues that currently exist in the Region. Learn more View Your Queues (https://docs.aws.amazon.com/gamelift/latest/developerguide/queues-console.html)
func (c *Client) DescribeGameSessionQueues(ctx context.Context, params *DescribeGameSessionQueuesInput, optFns ...func(*Options)) (*DescribeGameSessionQueuesOutput, error) {
if params == nil {
params = &DescribeGameSessionQueuesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeGameSessionQueues", params, optFns, c.addOperationDescribeGameSessionQueuesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeGameSessionQueuesOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeGameSessionQueuesInput struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages. You can request up to 50 results.
Limit *int32
// A list of queue names to retrieve information for. You can use either the queue
// ID or ARN value. To request settings for all queues, leave this parameter empty.
Names []string
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, do not specify a value.
NextToken *string
noSmithyDocumentSerde
}
type DescribeGameSessionQueuesOutput struct {
// A collection of objects that describe the requested game session queues.
GameSessionQueues []types.GameSessionQueue
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeGameSessionQueuesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeGameSessionQueues{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeGameSessionQueues{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeGameSessionQueues(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
}
// DescribeGameSessionQueuesAPIClient is a client that implements the
// DescribeGameSessionQueues operation.
type DescribeGameSessionQueuesAPIClient interface {
DescribeGameSessionQueues(context.Context, *DescribeGameSessionQueuesInput, ...func(*Options)) (*DescribeGameSessionQueuesOutput, error)
}
var _ DescribeGameSessionQueuesAPIClient = (*Client)(nil)
// DescribeGameSessionQueuesPaginatorOptions is the paginator options for
// DescribeGameSessionQueues
type DescribeGameSessionQueuesPaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages. You can request up to 50 results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// DescribeGameSessionQueuesPaginator is a paginator for DescribeGameSessionQueues
type DescribeGameSessionQueuesPaginator struct {
options DescribeGameSessionQueuesPaginatorOptions
client DescribeGameSessionQueuesAPIClient
params *DescribeGameSessionQueuesInput
nextToken *string
firstPage bool
}
// NewDescribeGameSessionQueuesPaginator returns a new
// DescribeGameSessionQueuesPaginator
func NewDescribeGameSessionQueuesPaginator(client DescribeGameSessionQueuesAPIClient, params *DescribeGameSessionQueuesInput, optFns ...func(*DescribeGameSessionQueuesPaginatorOptions)) *DescribeGameSessionQueuesPaginator {
if params == nil {
params = &DescribeGameSessionQueuesInput{}
}
options := DescribeGameSessionQueuesPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeGameSessionQueuesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeGameSessionQueuesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeGameSessionQueues page.
func (p *DescribeGameSessionQueuesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeGameSessionQueuesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.DescribeGameSessionQueues(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opDescribeGameSessionQueues(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeGameSessionQueues",
}
}
| 232 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a set of one or more game sessions in a specific fleet location. You
// can optionally filter the results by current game session status. This operation
// can be used in the following ways:
// - To retrieve all game sessions that are currently running on all locations
// in a fleet, provide a fleet or alias ID, with an optional status filter. This
// approach returns all game sessions in the fleet's home Region and all remote
// locations.
// - To retrieve all game sessions that are currently running on a specific
// fleet location, provide a fleet or alias ID and a location name, with optional
// status filter. The location can be the fleet's home Region or any remote
// location.
// - To retrieve a specific game session, provide the game session ID. This
// approach looks for the game session ID in all fleets that reside in the Amazon
// Web Services Region defined in the request.
//
// Use the pagination parameters to retrieve results as a set of sequential pages.
// If successful, a GameSession object is returned for each game session that
// matches the request. This operation is not designed to be continually called to
// track game session status. This practice can cause you to exceed your API limit,
// which results in errors. Instead, you must configure an Amazon Simple
// Notification Service (SNS) topic to receive notifications from FlexMatch or
// queues. Continuously polling with DescribeGameSessions should only be used for
// games in development with low game session usage. Available in Amazon GameLift
// Local. Learn more Find a game session (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-client-api.html#gamelift-sdk-client-api-find)
// All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) DescribeGameSessions(ctx context.Context, params *DescribeGameSessionsInput, optFns ...func(*Options)) (*DescribeGameSessionsOutput, error) {
if params == nil {
params = &DescribeGameSessionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeGameSessions", params, optFns, c.addOperationDescribeGameSessionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeGameSessionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeGameSessionsInput struct {
// A unique identifier for the alias associated with the fleet to retrieve game
// sessions for. You can use either the alias ID or ARN value.
AliasId *string
// A unique identifier for the fleet to retrieve game sessions for. You can use
// either the fleet ID or ARN value.
FleetId *string
// A unique identifier for the game session to retrieve.
GameSessionId *string
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit *int32
// A fleet location to get game sessions for. You can specify a fleet's home
// Region or a remote location. Use the Amazon Web Services Region code format,
// such as us-west-2 .
Location *string
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, do not specify a value.
NextToken *string
// Game session status to filter results on. You can filter on the following
// states: ACTIVE , TERMINATED , ACTIVATING , and TERMINATING . The last two are
// transitory and used for only very brief periods of time.
StatusFilter *string
noSmithyDocumentSerde
}
type DescribeGameSessionsOutput struct {
// A collection of properties for each game session that matches the request.
GameSessions []types.GameSession
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeGameSessionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeGameSessions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeGameSessions{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeGameSessions(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
}
// DescribeGameSessionsAPIClient is a client that implements the
// DescribeGameSessions operation.
type DescribeGameSessionsAPIClient interface {
DescribeGameSessions(context.Context, *DescribeGameSessionsInput, ...func(*Options)) (*DescribeGameSessionsOutput, error)
}
var _ DescribeGameSessionsAPIClient = (*Client)(nil)
// DescribeGameSessionsPaginatorOptions is the paginator options for
// DescribeGameSessions
type DescribeGameSessionsPaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// DescribeGameSessionsPaginator is a paginator for DescribeGameSessions
type DescribeGameSessionsPaginator struct {
options DescribeGameSessionsPaginatorOptions
client DescribeGameSessionsAPIClient
params *DescribeGameSessionsInput
nextToken *string
firstPage bool
}
// NewDescribeGameSessionsPaginator returns a new DescribeGameSessionsPaginator
func NewDescribeGameSessionsPaginator(client DescribeGameSessionsAPIClient, params *DescribeGameSessionsInput, optFns ...func(*DescribeGameSessionsPaginatorOptions)) *DescribeGameSessionsPaginator {
if params == nil {
params = &DescribeGameSessionsInput{}
}
options := DescribeGameSessionsPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeGameSessionsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeGameSessionsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeGameSessions page.
func (p *DescribeGameSessionsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeGameSessionsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.DescribeGameSessions(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opDescribeGameSessions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeGameSessions",
}
}
| 269 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves information about a fleet's instances, including instance IDs,
// connection data, and status. This operation can be used in the following ways:
// - To get information on all instances that are deployed to a fleet's home
// Region, provide the fleet ID.
// - To get information on all instances that are deployed to a fleet's remote
// location, provide the fleet ID and location name.
// - To get information on a specific instance in a fleet, provide the fleet ID
// and instance ID.
//
// Use the pagination parameters to retrieve results as a set of sequential pages.
// If successful, an Instance object is returned for each requested instance.
// Instances are not returned in any particular order. Learn more Remotely Access
// Fleet Instances (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-remote-access.html)
// Debug Fleet Issues (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-creating-debug.html)
// Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) DescribeInstances(ctx context.Context, params *DescribeInstancesInput, optFns ...func(*Options)) (*DescribeInstancesOutput, error) {
if params == nil {
params = &DescribeInstancesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeInstances", params, optFns, c.addOperationDescribeInstancesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeInstancesOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeInstancesInput struct {
// A unique identifier for the fleet to retrieve instance information for. You can
// use either the fleet ID or ARN value.
//
// This member is required.
FleetId *string
// A unique identifier for an instance to retrieve. Specify an instance ID or
// leave blank to retrieve all instances in the fleet.
InstanceId *string
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit *int32
// The name of a location to retrieve instance information for, in the form of an
// Amazon Web Services Region code such as us-west-2 .
Location *string
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, do not specify a value.
NextToken *string
noSmithyDocumentSerde
}
type DescribeInstancesOutput struct {
// A collection of objects containing properties for each instance returned.
Instances []types.Instance
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeInstancesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeInstances{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeInstances{}, 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 = addOpDescribeInstancesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeInstances(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
}
// DescribeInstancesAPIClient is a client that implements the DescribeInstances
// operation.
type DescribeInstancesAPIClient interface {
DescribeInstances(context.Context, *DescribeInstancesInput, ...func(*Options)) (*DescribeInstancesOutput, error)
}
var _ DescribeInstancesAPIClient = (*Client)(nil)
// DescribeInstancesPaginatorOptions is the paginator options for DescribeInstances
type DescribeInstancesPaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// DescribeInstancesPaginator is a paginator for DescribeInstances
type DescribeInstancesPaginator struct {
options DescribeInstancesPaginatorOptions
client DescribeInstancesAPIClient
params *DescribeInstancesInput
nextToken *string
firstPage bool
}
// NewDescribeInstancesPaginator returns a new DescribeInstancesPaginator
func NewDescribeInstancesPaginator(client DescribeInstancesAPIClient, params *DescribeInstancesInput, optFns ...func(*DescribeInstancesPaginatorOptions)) *DescribeInstancesPaginator {
if params == nil {
params = &DescribeInstancesInput{}
}
options := DescribeInstancesPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeInstancesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeInstancesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeInstances page.
func (p *DescribeInstancesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeInstancesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.DescribeInstances(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opDescribeInstances(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeInstances",
}
}
| 254 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves one or more matchmaking tickets. Use this operation to retrieve
// ticket information, including--after a successful match is made--connection
// information for the resulting new game session. To request matchmaking tickets,
// provide a list of up to 10 ticket IDs. If the request is successful, a ticket
// object is returned for each requested ID that currently exists. This operation
// is not designed to be continually called to track matchmaking ticket status.
// This practice can cause you to exceed your API limit, which results in errors.
// Instead, as a best practice, set up an Amazon Simple Notification Service to
// receive notifications, and provide the topic ARN in the matchmaking
// configuration. Learn more Add FlexMatch to a game client (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-client.html)
// Set Up FlexMatch event notification (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-notification.html)
func (c *Client) DescribeMatchmaking(ctx context.Context, params *DescribeMatchmakingInput, optFns ...func(*Options)) (*DescribeMatchmakingOutput, error) {
if params == nil {
params = &DescribeMatchmakingInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeMatchmaking", params, optFns, c.addOperationDescribeMatchmakingMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeMatchmakingOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeMatchmakingInput struct {
// A unique identifier for a matchmaking ticket. You can include up to 10 ID
// values.
//
// This member is required.
TicketIds []string
noSmithyDocumentSerde
}
type DescribeMatchmakingOutput struct {
// A collection of existing matchmaking ticket objects matching the request.
TicketList []types.MatchmakingTicket
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeMatchmakingMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeMatchmaking{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeMatchmaking{}, 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 = addOpDescribeMatchmakingValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeMatchmaking(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
}
func newServiceMetadataMiddleware_opDescribeMatchmaking(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeMatchmaking",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves the details of FlexMatch matchmaking configurations. This operation
// offers the following options: (1) retrieve all matchmaking configurations, (2)
// retrieve configurations for a specified list, or (3) retrieve all configurations
// that use a specified rule set name. When requesting multiple items, use the
// pagination parameters to retrieve results as a set of sequential pages. If
// successful, a configuration is returned for each requested name. When specifying
// a list of names, only configurations that currently exist are returned. Learn
// more Setting up FlexMatch matchmakers (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/matchmaker-build.html)
func (c *Client) DescribeMatchmakingConfigurations(ctx context.Context, params *DescribeMatchmakingConfigurationsInput, optFns ...func(*Options)) (*DescribeMatchmakingConfigurationsOutput, error) {
if params == nil {
params = &DescribeMatchmakingConfigurationsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeMatchmakingConfigurations", params, optFns, c.addOperationDescribeMatchmakingConfigurationsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeMatchmakingConfigurationsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeMatchmakingConfigurationsInput struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages. This parameter is limited to 10.
Limit *int32
// A unique identifier for the matchmaking configuration(s) to retrieve. You can
// use either the configuration name or ARN value. To request all existing
// configurations, leave this parameter empty.
Names []string
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, do not specify a value.
NextToken *string
// A unique identifier for the matchmaking rule set. You can use either the rule
// set name or ARN value. Use this parameter to retrieve all matchmaking
// configurations that use this rule set.
RuleSetName *string
noSmithyDocumentSerde
}
type DescribeMatchmakingConfigurationsOutput struct {
// A collection of requested matchmaking configurations.
Configurations []types.MatchmakingConfiguration
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeMatchmakingConfigurationsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeMatchmakingConfigurations{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeMatchmakingConfigurations{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeMatchmakingConfigurations(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
}
// DescribeMatchmakingConfigurationsAPIClient is a client that implements the
// DescribeMatchmakingConfigurations operation.
type DescribeMatchmakingConfigurationsAPIClient interface {
DescribeMatchmakingConfigurations(context.Context, *DescribeMatchmakingConfigurationsInput, ...func(*Options)) (*DescribeMatchmakingConfigurationsOutput, error)
}
var _ DescribeMatchmakingConfigurationsAPIClient = (*Client)(nil)
// DescribeMatchmakingConfigurationsPaginatorOptions is the paginator options for
// DescribeMatchmakingConfigurations
type DescribeMatchmakingConfigurationsPaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages. This parameter is limited to 10.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// DescribeMatchmakingConfigurationsPaginator is a paginator for
// DescribeMatchmakingConfigurations
type DescribeMatchmakingConfigurationsPaginator struct {
options DescribeMatchmakingConfigurationsPaginatorOptions
client DescribeMatchmakingConfigurationsAPIClient
params *DescribeMatchmakingConfigurationsInput
nextToken *string
firstPage bool
}
// NewDescribeMatchmakingConfigurationsPaginator returns a new
// DescribeMatchmakingConfigurationsPaginator
func NewDescribeMatchmakingConfigurationsPaginator(client DescribeMatchmakingConfigurationsAPIClient, params *DescribeMatchmakingConfigurationsInput, optFns ...func(*DescribeMatchmakingConfigurationsPaginatorOptions)) *DescribeMatchmakingConfigurationsPaginator {
if params == nil {
params = &DescribeMatchmakingConfigurationsInput{}
}
options := DescribeMatchmakingConfigurationsPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeMatchmakingConfigurationsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeMatchmakingConfigurationsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeMatchmakingConfigurations page.
func (p *DescribeMatchmakingConfigurationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeMatchmakingConfigurationsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.DescribeMatchmakingConfigurations(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opDescribeMatchmakingConfigurations(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeMatchmakingConfigurations",
}
}
| 243 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves the details for FlexMatch matchmaking rule sets. You can request all
// existing rule sets for the Region, or provide a list of one or more rule set
// names. When requesting multiple items, use the pagination parameters to retrieve
// results as a set of sequential pages. If successful, a rule set is returned for
// each requested name. Learn more
// - Build a rule set (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-rulesets.html)
func (c *Client) DescribeMatchmakingRuleSets(ctx context.Context, params *DescribeMatchmakingRuleSetsInput, optFns ...func(*Options)) (*DescribeMatchmakingRuleSetsOutput, error) {
if params == nil {
params = &DescribeMatchmakingRuleSetsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeMatchmakingRuleSets", params, optFns, c.addOperationDescribeMatchmakingRuleSetsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeMatchmakingRuleSetsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeMatchmakingRuleSetsInput struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit *int32
// A list of one or more matchmaking rule set names to retrieve details for.
// (Note: The rule set name is different from the optional "name" field in the rule
// set body.) You can use either the rule set name or ARN value.
Names []string
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, do not specify a value.
NextToken *string
noSmithyDocumentSerde
}
type DescribeMatchmakingRuleSetsOutput struct {
// A collection of requested matchmaking rule set objects.
//
// This member is required.
RuleSets []types.MatchmakingRuleSet
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeMatchmakingRuleSetsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeMatchmakingRuleSets{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeMatchmakingRuleSets{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeMatchmakingRuleSets(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
}
// DescribeMatchmakingRuleSetsAPIClient is a client that implements the
// DescribeMatchmakingRuleSets operation.
type DescribeMatchmakingRuleSetsAPIClient interface {
DescribeMatchmakingRuleSets(context.Context, *DescribeMatchmakingRuleSetsInput, ...func(*Options)) (*DescribeMatchmakingRuleSetsOutput, error)
}
var _ DescribeMatchmakingRuleSetsAPIClient = (*Client)(nil)
// DescribeMatchmakingRuleSetsPaginatorOptions is the paginator options for
// DescribeMatchmakingRuleSets
type DescribeMatchmakingRuleSetsPaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// DescribeMatchmakingRuleSetsPaginator is a paginator for
// DescribeMatchmakingRuleSets
type DescribeMatchmakingRuleSetsPaginator struct {
options DescribeMatchmakingRuleSetsPaginatorOptions
client DescribeMatchmakingRuleSetsAPIClient
params *DescribeMatchmakingRuleSetsInput
nextToken *string
firstPage bool
}
// NewDescribeMatchmakingRuleSetsPaginator returns a new
// DescribeMatchmakingRuleSetsPaginator
func NewDescribeMatchmakingRuleSetsPaginator(client DescribeMatchmakingRuleSetsAPIClient, params *DescribeMatchmakingRuleSetsInput, optFns ...func(*DescribeMatchmakingRuleSetsPaginatorOptions)) *DescribeMatchmakingRuleSetsPaginator {
if params == nil {
params = &DescribeMatchmakingRuleSetsInput{}
}
options := DescribeMatchmakingRuleSetsPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeMatchmakingRuleSetsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeMatchmakingRuleSetsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeMatchmakingRuleSets page.
func (p *DescribeMatchmakingRuleSetsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeMatchmakingRuleSetsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.DescribeMatchmakingRuleSets(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opDescribeMatchmakingRuleSets(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeMatchmakingRuleSets",
}
}
| 238 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves properties for one or more player sessions. This action can be used
// in the following ways:
// - To retrieve a specific player session, provide the player session ID only.
// - To retrieve all player sessions in a game session, provide the game session
// ID only.
// - To retrieve all player sessions for a specific player, provide a player ID
// only.
//
// To request player sessions, specify either a player session ID, game session
// ID, or player ID. You can filter this request by player session status. Use the
// pagination parameters to retrieve results as a set of sequential pages. If
// successful, a PlayerSession object is returned for each session that matches
// the request. Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) DescribePlayerSessions(ctx context.Context, params *DescribePlayerSessionsInput, optFns ...func(*Options)) (*DescribePlayerSessionsOutput, error) {
if params == nil {
params = &DescribePlayerSessionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribePlayerSessions", params, optFns, c.addOperationDescribePlayerSessionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribePlayerSessionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribePlayerSessionsInput struct {
// A unique identifier for the game session to retrieve player sessions for.
GameSessionId *string
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages. If a player session ID is specified,
// this parameter is ignored.
Limit *int32
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, do not specify a value. If a player session ID
// is specified, this parameter is ignored.
NextToken *string
// A unique identifier for a player to retrieve player sessions for.
PlayerId *string
// A unique identifier for a player session to retrieve.
PlayerSessionId *string
// Player session status to filter results on. Note that when a PlayerSessionId or
// PlayerId is provided in a DescribePlayerSessions request, then the
// PlayerSessionStatusFilter has no effect on the response. Possible player session
// statuses include the following:
// - RESERVED -- The player session request has been received, but the player
// has not yet connected to the server process and/or been validated.
// - ACTIVE -- The player has been validated by the server process and is
// currently connected.
// - COMPLETED -- The player connection has been dropped.
// - TIMEDOUT -- A player session request was received, but the player did not
// connect and/or was not validated within the timeout limit (60 seconds).
PlayerSessionStatusFilter *string
noSmithyDocumentSerde
}
type DescribePlayerSessionsOutput struct {
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// A collection of objects containing properties for each player session that
// matches the request.
PlayerSessions []types.PlayerSession
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribePlayerSessionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribePlayerSessions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribePlayerSessions{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribePlayerSessions(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
}
// DescribePlayerSessionsAPIClient is a client that implements the
// DescribePlayerSessions operation.
type DescribePlayerSessionsAPIClient interface {
DescribePlayerSessions(context.Context, *DescribePlayerSessionsInput, ...func(*Options)) (*DescribePlayerSessionsOutput, error)
}
var _ DescribePlayerSessionsAPIClient = (*Client)(nil)
// DescribePlayerSessionsPaginatorOptions is the paginator options for
// DescribePlayerSessions
type DescribePlayerSessionsPaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages. If a player session ID is specified,
// this parameter is ignored.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// DescribePlayerSessionsPaginator is a paginator for DescribePlayerSessions
type DescribePlayerSessionsPaginator struct {
options DescribePlayerSessionsPaginatorOptions
client DescribePlayerSessionsAPIClient
params *DescribePlayerSessionsInput
nextToken *string
firstPage bool
}
// NewDescribePlayerSessionsPaginator returns a new DescribePlayerSessionsPaginator
func NewDescribePlayerSessionsPaginator(client DescribePlayerSessionsAPIClient, params *DescribePlayerSessionsInput, optFns ...func(*DescribePlayerSessionsPaginatorOptions)) *DescribePlayerSessionsPaginator {
if params == nil {
params = &DescribePlayerSessionsInput{}
}
options := DescribePlayerSessionsPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &DescribePlayerSessionsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribePlayerSessionsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribePlayerSessions page.
func (p *DescribePlayerSessionsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribePlayerSessionsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.DescribePlayerSessions(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opDescribePlayerSessions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribePlayerSessions",
}
}
| 262 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a fleet's runtime configuration settings. The runtime configuration
// tells Amazon GameLift which server processes to run (and how) on each instance
// in the fleet. To get the runtime configuration that is currently in forces for a
// fleet, provide the fleet ID. If successful, a RuntimeConfiguration object is
// returned for the requested fleet. If the requested fleet has been deleted, the
// result set is empty. Learn more Setting up Amazon GameLift fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
// Running multiple processes on a fleet (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-multiprocess.html)
func (c *Client) DescribeRuntimeConfiguration(ctx context.Context, params *DescribeRuntimeConfigurationInput, optFns ...func(*Options)) (*DescribeRuntimeConfigurationOutput, error) {
if params == nil {
params = &DescribeRuntimeConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeRuntimeConfiguration", params, optFns, c.addOperationDescribeRuntimeConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeRuntimeConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeRuntimeConfigurationInput struct {
// A unique identifier for the fleet to get the runtime configuration for. You can
// use either the fleet ID or ARN value.
//
// This member is required.
FleetId *string
noSmithyDocumentSerde
}
type DescribeRuntimeConfigurationOutput struct {
// Instructions that describe how server processes should be launched and
// maintained on each instance in the fleet.
RuntimeConfiguration *types.RuntimeConfiguration
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeRuntimeConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeRuntimeConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeRuntimeConfiguration{}, 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 = addOpDescribeRuntimeConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeRuntimeConfiguration(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
}
func newServiceMetadataMiddleware_opDescribeRuntimeConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeRuntimeConfiguration",
}
}
| 133 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves all scaling policies applied to a fleet. To get a fleet's scaling
// policies, specify the fleet ID. You can filter this request by policy status,
// such as to retrieve only active scaling policies. Use the pagination parameters
// to retrieve results as a set of sequential pages. If successful, set of
// ScalingPolicy objects is returned for the fleet. A fleet may have all of its
// scaling policies suspended. This operation does not affect the status of the
// scaling policies, which remains ACTIVE.
func (c *Client) DescribeScalingPolicies(ctx context.Context, params *DescribeScalingPoliciesInput, optFns ...func(*Options)) (*DescribeScalingPoliciesOutput, error) {
if params == nil {
params = &DescribeScalingPoliciesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeScalingPolicies", params, optFns, c.addOperationDescribeScalingPoliciesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeScalingPoliciesOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeScalingPoliciesInput struct {
// A unique identifier for the fleet for which to retrieve scaling policies. You
// can use either the fleet ID or ARN value.
//
// This member is required.
FleetId *string
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit *int32
// The fleet location. If you don't specify this value, the response contains the
// scaling policies of every location in the fleet.
Location *string
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, do not specify a value.
NextToken *string
// Scaling policy status to filter results on. A scaling policy is only in force
// when in an ACTIVE status.
// - ACTIVE -- The scaling policy is currently in force.
// - UPDATEREQUESTED -- A request to update the scaling policy has been
// received.
// - UPDATING -- A change is being made to the scaling policy.
// - DELETEREQUESTED -- A request to delete the scaling policy has been
// received.
// - DELETING -- The scaling policy is being deleted.
// - DELETED -- The scaling policy has been deleted.
// - ERROR -- An error occurred in creating the policy. It should be removed and
// recreated.
StatusFilter types.ScalingStatusType
noSmithyDocumentSerde
}
type DescribeScalingPoliciesOutput struct {
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// A collection of objects containing the scaling policies matching the request.
ScalingPolicies []types.ScalingPolicy
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeScalingPoliciesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeScalingPolicies{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeScalingPolicies{}, 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 = addOpDescribeScalingPoliciesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeScalingPolicies(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
}
// DescribeScalingPoliciesAPIClient is a client that implements the
// DescribeScalingPolicies operation.
type DescribeScalingPoliciesAPIClient interface {
DescribeScalingPolicies(context.Context, *DescribeScalingPoliciesInput, ...func(*Options)) (*DescribeScalingPoliciesOutput, error)
}
var _ DescribeScalingPoliciesAPIClient = (*Client)(nil)
// DescribeScalingPoliciesPaginatorOptions is the paginator options for
// DescribeScalingPolicies
type DescribeScalingPoliciesPaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// DescribeScalingPoliciesPaginator is a paginator for DescribeScalingPolicies
type DescribeScalingPoliciesPaginator struct {
options DescribeScalingPoliciesPaginatorOptions
client DescribeScalingPoliciesAPIClient
params *DescribeScalingPoliciesInput
nextToken *string
firstPage bool
}
// NewDescribeScalingPoliciesPaginator returns a new
// DescribeScalingPoliciesPaginator
func NewDescribeScalingPoliciesPaginator(client DescribeScalingPoliciesAPIClient, params *DescribeScalingPoliciesInput, optFns ...func(*DescribeScalingPoliciesPaginatorOptions)) *DescribeScalingPoliciesPaginator {
if params == nil {
params = &DescribeScalingPoliciesInput{}
}
options := DescribeScalingPoliciesPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeScalingPoliciesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeScalingPoliciesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeScalingPolicies page.
func (p *DescribeScalingPoliciesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeScalingPoliciesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.DescribeScalingPolicies(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opDescribeScalingPolicies(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeScalingPolicies",
}
}
| 258 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves properties for a Realtime script. To request a script record, specify
// the script ID. If successful, an object containing the script properties is
// returned. Learn more Amazon GameLift Realtime Servers (https://docs.aws.amazon.com/gamelift/latest/developerguide/realtime-intro.html)
// Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) DescribeScript(ctx context.Context, params *DescribeScriptInput, optFns ...func(*Options)) (*DescribeScriptOutput, error) {
if params == nil {
params = &DescribeScriptInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeScript", params, optFns, c.addOperationDescribeScriptMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeScriptOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeScriptInput struct {
// A unique identifier for the Realtime script to retrieve properties for. You can
// use either the script ID or ARN value.
//
// This member is required.
ScriptId *string
noSmithyDocumentSerde
}
type DescribeScriptOutput struct {
// A set of properties describing the requested script.
Script *types.Script
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeScriptMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeScript{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeScript{}, 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 = addOpDescribeScriptValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeScript(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
}
func newServiceMetadataMiddleware_opDescribeScript(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeScript",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves valid VPC peering authorizations that are pending for the Amazon Web
// Services account. This operation returns all VPC peering authorizations and
// requests for peering. This includes those initiated and received by this
// account. Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) DescribeVpcPeeringAuthorizations(ctx context.Context, params *DescribeVpcPeeringAuthorizationsInput, optFns ...func(*Options)) (*DescribeVpcPeeringAuthorizationsOutput, error) {
if params == nil {
params = &DescribeVpcPeeringAuthorizationsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeVpcPeeringAuthorizations", params, optFns, c.addOperationDescribeVpcPeeringAuthorizationsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeVpcPeeringAuthorizationsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeVpcPeeringAuthorizationsInput struct {
noSmithyDocumentSerde
}
type DescribeVpcPeeringAuthorizationsOutput struct {
// A collection of objects that describe all valid VPC peering operations for the
// current Amazon Web Services account.
VpcPeeringAuthorizations []types.VpcPeeringAuthorization
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeVpcPeeringAuthorizationsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeVpcPeeringAuthorizations{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeVpcPeeringAuthorizations{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeVpcPeeringAuthorizations(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
}
func newServiceMetadataMiddleware_opDescribeVpcPeeringAuthorizations(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeVpcPeeringAuthorizations",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves information on VPC peering connections. Use this operation to get
// peering information for all fleets or for one specific fleet ID. To retrieve
// connection information, call this operation from the Amazon Web Services account
// that is used to manage the Amazon GameLift fleets. Specify a fleet ID or leave
// the parameter empty to retrieve all connection records. If successful, the
// retrieved information includes both active and pending connections. Active
// connections identify the IpV4 CIDR block that the VPC uses to connect. Related
// actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) DescribeVpcPeeringConnections(ctx context.Context, params *DescribeVpcPeeringConnectionsInput, optFns ...func(*Options)) (*DescribeVpcPeeringConnectionsOutput, error) {
if params == nil {
params = &DescribeVpcPeeringConnectionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeVpcPeeringConnections", params, optFns, c.addOperationDescribeVpcPeeringConnectionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeVpcPeeringConnectionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeVpcPeeringConnectionsInput struct {
// A unique identifier for the fleet. You can use either the fleet ID or ARN value.
FleetId *string
noSmithyDocumentSerde
}
type DescribeVpcPeeringConnectionsOutput struct {
// A collection of VPC peering connection records that match the request.
VpcPeeringConnections []types.VpcPeeringConnection
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeVpcPeeringConnectionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeVpcPeeringConnections{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeVpcPeeringConnections{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeVpcPeeringConnections(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
}
func newServiceMetadataMiddleware_opDescribeVpcPeeringConnections(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "DescribeVpcPeeringConnections",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Requests remote access to a fleet instance. Remote access is useful for
// debugging, gathering benchmarking data, or observing activity in real time. To
// remotely access an instance, you need credentials that match the operating
// system of the instance. For a Windows instance, Amazon GameLift returns a user
// name and password as strings for use with a Windows Remote Desktop client. For a
// Linux instance, Amazon GameLift returns a user name and RSA private key, also as
// strings, for use with an SSH client. The private key must be saved in the proper
// format to a .pem file before using. If you're making this request using the
// CLI, saving the secret can be handled as part of the GetInstanceAccess request,
// as shown in one of the examples for this operation. To request access to a
// specific instance, specify the IDs of both the instance and the fleet it belongs
// to. Learn more Remotely Access Fleet Instances (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-remote-access.html)
// Debug Fleet Issues (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-creating-debug.html)
func (c *Client) GetComputeAccess(ctx context.Context, params *GetComputeAccessInput, optFns ...func(*Options)) (*GetComputeAccessOutput, error) {
if params == nil {
params = &GetComputeAccessInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetComputeAccess", params, optFns, c.addOperationGetComputeAccessMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetComputeAccessOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetComputeAccessInput struct {
// The name of the compute resource you are requesting credentials for.
//
// This member is required.
ComputeName *string
// A unique identifier for the fleet that the compute resource is registered to.
//
// This member is required.
FleetId *string
noSmithyDocumentSerde
}
type GetComputeAccessOutput struct {
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift compute resource and uniquely identifies
// it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::compute/compute-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 .
ComputeArn *string
// The name of the compute resource you requested credentials for.
ComputeName *string
// The access credentials for the compute resource.
Credentials *types.AwsCredentials
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift fleet resource and uniquely identifies
// it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 .
FleetArn *string
// The fleet ID of compute resource.
FleetId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetComputeAccessMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetComputeAccess{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetComputeAccess{}, 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 = addOpGetComputeAccessValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetComputeAccess(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
}
func newServiceMetadataMiddleware_opGetComputeAccess(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "GetComputeAccess",
}
}
| 160 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Requests an authentication token from Amazon GameLift. The authentication token
// is used by your game server to authenticate with Amazon GameLift. Each
// authentication token has an expiration time. To continue using the compute
// resource to host your game server, regularly retrieve a new authorization token.
func (c *Client) GetComputeAuthToken(ctx context.Context, params *GetComputeAuthTokenInput, optFns ...func(*Options)) (*GetComputeAuthTokenOutput, error) {
if params == nil {
params = &GetComputeAuthTokenInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetComputeAuthToken", params, optFns, c.addOperationGetComputeAuthTokenMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetComputeAuthTokenOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetComputeAuthTokenInput struct {
// The name of the compute resource you are requesting the authentication token
// for.
//
// This member is required.
ComputeName *string
// A unique identifier for the fleet that the compute is registered to.
//
// This member is required.
FleetId *string
noSmithyDocumentSerde
}
type GetComputeAuthTokenOutput struct {
// The authentication token that your game server uses to authenticate with Amazon
// GameLift.
AuthToken *string
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift compute resource and uniquely identifies
// it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::compute/compute-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912
ComputeArn *string
// The name of the compute resource you are requesting the authentication token
// for.
ComputeName *string
// The amount of time until the authentication token is no longer valid. To
// continue using the compute resource for game server hosting, renew the
// authentication token by using this operation again.
ExpirationTimestamp *time.Time
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift fleet resource and uniquely identifies
// it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 .
FleetArn *string
// A unique identifier for the fleet that the compute is registered to.
FleetId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetComputeAuthTokenMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetComputeAuthToken{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetComputeAuthToken{}, 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 = addOpGetComputeAuthTokenValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetComputeAuthToken(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
}
func newServiceMetadataMiddleware_opGetComputeAuthToken(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "GetComputeAuthToken",
}
}
| 159 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves the location of stored game session logs for a specified game session
// on Amazon GameLift managed fleets. When a game session is terminated, Amazon
// GameLift automatically stores the logs in Amazon S3 and retains them for 14
// days. Use this URL to download the logs. See the Amazon Web Services Service
// Limits (https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#limits_gamelift)
// page for maximum log file sizes. Log files that exceed this limit are not saved.
// All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) GetGameSessionLogUrl(ctx context.Context, params *GetGameSessionLogUrlInput, optFns ...func(*Options)) (*GetGameSessionLogUrlOutput, error) {
if params == nil {
params = &GetGameSessionLogUrlInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetGameSessionLogUrl", params, optFns, c.addOperationGetGameSessionLogUrlMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetGameSessionLogUrlOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetGameSessionLogUrlInput struct {
// A unique identifier for the game session to get logs for.
//
// This member is required.
GameSessionId *string
noSmithyDocumentSerde
}
type GetGameSessionLogUrlOutput struct {
// Location of the requested game session logs, available for download. This URL
// is valid for 15 minutes, after which S3 will reject any download request using
// this URL. You can request a new URL any time within the 14-day period that the
// logs are retained.
PreSignedUrl *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetGameSessionLogUrlMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetGameSessionLogUrl{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetGameSessionLogUrl{}, 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 = addOpGetGameSessionLogUrlValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetGameSessionLogUrl(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
}
func newServiceMetadataMiddleware_opGetGameSessionLogUrl(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "GetGameSessionLogUrl",
}
}
| 133 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Requests remote access to a fleet instance. Remote access is useful for
// debugging, gathering benchmarking data, or observing activity in real time. To
// remotely access an instance, you need credentials that match the operating
// system of the instance. For a Windows instance, Amazon GameLift returns a user
// name and password as strings for use with a Windows Remote Desktop client. For a
// Linux instance, Amazon GameLift returns a user name and RSA private key, also as
// strings, for use with an SSH client. The private key must be saved in the proper
// format to a .pem file before using. If you're making this request using the
// CLI, saving the secret can be handled as part of the GetInstanceAccess request,
// as shown in one of the examples for this operation. To request access to a
// specific instance, specify the IDs of both the instance and the fleet it belongs
// to. You can retrieve a fleet's instance IDs by calling DescribeInstances (https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeInstances.html)
// . Learn more Remotely Access Fleet Instances (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-remote-access.html)
// Debug Fleet Issues (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-creating-debug.html)
// Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) GetInstanceAccess(ctx context.Context, params *GetInstanceAccessInput, optFns ...func(*Options)) (*GetInstanceAccessOutput, error) {
if params == nil {
params = &GetInstanceAccessInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetInstanceAccess", params, optFns, c.addOperationGetInstanceAccessMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetInstanceAccessOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetInstanceAccessInput struct {
// A unique identifier for the fleet that contains the instance you want access
// to. You can use either the fleet ID or ARN value. The fleet can be in any of the
// following statuses: ACTIVATING , ACTIVE , or ERROR . Fleets with an ERROR
// status may be accessible for a short time before they are deleted.
//
// This member is required.
FleetId *string
// A unique identifier for the instance you want to get access to. You can access
// an instance in any status.
//
// This member is required.
InstanceId *string
noSmithyDocumentSerde
}
type GetInstanceAccessOutput struct {
// The connection information for a fleet instance, including IP address and
// access credentials.
InstanceAccess *types.InstanceAccess
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetInstanceAccessMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetInstanceAccess{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetInstanceAccess{}, 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 = addOpGetInstanceAccessValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetInstanceAccess(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
}
func newServiceMetadataMiddleware_opGetInstanceAccess(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "GetInstanceAccess",
}
}
| 149 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves all aliases for this Amazon Web Services account. You can filter the
// result set by alias name and/or routing strategy type. Use the pagination
// parameters to retrieve results in sequential pages. Returned aliases are not
// listed in any particular order. Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) ListAliases(ctx context.Context, params *ListAliasesInput, optFns ...func(*Options)) (*ListAliasesOutput, error) {
if params == nil {
params = &ListAliasesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListAliases", params, optFns, c.addOperationListAliasesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListAliasesOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListAliasesInput struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit *int32
// A descriptive label that is associated with an alias. Alias names do not need
// to be unique.
Name *string
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, do not specify a value.
NextToken *string
// The routing type to filter results on. Use this parameter to retrieve only
// aliases with a certain routing type. To retrieve all aliases, leave this
// parameter empty. Possible routing types include the following:
// - SIMPLE -- The alias resolves to one specific fleet. Use this type when
// routing to active fleets.
// - TERMINAL -- The alias does not resolve to a fleet but instead can be used
// to display a message to the user. A terminal alias throws a
// TerminalRoutingStrategyException with the RoutingStrategy (https://docs.aws.amazon.com/gamelift/latest/apireference/API_RoutingStrategy.html)
// message embedded.
RoutingStrategyType types.RoutingStrategyType
noSmithyDocumentSerde
}
type ListAliasesOutput struct {
// A collection of alias resources that match the request parameters.
Aliases []types.Alias
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListAliasesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListAliases{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListAliases{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opListAliases(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
}
// ListAliasesAPIClient is a client that implements the ListAliases operation.
type ListAliasesAPIClient interface {
ListAliases(context.Context, *ListAliasesInput, ...func(*Options)) (*ListAliasesOutput, error)
}
var _ ListAliasesAPIClient = (*Client)(nil)
// ListAliasesPaginatorOptions is the paginator options for ListAliases
type ListAliasesPaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListAliasesPaginator is a paginator for ListAliases
type ListAliasesPaginator struct {
options ListAliasesPaginatorOptions
client ListAliasesAPIClient
params *ListAliasesInput
nextToken *string
firstPage bool
}
// NewListAliasesPaginator returns a new ListAliasesPaginator
func NewListAliasesPaginator(client ListAliasesAPIClient, params *ListAliasesInput, optFns ...func(*ListAliasesPaginatorOptions)) *ListAliasesPaginator {
if params == nil {
params = &ListAliasesInput{}
}
options := ListAliasesPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &ListAliasesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListAliasesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListAliases page.
func (p *ListAliasesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListAliasesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.ListAliases(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListAliases(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "ListAliases",
}
}
| 240 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves build resources for all builds associated with the Amazon Web
// Services account in use. You can limit results to builds that are in a specific
// status by using the Status parameter. Use the pagination parameters to retrieve
// results in a set of sequential pages. Build resources are not listed in any
// particular order. Learn more Upload a Custom Server Build (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-build-intro.html)
// All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) ListBuilds(ctx context.Context, params *ListBuildsInput, optFns ...func(*Options)) (*ListBuildsOutput, error) {
if params == nil {
params = &ListBuildsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListBuilds", params, optFns, c.addOperationListBuildsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListBuildsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListBuildsInput struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit *int32
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, don't specify a value.
NextToken *string
// Build status to filter results by. To retrieve all builds, leave this parameter
// empty. Possible build statuses include the following:
// - INITIALIZED -- A new build has been defined, but no files have been
// uploaded. You cannot create fleets for builds that are in this status. When a
// build is successfully created, the build status is set to this value.
// - READY -- The game build has been successfully uploaded. You can now create
// new fleets for this build.
// - FAILED -- The game build upload failed. You cannot create new fleets for
// this build.
Status types.BuildStatus
noSmithyDocumentSerde
}
type ListBuildsOutput struct {
// A collection of build resources that match the request.
Builds []types.Build
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListBuildsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListBuilds{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListBuilds{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opListBuilds(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
}
// ListBuildsAPIClient is a client that implements the ListBuilds operation.
type ListBuildsAPIClient interface {
ListBuilds(context.Context, *ListBuildsInput, ...func(*Options)) (*ListBuildsOutput, error)
}
var _ ListBuildsAPIClient = (*Client)(nil)
// ListBuildsPaginatorOptions is the paginator options for ListBuilds
type ListBuildsPaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListBuildsPaginator is a paginator for ListBuilds
type ListBuildsPaginator struct {
options ListBuildsPaginatorOptions
client ListBuildsAPIClient
params *ListBuildsInput
nextToken *string
firstPage bool
}
// NewListBuildsPaginator returns a new ListBuildsPaginator
func NewListBuildsPaginator(client ListBuildsAPIClient, params *ListBuildsInput, optFns ...func(*ListBuildsPaginatorOptions)) *ListBuildsPaginator {
if params == nil {
params = &ListBuildsInput{}
}
options := ListBuildsPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &ListBuildsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListBuildsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListBuilds page.
func (p *ListBuildsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListBuildsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.ListBuilds(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListBuilds(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "ListBuilds",
}
}
| 238 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves all compute resources registered to a fleet in your Amazon Web
// Services account. You can filter the result set by location.
func (c *Client) ListCompute(ctx context.Context, params *ListComputeInput, optFns ...func(*Options)) (*ListComputeOutput, error) {
if params == nil {
params = &ListComputeInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListCompute", params, optFns, c.addOperationListComputeMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListComputeOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListComputeInput struct {
// A unique identifier for the fleet the compute resources are registered to.
//
// This member is required.
FleetId *string
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit *int32
// The name of the custom location that the compute resources are assigned to.
Location *string
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, do not specify a value.
NextToken *string
noSmithyDocumentSerde
}
type ListComputeOutput struct {
// A list of compute resources registered to the fleet you specified.
ComputeList []types.Compute
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListComputeMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListCompute{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListCompute{}, 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 = addOpListComputeValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListCompute(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
}
// ListComputeAPIClient is a client that implements the ListCompute operation.
type ListComputeAPIClient interface {
ListCompute(context.Context, *ListComputeInput, ...func(*Options)) (*ListComputeOutput, error)
}
var _ ListComputeAPIClient = (*Client)(nil)
// ListComputePaginatorOptions is the paginator options for ListCompute
type ListComputePaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListComputePaginator is a paginator for ListCompute
type ListComputePaginator struct {
options ListComputePaginatorOptions
client ListComputeAPIClient
params *ListComputeInput
nextToken *string
firstPage bool
}
// NewListComputePaginator returns a new ListComputePaginator
func NewListComputePaginator(client ListComputeAPIClient, params *ListComputeInput, optFns ...func(*ListComputePaginatorOptions)) *ListComputePaginator {
if params == nil {
params = &ListComputeInput{}
}
options := ListComputePaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &ListComputePaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListComputePaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListCompute page.
func (p *ListComputePaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListComputeOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.ListCompute(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListCompute(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "ListCompute",
}
}
| 234 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a collection of fleet resources in an Amazon Web Services Region. You
// can call this operation to get fleets in a previously selected default Region
// (see
// https://docs.aws.amazon.com/credref/latest/refdocs/setting-global-region.html (https://docs.aws.amazon.com/credref/latest/refdocs/setting-global-region.html)
// or specify a Region in your request. You can filter the result set to find only
// those fleets that are deployed with a specific build or script. For fleets that
// have multiple locations, this operation retrieves fleets based on their home
// Region only. This operation can be used in the following ways:
// - To get a list of all fleets in a Region, don't provide a build or script
// identifier.
// - To get a list of all fleets where a specific custom game build is deployed,
// provide the build ID.
// - To get a list of all Realtime Servers fleets with a specific configuration
// script, provide the script ID.
//
// Use the pagination parameters to retrieve results as a set of sequential pages.
// If successful, a list of fleet IDs that match the request parameters is
// returned. A NextToken value is also returned if there are more result pages to
// retrieve. Fleet resources are not listed in a particular order. Learn more
// Setting up Amazon GameLift fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
func (c *Client) ListFleets(ctx context.Context, params *ListFleetsInput, optFns ...func(*Options)) (*ListFleetsOutput, error) {
if params == nil {
params = &ListFleetsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListFleets", params, optFns, c.addOperationListFleetsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListFleetsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListFleetsInput struct {
// A unique identifier for the build to request fleets for. Use this parameter to
// return only fleets using a specified build. Use either the build ID or ARN
// value.
BuildId *string
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit *int32
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, do not specify a value.
NextToken *string
// A unique identifier for the Realtime script to request fleets for. Use this
// parameter to return only fleets using a specified script. Use either the script
// ID or ARN value.
ScriptId *string
noSmithyDocumentSerde
}
type ListFleetsOutput struct {
// A set of fleet IDs that match the list request.
FleetIds []string
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListFleetsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListFleets{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListFleets{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opListFleets(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
}
// ListFleetsAPIClient is a client that implements the ListFleets operation.
type ListFleetsAPIClient interface {
ListFleets(context.Context, *ListFleetsInput, ...func(*Options)) (*ListFleetsOutput, error)
}
var _ ListFleetsAPIClient = (*Client)(nil)
// ListFleetsPaginatorOptions is the paginator options for ListFleets
type ListFleetsPaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListFleetsPaginator is a paginator for ListFleets
type ListFleetsPaginator struct {
options ListFleetsPaginatorOptions
client ListFleetsAPIClient
params *ListFleetsInput
nextToken *string
firstPage bool
}
// NewListFleetsPaginator returns a new ListFleetsPaginator
func NewListFleetsPaginator(client ListFleetsAPIClient, params *ListFleetsInput, optFns ...func(*ListFleetsPaginatorOptions)) *ListFleetsPaginator {
if params == nil {
params = &ListFleetsInput{}
}
options := ListFleetsPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &ListFleetsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListFleetsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListFleets page.
func (p *ListFleetsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListFleetsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.ListFleets(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListFleets(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "ListFleets",
}
}
| 250 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists a game server groups.
func (c *Client) ListGameServerGroups(ctx context.Context, params *ListGameServerGroupsInput, optFns ...func(*Options)) (*ListGameServerGroupsOutput, error) {
if params == nil {
params = &ListGameServerGroupsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListGameServerGroups", params, optFns, c.addOperationListGameServerGroupsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListGameServerGroupsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListGameServerGroupsInput struct {
// The game server groups' limit.
Limit *int32
// Specify the pagination token from a previous request to retrieve the next page
// of results.
NextToken *string
noSmithyDocumentSerde
}
type ListGameServerGroupsOutput struct {
// The game server groups' game server groups.
GameServerGroups []types.GameServerGroup
// Specify the pagination token from a previous request to retrieve the next page
// of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListGameServerGroupsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListGameServerGroups{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListGameServerGroups{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opListGameServerGroups(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
}
// ListGameServerGroupsAPIClient is a client that implements the
// ListGameServerGroups operation.
type ListGameServerGroupsAPIClient interface {
ListGameServerGroups(context.Context, *ListGameServerGroupsInput, ...func(*Options)) (*ListGameServerGroupsOutput, error)
}
var _ ListGameServerGroupsAPIClient = (*Client)(nil)
// ListGameServerGroupsPaginatorOptions is the paginator options for
// ListGameServerGroups
type ListGameServerGroupsPaginatorOptions struct {
// The game server groups' limit.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListGameServerGroupsPaginator is a paginator for ListGameServerGroups
type ListGameServerGroupsPaginator struct {
options ListGameServerGroupsPaginatorOptions
client ListGameServerGroupsAPIClient
params *ListGameServerGroupsInput
nextToken *string
firstPage bool
}
// NewListGameServerGroupsPaginator returns a new ListGameServerGroupsPaginator
func NewListGameServerGroupsPaginator(client ListGameServerGroupsAPIClient, params *ListGameServerGroupsInput, optFns ...func(*ListGameServerGroupsPaginatorOptions)) *ListGameServerGroupsPaginator {
if params == nil {
params = &ListGameServerGroupsInput{}
}
options := ListGameServerGroupsPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &ListGameServerGroupsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListGameServerGroupsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListGameServerGroups page.
func (p *ListGameServerGroupsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListGameServerGroupsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.ListGameServerGroups(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListGameServerGroups(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "ListGameServerGroups",
}
}
| 220 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// This operation is used with the Amazon GameLift FleetIQ solution and game
// server groups. Retrieves information on all game servers that are currently
// active in a specified game server group. You can opt to sort the list by game
// server age. Use the pagination parameters to retrieve results in a set of
// sequential segments. Learn more Amazon GameLift FleetIQ Guide (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
func (c *Client) ListGameServers(ctx context.Context, params *ListGameServersInput, optFns ...func(*Options)) (*ListGameServersOutput, error) {
if params == nil {
params = &ListGameServersInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListGameServers", params, optFns, c.addOperationListGameServersMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListGameServersOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListGameServersInput struct {
// An identifier for the game server group to retrieve a list of game servers
// from. Use either the name or ARN value.
//
// This member is required.
GameServerGroupName *string
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit *int32
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, do not specify a value.
NextToken *string
// Indicates how to sort the returned data based on game server registration
// timestamp. Use ASCENDING to retrieve oldest game servers first, or use
// DESCENDING to retrieve newest game servers first. If this parameter is left
// empty, game servers are returned in no particular order.
SortOrder types.SortOrder
noSmithyDocumentSerde
}
type ListGameServersOutput struct {
// A collection of game server objects that match the request.
GameServers []types.GameServer
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListGameServersMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListGameServers{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListGameServers{}, 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 = addOpListGameServersValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListGameServers(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
}
// ListGameServersAPIClient is a client that implements the ListGameServers
// operation.
type ListGameServersAPIClient interface {
ListGameServers(context.Context, *ListGameServersInput, ...func(*Options)) (*ListGameServersOutput, error)
}
var _ ListGameServersAPIClient = (*Client)(nil)
// ListGameServersPaginatorOptions is the paginator options for ListGameServers
type ListGameServersPaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListGameServersPaginator is a paginator for ListGameServers
type ListGameServersPaginator struct {
options ListGameServersPaginatorOptions
client ListGameServersAPIClient
params *ListGameServersInput
nextToken *string
firstPage bool
}
// NewListGameServersPaginator returns a new ListGameServersPaginator
func NewListGameServersPaginator(client ListGameServersAPIClient, params *ListGameServersInput, optFns ...func(*ListGameServersPaginatorOptions)) *ListGameServersPaginator {
if params == nil {
params = &ListGameServersInput{}
}
options := ListGameServersPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &ListGameServersPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListGameServersPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListGameServers page.
func (p *ListGameServersPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListGameServersOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.ListGameServers(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListGameServers(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "ListGameServers",
}
}
| 242 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all custom and Amazon Web Services locations.
func (c *Client) ListLocations(ctx context.Context, params *ListLocationsInput, optFns ...func(*Options)) (*ListLocationsOutput, error) {
if params == nil {
params = &ListLocationsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListLocations", params, optFns, c.addOperationListLocationsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListLocationsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListLocationsInput struct {
// Filters the list for AWS or CUSTOM locations.
Filters []types.LocationFilter
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit *int32
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, do not specify a value.
NextToken *string
noSmithyDocumentSerde
}
type ListLocationsOutput struct {
// A collection of locations.
Locations []types.LocationModel
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListLocationsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListLocations{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListLocations{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opListLocations(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
}
// ListLocationsAPIClient is a client that implements the ListLocations operation.
type ListLocationsAPIClient interface {
ListLocations(context.Context, *ListLocationsInput, ...func(*Options)) (*ListLocationsOutput, error)
}
var _ ListLocationsAPIClient = (*Client)(nil)
// ListLocationsPaginatorOptions is the paginator options for ListLocations
type ListLocationsPaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListLocationsPaginator is a paginator for ListLocations
type ListLocationsPaginator struct {
options ListLocationsPaginatorOptions
client ListLocationsAPIClient
params *ListLocationsInput
nextToken *string
firstPage bool
}
// NewListLocationsPaginator returns a new ListLocationsPaginator
func NewListLocationsPaginator(client ListLocationsAPIClient, params *ListLocationsInput, optFns ...func(*ListLocationsPaginatorOptions)) *ListLocationsPaginator {
if params == nil {
params = &ListLocationsInput{}
}
options := ListLocationsPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &ListLocationsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListLocationsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListLocations page.
func (p *ListLocationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListLocationsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.ListLocations(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListLocations(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "ListLocations",
}
}
| 225 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves script records for all Realtime scripts that are associated with the
// Amazon Web Services account in use. Learn more Amazon GameLift Realtime Servers (https://docs.aws.amazon.com/gamelift/latest/developerguide/realtime-intro.html)
// Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) ListScripts(ctx context.Context, params *ListScriptsInput, optFns ...func(*Options)) (*ListScriptsOutput, error) {
if params == nil {
params = &ListScriptsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListScripts", params, optFns, c.addOperationListScriptsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListScriptsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListScriptsInput struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit *int32
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, don't specify a value.
NextToken *string
noSmithyDocumentSerde
}
type ListScriptsOutput struct {
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// A set of properties describing the requested script.
Scripts []types.Script
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListScriptsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListScripts{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListScripts{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opListScripts(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
}
// ListScriptsAPIClient is a client that implements the ListScripts operation.
type ListScriptsAPIClient interface {
ListScripts(context.Context, *ListScriptsInput, ...func(*Options)) (*ListScriptsOutput, error)
}
var _ ListScriptsAPIClient = (*Client)(nil)
// ListScriptsPaginatorOptions is the paginator options for ListScripts
type ListScriptsPaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListScriptsPaginator is a paginator for ListScripts
type ListScriptsPaginator struct {
options ListScriptsPaginatorOptions
client ListScriptsAPIClient
params *ListScriptsInput
nextToken *string
firstPage bool
}
// NewListScriptsPaginator returns a new ListScriptsPaginator
func NewListScriptsPaginator(client ListScriptsAPIClient, params *ListScriptsInput, optFns ...func(*ListScriptsPaginatorOptions)) *ListScriptsPaginator {
if params == nil {
params = &ListScriptsInput{}
}
options := ListScriptsPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &ListScriptsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListScriptsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListScripts page.
func (p *ListScriptsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListScriptsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.ListScripts(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListScripts(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "ListScripts",
}
}
| 224 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves all tags assigned to a Amazon GameLift resource. Use resource tags to
// organize Amazon Web Services resources for a range of purposes. This operation
// handles the permissions necessary to manage tags for Amazon GameLift resources
// that support tagging. To list tags for a resource, specify the unique ARN value
// for the resource. Learn more Tagging Amazon Web Services Resources (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html)
// in the Amazon Web Services General Reference Amazon Web Services Tagging
// Strategies (http://aws.amazon.com/answers/account-management/aws-tagging-strategies/)
// Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) ListTagsForResource(ctx context.Context, params *ListTagsForResourceInput, optFns ...func(*Options)) (*ListTagsForResourceOutput, error) {
if params == nil {
params = &ListTagsForResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListTagsForResource", params, optFns, c.addOperationListTagsForResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListTagsForResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListTagsForResourceInput struct {
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that uniquely identifies the Amazon GameLift resource that you want to
// retrieve tags for. Amazon GameLift includes resource ARNs in the data object for
// the resource. You can retrieve the ARN by calling a List or Describe operation
// for the resource type.
//
// This member is required.
ResourceARN *string
noSmithyDocumentSerde
}
type ListTagsForResourceOutput struct {
// The collection of tags assigned to the resource.
Tags []types.Tag
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListTagsForResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListTagsForResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListTagsForResource{}, 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 = addOpListTagsForResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListTagsForResource(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
}
func newServiceMetadataMiddleware_opListTagsForResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "ListTagsForResource",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates or updates a scaling policy for a fleet. Scaling policies are used to
// automatically scale a fleet's hosting capacity to meet player demand. An active
// scaling policy instructs Amazon GameLift to track a fleet metric and
// automatically change the fleet's capacity when a certain threshold is reached.
// There are two types of scaling policies: target-based and rule-based. Use a
// target-based policy to quickly and efficiently manage fleet scaling; this option
// is the most commonly used. Use rule-based policies when you need to exert
// fine-grained control over auto-scaling. Fleets can have multiple scaling
// policies of each type in force at the same time; you can have one target-based
// policy, one or multiple rule-based scaling policies, or both. We recommend
// caution, however, because multiple auto-scaling policies can have unintended
// consequences. Learn more about how to work with auto-scaling in Set Up Fleet
// Automatic Scaling (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-autoscaling.html)
// . Target-based policy A target-based policy tracks a single metric:
// PercentAvailableGameSessions. This metric tells us how much of a fleet's hosting
// capacity is ready to host game sessions but is not currently in use. This is the
// fleet's buffer; it measures the additional player demand that the fleet could
// handle at current capacity. With a target-based policy, you set your ideal
// buffer size and leave it to Amazon GameLift to take whatever action is needed to
// maintain that target. For example, you might choose to maintain a 10% buffer for
// a fleet that has the capacity to host 100 simultaneous game sessions. This
// policy tells Amazon GameLift to take action whenever the fleet's available
// capacity falls below or rises above 10 game sessions. Amazon GameLift will start
// new instances or stop unused instances in order to return to the 10% buffer. To
// create or update a target-based policy, specify a fleet ID and name, and set the
// policy type to "TargetBased". Specify the metric to track
// (PercentAvailableGameSessions) and reference a TargetConfiguration object with
// your desired buffer value. Exclude all other parameters. On a successful
// request, the policy name is returned. The scaling policy is automatically in
// force as soon as it's successfully created. If the fleet's auto-scaling actions
// are temporarily suspended, the new policy will be in force once the fleet
// actions are restarted. Rule-based policy A rule-based policy tracks specified
// fleet metric, sets a threshold value, and specifies the type of action to
// initiate when triggered. With a rule-based policy, you can select from several
// available fleet metrics. Each policy specifies whether to scale up or scale down
// (and by how much), so you need one policy for each type of action. For example,
// a policy may make the following statement: "If the percentage of idle instances
// is greater than 20% for more than 15 minutes, then reduce the fleet capacity by
// 10%." A policy's rule statement has the following structure: If [MetricName] is
// [ComparisonOperator] [Threshold] for [EvaluationPeriods] minutes, then
// [ScalingAdjustmentType] to/by [ScalingAdjustment] . To implement the example,
// the rule statement would look like this: If [PercentIdleInstances] is
// [GreaterThanThreshold] [20] for [15] minutes, then [PercentChangeInCapacity]
// to/by [10] . To create or update a scaling policy, specify a unique combination
// of name and fleet ID, and set the policy type to "RuleBased". Specify the
// parameter values for a policy rule statement. On a successful request, the
// policy name is returned. Scaling policies are automatically in force as soon as
// they're successfully created. If the fleet's auto-scaling actions are
// temporarily suspended, the new policy will be in force once the fleet actions
// are restarted.
func (c *Client) PutScalingPolicy(ctx context.Context, params *PutScalingPolicyInput, optFns ...func(*Options)) (*PutScalingPolicyOutput, error) {
if params == nil {
params = &PutScalingPolicyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "PutScalingPolicy", params, optFns, c.addOperationPutScalingPolicyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*PutScalingPolicyOutput)
out.ResultMetadata = metadata
return out, nil
}
type PutScalingPolicyInput struct {
// A unique identifier for the fleet to apply this policy to. You can use either
// the fleet ID or ARN value. The fleet cannot be in any of the following statuses:
// ERROR or DELETING.
//
// This member is required.
FleetId *string
// Name of the Amazon GameLift-defined metric that is used to trigger a scaling
// adjustment. For detailed descriptions of fleet metrics, see Monitor Amazon
// GameLift with Amazon CloudWatch (https://docs.aws.amazon.com/gamelift/latest/developerguide/monitoring-cloudwatch.html)
// .
// - ActivatingGameSessions -- Game sessions in the process of being created.
// - ActiveGameSessions -- Game sessions that are currently running.
// - ActiveInstances -- Fleet instances that are currently running at least one
// game session.
// - AvailableGameSessions -- Additional game sessions that fleet could host
// simultaneously, given current capacity.
// - AvailablePlayerSessions -- Empty player slots in currently active game
// sessions. This includes game sessions that are not currently accepting players.
// Reserved player slots are not included.
// - CurrentPlayerSessions -- Player slots in active game sessions that are
// being used by a player or are reserved for a player.
// - IdleInstances -- Active instances that are currently hosting zero game
// sessions.
// - PercentAvailableGameSessions -- Unused percentage of the total number of
// game sessions that a fleet could host simultaneously, given current capacity.
// Use this metric for a target-based scaling policy.
// - PercentIdleInstances -- Percentage of the total number of active instances
// that are hosting zero game sessions.
// - QueueDepth -- Pending game session placement requests, in any queue, where
// the current fleet is the top-priority destination.
// - WaitTime -- Current wait time for pending game session placement requests,
// in any queue, where the current fleet is the top-priority destination.
//
// This member is required.
MetricName types.MetricName
// A descriptive label that is associated with a fleet's scaling policy. Policy
// names do not need to be unique. A fleet can have only one scaling policy with
// the same name.
//
// This member is required.
Name *string
// Comparison operator to use when measuring the metric against the threshold
// value.
ComparisonOperator types.ComparisonOperatorType
// Length of time (in minutes) the metric must be at or beyond the threshold
// before a scaling event is triggered.
EvaluationPeriods *int32
// The type of scaling policy to create. For a target-based policy, set the
// parameter MetricName to 'PercentAvailableGameSessions' and specify a
// TargetConfiguration. For a rule-based policy set the following parameters:
// MetricName, ComparisonOperator, Threshold, EvaluationPeriods,
// ScalingAdjustmentType, and ScalingAdjustment.
PolicyType types.PolicyType
// Amount of adjustment to make, based on the scaling adjustment type.
ScalingAdjustment int32
// The type of adjustment to make to a fleet's instance count:
// - ChangeInCapacity -- add (or subtract) the scaling adjustment value from the
// current instance count. Positive values scale up while negative values scale
// down.
// - ExactCapacity -- set the instance count to the scaling adjustment value.
// - PercentChangeInCapacity -- increase or reduce the current instance count by
// the scaling adjustment, read as a percentage. Positive values scale up while
// negative values scale down; for example, a value of "-10" scales the fleet down
// by 10%.
ScalingAdjustmentType types.ScalingAdjustmentType
// An object that contains settings for a target-based scaling policy.
TargetConfiguration *types.TargetConfiguration
// Metric value used to trigger a scaling event.
Threshold float64
noSmithyDocumentSerde
}
type PutScalingPolicyOutput struct {
// A descriptive label that is associated with a fleet's scaling policy. Policy
// names do not need to be unique.
Name *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationPutScalingPolicyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpPutScalingPolicy{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpPutScalingPolicy{}, 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 = addOpPutScalingPolicyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opPutScalingPolicy(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
}
func newServiceMetadataMiddleware_opPutScalingPolicy(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "PutScalingPolicy",
}
}
| 249 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Registers your compute resources in a fleet you previously created. After you
// register a compute to your fleet, you can monitor and manage your compute using
// Amazon GameLift. The operation returns the compute resource containing SDK
// endpoint you can use to connect your game server to Amazon GameLift. Learn more
// - Create an Anywhere fleet (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-creating-anywhere.html)
// - Test your integration (https://docs.aws.amazon.com/gamelift/latest/developerguide/integration-testing.html)
func (c *Client) RegisterCompute(ctx context.Context, params *RegisterComputeInput, optFns ...func(*Options)) (*RegisterComputeOutput, error) {
if params == nil {
params = &RegisterComputeInput{}
}
result, metadata, err := c.invokeOperation(ctx, "RegisterCompute", params, optFns, c.addOperationRegisterComputeMiddlewares)
if err != nil {
return nil, err
}
out := result.(*RegisterComputeOutput)
out.ResultMetadata = metadata
return out, nil
}
type RegisterComputeInput struct {
// A descriptive label that is associated with the compute resource registered to
// your fleet.
//
// This member is required.
ComputeName *string
// A unique identifier for the fleet to register the compute to. You can use
// either the fleet ID or ARN value.
//
// This member is required.
FleetId *string
// The path to the TLS certificate on your compute resource. The path and
// certificate are not validated by Amazon GameLift.
CertificatePath *string
// The DNS name of the compute resource. Amazon GameLift requires the DNS name or
// IP address to manage your compute resource.
DnsName *string
// The IP address of the compute resource. Amazon GameLift requires the DNS name
// or IP address to manage your compute resource.
IpAddress *string
// The name of the custom location you added to the fleet you are registering this
// compute resource to.
Location *string
noSmithyDocumentSerde
}
type RegisterComputeOutput struct {
// The details of the compute resource you registered to the specified fleet.
Compute *types.Compute
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationRegisterComputeMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpRegisterCompute{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpRegisterCompute{}, 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 = addOpRegisterComputeValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opRegisterCompute(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
}
func newServiceMetadataMiddleware_opRegisterCompute(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "RegisterCompute",
}
}
| 153 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// This operation is used with the Amazon GameLift FleetIQ solution and game
// server groups. Creates a new game server resource and notifies Amazon GameLift
// FleetIQ that the game server is ready to host gameplay and players. This
// operation is called by a game server process that is running on an instance in a
// game server group. Registering game servers enables Amazon GameLift FleetIQ to
// track available game servers and enables game clients and services to claim a
// game server for a new game session. To register a game server, identify the game
// server group and instance where the game server is running, and provide a unique
// identifier for the game server. You can also include connection and game server
// data. Once a game server is successfully registered, it is put in status
// AVAILABLE . A request to register a game server may fail if the instance it is
// running on is in the process of shutting down as part of instance balancing or
// scale-down activity. Learn more Amazon GameLift FleetIQ Guide (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
func (c *Client) RegisterGameServer(ctx context.Context, params *RegisterGameServerInput, optFns ...func(*Options)) (*RegisterGameServerOutput, error) {
if params == nil {
params = &RegisterGameServerInput{}
}
result, metadata, err := c.invokeOperation(ctx, "RegisterGameServer", params, optFns, c.addOperationRegisterGameServerMiddlewares)
if err != nil {
return nil, err
}
out := result.(*RegisterGameServerOutput)
out.ResultMetadata = metadata
return out, nil
}
type RegisterGameServerInput struct {
// A unique identifier for the game server group where the game server is running.
//
// This member is required.
GameServerGroupName *string
// A custom string that uniquely identifies the game server to register. Game
// server IDs are developer-defined and must be unique across all game server
// groups in your Amazon Web Services account.
//
// This member is required.
GameServerId *string
// The unique identifier for the instance where the game server is running. This
// ID is available in the instance metadata. EC2 instance IDs use a 17-character
// format, for example: i-1234567890abcdef0 .
//
// This member is required.
InstanceId *string
// Information that is needed to make inbound client connections to the game
// server. This might include the IP address and port, DNS name, and other
// information.
ConnectionInfo *string
// A set of custom game server properties, formatted as a single string value.
// This data is passed to a game client or service when it requests information on
// game servers.
GameServerData *string
noSmithyDocumentSerde
}
type RegisterGameServerOutput struct {
// Object that describes the newly registered game server.
GameServer *types.GameServer
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationRegisterGameServerMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpRegisterGameServer{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpRegisterGameServer{}, 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 = addOpRegisterGameServerValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opRegisterGameServer(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
}
func newServiceMetadataMiddleware_opRegisterGameServer(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "RegisterGameServer",
}
}
| 161 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a fresh set of credentials for use when uploading a new set of game
// build files to Amazon GameLift's Amazon S3. This is done as part of the build
// creation process; see GameSession (https://docs.aws.amazon.com/gamelift/latest/apireference/API_CreateBuild.html)
// . To request new credentials, specify the build ID as returned with an initial
// CreateBuild request. If successful, a new set of credentials are returned, along
// with the S3 storage location associated with the build ID. Learn more Create a
// Build with Files in S3 (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-build-cli-uploading.html#gamelift-build-cli-uploading-create-build)
// All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) RequestUploadCredentials(ctx context.Context, params *RequestUploadCredentialsInput, optFns ...func(*Options)) (*RequestUploadCredentialsOutput, error) {
if params == nil {
params = &RequestUploadCredentialsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "RequestUploadCredentials", params, optFns, c.addOperationRequestUploadCredentialsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*RequestUploadCredentialsOutput)
out.ResultMetadata = metadata
return out, nil
}
type RequestUploadCredentialsInput struct {
// A unique identifier for the build to get credentials for. You can use either
// the build ID or ARN value.
//
// This member is required.
BuildId *string
noSmithyDocumentSerde
}
type RequestUploadCredentialsOutput struct {
// Amazon S3 path and key, identifying where the game build files are stored.
StorageLocation *types.S3Location
// Amazon Web Services credentials required when uploading a game build to the
// storage location. These credentials have a limited lifespan and are valid only
// for the build they were issued for.
UploadCredentials *types.AwsCredentials
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationRequestUploadCredentialsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpRequestUploadCredentials{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpRequestUploadCredentials{}, 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 = addOpRequestUploadCredentialsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opRequestUploadCredentials(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
}
func newServiceMetadataMiddleware_opRequestUploadCredentials(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "RequestUploadCredentials",
}
}
| 138 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves the fleet ID that an alias is currently pointing to. Related actions
// All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) ResolveAlias(ctx context.Context, params *ResolveAliasInput, optFns ...func(*Options)) (*ResolveAliasOutput, error) {
if params == nil {
params = &ResolveAliasInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ResolveAlias", params, optFns, c.addOperationResolveAliasMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ResolveAliasOutput)
out.ResultMetadata = metadata
return out, nil
}
type ResolveAliasInput struct {
// The unique identifier of the alias that you want to retrieve a fleet ID for.
// You can use either the alias ID or ARN value.
//
// This member is required.
AliasId *string
noSmithyDocumentSerde
}
type ResolveAliasOutput struct {
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) associated with the GameLift fleet resource that this alias points to.
FleetArn *string
// The fleet identifier that the alias is pointing to.
FleetId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationResolveAliasMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpResolveAlias{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpResolveAlias{}, 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 = addOpResolveAliasValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opResolveAlias(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
}
func newServiceMetadataMiddleware_opResolveAlias(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "ResolveAlias",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// This operation is used with the Amazon GameLift FleetIQ solution and game
// server groups. Reinstates activity on a game server group after it has been
// suspended. A game server group might be suspended by the SuspendGameServerGroup
// operation, or it might be suspended involuntarily due to a configuration
// problem. In the second case, you can manually resume activity on the group once
// the configuration problem has been resolved. Refer to the game server group
// status and status reason for more information on why group activity is
// suspended. To resume activity, specify a game server group ARN and the type of
// activity to be resumed. If successful, a GameServerGroup object is returned
// showing that the resumed activity is no longer listed in SuspendedActions .
// Learn more Amazon GameLift FleetIQ Guide (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
func (c *Client) ResumeGameServerGroup(ctx context.Context, params *ResumeGameServerGroupInput, optFns ...func(*Options)) (*ResumeGameServerGroupOutput, error) {
if params == nil {
params = &ResumeGameServerGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ResumeGameServerGroup", params, optFns, c.addOperationResumeGameServerGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ResumeGameServerGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type ResumeGameServerGroupInput struct {
// A unique identifier for the game server group. Use either the name or ARN value.
//
// This member is required.
GameServerGroupName *string
// The activity to resume for this game server group.
//
// This member is required.
ResumeActions []types.GameServerGroupAction
noSmithyDocumentSerde
}
type ResumeGameServerGroupOutput struct {
// An object that describes the game server group resource, with the
// SuspendedActions property updated to reflect the resumed activity.
GameServerGroup *types.GameServerGroup
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationResumeGameServerGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpResumeGameServerGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpResumeGameServerGroup{}, 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 = addOpResumeGameServerGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opResumeGameServerGroup(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
}
func newServiceMetadataMiddleware_opResumeGameServerGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "ResumeGameServerGroup",
}
}
| 141 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves all active game sessions that match a set of search criteria and
// sorts them into a specified order. This operation is not designed to be
// continually called to track game session status. This practice can cause you to
// exceed your API limit, which results in errors. Instead, you must configure
// configure an Amazon Simple Notification Service (SNS) topic to receive
// notifications from FlexMatch or queues. Continuously polling game session status
// with DescribeGameSessions should only be used for games in development with low
// game session usage. When searching for game sessions, you specify exactly where
// you want to search and provide a search filter expression, a sort expression, or
// both. A search request can search only one fleet, but it can search all of a
// fleet's locations. This operation can be used in the following ways:
// - To search all game sessions that are currently running on all locations in
// a fleet, provide a fleet or alias ID. This approach returns game sessions in the
// fleet's home Region and all remote locations that fit the search criteria.
// - To search all game sessions that are currently running on a specific fleet
// location, provide a fleet or alias ID and a location name. For location, you can
// specify a fleet's home Region or any remote location.
//
// Use the pagination parameters to retrieve results as a set of sequential pages.
// If successful, a GameSession object is returned for each game session that
// matches the request. Search finds game sessions that are in ACTIVE status only.
// To retrieve information on game sessions in other statuses, use
// DescribeGameSessions (https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeGameSessions.html)
// . You can search or sort by the following game session attributes:
// - gameSessionId -- A unique identifier for the game session. You can use
// either a GameSessionId or GameSessionArn value.
// - gameSessionName -- Name assigned to a game session. Game session names do
// not need to be unique to a game session.
// - gameSessionProperties -- Custom data defined in a game session's
// GameProperty parameter. GameProperty values are stored as key:value pairs; the
// filter expression must indicate the key and a string to search the data values
// for. For example, to search for game sessions with custom data containing the
// key:value pair "gameMode:brawl", specify the following:
// gameSessionProperties.gameMode = "brawl" . All custom data values are searched
// as strings.
// - maximumSessions -- Maximum number of player sessions allowed for a game
// session.
// - creationTimeMillis -- Value indicating when a game session was created. It
// is expressed in Unix time as milliseconds.
// - playerSessionCount -- Number of players currently connected to a game
// session. This value changes rapidly as players join the session or drop out.
// - hasAvailablePlayerSessions -- Boolean value indicating whether a game
// session has reached its maximum number of players. It is highly recommended that
// all search requests include this filter attribute to optimize search performance
// and return only sessions that players can join.
//
// Returned values for playerSessionCount and hasAvailablePlayerSessions change
// quickly as players join sessions and others drop out. Results should be
// considered a snapshot in time. Be sure to refresh search results often, and
// handle sessions that fill up before a player can join. All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) SearchGameSessions(ctx context.Context, params *SearchGameSessionsInput, optFns ...func(*Options)) (*SearchGameSessionsOutput, error) {
if params == nil {
params = &SearchGameSessionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "SearchGameSessions", params, optFns, c.addOperationSearchGameSessionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*SearchGameSessionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type SearchGameSessionsInput struct {
// A unique identifier for the alias associated with the fleet to search for
// active game sessions. You can use either the alias ID or ARN value. Each request
// must reference either a fleet ID or alias ID, but not both.
AliasId *string
// String containing the search criteria for the session search. If no filter
// expression is included, the request returns results for all game sessions in the
// fleet that are in ACTIVE status. A filter expression can contain one or
// multiple conditions. Each condition consists of the following:
// - Operand -- Name of a game session attribute. Valid values are
// gameSessionName , gameSessionId , gameSessionProperties , maximumSessions ,
// creationTimeMillis , playerSessionCount , hasAvailablePlayerSessions .
// - Comparator -- Valid comparators are: = , <> , < , > , <= , >= .
// - Value -- Value to be searched for. Values may be numbers, boolean values
// (true/false) or strings depending on the operand. String values are case
// sensitive and must be enclosed in single quotes. Special characters must be
// escaped. Boolean and string values can only be used with the comparators = and
// <> . For example, the following filter expression searches on gameSessionName
// : " FilterExpression": "gameSessionName = 'Matt\\'s Awesome Game 1'" .
// To chain multiple conditions in a single expression, use the logical keywords
// AND , OR , and NOT and parentheses as needed. For example: x AND y AND NOT z ,
// NOT (x OR y) . Session search evaluates conditions from left to right using the
// following precedence rules:
// - = , <> , < , > , <= , >=
// - Parentheses
// - NOT
// - AND
// - OR
// For example, this filter expression retrieves game sessions hosting at least
// ten players that have an open player slot: "maximumSessions>=10 AND
// hasAvailablePlayerSessions=true" .
FilterExpression *string
// A unique identifier for the fleet to search for active game sessions. You can
// use either the fleet ID or ARN value. Each request must reference either a fleet
// ID or alias ID, but not both.
FleetId *string
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages. The maximum number of results returned
// is 20, even if this value is not set or is set higher than 20.
Limit *int32
// A fleet location to search for game sessions. You can specify a fleet's home
// Region or a remote location. Use the Amazon Web Services Region code format,
// such as us-west-2 .
Location *string
// A token that indicates the start of the next sequential page of results. Use
// the token that is returned with a previous call to this operation. To start at
// the beginning of the result set, do not specify a value.
NextToken *string
// Instructions on how to sort the search results. If no sort expression is
// included, the request returns results in random order. A sort expression
// consists of the following elements:
// - Operand -- Name of a game session attribute. Valid values are
// gameSessionName , gameSessionId , gameSessionProperties , maximumSessions ,
// creationTimeMillis , playerSessionCount , hasAvailablePlayerSessions .
// - Order -- Valid sort orders are ASC (ascending) and DESC (descending).
// For example, this sort expression returns the oldest active sessions first:
// "SortExpression": "creationTimeMillis ASC" . Results with a null value for the
// sort operand are returned at the end of the list.
SortExpression *string
noSmithyDocumentSerde
}
type SearchGameSessionsOutput struct {
// A collection of objects containing game session properties for each session
// that matches the request.
GameSessions []types.GameSession
// A token that indicates where to resume retrieving results on the next call to
// this operation. If no token is returned, these results represent the end of the
// list.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationSearchGameSessionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpSearchGameSessions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpSearchGameSessions{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opSearchGameSessions(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
}
// SearchGameSessionsAPIClient is a client that implements the SearchGameSessions
// operation.
type SearchGameSessionsAPIClient interface {
SearchGameSessions(context.Context, *SearchGameSessionsInput, ...func(*Options)) (*SearchGameSessionsOutput, error)
}
var _ SearchGameSessionsAPIClient = (*Client)(nil)
// SearchGameSessionsPaginatorOptions is the paginator options for
// SearchGameSessions
type SearchGameSessionsPaginatorOptions struct {
// The maximum number of results to return. Use this parameter with NextToken to
// get results as a set of sequential pages. The maximum number of results returned
// is 20, even if this value is not set or is set higher than 20.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// SearchGameSessionsPaginator is a paginator for SearchGameSessions
type SearchGameSessionsPaginator struct {
options SearchGameSessionsPaginatorOptions
client SearchGameSessionsAPIClient
params *SearchGameSessionsInput
nextToken *string
firstPage bool
}
// NewSearchGameSessionsPaginator returns a new SearchGameSessionsPaginator
func NewSearchGameSessionsPaginator(client SearchGameSessionsAPIClient, params *SearchGameSessionsInput, optFns ...func(*SearchGameSessionsPaginatorOptions)) *SearchGameSessionsPaginator {
if params == nil {
params = &SearchGameSessionsInput{}
}
options := SearchGameSessionsPaginatorOptions{}
if params.Limit != nil {
options.Limit = *params.Limit
}
for _, fn := range optFns {
fn(&options)
}
return &SearchGameSessionsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *SearchGameSessionsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next SearchGameSessions page.
func (p *SearchGameSessionsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*SearchGameSessionsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.Limit = limit
result, err := p.client.SearchGameSessions(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opSearchGameSessions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "SearchGameSessions",
}
}
| 331 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Resumes certain types of activity on fleet instances that were suspended with
// StopFleetActions (https://docs.aws.amazon.com/gamelift/latest/apireference/API_StopFleetActions.html)
// . For multi-location fleets, fleet actions are managed separately for each
// location. Currently, this operation is used to restart a fleet's auto-scaling
// activity. This operation can be used in the following ways:
// - To restart actions on instances in the fleet's home Region, provide a fleet
// ID and the type of actions to resume.
// - To restart actions on instances in one of the fleet's remote locations,
// provide a fleet ID, a location name, and the type of actions to resume.
//
// If successful, Amazon GameLift once again initiates scaling events as triggered
// by the fleet's scaling policies. If actions on the fleet location were never
// stopped, this operation will have no effect. Learn more Setting up Amazon
// GameLift fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
func (c *Client) StartFleetActions(ctx context.Context, params *StartFleetActionsInput, optFns ...func(*Options)) (*StartFleetActionsOutput, error) {
if params == nil {
params = &StartFleetActionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartFleetActions", params, optFns, c.addOperationStartFleetActionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartFleetActionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartFleetActionsInput struct {
// List of actions to restart on the fleet.
//
// This member is required.
Actions []types.FleetAction
// A unique identifier for the fleet to restart actions on. You can use either the
// fleet ID or ARN value.
//
// This member is required.
FleetId *string
// The fleet location to restart fleet actions for. Specify a location in the form
// of an Amazon Web Services Region code, such as us-west-2 .
Location *string
noSmithyDocumentSerde
}
type StartFleetActionsOutput struct {
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift fleet resource and uniquely identifies
// it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 .
FleetArn *string
// A unique identifier for the fleet to restart actions on.
FleetId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartFleetActionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpStartFleetActions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpStartFleetActions{}, 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 = addOpStartFleetActionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartFleetActions(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
}
func newServiceMetadataMiddleware_opStartFleetActions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "StartFleetActions",
}
}
| 154 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Places a request for a new game session in a queue. When processing a placement
// request, Amazon GameLift searches for available resources on the queue's
// destinations, scanning each until it finds resources or the placement request
// times out. A game session placement request can also request player sessions.
// When a new game session is successfully created, Amazon GameLift creates a
// player session for each player included in the request. When placing a game
// session, by default Amazon GameLift tries each fleet in the order they are
// listed in the queue configuration. Ideally, a queue's destinations are listed in
// preference order. Alternatively, when requesting a game session with players,
// you can also provide latency data for each player in relevant Regions. Latency
// data indicates the performance lag a player experiences when connected to a
// fleet in the Region. Amazon GameLift uses latency data to reorder the list of
// destinations to place the game session in a Region with minimal lag. If latency
// data is provided for multiple players, Amazon GameLift calculates each Region's
// average lag for all players and reorders to get the best game play across all
// players. To place a new game session request, specify the following:
// - The queue name and a set of game session properties and settings
// - A unique ID (such as a UUID) for the placement. You use this ID to track
// the status of the placement request
// - (Optional) A set of player data and a unique player ID for each player that
// you are joining to the new game session (player data is optional, but if you
// include it, you must also provide a unique ID for each player)
// - Latency data for all players (if you want to optimize game play for the
// players)
//
// If successful, a new game session placement is created. To track the status of
// a placement request, call DescribeGameSessionPlacement (https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeGameSessionPlacement.html)
// and check the request's status. If the status is FULFILLED , a new game session
// has been created and a game session ARN and Region are referenced. If the
// placement request times out, you can resubmit the request or retry it with a
// different queue.
func (c *Client) StartGameSessionPlacement(ctx context.Context, params *StartGameSessionPlacementInput, optFns ...func(*Options)) (*StartGameSessionPlacementOutput, error) {
if params == nil {
params = &StartGameSessionPlacementInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartGameSessionPlacement", params, optFns, c.addOperationStartGameSessionPlacementMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartGameSessionPlacementOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartGameSessionPlacementInput struct {
// Name of the queue to use to place the new game session. You can use either the
// queue name or ARN value.
//
// This member is required.
GameSessionQueueName *string
// The maximum number of players that can be connected simultaneously to the game
// session.
//
// This member is required.
MaximumPlayerSessionCount *int32
// A unique identifier to assign to the new game session placement. This value is
// developer-defined. The value must be unique across all Regions and cannot be
// reused.
//
// This member is required.
PlacementId *string
// Set of information on each player to create a player session for.
DesiredPlayerSessions []types.DesiredPlayerSession
// A set of custom properties for a game session, formatted as key:value pairs.
// These properties are passed to a game server process with a request to start a
// new game session (see Start a Game Session (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession)
// ).
GameProperties []types.GameProperty
// A set of custom game session properties, formatted as a single string value.
// This data is passed to a game server process in the GameSession object with a
// request to start a new game session (see Start a Game Session (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession)
// ).
GameSessionData *string
// A descriptive label that is associated with a game session. Session names do
// not need to be unique.
GameSessionName *string
// A set of values, expressed in milliseconds, that indicates the amount of
// latency that a player experiences when connected to Amazon Web Services Regions.
// This information is used to try to place the new game session where it can offer
// the best possible gameplay experience for the players.
PlayerLatencies []types.PlayerLatency
noSmithyDocumentSerde
}
type StartGameSessionPlacementOutput struct {
// Object that describes the newly created game session placement. This object
// includes all the information provided in the request, as well as start/end time
// stamps and placement status.
GameSessionPlacement *types.GameSessionPlacement
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartGameSessionPlacementMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpStartGameSessionPlacement{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpStartGameSessionPlacement{}, 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 = addOpStartGameSessionPlacementValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartGameSessionPlacement(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
}
func newServiceMetadataMiddleware_opStartGameSessionPlacement(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "StartGameSessionPlacement",
}
}
| 196 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Finds new players to fill open slots in currently running game sessions. The
// backfill match process is essentially identical to the process of forming new
// matches. Backfill requests use the same matchmaker that was used to make the
// original match, and they provide matchmaking data for all players currently in
// the game session. FlexMatch uses this information to select new players so that
// backfilled match continues to meet the original match requirements. When using
// FlexMatch with Amazon GameLift managed hosting, you can request a backfill match
// from a client service by calling this operation with a GameSessions ID. You
// also have the option of making backfill requests directly from your game server.
// In response to a request, FlexMatch creates player sessions for the new players,
// updates the GameSession resource, and sends updated matchmaking data to the
// game server. You can request a backfill match at any point after a game session
// is started. Each game session can have only one active backfill request at a
// time; a subsequent request automatically replaces the earlier request. When
// using FlexMatch as a standalone component, request a backfill match by calling
// this operation without a game session identifier. As with newly formed matches,
// matchmaking results are returned in a matchmaking event so that your game can
// update the game session that is being backfilled. To request a backfill match,
// specify a unique ticket ID, the original matchmaking configuration, and
// matchmaking data for all current players in the game session being backfilled.
// Optionally, specify the GameSession ARN. If successful, a match backfill ticket
// is created and returned with status set to QUEUED. Track the status of backfill
// tickets using the same method for tracking tickets for new matches. Only game
// sessions created by FlexMatch are supported for match backfill. Learn more
// Backfill existing games with FlexMatch (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-backfill.html)
// Matchmaking events (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-events.html)
// (reference) How Amazon GameLift FlexMatch works (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/gamelift-match.html)
func (c *Client) StartMatchBackfill(ctx context.Context, params *StartMatchBackfillInput, optFns ...func(*Options)) (*StartMatchBackfillOutput, error) {
if params == nil {
params = &StartMatchBackfillInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartMatchBackfill", params, optFns, c.addOperationStartMatchBackfillMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartMatchBackfillOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartMatchBackfillInput struct {
// Name of the matchmaker to use for this request. You can use either the
// configuration name or ARN value. The ARN of the matchmaker that was used with
// the original game session is listed in the GameSession object, MatchmakerData
// property.
//
// This member is required.
ConfigurationName *string
// Match information on all players that are currently assigned to the game
// session. This information is used by the matchmaker to find new players and add
// them to the existing game. You can include up to 199 Players in a
// StartMatchBackfill request.
// - PlayerID, PlayerAttributes, Team -- This information is maintained in the
// GameSession object, MatchmakerData property, for all players who are currently
// assigned to the game session. The matchmaker data is in JSON syntax, formatted
// as a string. For more details, see Match Data (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-server.html#match-server-data)
// . The backfill request must specify the team membership for every player. Do not
// specify team if you are not using backfill.
// - LatencyInMs -- If the matchmaker uses player latency, include a latency
// value, in milliseconds, for the Region that the game session is currently in. Do
// not include latency values for any other Region.
//
// This member is required.
Players []types.Player
// A unique identifier for the game session. Use the game session ID. When using
// FlexMatch as a standalone matchmaking solution, this parameter is not needed.
GameSessionArn *string
// A unique identifier for a matchmaking ticket. If no ticket ID is specified
// here, Amazon GameLift will generate one in the form of a UUID. Use this
// identifier to track the match backfill ticket status and retrieve match results.
TicketId *string
noSmithyDocumentSerde
}
type StartMatchBackfillOutput struct {
// Ticket representing the backfill matchmaking request. This object includes the
// information in the request, ticket status, and match results as generated during
// the matchmaking process.
MatchmakingTicket *types.MatchmakingTicket
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartMatchBackfillMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpStartMatchBackfill{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpStartMatchBackfill{}, 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 = addOpStartMatchBackfillValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartMatchBackfill(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
}
func newServiceMetadataMiddleware_opStartMatchBackfill(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "StartMatchBackfill",
}
}
| 182 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Uses FlexMatch to create a game match for a group of players based on custom
// matchmaking rules. With games that use Amazon GameLift managed hosting, this
// operation also triggers Amazon GameLift to find hosting resources and start a
// new game session for the new match. Each matchmaking request includes
// information on one or more players and specifies the FlexMatch matchmaker to
// use. When a request is for multiple players, FlexMatch attempts to build a match
// that includes all players in the request, placing them in the same team and
// finding additional players as needed to fill the match. To start matchmaking,
// provide a unique ticket ID, specify a matchmaking configuration, and include the
// players to be matched. You must also include any player attributes that are
// required by the matchmaking configuration's rule set. If successful, a
// matchmaking ticket is returned with status set to QUEUED . Track matchmaking
// events to respond as needed and acquire game session connection information for
// successfully completed matches. Ticket status updates are tracked using event
// notification through Amazon Simple Notification Service, which is defined in the
// matchmaking configuration. Learn more Add FlexMatch to a game client (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-client.html)
// Set Up FlexMatch event notification (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-notification.html)
// How Amazon GameLift FlexMatch works (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/gamelift-match.html)
func (c *Client) StartMatchmaking(ctx context.Context, params *StartMatchmakingInput, optFns ...func(*Options)) (*StartMatchmakingOutput, error) {
if params == nil {
params = &StartMatchmakingInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartMatchmaking", params, optFns, c.addOperationStartMatchmakingMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartMatchmakingOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartMatchmakingInput struct {
// Name of the matchmaking configuration to use for this request. Matchmaking
// configurations must exist in the same Region as this request. You can use either
// the configuration name or ARN value.
//
// This member is required.
ConfigurationName *string
// Information on each player to be matched. This information must include a
// player ID, and may contain player attributes and latency data to be used in the
// matchmaking process. After a successful match, Player objects contain the name
// of the team the player is assigned to. You can include up to 10 Players in a
// StartMatchmaking request.
//
// This member is required.
Players []types.Player
// A unique identifier for a matchmaking ticket. If no ticket ID is specified
// here, Amazon GameLift will generate one in the form of a UUID. Use this
// identifier to track the matchmaking ticket status and retrieve match results.
TicketId *string
noSmithyDocumentSerde
}
type StartMatchmakingOutput struct {
// Ticket representing the matchmaking request. This object include the
// information included in the request, ticket status, and match results as
// generated during the matchmaking process.
MatchmakingTicket *types.MatchmakingTicket
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartMatchmakingMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpStartMatchmaking{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpStartMatchmaking{}, 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 = addOpStartMatchmakingValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartMatchmaking(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
}
func newServiceMetadataMiddleware_opStartMatchmaking(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "StartMatchmaking",
}
}
| 160 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Suspends certain types of activity in a fleet location. Currently, this
// operation is used to stop auto-scaling activity. For multi-location fleets,
// fleet actions are managed separately for each location. Stopping fleet actions
// has several potential purposes. It allows you to temporarily stop auto-scaling
// activity but retain your scaling policies for use in the future. For
// multi-location fleets, you can set up fleet-wide auto-scaling, and then opt out
// of it for certain locations. This operation can be used in the following ways:
// - To stop actions on instances in the fleet's home Region, provide a fleet ID
// and the type of actions to suspend.
// - To stop actions on instances in one of the fleet's remote locations,
// provide a fleet ID, a location name, and the type of actions to suspend.
//
// If successful, Amazon GameLift no longer initiates scaling events except in
// response to manual changes using UpdateFleetCapacity (https://docs.aws.amazon.com/gamelift/latest/apireference/API_UpdateFleetCapacity.html)
// . Learn more Setting up Amazon GameLift Fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
func (c *Client) StopFleetActions(ctx context.Context, params *StopFleetActionsInput, optFns ...func(*Options)) (*StopFleetActionsOutput, error) {
if params == nil {
params = &StopFleetActionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StopFleetActions", params, optFns, c.addOperationStopFleetActionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StopFleetActionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type StopFleetActionsInput struct {
// List of actions to suspend on the fleet.
//
// This member is required.
Actions []types.FleetAction
// A unique identifier for the fleet to stop actions on. You can use either the
// fleet ID or ARN value.
//
// This member is required.
FleetId *string
// The fleet location to stop fleet actions for. Specify a location in the form of
// an Amazon Web Services Region code, such as us-west-2 .
Location *string
noSmithyDocumentSerde
}
type StopFleetActionsOutput struct {
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift fleet resource and uniquely identifies
// it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 .
FleetArn *string
// A unique identifier for the fleet to stop actions on.
FleetId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStopFleetActionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpStopFleetActions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpStopFleetActions{}, 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 = addOpStopFleetActionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStopFleetActions(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
}
func newServiceMetadataMiddleware_opStopFleetActions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "StopFleetActions",
}
}
| 155 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Cancels a game session placement that is in PENDING status. To stop a
// placement, provide the placement ID values. If successful, the placement is
// moved to CANCELLED status.
func (c *Client) StopGameSessionPlacement(ctx context.Context, params *StopGameSessionPlacementInput, optFns ...func(*Options)) (*StopGameSessionPlacementOutput, error) {
if params == nil {
params = &StopGameSessionPlacementInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StopGameSessionPlacement", params, optFns, c.addOperationStopGameSessionPlacementMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StopGameSessionPlacementOutput)
out.ResultMetadata = metadata
return out, nil
}
type StopGameSessionPlacementInput struct {
// A unique identifier for a game session placement to stop.
//
// This member is required.
PlacementId *string
noSmithyDocumentSerde
}
type StopGameSessionPlacementOutput struct {
// Object that describes the canceled game session placement, with CANCELLED
// status and an end time stamp.
GameSessionPlacement *types.GameSessionPlacement
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStopGameSessionPlacementMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpStopGameSessionPlacement{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpStopGameSessionPlacement{}, 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 = addOpStopGameSessionPlacementValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStopGameSessionPlacement(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
}
func newServiceMetadataMiddleware_opStopGameSessionPlacement(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "StopGameSessionPlacement",
}
}
| 128 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Cancels a matchmaking ticket or match backfill ticket that is currently being
// processed. To stop the matchmaking operation, specify the ticket ID. If
// successful, work on the ticket is stopped, and the ticket status is changed to
// CANCELLED . This call is also used to turn off automatic backfill for an
// individual game session. This is for game sessions that are created with a
// matchmaking configuration that has automatic backfill enabled. The ticket ID is
// included in the MatchmakerData of an updated game session object, which is
// provided to the game server. If the operation is successful, the service sends
// back an empty JSON struct with the HTTP 200 response (not an empty HTTP body).
// Learn more Add FlexMatch to a game client (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-client.html)
func (c *Client) StopMatchmaking(ctx context.Context, params *StopMatchmakingInput, optFns ...func(*Options)) (*StopMatchmakingOutput, error) {
if params == nil {
params = &StopMatchmakingInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StopMatchmaking", params, optFns, c.addOperationStopMatchmakingMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StopMatchmakingOutput)
out.ResultMetadata = metadata
return out, nil
}
type StopMatchmakingInput struct {
// A unique identifier for a matchmaking ticket.
//
// This member is required.
TicketId *string
noSmithyDocumentSerde
}
type StopMatchmakingOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStopMatchmakingMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpStopMatchmaking{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpStopMatchmaking{}, 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 = addOpStopMatchmakingValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStopMatchmaking(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
}
func newServiceMetadataMiddleware_opStopMatchmaking(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "StopMatchmaking",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// This operation is used with the Amazon GameLift FleetIQ solution and game
// server groups. Temporarily stops activity on a game server group without
// terminating instances or the game server group. You can restart activity by
// calling ResumeGameServerGroup . You can suspend the following activity:
// - Instance type replacement - This activity evaluates the current game
// hosting viability of all Spot instance types that are defined for the game
// server group. It updates the Auto Scaling group to remove nonviable Spot
// Instance types, which have a higher chance of game server interruptions. It then
// balances capacity across the remaining viable Spot Instance types. When this
// activity is suspended, the Auto Scaling group continues with its current
// balance, regardless of viability. Instance protection, utilization metrics, and
// capacity scaling activities continue to be active.
//
// To suspend activity, specify a game server group ARN and the type of activity
// to be suspended. If successful, a GameServerGroup object is returned showing
// that the activity is listed in SuspendedActions . Learn more Amazon GameLift
// FleetIQ Guide (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
func (c *Client) SuspendGameServerGroup(ctx context.Context, params *SuspendGameServerGroupInput, optFns ...func(*Options)) (*SuspendGameServerGroupOutput, error) {
if params == nil {
params = &SuspendGameServerGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "SuspendGameServerGroup", params, optFns, c.addOperationSuspendGameServerGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*SuspendGameServerGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type SuspendGameServerGroupInput struct {
// A unique identifier for the game server group. Use either the name or ARN value.
//
// This member is required.
GameServerGroupName *string
// The activity to suspend for this game server group.
//
// This member is required.
SuspendActions []types.GameServerGroupAction
noSmithyDocumentSerde
}
type SuspendGameServerGroupOutput struct {
// An object that describes the game server group resource, with the
// SuspendedActions property updated to reflect the suspended activity.
GameServerGroup *types.GameServerGroup
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationSuspendGameServerGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpSuspendGameServerGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpSuspendGameServerGroup{}, 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 = addOpSuspendGameServerGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opSuspendGameServerGroup(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
}
func newServiceMetadataMiddleware_opSuspendGameServerGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "SuspendGameServerGroup",
}
}
| 147 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Assigns a tag to an Amazon GameLift resource. You can use tags to organize
// resources, create IAM permissions policies to manage access to groups of
// resources, customize Amazon Web Services cost breakdowns, and more. This
// operation handles the permissions necessary to manage tags for Amazon GameLift
// resources that support tagging. To add a tag to a resource, specify the unique
// ARN value for the resource and provide a tag list containing one or more tags.
// The operation succeeds even if the list includes tags that are already assigned
// to the resource. Learn more Tagging Amazon Web Services Resources (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html)
// in the Amazon Web Services General Reference Amazon Web Services Tagging
// Strategies (http://aws.amazon.com/answers/account-management/aws-tagging-strategies/)
// Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) TagResource(ctx context.Context, params *TagResourceInput, optFns ...func(*Options)) (*TagResourceOutput, error) {
if params == nil {
params = &TagResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "TagResource", params, optFns, c.addOperationTagResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*TagResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type TagResourceInput struct {
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that uniquely identifies the Amazon GameLift resource that you want to assign
// tags to. Amazon GameLift includes resource ARNs in the data object for the
// resource. You can retrieve the ARN by calling a List or Describe operation for
// the resource type.
//
// This member is required.
ResourceARN *string
// A list of one or more tags to assign to the specified Amazon GameLift resource.
// Tags are developer-defined and structured as key-value pairs. The maximum tag
// limit may be lower than stated. See Tagging Amazon Web Services Resources (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html)
// for tagging limits.
//
// This member is required.
Tags []types.Tag
noSmithyDocumentSerde
}
type TagResourceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationTagResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpTagResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpTagResource{}, 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 = addOpTagResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opTagResource(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
}
func newServiceMetadataMiddleware_opTagResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "TagResource",
}
}
| 143 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Removes a tag assigned to a Amazon GameLift resource. You can use resource tags
// to organize Amazon Web Services resources for a range of purposes. This
// operation handles the permissions necessary to manage tags for Amazon GameLift
// resources that support tagging. To remove a tag from a resource, specify the
// unique ARN value for the resource and provide a string list containing one or
// more tags to remove. This operation succeeds even if the list includes tags that
// aren't assigned to the resource. Learn more Tagging Amazon Web Services
// Resources (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) in
// the Amazon Web Services General Reference Amazon Web Services Tagging Strategies (http://aws.amazon.com/answers/account-management/aws-tagging-strategies/)
// Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) UntagResource(ctx context.Context, params *UntagResourceInput, optFns ...func(*Options)) (*UntagResourceOutput, error) {
if params == nil {
params = &UntagResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UntagResource", params, optFns, c.addOperationUntagResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UntagResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type UntagResourceInput struct {
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that uniquely identifies the Amazon GameLift resource that you want to remove
// tags from. Amazon GameLift includes resource ARNs in the data object for the
// resource. You can retrieve the ARN by calling a List or Describe operation for
// the resource type.
//
// This member is required.
ResourceARN *string
// A list of one or more tag keys to remove from the specified Amazon GameLift
// resource.
//
// This member is required.
TagKeys []string
noSmithyDocumentSerde
}
type UntagResourceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUntagResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUntagResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUntagResource{}, 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 = addOpUntagResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUntagResource(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
}
func newServiceMetadataMiddleware_opUntagResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "UntagResource",
}
}
| 139 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates properties for an alias. To update properties, specify the alias ID to
// be updated and provide the information to be changed. To reassign an alias to
// another fleet, provide an updated routing strategy. If successful, the updated
// alias record is returned. Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) UpdateAlias(ctx context.Context, params *UpdateAliasInput, optFns ...func(*Options)) (*UpdateAliasOutput, error) {
if params == nil {
params = &UpdateAliasInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateAlias", params, optFns, c.addOperationUpdateAliasMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateAliasOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateAliasInput struct {
// A unique identifier for the alias that you want to update. You can use either
// the alias ID or ARN value.
//
// This member is required.
AliasId *string
// A human-readable description of the alias.
Description *string
// A descriptive label that is associated with an alias. Alias names do not need
// to be unique.
Name *string
// The routing configuration, including routing type and fleet target, for the
// alias.
RoutingStrategy *types.RoutingStrategy
noSmithyDocumentSerde
}
type UpdateAliasOutput struct {
// The updated alias resource.
Alias *types.Alias
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateAliasMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateAlias{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateAlias{}, 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 = addOpUpdateAliasValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateAlias(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
}
func newServiceMetadataMiddleware_opUpdateAlias(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "UpdateAlias",
}
}
| 140 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates metadata in a build resource, including the build name and version. To
// update the metadata, specify the build ID to update and provide the new values.
// If successful, a build object containing the updated metadata is returned. Learn
// more Upload a Custom Server Build (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-build-intro.html)
// All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) UpdateBuild(ctx context.Context, params *UpdateBuildInput, optFns ...func(*Options)) (*UpdateBuildOutput, error) {
if params == nil {
params = &UpdateBuildInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateBuild", params, optFns, c.addOperationUpdateBuildMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateBuildOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateBuildInput struct {
// A unique identifier for the build to update. You can use either the build ID or
// ARN value.
//
// This member is required.
BuildId *string
// A descriptive label associated with a build. Build names don't need to be
// unique.
Name *string
// Version information associated with a build or script. Version strings don't
// need to be unique.
Version *string
noSmithyDocumentSerde
}
type UpdateBuildOutput struct {
// The updated build resource.
Build *types.Build
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateBuildMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateBuild{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateBuild{}, 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 = addOpUpdateBuildValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateBuild(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
}
func newServiceMetadataMiddleware_opUpdateBuild(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "UpdateBuild",
}
}
| 138 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates a fleet's mutable attributes, including game session protection and
// resource creation limits. To update fleet attributes, specify the fleet ID and
// the property values that you want to change. If successful, an updated
// FleetAttributes object is returned. Learn more Setting up Amazon GameLift fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
func (c *Client) UpdateFleetAttributes(ctx context.Context, params *UpdateFleetAttributesInput, optFns ...func(*Options)) (*UpdateFleetAttributesOutput, error) {
if params == nil {
params = &UpdateFleetAttributesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateFleetAttributes", params, optFns, c.addOperationUpdateFleetAttributesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateFleetAttributesOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateFleetAttributesInput struct {
// A unique identifier for the fleet to update attribute metadata for. You can use
// either the fleet ID or ARN value.
//
// This member is required.
FleetId *string
// Amazon GameLift Anywhere configuration options.
AnywhereConfiguration *types.AnywhereConfiguration
// A human-readable description of a fleet.
Description *string
// The name of a metric group to add this fleet to. Use a metric group in Amazon
// CloudWatch to aggregate the metrics from multiple fleets. Provide an existing
// metric group name, or create a new metric group by providing a new name. A fleet
// can only be in one metric group at a time.
MetricGroups []string
// A descriptive label that is associated with a fleet. Fleet names do not need to
// be unique.
Name *string
// The game session protection policy to apply to all new instances created in
// this fleet. Instances that already exist are not affected. You can set
// protection for individual instances using UpdateGameSession (https://docs.aws.amazon.com/gamelift/latest/apireference/API_UpdateGameSession.html)
// .
// - NoProtection -- The game session can be terminated during a scale-down
// event.
// - FullProtection -- If the game session is in an ACTIVE status, it cannot be
// terminated during a scale-down event.
NewGameSessionProtectionPolicy types.ProtectionPolicy
// Policy settings that limit the number of game sessions an individual player can
// create over a span of time.
ResourceCreationLimitPolicy *types.ResourceCreationLimitPolicy
noSmithyDocumentSerde
}
type UpdateFleetAttributesOutput struct {
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift fleet resource and uniquely identifies
// it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 .
FleetArn *string
// A unique identifier for the fleet that was updated.
FleetId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateFleetAttributesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateFleetAttributes{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateFleetAttributes{}, 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 = addOpUpdateFleetAttributesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateFleetAttributes(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
}
func newServiceMetadataMiddleware_opUpdateFleetAttributes(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "UpdateFleetAttributes",
}
}
| 165 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates capacity settings for a fleet. For fleets with multiple locations, use
// this operation to manage capacity settings in each location individually. Fleet
// capacity determines the number of game sessions and players that can be hosted
// based on the fleet configuration. Use this operation to set the following fleet
// capacity properties:
// - Minimum/maximum size: Set hard limits on fleet capacity. Amazon GameLift
// cannot set the fleet's capacity to a value outside of this range, whether the
// capacity is changed manually or through automatic scaling.
// - Desired capacity: Manually set the number of Amazon EC2 instances to be
// maintained in a fleet location. Before changing a fleet's desired capacity, you
// may want to call DescribeEC2InstanceLimits (https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeEC2InstanceLimits.html)
// to get the maximum capacity of the fleet's Amazon EC2 instance type.
// Alternatively, consider using automatic scaling to adjust capacity based on
// player demand.
//
// This operation can be used in the following ways:
// - To update capacity for a fleet's home Region, or if the fleet has no remote
// locations, omit the Location parameter. The fleet must be in ACTIVE status.
// - To update capacity for a fleet's remote location, include the Location
// parameter set to the location to be updated. The location must be in ACTIVE
// status.
//
// If successful, capacity settings are updated immediately. In response a change
// in desired capacity, Amazon GameLift initiates steps to start new instances or
// terminate existing instances in the requested fleet location. This continues
// until the location's active instance count matches the new desired instance
// count. You can track a fleet's current capacity by calling DescribeFleetCapacity (https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeFleetCapacity.html)
// or DescribeFleetLocationCapacity (https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeFleetLocationCapacity.html)
// . If the requested desired instance count is higher than the instance type's
// limit, the LimitExceeded exception occurs. Learn more Scaling fleet capacity (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-manage-capacity.html)
func (c *Client) UpdateFleetCapacity(ctx context.Context, params *UpdateFleetCapacityInput, optFns ...func(*Options)) (*UpdateFleetCapacityOutput, error) {
if params == nil {
params = &UpdateFleetCapacityInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateFleetCapacity", params, optFns, c.addOperationUpdateFleetCapacityMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateFleetCapacityOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateFleetCapacityInput struct {
// A unique identifier for the fleet to update capacity settings for. You can use
// either the fleet ID or ARN value.
//
// This member is required.
FleetId *string
// The number of Amazon EC2 instances you want to maintain in the specified fleet
// location. This value must fall between the minimum and maximum size limits.
DesiredInstances *int32
// The name of a remote location to update fleet capacity settings for, in the
// form of an Amazon Web Services Region code such as us-west-2 .
Location *string
// The maximum number of instances that are allowed in the specified fleet
// location. If this parameter is not set, the default is 1.
MaxSize *int32
// The minimum number of instances that are allowed in the specified fleet
// location. If this parameter is not set, the default is 0.
MinSize *int32
noSmithyDocumentSerde
}
type UpdateFleetCapacityOutput struct {
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift fleet resource and uniquely identifies
// it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 .
FleetArn *string
// A unique identifier for the fleet that was updated.
FleetId *string
// The remote location being updated, expressed as an Amazon Web Services Region
// code, such as us-west-2 .
Location *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateFleetCapacityMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateFleetCapacity{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateFleetCapacity{}, 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 = addOpUpdateFleetCapacityValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateFleetCapacity(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
}
func newServiceMetadataMiddleware_opUpdateFleetCapacity(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "UpdateFleetCapacity",
}
}
| 180 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates permissions that allow inbound traffic to connect to game sessions that
// are being hosted on instances in the fleet. To update settings, specify the
// fleet ID to be updated and specify the changes to be made. List the permissions
// you want to add in InboundPermissionAuthorizations , and permissions you want to
// remove in InboundPermissionRevocations . Permissions to be removed must match
// existing fleet permissions. If successful, the fleet ID for the updated fleet is
// returned. For fleets with remote locations, port setting updates can take time
// to propagate across all locations. You can check the status of updates in each
// location by calling DescribeFleetPortSettings with a location name. Learn more
// Setting up Amazon GameLift fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
func (c *Client) UpdateFleetPortSettings(ctx context.Context, params *UpdateFleetPortSettingsInput, optFns ...func(*Options)) (*UpdateFleetPortSettingsOutput, error) {
if params == nil {
params = &UpdateFleetPortSettingsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateFleetPortSettings", params, optFns, c.addOperationUpdateFleetPortSettingsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateFleetPortSettingsOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateFleetPortSettingsInput struct {
// A unique identifier for the fleet to update port settings for. You can use
// either the fleet ID or ARN value.
//
// This member is required.
FleetId *string
// A collection of port settings to be added to the fleet resource.
InboundPermissionAuthorizations []types.IpPermission
// A collection of port settings to be removed from the fleet resource.
InboundPermissionRevocations []types.IpPermission
noSmithyDocumentSerde
}
type UpdateFleetPortSettingsOutput struct {
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift fleet resource and uniquely identifies
// it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 .
FleetArn *string
// A unique identifier for the fleet that was updated.
FleetId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateFleetPortSettingsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateFleetPortSettings{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateFleetPortSettings{}, 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 = addOpUpdateFleetPortSettingsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateFleetPortSettings(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
}
func newServiceMetadataMiddleware_opUpdateFleetPortSettings(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "UpdateFleetPortSettings",
}
}
| 147 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// This operation is used with the Amazon GameLift FleetIQ solution and game
// server groups. Updates information about a registered game server to help Amazon
// GameLift FleetIQ to track game server availability. This operation is called by
// a game server process that is running on an instance in a game server group. Use
// this operation to update the following types of game server information. You can
// make all three types of updates in the same request:
// - To update the game server's utilization status, identify the game server
// and game server group and specify the current utilization status. Use this
// status to identify when game servers are currently hosting games and when they
// are available to be claimed.
// - To report health status, identify the game server and game server group and
// set health check to HEALTHY . If a game server does not report health status
// for a certain length of time, the game server is no longer considered healthy.
// As a result, it will be eventually deregistered from the game server group to
// avoid affecting utilization metrics. The best practice is to report health every
// 60 seconds.
// - To change game server metadata, provide updated game server data.
//
// Once a game server is successfully updated, the relevant statuses and
// timestamps are updated. Learn more Amazon GameLift FleetIQ Guide (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
func (c *Client) UpdateGameServer(ctx context.Context, params *UpdateGameServerInput, optFns ...func(*Options)) (*UpdateGameServerOutput, error) {
if params == nil {
params = &UpdateGameServerInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateGameServer", params, optFns, c.addOperationUpdateGameServerMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateGameServerOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateGameServerInput struct {
// A unique identifier for the game server group where the game server is running.
//
// This member is required.
GameServerGroupName *string
// A custom string that uniquely identifies the game server to update.
//
// This member is required.
GameServerId *string
// A set of custom game server properties, formatted as a single string value.
// This data is passed to a game client or service when it requests information on
// game servers.
GameServerData *string
// Indicates health status of the game server. A request that includes this
// parameter updates the game server's LastHealthCheckTime timestamp.
HealthCheck types.GameServerHealthCheck
// Indicates whether the game server is available or is currently hosting gameplay.
UtilizationStatus types.GameServerUtilizationStatus
noSmithyDocumentSerde
}
type UpdateGameServerOutput struct {
// Object that describes the newly updated game server.
GameServer *types.GameServer
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateGameServerMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateGameServer{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateGameServer{}, 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 = addOpUpdateGameServerValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateGameServer(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
}
func newServiceMetadataMiddleware_opUpdateGameServer(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "UpdateGameServer",
}
}
| 161 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// This operation is used with the Amazon GameLift FleetIQ solution and game
// server groups. Updates Amazon GameLift FleetIQ-specific properties for a game
// server group. Many Auto Scaling group properties are updated on the Auto Scaling
// group directly, including the launch template, Auto Scaling policies, and
// maximum/minimum/desired instance counts. To update the game server group,
// specify the game server group ID and provide the updated values. Before applying
// the updates, the new values are validated to ensure that Amazon GameLift FleetIQ
// can continue to perform instance balancing activity. If successful, a
// GameServerGroup object is returned. Learn more Amazon GameLift FleetIQ Guide (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
func (c *Client) UpdateGameServerGroup(ctx context.Context, params *UpdateGameServerGroupInput, optFns ...func(*Options)) (*UpdateGameServerGroupOutput, error) {
if params == nil {
params = &UpdateGameServerGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateGameServerGroup", params, optFns, c.addOperationUpdateGameServerGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateGameServerGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateGameServerGroupInput struct {
// A unique identifier for the game server group. Use either the name or ARN value.
//
// This member is required.
GameServerGroupName *string
// Indicates how Amazon GameLift FleetIQ balances the use of Spot Instances and
// On-Demand Instances in the game server group. Method options include the
// following:
// - SPOT_ONLY - Only Spot Instances are used in the game server group. If Spot
// Instances are unavailable or not viable for game hosting, the game server group
// provides no hosting capacity until Spot Instances can again be used. Until then,
// no new instances are started, and the existing nonviable Spot Instances are
// terminated (after current gameplay ends) and are not replaced.
// - SPOT_PREFERRED - (default value) Spot Instances are used whenever available
// in the game server group. If Spot Instances are unavailable, the game server
// group continues to provide hosting capacity by falling back to On-Demand
// Instances. Existing nonviable Spot Instances are terminated (after current
// gameplay ends) and are replaced with new On-Demand Instances.
// - ON_DEMAND_ONLY - Only On-Demand Instances are used in the game server group.
// No Spot Instances are used, even when available, while this balancing strategy
// is in force.
BalancingStrategy types.BalancingStrategy
// A flag that indicates whether instances in the game server group are protected
// from early termination. Unprotected instances that have active game servers
// running might be terminated during a scale-down event, causing players to be
// dropped from the game. Protected instances cannot be terminated while there are
// active game servers running except in the event of a forced game server group
// deletion (see ). An exception to this is with Spot Instances, which can be
// terminated by Amazon Web Services regardless of protection status. This property
// is set to NO_PROTECTION by default.
GameServerProtectionPolicy types.GameServerProtectionPolicy
// An updated list of Amazon EC2 instance types to use in the Auto Scaling group.
// The instance definitions must specify at least two different instance types that
// are supported by Amazon GameLift FleetIQ. This updated list replaces the entire
// current list of instance definitions for the game server group. For more
// information on instance types, see EC2 Instance Types (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html)
// in the Amazon EC2 User Guide. You can optionally specify capacity weighting for
// each instance type. If no weight value is specified for an instance type, it is
// set to the default value "1". For more information about capacity weighting, see
// Instance Weighting for Amazon EC2 Auto Scaling (https://docs.aws.amazon.com/autoscaling/ec2/userguide/asg-instance-weighting.html)
// in the Amazon EC2 Auto Scaling User Guide.
InstanceDefinitions []types.InstanceDefinition
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) for an IAM role that allows Amazon GameLift to access your Amazon EC2 Auto
// Scaling groups.
RoleArn *string
noSmithyDocumentSerde
}
type UpdateGameServerGroupOutput struct {
// An object that describes the game server group resource with updated properties.
GameServerGroup *types.GameServerGroup
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateGameServerGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateGameServerGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateGameServerGroup{}, 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 = addOpUpdateGameServerGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateGameServerGroup(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
}
func newServiceMetadataMiddleware_opUpdateGameServerGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "UpdateGameServerGroup",
}
}
| 178 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates the mutable properties of a game session. To update a game session,
// specify the game session ID and the values you want to change. If successful,
// the updated GameSession object is returned. All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) UpdateGameSession(ctx context.Context, params *UpdateGameSessionInput, optFns ...func(*Options)) (*UpdateGameSessionOutput, error) {
if params == nil {
params = &UpdateGameSessionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateGameSession", params, optFns, c.addOperationUpdateGameSessionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateGameSessionOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateGameSessionInput struct {
// A unique identifier for the game session to update.
//
// This member is required.
GameSessionId *string
// The maximum number of players that can be connected simultaneously to the game
// session.
MaximumPlayerSessionCount *int32
// A descriptive label that is associated with a game session. Session names do
// not need to be unique.
Name *string
// A policy that determines whether the game session is accepting new players.
PlayerSessionCreationPolicy types.PlayerSessionCreationPolicy
// Game session protection policy to apply to this game session only.
// - NoProtection -- The game session can be terminated during a scale-down
// event.
// - FullProtection -- If the game session is in an ACTIVE status, it cannot be
// terminated during a scale-down event.
ProtectionPolicy types.ProtectionPolicy
noSmithyDocumentSerde
}
type UpdateGameSessionOutput struct {
// The updated game session properties.
GameSession *types.GameSession
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateGameSessionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateGameSession{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateGameSession{}, 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 = addOpUpdateGameSessionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateGameSession(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
}
func newServiceMetadataMiddleware_opUpdateGameSession(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "UpdateGameSession",
}
}
| 145 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates the configuration of a game session queue, which determines how the
// queue processes new game session requests. To update settings, specify the queue
// name to be updated and provide the new settings. When updating destinations,
// provide a complete list of destinations. Learn more Using Multi-Region Queues (https://docs.aws.amazon.com/gamelift/latest/developerguide/queues-intro.html)
func (c *Client) UpdateGameSessionQueue(ctx context.Context, params *UpdateGameSessionQueueInput, optFns ...func(*Options)) (*UpdateGameSessionQueueOutput, error) {
if params == nil {
params = &UpdateGameSessionQueueInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateGameSessionQueue", params, optFns, c.addOperationUpdateGameSessionQueueMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateGameSessionQueueOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateGameSessionQueueInput struct {
// A descriptive label that is associated with game session queue. Queue names
// must be unique within each Region. You can use either the queue ID or ARN value.
//
// This member is required.
Name *string
// Information to be added to all events that are related to this game session
// queue.
CustomEventData *string
// A list of fleets and/or fleet aliases that can be used to fulfill game session
// placement requests in the queue. Destinations are identified by either a fleet
// ARN or a fleet alias ARN, and are listed in order of placement preference. When
// updating this list, provide a complete list of destinations.
Destinations []types.GameSessionQueueDestination
// A list of locations where a queue is allowed to place new game sessions.
// Locations are specified in the form of Amazon Web Services Region codes, such as
// us-west-2 . If this parameter is not set, game sessions can be placed in any
// queue location. To remove an existing filter configuration, pass in an empty
// set.
FilterConfiguration *types.FilterConfiguration
// An SNS topic ARN that is set up to receive game session placement
// notifications. See Setting up notifications for game session placement (https://docs.aws.amazon.com/gamelift/latest/developerguide/queue-notification.html)
// .
NotificationTarget *string
// A set of policies that act as a sliding cap on player latency. FleetIQ works to
// deliver low latency for most players in a game session. These policies ensure
// that no individual player can be placed into a game with unreasonably high
// latency. Use multiple policies to gradually relax latency requirements a step at
// a time. Multiple policies are applied based on their maximum allowed latency,
// starting with the lowest value. When updating policies, provide a complete
// collection of policies.
PlayerLatencyPolicies []types.PlayerLatencyPolicy
// Custom settings to use when prioritizing destinations and locations for game
// session placements. This configuration replaces the FleetIQ default
// prioritization process. Priority types that are not explicitly named will be
// automatically applied at the end of the prioritization process. To remove an
// existing priority configuration, pass in an empty set.
PriorityConfiguration *types.PriorityConfiguration
// The maximum time, in seconds, that a new game session placement request remains
// in the queue. When a request exceeds this time, the game session placement
// changes to a TIMED_OUT status. By default, this property is set to 600 .
TimeoutInSeconds *int32
noSmithyDocumentSerde
}
type UpdateGameSessionQueueOutput struct {
// An object that describes the newly updated game session queue.
GameSessionQueue *types.GameSessionQueue
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateGameSessionQueueMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateGameSessionQueue{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateGameSessionQueue{}, 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 = addOpUpdateGameSessionQueueValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateGameSessionQueue(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
}
func newServiceMetadataMiddleware_opUpdateGameSessionQueue(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "UpdateGameSessionQueue",
}
}
| 172 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates settings for a FlexMatch matchmaking configuration. These changes
// affect all matches and game sessions that are created after the update. To
// update settings, specify the configuration name to be updated and provide the
// new settings. Learn more Design a FlexMatch matchmaker (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-configuration.html)
func (c *Client) UpdateMatchmakingConfiguration(ctx context.Context, params *UpdateMatchmakingConfigurationInput, optFns ...func(*Options)) (*UpdateMatchmakingConfigurationOutput, error) {
if params == nil {
params = &UpdateMatchmakingConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateMatchmakingConfiguration", params, optFns, c.addOperationUpdateMatchmakingConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateMatchmakingConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateMatchmakingConfigurationInput struct {
// A unique identifier for the matchmaking configuration to update. You can use
// either the configuration name or ARN value.
//
// This member is required.
Name *string
// A flag that indicates whether a match that was created with this configuration
// must be accepted by the matched players. To require acceptance, set to TRUE.
// With this option enabled, matchmaking tickets use the status REQUIRES_ACCEPTANCE
// to indicate when a completed potential match is waiting for player acceptance.
AcceptanceRequired *bool
// The length of time (in seconds) to wait for players to accept a proposed match,
// if acceptance is required.
AcceptanceTimeoutSeconds *int32
// The number of player slots in a match to keep open for future players. For
// example, if the configuration's rule set specifies a match for a single
// 10-person team, and the additional player count is set to 2, 10 players will be
// selected for the match and 2 more player slots will be open for future players.
// This parameter is not used if FlexMatchMode is set to STANDALONE .
AdditionalPlayerCount *int32
// The method that is used to backfill game sessions created with this matchmaking
// configuration. Specify MANUAL when your game manages backfill requests manually
// or does not use the match backfill feature. Specify AUTOMATIC to have GameLift
// create a match backfill request whenever a game session has one or more open
// slots. Learn more about manual and automatic backfill in Backfill Existing
// Games with FlexMatch (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-backfill.html)
// . Automatic backfill is not available when FlexMatchMode is set to STANDALONE .
BackfillMode types.BackfillMode
// Information to add to all events related to the matchmaking configuration.
CustomEventData *string
// A description for the matchmaking configuration.
Description *string
// Indicates whether this matchmaking configuration is being used with Amazon
// GameLift hosting or as a standalone matchmaking solution.
// - STANDALONE - FlexMatch forms matches and returns match information,
// including players and team assignments, in a MatchmakingSucceeded (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-events.html#match-events-matchmakingsucceeded)
// event.
// - WITH_QUEUE - FlexMatch forms matches and uses the specified Amazon GameLift
// queue to start a game session for the match.
FlexMatchMode types.FlexMatchMode
// A set of custom properties for a game session, formatted as key:value pairs.
// These properties are passed to a game server process with a request to start a
// new game session (see Start a Game Session (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession)
// ). This information is added to the new GameSession object that is created for
// a successful match. This parameter is not used if FlexMatchMode is set to
// STANDALONE .
GameProperties []types.GameProperty
// A set of custom game session properties, formatted as a single string value.
// This data is passed to a game server process with a request to start a new game
// session (see Start a Game Session (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession)
// ). This information is added to the game session that is created for a
// successful match. This parameter is not used if FlexMatchMode is set to
// STANDALONE .
GameSessionData *string
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift game session queue resource and uniquely
// identifies it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::gamesessionqueue/ . Queues can be located in any Region.
// Queues are used to start new Amazon GameLift-hosted game sessions for matches
// that are created with this matchmaking configuration. If FlexMatchMode is set
// to STANDALONE , do not set this parameter.
GameSessionQueueArns []string
// An SNS topic ARN that is set up to receive matchmaking notifications. See
// Setting up notifications for matchmaking (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-notification.html)
// for more information.
NotificationTarget *string
// The maximum duration, in seconds, that a matchmaking ticket can remain in
// process before timing out. Requests that fail due to timing out can be
// resubmitted as needed.
RequestTimeoutSeconds *int32
// A unique identifier for the matchmaking rule set to use with this
// configuration. You can use either the rule set name or ARN value. A matchmaking
// configuration can only use rule sets that are defined in the same Region.
RuleSetName *string
noSmithyDocumentSerde
}
type UpdateMatchmakingConfigurationOutput struct {
// The updated matchmaking configuration.
Configuration *types.MatchmakingConfiguration
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateMatchmakingConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateMatchmakingConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateMatchmakingConfiguration{}, 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 = addOpUpdateMatchmakingConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateMatchmakingConfiguration(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
}
func newServiceMetadataMiddleware_opUpdateMatchmakingConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "UpdateMatchmakingConfiguration",
}
}
| 210 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates the current runtime configuration for the specified fleet, which tells
// Amazon GameLift how to launch server processes on all instances in the fleet.
// You can update a fleet's runtime configuration at any time after the fleet is
// created; it does not need to be in ACTIVE status. To update runtime
// configuration, specify the fleet ID and provide a RuntimeConfiguration with an
// updated set of server process configurations. If successful, the fleet's runtime
// configuration settings are updated. Each instance in the fleet regularly checks
// for and retrieves updated runtime configurations. Instances immediately begin
// complying with the new configuration by launching new server processes or not
// replacing existing processes when they shut down. Updating a fleet's runtime
// configuration never affects existing server processes. Learn more Setting up
// Amazon GameLift fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
func (c *Client) UpdateRuntimeConfiguration(ctx context.Context, params *UpdateRuntimeConfigurationInput, optFns ...func(*Options)) (*UpdateRuntimeConfigurationOutput, error) {
if params == nil {
params = &UpdateRuntimeConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateRuntimeConfiguration", params, optFns, c.addOperationUpdateRuntimeConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateRuntimeConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateRuntimeConfigurationInput struct {
// A unique identifier for the fleet to update runtime configuration for. You can
// use either the fleet ID or ARN value.
//
// This member is required.
FleetId *string
// Instructions for launching server processes on each instance in the fleet.
// Server processes run either a custom game build executable or a Realtime Servers
// script. The runtime configuration lists the types of server processes to run on
// an instance, how to launch them, and the number of processes to run
// concurrently.
//
// This member is required.
RuntimeConfiguration *types.RuntimeConfiguration
noSmithyDocumentSerde
}
type UpdateRuntimeConfigurationOutput struct {
// The runtime configuration currently in use by all instances in the fleet. If
// the update was successful, all property changes are shown.
RuntimeConfiguration *types.RuntimeConfiguration
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateRuntimeConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateRuntimeConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateRuntimeConfiguration{}, 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 = addOpUpdateRuntimeConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateRuntimeConfiguration(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
}
func newServiceMetadataMiddleware_opUpdateRuntimeConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "UpdateRuntimeConfiguration",
}
}
| 147 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates Realtime script metadata and content. To update script metadata,
// specify the script ID and provide updated name and/or version values. To update
// script content, provide an updated zip file by pointing to either a local file
// or an Amazon S3 bucket location. You can use either method regardless of how the
// original script was uploaded. Use the Version parameter to track updates to the
// script. If the call is successful, the updated metadata is stored in the script
// record and a revised script is uploaded to the Amazon GameLift service. Once the
// script is updated and acquired by a fleet instance, the new version is used for
// all new game sessions. Learn more Amazon GameLift Realtime Servers (https://docs.aws.amazon.com/gamelift/latest/developerguide/realtime-intro.html)
// Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
func (c *Client) UpdateScript(ctx context.Context, params *UpdateScriptInput, optFns ...func(*Options)) (*UpdateScriptOutput, error) {
if params == nil {
params = &UpdateScriptInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateScript", params, optFns, c.addOperationUpdateScriptMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateScriptOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateScriptInput struct {
// A unique identifier for the Realtime script to update. You can use either the
// script ID or ARN value.
//
// This member is required.
ScriptId *string
// A descriptive label that is associated with a script. Script names don't need
// to be unique.
Name *string
// The location of the Amazon S3 bucket where a zipped file containing your
// Realtime scripts is stored. The storage location must specify the Amazon S3
// bucket name, the zip file name (the "key"), and a role ARN that allows Amazon
// GameLift to access the Amazon S3 storage location. The S3 bucket must be in the
// same Region where you want to create a new script. By default, Amazon GameLift
// uploads the latest version of the zip file; if you have S3 object versioning
// turned on, you can use the ObjectVersion parameter to specify an earlier
// version.
StorageLocation *types.S3Location
// Version information associated with a build or script. Version strings don't
// need to be unique.
Version *string
// A data object containing your Realtime scripts and dependencies as a zip file.
// The zip file can have one or multiple files. Maximum size of a zip file is 5 MB.
// When using the Amazon Web Services CLI tool to create a script, this parameter
// is set to the zip file name. It must be prepended with the string "fileb://" to
// indicate that the file data is a binary object. For example: --zip-file
// fileb://myRealtimeScript.zip .
ZipFile []byte
noSmithyDocumentSerde
}
type UpdateScriptOutput struct {
// The newly created script record with a unique script ID. The new script's
// storage location reflects an Amazon S3 location: (1) If the script was uploaded
// from an S3 bucket under your account, the storage location reflects the
// information that was provided in the CreateScript request; (2) If the script
// file was uploaded from a local zip file, the storage location reflects an S3
// location controls by the Amazon GameLift service.
Script *types.Script
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateScriptMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateScript{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateScript{}, 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 = addOpUpdateScriptValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateScript(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
}
func newServiceMetadataMiddleware_opUpdateScript(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "UpdateScript",
}
}
| 166 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Validates the syntax of a matchmaking rule or rule set. This operation checks
// that the rule set is using syntactically correct JSON and that it conforms to
// allowed property expressions. To validate syntax, provide a rule set JSON
// string. Learn more
// - Build a rule set (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-rulesets.html)
func (c *Client) ValidateMatchmakingRuleSet(ctx context.Context, params *ValidateMatchmakingRuleSetInput, optFns ...func(*Options)) (*ValidateMatchmakingRuleSetOutput, error) {
if params == nil {
params = &ValidateMatchmakingRuleSetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ValidateMatchmakingRuleSet", params, optFns, c.addOperationValidateMatchmakingRuleSetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ValidateMatchmakingRuleSetOutput)
out.ResultMetadata = metadata
return out, nil
}
type ValidateMatchmakingRuleSetInput struct {
// A collection of matchmaking rules to validate, formatted as a JSON string.
//
// This member is required.
RuleSetBody *string
noSmithyDocumentSerde
}
type ValidateMatchmakingRuleSetOutput struct {
// A response indicating whether the rule set is valid.
Valid *bool
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationValidateMatchmakingRuleSetMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpValidateMatchmakingRuleSet{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpValidateMatchmakingRuleSet{}, 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 = addOpValidateMatchmakingRuleSetValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opValidateMatchmakingRuleSet(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
}
func newServiceMetadataMiddleware_opValidateMatchmakingRuleSet(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamelift",
OperationName: "ValidateMatchmakingRuleSet",
}
}
| 128 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
// Package gamelift provides the API client, operations, and parameter types for
// Amazon GameLift.
//
// Amazon GameLift provides solutions for hosting session-based multiplayer game
// servers in the cloud, including tools for deploying, operating, and scaling game
// servers. Built on Amazon Web Services global computing infrastructure, GameLift
// helps you deliver high-performance, high-reliability, low-cost game servers
// while dynamically scaling your resource usage to meet player demand. About
// Amazon GameLift solutions Get more information on these Amazon GameLift
// solutions in the Amazon GameLift Developer Guide (https://docs.aws.amazon.com/gamelift/latest/developerguide/)
// .
// - Amazon GameLift managed hosting -- Amazon GameLift offers a fully managed
// service to set up and maintain computing machines for hosting, manage game
// session and player session life cycle, and handle security, storage, and
// performance tracking. You can use automatic scaling tools to balance player
// demand and hosting costs, configure your game session management to minimize
// player latency, and add FlexMatch for matchmaking.
// - Managed hosting with Realtime Servers -- With Amazon GameLift Realtime
// Servers, you can quickly configure and set up ready-to-go game servers for your
// game. Realtime Servers provides a game server framework with core Amazon
// GameLift infrastructure already built in. Then use the full range of Amazon
// GameLift managed hosting features, including FlexMatch, for your game.
// - Amazon GameLift FleetIQ -- Use Amazon GameLift FleetIQ as a standalone
// service while hosting your games using EC2 instances and Auto Scaling groups.
// Amazon GameLift FleetIQ provides optimizations for game hosting, including
// boosting the viability of low-cost Spot Instances gaming. For a complete
// solution, pair the Amazon GameLift FleetIQ and FlexMatch standalone services.
// - Amazon GameLift FlexMatch -- Add matchmaking to your game hosting solution.
// FlexMatch is a customizable matchmaking service for multiplayer games. Use
// FlexMatch as integrated with Amazon GameLift managed hosting or incorporate
// FlexMatch as a standalone service into your own hosting solution.
//
// About this API Reference This reference guide describes the low-level service
// API for Amazon GameLift. With each topic in this guide, you can find links to
// language-specific SDK guides and the Amazon Web Services CLI reference. Useful
// links:
// - Amazon GameLift API operations listed by tasks (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html)
// - Amazon GameLift tools and resources (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-components.html)
package gamelift
| 42 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
import (
"context"
"errors"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
internalendpoints "github.com/aws/aws-sdk-go-v2/service/gamelift/internal/endpoints"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net/url"
"strings"
)
// EndpointResolverOptions is the service endpoint resolver options
type EndpointResolverOptions = internalendpoints.Options
// EndpointResolver interface for resolving service endpoints.
type EndpointResolver interface {
ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
}
var _ EndpointResolver = &internalendpoints.Resolver{}
// NewDefaultEndpointResolver constructs a new service endpoint resolver
func NewDefaultEndpointResolver() *internalendpoints.Resolver {
return internalendpoints.New()
}
// EndpointResolverFunc is a helper utility that wraps a function so it satisfies
// the EndpointResolver interface. This is useful when you want to add additional
// endpoint resolving logic, or stub out specific endpoints with custom values.
type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)
func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
return fn(region, options)
}
func resolveDefaultEndpointConfiguration(o *Options) {
if o.EndpointResolver != nil {
return
}
o.EndpointResolver = NewDefaultEndpointResolver()
}
// EndpointResolverFromURL returns an EndpointResolver configured using the
// provided endpoint url. By default, the resolved endpoint resolver uses the
// client region as signing region, and the endpoint source is set to
// EndpointSourceCustom.You can provide functional options to configure endpoint
// values for the resolved endpoint.
func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver {
e := aws.Endpoint{URL: url, Source: aws.EndpointSourceCustom}
for _, fn := range optFns {
fn(&e)
}
return EndpointResolverFunc(
func(region string, options EndpointResolverOptions) (aws.Endpoint, error) {
if len(e.SigningRegion) == 0 {
e.SigningRegion = region
}
return e, nil
},
)
}
type ResolveEndpoint struct {
Resolver EndpointResolver
Options EndpointResolverOptions
}
func (*ResolveEndpoint) ID() string {
return "ResolveEndpoint"
}
func (m *ResolveEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
if m.Resolver == nil {
return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
}
eo := m.Options
eo.Logger = middleware.GetLogger(ctx)
var endpoint aws.Endpoint
endpoint, err = m.Resolver.ResolveEndpoint(awsmiddleware.GetRegion(ctx), eo)
if err != nil {
return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err)
}
req.URL, err = url.Parse(endpoint.URL)
if err != nil {
return out, metadata, fmt.Errorf("failed to parse endpoint URL: %w", err)
}
if len(awsmiddleware.GetSigningName(ctx)) == 0 {
signingName := endpoint.SigningName
if len(signingName) == 0 {
signingName = "gamelift"
}
ctx = awsmiddleware.SetSigningName(ctx, signingName)
}
ctx = awsmiddleware.SetEndpointSource(ctx, endpoint.Source)
ctx = smithyhttp.SetHostnameImmutable(ctx, endpoint.HostnameImmutable)
ctx = awsmiddleware.SetSigningRegion(ctx, endpoint.SigningRegion)
ctx = awsmiddleware.SetPartitionID(ctx, endpoint.PartitionID)
return next.HandleSerialize(ctx, in)
}
func addResolveEndpointMiddleware(stack *middleware.Stack, o Options) error {
return stack.Serialize.Insert(&ResolveEndpoint{
Resolver: o.EndpointResolver,
Options: o.EndpointOptions,
}, "OperationSerializer", middleware.Before)
}
func removeResolveEndpointMiddleware(stack *middleware.Stack) error {
_, err := stack.Serialize.Remove((&ResolveEndpoint{}).ID())
return err
}
type wrappedEndpointResolver struct {
awsResolver aws.EndpointResolverWithOptions
resolver EndpointResolver
}
func (w *wrappedEndpointResolver) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
if w.awsResolver == nil {
goto fallback
}
endpoint, err = w.awsResolver.ResolveEndpoint(ServiceID, region, options)
if err == nil {
return endpoint, nil
}
if nf := (&aws.EndpointNotFoundError{}); !errors.As(err, &nf) {
return endpoint, err
}
fallback:
if w.resolver == nil {
return endpoint, fmt.Errorf("default endpoint resolver provided was nil")
}
return w.resolver.ResolveEndpoint(region, options)
}
type awsEndpointResolverAdaptor func(service, region string) (aws.Endpoint, error)
func (a awsEndpointResolverAdaptor) ResolveEndpoint(service, region string, options ...interface{}) (aws.Endpoint, error) {
return a(service, region)
}
var _ aws.EndpointResolverWithOptions = awsEndpointResolverAdaptor(nil)
// withEndpointResolver returns an EndpointResolver that first delegates endpoint resolution to the awsResolver.
// If awsResolver returns aws.EndpointNotFoundError error, the resolver will use the the provided
// fallbackResolver for resolution.
//
// fallbackResolver must not be nil
func withEndpointResolver(awsResolver aws.EndpointResolver, awsResolverWithOptions aws.EndpointResolverWithOptions, fallbackResolver EndpointResolver) EndpointResolver {
var resolver aws.EndpointResolverWithOptions
if awsResolverWithOptions != nil {
resolver = awsResolverWithOptions
} else if awsResolver != nil {
resolver = awsEndpointResolverAdaptor(awsResolver.ResolveEndpoint)
}
return &wrappedEndpointResolver{
awsResolver: resolver,
resolver: fallbackResolver,
}
}
func finalizeClientEndpointResolverOptions(options *Options) {
options.EndpointOptions.LogDeprecated = options.ClientLogMode.IsDeprecatedUsage()
if len(options.EndpointOptions.ResolvedRegion) == 0 {
const fipsInfix = "-fips-"
const fipsPrefix = "fips-"
const fipsSuffix = "-fips"
if strings.Contains(options.Region, fipsInfix) ||
strings.Contains(options.Region, fipsPrefix) ||
strings.Contains(options.Region, fipsSuffix) {
options.EndpointOptions.ResolvedRegion = strings.ReplaceAll(strings.ReplaceAll(strings.ReplaceAll(
options.Region, fipsInfix, "-"), fipsPrefix, ""), fipsSuffix, "")
options.EndpointOptions.UseFIPSEndpoint = aws.FIPSEndpointStateEnabled
}
}
}
| 201 |
aws-sdk-go-v2 | aws | Go | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT.
package gamelift
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.20.0"
| 7 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
| 4 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
import (
"bytes"
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/gamelift/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/encoding/httpbinding"
smithyjson "github.com/aws/smithy-go/encoding/json"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
"math"
"path"
)
type awsAwsjson11_serializeOpAcceptMatch struct {
}
func (*awsAwsjson11_serializeOpAcceptMatch) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpAcceptMatch) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*AcceptMatchInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.AcceptMatch")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentAcceptMatchInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpClaimGameServer struct {
}
func (*awsAwsjson11_serializeOpClaimGameServer) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpClaimGameServer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ClaimGameServerInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ClaimGameServer")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentClaimGameServerInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateAlias struct {
}
func (*awsAwsjson11_serializeOpCreateAlias) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*CreateAliasInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.CreateAlias")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateAliasInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateBuild struct {
}
func (*awsAwsjson11_serializeOpCreateBuild) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateBuild) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*CreateBuildInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.CreateBuild")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateBuildInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateFleet struct {
}
func (*awsAwsjson11_serializeOpCreateFleet) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateFleet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*CreateFleetInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.CreateFleet")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateFleetInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateFleetLocations struct {
}
func (*awsAwsjson11_serializeOpCreateFleetLocations) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateFleetLocations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*CreateFleetLocationsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.CreateFleetLocations")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateFleetLocationsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateGameServerGroup struct {
}
func (*awsAwsjson11_serializeOpCreateGameServerGroup) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateGameServerGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*CreateGameServerGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.CreateGameServerGroup")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateGameServerGroupInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateGameSession struct {
}
func (*awsAwsjson11_serializeOpCreateGameSession) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateGameSession) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*CreateGameSessionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.CreateGameSession")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateGameSessionInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateGameSessionQueue struct {
}
func (*awsAwsjson11_serializeOpCreateGameSessionQueue) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateGameSessionQueue) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*CreateGameSessionQueueInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.CreateGameSessionQueue")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateGameSessionQueueInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateLocation struct {
}
func (*awsAwsjson11_serializeOpCreateLocation) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateLocation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*CreateLocationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.CreateLocation")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateLocationInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateMatchmakingConfiguration struct {
}
func (*awsAwsjson11_serializeOpCreateMatchmakingConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateMatchmakingConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*CreateMatchmakingConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.CreateMatchmakingConfiguration")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateMatchmakingConfigurationInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateMatchmakingRuleSet struct {
}
func (*awsAwsjson11_serializeOpCreateMatchmakingRuleSet) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateMatchmakingRuleSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*CreateMatchmakingRuleSetInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.CreateMatchmakingRuleSet")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateMatchmakingRuleSetInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreatePlayerSession struct {
}
func (*awsAwsjson11_serializeOpCreatePlayerSession) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreatePlayerSession) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*CreatePlayerSessionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.CreatePlayerSession")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreatePlayerSessionInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreatePlayerSessions struct {
}
func (*awsAwsjson11_serializeOpCreatePlayerSessions) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreatePlayerSessions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*CreatePlayerSessionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.CreatePlayerSessions")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreatePlayerSessionsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateScript struct {
}
func (*awsAwsjson11_serializeOpCreateScript) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateScript) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*CreateScriptInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.CreateScript")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateScriptInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateVpcPeeringAuthorization struct {
}
func (*awsAwsjson11_serializeOpCreateVpcPeeringAuthorization) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateVpcPeeringAuthorization) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*CreateVpcPeeringAuthorizationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.CreateVpcPeeringAuthorization")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateVpcPeeringAuthorizationInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateVpcPeeringConnection struct {
}
func (*awsAwsjson11_serializeOpCreateVpcPeeringConnection) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateVpcPeeringConnection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*CreateVpcPeeringConnectionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.CreateVpcPeeringConnection")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateVpcPeeringConnectionInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteAlias struct {
}
func (*awsAwsjson11_serializeOpDeleteAlias) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DeleteAliasInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DeleteAlias")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteAliasInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteBuild struct {
}
func (*awsAwsjson11_serializeOpDeleteBuild) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteBuild) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DeleteBuildInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DeleteBuild")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteBuildInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteFleet struct {
}
func (*awsAwsjson11_serializeOpDeleteFleet) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteFleet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DeleteFleetInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DeleteFleet")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteFleetInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteFleetLocations struct {
}
func (*awsAwsjson11_serializeOpDeleteFleetLocations) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteFleetLocations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DeleteFleetLocationsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DeleteFleetLocations")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteFleetLocationsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteGameServerGroup struct {
}
func (*awsAwsjson11_serializeOpDeleteGameServerGroup) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteGameServerGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DeleteGameServerGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DeleteGameServerGroup")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteGameServerGroupInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteGameSessionQueue struct {
}
func (*awsAwsjson11_serializeOpDeleteGameSessionQueue) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteGameSessionQueue) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DeleteGameSessionQueueInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DeleteGameSessionQueue")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteGameSessionQueueInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteLocation struct {
}
func (*awsAwsjson11_serializeOpDeleteLocation) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteLocation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DeleteLocationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DeleteLocation")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteLocationInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteMatchmakingConfiguration struct {
}
func (*awsAwsjson11_serializeOpDeleteMatchmakingConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteMatchmakingConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DeleteMatchmakingConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DeleteMatchmakingConfiguration")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteMatchmakingConfigurationInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteMatchmakingRuleSet struct {
}
func (*awsAwsjson11_serializeOpDeleteMatchmakingRuleSet) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteMatchmakingRuleSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DeleteMatchmakingRuleSetInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DeleteMatchmakingRuleSet")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteMatchmakingRuleSetInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteScalingPolicy struct {
}
func (*awsAwsjson11_serializeOpDeleteScalingPolicy) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteScalingPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DeleteScalingPolicyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DeleteScalingPolicy")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteScalingPolicyInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteScript struct {
}
func (*awsAwsjson11_serializeOpDeleteScript) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteScript) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DeleteScriptInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DeleteScript")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteScriptInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteVpcPeeringAuthorization struct {
}
func (*awsAwsjson11_serializeOpDeleteVpcPeeringAuthorization) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteVpcPeeringAuthorization) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DeleteVpcPeeringAuthorizationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DeleteVpcPeeringAuthorization")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteVpcPeeringAuthorizationInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteVpcPeeringConnection struct {
}
func (*awsAwsjson11_serializeOpDeleteVpcPeeringConnection) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteVpcPeeringConnection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DeleteVpcPeeringConnectionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DeleteVpcPeeringConnection")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteVpcPeeringConnectionInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeregisterCompute struct {
}
func (*awsAwsjson11_serializeOpDeregisterCompute) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeregisterCompute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DeregisterComputeInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DeregisterCompute")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeregisterComputeInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeregisterGameServer struct {
}
func (*awsAwsjson11_serializeOpDeregisterGameServer) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeregisterGameServer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DeregisterGameServerInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DeregisterGameServer")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeregisterGameServerInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeAlias struct {
}
func (*awsAwsjson11_serializeOpDescribeAlias) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeAliasInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeAlias")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeAliasInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeBuild struct {
}
func (*awsAwsjson11_serializeOpDescribeBuild) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeBuild) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeBuildInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeBuild")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeBuildInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeCompute struct {
}
func (*awsAwsjson11_serializeOpDescribeCompute) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeCompute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeComputeInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeCompute")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeComputeInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeEC2InstanceLimits struct {
}
func (*awsAwsjson11_serializeOpDescribeEC2InstanceLimits) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeEC2InstanceLimits) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeEC2InstanceLimitsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeEC2InstanceLimits")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeEC2InstanceLimitsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeFleetAttributes struct {
}
func (*awsAwsjson11_serializeOpDescribeFleetAttributes) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeFleetAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeFleetAttributesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeFleetAttributes")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeFleetAttributesInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeFleetCapacity struct {
}
func (*awsAwsjson11_serializeOpDescribeFleetCapacity) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeFleetCapacity) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeFleetCapacityInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeFleetCapacity")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeFleetCapacityInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeFleetEvents struct {
}
func (*awsAwsjson11_serializeOpDescribeFleetEvents) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeFleetEvents) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeFleetEventsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeFleetEvents")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeFleetEventsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeFleetLocationAttributes struct {
}
func (*awsAwsjson11_serializeOpDescribeFleetLocationAttributes) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeFleetLocationAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeFleetLocationAttributesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeFleetLocationAttributes")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeFleetLocationAttributesInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeFleetLocationCapacity struct {
}
func (*awsAwsjson11_serializeOpDescribeFleetLocationCapacity) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeFleetLocationCapacity) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeFleetLocationCapacityInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeFleetLocationCapacity")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeFleetLocationCapacityInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeFleetLocationUtilization struct {
}
func (*awsAwsjson11_serializeOpDescribeFleetLocationUtilization) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeFleetLocationUtilization) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeFleetLocationUtilizationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeFleetLocationUtilization")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeFleetLocationUtilizationInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeFleetPortSettings struct {
}
func (*awsAwsjson11_serializeOpDescribeFleetPortSettings) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeFleetPortSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeFleetPortSettingsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeFleetPortSettings")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeFleetPortSettingsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeFleetUtilization struct {
}
func (*awsAwsjson11_serializeOpDescribeFleetUtilization) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeFleetUtilization) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeFleetUtilizationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeFleetUtilization")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeFleetUtilizationInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeGameServer struct {
}
func (*awsAwsjson11_serializeOpDescribeGameServer) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeGameServer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeGameServerInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeGameServer")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeGameServerInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeGameServerGroup struct {
}
func (*awsAwsjson11_serializeOpDescribeGameServerGroup) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeGameServerGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeGameServerGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeGameServerGroup")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeGameServerGroupInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeGameServerInstances struct {
}
func (*awsAwsjson11_serializeOpDescribeGameServerInstances) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeGameServerInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeGameServerInstancesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeGameServerInstances")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeGameServerInstancesInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeGameSessionDetails struct {
}
func (*awsAwsjson11_serializeOpDescribeGameSessionDetails) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeGameSessionDetails) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeGameSessionDetailsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeGameSessionDetails")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeGameSessionDetailsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeGameSessionPlacement struct {
}
func (*awsAwsjson11_serializeOpDescribeGameSessionPlacement) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeGameSessionPlacement) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeGameSessionPlacementInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeGameSessionPlacement")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeGameSessionPlacementInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeGameSessionQueues struct {
}
func (*awsAwsjson11_serializeOpDescribeGameSessionQueues) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeGameSessionQueues) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeGameSessionQueuesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeGameSessionQueues")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeGameSessionQueuesInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeGameSessions struct {
}
func (*awsAwsjson11_serializeOpDescribeGameSessions) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeGameSessions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeGameSessionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeGameSessions")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeGameSessionsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeInstances struct {
}
func (*awsAwsjson11_serializeOpDescribeInstances) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeInstancesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeInstances")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeInstancesInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeMatchmaking struct {
}
func (*awsAwsjson11_serializeOpDescribeMatchmaking) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeMatchmaking) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeMatchmakingInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeMatchmaking")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeMatchmakingInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeMatchmakingConfigurations struct {
}
func (*awsAwsjson11_serializeOpDescribeMatchmakingConfigurations) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeMatchmakingConfigurations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeMatchmakingConfigurationsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeMatchmakingConfigurations")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeMatchmakingConfigurationsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeMatchmakingRuleSets struct {
}
func (*awsAwsjson11_serializeOpDescribeMatchmakingRuleSets) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeMatchmakingRuleSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeMatchmakingRuleSetsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeMatchmakingRuleSets")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeMatchmakingRuleSetsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribePlayerSessions struct {
}
func (*awsAwsjson11_serializeOpDescribePlayerSessions) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribePlayerSessions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribePlayerSessionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribePlayerSessions")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribePlayerSessionsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeRuntimeConfiguration struct {
}
func (*awsAwsjson11_serializeOpDescribeRuntimeConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeRuntimeConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeRuntimeConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeRuntimeConfiguration")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeRuntimeConfigurationInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeScalingPolicies struct {
}
func (*awsAwsjson11_serializeOpDescribeScalingPolicies) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeScalingPolicies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeScalingPoliciesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeScalingPolicies")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeScalingPoliciesInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeScript struct {
}
func (*awsAwsjson11_serializeOpDescribeScript) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeScript) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeScriptInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeScript")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeScriptInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeVpcPeeringAuthorizations struct {
}
func (*awsAwsjson11_serializeOpDescribeVpcPeeringAuthorizations) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeVpcPeeringAuthorizations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeVpcPeeringAuthorizationsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeVpcPeeringAuthorizations")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeVpcPeeringAuthorizationsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeVpcPeeringConnections struct {
}
func (*awsAwsjson11_serializeOpDescribeVpcPeeringConnections) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeVpcPeeringConnections) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeVpcPeeringConnectionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeVpcPeeringConnections")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeVpcPeeringConnectionsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpGetComputeAccess struct {
}
func (*awsAwsjson11_serializeOpGetComputeAccess) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpGetComputeAccess) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetComputeAccessInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.GetComputeAccess")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentGetComputeAccessInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpGetComputeAuthToken struct {
}
func (*awsAwsjson11_serializeOpGetComputeAuthToken) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpGetComputeAuthToken) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetComputeAuthTokenInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.GetComputeAuthToken")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentGetComputeAuthTokenInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpGetGameSessionLogUrl struct {
}
func (*awsAwsjson11_serializeOpGetGameSessionLogUrl) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpGetGameSessionLogUrl) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetGameSessionLogUrlInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.GetGameSessionLogUrl")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentGetGameSessionLogUrlInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpGetInstanceAccess struct {
}
func (*awsAwsjson11_serializeOpGetInstanceAccess) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpGetInstanceAccess) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetInstanceAccessInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.GetInstanceAccess")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentGetInstanceAccessInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListAliases struct {
}
func (*awsAwsjson11_serializeOpListAliases) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListAliases) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ListAliasesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ListAliases")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListAliasesInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListBuilds struct {
}
func (*awsAwsjson11_serializeOpListBuilds) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListBuilds) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ListBuildsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ListBuilds")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListBuildsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListCompute struct {
}
func (*awsAwsjson11_serializeOpListCompute) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListCompute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ListComputeInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ListCompute")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListComputeInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListFleets struct {
}
func (*awsAwsjson11_serializeOpListFleets) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListFleets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ListFleetsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ListFleets")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListFleetsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListGameServerGroups struct {
}
func (*awsAwsjson11_serializeOpListGameServerGroups) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListGameServerGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ListGameServerGroupsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ListGameServerGroups")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListGameServerGroupsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListGameServers struct {
}
func (*awsAwsjson11_serializeOpListGameServers) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListGameServers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ListGameServersInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ListGameServers")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListGameServersInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListLocations struct {
}
func (*awsAwsjson11_serializeOpListLocations) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListLocations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ListLocationsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ListLocations")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListLocationsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListScripts struct {
}
func (*awsAwsjson11_serializeOpListScripts) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListScripts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ListScriptsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ListScripts")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListScriptsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListTagsForResource struct {
}
func (*awsAwsjson11_serializeOpListTagsForResource) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ListTagsForResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ListTagsForResource")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListTagsForResourceInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpPutScalingPolicy struct {
}
func (*awsAwsjson11_serializeOpPutScalingPolicy) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpPutScalingPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*PutScalingPolicyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.PutScalingPolicy")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentPutScalingPolicyInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpRegisterCompute struct {
}
func (*awsAwsjson11_serializeOpRegisterCompute) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpRegisterCompute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*RegisterComputeInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.RegisterCompute")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentRegisterComputeInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpRegisterGameServer struct {
}
func (*awsAwsjson11_serializeOpRegisterGameServer) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpRegisterGameServer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*RegisterGameServerInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.RegisterGameServer")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentRegisterGameServerInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpRequestUploadCredentials struct {
}
func (*awsAwsjson11_serializeOpRequestUploadCredentials) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpRequestUploadCredentials) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*RequestUploadCredentialsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.RequestUploadCredentials")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentRequestUploadCredentialsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpResolveAlias struct {
}
func (*awsAwsjson11_serializeOpResolveAlias) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpResolveAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ResolveAliasInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ResolveAlias")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentResolveAliasInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpResumeGameServerGroup struct {
}
func (*awsAwsjson11_serializeOpResumeGameServerGroup) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpResumeGameServerGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ResumeGameServerGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ResumeGameServerGroup")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentResumeGameServerGroupInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpSearchGameSessions struct {
}
func (*awsAwsjson11_serializeOpSearchGameSessions) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpSearchGameSessions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*SearchGameSessionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.SearchGameSessions")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentSearchGameSessionsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpStartFleetActions struct {
}
func (*awsAwsjson11_serializeOpStartFleetActions) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpStartFleetActions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*StartFleetActionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.StartFleetActions")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentStartFleetActionsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpStartGameSessionPlacement struct {
}
func (*awsAwsjson11_serializeOpStartGameSessionPlacement) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpStartGameSessionPlacement) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*StartGameSessionPlacementInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.StartGameSessionPlacement")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentStartGameSessionPlacementInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpStartMatchBackfill struct {
}
func (*awsAwsjson11_serializeOpStartMatchBackfill) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpStartMatchBackfill) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*StartMatchBackfillInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.StartMatchBackfill")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentStartMatchBackfillInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpStartMatchmaking struct {
}
func (*awsAwsjson11_serializeOpStartMatchmaking) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpStartMatchmaking) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*StartMatchmakingInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.StartMatchmaking")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentStartMatchmakingInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpStopFleetActions struct {
}
func (*awsAwsjson11_serializeOpStopFleetActions) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpStopFleetActions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*StopFleetActionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.StopFleetActions")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentStopFleetActionsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpStopGameSessionPlacement struct {
}
func (*awsAwsjson11_serializeOpStopGameSessionPlacement) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpStopGameSessionPlacement) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*StopGameSessionPlacementInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.StopGameSessionPlacement")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentStopGameSessionPlacementInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpStopMatchmaking struct {
}
func (*awsAwsjson11_serializeOpStopMatchmaking) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpStopMatchmaking) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*StopMatchmakingInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.StopMatchmaking")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentStopMatchmakingInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpSuspendGameServerGroup struct {
}
func (*awsAwsjson11_serializeOpSuspendGameServerGroup) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpSuspendGameServerGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*SuspendGameServerGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.SuspendGameServerGroup")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentSuspendGameServerGroupInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpTagResource struct {
}
func (*awsAwsjson11_serializeOpTagResource) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*TagResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.TagResource")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUntagResource struct {
}
func (*awsAwsjson11_serializeOpUntagResource) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UntagResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UntagResource")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUntagResourceInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUpdateAlias struct {
}
func (*awsAwsjson11_serializeOpUpdateAlias) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUpdateAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UpdateAliasInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateAlias")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUpdateAliasInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUpdateBuild struct {
}
func (*awsAwsjson11_serializeOpUpdateBuild) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUpdateBuild) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UpdateBuildInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateBuild")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUpdateBuildInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUpdateFleetAttributes struct {
}
func (*awsAwsjson11_serializeOpUpdateFleetAttributes) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUpdateFleetAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UpdateFleetAttributesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateFleetAttributes")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUpdateFleetAttributesInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUpdateFleetCapacity struct {
}
func (*awsAwsjson11_serializeOpUpdateFleetCapacity) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUpdateFleetCapacity) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UpdateFleetCapacityInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateFleetCapacity")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUpdateFleetCapacityInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUpdateFleetPortSettings struct {
}
func (*awsAwsjson11_serializeOpUpdateFleetPortSettings) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUpdateFleetPortSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UpdateFleetPortSettingsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateFleetPortSettings")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUpdateFleetPortSettingsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUpdateGameServer struct {
}
func (*awsAwsjson11_serializeOpUpdateGameServer) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUpdateGameServer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UpdateGameServerInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateGameServer")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUpdateGameServerInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUpdateGameServerGroup struct {
}
func (*awsAwsjson11_serializeOpUpdateGameServerGroup) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUpdateGameServerGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UpdateGameServerGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateGameServerGroup")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUpdateGameServerGroupInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUpdateGameSession struct {
}
func (*awsAwsjson11_serializeOpUpdateGameSession) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUpdateGameSession) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UpdateGameSessionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateGameSession")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUpdateGameSessionInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUpdateGameSessionQueue struct {
}
func (*awsAwsjson11_serializeOpUpdateGameSessionQueue) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUpdateGameSessionQueue) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UpdateGameSessionQueueInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateGameSessionQueue")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUpdateGameSessionQueueInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUpdateMatchmakingConfiguration struct {
}
func (*awsAwsjson11_serializeOpUpdateMatchmakingConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUpdateMatchmakingConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UpdateMatchmakingConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateMatchmakingConfiguration")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUpdateMatchmakingConfigurationInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUpdateRuntimeConfiguration struct {
}
func (*awsAwsjson11_serializeOpUpdateRuntimeConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUpdateRuntimeConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UpdateRuntimeConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateRuntimeConfiguration")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUpdateRuntimeConfigurationInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUpdateScript struct {
}
func (*awsAwsjson11_serializeOpUpdateScript) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUpdateScript) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UpdateScriptInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateScript")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUpdateScriptInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpValidateMatchmakingRuleSet struct {
}
func (*awsAwsjson11_serializeOpValidateMatchmakingRuleSet) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpValidateMatchmakingRuleSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ValidateMatchmakingRuleSetInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ValidateMatchmakingRuleSet")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentValidateMatchmakingRuleSetInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsAwsjson11_serializeDocumentAnywhereConfiguration(v *types.AnywhereConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Cost != nil {
ok := object.Key("Cost")
ok.String(*v.Cost)
}
return nil
}
func awsAwsjson11_serializeDocumentAttributeValue(v *types.AttributeValue, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.N != nil {
ok := object.Key("N")
switch {
case math.IsNaN(*v.N):
ok.String("NaN")
case math.IsInf(*v.N, 1):
ok.String("Infinity")
case math.IsInf(*v.N, -1):
ok.String("-Infinity")
default:
ok.Double(*v.N)
}
}
if v.S != nil {
ok := object.Key("S")
ok.String(*v.S)
}
if v.SDM != nil {
ok := object.Key("SDM")
if err := awsAwsjson11_serializeDocumentPlayerAttributeStringDoubleMap(v.SDM, ok); err != nil {
return err
}
}
if v.SL != nil {
ok := object.Key("SL")
if err := awsAwsjson11_serializeDocumentPlayerAttributeStringList(v.SL, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentCertificateConfiguration(v *types.CertificateConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.CertificateType) > 0 {
ok := object.Key("CertificateType")
ok.String(string(v.CertificateType))
}
return nil
}
func awsAwsjson11_serializeDocumentClaimFilterOption(v *types.ClaimFilterOption, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.InstanceStatuses != nil {
ok := object.Key("InstanceStatuses")
if err := awsAwsjson11_serializeDocumentFilterInstanceStatuses(v.InstanceStatuses, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentDesiredPlayerSession(v *types.DesiredPlayerSession, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.PlayerData != nil {
ok := object.Key("PlayerData")
ok.String(*v.PlayerData)
}
if v.PlayerId != nil {
ok := object.Key("PlayerId")
ok.String(*v.PlayerId)
}
return nil
}
func awsAwsjson11_serializeDocumentDesiredPlayerSessionList(v []types.DesiredPlayerSession, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsAwsjson11_serializeDocumentDesiredPlayerSession(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentFilterConfiguration(v *types.FilterConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AllowedLocations != nil {
ok := object.Key("AllowedLocations")
if err := awsAwsjson11_serializeDocumentLocationList(v.AllowedLocations, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentFilterInstanceStatuses(v []types.FilterInstanceStatus, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(string(v[i]))
}
return nil
}
func awsAwsjson11_serializeDocumentFleetActionList(v []types.FleetAction, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(string(v[i]))
}
return nil
}
func awsAwsjson11_serializeDocumentFleetIdOrArnList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentGameProperty(v *types.GameProperty, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Key != nil {
ok := object.Key("Key")
ok.String(*v.Key)
}
if v.Value != nil {
ok := object.Key("Value")
ok.String(*v.Value)
}
return nil
}
func awsAwsjson11_serializeDocumentGamePropertyList(v []types.GameProperty, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsAwsjson11_serializeDocumentGameProperty(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentGameServerGroupActions(v []types.GameServerGroupAction, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(string(v[i]))
}
return nil
}
func awsAwsjson11_serializeDocumentGameServerGroupAutoScalingPolicy(v *types.GameServerGroupAutoScalingPolicy, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.EstimatedInstanceWarmup != nil {
ok := object.Key("EstimatedInstanceWarmup")
ok.Integer(*v.EstimatedInstanceWarmup)
}
if v.TargetTrackingConfiguration != nil {
ok := object.Key("TargetTrackingConfiguration")
if err := awsAwsjson11_serializeDocumentTargetTrackingConfiguration(v.TargetTrackingConfiguration, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentGameServerInstanceIds(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentGameSessionQueueDestination(v *types.GameSessionQueueDestination, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DestinationArn != nil {
ok := object.Key("DestinationArn")
ok.String(*v.DestinationArn)
}
return nil
}
func awsAwsjson11_serializeDocumentGameSessionQueueDestinationList(v []types.GameSessionQueueDestination, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsAwsjson11_serializeDocumentGameSessionQueueDestination(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentGameSessionQueueNameOrArnList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentInstanceDefinition(v *types.InstanceDefinition, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.InstanceType) > 0 {
ok := object.Key("InstanceType")
ok.String(string(v.InstanceType))
}
if v.WeightedCapacity != nil {
ok := object.Key("WeightedCapacity")
ok.String(*v.WeightedCapacity)
}
return nil
}
func awsAwsjson11_serializeDocumentInstanceDefinitions(v []types.InstanceDefinition, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsAwsjson11_serializeDocumentInstanceDefinition(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentIpPermission(v *types.IpPermission, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FromPort != nil {
ok := object.Key("FromPort")
ok.Integer(*v.FromPort)
}
if v.IpRange != nil {
ok := object.Key("IpRange")
ok.String(*v.IpRange)
}
if len(v.Protocol) > 0 {
ok := object.Key("Protocol")
ok.String(string(v.Protocol))
}
if v.ToPort != nil {
ok := object.Key("ToPort")
ok.Integer(*v.ToPort)
}
return nil
}
func awsAwsjson11_serializeDocumentIpPermissionsList(v []types.IpPermission, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsAwsjson11_serializeDocumentIpPermission(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentLatencyMap(v map[string]int32, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
om.Integer(v[key])
}
return nil
}
func awsAwsjson11_serializeDocumentLaunchTemplateSpecification(v *types.LaunchTemplateSpecification, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LaunchTemplateId != nil {
ok := object.Key("LaunchTemplateId")
ok.String(*v.LaunchTemplateId)
}
if v.LaunchTemplateName != nil {
ok := object.Key("LaunchTemplateName")
ok.String(*v.LaunchTemplateName)
}
if v.Version != nil {
ok := object.Key("Version")
ok.String(*v.Version)
}
return nil
}
func awsAwsjson11_serializeDocumentLocationConfiguration(v *types.LocationConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Location != nil {
ok := object.Key("Location")
ok.String(*v.Location)
}
return nil
}
func awsAwsjson11_serializeDocumentLocationConfigurationList(v []types.LocationConfiguration, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsAwsjson11_serializeDocumentLocationConfiguration(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentLocationFilterList(v []types.LocationFilter, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(string(v[i]))
}
return nil
}
func awsAwsjson11_serializeDocumentLocationList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentMatchmakingConfigurationNameList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentMatchmakingIdList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentMatchmakingRuleSetNameList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentMetricGroupList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentPlayer(v *types.Player, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LatencyInMs != nil {
ok := object.Key("LatencyInMs")
if err := awsAwsjson11_serializeDocumentLatencyMap(v.LatencyInMs, ok); err != nil {
return err
}
}
if v.PlayerAttributes != nil {
ok := object.Key("PlayerAttributes")
if err := awsAwsjson11_serializeDocumentPlayerAttributeMap(v.PlayerAttributes, ok); err != nil {
return err
}
}
if v.PlayerId != nil {
ok := object.Key("PlayerId")
ok.String(*v.PlayerId)
}
if v.Team != nil {
ok := object.Key("Team")
ok.String(*v.Team)
}
return nil
}
func awsAwsjson11_serializeDocumentPlayerAttributeMap(v map[string]types.AttributeValue, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
mapVar := v[key]
if err := awsAwsjson11_serializeDocumentAttributeValue(&mapVar, om); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentPlayerAttributeStringDoubleMap(v map[string]float64, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
switch {
case math.IsNaN(v[key]):
om.String("NaN")
case math.IsInf(v[key], 1):
om.String("Infinity")
case math.IsInf(v[key], -1):
om.String("-Infinity")
default:
om.Double(v[key])
}
}
return nil
}
func awsAwsjson11_serializeDocumentPlayerAttributeStringList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentPlayerDataMap(v map[string]string, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
om.String(v[key])
}
return nil
}
func awsAwsjson11_serializeDocumentPlayerIdList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentPlayerLatency(v *types.PlayerLatency, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LatencyInMilliseconds != 0 {
ok := object.Key("LatencyInMilliseconds")
switch {
case math.IsNaN(float64(v.LatencyInMilliseconds)):
ok.String("NaN")
case math.IsInf(float64(v.LatencyInMilliseconds), 1):
ok.String("Infinity")
case math.IsInf(float64(v.LatencyInMilliseconds), -1):
ok.String("-Infinity")
default:
ok.Float(v.LatencyInMilliseconds)
}
}
if v.PlayerId != nil {
ok := object.Key("PlayerId")
ok.String(*v.PlayerId)
}
if v.RegionIdentifier != nil {
ok := object.Key("RegionIdentifier")
ok.String(*v.RegionIdentifier)
}
return nil
}
func awsAwsjson11_serializeDocumentPlayerLatencyList(v []types.PlayerLatency, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsAwsjson11_serializeDocumentPlayerLatency(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentPlayerLatencyPolicy(v *types.PlayerLatencyPolicy, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.MaximumIndividualPlayerLatencyMilliseconds != nil {
ok := object.Key("MaximumIndividualPlayerLatencyMilliseconds")
ok.Integer(*v.MaximumIndividualPlayerLatencyMilliseconds)
}
if v.PolicyDurationSeconds != nil {
ok := object.Key("PolicyDurationSeconds")
ok.Integer(*v.PolicyDurationSeconds)
}
return nil
}
func awsAwsjson11_serializeDocumentPlayerLatencyPolicyList(v []types.PlayerLatencyPolicy, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsAwsjson11_serializeDocumentPlayerLatencyPolicy(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentPlayerList(v []types.Player, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsAwsjson11_serializeDocumentPlayer(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentPriorityConfiguration(v *types.PriorityConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LocationOrder != nil {
ok := object.Key("LocationOrder")
if err := awsAwsjson11_serializeDocumentLocationList(v.LocationOrder, ok); err != nil {
return err
}
}
if v.PriorityOrder != nil {
ok := object.Key("PriorityOrder")
if err := awsAwsjson11_serializeDocumentPriorityTypeList(v.PriorityOrder, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentPriorityTypeList(v []types.PriorityType, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(string(v[i]))
}
return nil
}
func awsAwsjson11_serializeDocumentQueueArnsList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentResourceCreationLimitPolicy(v *types.ResourceCreationLimitPolicy, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.NewGameSessionsPerCreator != nil {
ok := object.Key("NewGameSessionsPerCreator")
ok.Integer(*v.NewGameSessionsPerCreator)
}
if v.PolicyPeriodInMinutes != nil {
ok := object.Key("PolicyPeriodInMinutes")
ok.Integer(*v.PolicyPeriodInMinutes)
}
return nil
}
func awsAwsjson11_serializeDocumentRoutingStrategy(v *types.RoutingStrategy, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.Message != nil {
ok := object.Key("Message")
ok.String(*v.Message)
}
if len(v.Type) > 0 {
ok := object.Key("Type")
ok.String(string(v.Type))
}
return nil
}
func awsAwsjson11_serializeDocumentRuntimeConfiguration(v *types.RuntimeConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.GameSessionActivationTimeoutSeconds != nil {
ok := object.Key("GameSessionActivationTimeoutSeconds")
ok.Integer(*v.GameSessionActivationTimeoutSeconds)
}
if v.MaxConcurrentGameSessionActivations != nil {
ok := object.Key("MaxConcurrentGameSessionActivations")
ok.Integer(*v.MaxConcurrentGameSessionActivations)
}
if v.ServerProcesses != nil {
ok := object.Key("ServerProcesses")
if err := awsAwsjson11_serializeDocumentServerProcessList(v.ServerProcesses, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentS3Location(v *types.S3Location, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Bucket != nil {
ok := object.Key("Bucket")
ok.String(*v.Bucket)
}
if v.Key != nil {
ok := object.Key("Key")
ok.String(*v.Key)
}
if v.ObjectVersion != nil {
ok := object.Key("ObjectVersion")
ok.String(*v.ObjectVersion)
}
if v.RoleArn != nil {
ok := object.Key("RoleArn")
ok.String(*v.RoleArn)
}
return nil
}
func awsAwsjson11_serializeDocumentServerProcess(v *types.ServerProcess, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ConcurrentExecutions != nil {
ok := object.Key("ConcurrentExecutions")
ok.Integer(*v.ConcurrentExecutions)
}
if v.LaunchPath != nil {
ok := object.Key("LaunchPath")
ok.String(*v.LaunchPath)
}
if v.Parameters != nil {
ok := object.Key("Parameters")
ok.String(*v.Parameters)
}
return nil
}
func awsAwsjson11_serializeDocumentServerProcessList(v []types.ServerProcess, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsAwsjson11_serializeDocumentServerProcess(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentStringList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Key != nil {
ok := object.Key("Key")
ok.String(*v.Key)
}
if v.Value != nil {
ok := object.Key("Value")
ok.String(*v.Value)
}
return nil
}
func awsAwsjson11_serializeDocumentTagKeyList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentTargetConfiguration(v *types.TargetConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
{
ok := object.Key("TargetValue")
switch {
case math.IsNaN(v.TargetValue):
ok.String("NaN")
case math.IsInf(v.TargetValue, 1):
ok.String("Infinity")
case math.IsInf(v.TargetValue, -1):
ok.String("-Infinity")
default:
ok.Double(v.TargetValue)
}
}
return nil
}
func awsAwsjson11_serializeDocumentTargetTrackingConfiguration(v *types.TargetTrackingConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.TargetValue != nil {
ok := object.Key("TargetValue")
switch {
case math.IsNaN(*v.TargetValue):
ok.String("NaN")
case math.IsInf(*v.TargetValue, 1):
ok.String("Infinity")
case math.IsInf(*v.TargetValue, -1):
ok.String("-Infinity")
default:
ok.Double(*v.TargetValue)
}
}
return nil
}
func awsAwsjson11_serializeDocumentVpcSubnets(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeOpDocumentAcceptMatchInput(v *AcceptMatchInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.AcceptanceType) > 0 {
ok := object.Key("AcceptanceType")
ok.String(string(v.AcceptanceType))
}
if v.PlayerIds != nil {
ok := object.Key("PlayerIds")
if err := awsAwsjson11_serializeDocumentStringList(v.PlayerIds, ok); err != nil {
return err
}
}
if v.TicketId != nil {
ok := object.Key("TicketId")
ok.String(*v.TicketId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentClaimGameServerInput(v *ClaimGameServerInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FilterOption != nil {
ok := object.Key("FilterOption")
if err := awsAwsjson11_serializeDocumentClaimFilterOption(v.FilterOption, ok); err != nil {
return err
}
}
if v.GameServerData != nil {
ok := object.Key("GameServerData")
ok.String(*v.GameServerData)
}
if v.GameServerGroupName != nil {
ok := object.Key("GameServerGroupName")
ok.String(*v.GameServerGroupName)
}
if v.GameServerId != nil {
ok := object.Key("GameServerId")
ok.String(*v.GameServerId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateAliasInput(v *CreateAliasInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.RoutingStrategy != nil {
ok := object.Key("RoutingStrategy")
if err := awsAwsjson11_serializeDocumentRoutingStrategy(v.RoutingStrategy, ok); err != nil {
return err
}
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateBuildInput(v *CreateBuildInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if len(v.OperatingSystem) > 0 {
ok := object.Key("OperatingSystem")
ok.String(string(v.OperatingSystem))
}
if v.ServerSdkVersion != nil {
ok := object.Key("ServerSdkVersion")
ok.String(*v.ServerSdkVersion)
}
if v.StorageLocation != nil {
ok := object.Key("StorageLocation")
if err := awsAwsjson11_serializeDocumentS3Location(v.StorageLocation, ok); err != nil {
return err
}
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
if v.Version != nil {
ok := object.Key("Version")
ok.String(*v.Version)
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateFleetInput(v *CreateFleetInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AnywhereConfiguration != nil {
ok := object.Key("AnywhereConfiguration")
if err := awsAwsjson11_serializeDocumentAnywhereConfiguration(v.AnywhereConfiguration, ok); err != nil {
return err
}
}
if v.BuildId != nil {
ok := object.Key("BuildId")
ok.String(*v.BuildId)
}
if v.CertificateConfiguration != nil {
ok := object.Key("CertificateConfiguration")
if err := awsAwsjson11_serializeDocumentCertificateConfiguration(v.CertificateConfiguration, ok); err != nil {
return err
}
}
if len(v.ComputeType) > 0 {
ok := object.Key("ComputeType")
ok.String(string(v.ComputeType))
}
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.EC2InboundPermissions != nil {
ok := object.Key("EC2InboundPermissions")
if err := awsAwsjson11_serializeDocumentIpPermissionsList(v.EC2InboundPermissions, ok); err != nil {
return err
}
}
if len(v.EC2InstanceType) > 0 {
ok := object.Key("EC2InstanceType")
ok.String(string(v.EC2InstanceType))
}
if len(v.FleetType) > 0 {
ok := object.Key("FleetType")
ok.String(string(v.FleetType))
}
if v.InstanceRoleArn != nil {
ok := object.Key("InstanceRoleArn")
ok.String(*v.InstanceRoleArn)
}
if v.Locations != nil {
ok := object.Key("Locations")
if err := awsAwsjson11_serializeDocumentLocationConfigurationList(v.Locations, ok); err != nil {
return err
}
}
if v.LogPaths != nil {
ok := object.Key("LogPaths")
if err := awsAwsjson11_serializeDocumentStringList(v.LogPaths, ok); err != nil {
return err
}
}
if v.MetricGroups != nil {
ok := object.Key("MetricGroups")
if err := awsAwsjson11_serializeDocumentMetricGroupList(v.MetricGroups, ok); err != nil {
return err
}
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if len(v.NewGameSessionProtectionPolicy) > 0 {
ok := object.Key("NewGameSessionProtectionPolicy")
ok.String(string(v.NewGameSessionProtectionPolicy))
}
if v.PeerVpcAwsAccountId != nil {
ok := object.Key("PeerVpcAwsAccountId")
ok.String(*v.PeerVpcAwsAccountId)
}
if v.PeerVpcId != nil {
ok := object.Key("PeerVpcId")
ok.String(*v.PeerVpcId)
}
if v.ResourceCreationLimitPolicy != nil {
ok := object.Key("ResourceCreationLimitPolicy")
if err := awsAwsjson11_serializeDocumentResourceCreationLimitPolicy(v.ResourceCreationLimitPolicy, ok); err != nil {
return err
}
}
if v.RuntimeConfiguration != nil {
ok := object.Key("RuntimeConfiguration")
if err := awsAwsjson11_serializeDocumentRuntimeConfiguration(v.RuntimeConfiguration, ok); err != nil {
return err
}
}
if v.ScriptId != nil {
ok := object.Key("ScriptId")
ok.String(*v.ScriptId)
}
if v.ServerLaunchParameters != nil {
ok := object.Key("ServerLaunchParameters")
ok.String(*v.ServerLaunchParameters)
}
if v.ServerLaunchPath != nil {
ok := object.Key("ServerLaunchPath")
ok.String(*v.ServerLaunchPath)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateFleetLocationsInput(v *CreateFleetLocationsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.Locations != nil {
ok := object.Key("Locations")
if err := awsAwsjson11_serializeDocumentLocationConfigurationList(v.Locations, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateGameServerGroupInput(v *CreateGameServerGroupInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AutoScalingPolicy != nil {
ok := object.Key("AutoScalingPolicy")
if err := awsAwsjson11_serializeDocumentGameServerGroupAutoScalingPolicy(v.AutoScalingPolicy, ok); err != nil {
return err
}
}
if len(v.BalancingStrategy) > 0 {
ok := object.Key("BalancingStrategy")
ok.String(string(v.BalancingStrategy))
}
if v.GameServerGroupName != nil {
ok := object.Key("GameServerGroupName")
ok.String(*v.GameServerGroupName)
}
if len(v.GameServerProtectionPolicy) > 0 {
ok := object.Key("GameServerProtectionPolicy")
ok.String(string(v.GameServerProtectionPolicy))
}
if v.InstanceDefinitions != nil {
ok := object.Key("InstanceDefinitions")
if err := awsAwsjson11_serializeDocumentInstanceDefinitions(v.InstanceDefinitions, ok); err != nil {
return err
}
}
if v.LaunchTemplate != nil {
ok := object.Key("LaunchTemplate")
if err := awsAwsjson11_serializeDocumentLaunchTemplateSpecification(v.LaunchTemplate, ok); err != nil {
return err
}
}
if v.MaxSize != nil {
ok := object.Key("MaxSize")
ok.Integer(*v.MaxSize)
}
if v.MinSize != nil {
ok := object.Key("MinSize")
ok.Integer(*v.MinSize)
}
if v.RoleArn != nil {
ok := object.Key("RoleArn")
ok.String(*v.RoleArn)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
if v.VpcSubnets != nil {
ok := object.Key("VpcSubnets")
if err := awsAwsjson11_serializeDocumentVpcSubnets(v.VpcSubnets, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateGameSessionInput(v *CreateGameSessionInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AliasId != nil {
ok := object.Key("AliasId")
ok.String(*v.AliasId)
}
if v.CreatorId != nil {
ok := object.Key("CreatorId")
ok.String(*v.CreatorId)
}
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.GameProperties != nil {
ok := object.Key("GameProperties")
if err := awsAwsjson11_serializeDocumentGamePropertyList(v.GameProperties, ok); err != nil {
return err
}
}
if v.GameSessionData != nil {
ok := object.Key("GameSessionData")
ok.String(*v.GameSessionData)
}
if v.GameSessionId != nil {
ok := object.Key("GameSessionId")
ok.String(*v.GameSessionId)
}
if v.IdempotencyToken != nil {
ok := object.Key("IdempotencyToken")
ok.String(*v.IdempotencyToken)
}
if v.Location != nil {
ok := object.Key("Location")
ok.String(*v.Location)
}
if v.MaximumPlayerSessionCount != nil {
ok := object.Key("MaximumPlayerSessionCount")
ok.Integer(*v.MaximumPlayerSessionCount)
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateGameSessionQueueInput(v *CreateGameSessionQueueInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CustomEventData != nil {
ok := object.Key("CustomEventData")
ok.String(*v.CustomEventData)
}
if v.Destinations != nil {
ok := object.Key("Destinations")
if err := awsAwsjson11_serializeDocumentGameSessionQueueDestinationList(v.Destinations, ok); err != nil {
return err
}
}
if v.FilterConfiguration != nil {
ok := object.Key("FilterConfiguration")
if err := awsAwsjson11_serializeDocumentFilterConfiguration(v.FilterConfiguration, ok); err != nil {
return err
}
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.NotificationTarget != nil {
ok := object.Key("NotificationTarget")
ok.String(*v.NotificationTarget)
}
if v.PlayerLatencyPolicies != nil {
ok := object.Key("PlayerLatencyPolicies")
if err := awsAwsjson11_serializeDocumentPlayerLatencyPolicyList(v.PlayerLatencyPolicies, ok); err != nil {
return err
}
}
if v.PriorityConfiguration != nil {
ok := object.Key("PriorityConfiguration")
if err := awsAwsjson11_serializeDocumentPriorityConfiguration(v.PriorityConfiguration, ok); err != nil {
return err
}
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
if v.TimeoutInSeconds != nil {
ok := object.Key("TimeoutInSeconds")
ok.Integer(*v.TimeoutInSeconds)
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateLocationInput(v *CreateLocationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LocationName != nil {
ok := object.Key("LocationName")
ok.String(*v.LocationName)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateMatchmakingConfigurationInput(v *CreateMatchmakingConfigurationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AcceptanceRequired != nil {
ok := object.Key("AcceptanceRequired")
ok.Boolean(*v.AcceptanceRequired)
}
if v.AcceptanceTimeoutSeconds != nil {
ok := object.Key("AcceptanceTimeoutSeconds")
ok.Integer(*v.AcceptanceTimeoutSeconds)
}
if v.AdditionalPlayerCount != nil {
ok := object.Key("AdditionalPlayerCount")
ok.Integer(*v.AdditionalPlayerCount)
}
if len(v.BackfillMode) > 0 {
ok := object.Key("BackfillMode")
ok.String(string(v.BackfillMode))
}
if v.CustomEventData != nil {
ok := object.Key("CustomEventData")
ok.String(*v.CustomEventData)
}
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if len(v.FlexMatchMode) > 0 {
ok := object.Key("FlexMatchMode")
ok.String(string(v.FlexMatchMode))
}
if v.GameProperties != nil {
ok := object.Key("GameProperties")
if err := awsAwsjson11_serializeDocumentGamePropertyList(v.GameProperties, ok); err != nil {
return err
}
}
if v.GameSessionData != nil {
ok := object.Key("GameSessionData")
ok.String(*v.GameSessionData)
}
if v.GameSessionQueueArns != nil {
ok := object.Key("GameSessionQueueArns")
if err := awsAwsjson11_serializeDocumentQueueArnsList(v.GameSessionQueueArns, ok); err != nil {
return err
}
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.NotificationTarget != nil {
ok := object.Key("NotificationTarget")
ok.String(*v.NotificationTarget)
}
if v.RequestTimeoutSeconds != nil {
ok := object.Key("RequestTimeoutSeconds")
ok.Integer(*v.RequestTimeoutSeconds)
}
if v.RuleSetName != nil {
ok := object.Key("RuleSetName")
ok.String(*v.RuleSetName)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateMatchmakingRuleSetInput(v *CreateMatchmakingRuleSetInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.RuleSetBody != nil {
ok := object.Key("RuleSetBody")
ok.String(*v.RuleSetBody)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreatePlayerSessionInput(v *CreatePlayerSessionInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.GameSessionId != nil {
ok := object.Key("GameSessionId")
ok.String(*v.GameSessionId)
}
if v.PlayerData != nil {
ok := object.Key("PlayerData")
ok.String(*v.PlayerData)
}
if v.PlayerId != nil {
ok := object.Key("PlayerId")
ok.String(*v.PlayerId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreatePlayerSessionsInput(v *CreatePlayerSessionsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.GameSessionId != nil {
ok := object.Key("GameSessionId")
ok.String(*v.GameSessionId)
}
if v.PlayerDataMap != nil {
ok := object.Key("PlayerDataMap")
if err := awsAwsjson11_serializeDocumentPlayerDataMap(v.PlayerDataMap, ok); err != nil {
return err
}
}
if v.PlayerIds != nil {
ok := object.Key("PlayerIds")
if err := awsAwsjson11_serializeDocumentPlayerIdList(v.PlayerIds, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateScriptInput(v *CreateScriptInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.StorageLocation != nil {
ok := object.Key("StorageLocation")
if err := awsAwsjson11_serializeDocumentS3Location(v.StorageLocation, ok); err != nil {
return err
}
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
if v.Version != nil {
ok := object.Key("Version")
ok.String(*v.Version)
}
if v.ZipFile != nil {
ok := object.Key("ZipFile")
ok.Base64EncodeBytes(v.ZipFile)
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateVpcPeeringAuthorizationInput(v *CreateVpcPeeringAuthorizationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.GameLiftAwsAccountId != nil {
ok := object.Key("GameLiftAwsAccountId")
ok.String(*v.GameLiftAwsAccountId)
}
if v.PeerVpcId != nil {
ok := object.Key("PeerVpcId")
ok.String(*v.PeerVpcId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateVpcPeeringConnectionInput(v *CreateVpcPeeringConnectionInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.PeerVpcAwsAccountId != nil {
ok := object.Key("PeerVpcAwsAccountId")
ok.String(*v.PeerVpcAwsAccountId)
}
if v.PeerVpcId != nil {
ok := object.Key("PeerVpcId")
ok.String(*v.PeerVpcId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteAliasInput(v *DeleteAliasInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AliasId != nil {
ok := object.Key("AliasId")
ok.String(*v.AliasId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteBuildInput(v *DeleteBuildInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.BuildId != nil {
ok := object.Key("BuildId")
ok.String(*v.BuildId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteFleetInput(v *DeleteFleetInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteFleetLocationsInput(v *DeleteFleetLocationsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.Locations != nil {
ok := object.Key("Locations")
if err := awsAwsjson11_serializeDocumentLocationList(v.Locations, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteGameServerGroupInput(v *DeleteGameServerGroupInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.DeleteOption) > 0 {
ok := object.Key("DeleteOption")
ok.String(string(v.DeleteOption))
}
if v.GameServerGroupName != nil {
ok := object.Key("GameServerGroupName")
ok.String(*v.GameServerGroupName)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteGameSessionQueueInput(v *DeleteGameSessionQueueInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteLocationInput(v *DeleteLocationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LocationName != nil {
ok := object.Key("LocationName")
ok.String(*v.LocationName)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteMatchmakingConfigurationInput(v *DeleteMatchmakingConfigurationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteMatchmakingRuleSetInput(v *DeleteMatchmakingRuleSetInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteScalingPolicyInput(v *DeleteScalingPolicyInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteScriptInput(v *DeleteScriptInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ScriptId != nil {
ok := object.Key("ScriptId")
ok.String(*v.ScriptId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteVpcPeeringAuthorizationInput(v *DeleteVpcPeeringAuthorizationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.GameLiftAwsAccountId != nil {
ok := object.Key("GameLiftAwsAccountId")
ok.String(*v.GameLiftAwsAccountId)
}
if v.PeerVpcId != nil {
ok := object.Key("PeerVpcId")
ok.String(*v.PeerVpcId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteVpcPeeringConnectionInput(v *DeleteVpcPeeringConnectionInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.VpcPeeringConnectionId != nil {
ok := object.Key("VpcPeeringConnectionId")
ok.String(*v.VpcPeeringConnectionId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeregisterComputeInput(v *DeregisterComputeInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ComputeName != nil {
ok := object.Key("ComputeName")
ok.String(*v.ComputeName)
}
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeregisterGameServerInput(v *DeregisterGameServerInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.GameServerGroupName != nil {
ok := object.Key("GameServerGroupName")
ok.String(*v.GameServerGroupName)
}
if v.GameServerId != nil {
ok := object.Key("GameServerId")
ok.String(*v.GameServerId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeAliasInput(v *DescribeAliasInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AliasId != nil {
ok := object.Key("AliasId")
ok.String(*v.AliasId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeBuildInput(v *DescribeBuildInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.BuildId != nil {
ok := object.Key("BuildId")
ok.String(*v.BuildId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeComputeInput(v *DescribeComputeInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ComputeName != nil {
ok := object.Key("ComputeName")
ok.String(*v.ComputeName)
}
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeEC2InstanceLimitsInput(v *DescribeEC2InstanceLimitsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.EC2InstanceType) > 0 {
ok := object.Key("EC2InstanceType")
ok.String(string(v.EC2InstanceType))
}
if v.Location != nil {
ok := object.Key("Location")
ok.String(*v.Location)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeFleetAttributesInput(v *DescribeFleetAttributesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetIds != nil {
ok := object.Key("FleetIds")
if err := awsAwsjson11_serializeDocumentFleetIdOrArnList(v.FleetIds, ok); err != nil {
return err
}
}
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeFleetCapacityInput(v *DescribeFleetCapacityInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetIds != nil {
ok := object.Key("FleetIds")
if err := awsAwsjson11_serializeDocumentFleetIdOrArnList(v.FleetIds, ok); err != nil {
return err
}
}
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeFleetEventsInput(v *DescribeFleetEventsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.EndTime != nil {
ok := object.Key("EndTime")
ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
}
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.StartTime != nil {
ok := object.Key("StartTime")
ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeFleetLocationAttributesInput(v *DescribeFleetLocationAttributesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.Locations != nil {
ok := object.Key("Locations")
if err := awsAwsjson11_serializeDocumentLocationList(v.Locations, ok); err != nil {
return err
}
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeFleetLocationCapacityInput(v *DescribeFleetLocationCapacityInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.Location != nil {
ok := object.Key("Location")
ok.String(*v.Location)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeFleetLocationUtilizationInput(v *DescribeFleetLocationUtilizationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.Location != nil {
ok := object.Key("Location")
ok.String(*v.Location)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeFleetPortSettingsInput(v *DescribeFleetPortSettingsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.Location != nil {
ok := object.Key("Location")
ok.String(*v.Location)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeFleetUtilizationInput(v *DescribeFleetUtilizationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetIds != nil {
ok := object.Key("FleetIds")
if err := awsAwsjson11_serializeDocumentFleetIdOrArnList(v.FleetIds, ok); err != nil {
return err
}
}
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeGameServerGroupInput(v *DescribeGameServerGroupInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.GameServerGroupName != nil {
ok := object.Key("GameServerGroupName")
ok.String(*v.GameServerGroupName)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeGameServerInput(v *DescribeGameServerInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.GameServerGroupName != nil {
ok := object.Key("GameServerGroupName")
ok.String(*v.GameServerGroupName)
}
if v.GameServerId != nil {
ok := object.Key("GameServerId")
ok.String(*v.GameServerId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeGameServerInstancesInput(v *DescribeGameServerInstancesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.GameServerGroupName != nil {
ok := object.Key("GameServerGroupName")
ok.String(*v.GameServerGroupName)
}
if v.InstanceIds != nil {
ok := object.Key("InstanceIds")
if err := awsAwsjson11_serializeDocumentGameServerInstanceIds(v.InstanceIds, ok); err != nil {
return err
}
}
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeGameSessionDetailsInput(v *DescribeGameSessionDetailsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AliasId != nil {
ok := object.Key("AliasId")
ok.String(*v.AliasId)
}
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.GameSessionId != nil {
ok := object.Key("GameSessionId")
ok.String(*v.GameSessionId)
}
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.Location != nil {
ok := object.Key("Location")
ok.String(*v.Location)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.StatusFilter != nil {
ok := object.Key("StatusFilter")
ok.String(*v.StatusFilter)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeGameSessionPlacementInput(v *DescribeGameSessionPlacementInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.PlacementId != nil {
ok := object.Key("PlacementId")
ok.String(*v.PlacementId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeGameSessionQueuesInput(v *DescribeGameSessionQueuesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.Names != nil {
ok := object.Key("Names")
if err := awsAwsjson11_serializeDocumentGameSessionQueueNameOrArnList(v.Names, ok); err != nil {
return err
}
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeGameSessionsInput(v *DescribeGameSessionsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AliasId != nil {
ok := object.Key("AliasId")
ok.String(*v.AliasId)
}
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.GameSessionId != nil {
ok := object.Key("GameSessionId")
ok.String(*v.GameSessionId)
}
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.Location != nil {
ok := object.Key("Location")
ok.String(*v.Location)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.StatusFilter != nil {
ok := object.Key("StatusFilter")
ok.String(*v.StatusFilter)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeInstancesInput(v *DescribeInstancesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.InstanceId != nil {
ok := object.Key("InstanceId")
ok.String(*v.InstanceId)
}
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.Location != nil {
ok := object.Key("Location")
ok.String(*v.Location)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeMatchmakingConfigurationsInput(v *DescribeMatchmakingConfigurationsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.Names != nil {
ok := object.Key("Names")
if err := awsAwsjson11_serializeDocumentMatchmakingConfigurationNameList(v.Names, ok); err != nil {
return err
}
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.RuleSetName != nil {
ok := object.Key("RuleSetName")
ok.String(*v.RuleSetName)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeMatchmakingInput(v *DescribeMatchmakingInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.TicketIds != nil {
ok := object.Key("TicketIds")
if err := awsAwsjson11_serializeDocumentMatchmakingIdList(v.TicketIds, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeMatchmakingRuleSetsInput(v *DescribeMatchmakingRuleSetsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.Names != nil {
ok := object.Key("Names")
if err := awsAwsjson11_serializeDocumentMatchmakingRuleSetNameList(v.Names, ok); err != nil {
return err
}
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribePlayerSessionsInput(v *DescribePlayerSessionsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.GameSessionId != nil {
ok := object.Key("GameSessionId")
ok.String(*v.GameSessionId)
}
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.PlayerId != nil {
ok := object.Key("PlayerId")
ok.String(*v.PlayerId)
}
if v.PlayerSessionId != nil {
ok := object.Key("PlayerSessionId")
ok.String(*v.PlayerSessionId)
}
if v.PlayerSessionStatusFilter != nil {
ok := object.Key("PlayerSessionStatusFilter")
ok.String(*v.PlayerSessionStatusFilter)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeRuntimeConfigurationInput(v *DescribeRuntimeConfigurationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeScalingPoliciesInput(v *DescribeScalingPoliciesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.Location != nil {
ok := object.Key("Location")
ok.String(*v.Location)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if len(v.StatusFilter) > 0 {
ok := object.Key("StatusFilter")
ok.String(string(v.StatusFilter))
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeScriptInput(v *DescribeScriptInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ScriptId != nil {
ok := object.Key("ScriptId")
ok.String(*v.ScriptId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeVpcPeeringAuthorizationsInput(v *DescribeVpcPeeringAuthorizationsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeVpcPeeringConnectionsInput(v *DescribeVpcPeeringConnectionsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentGetComputeAccessInput(v *GetComputeAccessInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ComputeName != nil {
ok := object.Key("ComputeName")
ok.String(*v.ComputeName)
}
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentGetComputeAuthTokenInput(v *GetComputeAuthTokenInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ComputeName != nil {
ok := object.Key("ComputeName")
ok.String(*v.ComputeName)
}
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentGetGameSessionLogUrlInput(v *GetGameSessionLogUrlInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.GameSessionId != nil {
ok := object.Key("GameSessionId")
ok.String(*v.GameSessionId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentGetInstanceAccessInput(v *GetInstanceAccessInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.InstanceId != nil {
ok := object.Key("InstanceId")
ok.String(*v.InstanceId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentListAliasesInput(v *ListAliasesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if len(v.RoutingStrategyType) > 0 {
ok := object.Key("RoutingStrategyType")
ok.String(string(v.RoutingStrategyType))
}
return nil
}
func awsAwsjson11_serializeOpDocumentListBuildsInput(v *ListBuildsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if len(v.Status) > 0 {
ok := object.Key("Status")
ok.String(string(v.Status))
}
return nil
}
func awsAwsjson11_serializeOpDocumentListComputeInput(v *ListComputeInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.Location != nil {
ok := object.Key("Location")
ok.String(*v.Location)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentListFleetsInput(v *ListFleetsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.BuildId != nil {
ok := object.Key("BuildId")
ok.String(*v.BuildId)
}
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.ScriptId != nil {
ok := object.Key("ScriptId")
ok.String(*v.ScriptId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentListGameServerGroupsInput(v *ListGameServerGroupsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentListGameServersInput(v *ListGameServersInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.GameServerGroupName != nil {
ok := object.Key("GameServerGroupName")
ok.String(*v.GameServerGroupName)
}
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if len(v.SortOrder) > 0 {
ok := object.Key("SortOrder")
ok.String(string(v.SortOrder))
}
return nil
}
func awsAwsjson11_serializeOpDocumentListLocationsInput(v *ListLocationsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Filters != nil {
ok := object.Key("Filters")
if err := awsAwsjson11_serializeDocumentLocationFilterList(v.Filters, ok); err != nil {
return err
}
}
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentListScriptsInput(v *ListScriptsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ResourceARN != nil {
ok := object.Key("ResourceARN")
ok.String(*v.ResourceARN)
}
return nil
}
func awsAwsjson11_serializeOpDocumentPutScalingPolicyInput(v *PutScalingPolicyInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.ComparisonOperator) > 0 {
ok := object.Key("ComparisonOperator")
ok.String(string(v.ComparisonOperator))
}
if v.EvaluationPeriods != nil {
ok := object.Key("EvaluationPeriods")
ok.Integer(*v.EvaluationPeriods)
}
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if len(v.MetricName) > 0 {
ok := object.Key("MetricName")
ok.String(string(v.MetricName))
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if len(v.PolicyType) > 0 {
ok := object.Key("PolicyType")
ok.String(string(v.PolicyType))
}
if v.ScalingAdjustment != 0 {
ok := object.Key("ScalingAdjustment")
ok.Integer(v.ScalingAdjustment)
}
if len(v.ScalingAdjustmentType) > 0 {
ok := object.Key("ScalingAdjustmentType")
ok.String(string(v.ScalingAdjustmentType))
}
if v.TargetConfiguration != nil {
ok := object.Key("TargetConfiguration")
if err := awsAwsjson11_serializeDocumentTargetConfiguration(v.TargetConfiguration, ok); err != nil {
return err
}
}
if v.Threshold != 0 {
ok := object.Key("Threshold")
switch {
case math.IsNaN(v.Threshold):
ok.String("NaN")
case math.IsInf(v.Threshold, 1):
ok.String("Infinity")
case math.IsInf(v.Threshold, -1):
ok.String("-Infinity")
default:
ok.Double(v.Threshold)
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentRegisterComputeInput(v *RegisterComputeInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CertificatePath != nil {
ok := object.Key("CertificatePath")
ok.String(*v.CertificatePath)
}
if v.ComputeName != nil {
ok := object.Key("ComputeName")
ok.String(*v.ComputeName)
}
if v.DnsName != nil {
ok := object.Key("DnsName")
ok.String(*v.DnsName)
}
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.IpAddress != nil {
ok := object.Key("IpAddress")
ok.String(*v.IpAddress)
}
if v.Location != nil {
ok := object.Key("Location")
ok.String(*v.Location)
}
return nil
}
func awsAwsjson11_serializeOpDocumentRegisterGameServerInput(v *RegisterGameServerInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ConnectionInfo != nil {
ok := object.Key("ConnectionInfo")
ok.String(*v.ConnectionInfo)
}
if v.GameServerData != nil {
ok := object.Key("GameServerData")
ok.String(*v.GameServerData)
}
if v.GameServerGroupName != nil {
ok := object.Key("GameServerGroupName")
ok.String(*v.GameServerGroupName)
}
if v.GameServerId != nil {
ok := object.Key("GameServerId")
ok.String(*v.GameServerId)
}
if v.InstanceId != nil {
ok := object.Key("InstanceId")
ok.String(*v.InstanceId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentRequestUploadCredentialsInput(v *RequestUploadCredentialsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.BuildId != nil {
ok := object.Key("BuildId")
ok.String(*v.BuildId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentResolveAliasInput(v *ResolveAliasInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AliasId != nil {
ok := object.Key("AliasId")
ok.String(*v.AliasId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentResumeGameServerGroupInput(v *ResumeGameServerGroupInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.GameServerGroupName != nil {
ok := object.Key("GameServerGroupName")
ok.String(*v.GameServerGroupName)
}
if v.ResumeActions != nil {
ok := object.Key("ResumeActions")
if err := awsAwsjson11_serializeDocumentGameServerGroupActions(v.ResumeActions, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentSearchGameSessionsInput(v *SearchGameSessionsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AliasId != nil {
ok := object.Key("AliasId")
ok.String(*v.AliasId)
}
if v.FilterExpression != nil {
ok := object.Key("FilterExpression")
ok.String(*v.FilterExpression)
}
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.Limit != nil {
ok := object.Key("Limit")
ok.Integer(*v.Limit)
}
if v.Location != nil {
ok := object.Key("Location")
ok.String(*v.Location)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.SortExpression != nil {
ok := object.Key("SortExpression")
ok.String(*v.SortExpression)
}
return nil
}
func awsAwsjson11_serializeOpDocumentStartFleetActionsInput(v *StartFleetActionsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Actions != nil {
ok := object.Key("Actions")
if err := awsAwsjson11_serializeDocumentFleetActionList(v.Actions, ok); err != nil {
return err
}
}
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.Location != nil {
ok := object.Key("Location")
ok.String(*v.Location)
}
return nil
}
func awsAwsjson11_serializeOpDocumentStartGameSessionPlacementInput(v *StartGameSessionPlacementInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DesiredPlayerSessions != nil {
ok := object.Key("DesiredPlayerSessions")
if err := awsAwsjson11_serializeDocumentDesiredPlayerSessionList(v.DesiredPlayerSessions, ok); err != nil {
return err
}
}
if v.GameProperties != nil {
ok := object.Key("GameProperties")
if err := awsAwsjson11_serializeDocumentGamePropertyList(v.GameProperties, ok); err != nil {
return err
}
}
if v.GameSessionData != nil {
ok := object.Key("GameSessionData")
ok.String(*v.GameSessionData)
}
if v.GameSessionName != nil {
ok := object.Key("GameSessionName")
ok.String(*v.GameSessionName)
}
if v.GameSessionQueueName != nil {
ok := object.Key("GameSessionQueueName")
ok.String(*v.GameSessionQueueName)
}
if v.MaximumPlayerSessionCount != nil {
ok := object.Key("MaximumPlayerSessionCount")
ok.Integer(*v.MaximumPlayerSessionCount)
}
if v.PlacementId != nil {
ok := object.Key("PlacementId")
ok.String(*v.PlacementId)
}
if v.PlayerLatencies != nil {
ok := object.Key("PlayerLatencies")
if err := awsAwsjson11_serializeDocumentPlayerLatencyList(v.PlayerLatencies, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentStartMatchBackfillInput(v *StartMatchBackfillInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ConfigurationName != nil {
ok := object.Key("ConfigurationName")
ok.String(*v.ConfigurationName)
}
if v.GameSessionArn != nil {
ok := object.Key("GameSessionArn")
ok.String(*v.GameSessionArn)
}
if v.Players != nil {
ok := object.Key("Players")
if err := awsAwsjson11_serializeDocumentPlayerList(v.Players, ok); err != nil {
return err
}
}
if v.TicketId != nil {
ok := object.Key("TicketId")
ok.String(*v.TicketId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentStartMatchmakingInput(v *StartMatchmakingInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ConfigurationName != nil {
ok := object.Key("ConfigurationName")
ok.String(*v.ConfigurationName)
}
if v.Players != nil {
ok := object.Key("Players")
if err := awsAwsjson11_serializeDocumentPlayerList(v.Players, ok); err != nil {
return err
}
}
if v.TicketId != nil {
ok := object.Key("TicketId")
ok.String(*v.TicketId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentStopFleetActionsInput(v *StopFleetActionsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Actions != nil {
ok := object.Key("Actions")
if err := awsAwsjson11_serializeDocumentFleetActionList(v.Actions, ok); err != nil {
return err
}
}
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.Location != nil {
ok := object.Key("Location")
ok.String(*v.Location)
}
return nil
}
func awsAwsjson11_serializeOpDocumentStopGameSessionPlacementInput(v *StopGameSessionPlacementInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.PlacementId != nil {
ok := object.Key("PlacementId")
ok.String(*v.PlacementId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentStopMatchmakingInput(v *StopMatchmakingInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.TicketId != nil {
ok := object.Key("TicketId")
ok.String(*v.TicketId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentSuspendGameServerGroupInput(v *SuspendGameServerGroupInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.GameServerGroupName != nil {
ok := object.Key("GameServerGroupName")
ok.String(*v.GameServerGroupName)
}
if v.SuspendActions != nil {
ok := object.Key("SuspendActions")
if err := awsAwsjson11_serializeDocumentGameServerGroupActions(v.SuspendActions, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ResourceARN != nil {
ok := object.Key("ResourceARN")
ok.String(*v.ResourceARN)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ResourceARN != nil {
ok := object.Key("ResourceARN")
ok.String(*v.ResourceARN)
}
if v.TagKeys != nil {
ok := object.Key("TagKeys")
if err := awsAwsjson11_serializeDocumentTagKeyList(v.TagKeys, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentUpdateAliasInput(v *UpdateAliasInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AliasId != nil {
ok := object.Key("AliasId")
ok.String(*v.AliasId)
}
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.RoutingStrategy != nil {
ok := object.Key("RoutingStrategy")
if err := awsAwsjson11_serializeDocumentRoutingStrategy(v.RoutingStrategy, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentUpdateBuildInput(v *UpdateBuildInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.BuildId != nil {
ok := object.Key("BuildId")
ok.String(*v.BuildId)
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.Version != nil {
ok := object.Key("Version")
ok.String(*v.Version)
}
return nil
}
func awsAwsjson11_serializeOpDocumentUpdateFleetAttributesInput(v *UpdateFleetAttributesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AnywhereConfiguration != nil {
ok := object.Key("AnywhereConfiguration")
if err := awsAwsjson11_serializeDocumentAnywhereConfiguration(v.AnywhereConfiguration, ok); err != nil {
return err
}
}
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.MetricGroups != nil {
ok := object.Key("MetricGroups")
if err := awsAwsjson11_serializeDocumentMetricGroupList(v.MetricGroups, ok); err != nil {
return err
}
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if len(v.NewGameSessionProtectionPolicy) > 0 {
ok := object.Key("NewGameSessionProtectionPolicy")
ok.String(string(v.NewGameSessionProtectionPolicy))
}
if v.ResourceCreationLimitPolicy != nil {
ok := object.Key("ResourceCreationLimitPolicy")
if err := awsAwsjson11_serializeDocumentResourceCreationLimitPolicy(v.ResourceCreationLimitPolicy, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentUpdateFleetCapacityInput(v *UpdateFleetCapacityInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DesiredInstances != nil {
ok := object.Key("DesiredInstances")
ok.Integer(*v.DesiredInstances)
}
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.Location != nil {
ok := object.Key("Location")
ok.String(*v.Location)
}
if v.MaxSize != nil {
ok := object.Key("MaxSize")
ok.Integer(*v.MaxSize)
}
if v.MinSize != nil {
ok := object.Key("MinSize")
ok.Integer(*v.MinSize)
}
return nil
}
func awsAwsjson11_serializeOpDocumentUpdateFleetPortSettingsInput(v *UpdateFleetPortSettingsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.InboundPermissionAuthorizations != nil {
ok := object.Key("InboundPermissionAuthorizations")
if err := awsAwsjson11_serializeDocumentIpPermissionsList(v.InboundPermissionAuthorizations, ok); err != nil {
return err
}
}
if v.InboundPermissionRevocations != nil {
ok := object.Key("InboundPermissionRevocations")
if err := awsAwsjson11_serializeDocumentIpPermissionsList(v.InboundPermissionRevocations, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentUpdateGameServerGroupInput(v *UpdateGameServerGroupInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.BalancingStrategy) > 0 {
ok := object.Key("BalancingStrategy")
ok.String(string(v.BalancingStrategy))
}
if v.GameServerGroupName != nil {
ok := object.Key("GameServerGroupName")
ok.String(*v.GameServerGroupName)
}
if len(v.GameServerProtectionPolicy) > 0 {
ok := object.Key("GameServerProtectionPolicy")
ok.String(string(v.GameServerProtectionPolicy))
}
if v.InstanceDefinitions != nil {
ok := object.Key("InstanceDefinitions")
if err := awsAwsjson11_serializeDocumentInstanceDefinitions(v.InstanceDefinitions, ok); err != nil {
return err
}
}
if v.RoleArn != nil {
ok := object.Key("RoleArn")
ok.String(*v.RoleArn)
}
return nil
}
func awsAwsjson11_serializeOpDocumentUpdateGameServerInput(v *UpdateGameServerInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.GameServerData != nil {
ok := object.Key("GameServerData")
ok.String(*v.GameServerData)
}
if v.GameServerGroupName != nil {
ok := object.Key("GameServerGroupName")
ok.String(*v.GameServerGroupName)
}
if v.GameServerId != nil {
ok := object.Key("GameServerId")
ok.String(*v.GameServerId)
}
if len(v.HealthCheck) > 0 {
ok := object.Key("HealthCheck")
ok.String(string(v.HealthCheck))
}
if len(v.UtilizationStatus) > 0 {
ok := object.Key("UtilizationStatus")
ok.String(string(v.UtilizationStatus))
}
return nil
}
func awsAwsjson11_serializeOpDocumentUpdateGameSessionInput(v *UpdateGameSessionInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.GameSessionId != nil {
ok := object.Key("GameSessionId")
ok.String(*v.GameSessionId)
}
if v.MaximumPlayerSessionCount != nil {
ok := object.Key("MaximumPlayerSessionCount")
ok.Integer(*v.MaximumPlayerSessionCount)
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if len(v.PlayerSessionCreationPolicy) > 0 {
ok := object.Key("PlayerSessionCreationPolicy")
ok.String(string(v.PlayerSessionCreationPolicy))
}
if len(v.ProtectionPolicy) > 0 {
ok := object.Key("ProtectionPolicy")
ok.String(string(v.ProtectionPolicy))
}
return nil
}
func awsAwsjson11_serializeOpDocumentUpdateGameSessionQueueInput(v *UpdateGameSessionQueueInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CustomEventData != nil {
ok := object.Key("CustomEventData")
ok.String(*v.CustomEventData)
}
if v.Destinations != nil {
ok := object.Key("Destinations")
if err := awsAwsjson11_serializeDocumentGameSessionQueueDestinationList(v.Destinations, ok); err != nil {
return err
}
}
if v.FilterConfiguration != nil {
ok := object.Key("FilterConfiguration")
if err := awsAwsjson11_serializeDocumentFilterConfiguration(v.FilterConfiguration, ok); err != nil {
return err
}
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.NotificationTarget != nil {
ok := object.Key("NotificationTarget")
ok.String(*v.NotificationTarget)
}
if v.PlayerLatencyPolicies != nil {
ok := object.Key("PlayerLatencyPolicies")
if err := awsAwsjson11_serializeDocumentPlayerLatencyPolicyList(v.PlayerLatencyPolicies, ok); err != nil {
return err
}
}
if v.PriorityConfiguration != nil {
ok := object.Key("PriorityConfiguration")
if err := awsAwsjson11_serializeDocumentPriorityConfiguration(v.PriorityConfiguration, ok); err != nil {
return err
}
}
if v.TimeoutInSeconds != nil {
ok := object.Key("TimeoutInSeconds")
ok.Integer(*v.TimeoutInSeconds)
}
return nil
}
func awsAwsjson11_serializeOpDocumentUpdateMatchmakingConfigurationInput(v *UpdateMatchmakingConfigurationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AcceptanceRequired != nil {
ok := object.Key("AcceptanceRequired")
ok.Boolean(*v.AcceptanceRequired)
}
if v.AcceptanceTimeoutSeconds != nil {
ok := object.Key("AcceptanceTimeoutSeconds")
ok.Integer(*v.AcceptanceTimeoutSeconds)
}
if v.AdditionalPlayerCount != nil {
ok := object.Key("AdditionalPlayerCount")
ok.Integer(*v.AdditionalPlayerCount)
}
if len(v.BackfillMode) > 0 {
ok := object.Key("BackfillMode")
ok.String(string(v.BackfillMode))
}
if v.CustomEventData != nil {
ok := object.Key("CustomEventData")
ok.String(*v.CustomEventData)
}
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if len(v.FlexMatchMode) > 0 {
ok := object.Key("FlexMatchMode")
ok.String(string(v.FlexMatchMode))
}
if v.GameProperties != nil {
ok := object.Key("GameProperties")
if err := awsAwsjson11_serializeDocumentGamePropertyList(v.GameProperties, ok); err != nil {
return err
}
}
if v.GameSessionData != nil {
ok := object.Key("GameSessionData")
ok.String(*v.GameSessionData)
}
if v.GameSessionQueueArns != nil {
ok := object.Key("GameSessionQueueArns")
if err := awsAwsjson11_serializeDocumentQueueArnsList(v.GameSessionQueueArns, ok); err != nil {
return err
}
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.NotificationTarget != nil {
ok := object.Key("NotificationTarget")
ok.String(*v.NotificationTarget)
}
if v.RequestTimeoutSeconds != nil {
ok := object.Key("RequestTimeoutSeconds")
ok.Integer(*v.RequestTimeoutSeconds)
}
if v.RuleSetName != nil {
ok := object.Key("RuleSetName")
ok.String(*v.RuleSetName)
}
return nil
}
func awsAwsjson11_serializeOpDocumentUpdateRuntimeConfigurationInput(v *UpdateRuntimeConfigurationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FleetId != nil {
ok := object.Key("FleetId")
ok.String(*v.FleetId)
}
if v.RuntimeConfiguration != nil {
ok := object.Key("RuntimeConfiguration")
if err := awsAwsjson11_serializeDocumentRuntimeConfiguration(v.RuntimeConfiguration, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentUpdateScriptInput(v *UpdateScriptInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.ScriptId != nil {
ok := object.Key("ScriptId")
ok.String(*v.ScriptId)
}
if v.StorageLocation != nil {
ok := object.Key("StorageLocation")
if err := awsAwsjson11_serializeDocumentS3Location(v.StorageLocation, ok); err != nil {
return err
}
}
if v.Version != nil {
ok := object.Key("Version")
ok.String(*v.Version)
}
if v.ZipFile != nil {
ok := object.Key("ZipFile")
ok.Base64EncodeBytes(v.ZipFile)
}
return nil
}
func awsAwsjson11_serializeOpDocumentValidateMatchmakingRuleSetInput(v *ValidateMatchmakingRuleSetInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.RuleSetBody != nil {
ok := object.Key("RuleSetBody")
ok.String(*v.RuleSetBody)
}
return nil
}
| 9,426 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/gamelift/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpAcceptMatch struct {
}
func (*validateOpAcceptMatch) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAcceptMatch) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AcceptMatchInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAcceptMatchInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpClaimGameServer struct {
}
func (*validateOpClaimGameServer) ID() string {
return "OperationInputValidation"
}
func (m *validateOpClaimGameServer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ClaimGameServerInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpClaimGameServerInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateAlias struct {
}
func (*validateOpCreateAlias) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateAlias) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateAliasInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateAliasInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateBuild struct {
}
func (*validateOpCreateBuild) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateBuild) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateBuildInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateBuildInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateFleet struct {
}
func (*validateOpCreateFleet) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateFleet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateFleetInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateFleetInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateFleetLocations struct {
}
func (*validateOpCreateFleetLocations) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateFleetLocations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateFleetLocationsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateFleetLocationsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateGameServerGroup struct {
}
func (*validateOpCreateGameServerGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateGameServerGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateGameServerGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateGameServerGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateGameSession struct {
}
func (*validateOpCreateGameSession) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateGameSession) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateGameSessionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateGameSessionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateGameSessionQueue struct {
}
func (*validateOpCreateGameSessionQueue) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateGameSessionQueue) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateGameSessionQueueInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateGameSessionQueueInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateLocation struct {
}
func (*validateOpCreateLocation) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateLocation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateLocationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateLocationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateMatchmakingConfiguration struct {
}
func (*validateOpCreateMatchmakingConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateMatchmakingConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateMatchmakingConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateMatchmakingConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateMatchmakingRuleSet struct {
}
func (*validateOpCreateMatchmakingRuleSet) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateMatchmakingRuleSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateMatchmakingRuleSetInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateMatchmakingRuleSetInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreatePlayerSession struct {
}
func (*validateOpCreatePlayerSession) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreatePlayerSession) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreatePlayerSessionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreatePlayerSessionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreatePlayerSessions struct {
}
func (*validateOpCreatePlayerSessions) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreatePlayerSessions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreatePlayerSessionsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreatePlayerSessionsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateScript struct {
}
func (*validateOpCreateScript) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateScript) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateScriptInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateScriptInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateVpcPeeringAuthorization struct {
}
func (*validateOpCreateVpcPeeringAuthorization) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateVpcPeeringAuthorization) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateVpcPeeringAuthorizationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateVpcPeeringAuthorizationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateVpcPeeringConnection struct {
}
func (*validateOpCreateVpcPeeringConnection) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateVpcPeeringConnection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateVpcPeeringConnectionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateVpcPeeringConnectionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteAlias struct {
}
func (*validateOpDeleteAlias) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteAlias) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteAliasInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteAliasInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteBuild struct {
}
func (*validateOpDeleteBuild) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteBuild) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteBuildInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteBuildInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteFleet struct {
}
func (*validateOpDeleteFleet) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteFleet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteFleetInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteFleetInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteFleetLocations struct {
}
func (*validateOpDeleteFleetLocations) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteFleetLocations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteFleetLocationsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteFleetLocationsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteGameServerGroup struct {
}
func (*validateOpDeleteGameServerGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteGameServerGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteGameServerGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteGameServerGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteGameSessionQueue struct {
}
func (*validateOpDeleteGameSessionQueue) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteGameSessionQueue) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteGameSessionQueueInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteGameSessionQueueInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteLocation struct {
}
func (*validateOpDeleteLocation) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteLocation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteLocationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteLocationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteMatchmakingConfiguration struct {
}
func (*validateOpDeleteMatchmakingConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteMatchmakingConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteMatchmakingConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteMatchmakingConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteMatchmakingRuleSet struct {
}
func (*validateOpDeleteMatchmakingRuleSet) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteMatchmakingRuleSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteMatchmakingRuleSetInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteMatchmakingRuleSetInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteScalingPolicy struct {
}
func (*validateOpDeleteScalingPolicy) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteScalingPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteScalingPolicyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteScalingPolicyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteScript struct {
}
func (*validateOpDeleteScript) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteScript) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteScriptInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteScriptInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteVpcPeeringAuthorization struct {
}
func (*validateOpDeleteVpcPeeringAuthorization) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteVpcPeeringAuthorization) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteVpcPeeringAuthorizationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteVpcPeeringAuthorizationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteVpcPeeringConnection struct {
}
func (*validateOpDeleteVpcPeeringConnection) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteVpcPeeringConnection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteVpcPeeringConnectionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteVpcPeeringConnectionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeregisterCompute struct {
}
func (*validateOpDeregisterCompute) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeregisterCompute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeregisterComputeInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeregisterComputeInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeregisterGameServer struct {
}
func (*validateOpDeregisterGameServer) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeregisterGameServer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeregisterGameServerInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeregisterGameServerInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeAlias struct {
}
func (*validateOpDescribeAlias) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeAlias) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeAliasInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeAliasInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeBuild struct {
}
func (*validateOpDescribeBuild) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeBuild) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeBuildInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeBuildInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeCompute struct {
}
func (*validateOpDescribeCompute) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeCompute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeComputeInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeComputeInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeFleetEvents struct {
}
func (*validateOpDescribeFleetEvents) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeFleetEvents) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeFleetEventsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeFleetEventsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeFleetLocationAttributes struct {
}
func (*validateOpDescribeFleetLocationAttributes) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeFleetLocationAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeFleetLocationAttributesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeFleetLocationAttributesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeFleetLocationCapacity struct {
}
func (*validateOpDescribeFleetLocationCapacity) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeFleetLocationCapacity) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeFleetLocationCapacityInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeFleetLocationCapacityInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeFleetLocationUtilization struct {
}
func (*validateOpDescribeFleetLocationUtilization) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeFleetLocationUtilization) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeFleetLocationUtilizationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeFleetLocationUtilizationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeFleetPortSettings struct {
}
func (*validateOpDescribeFleetPortSettings) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeFleetPortSettings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeFleetPortSettingsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeFleetPortSettingsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeGameServerGroup struct {
}
func (*validateOpDescribeGameServerGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeGameServerGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeGameServerGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeGameServerGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeGameServer struct {
}
func (*validateOpDescribeGameServer) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeGameServer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeGameServerInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeGameServerInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeGameServerInstances struct {
}
func (*validateOpDescribeGameServerInstances) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeGameServerInstances) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeGameServerInstancesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeGameServerInstancesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeGameSessionPlacement struct {
}
func (*validateOpDescribeGameSessionPlacement) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeGameSessionPlacement) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeGameSessionPlacementInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeGameSessionPlacementInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeInstances struct {
}
func (*validateOpDescribeInstances) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeInstances) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeInstancesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeInstancesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeMatchmaking struct {
}
func (*validateOpDescribeMatchmaking) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeMatchmaking) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeMatchmakingInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeMatchmakingInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeRuntimeConfiguration struct {
}
func (*validateOpDescribeRuntimeConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeRuntimeConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeRuntimeConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeRuntimeConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeScalingPolicies struct {
}
func (*validateOpDescribeScalingPolicies) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeScalingPolicies) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeScalingPoliciesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeScalingPoliciesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeScript struct {
}
func (*validateOpDescribeScript) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeScript) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeScriptInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeScriptInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetComputeAccess struct {
}
func (*validateOpGetComputeAccess) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetComputeAccess) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetComputeAccessInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetComputeAccessInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetComputeAuthToken struct {
}
func (*validateOpGetComputeAuthToken) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetComputeAuthToken) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetComputeAuthTokenInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetComputeAuthTokenInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetGameSessionLogUrl struct {
}
func (*validateOpGetGameSessionLogUrl) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetGameSessionLogUrl) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetGameSessionLogUrlInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetGameSessionLogUrlInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetInstanceAccess struct {
}
func (*validateOpGetInstanceAccess) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetInstanceAccess) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetInstanceAccessInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetInstanceAccessInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListCompute struct {
}
func (*validateOpListCompute) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListCompute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListComputeInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListComputeInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListGameServers struct {
}
func (*validateOpListGameServers) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListGameServers) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListGameServersInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListGameServersInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListTagsForResource struct {
}
func (*validateOpListTagsForResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListTagsForResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListTagsForResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpPutScalingPolicy struct {
}
func (*validateOpPutScalingPolicy) ID() string {
return "OperationInputValidation"
}
func (m *validateOpPutScalingPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*PutScalingPolicyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpPutScalingPolicyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpRegisterCompute struct {
}
func (*validateOpRegisterCompute) ID() string {
return "OperationInputValidation"
}
func (m *validateOpRegisterCompute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*RegisterComputeInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpRegisterComputeInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpRegisterGameServer struct {
}
func (*validateOpRegisterGameServer) ID() string {
return "OperationInputValidation"
}
func (m *validateOpRegisterGameServer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*RegisterGameServerInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpRegisterGameServerInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpRequestUploadCredentials struct {
}
func (*validateOpRequestUploadCredentials) ID() string {
return "OperationInputValidation"
}
func (m *validateOpRequestUploadCredentials) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*RequestUploadCredentialsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpRequestUploadCredentialsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpResolveAlias struct {
}
func (*validateOpResolveAlias) ID() string {
return "OperationInputValidation"
}
func (m *validateOpResolveAlias) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ResolveAliasInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpResolveAliasInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpResumeGameServerGroup struct {
}
func (*validateOpResumeGameServerGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpResumeGameServerGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ResumeGameServerGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpResumeGameServerGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartFleetActions struct {
}
func (*validateOpStartFleetActions) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartFleetActions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartFleetActionsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartFleetActionsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartGameSessionPlacement struct {
}
func (*validateOpStartGameSessionPlacement) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartGameSessionPlacement) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartGameSessionPlacementInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartGameSessionPlacementInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartMatchBackfill struct {
}
func (*validateOpStartMatchBackfill) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartMatchBackfill) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartMatchBackfillInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartMatchBackfillInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartMatchmaking struct {
}
func (*validateOpStartMatchmaking) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartMatchmaking) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartMatchmakingInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartMatchmakingInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStopFleetActions struct {
}
func (*validateOpStopFleetActions) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStopFleetActions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StopFleetActionsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStopFleetActionsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStopGameSessionPlacement struct {
}
func (*validateOpStopGameSessionPlacement) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStopGameSessionPlacement) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StopGameSessionPlacementInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStopGameSessionPlacementInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStopMatchmaking struct {
}
func (*validateOpStopMatchmaking) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStopMatchmaking) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StopMatchmakingInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStopMatchmakingInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpSuspendGameServerGroup struct {
}
func (*validateOpSuspendGameServerGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpSuspendGameServerGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*SuspendGameServerGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpSuspendGameServerGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpTagResource struct {
}
func (*validateOpTagResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*TagResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpTagResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUntagResource struct {
}
func (*validateOpUntagResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UntagResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUntagResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateAlias struct {
}
func (*validateOpUpdateAlias) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateAlias) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateAliasInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateAliasInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateBuild struct {
}
func (*validateOpUpdateBuild) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateBuild) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateBuildInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateBuildInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateFleetAttributes struct {
}
func (*validateOpUpdateFleetAttributes) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateFleetAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateFleetAttributesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateFleetAttributesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateFleetCapacity struct {
}
func (*validateOpUpdateFleetCapacity) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateFleetCapacity) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateFleetCapacityInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateFleetCapacityInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateFleetPortSettings struct {
}
func (*validateOpUpdateFleetPortSettings) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateFleetPortSettings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateFleetPortSettingsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateFleetPortSettingsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateGameServerGroup struct {
}
func (*validateOpUpdateGameServerGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateGameServerGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateGameServerGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateGameServerGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateGameServer struct {
}
func (*validateOpUpdateGameServer) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateGameServer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateGameServerInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateGameServerInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateGameSession struct {
}
func (*validateOpUpdateGameSession) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateGameSession) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateGameSessionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateGameSessionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateGameSessionQueue struct {
}
func (*validateOpUpdateGameSessionQueue) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateGameSessionQueue) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateGameSessionQueueInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateGameSessionQueueInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateMatchmakingConfiguration struct {
}
func (*validateOpUpdateMatchmakingConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateMatchmakingConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateMatchmakingConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateMatchmakingConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateRuntimeConfiguration struct {
}
func (*validateOpUpdateRuntimeConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateRuntimeConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateRuntimeConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateRuntimeConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateScript struct {
}
func (*validateOpUpdateScript) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateScript) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateScriptInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateScriptInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpValidateMatchmakingRuleSet struct {
}
func (*validateOpValidateMatchmakingRuleSet) ID() string {
return "OperationInputValidation"
}
func (m *validateOpValidateMatchmakingRuleSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ValidateMatchmakingRuleSetInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpValidateMatchmakingRuleSetInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpAcceptMatchValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAcceptMatch{}, middleware.After)
}
func addOpClaimGameServerValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpClaimGameServer{}, middleware.After)
}
func addOpCreateAliasValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateAlias{}, middleware.After)
}
func addOpCreateBuildValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateBuild{}, middleware.After)
}
func addOpCreateFleetValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateFleet{}, middleware.After)
}
func addOpCreateFleetLocationsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateFleetLocations{}, middleware.After)
}
func addOpCreateGameServerGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateGameServerGroup{}, middleware.After)
}
func addOpCreateGameSessionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateGameSession{}, middleware.After)
}
func addOpCreateGameSessionQueueValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateGameSessionQueue{}, middleware.After)
}
func addOpCreateLocationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateLocation{}, middleware.After)
}
func addOpCreateMatchmakingConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateMatchmakingConfiguration{}, middleware.After)
}
func addOpCreateMatchmakingRuleSetValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateMatchmakingRuleSet{}, middleware.After)
}
func addOpCreatePlayerSessionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreatePlayerSession{}, middleware.After)
}
func addOpCreatePlayerSessionsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreatePlayerSessions{}, middleware.After)
}
func addOpCreateScriptValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateScript{}, middleware.After)
}
func addOpCreateVpcPeeringAuthorizationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateVpcPeeringAuthorization{}, middleware.After)
}
func addOpCreateVpcPeeringConnectionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateVpcPeeringConnection{}, middleware.After)
}
func addOpDeleteAliasValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteAlias{}, middleware.After)
}
func addOpDeleteBuildValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteBuild{}, middleware.After)
}
func addOpDeleteFleetValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteFleet{}, middleware.After)
}
func addOpDeleteFleetLocationsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteFleetLocations{}, middleware.After)
}
func addOpDeleteGameServerGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteGameServerGroup{}, middleware.After)
}
func addOpDeleteGameSessionQueueValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteGameSessionQueue{}, middleware.After)
}
func addOpDeleteLocationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteLocation{}, middleware.After)
}
func addOpDeleteMatchmakingConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteMatchmakingConfiguration{}, middleware.After)
}
func addOpDeleteMatchmakingRuleSetValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteMatchmakingRuleSet{}, middleware.After)
}
func addOpDeleteScalingPolicyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteScalingPolicy{}, middleware.After)
}
func addOpDeleteScriptValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteScript{}, middleware.After)
}
func addOpDeleteVpcPeeringAuthorizationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteVpcPeeringAuthorization{}, middleware.After)
}
func addOpDeleteVpcPeeringConnectionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteVpcPeeringConnection{}, middleware.After)
}
func addOpDeregisterComputeValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeregisterCompute{}, middleware.After)
}
func addOpDeregisterGameServerValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeregisterGameServer{}, middleware.After)
}
func addOpDescribeAliasValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeAlias{}, middleware.After)
}
func addOpDescribeBuildValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeBuild{}, middleware.After)
}
func addOpDescribeComputeValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeCompute{}, middleware.After)
}
func addOpDescribeFleetEventsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeFleetEvents{}, middleware.After)
}
func addOpDescribeFleetLocationAttributesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeFleetLocationAttributes{}, middleware.After)
}
func addOpDescribeFleetLocationCapacityValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeFleetLocationCapacity{}, middleware.After)
}
func addOpDescribeFleetLocationUtilizationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeFleetLocationUtilization{}, middleware.After)
}
func addOpDescribeFleetPortSettingsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeFleetPortSettings{}, middleware.After)
}
func addOpDescribeGameServerGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeGameServerGroup{}, middleware.After)
}
func addOpDescribeGameServerValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeGameServer{}, middleware.After)
}
func addOpDescribeGameServerInstancesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeGameServerInstances{}, middleware.After)
}
func addOpDescribeGameSessionPlacementValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeGameSessionPlacement{}, middleware.After)
}
func addOpDescribeInstancesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeInstances{}, middleware.After)
}
func addOpDescribeMatchmakingValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeMatchmaking{}, middleware.After)
}
func addOpDescribeRuntimeConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeRuntimeConfiguration{}, middleware.After)
}
func addOpDescribeScalingPoliciesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeScalingPolicies{}, middleware.After)
}
func addOpDescribeScriptValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeScript{}, middleware.After)
}
func addOpGetComputeAccessValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetComputeAccess{}, middleware.After)
}
func addOpGetComputeAuthTokenValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetComputeAuthToken{}, middleware.After)
}
func addOpGetGameSessionLogUrlValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetGameSessionLogUrl{}, middleware.After)
}
func addOpGetInstanceAccessValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetInstanceAccess{}, middleware.After)
}
func addOpListComputeValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListCompute{}, middleware.After)
}
func addOpListGameServersValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListGameServers{}, middleware.After)
}
func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
}
func addOpPutScalingPolicyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpPutScalingPolicy{}, middleware.After)
}
func addOpRegisterComputeValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpRegisterCompute{}, middleware.After)
}
func addOpRegisterGameServerValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpRegisterGameServer{}, middleware.After)
}
func addOpRequestUploadCredentialsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpRequestUploadCredentials{}, middleware.After)
}
func addOpResolveAliasValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpResolveAlias{}, middleware.After)
}
func addOpResumeGameServerGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpResumeGameServerGroup{}, middleware.After)
}
func addOpStartFleetActionsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartFleetActions{}, middleware.After)
}
func addOpStartGameSessionPlacementValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartGameSessionPlacement{}, middleware.After)
}
func addOpStartMatchBackfillValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartMatchBackfill{}, middleware.After)
}
func addOpStartMatchmakingValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartMatchmaking{}, middleware.After)
}
func addOpStopFleetActionsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStopFleetActions{}, middleware.After)
}
func addOpStopGameSessionPlacementValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStopGameSessionPlacement{}, middleware.After)
}
func addOpStopMatchmakingValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStopMatchmaking{}, middleware.After)
}
func addOpSuspendGameServerGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpSuspendGameServerGroup{}, middleware.After)
}
func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
}
func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
}
func addOpUpdateAliasValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateAlias{}, middleware.After)
}
func addOpUpdateBuildValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateBuild{}, middleware.After)
}
func addOpUpdateFleetAttributesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateFleetAttributes{}, middleware.After)
}
func addOpUpdateFleetCapacityValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateFleetCapacity{}, middleware.After)
}
func addOpUpdateFleetPortSettingsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateFleetPortSettings{}, middleware.After)
}
func addOpUpdateGameServerGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateGameServerGroup{}, middleware.After)
}
func addOpUpdateGameServerValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateGameServer{}, middleware.After)
}
func addOpUpdateGameSessionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateGameSession{}, middleware.After)
}
func addOpUpdateGameSessionQueueValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateGameSessionQueue{}, middleware.After)
}
func addOpUpdateMatchmakingConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateMatchmakingConfiguration{}, middleware.After)
}
func addOpUpdateRuntimeConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateRuntimeConfiguration{}, middleware.After)
}
func addOpUpdateScriptValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateScript{}, middleware.After)
}
func addOpValidateMatchmakingRuleSetValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpValidateMatchmakingRuleSet{}, middleware.After)
}
func validateAnywhereConfiguration(v *types.AnywhereConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AnywhereConfiguration"}
if v.Cost == nil {
invalidParams.Add(smithy.NewErrParamRequired("Cost"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCertificateConfiguration(v *types.CertificateConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CertificateConfiguration"}
if len(v.CertificateType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("CertificateType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateGameProperty(v *types.GameProperty) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GameProperty"}
if v.Key == nil {
invalidParams.Add(smithy.NewErrParamRequired("Key"))
}
if v.Value == nil {
invalidParams.Add(smithy.NewErrParamRequired("Value"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateGamePropertyList(v []types.GameProperty) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GamePropertyList"}
for i := range v {
if err := validateGameProperty(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateGameServerGroupAutoScalingPolicy(v *types.GameServerGroupAutoScalingPolicy) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GameServerGroupAutoScalingPolicy"}
if v.TargetTrackingConfiguration == nil {
invalidParams.Add(smithy.NewErrParamRequired("TargetTrackingConfiguration"))
} else if v.TargetTrackingConfiguration != nil {
if err := validateTargetTrackingConfiguration(v.TargetTrackingConfiguration); err != nil {
invalidParams.AddNested("TargetTrackingConfiguration", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateInstanceDefinition(v *types.InstanceDefinition) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "InstanceDefinition"}
if len(v.InstanceType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("InstanceType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateInstanceDefinitions(v []types.InstanceDefinition) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "InstanceDefinitions"}
for i := range v {
if err := validateInstanceDefinition(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateIpPermission(v *types.IpPermission) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "IpPermission"}
if v.FromPort == nil {
invalidParams.Add(smithy.NewErrParamRequired("FromPort"))
}
if v.ToPort == nil {
invalidParams.Add(smithy.NewErrParamRequired("ToPort"))
}
if v.IpRange == nil {
invalidParams.Add(smithy.NewErrParamRequired("IpRange"))
}
if len(v.Protocol) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateIpPermissionsList(v []types.IpPermission) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "IpPermissionsList"}
for i := range v {
if err := validateIpPermission(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateLocationConfiguration(v *types.LocationConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "LocationConfiguration"}
if v.Location == nil {
invalidParams.Add(smithy.NewErrParamRequired("Location"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateLocationConfigurationList(v []types.LocationConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "LocationConfigurationList"}
for i := range v {
if err := validateLocationConfiguration(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateRuntimeConfiguration(v *types.RuntimeConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RuntimeConfiguration"}
if v.ServerProcesses != nil {
if err := validateServerProcessList(v.ServerProcesses); err != nil {
invalidParams.AddNested("ServerProcesses", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateServerProcess(v *types.ServerProcess) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ServerProcess"}
if v.LaunchPath == nil {
invalidParams.Add(smithy.NewErrParamRequired("LaunchPath"))
}
if v.ConcurrentExecutions == nil {
invalidParams.Add(smithy.NewErrParamRequired("ConcurrentExecutions"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateServerProcessList(v []types.ServerProcess) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ServerProcessList"}
for i := range v {
if err := validateServerProcess(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTag(v *types.Tag) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Tag"}
if v.Key == nil {
invalidParams.Add(smithy.NewErrParamRequired("Key"))
}
if v.Value == nil {
invalidParams.Add(smithy.NewErrParamRequired("Value"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTagList(v []types.Tag) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TagList"}
for i := range v {
if err := validateTag(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTargetConfiguration(v *types.TargetConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TargetConfiguration"}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTargetTrackingConfiguration(v *types.TargetTrackingConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TargetTrackingConfiguration"}
if v.TargetValue == nil {
invalidParams.Add(smithy.NewErrParamRequired("TargetValue"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAcceptMatchInput(v *AcceptMatchInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AcceptMatchInput"}
if v.TicketId == nil {
invalidParams.Add(smithy.NewErrParamRequired("TicketId"))
}
if v.PlayerIds == nil {
invalidParams.Add(smithy.NewErrParamRequired("PlayerIds"))
}
if len(v.AcceptanceType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("AcceptanceType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpClaimGameServerInput(v *ClaimGameServerInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ClaimGameServerInput"}
if v.GameServerGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateAliasInput(v *CreateAliasInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateAliasInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.RoutingStrategy == nil {
invalidParams.Add(smithy.NewErrParamRequired("RoutingStrategy"))
}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateBuildInput(v *CreateBuildInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateBuildInput"}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateFleetInput(v *CreateFleetInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateFleetInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.EC2InboundPermissions != nil {
if err := validateIpPermissionsList(v.EC2InboundPermissions); err != nil {
invalidParams.AddNested("EC2InboundPermissions", err.(smithy.InvalidParamsError))
}
}
if v.RuntimeConfiguration != nil {
if err := validateRuntimeConfiguration(v.RuntimeConfiguration); err != nil {
invalidParams.AddNested("RuntimeConfiguration", err.(smithy.InvalidParamsError))
}
}
if v.CertificateConfiguration != nil {
if err := validateCertificateConfiguration(v.CertificateConfiguration); err != nil {
invalidParams.AddNested("CertificateConfiguration", err.(smithy.InvalidParamsError))
}
}
if v.Locations != nil {
if err := validateLocationConfigurationList(v.Locations); err != nil {
invalidParams.AddNested("Locations", err.(smithy.InvalidParamsError))
}
}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if v.AnywhereConfiguration != nil {
if err := validateAnywhereConfiguration(v.AnywhereConfiguration); err != nil {
invalidParams.AddNested("AnywhereConfiguration", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateFleetLocationsInput(v *CreateFleetLocationsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateFleetLocationsInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if v.Locations == nil {
invalidParams.Add(smithy.NewErrParamRequired("Locations"))
} else if v.Locations != nil {
if err := validateLocationConfigurationList(v.Locations); err != nil {
invalidParams.AddNested("Locations", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateGameServerGroupInput(v *CreateGameServerGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateGameServerGroupInput"}
if v.GameServerGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
}
if v.RoleArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
}
if v.MinSize == nil {
invalidParams.Add(smithy.NewErrParamRequired("MinSize"))
}
if v.MaxSize == nil {
invalidParams.Add(smithy.NewErrParamRequired("MaxSize"))
}
if v.LaunchTemplate == nil {
invalidParams.Add(smithy.NewErrParamRequired("LaunchTemplate"))
}
if v.InstanceDefinitions == nil {
invalidParams.Add(smithy.NewErrParamRequired("InstanceDefinitions"))
} else if v.InstanceDefinitions != nil {
if err := validateInstanceDefinitions(v.InstanceDefinitions); err != nil {
invalidParams.AddNested("InstanceDefinitions", err.(smithy.InvalidParamsError))
}
}
if v.AutoScalingPolicy != nil {
if err := validateGameServerGroupAutoScalingPolicy(v.AutoScalingPolicy); err != nil {
invalidParams.AddNested("AutoScalingPolicy", err.(smithy.InvalidParamsError))
}
}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateGameSessionInput(v *CreateGameSessionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateGameSessionInput"}
if v.MaximumPlayerSessionCount == nil {
invalidParams.Add(smithy.NewErrParamRequired("MaximumPlayerSessionCount"))
}
if v.GameProperties != nil {
if err := validateGamePropertyList(v.GameProperties); err != nil {
invalidParams.AddNested("GameProperties", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateGameSessionQueueInput(v *CreateGameSessionQueueInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateGameSessionQueueInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateLocationInput(v *CreateLocationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateLocationInput"}
if v.LocationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("LocationName"))
}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateMatchmakingConfigurationInput(v *CreateMatchmakingConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateMatchmakingConfigurationInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.RequestTimeoutSeconds == nil {
invalidParams.Add(smithy.NewErrParamRequired("RequestTimeoutSeconds"))
}
if v.AcceptanceRequired == nil {
invalidParams.Add(smithy.NewErrParamRequired("AcceptanceRequired"))
}
if v.RuleSetName == nil {
invalidParams.Add(smithy.NewErrParamRequired("RuleSetName"))
}
if v.GameProperties != nil {
if err := validateGamePropertyList(v.GameProperties); err != nil {
invalidParams.AddNested("GameProperties", err.(smithy.InvalidParamsError))
}
}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateMatchmakingRuleSetInput(v *CreateMatchmakingRuleSetInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateMatchmakingRuleSetInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.RuleSetBody == nil {
invalidParams.Add(smithy.NewErrParamRequired("RuleSetBody"))
}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreatePlayerSessionInput(v *CreatePlayerSessionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreatePlayerSessionInput"}
if v.GameSessionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameSessionId"))
}
if v.PlayerId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PlayerId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreatePlayerSessionsInput(v *CreatePlayerSessionsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreatePlayerSessionsInput"}
if v.GameSessionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameSessionId"))
}
if v.PlayerIds == nil {
invalidParams.Add(smithy.NewErrParamRequired("PlayerIds"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateScriptInput(v *CreateScriptInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateScriptInput"}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateVpcPeeringAuthorizationInput(v *CreateVpcPeeringAuthorizationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateVpcPeeringAuthorizationInput"}
if v.GameLiftAwsAccountId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameLiftAwsAccountId"))
}
if v.PeerVpcId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PeerVpcId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateVpcPeeringConnectionInput(v *CreateVpcPeeringConnectionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateVpcPeeringConnectionInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if v.PeerVpcAwsAccountId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PeerVpcAwsAccountId"))
}
if v.PeerVpcId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PeerVpcId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteAliasInput(v *DeleteAliasInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteAliasInput"}
if v.AliasId == nil {
invalidParams.Add(smithy.NewErrParamRequired("AliasId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteBuildInput(v *DeleteBuildInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteBuildInput"}
if v.BuildId == nil {
invalidParams.Add(smithy.NewErrParamRequired("BuildId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteFleetInput(v *DeleteFleetInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteFleetInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteFleetLocationsInput(v *DeleteFleetLocationsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteFleetLocationsInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if v.Locations == nil {
invalidParams.Add(smithy.NewErrParamRequired("Locations"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteGameServerGroupInput(v *DeleteGameServerGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteGameServerGroupInput"}
if v.GameServerGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteGameSessionQueueInput(v *DeleteGameSessionQueueInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteGameSessionQueueInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteLocationInput(v *DeleteLocationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteLocationInput"}
if v.LocationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("LocationName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteMatchmakingConfigurationInput(v *DeleteMatchmakingConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteMatchmakingConfigurationInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteMatchmakingRuleSetInput(v *DeleteMatchmakingRuleSetInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteMatchmakingRuleSetInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteScalingPolicyInput(v *DeleteScalingPolicyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteScalingPolicyInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteScriptInput(v *DeleteScriptInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteScriptInput"}
if v.ScriptId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ScriptId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteVpcPeeringAuthorizationInput(v *DeleteVpcPeeringAuthorizationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteVpcPeeringAuthorizationInput"}
if v.GameLiftAwsAccountId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameLiftAwsAccountId"))
}
if v.PeerVpcId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PeerVpcId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteVpcPeeringConnectionInput(v *DeleteVpcPeeringConnectionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteVpcPeeringConnectionInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if v.VpcPeeringConnectionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("VpcPeeringConnectionId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeregisterComputeInput(v *DeregisterComputeInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeregisterComputeInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if v.ComputeName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ComputeName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeregisterGameServerInput(v *DeregisterGameServerInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeregisterGameServerInput"}
if v.GameServerGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
}
if v.GameServerId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameServerId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeAliasInput(v *DescribeAliasInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeAliasInput"}
if v.AliasId == nil {
invalidParams.Add(smithy.NewErrParamRequired("AliasId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeBuildInput(v *DescribeBuildInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeBuildInput"}
if v.BuildId == nil {
invalidParams.Add(smithy.NewErrParamRequired("BuildId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeComputeInput(v *DescribeComputeInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeComputeInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if v.ComputeName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ComputeName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeFleetEventsInput(v *DescribeFleetEventsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeFleetEventsInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeFleetLocationAttributesInput(v *DescribeFleetLocationAttributesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeFleetLocationAttributesInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeFleetLocationCapacityInput(v *DescribeFleetLocationCapacityInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeFleetLocationCapacityInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if v.Location == nil {
invalidParams.Add(smithy.NewErrParamRequired("Location"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeFleetLocationUtilizationInput(v *DescribeFleetLocationUtilizationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeFleetLocationUtilizationInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if v.Location == nil {
invalidParams.Add(smithy.NewErrParamRequired("Location"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeFleetPortSettingsInput(v *DescribeFleetPortSettingsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeFleetPortSettingsInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeGameServerGroupInput(v *DescribeGameServerGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeGameServerGroupInput"}
if v.GameServerGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeGameServerInput(v *DescribeGameServerInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeGameServerInput"}
if v.GameServerGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
}
if v.GameServerId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameServerId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeGameServerInstancesInput(v *DescribeGameServerInstancesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeGameServerInstancesInput"}
if v.GameServerGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeGameSessionPlacementInput(v *DescribeGameSessionPlacementInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeGameSessionPlacementInput"}
if v.PlacementId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PlacementId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeInstancesInput(v *DescribeInstancesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeInstancesInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeMatchmakingInput(v *DescribeMatchmakingInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeMatchmakingInput"}
if v.TicketIds == nil {
invalidParams.Add(smithy.NewErrParamRequired("TicketIds"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeRuntimeConfigurationInput(v *DescribeRuntimeConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeRuntimeConfigurationInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeScalingPoliciesInput(v *DescribeScalingPoliciesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeScalingPoliciesInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeScriptInput(v *DescribeScriptInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeScriptInput"}
if v.ScriptId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ScriptId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetComputeAccessInput(v *GetComputeAccessInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetComputeAccessInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if v.ComputeName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ComputeName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetComputeAuthTokenInput(v *GetComputeAuthTokenInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetComputeAuthTokenInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if v.ComputeName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ComputeName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetGameSessionLogUrlInput(v *GetGameSessionLogUrlInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetGameSessionLogUrlInput"}
if v.GameSessionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameSessionId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetInstanceAccessInput(v *GetInstanceAccessInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetInstanceAccessInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if v.InstanceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListComputeInput(v *ListComputeInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListComputeInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListGameServersInput(v *ListGameServersInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListGameServersInput"}
if v.GameServerGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
if v.ResourceARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpPutScalingPolicyInput(v *PutScalingPolicyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PutScalingPolicyInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if len(v.MetricName) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
}
if v.TargetConfiguration != nil {
if err := validateTargetConfiguration(v.TargetConfiguration); err != nil {
invalidParams.AddNested("TargetConfiguration", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpRegisterComputeInput(v *RegisterComputeInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RegisterComputeInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if v.ComputeName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ComputeName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpRegisterGameServerInput(v *RegisterGameServerInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RegisterGameServerInput"}
if v.GameServerGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
}
if v.GameServerId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameServerId"))
}
if v.InstanceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpRequestUploadCredentialsInput(v *RequestUploadCredentialsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RequestUploadCredentialsInput"}
if v.BuildId == nil {
invalidParams.Add(smithy.NewErrParamRequired("BuildId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpResolveAliasInput(v *ResolveAliasInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ResolveAliasInput"}
if v.AliasId == nil {
invalidParams.Add(smithy.NewErrParamRequired("AliasId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpResumeGameServerGroupInput(v *ResumeGameServerGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ResumeGameServerGroupInput"}
if v.GameServerGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
}
if v.ResumeActions == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResumeActions"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartFleetActionsInput(v *StartFleetActionsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartFleetActionsInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if v.Actions == nil {
invalidParams.Add(smithy.NewErrParamRequired("Actions"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartGameSessionPlacementInput(v *StartGameSessionPlacementInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartGameSessionPlacementInput"}
if v.PlacementId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PlacementId"))
}
if v.GameSessionQueueName == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameSessionQueueName"))
}
if v.GameProperties != nil {
if err := validateGamePropertyList(v.GameProperties); err != nil {
invalidParams.AddNested("GameProperties", err.(smithy.InvalidParamsError))
}
}
if v.MaximumPlayerSessionCount == nil {
invalidParams.Add(smithy.NewErrParamRequired("MaximumPlayerSessionCount"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartMatchBackfillInput(v *StartMatchBackfillInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartMatchBackfillInput"}
if v.ConfigurationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ConfigurationName"))
}
if v.Players == nil {
invalidParams.Add(smithy.NewErrParamRequired("Players"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartMatchmakingInput(v *StartMatchmakingInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartMatchmakingInput"}
if v.ConfigurationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ConfigurationName"))
}
if v.Players == nil {
invalidParams.Add(smithy.NewErrParamRequired("Players"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStopFleetActionsInput(v *StopFleetActionsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StopFleetActionsInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if v.Actions == nil {
invalidParams.Add(smithy.NewErrParamRequired("Actions"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStopGameSessionPlacementInput(v *StopGameSessionPlacementInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StopGameSessionPlacementInput"}
if v.PlacementId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PlacementId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStopMatchmakingInput(v *StopMatchmakingInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StopMatchmakingInput"}
if v.TicketId == nil {
invalidParams.Add(smithy.NewErrParamRequired("TicketId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpSuspendGameServerGroupInput(v *SuspendGameServerGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SuspendGameServerGroupInput"}
if v.GameServerGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
}
if v.SuspendActions == nil {
invalidParams.Add(smithy.NewErrParamRequired("SuspendActions"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpTagResourceInput(v *TagResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
if v.ResourceARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
}
if v.Tags == nil {
invalidParams.Add(smithy.NewErrParamRequired("Tags"))
} else if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUntagResourceInput(v *UntagResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
if v.ResourceARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
}
if v.TagKeys == nil {
invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateAliasInput(v *UpdateAliasInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateAliasInput"}
if v.AliasId == nil {
invalidParams.Add(smithy.NewErrParamRequired("AliasId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateBuildInput(v *UpdateBuildInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateBuildInput"}
if v.BuildId == nil {
invalidParams.Add(smithy.NewErrParamRequired("BuildId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateFleetAttributesInput(v *UpdateFleetAttributesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateFleetAttributesInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if v.AnywhereConfiguration != nil {
if err := validateAnywhereConfiguration(v.AnywhereConfiguration); err != nil {
invalidParams.AddNested("AnywhereConfiguration", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateFleetCapacityInput(v *UpdateFleetCapacityInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateFleetCapacityInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateFleetPortSettingsInput(v *UpdateFleetPortSettingsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateFleetPortSettingsInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if v.InboundPermissionAuthorizations != nil {
if err := validateIpPermissionsList(v.InboundPermissionAuthorizations); err != nil {
invalidParams.AddNested("InboundPermissionAuthorizations", err.(smithy.InvalidParamsError))
}
}
if v.InboundPermissionRevocations != nil {
if err := validateIpPermissionsList(v.InboundPermissionRevocations); err != nil {
invalidParams.AddNested("InboundPermissionRevocations", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateGameServerGroupInput(v *UpdateGameServerGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateGameServerGroupInput"}
if v.GameServerGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
}
if v.InstanceDefinitions != nil {
if err := validateInstanceDefinitions(v.InstanceDefinitions); err != nil {
invalidParams.AddNested("InstanceDefinitions", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateGameServerInput(v *UpdateGameServerInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateGameServerInput"}
if v.GameServerGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
}
if v.GameServerId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameServerId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateGameSessionInput(v *UpdateGameSessionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateGameSessionInput"}
if v.GameSessionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GameSessionId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateGameSessionQueueInput(v *UpdateGameSessionQueueInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateGameSessionQueueInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateMatchmakingConfigurationInput(v *UpdateMatchmakingConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateMatchmakingConfigurationInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.GameProperties != nil {
if err := validateGamePropertyList(v.GameProperties); err != nil {
invalidParams.AddNested("GameProperties", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateRuntimeConfigurationInput(v *UpdateRuntimeConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateRuntimeConfigurationInput"}
if v.FleetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
}
if v.RuntimeConfiguration == nil {
invalidParams.Add(smithy.NewErrParamRequired("RuntimeConfiguration"))
} else if v.RuntimeConfiguration != nil {
if err := validateRuntimeConfiguration(v.RuntimeConfiguration); err != nil {
invalidParams.AddNested("RuntimeConfiguration", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateScriptInput(v *UpdateScriptInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateScriptInput"}
if v.ScriptId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ScriptId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpValidateMatchmakingRuleSetInput(v *ValidateMatchmakingRuleSetInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ValidateMatchmakingRuleSetInput"}
if v.RuleSetBody == nil {
invalidParams.Add(smithy.NewErrParamRequired("RuleSetBody"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
| 3,904 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package endpoints
import (
"github.com/aws/aws-sdk-go-v2/aws"
endpoints "github.com/aws/aws-sdk-go-v2/internal/endpoints/v2"
"github.com/aws/smithy-go/logging"
"regexp"
)
// Options is the endpoint resolver configuration options
type Options struct {
// Logger is a logging implementation that log events should be sent to.
Logger logging.Logger
// LogDeprecated indicates that deprecated endpoints should be logged to the
// provided logger.
LogDeprecated bool
// ResolvedRegion is used to override the region to be resolved, rather then the
// using the value passed to the ResolveEndpoint method. This value is used by the
// SDK to translate regions like fips-us-east-1 or us-east-1-fips to an alternative
// name. You must not set this value directly in your application.
ResolvedRegion string
// DisableHTTPS informs the resolver to return an endpoint that does not use the
// HTTPS scheme.
DisableHTTPS bool
// UseDualStackEndpoint specifies the resolver must resolve a dual-stack endpoint.
UseDualStackEndpoint aws.DualStackEndpointState
// UseFIPSEndpoint specifies the resolver must resolve a FIPS endpoint.
UseFIPSEndpoint aws.FIPSEndpointState
}
func (o Options) GetResolvedRegion() string {
return o.ResolvedRegion
}
func (o Options) GetDisableHTTPS() bool {
return o.DisableHTTPS
}
func (o Options) GetUseDualStackEndpoint() aws.DualStackEndpointState {
return o.UseDualStackEndpoint
}
func (o Options) GetUseFIPSEndpoint() aws.FIPSEndpointState {
return o.UseFIPSEndpoint
}
func transformToSharedOptions(options Options) endpoints.Options {
return endpoints.Options{
Logger: options.Logger,
LogDeprecated: options.LogDeprecated,
ResolvedRegion: options.ResolvedRegion,
DisableHTTPS: options.DisableHTTPS,
UseDualStackEndpoint: options.UseDualStackEndpoint,
UseFIPSEndpoint: options.UseFIPSEndpoint,
}
}
// Resolver GameLift endpoint resolver
type Resolver struct {
partitions endpoints.Partitions
}
// ResolveEndpoint resolves the service endpoint for the given region and options
func (r *Resolver) ResolveEndpoint(region string, options Options) (endpoint aws.Endpoint, err error) {
if len(region) == 0 {
return endpoint, &aws.MissingRegionError{}
}
opt := transformToSharedOptions(options)
return r.partitions.ResolveEndpoint(region, opt)
}
// New returns a new Resolver
func New() *Resolver {
return &Resolver{
partitions: defaultPartitions,
}
}
var partitionRegexp = struct {
Aws *regexp.Regexp
AwsCn *regexp.Regexp
AwsIso *regexp.Regexp
AwsIsoB *regexp.Regexp
AwsIsoE *regexp.Regexp
AwsIsoF *regexp.Regexp
AwsUsGov *regexp.Regexp
}{
Aws: regexp.MustCompile("^(us|eu|ap|sa|ca|me|af)\\-\\w+\\-\\d+$"),
AwsCn: regexp.MustCompile("^cn\\-\\w+\\-\\d+$"),
AwsIso: regexp.MustCompile("^us\\-iso\\-\\w+\\-\\d+$"),
AwsIsoB: regexp.MustCompile("^us\\-isob\\-\\w+\\-\\d+$"),
AwsIsoE: regexp.MustCompile("^eu\\-isoe\\-\\w+\\-\\d+$"),
AwsIsoF: regexp.MustCompile("^us\\-isof\\-\\w+\\-\\d+$"),
AwsUsGov: regexp.MustCompile("^us\\-gov\\-\\w+\\-\\d+$"),
}
var defaultPartitions = endpoints.Partitions{
{
ID: "aws",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "gamelift.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "gamelift-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "gamelift-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "gamelift.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.Aws,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "af-south-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-northeast-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-northeast-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-northeast-3",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-south-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-southeast-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-southeast-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ca-central-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-central-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-north-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-south-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-west-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-west-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-west-3",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "me-south-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "sa-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-east-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-west-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-west-2",
}: endpoints.Endpoint{},
},
},
{
ID: "aws-cn",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "gamelift.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "gamelift-fips.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "gamelift-fips.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "gamelift.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsCn,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "cn-north-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "cn-northwest-1",
}: endpoints.Endpoint{},
},
},
{
ID: "aws-iso",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "gamelift-fips.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "gamelift.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIso,
IsRegionalized: true,
},
{
ID: "aws-iso-b",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "gamelift-fips.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "gamelift.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoB,
IsRegionalized: true,
},
{
ID: "aws-iso-e",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "gamelift-fips.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "gamelift.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoE,
IsRegionalized: true,
},
{
ID: "aws-iso-f",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "gamelift-fips.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "gamelift.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoF,
IsRegionalized: true,
},
{
ID: "aws-us-gov",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "gamelift.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "gamelift-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "gamelift-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "gamelift.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsUsGov,
IsRegionalized: true,
},
}
| 370 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package endpoints
import (
"testing"
)
func TestRegexCompile(t *testing.T) {
_ = defaultPartitions
}
| 12 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
type AcceptanceType string
// Enum values for AcceptanceType
const (
AcceptanceTypeAccept AcceptanceType = "ACCEPT"
AcceptanceTypeReject AcceptanceType = "REJECT"
)
// Values returns all known values for AcceptanceType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (AcceptanceType) Values() []AcceptanceType {
return []AcceptanceType{
"ACCEPT",
"REJECT",
}
}
type BackfillMode string
// Enum values for BackfillMode
const (
BackfillModeAutomatic BackfillMode = "AUTOMATIC"
BackfillModeManual BackfillMode = "MANUAL"
)
// Values returns all known values for BackfillMode. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (BackfillMode) Values() []BackfillMode {
return []BackfillMode{
"AUTOMATIC",
"MANUAL",
}
}
type BalancingStrategy string
// Enum values for BalancingStrategy
const (
BalancingStrategySpotOnly BalancingStrategy = "SPOT_ONLY"
BalancingStrategySpotPreferred BalancingStrategy = "SPOT_PREFERRED"
BalancingStrategyOnDemandOnly BalancingStrategy = "ON_DEMAND_ONLY"
)
// Values returns all known values for BalancingStrategy. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (BalancingStrategy) Values() []BalancingStrategy {
return []BalancingStrategy{
"SPOT_ONLY",
"SPOT_PREFERRED",
"ON_DEMAND_ONLY",
}
}
type BuildStatus string
// Enum values for BuildStatus
const (
BuildStatusInitialized BuildStatus = "INITIALIZED"
BuildStatusReady BuildStatus = "READY"
BuildStatusFailed BuildStatus = "FAILED"
)
// Values returns all known values for BuildStatus. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (BuildStatus) Values() []BuildStatus {
return []BuildStatus{
"INITIALIZED",
"READY",
"FAILED",
}
}
type CertificateType string
// Enum values for CertificateType
const (
CertificateTypeDisabled CertificateType = "DISABLED"
CertificateTypeGenerated CertificateType = "GENERATED"
)
// Values returns all known values for CertificateType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (CertificateType) Values() []CertificateType {
return []CertificateType{
"DISABLED",
"GENERATED",
}
}
type ComparisonOperatorType string
// Enum values for ComparisonOperatorType
const (
ComparisonOperatorTypeGreaterThanOrEqualToThreshold ComparisonOperatorType = "GreaterThanOrEqualToThreshold"
ComparisonOperatorTypeGreaterThanThreshold ComparisonOperatorType = "GreaterThanThreshold"
ComparisonOperatorTypeLessThanThreshold ComparisonOperatorType = "LessThanThreshold"
ComparisonOperatorTypeLessThanOrEqualToThreshold ComparisonOperatorType = "LessThanOrEqualToThreshold"
)
// Values returns all known values for ComparisonOperatorType. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (ComparisonOperatorType) Values() []ComparisonOperatorType {
return []ComparisonOperatorType{
"GreaterThanOrEqualToThreshold",
"GreaterThanThreshold",
"LessThanThreshold",
"LessThanOrEqualToThreshold",
}
}
type ComputeStatus string
// Enum values for ComputeStatus
const (
ComputeStatusPending ComputeStatus = "PENDING"
ComputeStatusActive ComputeStatus = "ACTIVE"
ComputeStatusTerminating ComputeStatus = "TERMINATING"
)
// Values returns all known values for ComputeStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (ComputeStatus) Values() []ComputeStatus {
return []ComputeStatus{
"PENDING",
"ACTIVE",
"TERMINATING",
}
}
type ComputeType string
// Enum values for ComputeType
const (
ComputeTypeEc2 ComputeType = "EC2"
ComputeTypeAnywhere ComputeType = "ANYWHERE"
)
// Values returns all known values for ComputeType. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (ComputeType) Values() []ComputeType {
return []ComputeType{
"EC2",
"ANYWHERE",
}
}
type EC2InstanceType string
// Enum values for EC2InstanceType
const (
EC2InstanceTypeT2Micro EC2InstanceType = "t2.micro"
EC2InstanceTypeT2Small EC2InstanceType = "t2.small"
EC2InstanceTypeT2Medium EC2InstanceType = "t2.medium"
EC2InstanceTypeT2Large EC2InstanceType = "t2.large"
EC2InstanceTypeC3Large EC2InstanceType = "c3.large"
EC2InstanceTypeC3Xlarge EC2InstanceType = "c3.xlarge"
EC2InstanceTypeC32xlarge EC2InstanceType = "c3.2xlarge"
EC2InstanceTypeC34xlarge EC2InstanceType = "c3.4xlarge"
EC2InstanceTypeC38xlarge EC2InstanceType = "c3.8xlarge"
EC2InstanceTypeC4Large EC2InstanceType = "c4.large"
EC2InstanceTypeC4Xlarge EC2InstanceType = "c4.xlarge"
EC2InstanceTypeC42xlarge EC2InstanceType = "c4.2xlarge"
EC2InstanceTypeC44xlarge EC2InstanceType = "c4.4xlarge"
EC2InstanceTypeC48xlarge EC2InstanceType = "c4.8xlarge"
EC2InstanceTypeC5Large EC2InstanceType = "c5.large"
EC2InstanceTypeC5Xlarge EC2InstanceType = "c5.xlarge"
EC2InstanceTypeC52xlarge EC2InstanceType = "c5.2xlarge"
EC2InstanceTypeC54xlarge EC2InstanceType = "c5.4xlarge"
EC2InstanceTypeC59xlarge EC2InstanceType = "c5.9xlarge"
EC2InstanceTypeC512xlarge EC2InstanceType = "c5.12xlarge"
EC2InstanceTypeC518xlarge EC2InstanceType = "c5.18xlarge"
EC2InstanceTypeC524xlarge EC2InstanceType = "c5.24xlarge"
EC2InstanceTypeC5aLarge EC2InstanceType = "c5a.large"
EC2InstanceTypeC5aXlarge EC2InstanceType = "c5a.xlarge"
EC2InstanceTypeC5a2xlarge EC2InstanceType = "c5a.2xlarge"
EC2InstanceTypeC5a4xlarge EC2InstanceType = "c5a.4xlarge"
EC2InstanceTypeC5a8xlarge EC2InstanceType = "c5a.8xlarge"
EC2InstanceTypeC5a12xlarge EC2InstanceType = "c5a.12xlarge"
EC2InstanceTypeC5a16xlarge EC2InstanceType = "c5a.16xlarge"
EC2InstanceTypeC5a24xlarge EC2InstanceType = "c5a.24xlarge"
EC2InstanceTypeR3Large EC2InstanceType = "r3.large"
EC2InstanceTypeR3Xlarge EC2InstanceType = "r3.xlarge"
EC2InstanceTypeR32xlarge EC2InstanceType = "r3.2xlarge"
EC2InstanceTypeR34xlarge EC2InstanceType = "r3.4xlarge"
EC2InstanceTypeR38xlarge EC2InstanceType = "r3.8xlarge"
EC2InstanceTypeR4Large EC2InstanceType = "r4.large"
EC2InstanceTypeR4Xlarge EC2InstanceType = "r4.xlarge"
EC2InstanceTypeR42xlarge EC2InstanceType = "r4.2xlarge"
EC2InstanceTypeR44xlarge EC2InstanceType = "r4.4xlarge"
EC2InstanceTypeR48xlarge EC2InstanceType = "r4.8xlarge"
EC2InstanceTypeR416xlarge EC2InstanceType = "r4.16xlarge"
EC2InstanceTypeR5Large EC2InstanceType = "r5.large"
EC2InstanceTypeR5Xlarge EC2InstanceType = "r5.xlarge"
EC2InstanceTypeR52xlarge EC2InstanceType = "r5.2xlarge"
EC2InstanceTypeR54xlarge EC2InstanceType = "r5.4xlarge"
EC2InstanceTypeR58xlarge EC2InstanceType = "r5.8xlarge"
EC2InstanceTypeR512xlarge EC2InstanceType = "r5.12xlarge"
EC2InstanceTypeR516xlarge EC2InstanceType = "r5.16xlarge"
EC2InstanceTypeR524xlarge EC2InstanceType = "r5.24xlarge"
EC2InstanceTypeR5aLarge EC2InstanceType = "r5a.large"
EC2InstanceTypeR5aXlarge EC2InstanceType = "r5a.xlarge"
EC2InstanceTypeR5a2xlarge EC2InstanceType = "r5a.2xlarge"
EC2InstanceTypeR5a4xlarge EC2InstanceType = "r5a.4xlarge"
EC2InstanceTypeR5a8xlarge EC2InstanceType = "r5a.8xlarge"
EC2InstanceTypeR5a12xlarge EC2InstanceType = "r5a.12xlarge"
EC2InstanceTypeR5a16xlarge EC2InstanceType = "r5a.16xlarge"
EC2InstanceTypeR5a24xlarge EC2InstanceType = "r5a.24xlarge"
EC2InstanceTypeM3Medium EC2InstanceType = "m3.medium"
EC2InstanceTypeM3Large EC2InstanceType = "m3.large"
EC2InstanceTypeM3Xlarge EC2InstanceType = "m3.xlarge"
EC2InstanceTypeM32xlarge EC2InstanceType = "m3.2xlarge"
EC2InstanceTypeM4Large EC2InstanceType = "m4.large"
EC2InstanceTypeM4Xlarge EC2InstanceType = "m4.xlarge"
EC2InstanceTypeM42xlarge EC2InstanceType = "m4.2xlarge"
EC2InstanceTypeM44xlarge EC2InstanceType = "m4.4xlarge"
EC2InstanceTypeM410xlarge EC2InstanceType = "m4.10xlarge"
EC2InstanceTypeM5Large EC2InstanceType = "m5.large"
EC2InstanceTypeM5Xlarge EC2InstanceType = "m5.xlarge"
EC2InstanceTypeM52xlarge EC2InstanceType = "m5.2xlarge"
EC2InstanceTypeM54xlarge EC2InstanceType = "m5.4xlarge"
EC2InstanceTypeM58xlarge EC2InstanceType = "m5.8xlarge"
EC2InstanceTypeM512xlarge EC2InstanceType = "m5.12xlarge"
EC2InstanceTypeM516xlarge EC2InstanceType = "m5.16xlarge"
EC2InstanceTypeM524xlarge EC2InstanceType = "m5.24xlarge"
EC2InstanceTypeM5aLarge EC2InstanceType = "m5a.large"
EC2InstanceTypeM5aXlarge EC2InstanceType = "m5a.xlarge"
EC2InstanceTypeM5a2xlarge EC2InstanceType = "m5a.2xlarge"
EC2InstanceTypeM5a4xlarge EC2InstanceType = "m5a.4xlarge"
EC2InstanceTypeM5a8xlarge EC2InstanceType = "m5a.8xlarge"
EC2InstanceTypeM5a12xlarge EC2InstanceType = "m5a.12xlarge"
EC2InstanceTypeM5a16xlarge EC2InstanceType = "m5a.16xlarge"
EC2InstanceTypeM5a24xlarge EC2InstanceType = "m5a.24xlarge"
EC2InstanceTypeC5dLarge EC2InstanceType = "c5d.large"
EC2InstanceTypeC5dXlarge EC2InstanceType = "c5d.xlarge"
EC2InstanceTypeC5d2xlarge EC2InstanceType = "c5d.2xlarge"
EC2InstanceTypeC5d4xlarge EC2InstanceType = "c5d.4xlarge"
EC2InstanceTypeC5d9xlarge EC2InstanceType = "c5d.9xlarge"
EC2InstanceTypeC5d12xlarge EC2InstanceType = "c5d.12xlarge"
EC2InstanceTypeC5d18xlarge EC2InstanceType = "c5d.18xlarge"
EC2InstanceTypeC5d24xlarge EC2InstanceType = "c5d.24xlarge"
EC2InstanceTypeC6aLarge EC2InstanceType = "c6a.large"
EC2InstanceTypeC6aXlarge EC2InstanceType = "c6a.xlarge"
EC2InstanceTypeC6a2xlarge EC2InstanceType = "c6a.2xlarge"
EC2InstanceTypeC6a4xlarge EC2InstanceType = "c6a.4xlarge"
EC2InstanceTypeC6a8xlarge EC2InstanceType = "c6a.8xlarge"
EC2InstanceTypeC6a12xlarge EC2InstanceType = "c6a.12xlarge"
EC2InstanceTypeC6a16xlarge EC2InstanceType = "c6a.16xlarge"
EC2InstanceTypeC6a24xlarge EC2InstanceType = "c6a.24xlarge"
EC2InstanceTypeC6iLarge EC2InstanceType = "c6i.large"
EC2InstanceTypeC6iXlarge EC2InstanceType = "c6i.xlarge"
EC2InstanceTypeC6i2xlarge EC2InstanceType = "c6i.2xlarge"
EC2InstanceTypeC6i4xlarge EC2InstanceType = "c6i.4xlarge"
EC2InstanceTypeC6i8xlarge EC2InstanceType = "c6i.8xlarge"
EC2InstanceTypeC6i12xlarge EC2InstanceType = "c6i.12xlarge"
EC2InstanceTypeC6i16xlarge EC2InstanceType = "c6i.16xlarge"
EC2InstanceTypeC6i24xlarge EC2InstanceType = "c6i.24xlarge"
EC2InstanceTypeR5dLarge EC2InstanceType = "r5d.large"
EC2InstanceTypeR5dXlarge EC2InstanceType = "r5d.xlarge"
EC2InstanceTypeR5d2xlarge EC2InstanceType = "r5d.2xlarge"
EC2InstanceTypeR5d4xlarge EC2InstanceType = "r5d.4xlarge"
EC2InstanceTypeR5d8xlarge EC2InstanceType = "r5d.8xlarge"
EC2InstanceTypeR5d12xlarge EC2InstanceType = "r5d.12xlarge"
EC2InstanceTypeR5d16xlarge EC2InstanceType = "r5d.16xlarge"
EC2InstanceTypeR5d24xlarge EC2InstanceType = "r5d.24xlarge"
)
// Values returns all known values for EC2InstanceType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (EC2InstanceType) Values() []EC2InstanceType {
return []EC2InstanceType{
"t2.micro",
"t2.small",
"t2.medium",
"t2.large",
"c3.large",
"c3.xlarge",
"c3.2xlarge",
"c3.4xlarge",
"c3.8xlarge",
"c4.large",
"c4.xlarge",
"c4.2xlarge",
"c4.4xlarge",
"c4.8xlarge",
"c5.large",
"c5.xlarge",
"c5.2xlarge",
"c5.4xlarge",
"c5.9xlarge",
"c5.12xlarge",
"c5.18xlarge",
"c5.24xlarge",
"c5a.large",
"c5a.xlarge",
"c5a.2xlarge",
"c5a.4xlarge",
"c5a.8xlarge",
"c5a.12xlarge",
"c5a.16xlarge",
"c5a.24xlarge",
"r3.large",
"r3.xlarge",
"r3.2xlarge",
"r3.4xlarge",
"r3.8xlarge",
"r4.large",
"r4.xlarge",
"r4.2xlarge",
"r4.4xlarge",
"r4.8xlarge",
"r4.16xlarge",
"r5.large",
"r5.xlarge",
"r5.2xlarge",
"r5.4xlarge",
"r5.8xlarge",
"r5.12xlarge",
"r5.16xlarge",
"r5.24xlarge",
"r5a.large",
"r5a.xlarge",
"r5a.2xlarge",
"r5a.4xlarge",
"r5a.8xlarge",
"r5a.12xlarge",
"r5a.16xlarge",
"r5a.24xlarge",
"m3.medium",
"m3.large",
"m3.xlarge",
"m3.2xlarge",
"m4.large",
"m4.xlarge",
"m4.2xlarge",
"m4.4xlarge",
"m4.10xlarge",
"m5.large",
"m5.xlarge",
"m5.2xlarge",
"m5.4xlarge",
"m5.8xlarge",
"m5.12xlarge",
"m5.16xlarge",
"m5.24xlarge",
"m5a.large",
"m5a.xlarge",
"m5a.2xlarge",
"m5a.4xlarge",
"m5a.8xlarge",
"m5a.12xlarge",
"m5a.16xlarge",
"m5a.24xlarge",
"c5d.large",
"c5d.xlarge",
"c5d.2xlarge",
"c5d.4xlarge",
"c5d.9xlarge",
"c5d.12xlarge",
"c5d.18xlarge",
"c5d.24xlarge",
"c6a.large",
"c6a.xlarge",
"c6a.2xlarge",
"c6a.4xlarge",
"c6a.8xlarge",
"c6a.12xlarge",
"c6a.16xlarge",
"c6a.24xlarge",
"c6i.large",
"c6i.xlarge",
"c6i.2xlarge",
"c6i.4xlarge",
"c6i.8xlarge",
"c6i.12xlarge",
"c6i.16xlarge",
"c6i.24xlarge",
"r5d.large",
"r5d.xlarge",
"r5d.2xlarge",
"r5d.4xlarge",
"r5d.8xlarge",
"r5d.12xlarge",
"r5d.16xlarge",
"r5d.24xlarge",
}
}
type EventCode string
// Enum values for EventCode
const (
EventCodeGenericEvent EventCode = "GENERIC_EVENT"
EventCodeFleetCreated EventCode = "FLEET_CREATED"
EventCodeFleetDeleted EventCode = "FLEET_DELETED"
EventCodeFleetScalingEvent EventCode = "FLEET_SCALING_EVENT"
EventCodeFleetStateDownloading EventCode = "FLEET_STATE_DOWNLOADING"
EventCodeFleetStateValidating EventCode = "FLEET_STATE_VALIDATING"
EventCodeFleetStateBuilding EventCode = "FLEET_STATE_BUILDING"
EventCodeFleetStateActivating EventCode = "FLEET_STATE_ACTIVATING"
EventCodeFleetStateActive EventCode = "FLEET_STATE_ACTIVE"
EventCodeFleetStateError EventCode = "FLEET_STATE_ERROR"
EventCodeFleetInitializationFailed EventCode = "FLEET_INITIALIZATION_FAILED"
EventCodeFleetBinaryDownloadFailed EventCode = "FLEET_BINARY_DOWNLOAD_FAILED"
EventCodeFleetValidationLaunchPathNotFound EventCode = "FLEET_VALIDATION_LAUNCH_PATH_NOT_FOUND"
EventCodeFleetValidationExecutableRuntimeFailure EventCode = "FLEET_VALIDATION_EXECUTABLE_RUNTIME_FAILURE"
EventCodeFleetValidationTimedOut EventCode = "FLEET_VALIDATION_TIMED_OUT"
EventCodeFleetActivationFailed EventCode = "FLEET_ACTIVATION_FAILED"
EventCodeFleetActivationFailedNoInstances EventCode = "FLEET_ACTIVATION_FAILED_NO_INSTANCES"
EventCodeFleetNewGameSessionProtectionPolicyUpdated EventCode = "FLEET_NEW_GAME_SESSION_PROTECTION_POLICY_UPDATED"
EventCodeServerProcessInvalidPath EventCode = "SERVER_PROCESS_INVALID_PATH"
EventCodeServerProcessSdkInitializationTimeout EventCode = "SERVER_PROCESS_SDK_INITIALIZATION_TIMEOUT"
EventCodeServerProcessProcessReadyTimeout EventCode = "SERVER_PROCESS_PROCESS_READY_TIMEOUT"
EventCodeServerProcessCrashed EventCode = "SERVER_PROCESS_CRASHED"
EventCodeServerProcessTerminatedUnhealthy EventCode = "SERVER_PROCESS_TERMINATED_UNHEALTHY"
EventCodeServerProcessForceTerminated EventCode = "SERVER_PROCESS_FORCE_TERMINATED"
EventCodeServerProcessProcessExitTimeout EventCode = "SERVER_PROCESS_PROCESS_EXIT_TIMEOUT"
EventCodeGameSessionActivationTimeout EventCode = "GAME_SESSION_ACTIVATION_TIMEOUT"
EventCodeFleetCreationExtractingBuild EventCode = "FLEET_CREATION_EXTRACTING_BUILD"
EventCodeFleetCreationRunningInstaller EventCode = "FLEET_CREATION_RUNNING_INSTALLER"
EventCodeFleetCreationValidatingRuntimeConfig EventCode = "FLEET_CREATION_VALIDATING_RUNTIME_CONFIG"
EventCodeFleetVpcPeeringSucceeded EventCode = "FLEET_VPC_PEERING_SUCCEEDED"
EventCodeFleetVpcPeeringFailed EventCode = "FLEET_VPC_PEERING_FAILED"
EventCodeFleetVpcPeeringDeleted EventCode = "FLEET_VPC_PEERING_DELETED"
EventCodeInstanceInterrupted EventCode = "INSTANCE_INTERRUPTED"
EventCodeInstanceRecycled EventCode = "INSTANCE_RECYCLED"
)
// Values returns all known values for EventCode. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (EventCode) Values() []EventCode {
return []EventCode{
"GENERIC_EVENT",
"FLEET_CREATED",
"FLEET_DELETED",
"FLEET_SCALING_EVENT",
"FLEET_STATE_DOWNLOADING",
"FLEET_STATE_VALIDATING",
"FLEET_STATE_BUILDING",
"FLEET_STATE_ACTIVATING",
"FLEET_STATE_ACTIVE",
"FLEET_STATE_ERROR",
"FLEET_INITIALIZATION_FAILED",
"FLEET_BINARY_DOWNLOAD_FAILED",
"FLEET_VALIDATION_LAUNCH_PATH_NOT_FOUND",
"FLEET_VALIDATION_EXECUTABLE_RUNTIME_FAILURE",
"FLEET_VALIDATION_TIMED_OUT",
"FLEET_ACTIVATION_FAILED",
"FLEET_ACTIVATION_FAILED_NO_INSTANCES",
"FLEET_NEW_GAME_SESSION_PROTECTION_POLICY_UPDATED",
"SERVER_PROCESS_INVALID_PATH",
"SERVER_PROCESS_SDK_INITIALIZATION_TIMEOUT",
"SERVER_PROCESS_PROCESS_READY_TIMEOUT",
"SERVER_PROCESS_CRASHED",
"SERVER_PROCESS_TERMINATED_UNHEALTHY",
"SERVER_PROCESS_FORCE_TERMINATED",
"SERVER_PROCESS_PROCESS_EXIT_TIMEOUT",
"GAME_SESSION_ACTIVATION_TIMEOUT",
"FLEET_CREATION_EXTRACTING_BUILD",
"FLEET_CREATION_RUNNING_INSTALLER",
"FLEET_CREATION_VALIDATING_RUNTIME_CONFIG",
"FLEET_VPC_PEERING_SUCCEEDED",
"FLEET_VPC_PEERING_FAILED",
"FLEET_VPC_PEERING_DELETED",
"INSTANCE_INTERRUPTED",
"INSTANCE_RECYCLED",
}
}
type FilterInstanceStatus string
// Enum values for FilterInstanceStatus
const (
FilterInstanceStatusActive FilterInstanceStatus = "ACTIVE"
FilterInstanceStatusDraining FilterInstanceStatus = "DRAINING"
)
// Values returns all known values for FilterInstanceStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (FilterInstanceStatus) Values() []FilterInstanceStatus {
return []FilterInstanceStatus{
"ACTIVE",
"DRAINING",
}
}
type FleetAction string
// Enum values for FleetAction
const (
FleetActionAutoScaling FleetAction = "AUTO_SCALING"
)
// Values returns all known values for FleetAction. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (FleetAction) Values() []FleetAction {
return []FleetAction{
"AUTO_SCALING",
}
}
type FleetStatus string
// Enum values for FleetStatus
const (
FleetStatusNew FleetStatus = "NEW"
FleetStatusDownloading FleetStatus = "DOWNLOADING"
FleetStatusValidating FleetStatus = "VALIDATING"
FleetStatusBuilding FleetStatus = "BUILDING"
FleetStatusActivating FleetStatus = "ACTIVATING"
FleetStatusActive FleetStatus = "ACTIVE"
FleetStatusDeleting FleetStatus = "DELETING"
FleetStatusError FleetStatus = "ERROR"
FleetStatusTerminated FleetStatus = "TERMINATED"
FleetStatusNotFound FleetStatus = "NOT_FOUND"
)
// Values returns all known values for FleetStatus. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (FleetStatus) Values() []FleetStatus {
return []FleetStatus{
"NEW",
"DOWNLOADING",
"VALIDATING",
"BUILDING",
"ACTIVATING",
"ACTIVE",
"DELETING",
"ERROR",
"TERMINATED",
"NOT_FOUND",
}
}
type FleetType string
// Enum values for FleetType
const (
FleetTypeOnDemand FleetType = "ON_DEMAND"
FleetTypeSpot FleetType = "SPOT"
)
// Values returns all known values for FleetType. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (FleetType) Values() []FleetType {
return []FleetType{
"ON_DEMAND",
"SPOT",
}
}
type FlexMatchMode string
// Enum values for FlexMatchMode
const (
FlexMatchModeStandalone FlexMatchMode = "STANDALONE"
FlexMatchModeWithQueue FlexMatchMode = "WITH_QUEUE"
)
// Values returns all known values for FlexMatchMode. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (FlexMatchMode) Values() []FlexMatchMode {
return []FlexMatchMode{
"STANDALONE",
"WITH_QUEUE",
}
}
type GameServerClaimStatus string
// Enum values for GameServerClaimStatus
const (
GameServerClaimStatusClaimed GameServerClaimStatus = "CLAIMED"
)
// Values returns all known values for GameServerClaimStatus. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (GameServerClaimStatus) Values() []GameServerClaimStatus {
return []GameServerClaimStatus{
"CLAIMED",
}
}
type GameServerGroupAction string
// Enum values for GameServerGroupAction
const (
GameServerGroupActionReplaceInstanceTypes GameServerGroupAction = "REPLACE_INSTANCE_TYPES"
)
// Values returns all known values for GameServerGroupAction. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (GameServerGroupAction) Values() []GameServerGroupAction {
return []GameServerGroupAction{
"REPLACE_INSTANCE_TYPES",
}
}
type GameServerGroupDeleteOption string
// Enum values for GameServerGroupDeleteOption
const (
GameServerGroupDeleteOptionSafeDelete GameServerGroupDeleteOption = "SAFE_DELETE"
GameServerGroupDeleteOptionForceDelete GameServerGroupDeleteOption = "FORCE_DELETE"
GameServerGroupDeleteOptionRetain GameServerGroupDeleteOption = "RETAIN"
)
// Values returns all known values for GameServerGroupDeleteOption. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
// The ordering of this slice is not guaranteed to be stable across updates.
func (GameServerGroupDeleteOption) Values() []GameServerGroupDeleteOption {
return []GameServerGroupDeleteOption{
"SAFE_DELETE",
"FORCE_DELETE",
"RETAIN",
}
}
type GameServerGroupInstanceType string
// Enum values for GameServerGroupInstanceType
const (
GameServerGroupInstanceTypeC4Large GameServerGroupInstanceType = "c4.large"
GameServerGroupInstanceTypeC4Xlarge GameServerGroupInstanceType = "c4.xlarge"
GameServerGroupInstanceTypeC42xlarge GameServerGroupInstanceType = "c4.2xlarge"
GameServerGroupInstanceTypeC44xlarge GameServerGroupInstanceType = "c4.4xlarge"
GameServerGroupInstanceTypeC48xlarge GameServerGroupInstanceType = "c4.8xlarge"
GameServerGroupInstanceTypeC5Large GameServerGroupInstanceType = "c5.large"
GameServerGroupInstanceTypeC5Xlarge GameServerGroupInstanceType = "c5.xlarge"
GameServerGroupInstanceTypeC52xlarge GameServerGroupInstanceType = "c5.2xlarge"
GameServerGroupInstanceTypeC54xlarge GameServerGroupInstanceType = "c5.4xlarge"
GameServerGroupInstanceTypeC59xlarge GameServerGroupInstanceType = "c5.9xlarge"
GameServerGroupInstanceTypeC512xlarge GameServerGroupInstanceType = "c5.12xlarge"
GameServerGroupInstanceTypeC518xlarge GameServerGroupInstanceType = "c5.18xlarge"
GameServerGroupInstanceTypeC524xlarge GameServerGroupInstanceType = "c5.24xlarge"
GameServerGroupInstanceTypeC5aLarge GameServerGroupInstanceType = "c5a.large"
GameServerGroupInstanceTypeC5aXlarge GameServerGroupInstanceType = "c5a.xlarge"
GameServerGroupInstanceTypeC5a2xlarge GameServerGroupInstanceType = "c5a.2xlarge"
GameServerGroupInstanceTypeC5a4xlarge GameServerGroupInstanceType = "c5a.4xlarge"
GameServerGroupInstanceTypeC5a8xlarge GameServerGroupInstanceType = "c5a.8xlarge"
GameServerGroupInstanceTypeC5a12xlarge GameServerGroupInstanceType = "c5a.12xlarge"
GameServerGroupInstanceTypeC5a16xlarge GameServerGroupInstanceType = "c5a.16xlarge"
GameServerGroupInstanceTypeC5a24xlarge GameServerGroupInstanceType = "c5a.24xlarge"
GameServerGroupInstanceTypeC6gMedium GameServerGroupInstanceType = "c6g.medium"
GameServerGroupInstanceTypeC6gLarge GameServerGroupInstanceType = "c6g.large"
GameServerGroupInstanceTypeC6gXlarge GameServerGroupInstanceType = "c6g.xlarge"
GameServerGroupInstanceTypeC6g2xlarge GameServerGroupInstanceType = "c6g.2xlarge"
GameServerGroupInstanceTypeC6g4xlarge GameServerGroupInstanceType = "c6g.4xlarge"
GameServerGroupInstanceTypeC6g8xlarge GameServerGroupInstanceType = "c6g.8xlarge"
GameServerGroupInstanceTypeC6g12xlarge GameServerGroupInstanceType = "c6g.12xlarge"
GameServerGroupInstanceTypeC6g16xlarge GameServerGroupInstanceType = "c6g.16xlarge"
GameServerGroupInstanceTypeR4Large GameServerGroupInstanceType = "r4.large"
GameServerGroupInstanceTypeR4Xlarge GameServerGroupInstanceType = "r4.xlarge"
GameServerGroupInstanceTypeR42xlarge GameServerGroupInstanceType = "r4.2xlarge"
GameServerGroupInstanceTypeR44xlarge GameServerGroupInstanceType = "r4.4xlarge"
GameServerGroupInstanceTypeR48xlarge GameServerGroupInstanceType = "r4.8xlarge"
GameServerGroupInstanceTypeR416xlarge GameServerGroupInstanceType = "r4.16xlarge"
GameServerGroupInstanceTypeR5Large GameServerGroupInstanceType = "r5.large"
GameServerGroupInstanceTypeR5Xlarge GameServerGroupInstanceType = "r5.xlarge"
GameServerGroupInstanceTypeR52xlarge GameServerGroupInstanceType = "r5.2xlarge"
GameServerGroupInstanceTypeR54xlarge GameServerGroupInstanceType = "r5.4xlarge"
GameServerGroupInstanceTypeR58xlarge GameServerGroupInstanceType = "r5.8xlarge"
GameServerGroupInstanceTypeR512xlarge GameServerGroupInstanceType = "r5.12xlarge"
GameServerGroupInstanceTypeR516xlarge GameServerGroupInstanceType = "r5.16xlarge"
GameServerGroupInstanceTypeR524xlarge GameServerGroupInstanceType = "r5.24xlarge"
GameServerGroupInstanceTypeR5aLarge GameServerGroupInstanceType = "r5a.large"
GameServerGroupInstanceTypeR5aXlarge GameServerGroupInstanceType = "r5a.xlarge"
GameServerGroupInstanceTypeR5a2xlarge GameServerGroupInstanceType = "r5a.2xlarge"
GameServerGroupInstanceTypeR5a4xlarge GameServerGroupInstanceType = "r5a.4xlarge"
GameServerGroupInstanceTypeR5a8xlarge GameServerGroupInstanceType = "r5a.8xlarge"
GameServerGroupInstanceTypeR5a12xlarge GameServerGroupInstanceType = "r5a.12xlarge"
GameServerGroupInstanceTypeR5a16xlarge GameServerGroupInstanceType = "r5a.16xlarge"
GameServerGroupInstanceTypeR5a24xlarge GameServerGroupInstanceType = "r5a.24xlarge"
GameServerGroupInstanceTypeR6gMedium GameServerGroupInstanceType = "r6g.medium"
GameServerGroupInstanceTypeR6gLarge GameServerGroupInstanceType = "r6g.large"
GameServerGroupInstanceTypeR6gXlarge GameServerGroupInstanceType = "r6g.xlarge"
GameServerGroupInstanceTypeR6g2xlarge GameServerGroupInstanceType = "r6g.2xlarge"
GameServerGroupInstanceTypeR6g4xlarge GameServerGroupInstanceType = "r6g.4xlarge"
GameServerGroupInstanceTypeR6g8xlarge GameServerGroupInstanceType = "r6g.8xlarge"
GameServerGroupInstanceTypeR6g12xlarge GameServerGroupInstanceType = "r6g.12xlarge"
GameServerGroupInstanceTypeR6g16xlarge GameServerGroupInstanceType = "r6g.16xlarge"
GameServerGroupInstanceTypeM4Large GameServerGroupInstanceType = "m4.large"
GameServerGroupInstanceTypeM4Xlarge GameServerGroupInstanceType = "m4.xlarge"
GameServerGroupInstanceTypeM42xlarge GameServerGroupInstanceType = "m4.2xlarge"
GameServerGroupInstanceTypeM44xlarge GameServerGroupInstanceType = "m4.4xlarge"
GameServerGroupInstanceTypeM410xlarge GameServerGroupInstanceType = "m4.10xlarge"
GameServerGroupInstanceTypeM5Large GameServerGroupInstanceType = "m5.large"
GameServerGroupInstanceTypeM5Xlarge GameServerGroupInstanceType = "m5.xlarge"
GameServerGroupInstanceTypeM52xlarge GameServerGroupInstanceType = "m5.2xlarge"
GameServerGroupInstanceTypeM54xlarge GameServerGroupInstanceType = "m5.4xlarge"
GameServerGroupInstanceTypeM58xlarge GameServerGroupInstanceType = "m5.8xlarge"
GameServerGroupInstanceTypeM512xlarge GameServerGroupInstanceType = "m5.12xlarge"
GameServerGroupInstanceTypeM516xlarge GameServerGroupInstanceType = "m5.16xlarge"
GameServerGroupInstanceTypeM524xlarge GameServerGroupInstanceType = "m5.24xlarge"
GameServerGroupInstanceTypeM5aLarge GameServerGroupInstanceType = "m5a.large"
GameServerGroupInstanceTypeM5aXlarge GameServerGroupInstanceType = "m5a.xlarge"
GameServerGroupInstanceTypeM5a2xlarge GameServerGroupInstanceType = "m5a.2xlarge"
GameServerGroupInstanceTypeM5a4xlarge GameServerGroupInstanceType = "m5a.4xlarge"
GameServerGroupInstanceTypeM5a8xlarge GameServerGroupInstanceType = "m5a.8xlarge"
GameServerGroupInstanceTypeM5a12xlarge GameServerGroupInstanceType = "m5a.12xlarge"
GameServerGroupInstanceTypeM5a16xlarge GameServerGroupInstanceType = "m5a.16xlarge"
GameServerGroupInstanceTypeM5a24xlarge GameServerGroupInstanceType = "m5a.24xlarge"
GameServerGroupInstanceTypeM6gMedium GameServerGroupInstanceType = "m6g.medium"
GameServerGroupInstanceTypeM6gLarge GameServerGroupInstanceType = "m6g.large"
GameServerGroupInstanceTypeM6gXlarge GameServerGroupInstanceType = "m6g.xlarge"
GameServerGroupInstanceTypeM6g2xlarge GameServerGroupInstanceType = "m6g.2xlarge"
GameServerGroupInstanceTypeM6g4xlarge GameServerGroupInstanceType = "m6g.4xlarge"
GameServerGroupInstanceTypeM6g8xlarge GameServerGroupInstanceType = "m6g.8xlarge"
GameServerGroupInstanceTypeM6g12xlarge GameServerGroupInstanceType = "m6g.12xlarge"
GameServerGroupInstanceTypeM6g16xlarge GameServerGroupInstanceType = "m6g.16xlarge"
)
// Values returns all known values for GameServerGroupInstanceType. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
// The ordering of this slice is not guaranteed to be stable across updates.
func (GameServerGroupInstanceType) Values() []GameServerGroupInstanceType {
return []GameServerGroupInstanceType{
"c4.large",
"c4.xlarge",
"c4.2xlarge",
"c4.4xlarge",
"c4.8xlarge",
"c5.large",
"c5.xlarge",
"c5.2xlarge",
"c5.4xlarge",
"c5.9xlarge",
"c5.12xlarge",
"c5.18xlarge",
"c5.24xlarge",
"c5a.large",
"c5a.xlarge",
"c5a.2xlarge",
"c5a.4xlarge",
"c5a.8xlarge",
"c5a.12xlarge",
"c5a.16xlarge",
"c5a.24xlarge",
"c6g.medium",
"c6g.large",
"c6g.xlarge",
"c6g.2xlarge",
"c6g.4xlarge",
"c6g.8xlarge",
"c6g.12xlarge",
"c6g.16xlarge",
"r4.large",
"r4.xlarge",
"r4.2xlarge",
"r4.4xlarge",
"r4.8xlarge",
"r4.16xlarge",
"r5.large",
"r5.xlarge",
"r5.2xlarge",
"r5.4xlarge",
"r5.8xlarge",
"r5.12xlarge",
"r5.16xlarge",
"r5.24xlarge",
"r5a.large",
"r5a.xlarge",
"r5a.2xlarge",
"r5a.4xlarge",
"r5a.8xlarge",
"r5a.12xlarge",
"r5a.16xlarge",
"r5a.24xlarge",
"r6g.medium",
"r6g.large",
"r6g.xlarge",
"r6g.2xlarge",
"r6g.4xlarge",
"r6g.8xlarge",
"r6g.12xlarge",
"r6g.16xlarge",
"m4.large",
"m4.xlarge",
"m4.2xlarge",
"m4.4xlarge",
"m4.10xlarge",
"m5.large",
"m5.xlarge",
"m5.2xlarge",
"m5.4xlarge",
"m5.8xlarge",
"m5.12xlarge",
"m5.16xlarge",
"m5.24xlarge",
"m5a.large",
"m5a.xlarge",
"m5a.2xlarge",
"m5a.4xlarge",
"m5a.8xlarge",
"m5a.12xlarge",
"m5a.16xlarge",
"m5a.24xlarge",
"m6g.medium",
"m6g.large",
"m6g.xlarge",
"m6g.2xlarge",
"m6g.4xlarge",
"m6g.8xlarge",
"m6g.12xlarge",
"m6g.16xlarge",
}
}
type GameServerGroupStatus string
// Enum values for GameServerGroupStatus
const (
GameServerGroupStatusNew GameServerGroupStatus = "NEW"
GameServerGroupStatusActivating GameServerGroupStatus = "ACTIVATING"
GameServerGroupStatusActive GameServerGroupStatus = "ACTIVE"
GameServerGroupStatusDeleteScheduled GameServerGroupStatus = "DELETE_SCHEDULED"
GameServerGroupStatusDeleting GameServerGroupStatus = "DELETING"
GameServerGroupStatusDeleted GameServerGroupStatus = "DELETED"
GameServerGroupStatusError GameServerGroupStatus = "ERROR"
)
// Values returns all known values for GameServerGroupStatus. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (GameServerGroupStatus) Values() []GameServerGroupStatus {
return []GameServerGroupStatus{
"NEW",
"ACTIVATING",
"ACTIVE",
"DELETE_SCHEDULED",
"DELETING",
"DELETED",
"ERROR",
}
}
type GameServerHealthCheck string
// Enum values for GameServerHealthCheck
const (
GameServerHealthCheckHealthy GameServerHealthCheck = "HEALTHY"
)
// Values returns all known values for GameServerHealthCheck. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (GameServerHealthCheck) Values() []GameServerHealthCheck {
return []GameServerHealthCheck{
"HEALTHY",
}
}
type GameServerInstanceStatus string
// Enum values for GameServerInstanceStatus
const (
GameServerInstanceStatusActive GameServerInstanceStatus = "ACTIVE"
GameServerInstanceStatusDraining GameServerInstanceStatus = "DRAINING"
GameServerInstanceStatusSpotTerminating GameServerInstanceStatus = "SPOT_TERMINATING"
)
// Values returns all known values for GameServerInstanceStatus. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
// The ordering of this slice is not guaranteed to be stable across updates.
func (GameServerInstanceStatus) Values() []GameServerInstanceStatus {
return []GameServerInstanceStatus{
"ACTIVE",
"DRAINING",
"SPOT_TERMINATING",
}
}
type GameServerProtectionPolicy string
// Enum values for GameServerProtectionPolicy
const (
GameServerProtectionPolicyNoProtection GameServerProtectionPolicy = "NO_PROTECTION"
GameServerProtectionPolicyFullProtection GameServerProtectionPolicy = "FULL_PROTECTION"
)
// Values returns all known values for GameServerProtectionPolicy. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
// The ordering of this slice is not guaranteed to be stable across updates.
func (GameServerProtectionPolicy) Values() []GameServerProtectionPolicy {
return []GameServerProtectionPolicy{
"NO_PROTECTION",
"FULL_PROTECTION",
}
}
type GameServerUtilizationStatus string
// Enum values for GameServerUtilizationStatus
const (
GameServerUtilizationStatusAvailable GameServerUtilizationStatus = "AVAILABLE"
GameServerUtilizationStatusUtilized GameServerUtilizationStatus = "UTILIZED"
)
// Values returns all known values for GameServerUtilizationStatus. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
// The ordering of this slice is not guaranteed to be stable across updates.
func (GameServerUtilizationStatus) Values() []GameServerUtilizationStatus {
return []GameServerUtilizationStatus{
"AVAILABLE",
"UTILIZED",
}
}
type GameSessionPlacementState string
// Enum values for GameSessionPlacementState
const (
GameSessionPlacementStatePending GameSessionPlacementState = "PENDING"
GameSessionPlacementStateFulfilled GameSessionPlacementState = "FULFILLED"
GameSessionPlacementStateCancelled GameSessionPlacementState = "CANCELLED"
GameSessionPlacementStateTimedOut GameSessionPlacementState = "TIMED_OUT"
GameSessionPlacementStateFailed GameSessionPlacementState = "FAILED"
)
// Values returns all known values for GameSessionPlacementState. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
// The ordering of this slice is not guaranteed to be stable across updates.
func (GameSessionPlacementState) Values() []GameSessionPlacementState {
return []GameSessionPlacementState{
"PENDING",
"FULFILLED",
"CANCELLED",
"TIMED_OUT",
"FAILED",
}
}
type GameSessionStatus string
// Enum values for GameSessionStatus
const (
GameSessionStatusActive GameSessionStatus = "ACTIVE"
GameSessionStatusActivating GameSessionStatus = "ACTIVATING"
GameSessionStatusTerminated GameSessionStatus = "TERMINATED"
GameSessionStatusTerminating GameSessionStatus = "TERMINATING"
GameSessionStatusError GameSessionStatus = "ERROR"
)
// Values returns all known values for GameSessionStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (GameSessionStatus) Values() []GameSessionStatus {
return []GameSessionStatus{
"ACTIVE",
"ACTIVATING",
"TERMINATED",
"TERMINATING",
"ERROR",
}
}
type GameSessionStatusReason string
// Enum values for GameSessionStatusReason
const (
GameSessionStatusReasonInterrupted GameSessionStatusReason = "INTERRUPTED"
)
// Values returns all known values for GameSessionStatusReason. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (GameSessionStatusReason) Values() []GameSessionStatusReason {
return []GameSessionStatusReason{
"INTERRUPTED",
}
}
type InstanceStatus string
// Enum values for InstanceStatus
const (
InstanceStatusPending InstanceStatus = "PENDING"
InstanceStatusActive InstanceStatus = "ACTIVE"
InstanceStatusTerminating InstanceStatus = "TERMINATING"
)
// Values returns all known values for InstanceStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (InstanceStatus) Values() []InstanceStatus {
return []InstanceStatus{
"PENDING",
"ACTIVE",
"TERMINATING",
}
}
type IpProtocol string
// Enum values for IpProtocol
const (
IpProtocolTcp IpProtocol = "TCP"
IpProtocolUdp IpProtocol = "UDP"
)
// Values returns all known values for IpProtocol. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (IpProtocol) Values() []IpProtocol {
return []IpProtocol{
"TCP",
"UDP",
}
}
type LocationFilter string
// Enum values for LocationFilter
const (
LocationFilterAws LocationFilter = "AWS"
LocationFilterCustom LocationFilter = "CUSTOM"
)
// Values returns all known values for LocationFilter. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (LocationFilter) Values() []LocationFilter {
return []LocationFilter{
"AWS",
"CUSTOM",
}
}
type LocationUpdateStatus string
// Enum values for LocationUpdateStatus
const (
LocationUpdateStatusPendingUpdate LocationUpdateStatus = "PENDING_UPDATE"
)
// Values returns all known values for LocationUpdateStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (LocationUpdateStatus) Values() []LocationUpdateStatus {
return []LocationUpdateStatus{
"PENDING_UPDATE",
}
}
type MatchmakingConfigurationStatus string
// Enum values for MatchmakingConfigurationStatus
const (
MatchmakingConfigurationStatusCancelled MatchmakingConfigurationStatus = "CANCELLED"
MatchmakingConfigurationStatusCompleted MatchmakingConfigurationStatus = "COMPLETED"
MatchmakingConfigurationStatusFailed MatchmakingConfigurationStatus = "FAILED"
MatchmakingConfigurationStatusPlacing MatchmakingConfigurationStatus = "PLACING"
MatchmakingConfigurationStatusQueued MatchmakingConfigurationStatus = "QUEUED"
MatchmakingConfigurationStatusRequiresAcceptance MatchmakingConfigurationStatus = "REQUIRES_ACCEPTANCE"
MatchmakingConfigurationStatusSearching MatchmakingConfigurationStatus = "SEARCHING"
MatchmakingConfigurationStatusTimedOut MatchmakingConfigurationStatus = "TIMED_OUT"
)
// Values returns all known values for MatchmakingConfigurationStatus. Note that
// this can be expanded in the future, and so it is only as up to date as the
// client. The ordering of this slice is not guaranteed to be stable across
// updates.
func (MatchmakingConfigurationStatus) Values() []MatchmakingConfigurationStatus {
return []MatchmakingConfigurationStatus{
"CANCELLED",
"COMPLETED",
"FAILED",
"PLACING",
"QUEUED",
"REQUIRES_ACCEPTANCE",
"SEARCHING",
"TIMED_OUT",
}
}
type MetricName string
// Enum values for MetricName
const (
MetricNameActivatingGameSessions MetricName = "ActivatingGameSessions"
MetricNameActiveGameSessions MetricName = "ActiveGameSessions"
MetricNameActiveInstances MetricName = "ActiveInstances"
MetricNameAvailableGameSessions MetricName = "AvailableGameSessions"
MetricNameAvailablePlayerSessions MetricName = "AvailablePlayerSessions"
MetricNameCurrentPlayerSessions MetricName = "CurrentPlayerSessions"
MetricNameIdleInstances MetricName = "IdleInstances"
MetricNamePercentAvailableGameSessions MetricName = "PercentAvailableGameSessions"
MetricNamePercentIdleInstances MetricName = "PercentIdleInstances"
MetricNameQueueDepth MetricName = "QueueDepth"
MetricNameWaitTime MetricName = "WaitTime"
MetricNameConcurrentActivatableGameSessions MetricName = "ConcurrentActivatableGameSessions"
)
// Values returns all known values for MetricName. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (MetricName) Values() []MetricName {
return []MetricName{
"ActivatingGameSessions",
"ActiveGameSessions",
"ActiveInstances",
"AvailableGameSessions",
"AvailablePlayerSessions",
"CurrentPlayerSessions",
"IdleInstances",
"PercentAvailableGameSessions",
"PercentIdleInstances",
"QueueDepth",
"WaitTime",
"ConcurrentActivatableGameSessions",
}
}
type OperatingSystem string
// Enum values for OperatingSystem
const (
OperatingSystemWindows2012 OperatingSystem = "WINDOWS_2012"
OperatingSystemAmazonLinux OperatingSystem = "AMAZON_LINUX"
OperatingSystemAmazonLinux2 OperatingSystem = "AMAZON_LINUX_2"
OperatingSystemWindows2016 OperatingSystem = "WINDOWS_2016"
OperatingSystemAmazonLinux2023 OperatingSystem = "AMAZON_LINUX_2023"
)
// Values returns all known values for OperatingSystem. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (OperatingSystem) Values() []OperatingSystem {
return []OperatingSystem{
"WINDOWS_2012",
"AMAZON_LINUX",
"AMAZON_LINUX_2",
"WINDOWS_2016",
"AMAZON_LINUX_2023",
}
}
type PlayerSessionCreationPolicy string
// Enum values for PlayerSessionCreationPolicy
const (
PlayerSessionCreationPolicyAcceptAll PlayerSessionCreationPolicy = "ACCEPT_ALL"
PlayerSessionCreationPolicyDenyAll PlayerSessionCreationPolicy = "DENY_ALL"
)
// Values returns all known values for PlayerSessionCreationPolicy. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
// The ordering of this slice is not guaranteed to be stable across updates.
func (PlayerSessionCreationPolicy) Values() []PlayerSessionCreationPolicy {
return []PlayerSessionCreationPolicy{
"ACCEPT_ALL",
"DENY_ALL",
}
}
type PlayerSessionStatus string
// Enum values for PlayerSessionStatus
const (
PlayerSessionStatusReserved PlayerSessionStatus = "RESERVED"
PlayerSessionStatusActive PlayerSessionStatus = "ACTIVE"
PlayerSessionStatusCompleted PlayerSessionStatus = "COMPLETED"
PlayerSessionStatusTimedout PlayerSessionStatus = "TIMEDOUT"
)
// Values returns all known values for PlayerSessionStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (PlayerSessionStatus) Values() []PlayerSessionStatus {
return []PlayerSessionStatus{
"RESERVED",
"ACTIVE",
"COMPLETED",
"TIMEDOUT",
}
}
type PolicyType string
// Enum values for PolicyType
const (
PolicyTypeRuleBased PolicyType = "RuleBased"
PolicyTypeTargetBased PolicyType = "TargetBased"
)
// Values returns all known values for PolicyType. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (PolicyType) Values() []PolicyType {
return []PolicyType{
"RuleBased",
"TargetBased",
}
}
type PriorityType string
// Enum values for PriorityType
const (
PriorityTypeLatency PriorityType = "LATENCY"
PriorityTypeCost PriorityType = "COST"
PriorityTypeDestination PriorityType = "DESTINATION"
PriorityTypeLocation PriorityType = "LOCATION"
)
// Values returns all known values for PriorityType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (PriorityType) Values() []PriorityType {
return []PriorityType{
"LATENCY",
"COST",
"DESTINATION",
"LOCATION",
}
}
type ProtectionPolicy string
// Enum values for ProtectionPolicy
const (
ProtectionPolicyNoProtection ProtectionPolicy = "NoProtection"
ProtectionPolicyFullProtection ProtectionPolicy = "FullProtection"
)
// Values returns all known values for ProtectionPolicy. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (ProtectionPolicy) Values() []ProtectionPolicy {
return []ProtectionPolicy{
"NoProtection",
"FullProtection",
}
}
type RoutingStrategyType string
// Enum values for RoutingStrategyType
const (
RoutingStrategyTypeSimple RoutingStrategyType = "SIMPLE"
RoutingStrategyTypeTerminal RoutingStrategyType = "TERMINAL"
)
// Values returns all known values for RoutingStrategyType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (RoutingStrategyType) Values() []RoutingStrategyType {
return []RoutingStrategyType{
"SIMPLE",
"TERMINAL",
}
}
type ScalingAdjustmentType string
// Enum values for ScalingAdjustmentType
const (
ScalingAdjustmentTypeChangeInCapacity ScalingAdjustmentType = "ChangeInCapacity"
ScalingAdjustmentTypeExactCapacity ScalingAdjustmentType = "ExactCapacity"
ScalingAdjustmentTypePercentChangeInCapacity ScalingAdjustmentType = "PercentChangeInCapacity"
)
// Values returns all known values for ScalingAdjustmentType. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (ScalingAdjustmentType) Values() []ScalingAdjustmentType {
return []ScalingAdjustmentType{
"ChangeInCapacity",
"ExactCapacity",
"PercentChangeInCapacity",
}
}
type ScalingStatusType string
// Enum values for ScalingStatusType
const (
ScalingStatusTypeActive ScalingStatusType = "ACTIVE"
ScalingStatusTypeUpdateRequested ScalingStatusType = "UPDATE_REQUESTED"
ScalingStatusTypeUpdating ScalingStatusType = "UPDATING"
ScalingStatusTypeDeleteRequested ScalingStatusType = "DELETE_REQUESTED"
ScalingStatusTypeDeleting ScalingStatusType = "DELETING"
ScalingStatusTypeDeleted ScalingStatusType = "DELETED"
ScalingStatusTypeError ScalingStatusType = "ERROR"
)
// Values returns all known values for ScalingStatusType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (ScalingStatusType) Values() []ScalingStatusType {
return []ScalingStatusType{
"ACTIVE",
"UPDATE_REQUESTED",
"UPDATING",
"DELETE_REQUESTED",
"DELETING",
"DELETED",
"ERROR",
}
}
type SortOrder string
// Enum values for SortOrder
const (
SortOrderAscending SortOrder = "ASCENDING"
SortOrderDescending SortOrder = "DESCENDING"
)
// Values returns all known values for SortOrder. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (SortOrder) Values() []SortOrder {
return []SortOrder{
"ASCENDING",
"DESCENDING",
}
}
| 1,339 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
"fmt"
smithy "github.com/aws/smithy-go"
)
// The requested operation would cause a conflict with the current state of a
// service resource associated with the request. Resolve the conflict before
// retrying this request.
type ConflictException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ConflictException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ConflictException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ConflictException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ConflictException"
}
return *e.ErrorCodeOverride
}
func (e *ConflictException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The specified fleet has no available instances to fulfill a CreateGameSession
// request. Clients can retry such requests immediately or after a waiting period.
type FleetCapacityExceededException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *FleetCapacityExceededException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *FleetCapacityExceededException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *FleetCapacityExceededException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "FleetCapacityExceededException"
}
return *e.ErrorCodeOverride
}
func (e *FleetCapacityExceededException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The game instance is currently full and cannot allow the requested player(s) to
// join. Clients can retry such requests immediately or after a waiting period.
type GameSessionFullException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *GameSessionFullException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *GameSessionFullException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *GameSessionFullException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "GameSessionFullException"
}
return *e.ErrorCodeOverride
}
func (e *GameSessionFullException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// A game session with this custom ID string already exists in this fleet. Resolve
// this conflict before retrying this request.
type IdempotentParameterMismatchException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *IdempotentParameterMismatchException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *IdempotentParameterMismatchException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *IdempotentParameterMismatchException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "IdempotentParameterMismatchException"
}
return *e.ErrorCodeOverride
}
func (e *IdempotentParameterMismatchException) ErrorFault() smithy.ErrorFault {
return smithy.FaultClient
}
// The service encountered an unrecoverable internal failure while processing the
// request. Clients can retry such requests immediately or after a waiting period.
type InternalServiceException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InternalServiceException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InternalServiceException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InternalServiceException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InternalServiceException"
}
return *e.ErrorCodeOverride
}
func (e *InternalServiceException) ErrorFault() smithy.ErrorFault { return smithy.FaultServer }
// The requested operation would cause a conflict with the current state of a
// resource associated with the request and/or the fleet. Resolve the conflict
// before retrying.
type InvalidFleetStatusException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidFleetStatusException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidFleetStatusException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidFleetStatusException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidFleetStatusException"
}
return *e.ErrorCodeOverride
}
func (e *InvalidFleetStatusException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The requested operation would cause a conflict with the current state of a
// resource associated with the request and/or the game instance. Resolve the
// conflict before retrying.
type InvalidGameSessionStatusException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidGameSessionStatusException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidGameSessionStatusException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidGameSessionStatusException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidGameSessionStatusException"
}
return *e.ErrorCodeOverride
}
func (e *InvalidGameSessionStatusException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// One or more parameter values in the request are invalid. Correct the invalid
// parameter values before retrying.
type InvalidRequestException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidRequestException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidRequestException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidRequestException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidRequestException"
}
return *e.ErrorCodeOverride
}
func (e *InvalidRequestException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The requested operation would cause the resource to exceed the allowed service
// limit. Resolve the issue before retrying.
type LimitExceededException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *LimitExceededException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *LimitExceededException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *LimitExceededException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "LimitExceededException"
}
return *e.ErrorCodeOverride
}
func (e *LimitExceededException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// THe requested resources was not found. The resource was either not created yet
// or deleted.
type NotFoundException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *NotFoundException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *NotFoundException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *NotFoundException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "NotFoundException"
}
return *e.ErrorCodeOverride
}
func (e *NotFoundException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The specified game server group has no available game servers to fulfill a
// ClaimGameServer request. Clients can retry such requests immediately or after a
// waiting period.
type OutOfCapacityException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *OutOfCapacityException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *OutOfCapacityException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *OutOfCapacityException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "OutOfCapacityException"
}
return *e.ErrorCodeOverride
}
func (e *OutOfCapacityException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The requested tagging operation did not succeed. This may be due to invalid tag
// format or the maximum tag limit may have been exceeded. Resolve the issue before
// retrying.
type TaggingFailedException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *TaggingFailedException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *TaggingFailedException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *TaggingFailedException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "TaggingFailedException"
}
return *e.ErrorCodeOverride
}
func (e *TaggingFailedException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The service is unable to resolve the routing for a particular alias because it
// has a terminal RoutingStrategy associated with it. The message returned in this
// exception is the message defined in the routing strategy itself. Such requests
// should only be retried if the routing strategy for the specified alias is
// modified.
type TerminalRoutingStrategyException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *TerminalRoutingStrategyException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *TerminalRoutingStrategyException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *TerminalRoutingStrategyException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "TerminalRoutingStrategyException"
}
return *e.ErrorCodeOverride
}
func (e *TerminalRoutingStrategyException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The client failed authentication. Clients should not retry such requests.
type UnauthorizedException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *UnauthorizedException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *UnauthorizedException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *UnauthorizedException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "UnauthorizedException"
}
return *e.ErrorCodeOverride
}
func (e *UnauthorizedException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The requested operation is not supported in the Region specified.
type UnsupportedRegionException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *UnsupportedRegionException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *UnsupportedRegionException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *UnsupportedRegionException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "UnsupportedRegionException"
}
return *e.ErrorCodeOverride
}
func (e *UnsupportedRegionException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
| 422 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
smithydocument "github.com/aws/smithy-go/document"
"time"
)
// Properties that describe an alias resource. Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
type Alias struct {
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift alias resource and uniquely identifies
// it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::alias/alias-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 . In a
// GameLift alias ARN, the resource ID matches the alias ID value.
AliasArn *string
// A unique identifier for the alias. Alias IDs are unique within a Region.
AliasId *string
// A time stamp indicating when this data object was created. Format is a number
// expressed in Unix time as milliseconds (for example "1469498468.057" ).
CreationTime *time.Time
// A human-readable description of an alias.
Description *string
// The time that this data object was last modified. Format is a number expressed
// in Unix time as milliseconds (for example "1469498468.057" ).
LastUpdatedTime *time.Time
// A descriptive label that is associated with an alias. Alias names do not need
// to be unique.
Name *string
// The routing configuration, including routing type and fleet target, for the
// alias.
RoutingStrategy *RoutingStrategy
noSmithyDocumentSerde
}
// Amazon GameLift Anywhere configuration options for your Anywhere fleets.
type AnywhereConfiguration struct {
// The cost to run your fleet per hour. Amazon GameLift uses the provided cost of
// your fleet to balance usage in queues. For more information about queues, see
// Setting up queues (https://docs.aws.amazon.com/gamelift/latest/developerguide/queues-intro.html)
// in the Amazon GameLift Developer Guide.
//
// This member is required.
Cost *string
noSmithyDocumentSerde
}
// Values for use in player attribute key-value pairs. This object lets you
// specify an attribute value using any of the valid data types: string, number,
// string array, or data map. Each AttributeValue object can use only one of the
// available properties.
type AttributeValue struct {
// For number values, expressed as double.
N *float64
// For single string values. Maximum string length is 100 characters.
S *string
// For a map of up to 10 data type:value pairs. Maximum length for each string
// value is 100 characters.
SDM map[string]float64
// For a list of up to 100 strings. Maximum length for each string is 100
// characters. Duplicate values are not recognized; all occurrences of the repeated
// value after the first of a repeated value are ignored.
SL []string
noSmithyDocumentSerde
}
// Temporary access credentials used for uploading game build files to Amazon
// GameLift. They are valid for a limited time. If they expire before you upload
// your game build, get a new set by calling RequestUploadCredentials (https://docs.aws.amazon.com/gamelift/latest/apireference/API_RequestUploadCredentials.html)
// .
type AwsCredentials struct {
// Temporary key allowing access to the Amazon GameLift S3 account.
AccessKeyId *string
// Temporary secret key allowing access to the Amazon GameLift S3 account.
SecretAccessKey *string
// Token used to associate a specific build ID with the files uploaded using these
// credentials.
SessionToken *string
noSmithyDocumentSerde
}
// Properties describing a custom game build. All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
type Build struct {
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) assigned to a Amazon GameLift build resource and uniquely identifies it. ARNs
// are unique across all Regions. Format is
// arn:aws:gamelift:::build/build-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 . In a
// GameLift build ARN, the resource ID matches the BuildId value.
BuildArn *string
// A unique identifier for the build.
BuildId *string
// A time stamp indicating when this data object was created. Format is a number
// expressed in Unix time as milliseconds (for example "1469498468.057" ).
CreationTime *time.Time
// A descriptive label associated with a build. Build names don't need to be
// unique. It can be set using CreateBuild (https://docs.aws.amazon.com/gamelift/latest/apireference/API_CreateBuild.html)
// or UpdateBuild (https://docs.aws.amazon.com/gamelift/latest/apireference/UpdateBuild)
// .
Name *string
// Operating system that the game server binaries are built to run on. This value
// determines the type of fleet resources that you can use for this build.
OperatingSystem OperatingSystem
// The Amazon GameLift Server SDK version used to develop your game server.
ServerSdkVersion *string
// File size of the uploaded game build, expressed in bytes. When the build status
// is INITIALIZED or when using a custom Amazon S3 storage location, this value is
// 0.
SizeOnDisk *int64
// Current status of the build. Possible build statuses include the following:
// - INITIALIZED -- A new build has been defined, but no files have been
// uploaded. You cannot create fleets for builds that are in this status. When a
// build is successfully created, the build status is set to this value.
// - READY -- The game build has been successfully uploaded. You can now create
// new fleets for this build.
// - FAILED -- The game build upload failed. You cannot create new fleets for
// this build.
Status BuildStatus
// Version information associated with a build or script. Version strings don't
// need to be unique.
Version *string
noSmithyDocumentSerde
}
// Determines whether a TLS/SSL certificate is generated for a fleet. This feature
// must be enabled when creating the fleet. All instances in a fleet share the same
// certificate. The certificate can be retrieved by calling the Amazon GameLift
// Server SDK (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-serversdk.html)
// operation GetInstanceCertificate .
type CertificateConfiguration struct {
// Indicates whether a TLS/SSL certificate is generated for a fleet. Valid values
// include:
// - GENERATED - Generate a TLS/SSL certificate for this fleet.
// - DISABLED - (default) Do not generate a TLS/SSL certificate for this fleet.
//
// This member is required.
CertificateType CertificateType
noSmithyDocumentSerde
}
// This data type is used with the Amazon GameLift FleetIQ and game server groups.
// Filters which game servers may be claimed when calling ClaimGameServer .
type ClaimFilterOption struct {
// List of instance statuses that game servers may be claimed on. If provided, the
// list must contain the ACTIVE status.
InstanceStatuses []FilterInstanceStatus
noSmithyDocumentSerde
}
// Resources used to host your game servers. A compute resource can be managed
// Amazon GameLift Amazon EC2 instances or your own resources.
type Compute struct {
// The ARN that is assigned to the compute resource and uniquely identifies it.
// ARNs are unique across locations.
ComputeArn *string
// A descriptive label that is associated with the compute resource registered to
// your fleet.
ComputeName *string
// Current status of the compute. A compute must have an ACTIVE status to host
// game sessions.
ComputeStatus ComputeStatus
// A time stamp indicating when this data object was created. Format is a number
// expressed in Unix time as milliseconds (for example "1469498468.057" ).
CreationTime *time.Time
// The DNS name of the compute resource. Amazon GameLift requires the DNS name or
// IP address to manage your compute resource.
DnsName *string
// The Amazon Resource Name (ARN) of the fleet that the compute is registered to.
FleetArn *string
// A unique identifier for the fleet that the compute is registered to.
FleetId *string
// The endpoint connection details of the Amazon GameLift SDK endpoint that your
// game server connects to.
GameLiftServiceSdkEndpoint *string
// The IP address of the compute resource. Amazon GameLift requires the DNS name
// or IP address to manage your compute resource.
IpAddress *string
// The name of the custom location you added to the fleet that this compute
// resource resides in.
Location *string
// The type of operating system on your compute resource.
OperatingSystem OperatingSystem
// The compute type that the fleet uses. A fleet can use Anywhere compute
// resources that you own, or use managed Amazon EC2 instances.
Type EC2InstanceType
noSmithyDocumentSerde
}
// Player information for use when creating player sessions using a game session
// placement request.
type DesiredPlayerSession struct {
// Developer-defined information related to a player. Amazon GameLift does not use
// this data, so it can be formatted as needed for use in the game.
PlayerData *string
// A unique identifier for a player to associate with the player session.
PlayerId *string
noSmithyDocumentSerde
}
// Resource capacity settings. Fleet capacity is measured in Amazon EC2 instances.
// Pending and terminating counts are non-zero when the fleet capacity is adjusting
// to a scaling event or if access to resources is temporarily affected.
type EC2InstanceCounts struct {
// Actual number of instances that are ready to host game sessions.
ACTIVE *int32
// Ideal number of active instances. GameLift will always try to maintain the
// desired number of instances. Capacity is scaled up or down by changing the
// desired instances.
DESIRED *int32
// Number of active instances that are not currently hosting a game session.
IDLE *int32
// The maximum instance count value allowed.
MAXIMUM *int32
// The minimum instance count value allowed.
MINIMUM *int32
// Number of instances that are starting but not yet active.
PENDING *int32
// Number of instances that are no longer active but haven't yet been terminated.
TERMINATING *int32
noSmithyDocumentSerde
}
// The Amazon GameLift service limits for an Amazon EC2 instance type and current
// utilization. Amazon GameLift allows Amazon Web Services accounts a maximum
// number of instances, per instance type, per Amazon Web Services Region or
// location, for use with Amazon GameLift. You can request an limit increase for
// your account by using the Service limits page in the Amazon GameLift console.
type EC2InstanceLimit struct {
// The number of instances for the specified type and location that are currently
// being used by the Amazon Web Services account.
CurrentInstances *int32
// The name of an Amazon EC2 instance type. See Amazon Elastic Compute Cloud
// Instance Types (http://aws.amazon.com/ec2/instance-types/) for detailed
// descriptions.
EC2InstanceType EC2InstanceType
// The number of instances that is allowed for the specified instance type and
// location.
InstanceLimit *int32
// An Amazon Web Services Region code, such as us-west-2 .
Location *string
noSmithyDocumentSerde
}
// Log entry describing an event that involves Amazon GameLift resources (such as
// a fleet). In addition to tracking activity, event codes and messages can provide
// additional information for troubleshooting and debugging problems.
type Event struct {
// The type of event being logged. Fleet state transition events:
// - FLEET_CREATED -- A fleet resource was successfully created with a status of
// NEW . Event messaging includes the fleet ID.
// - FLEET_STATE_DOWNLOADING -- Fleet status changed from NEW to DOWNLOADING .
// The compressed build has started downloading to a fleet instance for
// installation.
// - FLEET_STATE_VALIDATING -- Fleet status changed from DOWNLOADING to
// VALIDATING . Amazon GameLift has successfully downloaded the build and is now
// validating the build files.
// - FLEET_STATE_BUILDING -- Fleet status changed from VALIDATING to BUILDING .
// Amazon GameLift has successfully verified the build files and is now running the
// installation scripts.
// - FLEET_STATE_ACTIVATING -- Fleet status changed from BUILDING to ACTIVATING .
// Amazon GameLift is trying to launch an instance and test the connectivity
// between the build and the Amazon GameLift Service via the Server SDK.
// - FLEET_STATE_ACTIVE -- The fleet's status changed from ACTIVATING to ACTIVE .
// The fleet is now ready to host game sessions.
// - FLEET_STATE_ERROR -- The Fleet's status changed to ERROR . Describe the
// fleet event message for more details.
// Fleet creation events (ordered by fleet creation activity):
// - FLEET_BINARY_DOWNLOAD_FAILED -- The build failed to download to the fleet
// instance.
// - FLEET_CREATION_EXTRACTING_BUILD -- The game server build was successfully
// downloaded to an instance, and the build files are now being extracted from the
// uploaded build and saved to an instance. Failure at this stage prevents a fleet
// from moving to ACTIVE status. Logs for this stage display a list of the files
// that are extracted and saved on the instance. Access the logs by using the URL
// in PreSignedLogUrl.
// - FLEET_CREATION_RUNNING_INSTALLER -- The game server build files were
// successfully extracted, and the GameLift is now running the build's install
// script (if one is included). Failure in this stage prevents a fleet from moving
// to ACTIVE status. Logs for this stage list the installation steps and whether or
// not the install completed successfully. Access the logs by using the URL in
// PreSignedLogUrl.
// - FLEET_CREATION_VALIDATING_RUNTIME_CONFIG -- The build process was
// successful, and the GameLift is now verifying that the game server launch paths,
// which are specified in the fleet's runtime configuration, exist. If any listed
// launch path exists, Amazon GameLift tries to launch a game server process and
// waits for the process to report ready. Failures in this stage prevent a fleet
// from moving to ACTIVE status. Logs for this stage list the launch paths in the
// runtime configuration and indicate whether each is found. Access the logs by
// using the URL in PreSignedLogUrl.
// - FLEET_VALIDATION_LAUNCH_PATH_NOT_FOUND -- Validation of the runtime
// configuration failed because the executable specified in a launch path does not
// exist on the instance.
// - FLEET_VALIDATION_EXECUTABLE_RUNTIME_FAILURE -- Validation of the runtime
// configuration failed because the executable specified in a launch path failed to
// run on the fleet instance.
// - FLEET_VALIDATION_TIMED_OUT -- Validation of the fleet at the end of
// creation timed out. Try fleet creation again.
// - FLEET_ACTIVATION_FAILED -- The fleet failed to successfully complete one of
// the steps in the fleet activation process. This event code indicates that the
// game build was successfully downloaded to a fleet instance, built, and
// validated, but was not able to start a server process. For more information, see
// Debug Fleet Creation Issues (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-creating-debug.html#fleets-creating-debug-creation)
// .
// - FLEET_ACTIVATION_FAILED_NO_INSTANCES -- Fleet creation was not able to
// obtain any instances based on the input fleet attributes. Try again at a
// different time or choose a different combination of fleet attributes such as
// fleet type, instance type, etc.
// - FLEET_INITIALIZATION_FAILED -- A generic exception occurred during fleet
// creation. Describe the fleet event message for more details.
// VPC peering events:
// - FLEET_VPC_PEERING_SUCCEEDED -- A VPC peering connection has been
// established between the VPC for an Amazon GameLift fleet and a VPC in your
// Amazon Web Services account.
// - FLEET_VPC_PEERING_FAILED -- A requested VPC peering connection has failed.
// Event details and status information provide additional detail. A common reason
// for peering failure is that the two VPCs have overlapping CIDR blocks of IPv4
// addresses. To resolve this, change the CIDR block for the VPC in your Amazon Web
// Services account. For more information on VPC peering failures, see
// https://docs.aws.amazon.com/AmazonVPC/latest/PeeringGuide/invalid-peering-configurations.html (https://docs.aws.amazon.com/AmazonVPC/latest/PeeringGuide/invalid-peering-configurations.html)
// - FLEET_VPC_PEERING_DELETED -- A VPC peering connection has been successfully
// deleted.
// Spot instance events:
// - INSTANCE_INTERRUPTED -- A spot instance was interrupted by EC2 with a
// two-minute notification.
// Server process events:
// - SERVER_PROCESS_INVALID_PATH -- The game server executable or script could
// not be found based on the Fleet runtime configuration. Check that the launch
// path is correct based on the operating system of the Fleet.
// - SERVER_PROCESS_SDK_INITIALIZATION_TIMEOUT -- The server process did not
// call InitSDK() within the time expected. Check your game session log to see why
// InitSDK() was not called in time.
// - SERVER_PROCESS_PROCESS_READY_TIMEOUT -- The server process did not call
// ProcessReady() within the time expected after calling InitSDK(). Check your game
// session log to see why ProcessReady() was not called in time.
// - SERVER_PROCESS_CRASHED -- The server process exited without calling
// ProcessEnding(). Check your game session log to see why ProcessEnding() was not
// called.
// - SERVER_PROCESS_TERMINATED_UNHEALTHY -- The server process did not report a
// valid health check for too long and was therefore terminated by GameLift. Check
// your game session log to see if the thread became stuck processing a synchronous
// task for too long.
// - SERVER_PROCESS_FORCE_TERMINATED -- The server process did not exit cleanly
// after OnProcessTerminate() was sent within the time expected. Check your game
// session log to see why termination took longer than expected.
// - SERVER_PROCESS_PROCESS_EXIT_TIMEOUT -- The server process did not exit
// cleanly within the time expected after calling ProcessEnding(). Check your game
// session log to see why termination took longer than expected.
// Game session events:
// - GAME_SESSION_ACTIVATION_TIMEOUT -- GameSession failed to activate within
// the expected time. Check your game session log to see why ActivateGameSession()
// took longer to complete than expected.
// Other fleet events:
// - FLEET_SCALING_EVENT -- A change was made to the fleet's capacity settings
// (desired instances, minimum/maximum scaling limits). Event messaging includes
// the new capacity settings.
// - FLEET_NEW_GAME_SESSION_PROTECTION_POLICY_UPDATED -- A change was made to
// the fleet's game session protection policy setting. Event messaging includes
// both the old and new policy setting.
// - FLEET_DELETED -- A request to delete a fleet was initiated.
// - GENERIC_EVENT -- An unspecified event has occurred.
EventCode EventCode
// A unique identifier for a fleet event.
EventId *string
// Time stamp indicating when this event occurred. Format is a number expressed in
// Unix time as milliseconds (for example "1469498468.057" ).
EventTime *time.Time
// Additional information related to the event.
Message *string
// Location of stored logs with additional detail that is related to the event.
// This is useful for debugging issues. The URL is valid for 15 minutes. You can
// also access fleet creation logs through the Amazon GameLift console.
PreSignedLogUrl *string
// A unique identifier for an event resource, such as a fleet ID.
ResourceId *string
noSmithyDocumentSerde
}
// A list of fleet locations where a game session queue can place new game
// sessions. You can use a filter to temporarily turn off placements for specific
// locations. For queues that have multi-location fleets, you can use a filter
// configuration allow placement with some, but not all of these locations.
type FilterConfiguration struct {
// A list of locations to allow game session placement in, in the form of Amazon
// Web Services Region codes such as us-west-2 .
AllowedLocations []string
noSmithyDocumentSerde
}
// Describes a Amazon GameLift fleet of game hosting resources. Related actions
type FleetAttributes struct {
// Amazon GameLift Anywhere configuration options for your Anywhere fleets.
AnywhereConfiguration *AnywhereConfiguration
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) associated with the Amazon GameLift build resource that is deployed on
// instances in this fleet. In a GameLift build ARN, the resource ID matches the
// BuildId value.
BuildArn *string
// A unique identifier for the build resource that is deployed on instances in
// this fleet.
BuildId *string
// Determines whether a TLS/SSL certificate is generated for a fleet. This feature
// must be enabled when creating the fleet. All instances in a fleet share the same
// certificate. The certificate can be retrieved by calling the Amazon GameLift
// Server SDK (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-serversdk.html)
// operation GetInstanceCertificate .
CertificateConfiguration *CertificateConfiguration
// The type of compute resource used to host your game servers. You can use your
// own compute resources with Amazon GameLift Anywhere or use Amazon EC2 instances
// with managed Amazon GameLift.
ComputeType ComputeType
// A time stamp indicating when this data object was created. Format is a number
// expressed in Unix time as milliseconds (for example "1469498468.057" ).
CreationTime *time.Time
// A human-readable description of the fleet.
Description *string
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift fleet resource and uniquely identifies
// it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 . In a
// GameLift fleet ARN, the resource ID matches the FleetId value.
FleetArn *string
// A unique identifier for the fleet.
FleetId *string
// Indicates whether to use On-Demand or Spot instances for this fleet. By
// default, this property is set to ON_DEMAND . Learn more about when to use
// On-Demand versus Spot Instances (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-ec2-instances.html#gamelift-ec2-instances-spot)
// . This property cannot be changed after the fleet is created.
FleetType FleetType
// A unique identifier for an IAM role that manages access to your Amazon Web
// Services services. With an instance role ARN set, any application that runs on
// an instance in this fleet can assume the role, including install scripts, server
// processes, and daemons (background processes). Create a role or look up a role's
// ARN by using the IAM dashboard (https://console.aws.amazon.com/iam/) in the
// Amazon Web Services Management Console. Learn more about using on-box
// credentials for your game servers at Access external resources from a game
// server (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-resources.html)
// .
InstanceRoleArn *string
// The Amazon EC2 instance type that determines the computing resources of each
// instance in the fleet. Instance type defines the CPU, memory, storage, and
// networking capacity. See Amazon Elastic Compute Cloud Instance Types (http://aws.amazon.com/ec2/instance-types/)
// for detailed descriptions.
InstanceType EC2InstanceType
// This parameter is no longer used. Game session log paths are now defined using
// the Amazon GameLift server API ProcessReady() logParameters . See more
// information in the Server API Reference (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api-ref.html#gamelift-sdk-server-api-ref-dataypes-process)
// .
LogPaths []string
// Name of a metric group that metrics for this fleet are added to. In Amazon
// CloudWatch, you can view aggregated metrics for fleets that are in a metric
// group. A fleet can be included in only one metric group at a time.
MetricGroups []string
// A descriptive label that is associated with a fleet. Fleet names do not need to
// be unique.
Name *string
// The type of game session protection to set on all new instances that are
// started in the fleet.
// - NoProtection -- The game session can be terminated during a scale-down
// event.
// - FullProtection -- If the game session is in an ACTIVE status, it cannot be
// terminated during a scale-down event.
NewGameSessionProtectionPolicy ProtectionPolicy
// The operating system of the fleet's computing resources. A fleet's operating
// system is determined by the OS of the build or script that is deployed on this
// fleet.
OperatingSystem OperatingSystem
// A policy that puts limits on the number of game sessions that a player can
// create within a specified span of time. With this policy, you can control
// players' ability to consume available resources. The policy is evaluated when a
// player tries to create a new game session. On receiving a CreateGameSession
// request, Amazon GameLift checks that the player (identified by CreatorId ) has
// created fewer than game session limit in the specified time period.
ResourceCreationLimitPolicy *ResourceCreationLimitPolicy
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) associated with the GameLift script resource that is deployed on instances in
// this fleet. In a GameLift script ARN, the resource ID matches the ScriptId
// value.
ScriptArn *string
// A unique identifier for the Realtime script resource that is deployed on
// instances in this fleet.
ScriptId *string
// This parameter is no longer used. Server launch parameters are now defined
// using the fleet's runtime configuration . Requests that use this parameter
// instead continue to be valid.
ServerLaunchParameters *string
// This parameter is no longer used. Server launch paths are now defined using the
// fleet's RuntimeConfiguration (https://docs.aws.amazon.com/gamelift/latest/apireference/RuntimeConfiguration.html)
// . Requests that use this parameter instead continue to be valid.
ServerLaunchPath *string
// Current status of the fleet. Possible fleet statuses include the following:
// - NEW -- A new fleet has been defined and desired instances is set to 1.
// - DOWNLOADING/VALIDATING/BUILDING/ACTIVATING -- Amazon GameLift is setting up
// the new fleet, creating new instances with the game build or Realtime script and
// starting server processes.
// - ACTIVE -- Hosts can now accept game sessions.
// - ERROR -- An error occurred when downloading, validating, building, or
// activating the fleet.
// - DELETING -- Hosts are responding to a delete fleet request.
// - TERMINATED -- The fleet no longer exists.
Status FleetStatus
// A list of fleet activity that has been suspended using StopFleetActions (https://docs.aws.amazon.com/gamelift/latest/apireference/API_StopFleetActions.html)
// . This includes fleet auto-scaling.
StoppedActions []FleetAction
// A time stamp indicating when this data object was terminated. Format is a
// number expressed in Unix time as milliseconds (for example "1469498468.057" ).
TerminationTime *time.Time
noSmithyDocumentSerde
}
// Current resource capacity settings in a specified fleet or location. The
// location value might refer to a fleet's remote location or its home Region.
// Related actions DescribeFleetCapacity (https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeFleetCapacity.html)
// | DescribeFleetLocationCapacity (https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeFleetLocationCapacity.html)
// | UpdateFleetCapacity (https://docs.aws.amazon.com/gamelift/latest/apireference/API_UpdateFleetCapacity.html)
type FleetCapacity struct {
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift fleet resource and uniquely identifies
// it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 .
FleetArn *string
// A unique identifier for the fleet associated with the location.
FleetId *string
// Resource capacity settings. Fleet capacity is measured in Amazon EC2 instances.
// Pending and terminating counts are non-zero when the fleet capacity is adjusting
// to a scaling event or if access to resources is temporarily affected.
InstanceCounts *EC2InstanceCounts
// The Amazon EC2 instance type that is used for all instances in a fleet. The
// instance type determines the computing resources in use, including CPU, memory,
// storage, and networking capacity. See Amazon Elastic Compute Cloud Instance
// Types (http://aws.amazon.com/ec2/instance-types/) for detailed descriptions.
InstanceType EC2InstanceType
// The fleet location for the instance count information, expressed as an Amazon
// Web Services Region code, such as us-west-2 .
Location *string
noSmithyDocumentSerde
}
// Current resource utilization statistics in a specified fleet or location. The
// location value might refer to a fleet's remote location or its home Region.
// Related actions
type FleetUtilization struct {
// The number of active game sessions that are currently being hosted across all
// instances in the fleet location.
ActiveGameSessionCount *int32
// The number of server processes in ACTIVE status that are currently running
// across all instances in the fleet location.
ActiveServerProcessCount *int32
// The number of active player sessions that are currently being hosted across all
// instances in the fleet location.
CurrentPlayerSessionCount *int32
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift fleet resource and uniquely identifies
// it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 .
FleetArn *string
// A unique identifier for the fleet associated with the location.
FleetId *string
// The fleet location for the fleet utilization information, expressed as an
// Amazon Web Services Region code, such as us-west-2 .
Location *string
// The maximum number of players allowed across all game sessions that are
// currently being hosted across all instances in the fleet location.
MaximumPlayerSessionCount *int32
noSmithyDocumentSerde
}
// Set of key-value pairs that contain information about a game session. When
// included in a game session request, these properties communicate details to be
// used when setting up the new game session. For example, a game property might
// specify a game mode, level, or map. Game properties are passed to the game
// server process when initiating a new game session. For more information, see the
// Amazon GameLift Developer Guide (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-client-api.html#gamelift-sdk-client-api-create)
// .
type GameProperty struct {
// The game property identifier.
//
// This member is required.
Key *string
// The game property value.
//
// This member is required.
Value *string
noSmithyDocumentSerde
}
// This data type is used with the Amazon GameLift FleetIQ and game server groups.
// Properties describing a game server that is running on an instance in a game
// server group. A game server is created by a successful call to
// RegisterGameServer and deleted by calling DeregisterGameServer . A game server
// is claimed to host a game session by calling ClaimGameServer .
type GameServer struct {
// Indicates when an available game server has been reserved for gameplay but has
// not yet started hosting a game. Once it is claimed, the game server remains in
// CLAIMED status for a maximum of one minute. During this time, game clients
// connect to the game server to start the game and trigger the game server to
// update its utilization status. After one minute, the game server claim status
// reverts to null.
ClaimStatus GameServerClaimStatus
// The port and IP address that must be used to establish a client connection to
// the game server.
ConnectionInfo *string
// A set of custom game server properties, formatted as a single string value.
// This data is passed to a game client or service when it requests information on
// game servers.
GameServerData *string
// The ARN identifier for the game server group where the game server is located.
GameServerGroupArn *string
// A unique identifier for the game server group where the game server is running.
GameServerGroupName *string
// A custom string that uniquely identifies the game server. Game server IDs are
// developer-defined and are unique across all game server groups in an Amazon Web
// Services account.
GameServerId *string
// The unique identifier for the instance where the game server is running. This
// ID is available in the instance metadata. EC2 instance IDs use a 17-character
// format, for example: i-1234567890abcdef0 .
InstanceId *string
// Timestamp that indicates the last time the game server was claimed. The format
// is a number expressed in Unix time as milliseconds (for example "1469498468.057"
// ). This value is used to calculate when a claimed game server's status should
// revert to null.
LastClaimTime *time.Time
// Timestamp that indicates the last time the game server was updated with health
// status. The format is a number expressed in Unix time as milliseconds (for
// example "1469498468.057" ). After game server registration, this property is
// only changed when a game server update specifies a health check value.
LastHealthCheckTime *time.Time
// Timestamp that indicates when the game server registered. The format is a
// number expressed in Unix time as milliseconds (for example "1469498468.057" ).
RegistrationTime *time.Time
// Indicates whether the game server is currently available for new games or is
// busy. Possible statuses include:
// - AVAILABLE - The game server is available to be claimed. A game server that
// has been claimed remains in this status until it reports game hosting activity.
// - UTILIZED - The game server is currently hosting a game session with players.
UtilizationStatus GameServerUtilizationStatus
noSmithyDocumentSerde
}
// This data type is used with the Amazon GameLift FleetIQ and game server groups.
// Properties that describe a game server group resource. A game server group
// manages certain properties related to a corresponding Amazon EC2 Auto Scaling
// group. A game server group is created by a successful call to
// CreateGameServerGroup and deleted by calling DeleteGameServerGroup . Game server
// group activity can be temporarily suspended and resumed by calling
// SuspendGameServerGroup and ResumeGameServerGroup , respectively.
type GameServerGroup struct {
// A generated unique ID for the Amazon EC2 Auto Scaling group that is associated
// with this game server group.
AutoScalingGroupArn *string
// Indicates how Amazon GameLift FleetIQ balances the use of Spot Instances and
// On-Demand Instances in the game server group. Method options include the
// following:
// - SPOT_ONLY - Only Spot Instances are used in the game server group. If Spot
// Instances are unavailable or not viable for game hosting, the game server group
// provides no hosting capacity until Spot Instances can again be used. Until then,
// no new instances are started, and the existing nonviable Spot Instances are
// terminated (after current gameplay ends) and are not replaced.
// - SPOT_PREFERRED - (default value) Spot Instances are used whenever available
// in the game server group. If Spot Instances are unavailable, the game server
// group continues to provide hosting capacity by falling back to On-Demand
// Instances. Existing nonviable Spot Instances are terminated (after current
// gameplay ends) and are replaced with new On-Demand Instances.
// - ON_DEMAND_ONLY - Only On-Demand Instances are used in the game server group.
// No Spot Instances are used, even when available, while this balancing strategy
// is in force.
BalancingStrategy BalancingStrategy
// A time stamp indicating when this data object was created. Format is a number
// expressed in Unix time as milliseconds (for example "1469498468.057" ).
CreationTime *time.Time
// A generated unique ID for the game server group.
GameServerGroupArn *string
// A developer-defined identifier for the game server group. The name is unique
// for each Region in each Amazon Web Services account.
GameServerGroupName *string
// A flag that indicates whether instances in the game server group are protected
// from early termination. Unprotected instances that have active game servers
// running might be terminated during a scale-down event, causing players to be
// dropped from the game. Protected instances cannot be terminated while there are
// active game servers running except in the event of a forced game server group
// deletion (see ). An exception to this is with Spot Instances, which can be
// terminated by Amazon Web Services regardless of protection status.
GameServerProtectionPolicy GameServerProtectionPolicy
// The set of Amazon EC2 instance types that Amazon GameLift FleetIQ can use when
// balancing and automatically scaling instances in the corresponding Auto Scaling
// group.
InstanceDefinitions []InstanceDefinition
// A timestamp that indicates when this game server group was last updated.
LastUpdatedTime *time.Time
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) for an IAM role that allows Amazon GameLift to access your Amazon EC2 Auto
// Scaling groups.
RoleArn *string
// The current status of the game server group. Possible statuses include:
// - NEW - Amazon GameLift FleetIQ has validated the CreateGameServerGroup()
// request.
// - ACTIVATING - Amazon GameLift FleetIQ is setting up a game server group,
// which includes creating an Auto Scaling group in your Amazon Web Services
// account.
// - ACTIVE - The game server group has been successfully created.
// - DELETE_SCHEDULED - A request to delete the game server group has been
// received.
// - DELETING - Amazon GameLift FleetIQ has received a valid
// DeleteGameServerGroup() request and is processing it. Amazon GameLift FleetIQ
// must first complete and release hosts before it deletes the Auto Scaling group
// and the game server group.
// - DELETED - The game server group has been successfully deleted.
// - ERROR - The asynchronous processes of activating or deleting a game server
// group has failed, resulting in an error state.
Status GameServerGroupStatus
// Additional information about the current game server group status. This
// information might provide additional insight on groups that are in ERROR status.
StatusReason *string
// A list of activities that are currently suspended for this game server group.
// If this property is empty, all activities are occurring.
SuspendedActions []GameServerGroupAction
noSmithyDocumentSerde
}
// This data type is used with the Amazon GameLift FleetIQ and game server groups.
// Configuration settings for intelligent automatic scaling that uses target
// tracking. These settings are used to add an Auto Scaling policy when creating
// the corresponding Auto Scaling group. After the Auto Scaling group is created,
// all updates to Auto Scaling policies, including changing this policy and adding
// or removing other policies, is done directly on the Auto Scaling group.
type GameServerGroupAutoScalingPolicy struct {
// Settings for a target-based scaling policy applied to Auto Scaling group. These
// settings are used to create a target-based policy that tracks the Amazon
// GameLift FleetIQ metric "PercentUtilizedGameServers" and specifies a target
// value for the metric. As player usage changes, the policy triggers to adjust the
// game server group capacity so that the metric returns to the target value.
//
// This member is required.
TargetTrackingConfiguration *TargetTrackingConfiguration
// Length of time, in seconds, it takes for a new instance to start new game
// server processes and register with Amazon GameLift FleetIQ. Specifying a warm-up
// time can be useful, particularly with game servers that take a long time to
// start up, because it avoids prematurely starting new instances.
EstimatedInstanceWarmup *int32
noSmithyDocumentSerde
}
// This data type is used with the Amazon GameLift FleetIQ and game server groups.
// Additional properties, including status, that describe an EC2 instance in a game
// server group. Instance configurations are set with game server group properties
// (see DescribeGameServerGroup and with the EC2 launch template that was used
// when creating the game server group. Retrieve game server instances for a game
// server group by calling DescribeGameServerInstances .
type GameServerInstance struct {
// A generated unique identifier for the game server group that includes the game
// server instance.
GameServerGroupArn *string
// A developer-defined identifier for the game server group that includes the game
// server instance. The name is unique for each Region in each Amazon Web Services
// account.
GameServerGroupName *string
// The unique identifier for the instance where the game server is running. This
// ID is available in the instance metadata. EC2 instance IDs use a 17-character
// format, for example: i-1234567890abcdef0 .
InstanceId *string
// Current status of the game server instance
InstanceStatus GameServerInstanceStatus
noSmithyDocumentSerde
}
// Properties describing a game session. A game session in ACTIVE status can host
// players. When a game session ends, its status is set to TERMINATED . Once the
// session ends, the game session object is retained for 30 days. This means you
// can reuse idempotency token values after this time. Game session logs are
// retained for 14 days. All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
type GameSession struct {
// A time stamp indicating when this data object was created. Format is a number
// expressed in Unix time as milliseconds (for example "1469498468.057" ).
CreationTime *time.Time
// A unique identifier for a player. This ID is used to enforce a resource
// protection policy (if one exists), that limits the number of game sessions a
// player can create.
CreatorId *string
// Number of players currently in the game session.
CurrentPlayerSessionCount *int32
// The DNS identifier assigned to the instance that is running the game session.
// Values have the following format:
// - TLS-enabled fleets: ..amazongamelift.com .
// - Non-TLS-enabled fleets: ec2-.compute.amazonaws.com . (See Amazon EC2
// Instance IP Addressing (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-instance-addressing.html#concepts-public-addresses)
// .)
// When connecting to a game session that is running on a TLS-enabled fleet, you
// must use the DNS name, not the IP address.
DnsName *string
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) associated with the GameLift fleet that this game session is running on.
FleetArn *string
// A unique identifier for the fleet that the game session is running on.
FleetId *string
// A set of custom properties for a game session, formatted as key:value pairs.
// These properties are passed to a game server process with a request to start a
// new game session (see Start a Game Session (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession)
// ).
GameProperties []GameProperty
// A set of custom game session properties, formatted as a single string value.
// This data is passed to a game server process with a request to start a new game
// session (see Start a Game Session (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession)
// ).
GameSessionData *string
// A unique identifier for the game session. A game session ARN has the following
// format: arn:aws:gamelift:::gamesession// .
GameSessionId *string
// The IP address of the game session. To connect to a Amazon GameLift game
// server, an app needs both the IP address and port number.
IpAddress *string
// The fleet location where the game session is running. This value might specify
// the fleet's home Region or a remote location. Location is expressed as an Amazon
// Web Services Region code such as us-west-2 .
Location *string
// Information about the matchmaking process that was used to create the game
// session. It is in JSON syntax, formatted as a string. In addition the
// matchmaking configuration used, it contains data on all players assigned to the
// match, including player attributes and team assignments. For more details on
// matchmaker data, see Match Data (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-server.html#match-server-data)
// . Matchmaker data is useful when requesting match backfills, and is updated
// whenever new players are added during a successful backfill (see
// StartMatchBackfill (https://docs.aws.amazon.com/gamelift/latest/apireference/API_StartMatchBackfill.html)
// ).
MatchmakerData *string
// The maximum number of players that can be connected simultaneously to the game
// session.
MaximumPlayerSessionCount *int32
// A descriptive label that is associated with a game session. Session names do
// not need to be unique.
Name *string
// Indicates whether or not the game session is accepting new players.
PlayerSessionCreationPolicy PlayerSessionCreationPolicy
// The port number for the game session. To connect to a Amazon GameLift game
// server, an app needs both the IP address and port number.
Port *int32
// Current status of the game session. A game session must have an ACTIVE status
// to have player sessions.
Status GameSessionStatus
// Provides additional information about game session status. INTERRUPTED
// indicates that the game session was hosted on a spot instance that was
// reclaimed, causing the active game session to be terminated.
StatusReason GameSessionStatusReason
// A time stamp indicating when this data object was terminated. Format is a
// number expressed in Unix time as milliseconds (for example "1469498468.057" ).
TerminationTime *time.Time
noSmithyDocumentSerde
}
// Connection information for a new game session that is created in response to a
// start matchmaking request. Once a match is made, the FlexMatch engine creates a
// new game session for it. This information, including the game session endpoint
// and player sessions for each player in the original matchmaking request, is
// added to the matchmaking ticket.
type GameSessionConnectionInfo struct {
// The DNS identifier assigned to the instance that is running the game session.
// Values have the following format:
// - TLS-enabled fleets: ..amazongamelift.com .
// - Non-TLS-enabled fleets: ec2-.compute.amazonaws.com . (See Amazon EC2
// Instance IP Addressing (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-instance-addressing.html#concepts-public-addresses)
// .)
// When connecting to a game session that is running on a TLS-enabled fleet, you
// must use the DNS name, not the IP address.
DnsName *string
// A unique identifier for the game session. Use the game session ID.
GameSessionArn *string
// The IP address of the game session. To connect to a Amazon GameLift game
// server, an app needs both the IP address and port number.
IpAddress *string
// A collection of player session IDs, one for each player ID that was included in
// the original matchmaking request.
MatchedPlayerSessions []MatchedPlayerSession
// The port number for the game session. To connect to a Amazon GameLift game
// server, an app needs both the IP address and port number.
Port *int32
noSmithyDocumentSerde
}
// A game session's properties plus the protection policy currently in force.
type GameSessionDetail struct {
// Object that describes a game session.
GameSession *GameSession
// Current status of protection for the game session.
// - NoProtection -- The game session can be terminated during a scale-down
// event.
// - FullProtection -- If the game session is in an ACTIVE status, it cannot be
// terminated during a scale-down event.
ProtectionPolicy ProtectionPolicy
noSmithyDocumentSerde
}
// This object includes the full details of the original request plus the current
// status and start/end time stamps.
type GameSessionPlacement struct {
// The DNS identifier assigned to the instance that is running the game session.
// Values have the following format:
// - TLS-enabled fleets: ..amazongamelift.com .
// - Non-TLS-enabled fleets: ec2-.compute.amazonaws.com . (See Amazon EC2
// Instance IP Addressing (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-instance-addressing.html#concepts-public-addresses)
// .)
// When connecting to a game session that is running on a TLS-enabled fleet, you
// must use the DNS name, not the IP address.
DnsName *string
// Time stamp indicating when this request was completed, canceled, or timed out.
EndTime *time.Time
// A set of custom properties for a game session, formatted as key:value pairs.
// These properties are passed to a game server process with a request to start a
// new game session (see Start a Game Session (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession)
// ).
GameProperties []GameProperty
// Identifier for the game session created by this placement request. This value
// is set once the new game session is placed (placement status is FULFILLED ).
// This identifier is unique across all Regions. You can use this value as a
// GameSessionId value as needed.
GameSessionArn *string
// A set of custom game session properties, formatted as a single string value.
// This data is passed to a game server process in the GameSession object with a
// request to start a new game session (see Start a Game Session (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession)
// ).
GameSessionData *string
// A unique identifier for the game session. This value is set once the new game
// session is placed (placement status is FULFILLED ).
GameSessionId *string
// A descriptive label that is associated with a game session. Session names do
// not need to be unique.
GameSessionName *string
// A descriptive label that is associated with game session queue. Queue names
// must be unique within each Region.
GameSessionQueueName *string
// Name of the Region where the game session created by this placement request is
// running. This value is set once the new game session is placed (placement status
// is FULFILLED ).
GameSessionRegion *string
// The IP address of the game session. To connect to a Amazon GameLift game
// server, an app needs both the IP address and port number. This value is set once
// the new game session is placed (placement status is FULFILLED ).
IpAddress *string
// Information on the matchmaking process for this game. Data is in JSON syntax,
// formatted as a string. It identifies the matchmaking configuration used to
// create the match, and contains data on all players assigned to the match,
// including player attributes and team assignments. For more details on matchmaker
// data, see Match Data (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-server.html#match-server-data)
// .
MatchmakerData *string
// The maximum number of players that can be connected simultaneously to the game
// session.
MaximumPlayerSessionCount *int32
// A collection of information on player sessions created in response to the game
// session placement request. These player sessions are created only once a new
// game session is successfully placed (placement status is FULFILLED ). This
// information includes the player ID (as provided in the placement request) and
// the corresponding player session ID.
PlacedPlayerSessions []PlacedPlayerSession
// A unique identifier for a game session placement.
PlacementId *string
// A set of values, expressed in milliseconds, that indicates the amount of
// latency that a player experiences when connected to Amazon Web Services Regions.
PlayerLatencies []PlayerLatency
// The port number for the game session. To connect to a Amazon GameLift game
// server, an app needs both the IP address and port number. This value is set once
// the new game session is placed (placement status is FULFILLED ).
Port *int32
// Time stamp indicating when this request was placed in the queue. Format is a
// number expressed in Unix time as milliseconds (for example "1469498468.057" ).
StartTime *time.Time
// Current status of the game session placement request.
// - PENDING -- The placement request is currently in the queue waiting to be
// processed.
// - FULFILLED -- A new game session and player sessions (if requested) have
// been successfully created. Values for GameSessionArn and GameSessionRegion are
// available.
// - CANCELLED -- The placement request was canceled.
// - TIMED_OUT -- A new game session was not successfully created before the
// time limit expired. You can resubmit the placement request as needed.
// - FAILED -- Amazon GameLift is not able to complete the process of placing
// the game session. Common reasons are the game session terminated before the
// placement process was completed, or an unexpected internal error.
Status GameSessionPlacementState
noSmithyDocumentSerde
}
// Configuration for a game session placement mechanism that processes requests
// for new game sessions. A queue can be used on its own or as part of a
// matchmaking solution.
type GameSessionQueue struct {
// Information that is added to all events that are related to this game session
// queue.
CustomEventData *string
// A list of fleets and/or fleet aliases that can be used to fulfill game session
// placement requests in the queue. Destinations are identified by either a fleet
// ARN or a fleet alias ARN, and are listed in order of placement preference.
Destinations []GameSessionQueueDestination
// A list of locations where a queue is allowed to place new game sessions.
// Locations are specified in the form of Amazon Web Services Region codes, such as
// us-west-2 . If this parameter is not set, game sessions can be placed in any
// queue location.
FilterConfiguration *FilterConfiguration
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift game session queue resource and uniquely
// identifies it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::gamesessionqueue/ . In a Amazon GameLift game session queue
// ARN, the resource ID matches the Name value.
GameSessionQueueArn *string
// A descriptive label that is associated with game session queue. Queue names
// must be unique within each Region.
Name *string
// An SNS topic ARN that is set up to receive game session placement
// notifications. See Setting up notifications for game session placement (https://docs.aws.amazon.com/gamelift/latest/developerguide/queue-notification.html)
// .
NotificationTarget *string
// A set of policies that act as a sliding cap on player latency. FleetIQ works to
// deliver low latency for most players in a game session. These policies ensure
// that no individual player can be placed into a game with unreasonably high
// latency. Use multiple policies to gradually relax latency requirements a step at
// a time. Multiple policies are applied based on their maximum allowed latency,
// starting with the lowest value.
PlayerLatencyPolicies []PlayerLatencyPolicy
// Custom settings to use when prioritizing destinations and locations for game
// session placements. This configuration replaces the FleetIQ default
// prioritization process. Priority types that are not explicitly named will be
// automatically applied at the end of the prioritization process.
PriorityConfiguration *PriorityConfiguration
// The maximum time, in seconds, that a new game session placement request remains
// in the queue. When a request exceeds this time, the game session placement
// changes to a TIMED_OUT status. By default, this property is set to 600 .
TimeoutInSeconds *int32
noSmithyDocumentSerde
}
// A fleet or alias designated in a game session queue. Queues fulfill requests
// for new game sessions by placing a new game session on any of the queue's
// destinations.
type GameSessionQueueDestination struct {
// The Amazon Resource Name (ARN) that is assigned to fleet or fleet alias. ARNs,
// which include a fleet ID or alias ID and a Region name, provide a unique
// identifier across all Regions.
DestinationArn *string
noSmithyDocumentSerde
}
// Represents an EC2 instance of virtual computing resources that hosts one or
// more game servers. In Amazon GameLift, a fleet can contain zero or more
// instances. Related actions
type Instance struct {
// A time stamp indicating when this data object was created. Format is a number
// expressed in Unix time as milliseconds (for example "1469498468.057" ).
CreationTime *time.Time
// The DNS identifier assigned to the instance that is running the game session.
// Values have the following format:
// - TLS-enabled fleets: ..amazongamelift.com .
// - Non-TLS-enabled fleets: ec2-.compute.amazonaws.com . (See Amazon EC2
// Instance IP Addressing (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-instance-addressing.html#concepts-public-addresses)
// .)
// When connecting to a game session that is running on a TLS-enabled fleet, you
// must use the DNS name, not the IP address.
DnsName *string
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift fleet resource and uniquely identifies
// it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 .
FleetArn *string
// A unique identifier for the fleet that the instance is in.
FleetId *string
// A unique identifier for the instance.
InstanceId *string
// IP address that is assigned to the instance.
IpAddress *string
// The fleet location of the instance, expressed as an Amazon Web Services Region
// code, such as us-west-2 .
Location *string
// Operating system that is running on this instance.
OperatingSystem OperatingSystem
// Current status of the instance. Possible statuses include the following:
// - PENDING -- The instance is in the process of being created and launching
// server processes as defined in the fleet's run-time configuration.
// - ACTIVE -- The instance has been successfully created and at least one
// server process has successfully launched and reported back to Amazon GameLift
// that it is ready to host a game session. The instance is now considered ready to
// host game sessions.
// - TERMINATING -- The instance is in the process of shutting down. This may
// happen to reduce capacity during a scaling down event or to recycle resources in
// the event of a problem.
Status InstanceStatus
// Amazon EC2 instance type that defines the computing resources of this instance.
Type EC2InstanceType
noSmithyDocumentSerde
}
// Information required to remotely connect to a fleet instance.
type InstanceAccess struct {
// Credentials required to access the instance.
Credentials *InstanceCredentials
// A unique identifier for the fleet containing the instance being accessed.
FleetId *string
// A unique identifier for the instance being accessed.
InstanceId *string
// IP address that is assigned to the instance.
IpAddress *string
// Operating system that is running on the instance.
OperatingSystem OperatingSystem
noSmithyDocumentSerde
}
// Set of credentials required to remotely access a fleet instance.
type InstanceCredentials struct {
// Secret string. For Windows instances, the secret is a password for use with
// Windows Remote Desktop. For Linux instances, it is a private key (which must be
// saved as a .pem file) for use with SSH.
Secret *string
// User login string.
UserName *string
noSmithyDocumentSerde
}
// This data type is used with the Amazon GameLift FleetIQ and game server groups.
// An allowed instance type for a game server group. All game server groups must
// have at least two instance types defined for it. Amazon GameLift FleetIQ
// periodically evaluates each defined instance type for viability. It then updates
// the Auto Scaling group with the list of viable instance types.
type InstanceDefinition struct {
// An Amazon EC2 instance type designation.
//
// This member is required.
InstanceType GameServerGroupInstanceType
// Instance weighting that indicates how much this instance type contributes to
// the total capacity of a game server group. Instance weights are used by Amazon
// GameLift FleetIQ to calculate the instance type's cost per unit hour and better
// identify the most cost-effective options. For detailed information on weighting
// instance capacity, see Instance Weighting (https://docs.aws.amazon.com/autoscaling/ec2/userguide/asg-instance-weighting.html)
// in the Amazon Elastic Compute Cloud Auto Scaling User Guide. Default value is
// "1".
WeightedCapacity *string
noSmithyDocumentSerde
}
// A range of IP addresses and port settings that allow inbound traffic to connect
// to server processes on an instance in a fleet. New game sessions are assigned an
// IP address/port number combination, which must fall into the fleet's allowed
// ranges. Fleets with custom game builds must have permissions explicitly set. For
// Realtime Servers fleets, Amazon GameLift automatically opens two port ranges,
// one for TCP messaging and one for UDP.
type IpPermission struct {
// A starting value for a range of allowed port numbers. For fleets using Linux
// builds, only ports 22 and 1026-60000 are valid. For fleets using Windows
// builds, only ports 1026-60000 are valid.
//
// This member is required.
FromPort *int32
// A range of allowed IP addresses. This value must be expressed in CIDR notation.
// Example: " 000.000.000.000/[subnet mask] " or optionally the shortened version "
// 0.0.0.0/[subnet mask] ".
//
// This member is required.
IpRange *string
// The network communication protocol used by the fleet.
//
// This member is required.
Protocol IpProtocol
// An ending value for a range of allowed port numbers. Port numbers are
// end-inclusive. This value must be equal to or greater than FromPort . For fleets
// using Linux builds, only ports 22 and 1026-60000 are valid. For fleets using
// Windows builds, only ports 1026-60000 are valid.
//
// This member is required.
ToPort *int32
noSmithyDocumentSerde
}
// This data type is used with the Amazon GameLift FleetIQ and game server groups.
// An Amazon Elastic Compute Cloud launch template that contains configuration
// settings and game server code to be deployed to all instances in a game server
// group. The launch template is specified when creating a new game server group.
type LaunchTemplateSpecification struct {
// A unique identifier for an existing Amazon EC2 launch template.
LaunchTemplateId *string
// A readable identifier for an existing Amazon EC2 launch template.
LaunchTemplateName *string
// The version of the Amazon EC2 launch template to use. If no version is
// specified, the default version will be used. With Amazon EC2, you can specify a
// default version for a launch template. If none is set, the default is the first
// version created.
Version *string
noSmithyDocumentSerde
}
// Details about a location in a multi-location fleet.
type LocationAttributes struct {
// A fleet location and its current life-cycle state.
LocationState *LocationState
// A list of fleet actions that have been suspended in the fleet location.
StoppedActions []FleetAction
// The status of fleet activity updates to the location. The status PENDING_UPDATE
// indicates that StopFleetActions or StartFleetActions has been requested but the
// update has not yet been completed for the location.
UpdateStatus LocationUpdateStatus
noSmithyDocumentSerde
}
// A remote location where a multi-location fleet can deploy game servers for game
// hosting.
type LocationConfiguration struct {
// An Amazon Web Services Region code, such as us-west-2 .
//
// This member is required.
Location *string
noSmithyDocumentSerde
}
// Properties of a location
type LocationModel struct {
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift location resource and uniquely
// identifies it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::location/location-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 .
LocationArn *string
// The location's name.
LocationName *string
noSmithyDocumentSerde
}
// A fleet location and its life-cycle state. A location state object might be
// used to describe a fleet's remote location or home Region. Life-cycle state
// tracks the progress of launching the first instance in a new location and
// preparing it for game hosting, and then removing all instances and deleting the
// location from the fleet.
// - NEW -- A new fleet location has been defined and desired instances is set
// to 1.
// - DOWNLOADING/VALIDATING/BUILDING/ACTIVATING -- Amazon GameLift is setting up
// the new fleet location, creating new instances with the game build or Realtime
// script and starting server processes.
// - ACTIVE -- Hosts can now accept game sessions.
// - ERROR -- An error occurred when downloading, validating, building, or
// activating the fleet location.
// - DELETING -- Hosts are responding to a delete fleet location request.
// - TERMINATED -- The fleet location no longer exists.
// - NOT_FOUND -- The fleet location was not found. This could be because the
// custom location was removed or not created.
type LocationState struct {
// The fleet location, expressed as an Amazon Web Services Region code such as
// us-west-2 .
Location *string
// The life-cycle status of a fleet location.
Status FleetStatus
noSmithyDocumentSerde
}
// Represents a new player session that is created as a result of a successful
// FlexMatch match. A successful match automatically creates new player sessions
// for every player ID in the original matchmaking request. When players connect to
// the match's game session, they must include both player ID and player session ID
// in order to claim their assigned player slot.
type MatchedPlayerSession struct {
// A unique identifier for a player
PlayerId *string
// A unique identifier for a player session
PlayerSessionId *string
noSmithyDocumentSerde
}
// Guidelines for use with FlexMatch to match players into games. All matchmaking
// requests must specify a matchmaking configuration.
type MatchmakingConfiguration struct {
// A flag that indicates whether a match that was created with this configuration
// must be accepted by the matched players. To require acceptance, set to TRUE.
// When this option is enabled, matchmaking tickets use the status
// REQUIRES_ACCEPTANCE to indicate when a completed potential match is waiting for
// player acceptance.
AcceptanceRequired *bool
// The length of time (in seconds) to wait for players to accept a proposed match,
// if acceptance is required. If any player rejects the match or fails to accept
// before the timeout, the ticket continues to look for an acceptable match.
AcceptanceTimeoutSeconds *int32
// The number of player slots in a match to keep open for future players. For
// example, if the configuration's rule set specifies a match for a single
// 10-person team, and the additional player count is set to 2, 10 players will be
// selected for the match and 2 more player slots will be open for future players.
// This parameter is not used when FlexMatchMode is set to STANDALONE .
AdditionalPlayerCount *int32
// The method used to backfill game sessions created with this matchmaking
// configuration. MANUAL indicates that the game makes backfill requests or does
// not use the match backfill feature. AUTOMATIC indicates that GameLift creates
// backfill requests whenever a game session has one or more open slots. Learn more
// about manual and automatic backfill in Backfill existing games with FlexMatch (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-backfill.html)
// . Automatic backfill is not available when FlexMatchMode is set to STANDALONE .
BackfillMode BackfillMode
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift matchmaking configuration resource and
// uniquely identifies it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::matchmakingconfiguration/ . In a Amazon GameLift
// configuration ARN, the resource ID matches the Name value.
ConfigurationArn *string
// A time stamp indicating when this data object was created. Format is a number
// expressed in Unix time as milliseconds (for example "1469498468.057" ).
CreationTime *time.Time
// Information to attach to all events related to the matchmaking configuration.
CustomEventData *string
// A descriptive label that is associated with matchmaking configuration.
Description *string
// Indicates whether this matchmaking configuration is being used with Amazon
// GameLift hosting or as a standalone matchmaking solution.
// - STANDALONE - FlexMatch forms matches and returns match information,
// including players and team assignments, in a MatchmakingSucceeded (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-events.html#match-events-matchmakingsucceeded)
// event.
// - WITH_QUEUE - FlexMatch forms matches and uses the specified Amazon GameLift
// queue to start a game session for the match.
FlexMatchMode FlexMatchMode
// A set of custom properties for a game session, formatted as key:value pairs.
// These properties are passed to a game server process with a request to start a
// new game session (see Start a Game Session (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession)
// ). This information is added to the new GameSession object that is created for
// a successful match. This parameter is not used when FlexMatchMode is set to
// STANDALONE .
GameProperties []GameProperty
// A set of custom game session properties, formatted as a single string value.
// This data is passed to a game server process with a request to start a new game
// session (see Start a Game Session (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession)
// ). This information is added to the new GameSession object that is created for
// a successful match. This parameter is not used when FlexMatchMode is set to
// STANDALONE .
GameSessionData *string
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift game session queue resource and uniquely
// identifies it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::gamesessionqueue/ . Queues can be located in any Region.
// Queues are used to start new Amazon GameLift-hosted game sessions for matches
// that are created with this matchmaking configuration. This property is not set
// when FlexMatchMode is set to STANDALONE .
GameSessionQueueArns []string
// A unique identifier for the matchmaking configuration. This name is used to
// identify the configuration associated with a matchmaking request or ticket.
Name *string
// An SNS topic ARN that is set up to receive matchmaking notifications.
NotificationTarget *string
// The maximum duration, in seconds, that a matchmaking ticket can remain in
// process before timing out. Requests that fail due to timing out can be
// resubmitted as needed.
RequestTimeoutSeconds *int32
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) associated with the GameLift matchmaking rule set resource that this
// configuration uses.
RuleSetArn *string
// A unique identifier for the matchmaking rule set to use with this
// configuration. A matchmaking configuration can only use rule sets that are
// defined in the same Region.
RuleSetName *string
noSmithyDocumentSerde
}
// Set of rule statements, used with FlexMatch, that determine how to build your
// player matches. Each rule set describes a type of group to be created and
// defines the parameters for acceptable player matches. A rule set may define the
// following elements for a match. For detailed information and examples showing
// how to construct a rule set, see Build a FlexMatch rule set (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-rulesets.html)
// .
// - Teams -- Required. A rule set must define one or multiple teams for the
// match and set minimum and maximum team sizes. For example, a rule set might
// describe a 4x4 match that requires all eight slots to be filled.
// - Player attributes -- Optional. These attributes specify a set of player
// characteristics to evaluate when looking for a match. Matchmaking requests that
// use a rule set with player attributes must provide the corresponding attribute
// values. For example, an attribute might specify a player's skill or level.
// - Rules -- Optional. Rules define how to evaluate potential players for a
// match based on player attributes. A rule might specify minimum requirements for
// individual players, teams, or entire matches. For example, a rule might require
// each player to meet a certain skill level, each team to have at least one player
// in a certain role, or the match to have a minimum average skill level. or may
// describe an entire group--such as all teams must be evenly matched or have at
// least one player in a certain role.
// - Expansions -- Optional. Expansions allow you to relax the rules after a
// period of time when no acceptable matches are found. This feature lets you
// balance getting players into games in a reasonable amount of time instead of
// making them wait indefinitely for the best possible match. For example, you
// might use an expansion to increase the maximum skill variance between players
// after 30 seconds.
type MatchmakingRuleSet struct {
// A collection of matchmaking rules, formatted as a JSON string. Comments are not
// allowed in JSON, but most elements support a description field.
//
// This member is required.
RuleSetBody *string
// A time stamp indicating when this data object was created. Format is a number
// expressed in Unix time as milliseconds (for example "1469498468.057" ).
CreationTime *time.Time
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift matchmaking rule set resource and
// uniquely identifies it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::matchmakingruleset/ . In a GameLift rule set ARN, the
// resource ID matches the RuleSetName value.
RuleSetArn *string
// A unique identifier for the matchmaking rule set
RuleSetName *string
noSmithyDocumentSerde
}
// Ticket generated to track the progress of a matchmaking request. Each ticket is
// uniquely identified by a ticket ID, supplied by the requester, when creating a
// matchmaking request.
type MatchmakingTicket struct {
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) associated with the GameLift matchmaking configuration resource that is used
// with this ticket.
ConfigurationArn *string
// Name of the matchmaking configuration that is used with this ticket.
// Matchmaking configurations determine how players are grouped into a match and
// how a new game session is created for the match.
ConfigurationName *string
// Time stamp indicating when the matchmaking request stopped being processed due
// to successful completion, timeout, or cancellation. Format is a number expressed
// in Unix time as milliseconds (for example "1469498468.057" ).
EndTime *time.Time
// Average amount of time (in seconds) that players are currently waiting for a
// match. If there is not enough recent data, this property may be empty.
EstimatedWaitTime *int32
// Connection information for a new game session. Once a match is made, the
// FlexMatch engine creates a new game session for it. This information is added to
// the matchmaking ticket, which you can be retrieve by calling DescribeMatchmaking (https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeMatchmaking.html)
// .
GameSessionConnectionInfo *GameSessionConnectionInfo
// A set of Player objects, each representing a player to find matches for.
// Players are identified by a unique player ID and may include latency data for
// use during matchmaking. If the ticket is in status COMPLETED , the Player
// objects include the team the players were assigned to in the resulting match.
Players []Player
// Time stamp indicating when this matchmaking request was received. Format is a
// number expressed in Unix time as milliseconds (for example "1469498468.057" ).
StartTime *time.Time
// Current status of the matchmaking request.
// - QUEUED -- The matchmaking request has been received and is currently
// waiting to be processed.
// - SEARCHING -- The matchmaking request is currently being processed.
// - REQUIRES_ACCEPTANCE -- A match has been proposed and the players must
// accept the match. This status is used only with requests that use a matchmaking
// configuration with a player acceptance requirement.
// - PLACING -- The FlexMatch engine has matched players and is in the process
// of placing a new game session for the match.
// - COMPLETED -- Players have been matched and a game session is ready to host
// the players. A ticket in this state contains the necessary connection
// information for players.
// - FAILED -- The matchmaking request was not completed.
// - CANCELLED -- The matchmaking request was canceled. This may be the result
// of a StopMatchmaking operation or a proposed match that one or more players
// failed to accept.
// - TIMED_OUT -- The matchmaking request was not successful within the duration
// specified in the matchmaking configuration.
// Matchmaking requests that fail to successfully complete (statuses FAILED,
// CANCELLED, TIMED_OUT) can be resubmitted as new requests with new ticket IDs.
Status MatchmakingConfigurationStatus
// Additional information about the current status.
StatusMessage *string
// Code to explain the current status. For example, a status reason may indicate
// when a ticket has returned to SEARCHING status after a proposed match fails to
// receive player acceptances.
StatusReason *string
// A unique identifier for a matchmaking ticket.
TicketId *string
noSmithyDocumentSerde
}
// Information about a player session. This object contains only the player ID and
// player session ID. To retrieve full details on a player session, call
// DescribePlayerSessions (https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribePlayerSessions.html)
// with the player session ID.
type PlacedPlayerSession struct {
// A unique identifier for a player that is associated with this player session.
PlayerId *string
// A unique identifier for a player session.
PlayerSessionId *string
noSmithyDocumentSerde
}
// Represents a player in matchmaking. When starting a matchmaking request, a
// player has a player ID, attributes, and may have latency data. Team information
// is added after a match has been successfully completed.
type Player struct {
// A set of values, expressed in milliseconds, that indicates the amount of
// latency that a player experiences when connected to @aws; Regions. If this
// property is present, FlexMatch considers placing the match only in Regions for
// which latency is reported. If a matchmaker has a rule that evaluates player
// latency, players must report latency in order to be matched. If no latency is
// reported in this scenario, FlexMatch assumes that no Regions are available to
// the player and the ticket is not matchable.
LatencyInMs map[string]int32
// A collection of key:value pairs containing player information for use in
// matchmaking. Player attribute keys must match the playerAttributes used in a
// matchmaking rule set. Example: "PlayerAttributes": {"skill": {"N": "23"},
// "gameMode": {"S": "deathmatch"}} . You can provide up to 10 PlayerAttributes .
PlayerAttributes map[string]AttributeValue
// A unique identifier for a player
PlayerId *string
// Name of the team that the player is assigned to in a match. Team names are
// defined in a matchmaking rule set.
Team *string
noSmithyDocumentSerde
}
// Regional latency information for a player, used when requesting a new game
// session. This value indicates the amount of time lag that exists when the player
// is connected to a fleet in the specified Region. The relative difference between
// a player's latency values for multiple Regions are used to determine which
// fleets are best suited to place a new game session for the player.
type PlayerLatency struct {
// Amount of time that represents the time lag experienced by the player when
// connected to the specified Region.
LatencyInMilliseconds float32
// A unique identifier for a player associated with the latency data.
PlayerId *string
// Name of the Region that is associated with the latency value.
RegionIdentifier *string
noSmithyDocumentSerde
}
// Sets a latency cap for individual players when placing a game session. With a
// latency policy in force, a game session cannot be placed in a fleet location
// where a player reports latency higher than the cap. Latency policies are used
// only with placement request that provide player latency information. Player
// latency policies can be stacked to gradually relax latency requirements over
// time.
type PlayerLatencyPolicy struct {
// The maximum latency value that is allowed for any player, in milliseconds. All
// policies must have a value set for this property.
MaximumIndividualPlayerLatencyMilliseconds *int32
// The length of time, in seconds, that the policy is enforced while placing a new
// game session. A null value for this property means that the policy is enforced
// until the queue times out.
PolicyDurationSeconds *int32
noSmithyDocumentSerde
}
// Represents a player session. Player sessions are created either for a specific
// game session, or as part of a game session placement or matchmaking request. A
// player session can represents a reserved player slot in a game session (when
// status is RESERVED ) or actual player activity in a game session (when status is
// ACTIVE ). A player session object, including player data, is automatically
// passed to a game session when the player connects to the game session and is
// validated. After the game session ends, player sessions information is retained
// for 30 days and then removed. Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
type PlayerSession struct {
// A time stamp indicating when this data object was created. Format is a number
// expressed in Unix time as milliseconds (for example "1469498468.057" ).
CreationTime *time.Time
// The DNS identifier assigned to the instance that is running the game session.
// Values have the following format:
// - TLS-enabled fleets: ..amazongamelift.com .
// - Non-TLS-enabled fleets: ec2-.compute.amazonaws.com . (See Amazon EC2
// Instance IP Addressing (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-instance-addressing.html#concepts-public-addresses)
// .)
// When connecting to a game session that is running on a TLS-enabled fleet, you
// must use the DNS name, not the IP address.
DnsName *string
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) associated with the GameLift fleet that the player's game session is running
// on.
FleetArn *string
// A unique identifier for the fleet that the player's game session is running on.
FleetId *string
// A unique identifier for the game session that the player session is connected
// to.
GameSessionId *string
// The IP address of the game session. To connect to a Amazon GameLift game
// server, an app needs both the IP address and port number.
IpAddress *string
// Developer-defined information related to a player. Amazon GameLift does not use
// this data, so it can be formatted as needed for use in the game.
PlayerData *string
// A unique identifier for a player that is associated with this player session.
PlayerId *string
// A unique identifier for a player session.
PlayerSessionId *string
// Port number for the game session. To connect to a Amazon GameLift server
// process, an app needs both the IP address and port number.
Port *int32
// Current status of the player session. Possible player session statuses include
// the following:
// - RESERVED -- The player session request has been received, but the player
// has not yet connected to the server process and/or been validated.
// - ACTIVE -- The player has been validated by the server process and is
// currently connected.
// - COMPLETED -- The player connection has been dropped.
// - TIMEDOUT -- A player session request was received, but the player did not
// connect and/or was not validated within the timeout limit (60 seconds).
Status PlayerSessionStatus
// A time stamp indicating when this data object was terminated. Format is a
// number expressed in Unix time as milliseconds (for example "1469498468.057" ).
TerminationTime *time.Time
noSmithyDocumentSerde
}
// Custom prioritization settings for use by a game session queue when placing new
// game sessions with available game servers. When defined, this configuration
// replaces the default FleetIQ prioritization process, which is as follows:
// - If player latency data is included in a game session request, destinations
// and locations are prioritized first based on lowest average latency (1), then on
// lowest hosting cost (2), then on destination list order (3), and finally on
// location (alphabetical) (4). This approach ensures that the queue's top priority
// is to place game sessions where average player latency is lowest, and--if
// latency is the same--where the hosting cost is less, etc.
// - If player latency data is not included, destinations and locations are
// prioritized first on destination list order (1), and then on location
// (alphabetical) (2). This approach ensures that the queue's top priority is to
// place game sessions on the first destination fleet listed. If that fleet has
// multiple locations, the game session is placed on the first location (when
// listed alphabetically).
//
// Changing the priority order will affect how game sessions are placed.
type PriorityConfiguration struct {
// The prioritization order to use for fleet locations, when the PriorityOrder
// property includes LOCATION . Locations are identified by Amazon Web Services
// Region codes such as us-west-2 . Each location can only be listed once.
LocationOrder []string
// The recommended sequence to use when prioritizing where to place new game
// sessions. Each type can only be listed once.
// - LATENCY -- FleetIQ prioritizes locations where the average player latency
// (provided in each game session request) is lowest.
// - COST -- FleetIQ prioritizes destinations with the lowest current hosting
// costs. Cost is evaluated based on the location, instance type, and fleet type
// (Spot or On-Demand) for each destination in the queue.
// - DESTINATION -- FleetIQ prioritizes based on the order that destinations are
// listed in the queue configuration.
// - LOCATION -- FleetIQ prioritizes based on the provided order of locations, as
// defined in LocationOrder .
PriorityOrder []PriorityType
noSmithyDocumentSerde
}
// A policy that puts limits on the number of game sessions that a player can
// create within a specified span of time. With this policy, you can control
// players' ability to consume available resources. The policy is evaluated when a
// player tries to create a new game session. On receiving a CreateGameSession
// request, Amazon GameLift checks that the player (identified by CreatorId ) has
// created fewer than game session limit in the specified time period.
type ResourceCreationLimitPolicy struct {
// A policy that puts limits on the number of game sessions that a player can
// create within a specified span of time. With this policy, you can control
// players' ability to consume available resources. The policy is evaluated when a
// player tries to create a new game session. On receiving a CreateGameSession
// request, Amazon GameLift checks that the player (identified by CreatorId ) has
// created fewer than game session limit in the specified time period.
NewGameSessionsPerCreator *int32
// The time span used in evaluating the resource creation limit policy.
PolicyPeriodInMinutes *int32
noSmithyDocumentSerde
}
// The routing configuration for a fleet alias. Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
type RoutingStrategy struct {
// A unique identifier for the fleet that the alias points to. This value is the
// fleet ID, not the fleet ARN.
FleetId *string
// The message text to be used with a terminal routing strategy.
Message *string
// The type of routing strategy for the alias. Possible routing types include the
// following:
// - SIMPLE - The alias resolves to one specific fleet. Use this type when
// routing to active fleets.
// - TERMINAL - The alias does not resolve to a fleet but instead can be used to
// display a message to the user. A terminal alias throws a
// TerminalRoutingStrategyException with the message embedded.
Type RoutingStrategyType
noSmithyDocumentSerde
}
// A collection of server process configurations that describe the set of
// processes to run on each instance in a fleet. Server processes run either an
// executable in a custom game build or a Realtime Servers script. Amazon GameLift
// launches the configured processes, manages their life cycle, and replaces them
// as needed. Each instance checks regularly for an updated runtime configuration.
// A Amazon GameLift instance is limited to 50 processes running concurrently. To
// calculate the total number of processes in a runtime configuration, add the
// values of the ConcurrentExecutions parameter for each server process. Learn
// more about Running Multiple Processes on a Fleet (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-multiprocess.html)
// .
type RuntimeConfiguration struct {
// The maximum amount of time (in seconds) allowed to launch a new game session
// and have it report ready to host players. During this time, the game session is
// in status ACTIVATING . If the game session does not become active before the
// timeout, it is ended and the game session status is changed to TERMINATED .
GameSessionActivationTimeoutSeconds *int32
// The number of game sessions in status ACTIVATING to allow on an instance. This
// setting limits the instance resources that can be used for new game activations
// at any one time.
MaxConcurrentGameSessionActivations *int32
// A collection of server process configurations that identify what server
// processes to run on each instance in a fleet.
ServerProcesses []ServerProcess
noSmithyDocumentSerde
}
// The location in Amazon S3 where build or script files are stored for access by
// Amazon GameLift.
type S3Location struct {
// An Amazon S3 bucket identifier. Thename of the S3 bucket. Amazon GameLift
// doesn't support uploading from Amazon S3 buckets with names that contain a dot
// (.).
Bucket *string
// The name of the zip file that contains the build files or script files.
Key *string
// The version of the file, if object versioning is turned on for the bucket.
// Amazon GameLift uses this information when retrieving files from an S3 bucket
// that you own. Use this parameter to specify a specific version of the file. If
// not set, the latest version of the file is retrieved.
ObjectVersion *string
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) for an IAM role that allows Amazon GameLift to access the S3 bucket.
RoleArn *string
noSmithyDocumentSerde
}
// Rule that controls how a fleet is scaled. Scaling policies are uniquely
// identified by the combination of name and fleet ID.
type ScalingPolicy struct {
// Comparison operator to use when measuring a metric against the threshold value.
ComparisonOperator ComparisonOperatorType
// Length of time (in minutes) the metric must be at or beyond the threshold
// before a scaling event is triggered.
EvaluationPeriods *int32
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift fleet resource and uniquely identifies
// it. ARNs are unique across all Regions. Format is
// arn:aws:gamelift:::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 .
FleetArn *string
// A unique identifier for the fleet that is associated with this scaling policy.
FleetId *string
// The fleet location.
Location *string
// Name of the Amazon GameLift-defined metric that is used to trigger a scaling
// adjustment. For detailed descriptions of fleet metrics, see Monitor Amazon
// GameLift with Amazon CloudWatch (https://docs.aws.amazon.com/gamelift/latest/developerguide/monitoring-cloudwatch.html)
// .
// - ActivatingGameSessions -- Game sessions in the process of being created.
// - ActiveGameSessions -- Game sessions that are currently running.
// - ActiveInstances -- Fleet instances that are currently running at least one
// game session.
// - AvailableGameSessions -- Additional game sessions that fleet could host
// simultaneously, given current capacity.
// - AvailablePlayerSessions -- Empty player slots in currently active game
// sessions. This includes game sessions that are not currently accepting players.
// Reserved player slots are not included.
// - CurrentPlayerSessions -- Player slots in active game sessions that are
// being used by a player or are reserved for a player.
// - IdleInstances -- Active instances that are currently hosting zero game
// sessions.
// - PercentAvailableGameSessions -- Unused percentage of the total number of
// game sessions that a fleet could host simultaneously, given current capacity.
// Use this metric for a target-based scaling policy.
// - PercentIdleInstances -- Percentage of the total number of active instances
// that are hosting zero game sessions.
// - QueueDepth -- Pending game session placement requests, in any queue, where
// the current fleet is the top-priority destination.
// - WaitTime -- Current wait time for pending game session placement requests,
// in any queue, where the current fleet is the top-priority destination.
MetricName MetricName
// A descriptive label that is associated with a fleet's scaling policy. Policy
// names do not need to be unique.
Name *string
// The type of scaling policy to create. For a target-based policy, set the
// parameter MetricName to 'PercentAvailableGameSessions' and specify a
// TargetConfiguration. For a rule-based policy set the following parameters:
// MetricName, ComparisonOperator, Threshold, EvaluationPeriods,
// ScalingAdjustmentType, and ScalingAdjustment.
PolicyType PolicyType
// Amount of adjustment to make, based on the scaling adjustment type.
ScalingAdjustment int32
// The type of adjustment to make to a fleet's instance count.
// - ChangeInCapacity -- add (or subtract) the scaling adjustment value from the
// current instance count. Positive values scale up while negative values scale
// down.
// - ExactCapacity -- set the instance count to the scaling adjustment value.
// - PercentChangeInCapacity -- increase or reduce the current instance count by
// the scaling adjustment, read as a percentage. Positive values scale up while
// negative values scale down.
ScalingAdjustmentType ScalingAdjustmentType
// Current status of the scaling policy. The scaling policy can be in force only
// when in an ACTIVE status. Scaling policies can be suspended for individual
// fleets. If the policy is suspended for a fleet, the policy status does not
// change.
// - ACTIVE -- The scaling policy can be used for auto-scaling a fleet.
// - UPDATE_REQUESTED -- A request to update the scaling policy has been
// received.
// - UPDATING -- A change is being made to the scaling policy.
// - DELETE_REQUESTED -- A request to delete the scaling policy has been
// received.
// - DELETING -- The scaling policy is being deleted.
// - DELETED -- The scaling policy has been deleted.
// - ERROR -- An error occurred in creating the policy. It should be removed and
// recreated.
Status ScalingStatusType
// An object that contains settings for a target-based scaling policy.
TargetConfiguration *TargetConfiguration
// Metric value used to trigger a scaling event.
Threshold float64
// The current status of the fleet's scaling policies in a requested fleet
// location. The status PENDING_UPDATE indicates that an update was requested for
// the fleet but has not yet been completed for the location.
UpdateStatus LocationUpdateStatus
noSmithyDocumentSerde
}
// Properties describing a Realtime script. Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
type Script struct {
// A time stamp indicating when this data object was created. Format is a number
// expressed in Unix time as milliseconds (for example "1469498468.057" ).
CreationTime *time.Time
// A descriptive label that is associated with a script. Script names don't need
// to be unique.
Name *string
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) that is assigned to a Amazon GameLift script resource and uniquely identifies
// it. ARNs are unique across all Regions. In a GameLift script ARN, the resource
// ID matches the ScriptId value.
ScriptArn *string
// A unique identifier for the Realtime script
ScriptId *string
// The file size of the uploaded Realtime script, expressed in bytes. When files
// are uploaded from an S3 location, this value remains at "0".
SizeOnDisk *int64
// The location of the Amazon S3 bucket where a zipped file containing your
// Realtime scripts is stored. The storage location must specify the Amazon S3
// bucket name, the zip file name (the "key"), and a role ARN that allows Amazon
// GameLift to access the Amazon S3 storage location. The S3 bucket must be in the
// same Region where you want to create a new script. By default, Amazon GameLift
// uploads the latest version of the zip file; if you have S3 object versioning
// turned on, you can use the ObjectVersion parameter to specify an earlier
// version.
StorageLocation *S3Location
// Version information associated with a build or script. Version strings don't
// need to be unique.
Version *string
noSmithyDocumentSerde
}
// A set of instructions for launching server processes on each instance in a
// fleet. Server processes run either an executable in a custom game build or a
// Realtime Servers script. Server process configurations are part of a fleet's
// runtime configuration.
type ServerProcess struct {
// The number of server processes using this configuration that run concurrently
// on each instance.
//
// This member is required.
ConcurrentExecutions *int32
// The location of a game build executable or the Realtime script file that
// contains the Init() function. Game builds and Realtime scripts are installed on
// instances at the root:
// - Windows (custom game builds only): C:\game . Example: "
// C:\game\MyGame\server.exe "
// - Linux: /local/game . Examples: " /local/game/MyGame/server.exe " or "
// /local/game/MyRealtimeScript.js "
//
// This member is required.
LaunchPath *string
// An optional list of parameters to pass to the server executable or Realtime
// script on launch.
Parameters *string
noSmithyDocumentSerde
}
// A label that you can assign to a Amazon GameLift resource. Learn more Tagging
// Amazon Web Services Resources (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html)
// in the Amazon Web Services General Reference Amazon Web Services Tagging
// Strategies (http://aws.amazon.com/answers/account-management/aws-tagging-strategies/)
// Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
type Tag struct {
// The key for a developer-defined key value pair for tagging an Amazon Web
// Services resource.
//
// This member is required.
Key *string
// The value for a developer-defined key value pair for tagging an Amazon Web
// Services resource.
//
// This member is required.
Value *string
noSmithyDocumentSerde
}
// Settings for a target-based scaling policy. A target-based policy tracks a
// particular fleet metric specifies a target value for the metric. As player usage
// changes, the policy triggers Amazon GameLift to adjust capacity so that the
// metric returns to the target value. The target configuration specifies settings
// as needed for the target based policy, including the target value.
type TargetConfiguration struct {
// Desired value to use with a target-based scaling policy. The value must be
// relevant for whatever metric the scaling policy is using. For example, in a
// policy using the metric PercentAvailableGameSessions, the target value should be
// the preferred size of the fleet's buffer (the percent of capacity that should be
// idle and ready for new game sessions).
//
// This member is required.
TargetValue float64
noSmithyDocumentSerde
}
// This data type is used with the Amazon GameLift FleetIQ and game server groups.
// Settings for a target-based scaling policy as part of a
// GameServerGroupAutoScalingPolicy (https://docs.aws.amazon.com/gamelift/latest/apireference/API_GameServerGroupAutoScalingPolicy.html)
// . These settings are used to create a target-based policy that tracks the Amazon
// GameLift FleetIQ metric "PercentUtilizedGameServers" and specifies a target
// value for the metric. As player usage changes, the policy triggers to adjust the
// game server group capacity so that the metric returns to the target value.
type TargetTrackingConfiguration struct {
// Desired value to use with a game server group target-based scaling policy.
//
// This member is required.
TargetValue *float64
noSmithyDocumentSerde
}
// Represents an authorization for a VPC peering connection between the VPC for an
// Amazon GameLift fleet and another VPC on an account you have access to. This
// authorization must exist and be valid for the peering connection to be
// established. Authorizations are valid for 24 hours after they are issued.
// Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
type VpcPeeringAuthorization struct {
// Time stamp indicating when this authorization was issued. Format is a number
// expressed in Unix time as milliseconds (for example "1469498468.057" ).
CreationTime *time.Time
// Time stamp indicating when this authorization expires (24 hours after
// issuance). Format is a number expressed in Unix time as milliseconds (for
// example "1469498468.057" ).
ExpirationTime *time.Time
// A unique identifier for the Amazon Web Services account that you use to manage
// your Amazon GameLift fleet. You can find your Account ID in the Amazon Web
// Services Management Console under account settings.
GameLiftAwsAccountId *string
// The authorization's peer VPC Amazon Web Services account ID.
PeerVpcAwsAccountId *string
// A unique identifier for a VPC with resources to be accessed by your Amazon
// GameLift fleet. The VPC must be in the same Region as your fleet. To look up a
// VPC ID, use the VPC Dashboard (https://console.aws.amazon.com/vpc/) in the
// Amazon Web Services Management Console. Learn more about VPC peering in VPC
// Peering with Amazon GameLift Fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/vpc-peering.html)
// .
PeerVpcId *string
noSmithyDocumentSerde
}
// Represents a peering connection between a VPC on one of your Amazon Web
// Services accounts and the VPC for your Amazon GameLift fleets. This record may
// be for an active peering connection or a pending connection that has not yet
// been established. Related actions All APIs by task (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
type VpcPeeringConnection struct {
// The Amazon Resource Name ( ARN (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)
// ) associated with the GameLift fleet resource for this connection.
FleetArn *string
// A unique identifier for the fleet. This ID determines the ID of the Amazon
// GameLift VPC for your fleet.
FleetId *string
// A unique identifier for the VPC that contains the Amazon GameLift fleet for
// this connection. This VPC is managed by Amazon GameLift and does not appear in
// your Amazon Web Services account.
GameLiftVpcId *string
// CIDR block of IPv4 addresses assigned to the VPC peering connection for the
// GameLift VPC. The peered VPC also has an IPv4 CIDR block associated with it;
// these blocks cannot overlap or the peering connection cannot be created.
IpV4CidrBlock *string
// A unique identifier for a VPC with resources to be accessed by your Amazon
// GameLift fleet. The VPC must be in the same Region as your fleet. To look up a
// VPC ID, use the VPC Dashboard (https://console.aws.amazon.com/vpc/) in the
// Amazon Web Services Management Console. Learn more about VPC peering in VPC
// Peering with Amazon GameLift Fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/vpc-peering.html)
// .
PeerVpcId *string
// The status information about the connection. Status indicates if a connection
// is pending, successful, or failed.
Status *VpcPeeringConnectionStatus
// A unique identifier that is automatically assigned to the connection record.
// This ID is referenced in VPC peering connection events, and is used when
// deleting a connection.
VpcPeeringConnectionId *string
noSmithyDocumentSerde
}
// Represents status information for a VPC peering connection. Status codes and
// messages are provided from EC2 (see VpcPeeringConnectionStateReason (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_VpcPeeringConnectionStateReason.html)
// ). Connection status information is also communicated as a fleet event.
type VpcPeeringConnectionStatus struct {
// Code indicating the status of a VPC peering connection.
Code *string
// Additional messaging associated with the connection status.
Message *string
noSmithyDocumentSerde
}
type noSmithyDocumentSerde = smithydocument.NoSerde
| 2,371 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamesparks
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/aws/defaults"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/retry"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources"
smithy "github.com/aws/smithy-go"
smithydocument "github.com/aws/smithy-go/document"
"github.com/aws/smithy-go/logging"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net"
"net/http"
"time"
)
const ServiceID = "GameSparks"
const ServiceAPIVersion = "2021-08-17"
// Client provides the API client to make operations call for GameSparks.
type Client struct {
options Options
}
// New returns an initialized Client based on the functional options. Provide
// additional functional options to further configure the behavior of the client,
// such as changing the client's endpoint or adding custom middleware behavior.
func New(options Options, optFns ...func(*Options)) *Client {
options = options.Copy()
resolveDefaultLogger(&options)
setResolvedDefaultsMode(&options)
resolveRetryer(&options)
resolveHTTPClient(&options)
resolveHTTPSignerV4(&options)
resolveDefaultEndpointConfiguration(&options)
for _, fn := range optFns {
fn(&options)
}
client := &Client{
options: options,
}
return client
}
type Options 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
// Configures the events that will be sent to the configured logger.
ClientLogMode aws.ClientLogMode
// The credentials object to use when signing requests.
Credentials aws.CredentialsProvider
// The configuration DefaultsMode that the SDK should use when constructing the
// clients initial default settings.
DefaultsMode aws.DefaultsMode
// The endpoint options to be used when attempting to resolve an endpoint.
EndpointOptions EndpointResolverOptions
// The service endpoint resolver.
EndpointResolver EndpointResolver
// Signature Version 4 (SigV4) Signer
HTTPSignerV4 HTTPSignerV4
// The logger writer interface to write logging messages to.
Logger logging.Logger
// The region to send requests to. (Required)
Region string
// RetryMaxAttempts specifies the maximum number attempts an API client will call
// an operation that fails with a retryable error. A value of 0 is ignored, and
// will not be used to configure the API client created default retryer, or modify
// per operation call's retry max attempts. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. If specified in an operation call's functional
// options with a value that is different than the constructed client's Options,
// the Client's Retryer will be wrapped to use the operation's specific
// RetryMaxAttempts value.
RetryMaxAttempts int
// RetryMode specifies the retry mode the API client will be created with, if
// Retryer option is not also specified. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. Currently does not support per operation call
// overrides, may in the future.
RetryMode aws.RetryMode
// Retryer guides how HTTP requests should be retried in case of recoverable
// failures. When nil the API client will use a default retryer. The kind of
// default retry created by the API client can be changed with the RetryMode
// option.
Retryer aws.Retryer
// The RuntimeEnvironment configuration, only populated if the DefaultsMode is set
// to DefaultsModeAuto and is initialized using config.LoadDefaultConfig . You
// should not populate this structure programmatically, or rely on the values here
// within your applications.
RuntimeEnvironment aws.RuntimeEnvironment
// The initial DefaultsMode used when the client options were constructed. If the
// DefaultsMode was set to aws.DefaultsModeAuto this will store what the resolved
// value was at that point in time. Currently does not support per operation call
// overrides, may in the future.
resolvedDefaultsMode aws.DefaultsMode
// The HTTP client to invoke API calls with. Defaults to client's default HTTP
// implementation if nil.
HTTPClient HTTPClient
}
// WithAPIOptions returns a functional option for setting the Client's APIOptions
// option.
func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options) {
return func(o *Options) {
o.APIOptions = append(o.APIOptions, optFns...)
}
}
// WithEndpointResolver returns a functional option for setting the Client's
// EndpointResolver option.
func WithEndpointResolver(v EndpointResolver) func(*Options) {
return func(o *Options) {
o.EndpointResolver = v
}
}
type HTTPClient interface {
Do(*http.Request) (*http.Response, error)
}
// Copy creates a clone where the APIOptions list is deep copied.
func (o Options) Copy() Options {
to := o
to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions))
copy(to.APIOptions, o.APIOptions)
return to
}
func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) {
ctx = middleware.ClearStackValues(ctx)
stack := middleware.NewStack(opID, smithyhttp.NewStackRequest)
options := c.options.Copy()
for _, fn := range optFns {
fn(&options)
}
finalizeRetryMaxAttemptOptions(&options, *c)
finalizeClientEndpointResolverOptions(&options)
for _, fn := range stackFns {
if err := fn(stack, options); err != nil {
return nil, metadata, err
}
}
for _, fn := range options.APIOptions {
if err := fn(stack); err != nil {
return nil, metadata, err
}
}
handler := middleware.DecorateHandler(smithyhttp.NewClientHandler(options.HTTPClient), stack)
result, metadata, err = handler.Handle(ctx, params)
if err != nil {
err = &smithy.OperationError{
ServiceID: ServiceID,
OperationName: opID,
Err: err,
}
}
return result, metadata, err
}
type noSmithyDocumentSerde = smithydocument.NoSerde
func resolveDefaultLogger(o *Options) {
if o.Logger != nil {
return
}
o.Logger = logging.Nop{}
}
func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error {
return middleware.AddSetLoggerMiddleware(stack, o.Logger)
}
func setResolvedDefaultsMode(o *Options) {
if len(o.resolvedDefaultsMode) > 0 {
return
}
var mode aws.DefaultsMode
mode.SetFromString(string(o.DefaultsMode))
if mode == aws.DefaultsModeAuto {
mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment)
}
o.resolvedDefaultsMode = mode
}
// NewFromConfig returns a new client from the provided config.
func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client {
opts := Options{
Region: cfg.Region,
DefaultsMode: cfg.DefaultsMode,
RuntimeEnvironment: cfg.RuntimeEnvironment,
HTTPClient: cfg.HTTPClient,
Credentials: cfg.Credentials,
APIOptions: cfg.APIOptions,
Logger: cfg.Logger,
ClientLogMode: cfg.ClientLogMode,
}
resolveAWSRetryerProvider(cfg, &opts)
resolveAWSRetryMaxAttempts(cfg, &opts)
resolveAWSRetryMode(cfg, &opts)
resolveAWSEndpointResolver(cfg, &opts)
resolveUseDualStackEndpoint(cfg, &opts)
resolveUseFIPSEndpoint(cfg, &opts)
return New(opts, optFns...)
}
func resolveHTTPClient(o *Options) {
var buildable *awshttp.BuildableClient
if o.HTTPClient != nil {
var ok bool
buildable, ok = o.HTTPClient.(*awshttp.BuildableClient)
if !ok {
return
}
} else {
buildable = awshttp.NewBuildableClient()
}
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) {
if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok {
dialer.Timeout = dialerTimeout
}
})
buildable = buildable.WithTransportOptions(func(transport *http.Transport) {
if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok {
transport.TLSHandshakeTimeout = tlsHandshakeTimeout
}
})
}
o.HTTPClient = buildable
}
func resolveRetryer(o *Options) {
if o.Retryer != nil {
return
}
if len(o.RetryMode) == 0 {
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
o.RetryMode = modeConfig.RetryMode
}
}
if len(o.RetryMode) == 0 {
o.RetryMode = aws.RetryModeStandard
}
var standardOptions []func(*retry.StandardOptions)
if v := o.RetryMaxAttempts; v != 0 {
standardOptions = append(standardOptions, func(so *retry.StandardOptions) {
so.MaxAttempts = v
})
}
switch o.RetryMode {
case aws.RetryModeAdaptive:
var adaptiveOptions []func(*retry.AdaptiveModeOptions)
if len(standardOptions) != 0 {
adaptiveOptions = append(adaptiveOptions, func(ao *retry.AdaptiveModeOptions) {
ao.StandardOptions = append(ao.StandardOptions, standardOptions...)
})
}
o.Retryer = retry.NewAdaptiveMode(adaptiveOptions...)
default:
o.Retryer = retry.NewStandard(standardOptions...)
}
}
func resolveAWSRetryerProvider(cfg aws.Config, o *Options) {
if cfg.Retryer == nil {
return
}
o.Retryer = cfg.Retryer()
}
func resolveAWSRetryMode(cfg aws.Config, o *Options) {
if len(cfg.RetryMode) == 0 {
return
}
o.RetryMode = cfg.RetryMode
}
func resolveAWSRetryMaxAttempts(cfg aws.Config, o *Options) {
if cfg.RetryMaxAttempts == 0 {
return
}
o.RetryMaxAttempts = cfg.RetryMaxAttempts
}
func finalizeRetryMaxAttemptOptions(o *Options, client Client) {
if v := o.RetryMaxAttempts; v == 0 || v == client.options.RetryMaxAttempts {
return
}
o.Retryer = retry.AddWithMaxAttempts(o.Retryer, o.RetryMaxAttempts)
}
func resolveAWSEndpointResolver(cfg aws.Config, o *Options) {
if cfg.EndpointResolver == nil && cfg.EndpointResolverWithOptions == nil {
return
}
o.EndpointResolver = withEndpointResolver(cfg.EndpointResolver, cfg.EndpointResolverWithOptions, NewDefaultEndpointResolver())
}
func addClientUserAgent(stack *middleware.Stack) error {
return awsmiddleware.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "gamesparks", goModuleVersion)(stack)
}
func addHTTPSignerV4Middleware(stack *middleware.Stack, o Options) error {
mw := v4.NewSignHTTPRequestMiddleware(v4.SignHTTPRequestMiddlewareOptions{
CredentialsProvider: o.Credentials,
Signer: o.HTTPSignerV4,
LogSigning: o.ClientLogMode.IsSigning(),
})
return stack.Finalize.Add(mw, middleware.After)
}
type HTTPSignerV4 interface {
SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
}
func resolveHTTPSignerV4(o *Options) {
if o.HTTPSignerV4 != nil {
return
}
o.HTTPSignerV4 = newDefaultV4Signer(*o)
}
func newDefaultV4Signer(o Options) *v4.Signer {
return v4.NewSigner(func(so *v4.SignerOptions) {
so.Logger = o.Logger
so.LogSigning = o.ClientLogMode.IsSigning()
})
}
func addRetryMiddlewares(stack *middleware.Stack, o Options) error {
mo := retry.AddRetryMiddlewaresOptions{
Retryer: o.Retryer,
LogRetryAttempts: o.ClientLogMode.IsRetries(),
}
return retry.AddRetryMiddlewares(stack, mo)
}
// resolves dual-stack endpoint configuration
func resolveUseDualStackEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseDualStackEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseDualStackEndpoint = value
}
return nil
}
// resolves FIPS endpoint configuration
func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseFIPSEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseFIPSEndpoint = value
}
return nil
}
func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error {
return awsmiddleware.AddRequestIDRetrieverMiddleware(stack)
}
func addResponseErrorMiddleware(stack *middleware.Stack) error {
return awshttp.AddResponseErrorMiddleware(stack)
}
func addRequestResponseLogging(stack *middleware.Stack, o Options) error {
return stack.Deserialize.Add(&smithyhttp.RequestResponseLogger{
LogRequest: o.ClientLogMode.IsRequest(),
LogRequestWithBody: o.ClientLogMode.IsRequestWithBody(),
LogResponse: o.ClientLogMode.IsResponse(),
LogResponseWithBody: o.ClientLogMode.IsResponseWithBody(),
}, middleware.After)
}
| 434 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamesparks
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io/ioutil"
"net/http"
"strings"
"testing"
)
func TestClient_resolveRetryOptions(t *testing.T) {
nopClient := smithyhttp.ClientDoFunc(func(_ *http.Request) (*http.Response, error) {
return &http.Response{
StatusCode: 200,
Header: http.Header{},
Body: ioutil.NopCloser(strings.NewReader("")),
}, nil
})
cases := map[string]struct {
defaultsMode aws.DefaultsMode
retryer aws.Retryer
retryMaxAttempts int
opRetryMaxAttempts *int
retryMode aws.RetryMode
expectClientRetryMode aws.RetryMode
expectClientMaxAttempts int
expectOpMaxAttempts int
}{
"defaults": {
defaultsMode: aws.DefaultsModeStandard,
expectClientRetryMode: aws.RetryModeStandard,
expectClientMaxAttempts: 3,
expectOpMaxAttempts: 3,
},
"custom default retry": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(2),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 2,
},
"custom op no change max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(10),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op 0 max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(0),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
client := NewFromConfig(aws.Config{
DefaultsMode: c.defaultsMode,
Retryer: func() func() aws.Retryer {
if c.retryer == nil {
return nil
}
return func() aws.Retryer { return c.retryer }
}(),
HTTPClient: nopClient,
RetryMaxAttempts: c.retryMaxAttempts,
RetryMode: c.retryMode,
})
if e, a := c.expectClientRetryMode, client.options.RetryMode; e != a {
t.Errorf("expect %v retry mode, got %v", e, a)
}
if e, a := c.expectClientMaxAttempts, client.options.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v max attempts, got %v", e, a)
}
_, _, err := client.invokeOperation(context.Background(), "mockOperation", struct{}{},
[]func(*Options){
func(o *Options) {
if c.opRetryMaxAttempts == nil {
return
}
o.RetryMaxAttempts = *c.opRetryMaxAttempts
},
},
func(s *middleware.Stack, o Options) error {
s.Initialize.Clear()
s.Serialize.Clear()
s.Build.Clear()
s.Finalize.Clear()
s.Deserialize.Clear()
if e, a := c.expectOpMaxAttempts, o.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v op max attempts, got %v", e, a)
}
return nil
})
if err != nil {
t.Fatalf("expect no operation error, got %v", err)
}
})
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamesparks
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/gamesparks/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a new game with an empty configuration. After creating your game, you
// can update the configuration using UpdateGameConfiguration or
// ImportGameConfiguration .
func (c *Client) CreateGame(ctx context.Context, params *CreateGameInput, optFns ...func(*Options)) (*CreateGameOutput, error) {
if params == nil {
params = &CreateGameInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateGame", params, optFns, c.addOperationCreateGameMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateGameOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateGameInput struct {
// The name of the game.
//
// This member is required.
GameName *string
// A client-defined token. With an active client token in the request, this action
// is idempotent.
ClientToken *string
// The description of the game.
Description *string
// The list of tags to apply to the game.
Tags map[string]string
noSmithyDocumentSerde
}
type CreateGameOutput struct {
// Details about the game that was created.
Game *types.GameDetails
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateGameMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateGame{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateGame{}, 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 = addOpCreateGameValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateGame(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
}
func newServiceMetadataMiddleware_opCreateGame(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamesparks",
OperationName: "CreateGame",
}
}
| 137 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamesparks
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/gamesparks/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a snapshot of the game configuration.
func (c *Client) CreateSnapshot(ctx context.Context, params *CreateSnapshotInput, optFns ...func(*Options)) (*CreateSnapshotOutput, error) {
if params == nil {
params = &CreateSnapshotInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateSnapshot", params, optFns, c.addOperationCreateSnapshotMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateSnapshotOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateSnapshotInput struct {
// The name of the game.
//
// This member is required.
GameName *string
// The description of the snapshot.
Description *string
noSmithyDocumentSerde
}
type CreateSnapshotOutput struct {
// Properties that provide details of the created snapshot.
Snapshot *types.SnapshotDetails
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateSnapshotMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateSnapshot{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateSnapshot{}, 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 = addOpCreateSnapshotValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateSnapshot(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
}
func newServiceMetadataMiddleware_opCreateSnapshot(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamesparks",
OperationName: "CreateSnapshot",
}
}
| 128 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamesparks
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/gamesparks/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a new stage for stage-by-stage game development and deployment.
func (c *Client) CreateStage(ctx context.Context, params *CreateStageInput, optFns ...func(*Options)) (*CreateStageOutput, error) {
if params == nil {
params = &CreateStageInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateStage", params, optFns, c.addOperationCreateStageMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateStageOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateStageInput struct {
// The name of the game.
//
// This member is required.
GameName *string
// The Amazon Resource Name (ARN) of the role to run the game with. This role can
// be a game-defined role or the default role that GameSparks created.
//
// This member is required.
Role *string
// The name of the stage.
//
// This member is required.
StageName *string
// A client-defined token. With an active client token in the request, this action
// is idempotent.
ClientToken *string
// The description of the stage.
Description *string
// The list of tags to apply to the stage.
Tags map[string]string
noSmithyDocumentSerde
}
type CreateStageOutput struct {
// Properties that describe the stage.
Stage *types.StageDetails
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateStageMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateStage{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateStage{}, 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 = addOpCreateStageValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateStage(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
}
func newServiceMetadataMiddleware_opCreateStage(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamesparks",
OperationName: "CreateStage",
}
}
| 146 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamesparks
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a game.
func (c *Client) DeleteGame(ctx context.Context, params *DeleteGameInput, optFns ...func(*Options)) (*DeleteGameOutput, error) {
if params == nil {
params = &DeleteGameInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteGame", params, optFns, c.addOperationDeleteGameMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteGameOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteGameInput struct {
// The name of the game to delete.
//
// This member is required.
GameName *string
noSmithyDocumentSerde
}
type DeleteGameOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteGameMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteGame{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteGame{}, 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 = addOpDeleteGameValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteGame(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
}
func newServiceMetadataMiddleware_opDeleteGame(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamesparks",
OperationName: "DeleteGame",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamesparks
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a stage from a game, along with the associated game runtime.
func (c *Client) DeleteStage(ctx context.Context, params *DeleteStageInput, optFns ...func(*Options)) (*DeleteStageOutput, error) {
if params == nil {
params = &DeleteStageInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteStage", params, optFns, c.addOperationDeleteStageMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteStageOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteStageInput struct {
// The name of the game.
//
// This member is required.
GameName *string
// The name of the stage to delete.
//
// This member is required.
StageName *string
noSmithyDocumentSerde
}
type DeleteStageOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteStageMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteStage{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteStage{}, 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 = addOpDeleteStageValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteStage(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
}
func newServiceMetadataMiddleware_opDeleteStage(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamesparks",
OperationName: "DeleteStage",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamesparks
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Disconnects a player from the game runtime. If a player has multiple
// connections, this operation attempts to close all of them.
func (c *Client) DisconnectPlayer(ctx context.Context, params *DisconnectPlayerInput, optFns ...func(*Options)) (*DisconnectPlayerOutput, error) {
if params == nil {
params = &DisconnectPlayerInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DisconnectPlayer", params, optFns, c.addOperationDisconnectPlayerMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DisconnectPlayerOutput)
out.ResultMetadata = metadata
return out, nil
}
type DisconnectPlayerInput struct {
// The name of the game.
//
// This member is required.
GameName *string
// The unique identifier representing a player.
//
// This member is required.
PlayerId *string
// The name of the stage.
//
// This member is required.
StageName *string
noSmithyDocumentSerde
}
type DisconnectPlayerOutput struct {
// The list of the connection ids that could not be disconnected.
DisconnectFailures []string
// The list of the connection ids that were disconnected.
DisconnectSuccesses []string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDisconnectPlayerMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDisconnectPlayer{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDisconnectPlayer{}, 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 = addOpDisconnectPlayerValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDisconnectPlayer(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
}
func newServiceMetadataMiddleware_opDisconnectPlayer(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamesparks",
OperationName: "DisconnectPlayer",
}
}
| 138 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package gamesparks
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Exports a game configuration snapshot.
func (c *Client) ExportSnapshot(ctx context.Context, params *ExportSnapshotInput, optFns ...func(*Options)) (*ExportSnapshotOutput, error) {
if params == nil {
params = &ExportSnapshotInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ExportSnapshot", params, optFns, c.addOperationExportSnapshotMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ExportSnapshotOutput)
out.ResultMetadata = metadata
return out, nil
}
type ExportSnapshotInput struct {
// The name of the game.
//
// This member is required.
GameName *string
// The identifier of the snapshot to export.
//
// This member is required.
SnapshotId *string
noSmithyDocumentSerde
}
type ExportSnapshotOutput struct {
// The presigned URL for the snapshot data. This URL will be available for 10
// minutes, and can be used to download the snapshot content. If the URL expires, a
// new one can be requested using the same operation.
S3Url *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationExportSnapshotMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpExportSnapshot{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpExportSnapshot{}, 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 = addOpExportSnapshotValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opExportSnapshot(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
}
func newServiceMetadataMiddleware_opExportSnapshot(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "gamesparks",
OperationName: "ExportSnapshot",
}
}
| 131 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.