{-# 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.EFS.CreateFileSystem
-- 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)
--
-- Creates a new, empty file system. The operation requires a creation
-- token in the request that Amazon EFS uses to ensure idempotent creation
-- (calling the operation with same creation token has no effect). If a
-- file system does not currently exist that is owned by the caller\'s
-- Amazon Web Services account with the specified creation token, this
-- operation does the following:
--
-- -   Creates a new, empty file system. The file system will have an
--     Amazon EFS assigned ID, and an initial lifecycle state @creating@.
--
-- -   Returns with the description of the created file system.
--
-- Otherwise, this operation returns a @FileSystemAlreadyExists@ error with
-- the ID of the existing file system.
--
-- For basic use cases, you can use a randomly generated UUID for the
-- creation token.
--
-- The idempotent operation allows you to retry a @CreateFileSystem@ call
-- without risk of creating an extra file system. This can happen when an
-- initial call fails in a way that leaves it uncertain whether or not a
-- file system was actually created. An example might be that a transport
-- level timeout occurred or your connection was reset. As long as you use
-- the same creation token, if the initial call had succeeded in creating a
-- file system, the client can learn of its existence from the
-- @FileSystemAlreadyExists@ error.
--
-- For more information, see
-- <https://docs.aws.amazon.com/efs/latest/ug/creating-using-create-fs.html#creating-using-create-fs-part1 Creating a file system>
-- in the /Amazon EFS User Guide/.
--
-- The @CreateFileSystem@ call returns while the file system\'s lifecycle
-- state is still @creating@. You can check the file system creation status
-- by calling the DescribeFileSystems operation, which among other things
-- returns the file system state.
--
-- This operation accepts an optional @PerformanceMode@ parameter that you
-- choose for your file system. We recommend @generalPurpose@ performance
-- mode for most file systems. File systems using the @maxIO@ performance
-- mode can scale to higher levels of aggregate throughput and operations
-- per second with a tradeoff of slightly higher latencies for most file
-- operations. The performance mode can\'t be changed after the file system
-- has been created. For more information, see
-- <https://docs.aws.amazon.com/efs/latest/ug/performance.html#performancemodes.html Amazon EFS performance modes>.
--
-- You can set the throughput mode for the file system using the
-- @ThroughputMode@ parameter.
--
-- After the file system is fully created, Amazon EFS sets its lifecycle
-- state to @available@, at which point you can create one or more mount
-- targets for the file system in your VPC. For more information, see
-- CreateMountTarget. You mount your Amazon EFS file system on an EC2
-- instances in your VPC by using the mount target. For more information,
-- see
-- <https://docs.aws.amazon.com/efs/latest/ug/how-it-works.html Amazon EFS: How it Works>.
--
-- This operation requires permissions for the
-- @elasticfilesystem:CreateFileSystem@ action.
module Amazonka.EFS.CreateFileSystem
  ( -- * Creating a Request
    CreateFileSystem (..),
    newCreateFileSystem,

    -- * Request Lenses
    createFileSystem_provisionedThroughputInMibps,
    createFileSystem_availabilityZoneName,
    createFileSystem_performanceMode,
    createFileSystem_backup,
    createFileSystem_encrypted,
    createFileSystem_throughputMode,
    createFileSystem_kmsKeyId,
    createFileSystem_tags,
    createFileSystem_creationToken,

    -- * Destructuring the Response
    FileSystemDescription (..),
    newFileSystemDescription,

    -- * Response Lenses
    fileSystemDescription_availabilityZoneId,
    fileSystemDescription_provisionedThroughputInMibps,
    fileSystemDescription_availabilityZoneName,
    fileSystemDescription_fileSystemArn,
    fileSystemDescription_encrypted,
    fileSystemDescription_throughputMode,
    fileSystemDescription_kmsKeyId,
    fileSystemDescription_name,
    fileSystemDescription_ownerId,
    fileSystemDescription_creationToken,
    fileSystemDescription_fileSystemId,
    fileSystemDescription_creationTime,
    fileSystemDescription_lifeCycleState,
    fileSystemDescription_numberOfMountTargets,
    fileSystemDescription_sizeInBytes,
    fileSystemDescription_performanceMode,
    fileSystemDescription_tags,
  )
where

