{-# 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.CreateReplicationConfiguration
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates a replication configuration that replicates an existing EFS file
-- system to a new, read-only file system. For more information, see
-- <https://docs.aws.amazon.com/efs/latest/ug/efs-replication.html Amazon EFS replication>
-- in the /Amazon EFS User Guide/. The replication configuration specifies
-- the following:
--
-- -   __Source file system__ - An existing EFS file system that you want
--     replicated. The source file system cannot be a destination file
--     system in an existing replication configuration.
--
-- -   __Destination file system configuration__ - The configuration of the
--     destination file system to which the source file system will be
--     replicated. There can only be one destination file system in a
--     replication configuration. The destination file system configuration
--     consists of the following properties:
--
--     -   __Amazon Web Services Region__ - The Amazon Web Services Region
--         in which the destination file system is created. Amazon EFS
--         replication is available in all Amazon Web Services Regions that
--         Amazon EFS is available in, except Africa (Cape Town), Asia
--         Pacific (Hong Kong), Asia Pacific (Jakarta), Europe (Milan), and
--         Middle East (Bahrain).
--
--     -   __Availability Zone__ - If you want the destination file system
--         to use EFS One Zone availability and durability, you must
--         specify the Availability Zone to create the file system in. For
--         more information about EFS storage classes, see
--         <https://docs.aws.amazon.com/efs/latest/ug/storage-classes.html Amazon EFS storage classes>
--         in the /Amazon EFS User Guide/.
--
--     -   __Encryption__ - All destination file systems are created with
--         encryption at rest enabled. You can specify the Key Management
--         Service (KMS) key that is used to encrypt the destination file
--         system. If you don\'t specify a KMS key, your service-managed
--         KMS key for Amazon EFS is used.
--
--         After the file system is created, you cannot change the KMS key.
--
-- The following properties are set by default:
--
-- -   __Performance mode__ - The destination file system\'s performance
--     mode matches that of the source file system, unless the destination
--     file system uses EFS One Zone storage. In that case, the General
--     Purpose performance mode is used. The performance mode cannot be
--     changed.
--
-- -   __Throughput mode__ - The destination file system uses the Bursting
--     Throughput mode by default. After the file system is created, you
--     can modify the throughput mode.
--
-- The following properties are turned off by default:
--
-- -   __Lifecycle management__ - EFS lifecycle management and EFS
--     Intelligent-Tiering are not enabled on the destination file system.
--     After the destination file system is created, you can enable EFS
--     lifecycle management and EFS Intelligent-Tiering.
--
-- -   __Automatic backups__ - Automatic daily backups not enabled on the
--     destination file system. After the file system is created, you can
--     change this setting.
--
-- For more information, see
-- <https://docs.aws.amazon.com/efs/latest/ug/efs-replication.html Amazon EFS replication>
-- in the /Amazon EFS User Guide/.
module Amazonka.EFS.CreateReplicationConfiguration
  ( -- * Creating a Request
    CreateReplicationConfiguration (..),
    newCreateReplicationConfiguration,

    -- * Request Lenses
    createReplicationConfiguration_sourceFileSystemId,
    createReplicationConfiguration_destinations,

    -- * Destructuring the Response
    ReplicationConfigurationDescription (..),
    newReplicationConfigurationDescription,

    -- * Response Lenses
    replicationConfigurationDescription_sourceFileSystemId,
    replicationConfigurationDescription_sourceFileSystemRegion,
    replicationConfigurationDescription_sourceFileSystemArn,
    replicationConfigurationDescription_originalSourceFileSystemArn,
    replicationConfigurationDescription_creationTime,
    replicationConfigurationDescription_destinations,
  )
where

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

-- | /See:/ 'newCreateReplicationConfiguration' smart constructor.
data CreateReplicationConfiguration = CreateReplicationConfiguration'
  { -- | Specifies the Amazon EFS file system that you want to replicate. This
    -- file system cannot already be a source or destination file system in
    -- another replication configuration.
    CreateReplicationConfiguration -> Text
sourceFileSystemId :: Prelude.Text,
    -- | An array of destination configuration objects. Only one destination
    -- configuration object is supported.
    CreateReplicationConfiguration -> [DestinationToCreate]
destinations :: [DestinationToCreate]
  }
  deriving (CreateReplicationConfiguration
-> CreateReplicationConfiguration -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateReplicationConfiguration
-> CreateReplicationConfiguration -> Bool
$c/= :: CreateReplicationConfiguration
-> CreateReplicationConfiguration -> Bool
== :: CreateReplicationConfiguration
-> CreateReplicationConfiguration -> Bool
$c== :: CreateReplicationConfiguration
-> CreateReplicationConfiguration -> Bool
Prelude.Eq, ReadPrec [CreateReplicationConfiguration]
ReadPrec CreateReplicationConfiguration
Int -> ReadS CreateReplicationConfiguration
ReadS [CreateReplicationConfiguration]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateReplicationConfiguration]
$creadListPrec :: ReadPrec [CreateReplicationConfiguration]
readPrec :: ReadPrec CreateReplicationConfiguration
$creadPrec :: ReadPrec CreateReplicationConfiguration
readList :: ReadS [CreateReplicationConfiguration]
$creadList :: ReadS [CreateReplicationConfiguration]
readsPrec :: Int -> ReadS CreateReplicationConfiguration
$creadsPrec :: Int -> ReadS CreateReplicationConfiguration
Prelude.Read, Int -> CreateReplicationConfiguration -> ShowS
[CreateReplicationConfiguration] -> ShowS
CreateReplicationConfiguration -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateReplicationConfiguration] -> ShowS
$cshowList :: [CreateReplicationConfiguration] -> ShowS
show :: CreateReplicationConfiguration -> String
$cshow :: CreateReplicationConfiguration -> String
showsPrec :: Int -> CreateReplicationConfiguration -> ShowS
$cshowsPrec :: Int -> CreateReplicationConfiguration -> ShowS
Prelude.Show, forall x.
Rep CreateReplicationConfiguration x
-> CreateReplicationConfiguration
forall x.
CreateReplicationConfiguration
-> Rep CreateReplicationConfiguration x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateReplicationConfiguration x
-> CreateReplicationConfiguration
$cfrom :: forall x.
CreateReplicationConfiguration
-> Rep CreateReplicationConfiguration x
Prelude.Generic)

