{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.GameLift.CreateGameServerGroup
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- __This operation is used with the GameLift FleetIQ solution and game
-- server groups.__
--
-- Creates a GameLift FleetIQ game server group for managing game hosting
-- on a collection of Amazon EC2 instances for game hosting. This operation
-- creates the game server group, creates an Auto Scaling group in your AWS
-- account, and establishes a link between the two groups. You can view the
-- status of your game server groups in the GameLift console. Game server
-- group metrics and events are emitted to Amazon CloudWatch.
--
-- Before creating a new game server group, you must have the following:
--
-- -   An Amazon EC2 launch template that specifies how to launch Amazon
--     EC2 instances with your game server build. For more information, see
--     <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html Launching an Instance from a Launch Template>
--     in the /Amazon EC2 User Guide/.
--
-- -   An IAM role that extends limited access to your AWS account to allow
--     GameLift FleetIQ to create and interact with the Auto Scaling group.
--     For more information, see
--     <https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-iam-permissions-roles.html Create IAM roles for cross-service interaction>
--     in the /GameLift FleetIQ Developer Guide/.
--
-- To create a new game server group, specify a unique group name, IAM role
-- and Amazon EC2 launch template, and provide a list of instance types
-- that can be used in the group. You must also set initial maximum and
-- minimum limits on the group\'s instance count. You can optionally set an
-- Auto Scaling policy with target tracking based on a GameLift FleetIQ
-- metric.
--
-- Once the game server group and corresponding Auto Scaling group are
-- created, you have full access to change the Auto Scaling group\'s
-- configuration as needed. Several properties that are set when creating a
-- game server group, including maximum\/minimum size and auto-scaling
-- policy settings, must be updated directly in the Auto Scaling group.
-- Keep in mind that some Auto Scaling group properties are periodically
-- updated by GameLift FleetIQ as part of its balancing activities to
-- optimize for availability and cost.
--
-- __Learn more__
--
-- <https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html GameLift FleetIQ Guide>
--
-- __Related actions__
--
-- CreateGameServerGroup | ListGameServerGroups | DescribeGameServerGroup |
-- UpdateGameServerGroup | DeleteGameServerGroup | ResumeGameServerGroup |
-- SuspendGameServerGroup | DescribeGameServerInstances |
-- <https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/reference-awssdk-fleetiq.html All APIs by task>
module Amazonka.GameLift.CreateGameServerGroup
  ( -- * Creating a Request
    CreateGameServerGroup (..),
    newCreateGameServerGroup,

    -- * Request Lenses
    createGameServerGroup_vpcSubnets,
    createGameServerGroup_balancingStrategy,
    createGameServerGroup_autoScalingPolicy,
    createGameServerGroup_gameServerProtectionPolicy,
    createGameServerGroup_tags,
    createGameServerGroup_gameServerGroupName,
    createGameServerGroup_roleArn,
    createGameServerGroup_minSize,
    createGameServerGroup_maxSize,
    createGameServerGroup_launchTemplate,
    createGameServerGroup_instanceDefinitions,

    -- * Destructuring the Response
    CreateGameServerGroupResponse (..),
    newCreateGameServerGroupResponse,

    -- * Response Lenses
    createGameServerGroupResponse_gameServerGroup,
    createGameServerGroupResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import Amazonka.GameLift.Types
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newCreateGameServerGroup' smart constructor.
data CreateGameServerGroup = CreateGameServerGroup'
  { -- | A list of virtual private cloud (VPC) subnets to use with instances in
    -- the game server group. By default, all GameLift FleetIQ-supported
    -- Availability Zones are used. You can use this parameter to specify VPCs
    -- that you\'ve set up. This property cannot be updated after the game
    -- server group is created, and the corresponding Auto Scaling group will
    -- always use the property value that is set with this request, even if the
    -- Auto Scaling group is updated directly.
    CreateGameServerGroup -> Maybe (NonEmpty Text)
vpcSubnets :: Prelude.Maybe (Prelude.NonEmpty Prelude.Text),
    -- | Indicates how 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.
    CreateGameServerGroup -> Maybe BalancingStrategy
balancingStrategy :: Prelude.Maybe BalancingStrategy,
    -- | Configuration settings to define a scaling policy for the Auto Scaling
    -- group that is optimized for game hosting. The scaling policy uses the
    -- metric @\"PercentUtilizedGameServers\"@ to maintain a buffer of idle
    -- game servers that can immediately accommodate new games and players.
    -- After the Auto Scaling group is created, update this value directly in
    -- the Auto Scaling group using the AWS console or APIs.
    CreateGameServerGroup -> Maybe GameServerGroupAutoScalingPolicy
autoScalingPolicy :: Prelude.Maybe GameServerGroupAutoScalingPolicy,
    -- | 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 AWS regardless
    -- of protection status. This property is set to @NO_PROTECTION@ by
    -- default.
    CreateGameServerGroup -> Maybe GameServerProtectionPolicy
gameServerProtectionPolicy :: Prelude.Maybe GameServerProtectionPolicy,
    -- | A list of labels to assign to the new game server group resource. Tags
    -- are developer-defined key-value pairs. Tagging AWS resources is useful
    -- for resource management, access management, and cost allocation. For
    -- more information, see
    -- <https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html Tagging AWS Resources>
    -- in the /AWS General Reference/. Once the resource is created, you can
    -- use TagResource, UntagResource, and ListTagsForResource to add, remove,
    -- and view tags, respectively. The maximum tag limit may be lower than
    -- stated. See the AWS General Reference for actual tagging limits.
    CreateGameServerGroup -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | An identifier for the new game server group. This value is used to
    -- generate unique ARN identifiers for the EC2 Auto Scaling group and the
    -- GameLift FleetIQ game server group. The name must be unique per Region
    -- per AWS account.
    CreateGameServerGroup -> Text
gameServerGroupName :: Prelude.Text,
    -- | The Amazon Resource Name
    -- (<https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html ARN>)
    -- for an IAM role that allows Amazon GameLift to access your EC2 Auto
    -- Scaling groups.
    CreateGameServerGroup -> Text
roleArn :: Prelude.Text,
    -- | The minimum number of instances allowed in the EC2 Auto Scaling group.
    -- During automatic scaling events, GameLift FleetIQ and EC2 do not scale
    -- down the group below this minimum. In production, this value should be
    -- set to at least 1. After the Auto Scaling group is created, update this
    -- value directly in the Auto Scaling group using the AWS console or APIs.
    CreateGameServerGroup -> Natural
minSize :: Prelude.Natural,
    -- | The maximum number of instances allowed in the EC2 Auto Scaling group.
    -- During automatic scaling events, GameLift FleetIQ and EC2 do not scale
    -- up the group above this maximum. After the Auto Scaling group is
    -- created, update this value directly in the Auto Scaling group using the
    -- AWS console or APIs.
    CreateGameServerGroup -> Natural
maxSize :: Prelude.Natural,
    -- | The EC2 launch template that contains configuration settings and game
    -- server code to be deployed to all instances in the game server group.
    -- You can specify the template using either the template name or ID. For
    -- help with creating a launch template, see
    -- <https://docs.aws.amazon.com/autoscaling/ec2/userguide/create-launch-template.html Creating a Launch Template for an Auto Scaling Group>
    -- in the /Amazon EC2 Auto Scaling User Guide/. After the Auto Scaling
    -- group is created, update this value directly in the Auto Scaling group
    -- using the AWS console or APIs.
    --
    -- If you specify network interfaces in your launch template, you must
    -- explicitly set the property @AssociatePublicIpAddress@ to \"true\". If
    -- no network interface is specified in the launch template, GameLift
    -- FleetIQ uses your account\'s default VPC.
    CreateGameServerGroup -> LaunchTemplateSpecification
launchTemplate :: LaunchTemplateSpecification,
    -- | The EC2 instance types and sizes to use in the Auto Scaling group. The
    -- instance definitions must specify at least two different instance types
    -- that are supported by GameLift FleetIQ. For more information on instance
    -- types, see
    -- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html EC2 Instance Types>
    -- 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
    -- <https://docs.aws.amazon.com/autoscaling/ec2/userguide/asg-instance-weighting.html Instance Weighting for Amazon EC2 Auto Scaling>
    -- in the Amazon EC2 Auto Scaling User Guide.
    CreateGameServerGroup -> NonEmpty InstanceDefinition
instanceDefinitions :: Prelude.NonEmpty InstanceDefinition
  }
  deriving (CreateGameServerGroup -> CreateGameServerGroup -> Bool
(CreateGameServerGroup -> CreateGameServerGroup -> Bool)
-> (CreateGameServerGroup -> CreateGameServerGroup -> Bool)
-> Eq CreateGameServerGroup
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateGameServerGroup -> CreateGameServerGroup -> Bool
$c/= :: CreateGameServerGroup -> CreateGameServerGroup -> Bool
== :: CreateGameServerGroup -> CreateGameServerGroup -> Bool
$c== :: CreateGameServerGroup -> CreateGameServerGroup -> Bool
Prelude.Eq, ReadPrec [CreateGameServerGroup]
ReadPrec CreateGameServerGroup
Int -> ReadS CreateGameServerGroup
ReadS [CreateGameServerGroup]
(Int -> ReadS CreateGameServerGroup)
-> ReadS [CreateGameServerGroup]
-> ReadPrec CreateGameServerGroup
-> ReadPrec [CreateGameServerGroup]
-> Read CreateGameServerGroup
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateGameServerGroup]
$creadListPrec :: ReadPrec [CreateGameServerGroup]
readPrec :: ReadPrec CreateGameServerGroup
$creadPrec :: ReadPrec CreateGameServerGroup
readList :: ReadS [CreateGameServerGroup]
$creadList :: ReadS [CreateGameServerGroup]
readsPrec :: Int -> ReadS CreateGameServerGroup
$creadsPrec :: Int -> ReadS CreateGameServerGroup
Prelude.Read, Int -> CreateGameServerGroup -> ShowS
[CreateGameServerGroup] -> ShowS
CreateGameServerGroup -> String
(Int -> CreateGameServerGroup -> ShowS)
-> (CreateGameServerGroup -> String)
-> ([CreateGameServerGroup] -> ShowS)
-> Show CreateGameServerGroup
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateGameServerGroup] -> ShowS
$cshowList :: [CreateGameServerGroup] -> ShowS
show :: CreateGameServerGroup -> String
$cshow :: CreateGameServerGroup -> String
showsPrec :: Int -> CreateGameServerGroup -> ShowS
$cshowsPrec :: Int -> CreateGameServerGroup -> ShowS
Prelude.Show, (forall x. CreateGameServerGroup -> Rep CreateGameServerGroup x)
-> (forall x. Rep CreateGameServerGroup x -> CreateGameServerGroup)
-> Generic CreateGameServerGroup
forall x. Rep CreateGameServerGroup x -> CreateGameServerGroup
forall x. CreateGameServerGroup -> Rep CreateGameServerGroup x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateGameServerGroup x -> CreateGameServerGroup
$cfrom :: forall x. CreateGameServerGroup -> Rep CreateGameServerGroup x
Prelude.Generic)

