{-# 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.CloudHSMV2.CopyBackupToRegion
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Copy an AWS CloudHSM cluster backup to a different region.
module Amazonka.CloudHSMV2.CopyBackupToRegion
  ( -- * Creating a Request
    CopyBackupToRegion (..),
    newCopyBackupToRegion,

    -- * Request Lenses
    copyBackupToRegion_tagList,
    copyBackupToRegion_destinationRegion,
    copyBackupToRegion_backupId,

    -- * Destructuring the Response
    CopyBackupToRegionResponse (..),
    newCopyBackupToRegionResponse,

    -- * Response Lenses
    copyBackupToRegionResponse_destinationBackup,
    copyBackupToRegionResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCopyBackupToRegion' smart constructor.
data CopyBackupToRegion = CopyBackupToRegion'
  { -- | Tags to apply to the destination backup during creation. If you specify
    -- tags, only these tags will be applied to the destination backup. If you
    -- do not specify tags, the service copies tags from the source backup to
    -- the destination backup.
    CopyBackupToRegion -> Maybe [Tag]
tagList :: Prelude.Maybe [Tag],
    -- | The AWS region that will contain your copied CloudHSM cluster backup.
    CopyBackupToRegion -> Text
destinationRegion :: Prelude.Text,
    -- | The ID of the backup that will be copied to the destination region.
    CopyBackupToRegion -> Text
backupId :: Prelude.Text
  }
  deriving (CopyBackupToRegion -> CopyBackupToRegion -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CopyBackupToRegion -> CopyBackupToRegion -> Bool
$c/= :: CopyBackupToRegion -> CopyBackupToRegion -> Bool
== :: CopyBackupToRegion -> CopyBackupToRegion -> Bool
$c== :: CopyBackupToRegion -> CopyBackupToRegion -> Bool
Prelude.Eq, ReadPrec [CopyBackupToRegion]
ReadPrec CopyBackupToRegion
Int -> ReadS CopyBackupToRegion
ReadS [CopyBackupToRegion]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CopyBackupToRegion]
$creadListPrec :: ReadPrec [CopyBackupToRegion]
readPrec :: ReadPrec CopyBackupToRegion
$creadPrec :: ReadPrec CopyBackupToRegion
readList :: ReadS [CopyBackupToRegion]
$creadList :: ReadS [CopyBackupToRegion]
readsPrec :: Int -> ReadS CopyBackupToRegion
$creadsPrec :: Int -> ReadS CopyBackupToRegion
Prelude.Read, Int -> CopyBackupToRegion -> ShowS
[CopyBackupToRegion] -> ShowS
CopyBackupToRegion -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CopyBackupToRegion] -> ShowS
$cshowList :: [CopyBackupToRegion] -> ShowS
show :: CopyBackupToRegion -> String
$cshow :: CopyBackupToRegion -> String
showsPrec :: Int -> CopyBackupToRegion -> ShowS
$cshowsPrec :: Int -> CopyBackupToRegion -> ShowS
Prelude.Show, forall x. Rep CopyBackupToRegion x -> CopyBackupToRegion
forall x. CopyBackupToRegion -> Rep CopyBackupToRegion x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CopyBackupToRegion x -> CopyBackupToRegion
$cfrom :: forall x. CopyBackupToRegion -> Rep CopyBackupToRegion x
Prelude.Generic)

-- |
-- Create a value of 'CopyBackupToRegion' 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:
--
-- 'tagList', 'copyBackupToRegion_tagList' - Tags to apply to the destination backup during creation. If you specify
-- tags, only these tags will be applied to the destination backup. If you
-- do not specify tags, the service copies tags from the source backup to
-- the destination backup.
--
-- 'destinationRegion', 'copyBackupToRegion_destinationRegion' - The AWS region that will contain your copied CloudHSM cluster backup.
--
-- 'backupId', 'copyBackupToRegion_backupId' - The ID of the backup that will be copied to the destination region.
newCopyBackupToRegion ::
  -- | 'destinationRegion'
  Prelude.Text ->
  -- | 'backupId'
  Prelude.Text ->
  CopyBackupToRegion
