{-# 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.ECS.DeleteTaskSet
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Deletes a specified task set within a service. This is used when a
-- service uses the @EXTERNAL@ deployment controller type. For more
-- information, see
-- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html Amazon ECS deployment types>
-- in the /Amazon Elastic Container Service Developer Guide/.
module Amazonka.ECS.DeleteTaskSet
  ( -- * Creating a Request
    DeleteTaskSet (..),
    newDeleteTaskSet,

    -- * Request Lenses
    deleteTaskSet_force,
    deleteTaskSet_cluster,
    deleteTaskSet_service,
    deleteTaskSet_taskSet,

    -- * Destructuring the Response
    DeleteTaskSetResponse (..),
    newDeleteTaskSetResponse,

    -- * Response Lenses
    deleteTaskSetResponse_taskSet,
    deleteTaskSetResponse_httpStatus,
  )
where

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

-- | /See:/ 'newDeleteTaskSet' smart constructor.
data DeleteTaskSet = DeleteTaskSet'
  { -- | If @true@, you can delete a task set even if it hasn\'t been scaled down
    -- to zero.
    DeleteTaskSet -> Maybe Bool
force :: Prelude.Maybe Prelude.Bool,
    -- | The short name or full Amazon Resource Name (ARN) of the cluster that
    -- hosts the service that the task set found in to delete.
    DeleteTaskSet -> Text
cluster :: Prelude.Text,
    -- | The short name or full Amazon Resource Name (ARN) of the service that
    -- hosts the task set to delete.
    DeleteTaskSet -> Text
service :: Prelude.Text,
    -- | The task set ID or full Amazon Resource Name (ARN) of the task set to
    -- delete.
    DeleteTaskSet -> Text
taskSet :: Prelude.Text
  }
  deriving (DeleteTaskSet -> DeleteTaskSet -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteTaskSet -> DeleteTaskSet -> Bool
$c/= :: DeleteTaskSet -> DeleteTaskSet -> Bool
== :: DeleteTaskSet -> DeleteTaskSet -> Bool
$c== :: DeleteTaskSet -> DeleteTaskSet -> Bool
Prelude.Eq, ReadPrec [DeleteTaskSet]
ReadPrec DeleteTaskSet
Int -> ReadS DeleteTaskSet
ReadS [DeleteTaskSet]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DeleteTaskSet]
$creadListPrec :: ReadPrec [DeleteTaskSet]
readPrec :: ReadPrec DeleteTaskSet
$creadPrec :: ReadPrec DeleteTaskSet
readList :: ReadS [DeleteTaskSet]
$creadList :: ReadS [DeleteTaskSet]
readsPrec :: Int -> ReadS DeleteTaskSet
$creadsPrec :: Int -> ReadS DeleteTaskSet
Prelude.Read, Int -> DeleteTaskSet -> ShowS
[DeleteTaskSet] -> ShowS
DeleteTaskSet -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteTaskSet] -> ShowS
$cshowList :: [DeleteTaskSet] -> ShowS
show :: DeleteTaskSet -> String
$cshow :: DeleteTaskSet -> String
showsPrec :: Int -> DeleteTaskSet -> ShowS
$cshowsPrec :: Int -> DeleteTaskSet -> ShowS
Prelude.Show, forall x. Rep DeleteTaskSet x -> DeleteTaskSet
forall x. DeleteTaskSet -> Rep DeleteTaskSet x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DeleteTaskSet x -> DeleteTaskSet
$cfrom :: forall x. DeleteTaskSet -> Rep DeleteTaskSet x
Prelude.Generic)

-- |
-- Create a value of 'DeleteTaskSet' 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:
--
-- 'force', 'deleteTaskSet_force' - If @true@, you can delete a task set even if it hasn\'t been scaled down
-- to zero.
--
-- 'cluster', 'deleteTaskSet_cluster' - The short name or full Amazon Resource Name (ARN) of the cluster that
-- hosts the service that the task set found in to delete.
--
-- 'service', 'deleteTaskSet_service' - The short name or full Amazon Resource Name (ARN) of the service that
-- hosts the task set to delete.
--
-- 'taskSet', 'deleteTaskSet_taskSet' - The task set ID or full Amazon Resource Name (ARN) of the task set to
-- delete.
newDeleteTaskSet ::
  -- | 'cluster'
  Prelude.Text ->
  -- | 'service'
  Prelude.Text ->
  -- | 'taskSet'
  Prelude.Text ->
  DeleteTaskSet