-- |
-- Create a value of 'CreateGameServerGroup' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'vpcSubnets', 'createGameServerGroup_vpcSubnets' - A list of virtual private cloud (VPC) subnets to use with instances in
-- the game server group. By default, all GameLift FleetIQ-supported
-- Availability Zones are used. You can use this parameter to specify VPCs
-- that you\'ve set up. This property cannot be updated after the game
-- server group is created, and the corresponding Auto Scaling group will
-- always use the property value that is set with this request, even if the
-- Auto Scaling group is updated directly.
--
-- 'balancingStrategy', 'createGameServerGroup_balancingStrategy' - Indicates how 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.
--
-- 'autoScalingPolicy', 'createGameServerGroup_autoScalingPolicy' - Configuration settings to define a scaling policy for the Auto Scaling
-- group that is optimized for game hosting. The scaling policy uses the
-- metric @\"PercentUtilizedGameServers\"@ to maintain a buffer of idle
-- game servers that can immediately accommodate new games and players.
-- After the Auto Scaling group is created, update this value directly in
-- the Auto Scaling group using the AWS console or APIs.
--
-- 'gameServerProtectionPolicy', 'createGameServerGroup_gameServerProtectionPolicy' - 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 AWS regardless
-- of protection status. This property is set to @NO_PROTECTION@ by
-- default.
--
-- 'tags', 'createGameServerGroup_tags' - A list of labels to assign to the new game server group resource. Tags
-- are developer-defined key-value pairs. Tagging AWS resources is useful
-- for resource management, access management, and cost allocation. For
-- more information, see
-- <https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html Tagging AWS Resources>
-- in the /AWS General Reference/. Once the resource is created, you can
-- use TagResource, UntagResource, and ListTagsForResource to add, remove,
-- and view tags, respectively. The maximum tag limit may be lower than
-- stated. See the AWS General Reference for actual tagging limits.
--
-- 'gameServerGroupName', 'createGameServerGroup_gameServerGroupName' - An identifier for the new game server group. This value is used to
-- generate unique ARN identifiers for the EC2 Auto Scaling group and the
-- GameLift FleetIQ game server group. The name must be unique per Region
-- per AWS account.
--
-- 'roleArn', 'createGameServerGroup_roleArn' - The Amazon Resource Name
-- (<https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html ARN>)
-- for an IAM role that allows Amazon GameLift to access your EC2 Auto
-- Scaling groups.
--
-- 'minSize', 'createGameServerGroup_minSize' - The minimum number of instances allowed in the EC2 Auto Scaling group.
-- During automatic scaling events, GameLift FleetIQ and EC2 do not scale
-- down the group below this minimum. In production, this value should be
-- set to at least 1. After the Auto Scaling group is created, update this
-- value directly in the Auto Scaling group using the AWS console or APIs.
--
-- 'maxSize', 'createGameServerGroup_maxSize' - The maximum number of instances allowed in the EC2 Auto Scaling group.
-- During automatic scaling events, GameLift FleetIQ and EC2 do not scale
-- up the group above this maximum. After the Auto Scaling group is
-- created, update this value directly in the Auto Scaling group using the
-- AWS console or APIs.
--
-- 'launchTemplate', 'createGameServerGroup_launchTemplate' - The EC2 launch template that contains configuration settings and game
-- server code to be deployed to all instances in the game server group.
-- You can specify the template using either the template name or ID. For
-- help with creating a launch template, see
-- <https://docs.aws.amazon.com/autoscaling/ec2/userguide/create-launch-template.html Creating a Launch Template for an Auto Scaling Group>
-- in the /Amazon EC2 Auto Scaling User Guide/. After the Auto Scaling
-- group is created, update this value directly in the Auto Scaling group
-- using the AWS console or APIs.
--
-- If you specify network interfaces in your launch template, you must
-- explicitly set the property @AssociatePublicIpAddress@ to \"true\". If
-- no network interface is specified in the launch template, GameLift
-- FleetIQ uses your account\'s default VPC.
--
-- 'instanceDefinitions', 'createGameServerGroup_instanceDefinitions' - The EC2 instance types and sizes to use in the Auto Scaling group. The
-- instance definitions must specify at least two different instance types
-- that are supported by GameLift FleetIQ. For more information on instance
-- types, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html EC2 Instance Types>
-- 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
-- <https://docs.aws.amazon.com/autoscaling/ec2/userguide/asg-instance-weighting.html Instance Weighting for Amazon EC2 Auto Scaling>
-- in the Amazon EC2 Auto Scaling User Guide.
newCreateGameServerGroup ::
  -- | 'gameServerGroupName'
  Prelude.Text ->
  -- | 'roleArn'
  Prelude.Text ->
  -- | 'minSize'
  Prelude.Natural ->
  -- | 'maxSize'
  Prelude.Natural ->
  -- | 'launchTemplate'
  LaunchTemplateSpecification ->
  -- | 'instanceDefinitions'
  Prelude.NonEmpty InstanceDefinition ->
  CreateGameServerGroup