newCopyBackupToRegion :: Text -> Text -> CopyBackupToRegion
newCopyBackupToRegion Text
pDestinationRegion_ Text
pBackupId_ =
  CopyBackupToRegion'
    { $sel:tagList:CopyBackupToRegion' :: Maybe [Tag]
tagList = forall a. Maybe a
Prelude.Nothing,
      $sel:destinationRegion:CopyBackupToRegion' :: Text
destinationRegion = Text
pDestinationRegion_,
      $sel:backupId:CopyBackupToRegion' :: Text
backupId = Text
pBackupId_
    }

-- | Tags to apply to the destination backup during creation. If you specify
-- tags, only these tags will be applied to the destination backup. If you
-- do not specify tags, the service copies tags from the source backup to
-- the destination backup.
copyBackupToRegion_tagList :: Lens.Lens' CopyBackupToRegion (Prelude.Maybe [Tag])
copyBackupToRegion_tagList :: Lens' CopyBackupToRegion (Maybe [Tag])
copyBackupToRegion_tagList = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyBackupToRegion' {Maybe [Tag]
tagList :: Maybe [Tag]
$sel:tagList:CopyBackupToRegion' :: CopyBackupToRegion -> Maybe [Tag]
tagList} -> Maybe [Tag]
tagList) (\s :: CopyBackupToRegion
s@CopyBackupToRegion' {} Maybe [Tag]
a -> CopyBackupToRegion
s {$sel:tagList:CopyBackupToRegion' :: Maybe [Tag]
tagList = Maybe [Tag]
a} :: CopyBackupToRegion) 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 AWS region that will contain your copied CloudHSM cluster backup.
copyBackupToRegion_destinationRegion :: Lens.Lens' CopyBackupToRegion Prelude.Text
copyBackupToRegion_destinationRegion :: Lens' CopyBackupToRegion Text
copyBackupToRegion_destinationRegion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyBackupToRegion' {Text
destinationRegion :: Text
$sel:destinationRegion:CopyBackupToRegion' :: CopyBackupToRegion -> Text
destinationRegion} -> Text
destinationRegion) (\s :: CopyBackupToRegion
s@CopyBackupToRegion' {} Text
a -> CopyBackupToRegion
s {$sel:destinationRegion:CopyBackupToRegion' :: Text
destinationRegion = Text
a} :: CopyBackupToRegion)

-- | The ID of the backup that will be copied to the destination region.
copyBackupToRegion_backupId :: Lens.Lens' CopyBackupToRegion Prelude.Text
copyBackupToRegion_backupId :: Lens' CopyBackupToRegion Text
copyBackupToRegion_backupId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyBackupToRegion' {Text
backupId :: Text
$sel:backupId:CopyBackupToRegion' :: CopyBackupToRegion -> Text
backupId} -> Text
backupId) (\s :: CopyBackupToRegion
s@CopyBackupToRegion' {} Text
a -> CopyBackupToRegion
s {$sel:backupId:CopyBackupToRegion' :: Text
backupId = Text
a} :: CopyBackupToRegion)

instance Core.AWSRequest CopyBackupToRegion where
  type
    AWSResponse CopyBackupToRegion =
      CopyBackupToRegionResponse
  request :: (Service -> Service)
-> CopyBackupToRegion -> Request CopyBackupToRegion
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 CopyBackupToRegion
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CopyBackupToRegion)))
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 ->
          Maybe DestinationBackup -> Int -> CopyBackupToRegionResponse
CopyBackupToRegionResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"DestinationBackup")
            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 CopyBackupToRegion where
  hashWithSalt :: Int -> CopyBackupToRegion -> Int
