{-# 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.ImportVolume
-- 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 an import volume task using metadata from the specified disk
-- image.
--
-- This API action supports only single-volume VMs. To import multi-volume
-- VMs, use ImportImage instead. To import a disk to a snapshot, use
-- ImportSnapshot instead.
--
-- This API action is not supported by the Command Line Interface (CLI).
-- For information about using the Amazon EC2 CLI, which is deprecated, see
-- <https://awsdocs.s3.amazonaws.com/EC2/ec2-clt.pdf#importing-your-volumes-into-amazon-ebs Importing Disks to Amazon EBS>
-- in the /Amazon EC2 CLI Reference/ PDF file.
--
-- For information about the import manifest referenced by this API action,
-- see
-- <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/manifest.html VM Import Manifest>.
module Amazonka.EC2.ImportVolume
  ( -- * Creating a Request
    ImportVolume (..),
    newImportVolume,

    -- * Request Lenses
    importVolume_description,
    importVolume_dryRun,
    importVolume_availabilityZone,
    importVolume_image,
    importVolume_volume,

    -- * Destructuring the Response
    ImportVolumeResponse (..),
    newImportVolumeResponse,

    -- * Response Lenses
    importVolumeResponse_conversionTask,
    importVolumeResponse_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:/ 'newImportVolume' smart constructor.
data ImportVolume = ImportVolume'
  { -- | A description of the volume.
    ImportVolume -> Maybe Text
description :: 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@.
    ImportVolume -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
    -- | The Availability Zone for the resulting EBS volume.
    ImportVolume -> Text
availabilityZone :: Prelude.Text,
    -- | The disk image.
    ImportVolume -> DiskImageDetail
image :: DiskImageDetail,
    -- | The volume size.
    ImportVolume -> VolumeDetail
volume :: VolumeDetail
  }
  deriving (ImportVolume -> ImportVolume -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ImportVolume -> ImportVolume -> Bool
$c/= :: ImportVolume -> ImportVolume -> Bool
== :: ImportVolume -> ImportVolume -> Bool
$c== :: ImportVolume -> ImportVolume -> Bool
Prelude.Eq, ReadPrec [ImportVolume]
ReadPrec ImportVolume
Int -> ReadS ImportVolume
ReadS [ImportVolume]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ImportVolume]
$creadListPrec :: ReadPrec [ImportVolume]
readPrec :: ReadPrec ImportVolume
$creadPrec :: ReadPrec ImportVolume
readList :: ReadS [ImportVolume]
$creadList :: ReadS [ImportVolume]
readsPrec :: Int -> ReadS ImportVolume
$creadsPrec :: Int -> ReadS ImportVolume
Prelude.Read, Int -> ImportVolume -> ShowS
[ImportVolume] -> ShowS
ImportVolume -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ImportVolume] -> ShowS
$cshowList :: [ImportVolume] -> ShowS
show :: ImportVolume -> String
$cshow :: ImportVolume -> String
showsPrec :: Int -> ImportVolume -> ShowS
$cshowsPrec :: Int -> ImportVolume -> ShowS
Prelude.Show, forall x. Rep ImportVolume x -> ImportVolume
forall x. ImportVolume -> Rep ImportVolume x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ImportVolume x -> ImportVolume
$cfrom :: forall x. ImportVolume -> Rep ImportVolume x
Prelude.Generic)

-- |
-- Create a value of 'ImportVolume' 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:
--
-- 'description', 'importVolume_description' - A description of the volume.
--
-- 'dryRun', 'importVolume_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@.
--
-- 'availabilityZone', 'importVolume_availabilityZone' - The Availability Zone for the resulting EBS volume.
--
-- 'image', 'importVolume_image' - The disk image.
--
-- 'volume', 'importVolume_volume' - The volume size.
newImportVolume ::
  -- | 'availabilityZone'
  Prelude.Text ->
  -- | 'image'
  DiskImageDetail ->
  -- | 'volume'
  VolumeDetail ->
  ImportVolume
newImportVolume :: Text -> DiskImageDetail -> VolumeDetail -> ImportVolume
newImportVolume Text
pAvailabilityZone_ DiskImageDetail
pImage_ VolumeDetail
pVolume_ =
  ImportVolume'
    { $sel:description:ImportVolume' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:dryRun:ImportVolume' :: Maybe Bool
dryRun = forall a. Maybe a
Prelude.Nothing,
      $sel:availabilityZone:ImportVolume' :: Text
availabilityZone = Text
pAvailabilityZone_,
      $sel:image:ImportVolume' :: DiskImageDetail
image = DiskImageDetail
pImage_,
      $sel:volume:ImportVolume' :: VolumeDetail
volume = VolumeDetail
pVolume_
    }

-- | A description of the volume.
importVolume_description :: Lens.Lens' ImportVolume (Prelude.Maybe Prelude.Text)
importVolume_description :: Lens' ImportVolume (Maybe Text)
importVolume_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ImportVolume' {Maybe Text
description :: Maybe Text
$sel:description:ImportVolume' :: ImportVolume -> Maybe Text
description} -> Maybe Text
description) (\s :: ImportVolume
s@ImportVolume' {} Maybe Text
a -> ImportVolume
s {$sel:description:ImportVolume' :: Maybe Text
description = Maybe Text
a} :: ImportVolume)

-- | 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@.
importVolume_dryRun :: Lens.Lens' ImportVolume (Prelude.Maybe Prelude.Bool)
importVolume_dryRun :: Lens' ImportVolume (Maybe Bool)
importVolume_dryRun = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ImportVolume' {Maybe Bool
dryRun :: Maybe Bool
$sel:dryRun:ImportVolume' :: ImportVolume -> Maybe Bool
dryRun} -> Maybe Bool
dryRun) (\s :: ImportVolume
s@ImportVolume' {} Maybe Bool
a -> ImportVolume
s {$sel:dryRun:ImportVolume' :: Maybe Bool
dryRun = Maybe Bool
a} :: ImportVolume)

-- | The Availability Zone for the resulting EBS volume.
importVolume_availabilityZone :: Lens.Lens' ImportVolume Prelude.Text
importVolume_availabilityZone :: Lens' ImportVolume Text
importVolume_availabilityZone = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ImportVolume' {Text
availabilityZone :: Text
$sel:availabilityZone:ImportVolume' :: ImportVolume -> Text
availabilityZone} -> Text
availabilityZone) (\s :: ImportVolume
s@ImportVolume' {} Text
a -> ImportVolume
s {$sel:availabilityZone:ImportVolume' :: Text
availabilityZone = Text
a} :: ImportVolume)

-- | The disk image.
importVolume_image :: Lens.Lens' ImportVolume DiskImageDetail
importVolume_image :: Lens' ImportVolume DiskImageDetail
importVolume_image = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ImportVolume' {DiskImageDetail
image :: DiskImageDetail
$sel:image:ImportVolume' :: ImportVolume -> DiskImageDetail
image} -> DiskImageDetail
image) (\s :: ImportVolume
s@ImportVolume' {} DiskImageDetail
a -> ImportVolume
s {$sel:image:ImportVolume' :: DiskImageDetail
image = DiskImageDetail
a} :: ImportVolume)

-- | The volume size.
importVolume_volume :: Lens.Lens' ImportVolume VolumeDetail
importVolume_volume :: Lens' ImportVolume VolumeDetail
importVolume_volume = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ImportVolume' {VolumeDetail
volume :: VolumeDetail
$sel:volume:ImportVolume' :: ImportVolume -> VolumeDetail
volume} -> VolumeDetail
volume) (\s :: ImportVolume
s@ImportVolume' {} VolumeDetail
a -> ImportVolume
s {$sel:volume:ImportVolume' :: VolumeDetail
volume = VolumeDetail
a} :: ImportVolume)

instance Core.AWSRequest ImportVolume where
  type AWSResponse ImportVolume = ImportVolumeResponse
  request :: (Service -> Service) -> ImportVolume -> Request ImportVolume
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 ImportVolume
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse ImportVolume)))
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 ConversionTask -> Int -> ImportVolumeResponse
ImportVolumeResponse'
            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
"conversionTask")
            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 ImportVolume where
  hashWithSalt :: Int -> ImportVolume -> Int
hashWithSalt Int
_salt ImportVolume' {Maybe Bool
Maybe Text
Text
DiskImageDetail
VolumeDetail
volume :: VolumeDetail
image :: DiskImageDetail
availabilityZone :: Text
dryRun :: Maybe Bool
description :: Maybe Text
$sel:volume:ImportVolume' :: ImportVolume -> VolumeDetail
$sel:image:ImportVolume' :: ImportVolume -> DiskImageDetail
$sel:availabilityZone:ImportVolume' :: ImportVolume -> Text
$sel:dryRun:ImportVolume' :: ImportVolume -> Maybe Bool
$sel:description:ImportVolume' :: ImportVolume -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
dryRun
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
availabilityZone
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` DiskImageDetail
image
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` VolumeDetail
volume

instance Prelude.NFData ImportVolume where
  rnf :: ImportVolume -> ()
rnf ImportVolume' {Maybe Bool
Maybe Text
Text
DiskImageDetail
VolumeDetail
volume :: VolumeDetail
image :: DiskImageDetail
availabilityZone :: Text
dryRun :: Maybe Bool
description :: Maybe Text
$sel:volume:ImportVolume' :: ImportVolume -> VolumeDetail
$sel:image:ImportVolume' :: ImportVolume -> DiskImageDetail
$sel:availabilityZone:ImportVolume' :: ImportVolume -> Text
$sel:dryRun:ImportVolume' :: ImportVolume -> Maybe Bool
$sel:description:ImportVolume' :: ImportVolume -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      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 Text
availabilityZone
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf DiskImageDetail
image
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf VolumeDetail
volume

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

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

instance Data.ToQuery ImportVolume where
  toQuery :: ImportVolume -> QueryString
toQuery ImportVolume' {Maybe Bool
Maybe Text
Text
DiskImageDetail
VolumeDetail
volume :: VolumeDetail
image :: DiskImageDetail
availabilityZone :: Text
dryRun :: Maybe Bool
description :: Maybe Text
$sel:volume:ImportVolume' :: ImportVolume -> VolumeDetail
$sel:image:ImportVolume' :: ImportVolume -> DiskImageDetail
$sel:availabilityZone:ImportVolume' :: ImportVolume -> Text
$sel:dryRun:ImportVolume' :: ImportVolume -> Maybe Bool
$sel:description:ImportVolume' :: ImportVolume -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"ImportVolume" :: Prelude.ByteString),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2016-11-15" :: Prelude.ByteString),
        ByteString
"Description" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
description,
        ByteString
"DryRun" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
dryRun,
        ByteString
"AvailabilityZone" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
availabilityZone,
        ByteString
"Image" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: DiskImageDetail
image,
        ByteString
"Volume" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: VolumeDetail
volume
      ]

-- | /See:/ 'newImportVolumeResponse' smart constructor.
data ImportVolumeResponse = ImportVolumeResponse'
  { -- | Information about the conversion task.
    ImportVolumeResponse -> Maybe ConversionTask
conversionTask :: Prelude.Maybe ConversionTask,
    -- | The response's http status code.
    ImportVolumeResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ImportVolumeResponse -> ImportVolumeResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ImportVolumeResponse -> ImportVolumeResponse -> Bool
$c/= :: ImportVolumeResponse -> ImportVolumeResponse -> Bool
== :: ImportVolumeResponse -> ImportVolumeResponse -> Bool
$c== :: ImportVolumeResponse -> ImportVolumeResponse -> Bool
Prelude.Eq, ReadPrec [ImportVolumeResponse]
ReadPrec ImportVolumeResponse
Int -> ReadS ImportVolumeResponse
ReadS [ImportVolumeResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ImportVolumeResponse]
$creadListPrec :: ReadPrec [ImportVolumeResponse]
readPrec :: ReadPrec ImportVolumeResponse
$creadPrec :: ReadPrec ImportVolumeResponse
readList :: ReadS [ImportVolumeResponse]
$creadList :: ReadS [ImportVolumeResponse]
readsPrec :: Int -> ReadS ImportVolumeResponse
$creadsPrec :: Int -> ReadS ImportVolumeResponse
Prelude.Read, Int -> ImportVolumeResponse -> ShowS
[ImportVolumeResponse] -> ShowS
ImportVolumeResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ImportVolumeResponse] -> ShowS
$cshowList :: [ImportVolumeResponse] -> ShowS
show :: ImportVolumeResponse -> String
$cshow :: ImportVolumeResponse -> String
showsPrec :: Int -> ImportVolumeResponse -> ShowS
$cshowsPrec :: Int -> ImportVolumeResponse -> ShowS
Prelude.Show, forall x. Rep ImportVolumeResponse x -> ImportVolumeResponse
forall x. ImportVolumeResponse -> Rep ImportVolumeResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ImportVolumeResponse x -> ImportVolumeResponse
$cfrom :: forall x. ImportVolumeResponse -> Rep ImportVolumeResponse x
Prelude.Generic)

-- |
-- Create a value of 'ImportVolumeResponse' 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:
--
-- 'conversionTask', 'importVolumeResponse_conversionTask' - Information about the conversion task.
--
-- 'httpStatus', 'importVolumeResponse_httpStatus' - The response's http status code.
newImportVolumeResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ImportVolumeResponse
newImportVolumeResponse :: Int -> ImportVolumeResponse
newImportVolumeResponse Int
pHttpStatus_ =
  ImportVolumeResponse'
    { $sel:conversionTask:ImportVolumeResponse' :: Maybe ConversionTask
conversionTask =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ImportVolumeResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Information about the conversion task.
importVolumeResponse_conversionTask :: Lens.Lens' ImportVolumeResponse (Prelude.Maybe ConversionTask)
importVolumeResponse_conversionTask :: Lens' ImportVolumeResponse (Maybe ConversionTask)
importVolumeResponse_conversionTask = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ImportVolumeResponse' {Maybe ConversionTask
conversionTask :: Maybe ConversionTask
$sel:conversionTask:ImportVolumeResponse' :: ImportVolumeResponse -> Maybe ConversionTask
conversionTask} -> Maybe ConversionTask
conversionTask) (\s :: ImportVolumeResponse
s@ImportVolumeResponse' {} Maybe ConversionTask
a -> ImportVolumeResponse
s {$sel:conversionTask:ImportVolumeResponse' :: Maybe ConversionTask
conversionTask = Maybe ConversionTask
a} :: ImportVolumeResponse)

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

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