newCreateGameServerGroup :: Text
-> Text
-> Natural
-> Natural
-> LaunchTemplateSpecification
-> NonEmpty InstanceDefinition
-> CreateGameServerGroup
newCreateGameServerGroup
  Text
pGameServerGroupName_
  Text
pRoleArn_
  Natural
pMinSize_
  Natural
pMaxSize_
  LaunchTemplateSpecification
pLaunchTemplate_
  NonEmpty InstanceDefinition
pInstanceDefinitions_ =
    CreateGameServerGroup' :: Maybe (NonEmpty Text)
-> Maybe BalancingStrategy
-> Maybe GameServerGroupAutoScalingPolicy
-> Maybe GameServerProtectionPolicy
-> Maybe [Tag]
-> Text
-> Text
-> Natural
-> Natural
-> LaunchTemplateSpecification
-> NonEmpty InstanceDefinition
-> CreateGameServerGroup
CreateGameServerGroup'
      { $sel:vpcSubnets:CreateGameServerGroup' :: Maybe (NonEmpty Text)
vpcSubnets =
          Maybe (NonEmpty Text)
forall a. Maybe a
Prelude.Nothing,
        $sel:balancingStrategy:CreateGameServerGroup' :: Maybe BalancingStrategy
balancingStrategy = Maybe BalancingStrategy
forall a. Maybe a
Prelude.Nothing,
        $sel:autoScalingPolicy:CreateGameServerGroup' :: Maybe GameServerGroupAutoScalingPolicy
autoScalingPolicy = Maybe GameServerGroupAutoScalingPolicy
forall a. Maybe a
Prelude.Nothing,
        $sel:gameServerProtectionPolicy:CreateGameServerGroup' :: Maybe GameServerProtectionPolicy
gameServerProtectionPolicy = Maybe GameServerProtectionPolicy
forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateGameServerGroup' :: Maybe [Tag]
tags = Maybe [Tag]
forall a. Maybe a
Prelude.Nothing,
        $sel:gameServerGroupName:CreateGameServerGroup' :: Text
gameServerGroupName = Text
pGameServerGroupName_,
        $sel:roleArn:CreateGameServerGroup' :: Text
roleArn = Text
pRoleArn_,
        $sel:minSize:CreateGameServerGroup' :: Natural
minSize = Natural
pMinSize_,
        $sel:maxSize:CreateGameServerGroup' :: Natural
maxSize = Natural
pMaxSize_,
        $sel:launchTemplate:CreateGameServerGroup' :: LaunchTemplateSpecification
launchTemplate = LaunchTemplateSpecification
pLaunchTemplate_,
        $sel:instanceDefinitions:CreateGameServerGroup' :: NonEmpty InstanceDefinition
instanceDefinitions =
          Tagged
  (NonEmpty InstanceDefinition)
  (Identity (NonEmpty InstanceDefinition))
-> Tagged
     (NonEmpty InstanceDefinition)
     (Identity (NonEmpty InstanceDefinition))
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced (Tagged
   (NonEmpty InstanceDefinition)
   (Identity (NonEmpty InstanceDefinition))
 -> Tagged
      (NonEmpty InstanceDefinition)
      (Identity (NonEmpty InstanceDefinition)))
-> NonEmpty InstanceDefinition -> NonEmpty InstanceDefinition
forall t b. AReview t b -> b -> t
Lens.# NonEmpty InstanceDefinition
pInstanceDefinitions_
      }

