{-# 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.EC2.CreateFleet
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Launches an EC2 Fleet.
--
-- You can create a single EC2 Fleet that includes multiple launch
-- specifications that vary by instance type, AMI, Availability Zone, or
-- subnet.
--
-- For more information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet.html EC2 Fleet>
-- in the /Amazon EC2 User Guide/.
module Amazonka.EC2.CreateFleet
  ( -- * Creating a Request
    CreateFleet (..),
    newCreateFleet,

    -- * Request Lenses
    createFleet_clientToken,
    createFleet_context,
    createFleet_dryRun,
    createFleet_excessCapacityTerminationPolicy,
    createFleet_onDemandOptions,
    createFleet_replaceUnhealthyInstances,
    createFleet_spotOptions,
    createFleet_tagSpecifications,
    createFleet_terminateInstancesWithExpiration,
    createFleet_type,
    createFleet_validFrom,
    createFleet_validUntil,
    createFleet_launchTemplateConfigs,
    createFleet_targetCapacitySpecification,

    -- * Destructuring the Response
    CreateFleetResponse (..),
    newCreateFleetResponse,

    -- * Response Lenses
    createFleetResponse_errors,
    createFleetResponse_fleetId,
    createFleetResponse_instances,
    createFleetResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.EC2.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newCreateFleet' smart constructor.
data CreateFleet = CreateFleet'
  { -- | Unique, case-sensitive identifier that you provide to ensure the
    -- idempotency of the request. For more information, see
    -- <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html Ensuring idempotency>.
    CreateFleet -> Maybe Text
clientToken :: Prelude.Maybe Prelude.Text,
    -- | Reserved.
    CreateFleet -> Maybe Text
context :: Prelude.Maybe Prelude.Text,
    -- | Checks whether you have the required permissions for the action, without
    -- actually making the request, and provides an error response. If you have
    -- the required permissions, the error response is @DryRunOperation@.
    -- Otherwise, it is @UnauthorizedOperation@.
    CreateFleet -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
    -- | Indicates whether running instances should be terminated if the total
    -- target capacity of the EC2 Fleet is decreased below the current size of
    -- the EC2 Fleet.
    CreateFleet -> Maybe FleetExcessCapacityTerminationPolicy
excessCapacityTerminationPolicy :: Prelude.Maybe FleetExcessCapacityTerminationPolicy,
    -- | Describes the configuration of On-Demand Instances in an EC2 Fleet.
    CreateFleet -> Maybe OnDemandOptionsRequest
onDemandOptions :: Prelude.Maybe OnDemandOptionsRequest,
    -- | Indicates whether EC2 Fleet should replace unhealthy Spot Instances.
    -- Supported only for fleets of type @maintain@. For more information, see
    -- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html#ec2-fleet-health-checks EC2 Fleet health checks>
    -- in the /Amazon EC2 User Guide/.
    CreateFleet -> Maybe Bool
replaceUnhealthyInstances :: Prelude.Maybe Prelude.Bool,
    -- | Describes the configuration of Spot Instances in an EC2 Fleet.
    CreateFleet -> Maybe SpotOptionsRequest
spotOptions :: Prelude.Maybe SpotOptionsRequest,
    -- | The key-value pair for tagging the EC2 Fleet request on creation. For
    -- more information, see
    -- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#tag-resources Tagging your resources>.
    --
    -- If the fleet type is @instant@, specify a resource type of @fleet@ to
    -- tag the fleet or @instance@ to tag the instances at launch.
    --
    -- If the fleet type is @maintain@ or @request@, specify a resource type of
    -- @fleet@ to tag the fleet. You cannot specify a resource type of
    -- @instance@. To tag instances at launch, specify the tags in a
    -- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html#create-launch-template launch template>.
    CreateFleet -> Maybe [TagSpecification]
tagSpecifications :: Prelude.Maybe [TagSpecification],
    -- | Indicates whether running instances should be terminated when the EC2
    -- Fleet expires.
    CreateFleet -> Maybe Bool
terminateInstancesWithExpiration :: Prelude.Maybe Prelude.Bool,
    -- | The fleet type. The default value is @maintain@.
    --
    -- -   @maintain@ - The EC2 Fleet places an asynchronous request for your
    --     desired capacity, and continues to maintain your desired Spot
    --     capacity by replenishing interrupted Spot Instances.
    --
    -- -   @request@ - The EC2 Fleet places an asynchronous one-time request
    --     for your desired capacity, but does submit Spot requests in
    --     alternative capacity pools if Spot capacity is unavailable, and does
    --     not maintain Spot capacity if Spot Instances are interrupted.
    --
    -- -   @instant@ - The EC2 Fleet places a synchronous one-time request for
    --     your desired capacity, and returns errors for any instances that
    --     could not be launched.
    --
    -- For more information, see
    -- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-request-type.html EC2 Fleet request types>
    -- in the /Amazon EC2 User Guide/.
    CreateFleet -> Maybe FleetType
type' :: Prelude.Maybe FleetType,
    -- | The start date and time of the request, in UTC format (for example,
    -- /YYYY/-/MM/-/DD/T/HH/:/MM/:/SS/Z). The default is to start fulfilling
    -- the request immediately.
    CreateFleet -> Maybe ISO8601
validFrom :: Prelude.Maybe Data.ISO8601,
    -- | The end date and time of the request, in UTC format (for example,
    -- /YYYY/-/MM/-/DD/T/HH/:/MM/:/SS/Z). At this point, no new EC2 Fleet
    -- requests are placed or able to fulfill the request. If no value is
    -- specified, the request remains until you cancel it.
    CreateFleet -> Maybe ISO8601
validUntil :: Prelude.Maybe Data.ISO8601,
    -- | The configuration for the EC2 Fleet.
    CreateFleet -> [FleetLaunchTemplateConfigRequest]
launchTemplateConfigs :: [FleetLaunchTemplateConfigRequest],
    -- | The number of units to request.
    CreateFleet -> TargetCapacitySpecificationRequest
targetCapacitySpecification :: TargetCapacitySpecificationRequest
  }
  deriving (CreateFleet -> CreateFleet -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateFleet -> CreateFleet -> Bool
$c/= :: CreateFleet -> CreateFleet -> Bool
== :: CreateFleet -> CreateFleet -> Bool
$c== :: CreateFleet -> CreateFleet -> Bool
Prelude.Eq, ReadPrec [CreateFleet]
ReadPrec CreateFleet
Int -> ReadS CreateFleet
ReadS [CreateFleet]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateFleet]
$creadListPrec :: ReadPrec [CreateFleet]
readPrec :: ReadPrec CreateFleet
$creadPrec :: ReadPrec CreateFleet
readList :: ReadS [CreateFleet]
$creadList :: ReadS [CreateFleet]
readsPrec :: Int -> ReadS CreateFleet
$creadsPrec :: Int -> ReadS CreateFleet
Prelude.Read, Int -> CreateFleet -> ShowS
[CreateFleet] -> ShowS
CreateFleet -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateFleet] -> ShowS
$cshowList :: [CreateFleet] -> ShowS
show :: CreateFleet -> String
$cshow :: CreateFleet -> String
showsPrec :: Int -> CreateFleet -> ShowS
$cshowsPrec :: Int -> CreateFleet -> ShowS
Prelude.Show, forall x. Rep CreateFleet x -> CreateFleet
forall x. CreateFleet -> Rep CreateFleet x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateFleet x -> CreateFleet
$cfrom :: forall x. CreateFleet -> Rep CreateFleet x
Prelude.Generic)