newDeleteTaskSet :: Text -> Text -> Text -> DeleteTaskSet
newDeleteTaskSet Text
pCluster_ Text
pService_ Text
pTaskSet_ =
  DeleteTaskSet'
    { $sel:force:DeleteTaskSet' :: Maybe Bool
force = forall a. Maybe a
Prelude.Nothing,
      $sel:cluster:DeleteTaskSet' :: Text
cluster = Text
pCluster_,
      $sel:service:DeleteTaskSet' :: Text
service = Text
pService_,
      $sel:taskSet:DeleteTaskSet' :: Text
taskSet = Text
pTaskSet_
    }

-- | If @true@, you can delete a task set even if it hasn\'t been scaled down
-- to zero.
deleteTaskSet_force :: Lens.Lens' DeleteTaskSet (Prelude.Maybe Prelude.Bool)
deleteTaskSet_force :: Lens' DeleteTaskSet (Maybe Bool)
deleteTaskSet_force = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTaskSet' {Maybe Bool
force :: Maybe Bool
$sel:force:DeleteTaskSet' :: DeleteTaskSet -> Maybe Bool
force} -> Maybe Bool
force) (\s :: DeleteTaskSet
s@DeleteTaskSet' {} Maybe Bool
a -> DeleteTaskSet
s {$sel:force:DeleteTaskSet' :: Maybe Bool
force = Maybe Bool
a} :: DeleteTaskSet)

-- | The short name or full Amazon Resource Name (ARN) of the cluster that
-- hosts the service that the task set found in to delete.
deleteTaskSet_cluster :: Lens.Lens' DeleteTaskSet Prelude.Text
deleteTaskSet_cluster :: Lens' DeleteTaskSet Text
deleteTaskSet_cluster = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTaskSet' {Text
cluster :: Text
$sel:cluster:DeleteTaskSet' :: DeleteTaskSet -> Text
cluster} -> Text
cluster) (\s :: DeleteTaskSet
s@DeleteTaskSet' {} Text
a -> DeleteTaskSet
s {$sel:cluster:DeleteTaskSet' :: Text
cluster = Text
a} :: DeleteTaskSet)

-- | The short name or full Amazon Resource Name (ARN) of the service that
-- hosts the task set to delete.
deleteTaskSet_service :: Lens.Lens' DeleteTaskSet Prelude.Text
deleteTaskSet_service :: Lens' DeleteTaskSet Text
deleteTaskSet_service = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTaskSet' {Text
service :: Text
$sel:service:DeleteTaskSet' :: DeleteTaskSet -> Text
service} -> Text
service) (\s :: DeleteTaskSet
s@DeleteTaskSet' {} Text
a -> DeleteTaskSet
s {$sel:service:DeleteTaskSet' :: Text
service = Text
a} :: DeleteTaskSet)

-- | The task set ID or full Amazon Resource Name (ARN) of the task set to
-- delete.
deleteTaskSet_taskSet :: Lens.Lens' DeleteTaskSet Prelude.Text
deleteTaskSet_taskSet :: Lens' DeleteTaskSet Text
deleteTaskSet_taskSet = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTaskSet' {Text
taskSet :: Text
$sel:taskSet:DeleteTaskSet' :: DeleteTaskSet -> Text
taskSet} -> Text
taskSet) (\s :: DeleteTaskSet
s@DeleteTaskSet' {} Text
a -> DeleteTaskSet
s {$sel:taskSet:DeleteTaskSet' :: Text
taskSet = Text
a} :: DeleteTaskSet)

instance Core.AWSRequest DeleteTaskSet where
  type
    AWSResponse DeleteTaskSet =
      DeleteTaskSetResponse
  request :: (Service -> Service) -> DeleteTaskSet -> Request DeleteTaskSet
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 DeleteTaskSet
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse DeleteTaskSet)))
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 TaskSet -> Int -> DeleteTaskSetResponse
DeleteTaskSetResponse'
            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
"taskSet")
            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 DeleteTaskSet where
  hashWithSalt :: Int -> DeleteTaskSet -> Int
hashWithSalt Int
_salt DeleteTaskSet' {Maybe Bool
Text
taskSet :: Text
service :: Text
cluster :: Text
force :: Maybe Bool
$sel:taskSet:DeleteTaskSet' :: DeleteTaskSet -> Text
$sel:service:DeleteTaskSet' :: DeleteTaskSet -> Text
$sel:cluster:DeleteTaskSet' :: DeleteTaskSet -> Text
$sel:force:DeleteTaskSet' :: DeleteTaskSet -> Maybe Bool
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
force
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
cluster
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
service
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
taskSet

instance Prelude.NFData DeleteTaskSet where
  rnf :: DeleteTaskSet -> ()
rnf DeleteTaskSet' {Maybe Bool
Text
taskSet :: Text
service :: Text
cluster :: Text
force :: Maybe Bool
$sel:taskSet:DeleteTaskSet' :: DeleteTaskSet -> Text
$sel:service:DeleteTaskSet' :: DeleteTaskSet -> Text
$sel:cluster:DeleteTaskSet' :: DeleteTaskSet -> Text
$sel:force:DeleteTaskSet' :: DeleteTaskSet -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
force
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
cluster
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
service
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
taskSet

instance Data.ToHeaders DeleteTaskSet where
  toHeaders :: DeleteTaskSet -> 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
"AmazonEC2ContainerServiceV20141113.DeleteTaskSet" ::
                          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 DeleteTaskSet where
  toJSON :: DeleteTaskSet -> Value
toJSON DeleteTaskSet' {Maybe Bool
Text
taskSet :: Text
service :: Text
cluster :: Text
force :: Maybe Bool
$sel:taskSet:DeleteTaskSet' :: DeleteTaskSet -> Text
$sel:service:DeleteTaskSet' :: DeleteTaskSet -> Text
$sel:cluster:DeleteTaskSet' :: DeleteTaskSet -> Text
$sel:force:DeleteTaskSet' :: DeleteTaskSet -> Maybe Bool
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"force" 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 Bool
force,
            forall a. a -> Maybe a
Prelude.Just (Key
"cluster" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
cluster),
            forall a. a -> Maybe a
Prelude.Just (Key
"service" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
service),
            forall a. a -> Maybe a
Prelude.Just (Key
"taskSet" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
taskSet)
          ]
      )

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

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

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

-- |
-- Create a value of 'DeleteTaskSetResponse' 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:
--
-- 'taskSet', 'deleteTaskSetResponse_taskSet' - Details about the task set.
--
-- 'httpStatus', 'deleteTaskSetResponse_httpStatus' - The response's http status code.
newDeleteTaskSetResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DeleteTaskSetResponse
newDeleteTaskSetResponse :: Int -> DeleteTaskSetResponse
newDeleteTaskSetResponse Int
pHttpStatus_ =
  DeleteTaskSetResponse'
    { $sel:taskSet:DeleteTaskSetResponse' :: Maybe TaskSet
taskSet = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:DeleteTaskSetResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Details about the task set.
deleteTaskSetResponse_taskSet :: Lens.Lens' DeleteTaskSetResponse (Prelude.Maybe TaskSet)
deleteTaskSetResponse_taskSet :: Lens' DeleteTaskSetResponse (Maybe TaskSet)
deleteTaskSetResponse_taskSet = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTaskSetResponse' {Maybe TaskSet
taskSet :: Maybe TaskSet
$sel:taskSet:DeleteTaskSetResponse' :: DeleteTaskSetResponse -> Maybe TaskSet
taskSet} -> Maybe TaskSet
taskSet) (\s :: DeleteTaskSetResponse
s@DeleteTaskSetResponse' {} Maybe TaskSet
a -> DeleteTaskSetResponse
s {$sel:taskSet:DeleteTaskSetResponse' :: Maybe TaskSet
taskSet = Maybe TaskSet
a} :: DeleteTaskSetResponse)

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

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