import qualified Amazonka.Core as Core
import Amazonka.EFS.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:/ 'newCreateFileSystem' smart constructor.
data CreateFileSystem = CreateFileSystem'
  { -- | The throughput, measured in MiB\/s, that you want to provision for a
    -- file system that you\'re creating. Valid values are 1-1024. Required if
    -- @ThroughputMode@ is set to @provisioned@. The upper limit for throughput
    -- is 1024 MiB\/s. To increase this limit, contact Amazon Web Services
    -- Support. For more information, see
    -- <https://docs.aws.amazon.com/efs/latest/ug/limits.html#soft-limits Amazon EFS quotas that you can increase>
    -- in the /Amazon EFS User Guide/.
    CreateFileSystem -> Maybe Double
provisionedThroughputInMibps :: Prelude.Maybe Prelude.Double,
    -- | Used to create a file system that uses One Zone storage classes. It
    -- specifies the Amazon Web Services Availability Zone in which to create
    -- the file system. Use the format @us-east-1a@ to specify the Availability
    -- Zone. For more information about One Zone storage classes, see
    -- <https://docs.aws.amazon.com/efs/latest/ug/storage-classes.html Using EFS storage classes>
    -- in the /Amazon EFS User Guide/.
    --
    -- One Zone storage classes are not available in all Availability Zones in
    -- Amazon Web Services Regions where Amazon EFS is available.
    CreateFileSystem -> Maybe Text
availabilityZoneName :: Prelude.Maybe Prelude.Text,
    -- | The performance mode of the file system. We recommend @generalPurpose@
    -- performance mode for most file systems. File systems using the @maxIO@
    -- performance mode can scale to higher levels of aggregate throughput and
    -- operations per second with a tradeoff of slightly higher latencies for
    -- most file operations. The performance mode can\'t be changed after the
    -- file system has been created.
    --
    -- The @maxIO@ mode is not supported on file systems using One Zone storage
    -- classes.
    CreateFileSystem -> Maybe PerformanceMode
performanceMode :: Prelude.Maybe PerformanceMode,
    -- | Specifies whether automatic backups are enabled on the file system that
    -- you are creating. Set the value to @true@ to enable automatic backups.
    -- If you are creating a file system that uses One Zone storage classes,
    -- automatic backups are enabled by default. For more information, see
    -- <https://docs.aws.amazon.com/efs/latest/ug/awsbackup.html#automatic-backups Automatic backups>
    -- in the /Amazon EFS User Guide/.
    --
    -- Default is @false@. However, if you specify an @AvailabilityZoneName@,
    -- the default is @true@.
    --
    -- Backup is not available in all Amazon Web Services Regionswhere Amazon
    -- EFS is available.
    CreateFileSystem -> Maybe Bool
backup :: Prelude.Maybe Prelude.Bool,
    -- | A Boolean value that, if true, creates an encrypted file system. When
    -- creating an encrypted file system, you have the option of specifying
    -- CreateFileSystemRequest$KmsKeyId for an existing Key Management Service
    -- (KMS customer master key (CMK). If you don\'t specify a CMK, then the
    -- default CMK for Amazon EFS, @\/aws\/elasticfilesystem@, is used to
    -- protect the encrypted file system.
    CreateFileSystem -> Maybe Bool
encrypted :: Prelude.Maybe Prelude.Bool,
    -- | Specifies the throughput mode for the file system, either @bursting@ or
    -- @provisioned@. If you set @ThroughputMode@ to @provisioned@, you must
    -- also set a value for @ProvisionedThroughputInMibps@. After you create
    -- the file system, you can decrease your file system\'s throughput in
    -- Provisioned Throughput mode or change between the throughput modes, as
    -- long as it’s been more than 24 hours since the last decrease or
    -- throughput mode change. For more information, see
    -- <https://docs.aws.amazon.com/efs/latest/ug/performance.html#provisioned-throughput Specifying throughput with provisioned mode>
    -- in the /Amazon EFS User Guide/.
    --
    -- Default is @bursting@.
    CreateFileSystem -> Maybe ThroughputMode
throughputMode :: Prelude.Maybe ThroughputMode,
    -- | The ID of the KMS CMK that you want to use to protect the encrypted file
    -- system. This parameter is only required if you want to use a non-default
    -- KMS key. If this parameter is not specified, the default CMK for Amazon
    -- EFS is used. This ID can be in one of the following formats:
    --
    -- -   Key ID - A unique identifier of the key, for example
    --     @1234abcd-12ab-34cd-56ef-1234567890ab@.
    --
    -- -   ARN - An Amazon Resource Name (ARN) for the key, for example
    --     @arn:aws:kms:us-west-2:111122223333:key\/1234abcd-12ab-34cd-56ef-1234567890ab@.
    --
    -- -   Key alias - A previously created display name for a key, for example
    --     @alias\/projectKey1@.
    --
    -- -   Key alias ARN - An ARN for a key alias, for example
    --     @arn:aws:kms:us-west-2:444455556666:alias\/projectKey1@.
    --
    -- If @KmsKeyId@ is specified, the CreateFileSystemRequest$Encrypted
    -- parameter must be set to true.
    --
    -- EFS accepts only symmetric KMS keys. You cannot use asymmetric KMS keys
    -- with EFS file systems.
    CreateFileSystem -> Maybe Text
kmsKeyId :: Prelude.Maybe Prelude.Text,
    -- | Use to create one or more tags associated with the file system. Each tag
    -- is a user-defined key-value pair. Name your file system on creation by
    -- including a @\"Key\":\"Name\",\"Value\":\"{value}\"@ key-value pair.
    -- Each key must be unique. For more information, see
    -- <https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html Tagging Amazon Web Services resources>
    -- in the /Amazon Web Services General Reference Guide/.
    CreateFileSystem -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | A string of up to 64 ASCII characters. Amazon EFS uses this to ensure
    -- idempotent creation.
    CreateFileSystem -> Text
creationToken :: Prelude.Text
  }
  deriving (CreateFileSystem -> CreateFileSystem -> Bool
(CreateFileSystem -> CreateFileSystem -> Bool)
-> (CreateFileSystem -> CreateFileSystem -> Bool)
-> Eq CreateFileSystem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateFileSystem -> CreateFileSystem -> Bool
$c/= :: CreateFileSystem -> CreateFileSystem -> Bool
== :: CreateFileSystem -> CreateFileSystem -> Bool
$c== :: CreateFileSystem -> CreateFileSystem -> Bool
Prelude.Eq, ReadPrec [CreateFileSystem]
ReadPrec CreateFileSystem
Int -> ReadS CreateFileSystem
ReadS [CreateFileSystem]
(Int -> ReadS CreateFileSystem)
-> ReadS [CreateFileSystem]
-> ReadPrec CreateFileSystem
-> ReadPrec [CreateFileSystem]
-> Read CreateFileSystem
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateFileSystem]
$creadListPrec :: ReadPrec [CreateFileSystem]
readPrec :: ReadPrec CreateFileSystem
$creadPrec :: ReadPrec CreateFileSystem
readList :: ReadS [CreateFileSystem]
$creadList :: ReadS [CreateFileSystem]
readsPrec :: Int -> ReadS CreateFileSystem
$creadsPrec :: Int -> ReadS CreateFileSystem
Prelude.Read, Int -> CreateFileSystem -> ShowS
[CreateFileSystem] -> ShowS
CreateFileSystem -> String
(Int -> CreateFileSystem -> ShowS)
-> (CreateFileSystem -> String)
-> ([CreateFileSystem] -> ShowS)
-> Show CreateFileSystem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateFileSystem] -> ShowS
$cshowList :: [CreateFileSystem] -> ShowS
show :: CreateFileSystem -> String
$cshow :: CreateFileSystem -> String
showsPrec :: Int -> CreateFileSystem -> ShowS
$cshowsPrec :: Int -> CreateFileSystem -> ShowS
Prelude.Show, (forall x. CreateFileSystem -> Rep CreateFileSystem x)
-> (forall x. Rep CreateFileSystem x -> CreateFileSystem)
-> Generic CreateFileSystem
forall x. Rep CreateFileSystem x -> CreateFileSystem
forall x. CreateFileSystem -> Rep CreateFileSystem x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateFileSystem x -> CreateFileSystem
$cfrom :: forall x. CreateFileSystem -> Rep CreateFileSystem x
Prelude.Generic)