hashWithSalt Int
_salt CopyBackupToRegion' {Maybe [Tag]
Text
backupId :: Text
destinationRegion :: Text
tagList :: Maybe [Tag]
$sel:backupId:CopyBackupToRegion' :: CopyBackupToRegion -> Text
$sel:destinationRegion:CopyBackupToRegion' :: CopyBackupToRegion -> Text
$sel:tagList:CopyBackupToRegion' :: CopyBackupToRegion -> Maybe [Tag]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tagList
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
destinationRegion
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
backupId

instance Prelude.NFData CopyBackupToRegion where
  rnf :: CopyBackupToRegion -> ()
rnf CopyBackupToRegion' {Maybe [Tag]
Text
backupId :: Text
destinationRegion :: Text
tagList :: Maybe [Tag]
$sel:backupId:CopyBackupToRegion' :: CopyBackupToRegion -> Text
$sel:destinationRegion:CopyBackupToRegion' :: CopyBackupToRegion -> Text
$sel:tagList:CopyBackupToRegion' :: CopyBackupToRegion -> Maybe [Tag]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Tag]
tagList
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
destinationRegion
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
backupId

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

instance Data.ToJSON CopyBackupToRegion where
  toJSON :: CopyBackupToRegion -> Value
toJSON CopyBackupToRegion' {Maybe [Tag]
Text
backupId :: Text
destinationRegion :: Text
tagList :: Maybe [Tag]
$sel:backupId:CopyBackupToRegion' :: CopyBackupToRegion -> Text
$sel:destinationRegion:CopyBackupToRegion' :: CopyBackupToRegion -> Text
$sel:tagList:CopyBackupToRegion' :: CopyBackupToRegion -> Maybe [Tag]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"TagList" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Tag]
tagList,
            forall a. a -> Maybe a
Prelude.Just
              (Key
"DestinationRegion" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
destinationRegion),
            forall a. a -> Maybe a
Prelude.Just (Key
"BackupId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
backupId)
          ]
      )

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

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

-- | /See:/ 'newCopyBackupToRegionResponse' smart constructor.
data CopyBackupToRegionResponse = CopyBackupToRegionResponse'
  { -- | Information on the backup that will be copied to the destination region,
    -- including CreateTimestamp, SourceBackup, SourceCluster, and Source
    -- Region. CreateTimestamp of the destination backup will be the same as
    -- that of the source backup.
    --
    -- You will need to use the @sourceBackupID@ returned in this operation to
    -- use the DescribeBackups operation on the backup that will be copied to
    -- the destination region.
    CopyBackupToRegionResponse -> Maybe DestinationBackup
destinationBackup :: Prelude.Maybe DestinationBackup,
    -- | The response's http status code.
    CopyBackupToRegionResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CopyBackupToRegionResponse -> CopyBackupToRegionResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CopyBackupToRegionResponse -> CopyBackupToRegionResponse -> Bool
$c/= :: CopyBackupToRegionResponse -> CopyBackupToRegionResponse -> Bool
== :: CopyBackupToRegionResponse -> CopyBackupToRegionResponse -> Bool
$c== :: CopyBackupToRegionResponse -> CopyBackupToRegionResponse -> Bool
Prelude.Eq, ReadPrec [CopyBackupToRegionResponse]
ReadPrec CopyBackupToRegionResponse
Int -> ReadS CopyBackupToRegionResponse
ReadS [CopyBackupToRegionResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CopyBackupToRegionResponse]
$creadListPrec :: ReadPrec [CopyBackupToRegionResponse]
readPrec :: ReadPrec CopyBackupToRegionResponse
$creadPrec :: ReadPrec CopyBackupToRegionResponse
readList :: ReadS [CopyBackupToRegionResponse]
$creadList :: ReadS [CopyBackupToRegionResponse]
readsPrec :: Int -> ReadS CopyBackupToRegionResponse
$creadsPrec :: Int -> ReadS CopyBackupToRegionResponse
Prelude.Read, Int -> CopyBackupToRegionResponse -> ShowS
[CopyBackupToRegionResponse] -> ShowS
CopyBackupToRegionResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CopyBackupToRegionResponse] -> ShowS
$cshowList :: [CopyBackupToRegionResponse] -> ShowS
show :: CopyBackupToRegionResponse -> String
$cshow :: CopyBackupToRegionResponse -> String
showsPrec :: Int -> CopyBackupToRegionResponse -> ShowS
$cshowsPrec :: Int -> CopyBackupToRegionResponse -> ShowS
Prelude.Show, forall x.
Rep CopyBackupToRegionResponse x -> CopyBackupToRegionResponse
forall x.
CopyBackupToRegionResponse -> Rep CopyBackupToRegionResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CopyBackupToRegionResponse x -> CopyBackupToRegionResponse
$cfrom :: forall x.
CopyBackupToRegionResponse -> Rep CopyBackupToRegionResponse x
Prelude.Generic)

-- |
-- Create a value of 'CopyBackupToRegionResponse' 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:
--
-- 'destinationBackup', 'copyBackupToRegionResponse_destinationBackup' - Information on the backup that will be copied to the destination region,
-- including CreateTimestamp, SourceBackup, SourceCluster, and Source
-- Region. CreateTimestamp of the destination backup will be the same as
-- that of the source backup.
--
-- You will need to use the @sourceBackupID@ returned in this operation to
-- use the DescribeBackups operation on the backup that will be copied to
-- the destination region.
--
-- 'httpStatus', 'copyBackupToRegionResponse_httpStatus' - The response's http status code.
newCopyBackupToRegionResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CopyBackupToRegionResponse
newCopyBackupToRegionResponse :: Int -> CopyBackupToRegionResponse
newCopyBackupToRegionResponse Int
pHttpStatus_ =
  CopyBackupToRegionResponse'
    { $sel:destinationBackup:CopyBackupToRegionResponse' :: Maybe DestinationBackup
destinationBackup =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CopyBackupToRegionResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Information on the backup that will be copied to the destination region,
-- including CreateTimestamp, SourceBackup, SourceCluster, and Source
-- Region. CreateTimestamp of the destination backup will be the same as
-- that of the source backup.
--
-- You will need to use the @sourceBackupID@ returned in this operation to
-- use the DescribeBackups operation on the backup that will be copied to
-- the destination region.
copyBackupToRegionResponse_destinationBackup :: Lens.Lens' CopyBackupToRegionResponse (Prelude.Maybe DestinationBackup)
copyBackupToRegionResponse_destinationBackup :: Lens' CopyBackupToRegionResponse (Maybe DestinationBackup)
copyBackupToRegionResponse_destinationBackup = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyBackupToRegionResponse' {Maybe DestinationBackup
destinationBackup :: Maybe DestinationBackup
$sel:destinationBackup:CopyBackupToRegionResponse' :: CopyBackupToRegionResponse -> Maybe DestinationBackup
destinationBackup} -> Maybe DestinationBackup
destinationBackup) (\s :: CopyBackupToRegionResponse
s@CopyBackupToRegionResponse' {} Maybe DestinationBackup
a -> CopyBackupToRegionResponse
s {$sel:destinationBackup:CopyBackupToRegionResponse' :: Maybe DestinationBackup
destinationBackup = Maybe DestinationBackup
a} :: CopyBackupToRegionResponse)

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

instance Prelude.NFData CopyBackupToRegionResponse where
  rnf :: CopyBackupToRegionResponse -> ()
rnf CopyBackupToRegionResponse' {Int
Maybe DestinationBackup
httpStatus :: Int
destinationBackup :: Maybe DestinationBackup
$sel:httpStatus:CopyBackupToRegionResponse' :: CopyBackupToRegionResponse -> Int
$sel:destinationBackup:CopyBackupToRegionResponse' :: CopyBackupToRegionResponse -> Maybe DestinationBackup
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe DestinationBackup
destinationBackup
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus