{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric      #-}
{-# LANGUAGE OverloadedStrings  #-}
{-# LANGUAGE RecordWildCards    #-}
{-# LANGUAGE TypeFamilies       #-}

{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-binds   #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

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

-- |
-- Module      : Network.AWS.GameLift.CreateFleet
-- Copyright   : (c) 2013-2016 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates a new fleet to host game servers. A fleet consists of a set of Amazon Elastic Compute Cloud (Amazon EC2) instances of a certain type, which defines the CPU, memory, storage, and networking capacity of each host in the fleet. See <https://aws.amazon.com/ec2/instance-types/ Amazon EC2 Instance Types> for more information. Each instance in the fleet hosts a game server created from the specified game build. Once a fleet is in an ACTIVE state, it can begin hosting game sessions.
--
-- To create a new fleet, provide a name and the EC2 instance type for the new fleet, and specify the build and server launch path. Builds must be in a READY state before they can be used to build fleets. When configuring the new fleet, you can optionally (1) provide a set of launch parameters to be passed to a game server when activated; (2) limit incoming traffic to a specified range of IP addresses and port numbers; (3) set game session protection for all instances in the fleet, and (4) configure Amazon GameLift to store game session logs by specifying the path to the logs stored in your game server files. If the call is successful, Amazon GameLift performs the following tasks:
--
-- -   Creates a fleet record and sets the state to NEW.
-- -   Sets the fleet\'s capacity to 1 \"desired\" and 1 \"active\" EC2 instance count.
-- -   Creates an EC2 instance and begins the process of initializing the fleet and activating a game server on the instance.
-- -   Begins writing events to the fleet event log, which can be accessed in the GameLift console.
--
-- Once a fleet is created, use the following actions to change certain fleet properties (server launch parameters and log paths cannot be changed):
--
-- -   < UpdateFleetAttributes> -- Update fleet metadata, including name and description.
-- -   < UpdateFleetCapacity> -- Increase or decrease the number of instances you want the fleet to maintain.
-- -   < UpdateFleetPortSettings> -- Change the IP addresses and ports that allow access to incoming traffic.
module Network.AWS.GameLift.CreateFleet
    (
    -- * Creating a Request
      createFleet
    , CreateFleet
    -- * Request Lenses
    , cfServerLaunchParameters
    , cfLogPaths
    , cfEC2InboundPermissions
    , cfNewGameSessionProtectionPolicy
    , cfDescription
    , cfName
    , cfBuildId
    , cfServerLaunchPath
    , cfEC2InstanceType

    -- * Destructuring the Response
    , createFleetResponse
    , CreateFleetResponse
    -- * Response Lenses
    , cfrsFleetAttributes
    , cfrsResponseStatus
    ) where

import           Network.AWS.GameLift.Types
import           Network.AWS.GameLift.Types.Product
import           Network.AWS.Lens
import           Network.AWS.Prelude
import           Network.AWS.Request
import           Network.AWS.Response

-- | Represents the input for a request action.
--
-- /See:/ 'createFleet' smart constructor.
data CreateFleet = CreateFleet'
    { _cfServerLaunchParameters         :: !(Maybe Text)
    , _cfLogPaths                       :: !(Maybe [Text])
    , _cfEC2InboundPermissions          :: !(Maybe [IPPermission])
    , _cfNewGameSessionProtectionPolicy :: !(Maybe ProtectionPolicy)
    , _cfDescription                    :: !(Maybe Text)
    , _cfName                           :: !Text
    , _cfBuildId                        :: !Text
    , _cfServerLaunchPath               :: !Text
    , _cfEC2InstanceType                :: !EC2InstanceType
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'CreateFleet' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'cfServerLaunchParameters'
--
-- * 'cfLogPaths'
--
-- * 'cfEC2InboundPermissions'
--
-- * 'cfNewGameSessionProtectionPolicy'
--
-- * 'cfDescription'
--
-- * 'cfName'
--
-- * 'cfBuildId'
--
-- * 'cfServerLaunchPath'
--
-- * 'cfEC2InstanceType'
createFleet
    :: Text -- ^ 'cfName'
    -> Text -- ^ 'cfBuildId'
    -> Text -- ^ 'cfServerLaunchPath'
    -> EC2InstanceType -- ^ 'cfEC2InstanceType'
    -> CreateFleet
createFleet pName_ pBuildId_ pServerLaunchPath_ pEC2InstanceType_ =
    CreateFleet'
    { _cfServerLaunchParameters = Nothing
    , _cfLogPaths = Nothing
    , _cfEC2InboundPermissions = Nothing
    , _cfNewGameSessionProtectionPolicy = Nothing
    , _cfDescription = Nothing
    , _cfName = pName_
    , _cfBuildId = pBuildId_
    , _cfServerLaunchPath = pServerLaunchPath_
    , _cfEC2InstanceType = pEC2InstanceType_
    }

-- | Parameters required to launch your game server. These parameters should be expressed as a string of command-line parameters. Example: \"+sv_port 33435 +start_lobby\".
cfServerLaunchParameters :: Lens' CreateFleet (Maybe Text)
cfServerLaunchParameters = lens _cfServerLaunchParameters (\ s a -> s{_cfServerLaunchParameters = a});

-- | Path to game-session log files generated by your game server. Once a game session has been terminated, Amazon GameLift captures and stores the logs on Amazon S3. Use the GameLift console to access the stored logs.
cfLogPaths :: Lens' CreateFleet [Text]
cfLogPaths = lens _cfLogPaths (\ s a -> s{_cfLogPaths = a}) . _Default . _Coerce;

-- | Access limits for incoming traffic. Setting these values limits game server access to incoming traffic using specified IP ranges and port numbers. Some ports in a range may be restricted. You can provide one or more sets of permissions for the fleet.
cfEC2InboundPermissions :: Lens' CreateFleet [IPPermission]
cfEC2InboundPermissions = lens _cfEC2InboundPermissions (\ s a -> s{_cfEC2InboundPermissions = a}) . _Default . _Coerce;

-- | Game session protection policy to apply to all instances created in this fleet. If this parameter is not set, new instances in this fleet will default to no protection. Protection can be set for individual instances using < UpdateGameSession>.
--
-- -   NoProtection: The game session can be terminated during a scale-down event.
-- -   FullProtection: If the game session is in an ACTIVE status, it cannot be terminated during a scale-down event.
cfNewGameSessionProtectionPolicy :: Lens' CreateFleet (Maybe ProtectionPolicy)
cfNewGameSessionProtectionPolicy = lens _cfNewGameSessionProtectionPolicy (\ s a -> s{_cfNewGameSessionProtectionPolicy = a});

-- | Human-readable description of the fleet.
cfDescription :: Lens' CreateFleet (Maybe Text)
cfDescription = lens _cfDescription (\ s a -> s{_cfDescription = a});

-- | Descriptive label associated with this fleet. Fleet names do not need to be unique.
cfName :: Lens' CreateFleet Text
cfName = lens _cfName (\ s a -> s{_cfName = a});

-- | Unique identifier for the build you want the new fleet to use.
cfBuildId :: Lens' CreateFleet Text
cfBuildId = lens _cfBuildId (\ s a -> s{_cfBuildId = a});

-- | Path to the launch executable for the game server. A game server is built into a 'C:\\game' drive. This value must be expressed as 'C:\\game\\[launchpath]'. Example: If, when built, your game server files are in a folder called \"MyGame\", your log path should be 'C:\\game\\MyGame\\server.exe'.
cfServerLaunchPath :: Lens' CreateFleet Text
cfServerLaunchPath = lens _cfServerLaunchPath (\ s a -> s{_cfServerLaunchPath = a});

-- | Type of EC2 instances used in the fleet. EC2 instance types define the CPU, memory, storage, and networking capacity of the fleetaposs hosts. Amazon GameLift supports the EC2 instance types listed below. See <https://aws.amazon.com/ec2/instance-types/ Amazon EC2 Instance Types> for detailed descriptions of each.
cfEC2InstanceType :: Lens' CreateFleet EC2InstanceType
cfEC2InstanceType = lens _cfEC2InstanceType (\ s a -> s{_cfEC2InstanceType = a});

instance AWSRequest CreateFleet where
        type Rs CreateFleet = CreateFleetResponse
        request = postJSON gameLift
        response
          = receiveJSON
              (\ s h x ->
                 CreateFleetResponse' <$>
                   (x .?> "FleetAttributes") <*> (pure (fromEnum s)))

instance Hashable CreateFleet

instance NFData CreateFleet

instance ToHeaders CreateFleet where
        toHeaders
          = const
              (mconcat
                 ["X-Amz-Target" =#
                    ("GameLift.CreateFleet" :: ByteString),
                  "Content-Type" =#
                    ("application/x-amz-json-1.1" :: ByteString)])

instance ToJSON CreateFleet where
        toJSON CreateFleet'{..}
          = object
              (catMaybes
                 [("ServerLaunchParameters" .=) <$>
                    _cfServerLaunchParameters,
                  ("LogPaths" .=) <$> _cfLogPaths,
                  ("EC2InboundPermissions" .=) <$>
                    _cfEC2InboundPermissions,
                  ("NewGameSessionProtectionPolicy" .=) <$>
                    _cfNewGameSessionProtectionPolicy,
                  ("Description" .=) <$> _cfDescription,
                  Just ("Name" .= _cfName),
                  Just ("BuildId" .= _cfBuildId),
                  Just ("ServerLaunchPath" .= _cfServerLaunchPath),
                  Just ("EC2InstanceType" .= _cfEC2InstanceType)])

instance ToPath CreateFleet where
        toPath = const "/"

instance ToQuery CreateFleet where
        toQuery = const mempty

-- | Represents the returned data in response to a request action.
--
-- /See:/ 'createFleetResponse' smart constructor.
data CreateFleetResponse = CreateFleetResponse'
    { _cfrsFleetAttributes :: !(Maybe FleetAttributes)
    , _cfrsResponseStatus  :: !Int
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'CreateFleetResponse' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'cfrsFleetAttributes'
--
-- * 'cfrsResponseStatus'
createFleetResponse
    :: Int -- ^ 'cfrsResponseStatus'
    -> CreateFleetResponse
createFleetResponse pResponseStatus_ =
    CreateFleetResponse'
    { _cfrsFleetAttributes = Nothing
    , _cfrsResponseStatus = pResponseStatus_
    }

-- | Properties for the newly created fleet.
cfrsFleetAttributes :: Lens' CreateFleetResponse (Maybe FleetAttributes)
cfrsFleetAttributes = lens _cfrsFleetAttributes (\ s a -> s{_cfrsFleetAttributes = a});

-- | The response status code.
cfrsResponseStatus :: Lens' CreateFleetResponse Int
cfrsResponseStatus = lens _cfrsResponseStatus (\ s a -> s{_cfrsResponseStatus = a});

instance NFData CreateFleetResponse