-- |
-- Create a value of 'CreateFileSystem' 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:
--
-- 'provisionedThroughputInMibps', 'createFileSystem_provisionedThroughputInMibps' - The throughput, measured in MiB\/s, that you want to provision for a
-- file system that you\'re creating. Valid values are 1-1024. Required if
-- @ThroughputMode@ is set to @provisioned@. The upper limit for throughput
-- is 1024 MiB\/s. To increase this limit, contact Amazon Web Services
-- Support. For more information, see
-- <https://docs.aws.amazon.com/efs/latest/ug/limits.html#soft-limits Amazon EFS quotas that you can increase>
-- in the /Amazon EFS User Guide/.
--
-- 'availabilityZoneName', 'createFileSystem_availabilityZoneName' - Used to create a file system that uses One Zone storage classes. It
-- specifies the Amazon Web Services Availability Zone in which to create
-- the file system. Use the format @us-east-1a@ to specify the Availability
-- Zone. For more information about One Zone storage classes, see
-- <https://docs.aws.amazon.com/efs/latest/ug/storage-classes.html Using EFS storage classes>
-- in the /Amazon EFS User Guide/.
--
-- One Zone storage classes are not available in all Availability Zones in
-- Amazon Web Services Regions where Amazon EFS is available.
--
-- 'performanceMode', 'createFileSystem_performanceMode' - The performance mode of the file system. We recommend @generalPurpose@
-- performance mode for most file systems. File systems using the @maxIO@
-- performance mode can scale to higher levels of aggregate throughput and
-- operations per second with a tradeoff of slightly higher latencies for
-- most file operations. The performance mode can\'t be changed after the
-- file system has been created.
--
-- The @maxIO@ mode is not supported on file systems using One Zone storage
-- classes.
--
-- 'backup', 'createFileSystem_backup' - Specifies whether automatic backups are enabled on the file system that
-- you are creating. Set the value to @true@ to enable automatic backups.
-- If you are creating a file system that uses One Zone storage classes,
-- automatic backups are enabled by default. For more information, see
-- <https://docs.aws.amazon.com/efs/latest/ug/awsbackup.html#automatic-backups Automatic backups>
-- in the /Amazon EFS User Guide/.
--
-- Default is @false@. However, if you specify an @AvailabilityZoneName@,
-- the default is @true@.
--
-- Backup is not available in all Amazon Web Services Regionswhere Amazon
-- EFS is available.
--
-- 'encrypted', 'createFileSystem_encrypted' - A Boolean value that, if true, creates an encrypted file system. When
-- creating an encrypted file system, you have the option of specifying
-- CreateFileSystemRequest$KmsKeyId for an existing Key Management Service
-- (KMS customer master key (CMK). If you don\'t specify a CMK, then the
-- default CMK for Amazon EFS, @\/aws\/elasticfilesystem@, is used to
-- protect the encrypted file system.
--
-- 'throughputMode', 'createFileSystem_throughputMode' - Specifies the throughput mode for the file system, either @bursting@ or
-- @provisioned@. If you set @ThroughputMode@ to @provisioned@, you must
-- also set a value for @ProvisionedThroughputInMibps@. After you create
-- the file system, you can decrease your file system\'s throughput in
-- Provisioned Throughput mode or change between the throughput modes, as
-- long as it’s been more than 24 hours since the last decrease or
-- throughput mode change. For more information, see
-- <https://docs.aws.amazon.com/efs/latest/ug/performance.html#provisioned-throughput Specifying throughput with provisioned mode>
-- in the /Amazon EFS User Guide/.
--
-- Default is @bursting@.
--
-- 'kmsKeyId', 'createFileSystem_kmsKeyId' - The ID of the KMS CMK that you want to use to protect the encrypted file
-- system. This parameter is only required if you want to use a non-default
-- KMS key. If this parameter is not specified, the default CMK for Amazon
-- EFS is used. This ID can be in one of the following formats:
--
-- -   Key ID - A unique identifier of the key, for example
--     @1234abcd-12ab-34cd-56ef-1234567890ab@.
--
-- -   ARN - An Amazon Resource Name (ARN) for the key, for example
--     @arn:aws:kms:us-west-2:111122223333:key\/1234abcd-12ab-34cd-56ef-1234567890ab@.
--
-- -   Key alias - A previously created display name for a key, for example
--     @alias\/projectKey1@.
--
-- -   Key alias ARN - An ARN for a key alias, for example
--     @arn:aws:kms:us-west-2:444455556666:alias\/projectKey1@.
--
-- If @KmsKeyId@ is specified, the CreateFileSystemRequest$Encrypted
-- parameter must be set to true.
--
-- EFS accepts only symmetric KMS keys. You cannot use asymmetric KMS keys
-- with EFS file systems.
--
-- 'tags', 'createFileSystem_tags' - Use to create one or more tags associated with the file system. Each tag
-- is a user-defined key-value pair. Name your file system on creation by
-- including a @\"Key\":\"Name\",\"Value\":\"{value}\"@ key-value pair.
-- Each key must be unique. For more information, see
-- <https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html Tagging Amazon Web Services resources>
-- in the /Amazon Web Services General Reference Guide/.
--
-- 'creationToken', 'createFileSystem_creationToken' - A string of up to 64 ASCII characters. Amazon EFS uses this to ensure
-- idempotent creation.
newCreateFileSystem ::
  -- | 'creationToken'
  Prelude.Text ->
  CreateFileSystem
newCreateFileSystem :: Text -> CreateFileSystem
newCreateFileSystem Text
pCreationToken_ =
  CreateFileSystem' :: Maybe Double
-> Maybe Text
-> Maybe PerformanceMode
-> Maybe Bool
-> Maybe Bool
-> Maybe ThroughputMode
-> Maybe Text
-> Maybe [Tag]
-> Text
-> CreateFileSystem
CreateFileSystem'
    { $sel:provisionedThroughputInMibps:CreateFileSystem' :: Maybe Double
provisionedThroughputInMibps =
        Maybe Double
forall a. Maybe a
Prelude.Nothing,
      $sel:availabilityZoneName:CreateFileSystem' :: Maybe Text
availabilityZoneName = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:performanceMode:CreateFileSystem' :: Maybe PerformanceMode
performanceMode = Maybe PerformanceMode
forall a. Maybe a
Prelude.Nothing,
      $sel:backup:CreateFileSystem' :: Maybe Bool
backup = Maybe Bool
forall a. Maybe a
Prelude.Nothing,
      $sel:encrypted:CreateFileSystem' :: Maybe Bool
encrypted = Maybe Bool
forall a. Maybe a
Prelude.Nothing,
      $sel:throughputMode:CreateFileSystem' :: Maybe ThroughputMode
throughputMode = Maybe ThroughputMode
forall a. Maybe a
Prelude.Nothing,
      $sel:kmsKeyId:CreateFileSystem' :: Maybe Text
kmsKeyId = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateFileSystem' :: Maybe [Tag]
tags = Maybe [Tag]
forall a. Maybe a
Prelude.Nothing,
      $sel:creationToken:CreateFileSystem' :: Text
creationToken = Text
pCreationToken_
    }

-- | The throughput, measured in MiB\/s, that you want to provision for a
-- file system that you\'re creating. Valid values are 1-1024. Required if
-- @ThroughputMode@ is set to @provisioned@. The upper limit for throughput
-- is 1024 MiB\/s. To increase this limit, contact Amazon Web Services
-- Support. For more information, see
-- <https://docs.aws.amazon.com/efs/latest/ug/limits.html#soft-limits Amazon EFS quotas that you can increase>
-- in the /Amazon EFS User Guide/.
createFileSystem_provisionedThroughputInMibps :: Lens.Lens' CreateFileSystem (Prelude.Maybe Prelude.Double)
createFileSystem_provisionedThroughputInMibps :: (Maybe Double -> f (Maybe Double))
-> CreateFileSystem -> f CreateFileSystem
createFileSystem_provisionedThroughputInMibps = (CreateFileSystem -> Maybe Double)
-> (CreateFileSystem -> Maybe Double -> CreateFileSystem)
-> Lens
     CreateFileSystem CreateFileSystem (Maybe Double) (Maybe Double)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFileSystem' {Maybe Double
provisionedThroughputInMibps :: Maybe Double
$sel:provisionedThroughputInMibps:CreateFileSystem' :: CreateFileSystem -> Maybe Double
provisionedThroughputInMibps} -> Maybe Double
provisionedThroughputInMibps) (\s :: CreateFileSystem
s@CreateFileSystem' {} Maybe Double
a -> CreateFileSystem
s {$sel:provisionedThroughputInMibps:CreateFileSystem' :: Maybe Double
provisionedThroughputInMibps = Maybe Double
a} :: CreateFileSystem)