-- |
-- Create a value of 'CreateFleet' 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:
--
-- 'clientToken', 'createFleet_clientToken' - Unique, case-sensitive identifier that you provide to ensure the
-- idempotency of the request. For more information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html Ensuring idempotency>.
--
-- 'context', 'createFleet_context' - Reserved.
--
-- 'dryRun', 'createFleet_dryRun' - Checks whether you have the required permissions for the action, without
-- actually making the request, and provides an error response. If you have
-- the required permissions, the error response is @DryRunOperation@.
-- Otherwise, it is @UnauthorizedOperation@.
--
-- 'excessCapacityTerminationPolicy', 'createFleet_excessCapacityTerminationPolicy' - Indicates whether running instances should be terminated if the total
-- target capacity of the EC2 Fleet is decreased below the current size of
-- the EC2 Fleet.
--
-- 'onDemandOptions', 'createFleet_onDemandOptions' - Describes the configuration of On-Demand Instances in an EC2 Fleet.
--
-- 'replaceUnhealthyInstances', 'createFleet_replaceUnhealthyInstances' - Indicates whether EC2 Fleet should replace unhealthy Spot Instances.
-- Supported only for fleets of type @maintain@. For more information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html#ec2-fleet-health-checks EC2 Fleet health checks>
-- in the /Amazon EC2 User Guide/.
--
-- 'spotOptions', 'createFleet_spotOptions' - Describes the configuration of Spot Instances in an EC2 Fleet.
--
-- 'tagSpecifications', 'createFleet_tagSpecifications' - The key-value pair for tagging the EC2 Fleet request on creation. For
-- more information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#tag-resources Tagging your resources>.
--
-- If the fleet type is @instant@, specify a resource type of @fleet@ to
-- tag the fleet or @instance@ to tag the instances at launch.
--
-- If the fleet type is @maintain@ or @request@, specify a resource type of
-- @fleet@ to tag the fleet. You cannot specify a resource type of
-- @instance@. To tag instances at launch, specify the tags in a
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html#create-launch-template launch template>.
--
-- 'terminateInstancesWithExpiration', 'createFleet_terminateInstancesWithExpiration' - Indicates whether running instances should be terminated when the EC2
-- Fleet expires.
--
-- 'type'', 'createFleet_type' - The fleet type. The default value is @maintain@.
--
-- -   @maintain@ - The EC2 Fleet places an asynchronous request for your
--     desired capacity, and continues to maintain your desired Spot
--     capacity by replenishing interrupted Spot Instances.
--
-- -   @request@ - The EC2 Fleet places an asynchronous one-time request
--     for your desired capacity, but does submit Spot requests in
--     alternative capacity pools if Spot capacity is unavailable, and does
--     not maintain Spot capacity if Spot Instances are interrupted.
--
-- -   @instant@ - The EC2 Fleet places a synchronous one-time request for
--     your desired capacity, and returns errors for any instances that
--     could not be launched.
--
-- For more information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-request-type.html EC2 Fleet request types>
-- in the /Amazon EC2 User Guide/.
--
-- 'validFrom', 'createFleet_validFrom' - The start date and time of the request, in UTC format (for example,
-- /YYYY/-/MM/-/DD/T/HH/:/MM/:/SS/Z). The default is to start fulfilling
-- the request immediately.
--
-- 'validUntil', 'createFleet_validUntil' - The end date and time of the request, in UTC format (for example,
-- /YYYY/-/MM/-/DD/T/HH/:/MM/:/SS/Z). At this point, no new EC2 Fleet
-- requests are placed or able to fulfill the request. If no value is
-- specified, the request remains until you cancel it.
--
-- 'launchTemplateConfigs', 'createFleet_launchTemplateConfigs' - The configuration for the EC2 Fleet.
--
-- 'targetCapacitySpecification', 'createFleet_targetCapacitySpecification' - The number of units to request.
newCreateFleet ::
  -- | 'targetCapacitySpecification'
  TargetCapacitySpecificationRequest ->
  CreateFleet