-- | A list of virtual private cloud (VPC) subnets to use with instances in
-- the game server group. By default, all GameLift FleetIQ-supported
-- Availability Zones are used. You can use this parameter to specify VPCs
-- that you\'ve set up. This property cannot be updated after the game
-- server group is created, and the corresponding Auto Scaling group will
-- always use the property value that is set with this request, even if the
-- Auto Scaling group is updated directly.
createGameServerGroup_vpcSubnets :: Lens.Lens' CreateGameServerGroup (Prelude.Maybe (Prelude.NonEmpty Prelude.Text))
createGameServerGroup_vpcSubnets :: (Maybe (NonEmpty Text) -> f (Maybe (NonEmpty Text)))
-> CreateGameServerGroup -> f CreateGameServerGroup
createGameServerGroup_vpcSubnets = (CreateGameServerGroup -> Maybe (NonEmpty Text))
-> (CreateGameServerGroup
    -> Maybe (NonEmpty Text) -> CreateGameServerGroup)
-> Lens
     CreateGameServerGroup
     CreateGameServerGroup
     (Maybe (NonEmpty Text))
     (Maybe (NonEmpty Text))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateGameServerGroup' {Maybe (NonEmpty Text)
vpcSubnets :: Maybe (NonEmpty Text)
$sel:vpcSubnets:CreateGameServerGroup' :: CreateGameServerGroup -> Maybe (NonEmpty Text)
vpcSubnets} -> Maybe (NonEmpty Text)
vpcSubnets) (\s :: CreateGameServerGroup
s@CreateGameServerGroup' {} Maybe (NonEmpty Text)
a -> CreateGameServerGroup
s {$sel:vpcSubnets:CreateGameServerGroup' :: Maybe (NonEmpty Text)
vpcSubnets = Maybe (NonEmpty Text)
a} :: CreateGameServerGroup) ((Maybe (NonEmpty Text) -> f (Maybe (NonEmpty Text)))
 -> CreateGameServerGroup -> f CreateGameServerGroup)
-> ((Maybe (NonEmpty Text) -> f (Maybe (NonEmpty Text)))
    -> Maybe (NonEmpty Text) -> f (Maybe (NonEmpty Text)))
-> (Maybe (NonEmpty Text) -> f (Maybe (NonEmpty Text)))
-> CreateGameServerGroup
-> f CreateGameServerGroup
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (NonEmpty Text) (NonEmpty Text) (NonEmpty Text) (NonEmpty Text)
-> Iso
     (Maybe (NonEmpty Text))
     (Maybe (NonEmpty Text))
     (Maybe (NonEmpty Text))
     (Maybe (NonEmpty Text))
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso
  (NonEmpty Text) (NonEmpty Text) (NonEmpty Text) (NonEmpty Text)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Indicates how 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.
createGameServerGroup_balancingStrategy :: Lens.Lens' CreateGameServerGroup (Prelude.Maybe BalancingStrategy)
createGameServerGroup_balancingStrategy :: (Maybe BalancingStrategy -> f (Maybe BalancingStrategy))
-> CreateGameServerGroup -> f CreateGameServerGroup
createGameServerGroup_balancingStrategy = (CreateGameServerGroup -> Maybe BalancingStrategy)
-> (CreateGameServerGroup
    -> Maybe BalancingStrategy -> CreateGameServerGroup)
-> Lens
     CreateGameServerGroup
     CreateGameServerGroup
     (Maybe BalancingStrategy)
     (Maybe BalancingStrategy)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateGameServerGroup' {Maybe BalancingStrategy
balancingStrategy :: Maybe BalancingStrategy
$sel:balancingStrategy:CreateGameServerGroup' :: CreateGameServerGroup -> Maybe BalancingStrategy
balancingStrategy} -> Maybe BalancingStrategy
balancingStrategy) (\s :: CreateGameServerGroup
s@CreateGameServerGroup' {} Maybe BalancingStrategy
a -> CreateGameServerGroup
s {$sel:balancingStrategy:CreateGameServerGroup' :: Maybe BalancingStrategy
balancingStrategy = Maybe BalancingStrategy
a} :: CreateGameServerGroup)

-- | Configuration settings to define a scaling policy for the Auto Scaling
-- group that is optimized for game hosting. The scaling policy uses the
-- metric @\"PercentUtilizedGameServers\"@ to maintain a buffer of idle
-- game servers that can immediately accommodate new games and players.
-- After the Auto Scaling group is created, update this value directly in
-- the Auto Scaling group using the AWS console or APIs.
createGameServerGroup_autoScalingPolicy :: Lens.Lens' CreateGameServerGroup (Prelude.Maybe GameServerGroupAutoScalingPolicy)
createGameServerGroup_autoScalingPolicy :: (Maybe GameServerGroupAutoScalingPolicy
 -> f (Maybe GameServerGroupAutoScalingPolicy))
-> CreateGameServerGroup -> f CreateGameServerGroup
createGameServerGroup_autoScalingPolicy = (CreateGameServerGroup -> Maybe GameServerGroupAutoScalingPolicy)
-> (CreateGameServerGroup
    -> Maybe GameServerGroupAutoScalingPolicy -> CreateGameServerGroup)
-> Lens
     CreateGameServerGroup
     CreateGameServerGroup
     (Maybe GameServerGroupAutoScalingPolicy)
     (Maybe GameServerGroupAutoScalingPolicy)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateGameServerGroup' {Maybe GameServerGroupAutoScalingPolicy
autoScalingPolicy :: Maybe GameServerGroupAutoScalingPolicy
$sel:autoScalingPolicy:CreateGameServerGroup' :: CreateGameServerGroup -> Maybe GameServerGroupAutoScalingPolicy
autoScalingPolicy} -> Maybe GameServerGroupAutoScalingPolicy
autoScalingPolicy) (\s :: CreateGameServerGroup
s@CreateGameServerGroup' {} Maybe GameServerGroupAutoScalingPolicy
a -> CreateGameServerGroup
s {$sel:autoScalingPolicy:CreateGameServerGroup' :: Maybe GameServerGroupAutoScalingPolicy
autoScalingPolicy = Maybe GameServerGroupAutoScalingPolicy
a} :: CreateGameServerGroup)

-- | 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 AWS regardless
-- of protection status. This property is set to @NO_PROTECTION@ by
-- default.
createGameServerGroup_gameServerProtectionPolicy :: Lens.Lens' CreateGameServerGroup (Prelude.Maybe GameServerProtectionPolicy)
createGameServerGroup_gameServerProtectionPolicy :: (Maybe GameServerProtectionPolicy
 -> f (Maybe GameServerProtectionPolicy))
-> CreateGameServerGroup -> f CreateGameServerGroup
createGameServerGroup_gameServerProtectionPolicy = (CreateGameServerGroup -> Maybe GameServerProtectionPolicy)
-> (CreateGameServerGroup
    -> Maybe GameServerProtectionPolicy -> CreateGameServerGroup)
-> Lens
     CreateGameServerGroup
     CreateGameServerGroup
     (Maybe GameServerProtectionPolicy)
     (Maybe GameServerProtectionPolicy)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateGameServerGroup' {Maybe GameServerProtectionPolicy
gameServerProtectionPolicy :: Maybe GameServerProtectionPolicy
$sel:gameServerProtectionPolicy:CreateGameServerGroup' :: CreateGameServerGroup -> Maybe GameServerProtectionPolicy
gameServerProtectionPolicy} -> Maybe GameServerProtectionPolicy
gameServerProtectionPolicy) (\s :: CreateGameServerGroup
s@CreateGameServerGroup' {} Maybe GameServerProtectionPolicy
a -> CreateGameServerGroup
s {$sel:gameServerProtectionPolicy:CreateGameServerGroup' :: Maybe GameServerProtectionPolicy
gameServerProtectionPolicy = Maybe GameServerProtectionPolicy
a} :: CreateGameServerGroup)

-- | A list of labels to assign to the new game server group resource. Tags
-- are developer-defined key-value pairs. Tagging AWS resources is useful
-- for resource management, access management, and cost allocation. For
-- more information, see
-- <https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html Tagging AWS Resources>
-- in the /AWS General Reference/. Once the resource is created, you can
-- use TagResource, UntagResource, and ListTagsForResource to add, remove,
-- and view tags, respectively. The maximum tag limit may be lower than
-- stated. See the AWS General Reference for actual tagging limits.
createGameServerGroup_tags :: Lens.Lens' CreateGameServerGroup (Prelude.Maybe [Tag])
createGameServerGroup_tags :: (Maybe [Tag] -> f (Maybe [Tag]))
-> CreateGameServerGroup -> f CreateGameServerGroup
createGameServerGroup_tags = (CreateGameServerGroup -> Maybe [Tag])
-> (CreateGameServerGroup -> Maybe [Tag] -> CreateGameServerGroup)
-> Lens
     CreateGameServerGroup
     CreateGameServerGroup
     (Maybe [Tag])
     (Maybe [Tag])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateGameServerGroup' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateGameServerGroup' :: CreateGameServerGroup -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateGameServerGroup
s@CreateGameServerGroup' {} Maybe [Tag]
a -> CreateGameServerGroup
s {$sel:tags:CreateGameServerGroup' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateGameServerGroup) ((Maybe [Tag] -> f (Maybe [Tag]))
 -> CreateGameServerGroup -> f CreateGameServerGroup)
-> ((Maybe [Tag] -> f (Maybe [Tag]))
    -> Maybe [Tag] -> f (Maybe [Tag]))
-> (Maybe [Tag] -> f (Maybe [Tag]))
-> CreateGameServerGroup
-> f CreateGameServerGroup
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Tag] [Tag] [Tag] [Tag]
-> Iso (Maybe [Tag]) (Maybe [Tag]) (Maybe [Tag]) (Maybe [Tag])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso [Tag] [Tag] [Tag] [Tag]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | An identifier for the new game server group. This value is used to
-- generate unique ARN identifiers for the EC2 Auto Scaling group and the
-- GameLift FleetIQ game server group. The name must be unique per Region
-- per AWS account.
createGameServerGroup_gameServerGroupName :: Lens.Lens' CreateGameServerGroup Prelude.Text
createGameServerGroup_gameServerGroupName :: (Text -> f Text)
-> CreateGameServerGroup -> f CreateGameServerGroup
createGameServerGroup_gameServerGroupName = (CreateGameServerGroup -> Text)
-> (CreateGameServerGroup -> Text -> CreateGameServerGroup)
-> Lens CreateGameServerGroup CreateGameServerGroup Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateGameServerGroup' {Text
gameServerGroupName :: Text
$sel:gameServerGroupName:CreateGameServerGroup' :: CreateGameServerGroup -> Text
gameServerGroupName} -> Text
gameServerGroupName) (\s :: CreateGameServerGroup
s@CreateGameServerGroup' {} Text
a -> CreateGameServerGroup
s {$sel:gameServerGroupName:CreateGameServerGroup' :: Text
gameServerGroupName = Text
a} :: CreateGameServerGroup)

-- | The Amazon Resource Name
-- (<https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html ARN>)
-- for an IAM role that allows Amazon GameLift to access your EC2 Auto
-- Scaling groups.
createGameServerGroup_roleArn :: Lens.Lens' CreateGameServerGroup Prelude.Text
createGameServerGroup_roleArn :: (Text -> f Text)
-> CreateGameServerGroup -> f CreateGameServerGroup
createGameServerGroup_roleArn = (CreateGameServerGroup -> Text)
-> (CreateGameServerGroup -> Text -> CreateGameServerGroup)
-> Lens CreateGameServerGroup CreateGameServerGroup Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateGameServerGroup' {Text
roleArn :: Text
$sel:roleArn:CreateGameServerGroup' :: CreateGameServerGroup -> Text
roleArn} -> Text
roleArn) (\s :: CreateGameServerGroup
s@CreateGameServerGroup' {} Text
a -> CreateGameServerGroup
s {$sel:roleArn:CreateGameServerGroup' :: Text
roleArn = Text
a} :: CreateGameServerGroup)

-- | The minimum number of instances allowed in the EC2 Auto Scaling group.
-- During automatic scaling events, GameLift FleetIQ and EC2 do not scale
-- down the group below this minimum. In production, this value should be
-- set to at least 1. After the Auto Scaling group is created, update this
-- value directly in the Auto Scaling group using the AWS console or APIs.
createGameServerGroup_minSize :: Lens.Lens' CreateGameServerGroup Prelude.Natural
createGameServerGroup_minSize :: (Natural -> f Natural)
-> CreateGameServerGroup -> f CreateGameServerGroup
createGameServerGroup_minSize = (CreateGameServerGroup -> Natural)
-> (CreateGameServerGroup -> Natural -> CreateGameServerGroup)
-> Lens CreateGameServerGroup CreateGameServerGroup Natural Natural
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateGameServerGroup' {Natural
minSize :: Natural
$sel:minSize:CreateGameServerGroup' :: CreateGameServerGroup -> Natural
minSize} -> Natural
minSize) (\s :: CreateGameServerGroup
s@CreateGameServerGroup' {} Natural
a -> CreateGameServerGroup
s {$sel:minSize:CreateGameServerGroup' :: Natural
minSize = Natural
a} :: CreateGameServerGroup)

-- | The maximum number of instances allowed in the EC2 Auto Scaling group.
-- During automatic scaling events, GameLift FleetIQ and EC2 do not scale
-- up the group above this maximum. After the Auto Scaling group is
-- created, update this value directly in the Auto Scaling group using the
-- AWS console or APIs.
createGameServerGroup_maxSize :: Lens.Lens' CreateGameServerGroup Prelude.Natural
createGameServerGroup_maxSize :: (Natural -> f Natural)
-> CreateGameServerGroup -> f CreateGameServerGroup
createGameServerGroup_maxSize = (CreateGameServerGroup -> Natural)
-> (CreateGameServerGroup -> Natural -> CreateGameServerGroup)
-> Lens CreateGameServerGroup CreateGameServerGroup Natural Natural
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateGameServerGroup' {Natural
maxSize :: Natural
$sel:maxSize:CreateGameServerGroup' :: CreateGameServerGroup -> Natural
maxSize} -> Natural
maxSize) (\s :: CreateGameServerGroup
s@CreateGameServerGroup' {} Natural
a -> CreateGameServerGroup
s {$sel:maxSize:CreateGameServerGroup' :: Natural
maxSize = Natural
a} :: CreateGameServerGroup)

-- | The EC2 launch template that contains configuration settings and game
-- server code to be deployed to all instances in the game server group.
-- You can specify the template using either the template name or ID. For
-- help with creating a launch template, see
-- <https://docs.aws.amazon.com/autoscaling/ec2/userguide/create-launch-template.html Creating a Launch Template for an Auto Scaling Group>
-- in the /Amazon EC2 Auto Scaling User Guide/. After the Auto Scaling
-- group is created, update this value directly in the Auto Scaling group
-- using the AWS console or APIs.
--
-- If you specify network interfaces in your launch template, you must
-- explicitly set the property @AssociatePublicIpAddress@ to \"true\". If
-- no network interface is specified in the launch template, GameLift
-- FleetIQ uses your account\'s default VPC.
createGameServerGroup_launchTemplate :: Lens.Lens' CreateGameServerGroup LaunchTemplateSpecification
createGameServerGroup_launchTemplate :: (LaunchTemplateSpecification -> f LaunchTemplateSpecification)
-> CreateGameServerGroup -> f CreateGameServerGroup
createGameServerGroup_launchTemplate = (CreateGameServerGroup -> LaunchTemplateSpecification)
-> (CreateGameServerGroup
    -> LaunchTemplateSpecification -> CreateGameServerGroup)
-> Lens
     CreateGameServerGroup
     CreateGameServerGroup
     LaunchTemplateSpecification
     LaunchTemplateSpecification
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateGameServerGroup' {LaunchTemplateSpecification
launchTemplate :: LaunchTemplateSpecification
$sel:launchTemplate:CreateGameServerGroup' :: CreateGameServerGroup -> LaunchTemplateSpecification
launchTemplate} -> LaunchTemplateSpecification
launchTemplate) (\s :: CreateGameServerGroup
s@CreateGameServerGroup' {} LaunchTemplateSpecification
a -> CreateGameServerGroup
s {$sel:launchTemplate:CreateGameServerGroup' :: LaunchTemplateSpecification
launchTemplate = LaunchTemplateSpecification
a} :: CreateGameServerGroup)

-- | The EC2 instance types and sizes to use in the Auto Scaling group. The
-- instance definitions must specify at least two different instance types
-- that are supported by GameLift FleetIQ. For more information on instance
-- types, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html EC2 Instance Types>
-- 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
-- <https://docs.aws.amazon.com/autoscaling/ec2/userguide/asg-instance-weighting.html Instance Weighting for Amazon EC2 Auto Scaling>
-- in the Amazon EC2 Auto Scaling User Guide.
createGameServerGroup_instanceDefinitions :: Lens.Lens' CreateGameServerGroup (Prelude.NonEmpty InstanceDefinition)
createGameServerGroup_instanceDefinitions :: (NonEmpty InstanceDefinition -> f (NonEmpty InstanceDefinition))
-> CreateGameServerGroup -> f CreateGameServerGroup
createGameServerGroup_instanceDefinitions = (CreateGameServerGroup -> NonEmpty InstanceDefinition)
-> (CreateGameServerGroup
    -> NonEmpty InstanceDefinition -> CreateGameServerGroup)
-> Lens
     CreateGameServerGroup
     CreateGameServerGroup
     (NonEmpty InstanceDefinition)
     (NonEmpty InstanceDefinition)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateGameServerGroup' {NonEmpty InstanceDefinition
instanceDefinitions :: NonEmpty InstanceDefinition
$sel:instanceDefinitions:CreateGameServerGroup' :: CreateGameServerGroup -> NonEmpty InstanceDefinition
instanceDefinitions} -> NonEmpty InstanceDefinition
instanceDefinitions) (\s :: CreateGameServerGroup
s@CreateGameServerGroup' {} NonEmpty InstanceDefinition
a -> CreateGameServerGroup
s {$sel:instanceDefinitions:CreateGameServerGroup' :: NonEmpty InstanceDefinition
instanceDefinitions = NonEmpty InstanceDefinition
a} :: CreateGameServerGroup) ((NonEmpty InstanceDefinition -> f (NonEmpty InstanceDefinition))
 -> CreateGameServerGroup -> f CreateGameServerGroup)
-> ((NonEmpty InstanceDefinition
     -> f (NonEmpty InstanceDefinition))
    -> NonEmpty InstanceDefinition -> f (NonEmpty InstanceDefinition))
-> (NonEmpty InstanceDefinition -> f (NonEmpty InstanceDefinition))
-> CreateGameServerGroup
-> f CreateGameServerGroup
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. (NonEmpty InstanceDefinition -> f (NonEmpty InstanceDefinition))
-> NonEmpty InstanceDefinition -> f (NonEmpty InstanceDefinition)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Core.AWSRequest CreateGameServerGroup where
  type
    AWSResponse CreateGameServerGroup =
      CreateGameServerGroupResponse
  request :: CreateGameServerGroup -> Request CreateGameServerGroup
request = Service -> CreateGameServerGroup -> Request CreateGameServerGroup
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON Service
defaultService
  response :: Logger
-> Service
-> Proxy CreateGameServerGroup
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateGameServerGroup)))
response =
    (Int
 -> ResponseHeaders
 -> Object
 -> Either String (AWSResponse CreateGameServerGroup))
-> Logger
-> Service
-> Proxy CreateGameServerGroup
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateGameServerGroup)))
forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe GameServerGroup -> Int -> CreateGameServerGroupResponse
CreateGameServerGroupResponse'
            (Maybe GameServerGroup -> Int -> CreateGameServerGroupResponse)
-> Either String (Maybe GameServerGroup)
-> Either String (Int -> CreateGameServerGroupResponse)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Either String (Maybe GameServerGroup)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"GameServerGroup")
            Either String (Int -> CreateGameServerGroupResponse)
-> Either String Int -> Either String CreateGameServerGroupResponse
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Int -> Either String Int
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (Int -> Int
forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable CreateGameServerGroup

instance Prelude.NFData CreateGameServerGroup

instance Core.ToHeaders CreateGameServerGroup where
  toHeaders :: CreateGameServerGroup -> ResponseHeaders
toHeaders =
    ResponseHeaders -> CreateGameServerGroup -> ResponseHeaders
forall a b. a -> b -> a
Prelude.const
      ( [ResponseHeaders] -> ResponseHeaders
forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"GameLift.CreateGameServerGroup" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Core.ToJSON CreateGameServerGroup where
  toJSON :: CreateGameServerGroup -> Value
toJSON CreateGameServerGroup' {Natural
Maybe [Tag]
Maybe (NonEmpty Text)
Maybe BalancingStrategy
Maybe GameServerProtectionPolicy
Maybe GameServerGroupAutoScalingPolicy
NonEmpty InstanceDefinition
Text
LaunchTemplateSpecification
instanceDefinitions :: NonEmpty InstanceDefinition
launchTemplate :: LaunchTemplateSpecification
maxSize :: Natural
minSize :: Natural
roleArn :: Text
gameServerGroupName :: Text
tags :: Maybe [Tag]
gameServerProtectionPolicy :: Maybe GameServerProtectionPolicy
autoScalingPolicy :: Maybe GameServerGroupAutoScalingPolicy
balancingStrategy :: Maybe BalancingStrategy
vpcSubnets :: Maybe (NonEmpty Text)
$sel:instanceDefinitions:CreateGameServerGroup' :: CreateGameServerGroup -> NonEmpty InstanceDefinition
$sel:launchTemplate:CreateGameServerGroup' :: CreateGameServerGroup -> LaunchTemplateSpecification
$sel:maxSize:CreateGameServerGroup' :: CreateGameServerGroup -> Natural
$sel:minSize:CreateGameServerGroup' :: CreateGameServerGroup -> Natural
$sel:roleArn:CreateGameServerGroup' :: CreateGameServerGroup -> Text
$sel:gameServerGroupName:CreateGameServerGroup' :: CreateGameServerGroup -> Text
$sel:tags:CreateGameServerGroup' :: CreateGameServerGroup -> Maybe [Tag]
$sel:gameServerProtectionPolicy:CreateGameServerGroup' :: CreateGameServerGroup -> Maybe GameServerProtectionPolicy
$sel:autoScalingPolicy:CreateGameServerGroup' :: CreateGameServerGroup -> Maybe GameServerGroupAutoScalingPolicy
$sel:balancingStrategy:CreateGameServerGroup' :: CreateGameServerGroup -> Maybe BalancingStrategy
$sel:vpcSubnets:CreateGameServerGroup' :: CreateGameServerGroup -> Maybe (NonEmpty Text)
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"VpcSubnets" Text -> NonEmpty Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (NonEmpty Text -> Pair) -> Maybe (NonEmpty Text) -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (NonEmpty Text)
vpcSubnets,
            (Text
"BalancingStrategy" Text -> BalancingStrategy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (BalancingStrategy -> Pair)
-> Maybe BalancingStrategy -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe BalancingStrategy
balancingStrategy,
            (Text
"AutoScalingPolicy" Text -> GameServerGroupAutoScalingPolicy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (GameServerGroupAutoScalingPolicy -> Pair)
-> Maybe GameServerGroupAutoScalingPolicy -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe GameServerGroupAutoScalingPolicy
autoScalingPolicy,
            (Text
"GameServerProtectionPolicy" Text -> GameServerProtectionPolicy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (GameServerProtectionPolicy -> Pair)
-> Maybe GameServerProtectionPolicy -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe GameServerProtectionPolicy
gameServerProtectionPolicy,
            (Text
"Tags" Text -> [Tag] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) ([Tag] -> Pair) -> Maybe [Tag] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Tag]
tags,
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just
              (Text
"GameServerGroupName" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Text
gameServerGroupName),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"RoleArn" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Text
roleArn),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"MinSize" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Natural
minSize),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"MaxSize" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Natural
maxSize),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just
              (Text
"LaunchTemplate" Text -> LaunchTemplateSpecification -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= LaunchTemplateSpecification
launchTemplate),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just
              (Text
"InstanceDefinitions" Text -> NonEmpty InstanceDefinition -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= NonEmpty InstanceDefinition
instanceDefinitions)
          ]
      )

instance Core.ToPath CreateGameServerGroup where
  toPath :: CreateGameServerGroup -> ByteString
toPath = ByteString -> CreateGameServerGroup -> ByteString
forall a b. a -> b -> a
Prelude.const ByteString
"/"

instance Core.ToQuery CreateGameServerGroup where
  toQuery :: CreateGameServerGroup -> QueryString
toQuery = QueryString -> CreateGameServerGroup -> QueryString
forall a b. a -> b -> a
Prelude.const QueryString
forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newCreateGameServerGroupResponse' smart constructor.
data CreateGameServerGroupResponse = CreateGameServerGroupResponse'
  { -- | The newly created game server group object, including the new ARN value
    -- for the GameLift FleetIQ game server group and the object\'s status. The
    -- EC2 Auto Scaling group ARN is initially null, since the group has not
    -- yet been created. This value is added once the game server group status
    -- reaches @ACTIVE@.
    CreateGameServerGroupResponse -> Maybe GameServerGroup
gameServerGroup :: Prelude.Maybe GameServerGroup,
    -- | The response's http status code.
    CreateGameServerGroupResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateGameServerGroupResponse
-> CreateGameServerGroupResponse -> Bool
(CreateGameServerGroupResponse
 -> CreateGameServerGroupResponse -> Bool)
-> (CreateGameServerGroupResponse
    -> CreateGameServerGroupResponse -> Bool)
-> Eq CreateGameServerGroupResponse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateGameServerGroupResponse
-> CreateGameServerGroupResponse -> Bool
$c/= :: CreateGameServerGroupResponse
-> CreateGameServerGroupResponse -> Bool
== :: CreateGameServerGroupResponse
-> CreateGameServerGroupResponse -> Bool
$c== :: CreateGameServerGroupResponse
-> CreateGameServerGroupResponse -> Bool
Prelude.Eq, ReadPrec [CreateGameServerGroupResponse]
ReadPrec CreateGameServerGroupResponse
Int -> ReadS CreateGameServerGroupResponse
ReadS [CreateGameServerGroupResponse]
(Int -> ReadS CreateGameServerGroupResponse)
-> ReadS [CreateGameServerGroupResponse]
-> ReadPrec CreateGameServerGroupResponse
-> ReadPrec [CreateGameServerGroupResponse]
-> Read CreateGameServerGroupResponse
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateGameServerGroupResponse]
$creadListPrec :: ReadPrec [CreateGameServerGroupResponse]
readPrec :: ReadPrec CreateGameServerGroupResponse
$creadPrec :: ReadPrec CreateGameServerGroupResponse
readList :: ReadS [CreateGameServerGroupResponse]
$creadList :: ReadS [CreateGameServerGroupResponse]
readsPrec :: Int -> ReadS CreateGameServerGroupResponse
$creadsPrec :: Int -> ReadS CreateGameServerGroupResponse
Prelude.Read, Int -> CreateGameServerGroupResponse -> ShowS
[CreateGameServerGroupResponse] -> ShowS
CreateGameServerGroupResponse -> String
(Int -> CreateGameServerGroupResponse -> ShowS)
-> (CreateGameServerGroupResponse -> String)
-> ([CreateGameServerGroupResponse] -> ShowS)
-> Show CreateGameServerGroupResponse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateGameServerGroupResponse] -> ShowS
$cshowList :: [CreateGameServerGroupResponse] -> ShowS
show :: CreateGameServerGroupResponse -> String
$cshow :: CreateGameServerGroupResponse -> String
showsPrec :: Int -> CreateGameServerGroupResponse -> ShowS
$cshowsPrec :: Int -> CreateGameServerGroupResponse -> ShowS
Prelude.Show, (forall x.
 CreateGameServerGroupResponse
 -> Rep CreateGameServerGroupResponse x)
-> (forall x.
    Rep CreateGameServerGroupResponse x
    -> CreateGameServerGroupResponse)
-> Generic CreateGameServerGroupResponse
forall x.
Rep CreateGameServerGroupResponse x
-> CreateGameServerGroupResponse
forall x.
CreateGameServerGroupResponse
-> Rep CreateGameServerGroupResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateGameServerGroupResponse x
-> CreateGameServerGroupResponse
$cfrom :: forall x.
CreateGameServerGroupResponse
-> Rep CreateGameServerGroupResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateGameServerGroupResponse' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'gameServerGroup', 'createGameServerGroupResponse_gameServerGroup' - The newly created game server group object, including the new ARN value
-- for the GameLift FleetIQ game server group and the object\'s status. The
-- EC2 Auto Scaling group ARN is initially null, since the group has not
-- yet been created. This value is added once the game server group status
-- reaches @ACTIVE@.
--
-- 'httpStatus', 'createGameServerGroupResponse_httpStatus' - The response's http status code.
newCreateGameServerGroupResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateGameServerGroupResponse
newCreateGameServerGroupResponse :: Int -> CreateGameServerGroupResponse
newCreateGameServerGroupResponse Int
pHttpStatus_ =
  CreateGameServerGroupResponse' :: Maybe GameServerGroup -> Int -> CreateGameServerGroupResponse
CreateGameServerGroupResponse'
    { $sel:gameServerGroup:CreateGameServerGroupResponse' :: Maybe GameServerGroup
gameServerGroup =
        Maybe GameServerGroup
forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateGameServerGroupResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The newly created game server group object, including the new ARN value
-- for the GameLift FleetIQ game server group and the object\'s status. The
-- EC2 Auto Scaling group ARN is initially null, since the group has not
-- yet been created. This value is added once the game server group status
-- reaches @ACTIVE@.
createGameServerGroupResponse_gameServerGroup :: Lens.Lens' CreateGameServerGroupResponse (Prelude.Maybe GameServerGroup)
createGameServerGroupResponse_gameServerGroup :: (Maybe GameServerGroup -> f (Maybe GameServerGroup))
-> CreateGameServerGroupResponse -> f CreateGameServerGroupResponse
createGameServerGroupResponse_gameServerGroup = (CreateGameServerGroupResponse -> Maybe GameServerGroup)
-> (CreateGameServerGroupResponse
    -> Maybe GameServerGroup -> CreateGameServerGroupResponse)
-> Lens
     CreateGameServerGroupResponse
     CreateGameServerGroupResponse
     (Maybe GameServerGroup)
     (Maybe GameServerGroup)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateGameServerGroupResponse' {Maybe GameServerGroup
gameServerGroup :: Maybe GameServerGroup
$sel:gameServerGroup:CreateGameServerGroupResponse' :: CreateGameServerGroupResponse -> Maybe GameServerGroup
gameServerGroup} -> Maybe GameServerGroup
gameServerGroup) (\s :: CreateGameServerGroupResponse
s@CreateGameServerGroupResponse' {} Maybe GameServerGroup
a -> CreateGameServerGroupResponse
s {$sel:gameServerGroup:CreateGameServerGroupResponse' :: Maybe GameServerGroup
gameServerGroup = Maybe GameServerGroup
a} :: CreateGameServerGroupResponse)

-- | The response's http status code.
createGameServerGroupResponse_httpStatus :: Lens.Lens' CreateGameServerGroupResponse Prelude.Int
createGameServerGroupResponse_httpStatus :: (Int -> f Int)
-> CreateGameServerGroupResponse -> f CreateGameServerGroupResponse
createGameServerGroupResponse_httpStatus = (CreateGameServerGroupResponse -> Int)
-> (CreateGameServerGroupResponse
    -> Int -> CreateGameServerGroupResponse)
-> Lens
     CreateGameServerGroupResponse CreateGameServerGroupResponse Int Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateGameServerGroupResponse' {Int
httpStatus :: Int
$sel:httpStatus:CreateGameServerGroupResponse' :: CreateGameServerGroupResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: CreateGameServerGroupResponse
s@CreateGameServerGroupResponse' {} Int
a -> CreateGameServerGroupResponse
s {$sel:httpStatus:CreateGameServerGroupResponse' :: Int
httpStatus = Int
a} :: CreateGameServerGroupResponse)

instance Prelude.NFData CreateGameServerGroupResponse