-- | Used to create a file system that uses One Zone storage classes. It
-- specifies the Amazon Web Services Availability Zone in which to create
-- the file system. Use the format @us-east-1a@ to specify the Availability
-- Zone. For more information about One Zone storage classes, see
-- <https://docs.aws.amazon.com/efs/latest/ug/storage-classes.html Using EFS storage classes>
-- in the /Amazon EFS User Guide/.
--
-- One Zone storage classes are not available in all Availability Zones in
-- Amazon Web Services Regions where Amazon EFS is available.
createFileSystem_availabilityZoneName :: Lens.Lens' CreateFileSystem (Prelude.Maybe Prelude.Text)
createFileSystem_availabilityZoneName :: (Maybe Text -> f (Maybe Text))
-> CreateFileSystem -> f CreateFileSystem
createFileSystem_availabilityZoneName = (CreateFileSystem -> Maybe Text)
-> (CreateFileSystem -> Maybe Text -> CreateFileSystem)
-> Lens CreateFileSystem CreateFileSystem (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFileSystem' {Maybe Text
availabilityZoneName :: Maybe Text
$sel:availabilityZoneName:CreateFileSystem' :: CreateFileSystem -> Maybe Text
availabilityZoneName} -> Maybe Text
availabilityZoneName) (\s :: CreateFileSystem
s@CreateFileSystem' {} Maybe Text
a -> CreateFileSystem
s {$sel:availabilityZoneName:CreateFileSystem' :: Maybe Text
availabilityZoneName = Maybe Text
a} :: CreateFileSystem)