newCreateFleet :: TargetCapacitySpecificationRequest -> CreateFleet
newCreateFleet TargetCapacitySpecificationRequest
pTargetCapacitySpecification_ =
  CreateFleet'
    { $sel:clientToken:CreateFleet' :: Maybe Text
clientToken = forall a. Maybe a
Prelude.Nothing,
      $sel:context:CreateFleet' :: Maybe Text
context = forall a. Maybe a
Prelude.Nothing,
      $sel:dryRun:CreateFleet' :: Maybe Bool
dryRun = forall a. Maybe a
Prelude.Nothing,
      $sel:excessCapacityTerminationPolicy:CreateFleet' :: Maybe FleetExcessCapacityTerminationPolicy
excessCapacityTerminationPolicy = forall a. Maybe a
Prelude.Nothing,
      $sel:onDemandOptions:CreateFleet' :: Maybe OnDemandOptionsRequest
onDemandOptions = forall a. Maybe a
Prelude.Nothing,
      $sel:replaceUnhealthyInstances:CreateFleet' :: Maybe Bool
replaceUnhealthyInstances = forall a. Maybe a
Prelude.Nothing,
      $sel:spotOptions:CreateFleet' :: Maybe SpotOptionsRequest
spotOptions = forall a. Maybe a
Prelude.Nothing,
      $sel:tagSpecifications:CreateFleet' :: Maybe [TagSpecification]
tagSpecifications = forall a. Maybe a
Prelude.Nothing,
      $sel:terminateInstancesWithExpiration:CreateFleet' :: Maybe Bool
terminateInstancesWithExpiration = forall a. Maybe a
Prelude.Nothing,
      $sel:type':CreateFleet' :: Maybe FleetType
type' = forall a. Maybe a
Prelude.Nothing,
      $sel:validFrom:CreateFleet' :: Maybe ISO8601
validFrom = forall a. Maybe a
Prelude.Nothing,
      $sel:validUntil:CreateFleet' :: Maybe ISO8601
validUntil = forall a. Maybe a
Prelude.Nothing,
      $sel:launchTemplateConfigs:CreateFleet' :: [FleetLaunchTemplateConfigRequest]
launchTemplateConfigs = forall a. Monoid a => a
Prelude.mempty,
      $sel:targetCapacitySpecification:CreateFleet' :: TargetCapacitySpecificationRequest
targetCapacitySpecification =
        TargetCapacitySpecificationRequest
pTargetCapacitySpecification_
    }

-- | Unique, case-sensitive identifier that you provide to ensure the
-- idempotency of the request. For more information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html Ensuring idempotency>.
createFleet_clientToken :: Lens.Lens' CreateFleet (Prelude.Maybe Prelude.Text)
createFleet_clientToken :: Lens' CreateFleet (Maybe Text)
createFleet_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleet' {Maybe Text
clientToken :: Maybe Text
$sel:clientToken:CreateFleet' :: CreateFleet -> Maybe Text
clientToken} -> Maybe Text
clientToken) (\s :: CreateFleet
s@CreateFleet' {} Maybe Text
a -> CreateFleet
s {$sel:clientToken:CreateFleet' :: Maybe Text
clientToken = Maybe Text
a} :: CreateFleet)

-- | Reserved.
createFleet_context :: Lens.Lens' CreateFleet (Prelude.Maybe Prelude.Text)
createFleet_context :: Lens' CreateFleet (Maybe Text)
createFleet_context = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleet' {Maybe Text
context :: Maybe Text
$sel:context:CreateFleet' :: CreateFleet -> Maybe Text
context} -> Maybe Text
context) (\s :: CreateFleet
s@CreateFleet' {} Maybe Text
a -> CreateFleet
s {$sel:context:CreateFleet' :: Maybe Text
context = Maybe Text
a} :: CreateFleet)

-- | Checks whether you have the required permissions for the action, without
-- actually making the request, and provides an error response. If you have
-- the required permissions, the error response is @DryRunOperation@.
-- Otherwise, it is @UnauthorizedOperation@.
createFleet_dryRun :: Lens.Lens' CreateFleet (Prelude.Maybe Prelude.Bool)
createFleet_dryRun :: Lens' CreateFleet (Maybe Bool)
createFleet_dryRun = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleet' {Maybe Bool
dryRun :: Maybe Bool
$sel:dryRun:CreateFleet' :: CreateFleet -> Maybe Bool
dryRun} -> Maybe Bool
dryRun) (\s :: CreateFleet
s@CreateFleet' {} Maybe Bool
a -> CreateFleet
s {$sel:dryRun:CreateFleet' :: Maybe Bool
dryRun = Maybe Bool
a} :: CreateFleet)

-- | Indicates whether running instances should be terminated if the total
-- target capacity of the EC2 Fleet is decreased below the current size of
-- the EC2 Fleet.
createFleet_excessCapacityTerminationPolicy :: Lens.Lens' CreateFleet (Prelude.Maybe FleetExcessCapacityTerminationPolicy)
createFleet_excessCapacityTerminationPolicy :: Lens' CreateFleet (Maybe FleetExcessCapacityTerminationPolicy)
createFleet_excessCapacityTerminationPolicy = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleet' {Maybe FleetExcessCapacityTerminationPolicy
excessCapacityTerminationPolicy :: Maybe FleetExcessCapacityTerminationPolicy
$sel:excessCapacityTerminationPolicy:CreateFleet' :: CreateFleet -> Maybe FleetExcessCapacityTerminationPolicy
excessCapacityTerminationPolicy} -> Maybe FleetExcessCapacityTerminationPolicy
excessCapacityTerminationPolicy) (\s :: CreateFleet
s@CreateFleet' {} Maybe FleetExcessCapacityTerminationPolicy
a -> CreateFleet
s {$sel:excessCapacityTerminationPolicy:CreateFleet' :: Maybe FleetExcessCapacityTerminationPolicy
excessCapacityTerminationPolicy = Maybe FleetExcessCapacityTerminationPolicy
a} :: CreateFleet)

-- | Describes the configuration of On-Demand Instances in an EC2 Fleet.
createFleet_onDemandOptions :: Lens.Lens' CreateFleet (Prelude.Maybe OnDemandOptionsRequest)
createFleet_onDemandOptions :: Lens' CreateFleet (Maybe OnDemandOptionsRequest)
createFleet_onDemandOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleet' {Maybe OnDemandOptionsRequest
onDemandOptions :: Maybe OnDemandOptionsRequest
$sel:onDemandOptions:CreateFleet' :: CreateFleet -> Maybe OnDemandOptionsRequest
onDemandOptions} -> Maybe OnDemandOptionsRequest
onDemandOptions) (\s :: CreateFleet
s@CreateFleet' {} Maybe OnDemandOptionsRequest
a -> CreateFleet
s {$sel:onDemandOptions:CreateFleet' :: Maybe OnDemandOptionsRequest
onDemandOptions = Maybe OnDemandOptionsRequest
a} :: CreateFleet)

-- | Indicates whether EC2 Fleet should replace unhealthy Spot Instances.
-- Supported only for fleets of type @maintain@. For more information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html#ec2-fleet-health-checks EC2 Fleet health checks>
-- in the /Amazon EC2 User Guide/.
createFleet_replaceUnhealthyInstances :: Lens.Lens' CreateFleet (Prelude.Maybe Prelude.Bool)
createFleet_replaceUnhealthyInstances :: Lens' CreateFleet (Maybe Bool)
createFleet_replaceUnhealthyInstances = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleet' {Maybe Bool
replaceUnhealthyInstances :: Maybe Bool
$sel:replaceUnhealthyInstances:CreateFleet' :: CreateFleet -> Maybe Bool
replaceUnhealthyInstances} -> Maybe Bool
replaceUnhealthyInstances) (\s :: CreateFleet
s@CreateFleet' {} Maybe Bool
a -> CreateFleet
s {$sel:replaceUnhealthyInstances:CreateFleet' :: Maybe Bool
replaceUnhealthyInstances = Maybe Bool
a} :: CreateFleet)

-- | Describes the configuration of Spot Instances in an EC2 Fleet.
createFleet_spotOptions :: Lens.Lens' CreateFleet (Prelude.Maybe SpotOptionsRequest)
createFleet_spotOptions :: Lens' CreateFleet (Maybe SpotOptionsRequest)
createFleet_spotOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleet' {Maybe SpotOptionsRequest
spotOptions :: Maybe SpotOptionsRequest
$sel:spotOptions:CreateFleet' :: CreateFleet -> Maybe SpotOptionsRequest
spotOptions} -> Maybe SpotOptionsRequest
spotOptions) (\s :: CreateFleet
s@CreateFleet' {} Maybe SpotOptionsRequest
a -> CreateFleet
s {$sel:spotOptions:CreateFleet' :: Maybe SpotOptionsRequest
spotOptions = Maybe SpotOptionsRequest
a} :: CreateFleet)

-- | The key-value pair for tagging the EC2 Fleet request on creation. For
-- more information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#tag-resources Tagging your resources>.
--
-- If the fleet type is @instant@, specify a resource type of @fleet@ to
-- tag the fleet or @instance@ to tag the instances at launch.
--
-- If the fleet type is @maintain@ or @request@, specify a resource type of
-- @fleet@ to tag the fleet. You cannot specify a resource type of
-- @instance@. To tag instances at launch, specify the tags in a
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html#create-launch-template launch template>.
createFleet_tagSpecifications :: Lens.Lens' CreateFleet (Prelude.Maybe [TagSpecification])
createFleet_tagSpecifications :: Lens' CreateFleet (Maybe [TagSpecification])
createFleet_tagSpecifications = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleet' {Maybe [TagSpecification]
tagSpecifications :: Maybe [TagSpecification]
$sel:tagSpecifications:CreateFleet' :: CreateFleet -> Maybe [TagSpecification]
tagSpecifications} -> Maybe [TagSpecification]
tagSpecifications) (\s :: CreateFleet
s@CreateFleet' {} Maybe [TagSpecification]
a -> CreateFleet
s {$sel:tagSpecifications:CreateFleet' :: Maybe [TagSpecification]
tagSpecifications = Maybe [TagSpecification]
a} :: CreateFleet) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Indicates whether running instances should be terminated when the EC2
-- Fleet expires.
createFleet_terminateInstancesWithExpiration :: Lens.Lens' CreateFleet (Prelude.Maybe Prelude.Bool)
createFleet_terminateInstancesWithExpiration :: Lens' CreateFleet (Maybe Bool)
createFleet_terminateInstancesWithExpiration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleet' {Maybe Bool
terminateInstancesWithExpiration :: Maybe Bool
$sel:terminateInstancesWithExpiration:CreateFleet' :: CreateFleet -> Maybe Bool
terminateInstancesWithExpiration} -> Maybe Bool
terminateInstancesWithExpiration) (\s :: CreateFleet
s@CreateFleet' {} Maybe Bool
a -> CreateFleet
s {$sel:terminateInstancesWithExpiration:CreateFleet' :: Maybe Bool
terminateInstancesWithExpiration = Maybe Bool
a} :: CreateFleet)

-- | The fleet type. The default value is @maintain@.
--
-- -   @maintain@ - The EC2 Fleet places an asynchronous request for your
--     desired capacity, and continues to maintain your desired Spot
--     capacity by replenishing interrupted Spot Instances.
--
-- -   @request@ - The EC2 Fleet places an asynchronous one-time request
--     for your desired capacity, but does submit Spot requests in
--     alternative capacity pools if Spot capacity is unavailable, and does
--     not maintain Spot capacity if Spot Instances are interrupted.
--
-- -   @instant@ - The EC2 Fleet places a synchronous one-time request for
--     your desired capacity, and returns errors for any instances that
--     could not be launched.
--
-- For more information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-request-type.html EC2 Fleet request types>
-- in the /Amazon EC2 User Guide/.
createFleet_type :: Lens.Lens' CreateFleet (Prelude.Maybe FleetType)
createFleet_type :: Lens' CreateFleet (Maybe FleetType)
createFleet_type = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleet' {Maybe FleetType
type' :: Maybe FleetType
$sel:type':CreateFleet' :: CreateFleet -> Maybe FleetType
type'} -> Maybe FleetType
type') (\s :: CreateFleet
s@CreateFleet' {} Maybe FleetType
a -> CreateFleet
s {$sel:type':CreateFleet' :: Maybe FleetType
type' = Maybe FleetType
a} :: CreateFleet)

-- | The start date and time of the request, in UTC format (for example,
-- /YYYY/-/MM/-/DD/T/HH/:/MM/:/SS/Z). The default is to start fulfilling
-- the request immediately.
createFleet_validFrom :: Lens.Lens' CreateFleet (Prelude.Maybe Prelude.UTCTime)
createFleet_validFrom :: Lens' CreateFleet (Maybe UTCTime)
createFleet_validFrom = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleet' {Maybe ISO8601
validFrom :: Maybe ISO8601
$sel:validFrom:CreateFleet' :: CreateFleet -> Maybe ISO8601
validFrom} -> Maybe ISO8601
validFrom) (\s :: CreateFleet
s@CreateFleet' {} Maybe ISO8601
a -> CreateFleet
s {$sel:validFrom:CreateFleet' :: Maybe ISO8601
validFrom = Maybe ISO8601
a} :: CreateFleet) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The end date and time of the request, in UTC format (for example,
-- /YYYY/-/MM/-/DD/T/HH/:/MM/:/SS/Z). At this point, no new EC2 Fleet
-- requests are placed or able to fulfill the request. If no value is
-- specified, the request remains until you cancel it.
createFleet_validUntil :: Lens.Lens' CreateFleet (Prelude.Maybe Prelude.UTCTime)
createFleet_validUntil :: Lens' CreateFleet (Maybe UTCTime)
createFleet_validUntil = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleet' {Maybe ISO8601
validUntil :: Maybe ISO8601
$sel:validUntil:CreateFleet' :: CreateFleet -> Maybe ISO8601
validUntil} -> Maybe ISO8601
validUntil) (\s :: CreateFleet
s@CreateFleet' {} Maybe ISO8601
a -> CreateFleet
s {$sel:validUntil:CreateFleet' :: Maybe ISO8601
validUntil = Maybe ISO8601
a} :: CreateFleet) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The configuration for the EC2 Fleet.
createFleet_launchTemplateConfigs :: Lens.Lens' CreateFleet [FleetLaunchTemplateConfigRequest]
createFleet_launchTemplateConfigs :: Lens' CreateFleet [FleetLaunchTemplateConfigRequest]
createFleet_launchTemplateConfigs = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleet' {[FleetLaunchTemplateConfigRequest]
launchTemplateConfigs :: [FleetLaunchTemplateConfigRequest]
$sel:launchTemplateConfigs:CreateFleet' :: CreateFleet -> [FleetLaunchTemplateConfigRequest]
launchTemplateConfigs} -> [FleetLaunchTemplateConfigRequest]
launchTemplateConfigs) (\s :: CreateFleet
s@CreateFleet' {} [FleetLaunchTemplateConfigRequest]
a -> CreateFleet
s {$sel:launchTemplateConfigs:CreateFleet' :: [FleetLaunchTemplateConfigRequest]
launchTemplateConfigs = [FleetLaunchTemplateConfigRequest]
a} :: CreateFleet) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The number of units to request.
createFleet_targetCapacitySpecification :: Lens.Lens' CreateFleet TargetCapacitySpecificationRequest
createFleet_targetCapacitySpecification :: Lens' CreateFleet TargetCapacitySpecificationRequest
createFleet_targetCapacitySpecification = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleet' {TargetCapacitySpecificationRequest
targetCapacitySpecification :: TargetCapacitySpecificationRequest
$sel:targetCapacitySpecification:CreateFleet' :: CreateFleet -> TargetCapacitySpecificationRequest
targetCapacitySpecification} -> TargetCapacitySpecificationRequest
targetCapacitySpecification) (\s :: CreateFleet
s@CreateFleet' {} TargetCapacitySpecificationRequest
a -> CreateFleet
s {$sel:targetCapacitySpecification:CreateFleet' :: TargetCapacitySpecificationRequest
targetCapacitySpecification = TargetCapacitySpecificationRequest
a} :: CreateFleet)

instance Core.AWSRequest CreateFleet where
  type AWSResponse CreateFleet = CreateFleetResponse
  request :: (Service -> Service) -> CreateFleet -> Request CreateFleet
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.postQuery (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy CreateFleet
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateFleet)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXML
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Maybe [CreateFleetError]
-> Maybe Text
-> Maybe [CreateFleetInstance]
-> Int
-> CreateFleetResponse
CreateFleetResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ( [Node]
x
                            forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"errorSet"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                            forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"item")
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"fleetId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                            forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"fleetInstanceSet"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                            forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"item")
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable CreateFleet where
  hashWithSalt :: Int -> CreateFleet -> Int