-- |
-- Create a value of 'CreateReplicationConfiguration' 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:
--
-- 'sourceFileSystemId', 'createReplicationConfiguration_sourceFileSystemId' - Specifies the Amazon EFS file system that you want to replicate. This
-- file system cannot already be a source or destination file system in
-- another replication configuration.
--
-- 'destinations', 'createReplicationConfiguration_destinations' - An array of destination configuration objects. Only one destination
-- configuration object is supported.
newCreateReplicationConfiguration ::
  -- | 'sourceFileSystemId'
  Prelude.Text ->
  CreateReplicationConfiguration
newCreateReplicationConfiguration :: Text -> CreateReplicationConfiguration
newCreateReplicationConfiguration
  Text
pSourceFileSystemId_ =
    CreateReplicationConfiguration'
      { $sel:sourceFileSystemId:CreateReplicationConfiguration' :: Text
sourceFileSystemId =
          Text
pSourceFileSystemId_,
        $sel:destinations:CreateReplicationConfiguration' :: [DestinationToCreate]
destinations = forall a. Monoid a => a
Prelude.mempty
      }

-- | Specifies the Amazon EFS file system that you want to replicate. This
-- file system cannot already be a source or destination file system in
-- another replication configuration.
createReplicationConfiguration_sourceFileSystemId :: Lens.Lens' CreateReplicationConfiguration Prelude.Text
createReplicationConfiguration_sourceFileSystemId :: Lens' CreateReplicationConfiguration Text
createReplicationConfiguration_sourceFileSystemId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateReplicationConfiguration' {Text
sourceFileSystemId :: Text
$sel:sourceFileSystemId:CreateReplicationConfiguration' :: CreateReplicationConfiguration -> Text
sourceFileSystemId} -> Text
sourceFileSystemId) (\s :: CreateReplicationConfiguration
s@CreateReplicationConfiguration' {} Text
a -> CreateReplicationConfiguration
s {$sel:sourceFileSystemId:CreateReplicationConfiguration' :: Text
sourceFileSystemId = Text
a} :: CreateReplicationConfiguration)

-- | An array of destination configuration objects. Only one destination
-- configuration object is supported.
createReplicationConfiguration_destinations :: Lens.Lens' CreateReplicationConfiguration [DestinationToCreate]
createReplicationConfiguration_destinations :: Lens' CreateReplicationConfiguration [DestinationToCreate]
createReplicationConfiguration_destinations = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateReplicationConfiguration' {[DestinationToCreate]
destinations :: [DestinationToCreate]
$sel:destinations:CreateReplicationConfiguration' :: CreateReplicationConfiguration -> [DestinationToCreate]
destinations} -> [DestinationToCreate]
destinations) (\s :: CreateReplicationConfiguration
s@CreateReplicationConfiguration' {} [DestinationToCreate]
a -> CreateReplicationConfiguration
s {$sel:destinations:CreateReplicationConfiguration' :: [DestinationToCreate]
destinations = [DestinationToCreate]
a} :: CreateReplicationConfiguration) 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

instance
  Core.AWSRequest
    CreateReplicationConfiguration
  where
  type
    AWSResponse CreateReplicationConfiguration =
      ReplicationConfigurationDescription
  request :: (Service -> Service)
-> CreateReplicationConfiguration
-> Request CreateReplicationConfiguration
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy CreateReplicationConfiguration
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse (AWSResponse CreateReplicationConfiguration)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      (\Int
s ResponseHeaders
h Object
x -> forall a. FromJSON a => Object -> Either String a
Data.eitherParseJSON Object
x)

instance
  Prelude.Hashable
    CreateReplicationConfiguration
  where
  hashWithSalt :: Int -> CreateReplicationConfiguration -> Int
hashWithSalt
    Int
_salt
    CreateReplicationConfiguration' {[DestinationToCreate]
Text
destinations :: [DestinationToCreate]
sourceFileSystemId :: Text
$sel:destinations:CreateReplicationConfiguration' :: CreateReplicationConfiguration -> [DestinationToCreate]
$sel:sourceFileSystemId:CreateReplicationConfiguration' :: CreateReplicationConfiguration -> Text
..} =
      Int
_salt
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
sourceFileSystemId
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` [DestinationToCreate]
destinations

instance
  Prelude.NFData
    CreateReplicationConfiguration
  where
  rnf :: CreateReplicationConfiguration -> ()
rnf CreateReplicationConfiguration' {[DestinationToCreate]
Text
destinations :: [DestinationToCreate]
sourceFileSystemId :: Text
$sel:destinations:CreateReplicationConfiguration' :: CreateReplicationConfiguration -> [DestinationToCreate]
$sel:sourceFileSystemId:CreateReplicationConfiguration' :: CreateReplicationConfiguration -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
sourceFileSystemId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [DestinationToCreate]
destinations

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

instance Data.ToJSON CreateReplicationConfiguration where
  toJSON :: CreateReplicationConfiguration -> Value
toJSON CreateReplicationConfiguration' {[DestinationToCreate]
Text
destinations :: [DestinationToCreate]
sourceFileSystemId :: Text
$sel:destinations:CreateReplicationConfiguration' :: CreateReplicationConfiguration -> [DestinationToCreate]
$sel:sourceFileSystemId:CreateReplicationConfiguration' :: CreateReplicationConfiguration -> Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [forall a. a -> Maybe a
Prelude.Just (Key
"Destinations" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= [DestinationToCreate]
destinations)]
      )

instance Data.ToPath CreateReplicationConfiguration where
  toPath :: CreateReplicationConfiguration -> ByteString
toPath CreateReplicationConfiguration' {[DestinationToCreate]
Text
destinations :: [DestinationToCreate]
sourceFileSystemId :: Text
$sel:destinations:CreateReplicationConfiguration' :: CreateReplicationConfiguration -> [DestinationToCreate]
$sel:sourceFileSystemId:CreateReplicationConfiguration' :: CreateReplicationConfiguration -> Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/2015-02-01/file-systems/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
sourceFileSystemId,
        ByteString
"/replication-configuration"
      ]

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