-- | The performance mode of the file system. We recommend @generalPurpose@
-- performance mode for most file systems. File systems using the @maxIO@
-- performance mode can scale to higher levels of aggregate throughput and
-- operations per second with a tradeoff of slightly higher latencies for
-- most file operations. The performance mode can\'t be changed after the
-- file system has been created.
--
-- The @maxIO@ mode is not supported on file systems using One Zone storage
-- classes.
createFileSystem_performanceMode :: Lens.Lens' CreateFileSystem (Prelude.Maybe PerformanceMode)
createFileSystem_performanceMode :: (Maybe PerformanceMode -> f (Maybe PerformanceMode))
-> CreateFileSystem -> f CreateFileSystem
createFileSystem_performanceMode = (CreateFileSystem -> Maybe PerformanceMode)
-> (CreateFileSystem -> Maybe PerformanceMode -> CreateFileSystem)
-> Lens
     CreateFileSystem
     CreateFileSystem
     (Maybe PerformanceMode)
     (Maybe PerformanceMode)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFileSystem' {Maybe PerformanceMode
performanceMode :: Maybe PerformanceMode
$sel:performanceMode:CreateFileSystem' :: CreateFileSystem -> Maybe PerformanceMode
performanceMode} -> Maybe PerformanceMode
performanceMode) (\s :: CreateFileSystem
s@CreateFileSystem' {} Maybe PerformanceMode
a -> CreateFileSystem
s {$sel:performanceMode:CreateFileSystem' :: Maybe PerformanceMode
performanceMode = Maybe PerformanceMode
a} :: CreateFileSystem)

-- | Specifies whether automatic backups are enabled on the file system that
-- you are creating. Set the value to @true@ to enable automatic backups.
-- If you are creating a file system that uses One Zone storage classes,
-- automatic backups are enabled by default. For more information, see
-- <https://docs.aws.amazon.com/efs/latest/ug/awsbackup.html#automatic-backups Automatic backups>
-- in the /Amazon EFS User Guide/.
--
-- Default is @false@. However, if you specify an @AvailabilityZoneName@,
-- the default is @true@.
--
-- Backup is not available in all Amazon Web Services Regionswhere Amazon
-- EFS is available.
createFileSystem_backup :: Lens.Lens' CreateFileSystem (Prelude.Maybe Prelude.Bool)
createFileSystem_backup :: (Maybe Bool -> f (Maybe Bool))
-> CreateFileSystem -> f CreateFileSystem
createFileSystem_backup = (CreateFileSystem -> Maybe Bool)
-> (CreateFileSystem -> Maybe Bool -> CreateFileSystem)
-> Lens CreateFileSystem CreateFileSystem (Maybe Bool) (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFileSystem' {Maybe Bool
backup :: Maybe Bool
$sel:backup:CreateFileSystem' :: CreateFileSystem -> Maybe Bool
backup} -> Maybe Bool
backup) (\s :: CreateFileSystem
s@CreateFileSystem' {} Maybe Bool
a -> CreateFileSystem
s {$sel:backup:CreateFileSystem' :: Maybe Bool
backup = Maybe Bool
a} :: CreateFileSystem)

-- | A Boolean value that, if true, creates an encrypted file system. When
-- creating an encrypted file system, you have the option of specifying
-- CreateFileSystemRequest$KmsKeyId for an existing Key Management Service
-- (KMS customer master key (CMK). If you don\'t specify a CMK, then the
-- default CMK for Amazon EFS, @\/aws\/elasticfilesystem@, is used to
-- protect the encrypted file system.
createFileSystem_encrypted :: Lens.Lens' CreateFileSystem (Prelude.Maybe Prelude.Bool)
createFileSystem_encrypted :: (Maybe Bool -> f (Maybe Bool))
-> CreateFileSystem -> f CreateFileSystem
createFileSystem_encrypted = (CreateFileSystem -> Maybe Bool)
-> (CreateFileSystem -> Maybe Bool -> CreateFileSystem)
-> Lens CreateFileSystem CreateFileSystem (Maybe Bool) (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFileSystem' {Maybe Bool
encrypted :: Maybe Bool
$sel:encrypted:CreateFileSystem' :: CreateFileSystem -> Maybe Bool
encrypted} -> Maybe Bool
encrypted) (\s :: CreateFileSystem
s@CreateFileSystem' {} Maybe Bool
a -> CreateFileSystem
s {$sel:encrypted:CreateFileSystem' :: Maybe Bool
encrypted = Maybe Bool
a} :: CreateFileSystem)

-- | Specifies the throughput mode for the file system, either @bursting@ or
-- @provisioned@. If you set @ThroughputMode@ to @provisioned@, you must
-- also set a value for @ProvisionedThroughputInMibps@. After you create
-- the file system, you can decrease your file system\'s throughput in
-- Provisioned Throughput mode or change between the throughput modes, as
-- long as it’s been more than 24 hours since the last decrease or
-- throughput mode change. For more information, see
-- <https://docs.aws.amazon.com/efs/latest/ug/performance.html#provisioned-throughput Specifying throughput with provisioned mode>
-- in the /Amazon EFS User Guide/.
--
-- Default is @bursting@.
createFileSystem_throughputMode :: Lens.Lens' CreateFileSystem (Prelude.Maybe ThroughputMode)
createFileSystem_throughputMode :: (Maybe ThroughputMode -> f (Maybe ThroughputMode))
-> CreateFileSystem -> f CreateFileSystem
createFileSystem_throughputMode = (CreateFileSystem -> Maybe ThroughputMode)
-> (CreateFileSystem -> Maybe ThroughputMode -> CreateFileSystem)
-> Lens
     CreateFileSystem
     CreateFileSystem
     (Maybe ThroughputMode)
     (Maybe ThroughputMode)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFileSystem' {Maybe ThroughputMode
throughputMode :: Maybe ThroughputMode
$sel:throughputMode:CreateFileSystem' :: CreateFileSystem -> Maybe ThroughputMode
throughputMode} -> Maybe ThroughputMode
throughputMode) (\s :: CreateFileSystem
s@CreateFileSystem' {} Maybe ThroughputMode
a -> CreateFileSystem
s {$sel:throughputMode:CreateFileSystem' :: Maybe ThroughputMode
throughputMode = Maybe ThroughputMode
a} :: CreateFileSystem)

-- | The ID of the KMS CMK that you want to use to protect the encrypted file
-- system. This parameter is only required if you want to use a non-default
-- KMS key. If this parameter is not specified, the default CMK for Amazon
-- EFS is used. This ID can be in one of the following formats:
--
-- -   Key ID - A unique identifier of the key, for example
--     @1234abcd-12ab-34cd-56ef-1234567890ab@.
--
-- -   ARN - An Amazon Resource Name (ARN) for the key, for example
--     @arn:aws:kms:us-west-2:111122223333:key\/1234abcd-12ab-34cd-56ef-1234567890ab@.
--
-- -   Key alias - A previously created display name for a key, for example
--     @alias\/projectKey1@.
--
-- -   Key alias ARN - An ARN for a key alias, for example
--     @arn:aws:kms:us-west-2:444455556666:alias\/projectKey1@.
--
-- If @KmsKeyId@ is specified, the CreateFileSystemRequest$Encrypted
-- parameter must be set to true.
--
-- EFS accepts only symmetric KMS keys. You cannot use asymmetric KMS keys
-- with EFS file systems.
createFileSystem_kmsKeyId :: Lens.Lens' CreateFileSystem (Prelude.Maybe Prelude.Text)
createFileSystem_kmsKeyId :: (Maybe Text -> f (Maybe Text))
-> CreateFileSystem -> f CreateFileSystem
createFileSystem_kmsKeyId = (CreateFileSystem -> Maybe Text)
-> (CreateFileSystem -> Maybe Text -> CreateFileSystem)
-> Lens CreateFileSystem CreateFileSystem (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFileSystem' {Maybe Text
kmsKeyId :: Maybe Text
$sel:kmsKeyId:CreateFileSystem' :: CreateFileSystem -> Maybe Text
kmsKeyId} -> Maybe Text
kmsKeyId) (\s :: CreateFileSystem
s@CreateFileSystem' {} Maybe Text
a -> CreateFileSystem
s {$sel:kmsKeyId:CreateFileSystem' :: Maybe Text
kmsKeyId = Maybe Text
a} :: CreateFileSystem)

-- | Use to create one or more tags associated with the file system. Each tag
-- is a user-defined key-value pair. Name your file system on creation by
-- including a @\"Key\":\"Name\",\"Value\":\"{value}\"@ key-value pair.
-- Each key must be unique. For more information, see
-- <https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html Tagging Amazon Web Services resources>
-- in the /Amazon Web Services General Reference Guide/.
createFileSystem_tags :: Lens.Lens' CreateFileSystem (Prelude.Maybe [Tag])
createFileSystem_tags :: (Maybe [Tag] -> f (Maybe [Tag]))
-> CreateFileSystem -> f CreateFileSystem
createFileSystem_tags = (CreateFileSystem -> Maybe [Tag])
-> (CreateFileSystem -> Maybe [Tag] -> CreateFileSystem)
-> Lens
     CreateFileSystem CreateFileSystem (Maybe [Tag]) (Maybe [Tag])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFileSystem' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateFileSystem' :: CreateFileSystem -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateFileSystem
s@CreateFileSystem' {} Maybe [Tag]
a -> CreateFileSystem
s {$sel:tags:CreateFileSystem' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateFileSystem) ((Maybe [Tag] -> f (Maybe [Tag]))
 -> CreateFileSystem -> f CreateFileSystem)
-> ((Maybe [Tag] -> f (Maybe [Tag]))
    -> Maybe [Tag] -> f (Maybe [Tag]))
-> (Maybe [Tag] -> f (Maybe [Tag]))
-> CreateFileSystem
-> f CreateFileSystem
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

-- | A string of up to 64 ASCII characters. Amazon EFS uses this to ensure
-- idempotent creation.
createFileSystem_creationToken :: Lens.Lens' CreateFileSystem Prelude.Text
createFileSystem_creationToken :: (Text -> f Text) -> CreateFileSystem -> f CreateFileSystem
createFileSystem_creationToken = (CreateFileSystem -> Text)
-> (CreateFileSystem -> Text -> CreateFileSystem)
-> Lens CreateFileSystem CreateFileSystem Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFileSystem' {Text
creationToken :: Text
$sel:creationToken:CreateFileSystem' :: CreateFileSystem -> Text
creationToken} -> Text
creationToken) (\s :: CreateFileSystem
s@CreateFileSystem' {} Text
a -> CreateFileSystem
s {$sel:creationToken:CreateFileSystem' :: Text
creationToken = Text
a} :: CreateFileSystem)

instance Core.AWSRequest CreateFileSystem where
  type
    AWSResponse CreateFileSystem =
      FileSystemDescription
  request :: CreateFileSystem -> Request CreateFileSystem
request = Service -> CreateFileSystem -> Request CreateFileSystem
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON Service
defaultService
  response :: Logger
-> Service
-> Proxy CreateFileSystem
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateFileSystem)))
response =
    (Int
 -> ResponseHeaders
 -> Object
 -> Either String (AWSResponse CreateFileSystem))
-> Logger
-> Service
-> Proxy CreateFileSystem
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateFileSystem)))
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 -> Object -> Either String FileSystemDescription
forall a. FromJSON a => Object -> Either String a
Core.eitherParseJSON Object
x)

instance Prelude.Hashable CreateFileSystem

instance Prelude.NFData CreateFileSystem

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

instance Core.ToJSON CreateFileSystem where
  toJSON :: CreateFileSystem -> Value
toJSON CreateFileSystem' {Maybe Bool
Maybe Double
Maybe [Tag]
Maybe Text
Maybe PerformanceMode
Maybe ThroughputMode
Text
creationToken :: Text
tags :: Maybe [Tag]
kmsKeyId :: Maybe Text
throughputMode :: Maybe ThroughputMode
encrypted :: Maybe Bool
backup :: Maybe Bool
performanceMode :: Maybe PerformanceMode
availabilityZoneName :: Maybe Text
provisionedThroughputInMibps :: Maybe Double
$sel:creationToken:CreateFileSystem' :: CreateFileSystem -> Text
$sel:tags:CreateFileSystem' :: CreateFileSystem -> Maybe [Tag]
$sel:kmsKeyId:CreateFileSystem' :: CreateFileSystem -> Maybe Text
$sel:throughputMode:CreateFileSystem' :: CreateFileSystem -> Maybe ThroughputMode
$sel:encrypted:CreateFileSystem' :: CreateFileSystem -> Maybe Bool
$sel:backup:CreateFileSystem' :: CreateFileSystem -> Maybe Bool
$sel:performanceMode:CreateFileSystem' :: CreateFileSystem -> Maybe PerformanceMode
$sel:availabilityZoneName:CreateFileSystem' :: CreateFileSystem -> Maybe Text
$sel:provisionedThroughputInMibps:CreateFileSystem' :: CreateFileSystem -> Maybe Double
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"ProvisionedThroughputInMibps" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Double
provisionedThroughputInMibps,
            (Text
"AvailabilityZoneName" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
availabilityZoneName,
            (Text
"PerformanceMode" Text -> PerformanceMode -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (PerformanceMode -> Pair) -> Maybe PerformanceMode -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe PerformanceMode
performanceMode,
            (Text
"Backup" Text -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Bool -> Pair) -> Maybe Bool -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Bool
backup,
            (Text
"Encrypted" Text -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Bool -> Pair) -> Maybe Bool -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Bool
encrypted,
            (Text
"ThroughputMode" Text -> ThroughputMode -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (ThroughputMode -> Pair) -> Maybe ThroughputMode -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ThroughputMode
throughputMode,
            (Text
"KmsKeyId" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
kmsKeyId,
            (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
"CreationToken" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Text
creationToken)
          ]
      )

instance Core.ToPath CreateFileSystem where
  toPath :: CreateFileSystem -> ByteString
toPath = ByteString -> CreateFileSystem -> ByteString
forall a b. a -> b -> a
Prelude.const ByteString
"/2015-02-01/file-systems"

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