hashWithSalt Int
_salt CreateFleet' {[FleetLaunchTemplateConfigRequest]
Maybe Bool
Maybe [TagSpecification]
Maybe Text
Maybe ISO8601
Maybe FleetExcessCapacityTerminationPolicy
Maybe FleetType
Maybe OnDemandOptionsRequest
Maybe SpotOptionsRequest
TargetCapacitySpecificationRequest
targetCapacitySpecification :: TargetCapacitySpecificationRequest
launchTemplateConfigs :: [FleetLaunchTemplateConfigRequest]
validUntil :: Maybe ISO8601
validFrom :: Maybe ISO8601
type' :: Maybe FleetType
terminateInstancesWithExpiration :: Maybe Bool
tagSpecifications :: Maybe [TagSpecification]
spotOptions :: Maybe SpotOptionsRequest
replaceUnhealthyInstances :: Maybe Bool
onDemandOptions :: Maybe OnDemandOptionsRequest
excessCapacityTerminationPolicy :: Maybe FleetExcessCapacityTerminationPolicy
dryRun :: Maybe Bool
context :: Maybe Text
clientToken :: Maybe Text
$sel:targetCapacitySpecification:CreateFleet' :: CreateFleet -> TargetCapacitySpecificationRequest
$sel:launchTemplateConfigs:CreateFleet' :: CreateFleet -> [FleetLaunchTemplateConfigRequest]
$sel:validUntil:CreateFleet' :: CreateFleet -> Maybe ISO8601
$sel:validFrom:CreateFleet' :: CreateFleet -> Maybe ISO8601
$sel:type':CreateFleet' :: CreateFleet -> Maybe FleetType
$sel:terminateInstancesWithExpiration:CreateFleet' :: CreateFleet -> Maybe Bool
$sel:tagSpecifications:CreateFleet' :: CreateFleet -> Maybe [TagSpecification]
$sel:spotOptions:CreateFleet' :: CreateFleet -> Maybe SpotOptionsRequest
$sel:replaceUnhealthyInstances:CreateFleet' :: CreateFleet -> Maybe Bool
$sel:onDemandOptions:CreateFleet' :: CreateFleet -> Maybe OnDemandOptionsRequest
$sel:excessCapacityTerminationPolicy:CreateFleet' :: CreateFleet -> Maybe FleetExcessCapacityTerminationPolicy
$sel:dryRun:CreateFleet' :: CreateFleet -> Maybe Bool
$sel:context:CreateFleet' :: CreateFleet -> Maybe Text
$sel:clientToken:CreateFleet' :: CreateFleet -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
context
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
dryRun
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe FleetExcessCapacityTerminationPolicy
excessCapacityTerminationPolicy
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe OnDemandOptionsRequest
onDemandOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
replaceUnhealthyInstances
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SpotOptionsRequest
spotOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [TagSpecification]
tagSpecifications
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
terminateInstancesWithExpiration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe FleetType
type'
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ISO8601
validFrom
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ISO8601
validUntil
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` [FleetLaunchTemplateConfigRequest]
launchTemplateConfigs
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` TargetCapacitySpecificationRequest
targetCapacitySpecification

instance Prelude.NFData CreateFleet where
  rnf :: CreateFleet -> ()
rnf CreateFleet' {[FleetLaunchTemplateConfigRequest]
Maybe Bool
Maybe [TagSpecification]
Maybe Text
Maybe ISO8601
Maybe FleetExcessCapacityTerminationPolicy
Maybe FleetType
Maybe OnDemandOptionsRequest
Maybe SpotOptionsRequest
TargetCapacitySpecificationRequest
targetCapacitySpecification :: TargetCapacitySpecificationRequest
launchTemplateConfigs :: [FleetLaunchTemplateConfigRequest]
validUntil :: Maybe ISO8601
validFrom :: Maybe ISO8601
type' :: Maybe FleetType
terminateInstancesWithExpiration :: Maybe Bool
tagSpecifications :: Maybe [TagSpecification]
spotOptions :: Maybe SpotOptionsRequest
replaceUnhealthyInstances :: Maybe Bool
onDemandOptions :: Maybe OnDemandOptionsRequest
excessCapacityTerminationPolicy :: Maybe FleetExcessCapacityTerminationPolicy
dryRun :: Maybe Bool
context :: Maybe Text
clientToken :: Maybe Text
$sel:targetCapacitySpecification:CreateFleet' :: CreateFleet -> TargetCapacitySpecificationRequest
$sel:launchTemplateConfigs:CreateFleet' :: CreateFleet -> [FleetLaunchTemplateConfigRequest]
$sel:validUntil:CreateFleet' :: CreateFleet -> Maybe ISO8601
$sel:validFrom:CreateFleet' :: CreateFleet -> Maybe ISO8601
$sel:type':CreateFleet' :: CreateFleet -> Maybe FleetType
$sel:terminateInstancesWithExpiration:CreateFleet' :: CreateFleet -> Maybe Bool
$sel:tagSpecifications:CreateFleet' :: CreateFleet -> Maybe [TagSpecification]
$sel:spotOptions:CreateFleet' :: CreateFleet -> Maybe SpotOptionsRequest
$sel:replaceUnhealthyInstances:CreateFleet' :: CreateFleet -> Maybe Bool
$sel:onDemandOptions:CreateFleet' :: CreateFleet -> Maybe OnDemandOptionsRequest
$sel:excessCapacityTerminationPolicy:CreateFleet' :: CreateFleet -> Maybe FleetExcessCapacityTerminationPolicy
$sel:dryRun:CreateFleet' :: CreateFleet -> Maybe Bool
$sel:context:CreateFleet' :: CreateFleet -> Maybe Text
$sel:clientToken:CreateFleet' :: CreateFleet -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
context
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
dryRun
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe FleetExcessCapacityTerminationPolicy
excessCapacityTerminationPolicy
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe OnDemandOptionsRequest
onDemandOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
replaceUnhealthyInstances
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SpotOptionsRequest
spotOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [TagSpecification]
tagSpecifications
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
terminateInstancesWithExpiration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe FleetType
type'
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ISO8601
validFrom
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ISO8601
validUntil
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [FleetLaunchTemplateConfigRequest]
launchTemplateConfigs
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf TargetCapacitySpecificationRequest
targetCapacitySpecification

instance Data.ToHeaders CreateFleet where
  toHeaders :: CreateFleet -> ResponseHeaders
toHeaders = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

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

instance Data.ToQuery CreateFleet where
  toQuery :: CreateFleet -> QueryString
toQuery CreateFleet' {[FleetLaunchTemplateConfigRequest]
Maybe Bool
Maybe [TagSpecification]
Maybe Text
Maybe ISO8601
Maybe FleetExcessCapacityTerminationPolicy
Maybe FleetType
Maybe OnDemandOptionsRequest
Maybe SpotOptionsRequest
TargetCapacitySpecificationRequest
targetCapacitySpecification :: TargetCapacitySpecificationRequest
launchTemplateConfigs :: [FleetLaunchTemplateConfigRequest]
validUntil :: Maybe ISO8601
validFrom :: Maybe ISO8601
type' :: Maybe FleetType
terminateInstancesWithExpiration :: Maybe Bool
tagSpecifications :: Maybe [TagSpecification]
spotOptions :: Maybe SpotOptionsRequest
replaceUnhealthyInstances :: Maybe Bool
onDemandOptions :: Maybe OnDemandOptionsRequest
excessCapacityTerminationPolicy :: Maybe FleetExcessCapacityTerminationPolicy
dryRun :: Maybe Bool
context :: Maybe Text
clientToken :: Maybe Text
$sel:targetCapacitySpecification:CreateFleet' :: CreateFleet -> TargetCapacitySpecificationRequest
$sel:launchTemplateConfigs:CreateFleet' :: CreateFleet -> [FleetLaunchTemplateConfigRequest]
$sel:validUntil:CreateFleet' :: CreateFleet -> Maybe ISO8601
$sel:validFrom:CreateFleet' :: CreateFleet -> Maybe ISO8601
$sel:type':CreateFleet' :: CreateFleet -> Maybe FleetType
$sel:terminateInstancesWithExpiration:CreateFleet' :: CreateFleet -> Maybe Bool
$sel:tagSpecifications:CreateFleet' :: CreateFleet -> Maybe [TagSpecification]
$sel:spotOptions:CreateFleet' :: CreateFleet -> Maybe SpotOptionsRequest
$sel:replaceUnhealthyInstances:CreateFleet' :: CreateFleet -> Maybe Bool
$sel:onDemandOptions:CreateFleet' :: CreateFleet -> Maybe OnDemandOptionsRequest
$sel:excessCapacityTerminationPolicy:CreateFleet' :: CreateFleet -> Maybe FleetExcessCapacityTerminationPolicy
$sel:dryRun:CreateFleet' :: CreateFleet -> Maybe Bool
$sel:context:CreateFleet' :: CreateFleet -> Maybe Text
$sel:clientToken:CreateFleet' :: CreateFleet -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"CreateFleet" :: Prelude.ByteString),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2016-11-15" :: Prelude.ByteString),
        ByteString
"ClientToken" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
clientToken,
        ByteString
"Context" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
context,
        ByteString
"DryRun" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
dryRun,
        ByteString
"ExcessCapacityTerminationPolicy"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe FleetExcessCapacityTerminationPolicy
excessCapacityTerminationPolicy,
        ByteString
"OnDemandOptions" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe OnDemandOptionsRequest
onDemandOptions,
        ByteString
"ReplaceUnhealthyInstances"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
replaceUnhealthyInstances,
        ByteString
"SpotOptions" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe SpotOptionsRequest
spotOptions,
        forall a. ToQuery a => a -> QueryString
Data.toQuery
          ( forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"TagSpecification"
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [TagSpecification]
tagSpecifications
          ),
        ByteString
"TerminateInstancesWithExpiration"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
terminateInstancesWithExpiration,
        ByteString
"Type" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe FleetType
type',
        ByteString
"ValidFrom" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe ISO8601
validFrom,
        ByteString
"ValidUntil" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe ISO8601
validUntil,
        forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList
          ByteString
"LaunchTemplateConfigs"
          [FleetLaunchTemplateConfigRequest]
launchTemplateConfigs,
        ByteString
"TargetCapacitySpecification"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: TargetCapacitySpecificationRequest
targetCapacitySpecification
      ]

-- | /See:/ 'newCreateFleetResponse' smart constructor.
data CreateFleetResponse = CreateFleetResponse'
  { -- | Information about the instances that could not be launched by the fleet.
    -- Supported only for fleets of type @instant@.
    CreateFleetResponse -> Maybe [CreateFleetError]
errors :: Prelude.Maybe [CreateFleetError],
    -- | The ID of the EC2 Fleet.
    CreateFleetResponse -> Maybe Text
fleetId :: Prelude.Maybe Prelude.Text,
    -- | Information about the instances that were launched by the fleet.
    -- Supported only for fleets of type @instant@.
    CreateFleetResponse -> Maybe [CreateFleetInstance]
instances :: Prelude.Maybe [CreateFleetInstance],
    -- | The response's http status code.
    CreateFleetResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateFleetResponse -> CreateFleetResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateFleetResponse -> CreateFleetResponse -> Bool
$c/= :: CreateFleetResponse -> CreateFleetResponse -> Bool
== :: CreateFleetResponse -> CreateFleetResponse -> Bool
$c== :: CreateFleetResponse -> CreateFleetResponse -> Bool
Prelude.Eq, ReadPrec [CreateFleetResponse]
ReadPrec CreateFleetResponse
Int -> ReadS CreateFleetResponse
ReadS [CreateFleetResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateFleetResponse]
$creadListPrec :: ReadPrec [CreateFleetResponse]
readPrec :: ReadPrec CreateFleetResponse
$creadPrec :: ReadPrec CreateFleetResponse
readList :: ReadS [CreateFleetResponse]
$creadList :: ReadS [CreateFleetResponse]
readsPrec :: Int -> ReadS CreateFleetResponse
$creadsPrec :: Int -> ReadS CreateFleetResponse
Prelude.Read, Int -> CreateFleetResponse -> ShowS
[CreateFleetResponse] -> ShowS
CreateFleetResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateFleetResponse] -> ShowS
$cshowList :: [CreateFleetResponse] -> ShowS
show :: CreateFleetResponse -> String
$cshow :: CreateFleetResponse -> String
showsPrec :: Int -> CreateFleetResponse -> ShowS
$cshowsPrec :: Int -> CreateFleetResponse -> ShowS
Prelude.Show, forall x. Rep CreateFleetResponse x -> CreateFleetResponse
forall x. CreateFleetResponse -> Rep CreateFleetResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateFleetResponse x -> CreateFleetResponse
$cfrom :: forall x. CreateFleetResponse -> Rep CreateFleetResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateFleetResponse' 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:
--
-- 'errors', 'createFleetResponse_errors' - Information about the instances that could not be launched by the fleet.
-- Supported only for fleets of type @instant@.
--
-- 'fleetId', 'createFleetResponse_fleetId' - The ID of the EC2 Fleet.
--
-- 'instances', 'createFleetResponse_instances' - Information about the instances that were launched by the fleet.
-- Supported only for fleets of type @instant@.
--
-- 'httpStatus', 'createFleetResponse_httpStatus' - The response's http status code.
newCreateFleetResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateFleetResponse
newCreateFleetResponse :: Int -> CreateFleetResponse
newCreateFleetResponse Int
pHttpStatus_ =
  CreateFleetResponse'
    { $sel:errors:CreateFleetResponse' :: Maybe [CreateFleetError]
errors = forall a. Maybe a
Prelude.Nothing,
      $sel:fleetId:CreateFleetResponse' :: Maybe Text
fleetId = forall a. Maybe a
Prelude.Nothing,
      $sel:instances:CreateFleetResponse' :: Maybe [CreateFleetInstance]
instances = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateFleetResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Information about the instances that could not be launched by the fleet.
-- Supported only for fleets of type @instant@.
createFleetResponse_errors :: Lens.Lens' CreateFleetResponse (Prelude.Maybe [CreateFleetError])
createFleetResponse_errors :: Lens' CreateFleetResponse (Maybe [CreateFleetError])
createFleetResponse_errors = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleetResponse' {Maybe [CreateFleetError]
errors :: Maybe [CreateFleetError]
$sel:errors:CreateFleetResponse' :: CreateFleetResponse -> Maybe [CreateFleetError]
errors} -> Maybe [CreateFleetError]
errors) (\s :: CreateFleetResponse
s@CreateFleetResponse' {} Maybe [CreateFleetError]
a -> CreateFleetResponse
s {$sel:errors:CreateFleetResponse' :: Maybe [CreateFleetError]
errors = Maybe [CreateFleetError]
a} :: CreateFleetResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The ID of the EC2 Fleet.
createFleetResponse_fleetId :: Lens.Lens' CreateFleetResponse (Prelude.Maybe Prelude.Text)
createFleetResponse_fleetId :: Lens' CreateFleetResponse (Maybe Text)
createFleetResponse_fleetId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleetResponse' {Maybe Text
fleetId :: Maybe Text
$sel:fleetId:CreateFleetResponse' :: CreateFleetResponse -> Maybe Text
fleetId} -> Maybe Text
fleetId) (\s :: CreateFleetResponse
s@CreateFleetResponse' {} Maybe Text
a -> CreateFleetResponse
s {$sel:fleetId:CreateFleetResponse' :: Maybe Text
fleetId = Maybe Text
a} :: CreateFleetResponse)

-- | Information about the instances that were launched by the fleet.
-- Supported only for fleets of type @instant@.
createFleetResponse_instances :: Lens.Lens' CreateFleetResponse (Prelude.Maybe [CreateFleetInstance])
createFleetResponse_instances :: Lens' CreateFleetResponse (Maybe [CreateFleetInstance])
createFleetResponse_instances = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFleetResponse' {Maybe [CreateFleetInstance]
instances :: Maybe [CreateFleetInstance]
$sel:instances:CreateFleetResponse' :: CreateFleetResponse -> Maybe [CreateFleetInstance]
instances} -> Maybe [CreateFleetInstance]
instances) (\s :: CreateFleetResponse
s@CreateFleetResponse' {} Maybe [CreateFleetInstance]
a -> CreateFleetResponse
s {$sel:instances:CreateFleetResponse' :: Maybe [CreateFleetInstance]
instances = Maybe [CreateFleetInstance]
a} :: CreateFleetResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

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

instance Prelude.NFData CreateFleetResponse where
  rnf :: CreateFleetResponse -> ()
rnf CreateFleetResponse' {Int
Maybe [CreateFleetInstance]
Maybe [CreateFleetError]
Maybe Text
httpStatus :: Int
instances :: Maybe [CreateFleetInstance]
fleetId :: Maybe Text
errors :: Maybe [CreateFleetError]
$sel:httpStatus:CreateFleetResponse' :: CreateFleetResponse -> Int
$sel:instances:CreateFleetResponse' :: CreateFleetResponse -> Maybe [CreateFleetInstance]
$sel:fleetId:CreateFleetResponse' :: CreateFleetResponse -> Maybe Text
$sel:errors:CreateFleetResponse' :: CreateFleetResponse -> Maybe [CreateFleetError]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [CreateFleetError]
errors
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
fleetId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [CreateFleetInstance]
instances
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus