{-# 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.SubmitTaskStateChange
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- This action is only used by the Amazon ECS agent, and it is not intended
-- for use outside of the agent.
--
-- Sent to acknowledge that a task changed states.
module Amazonka.ECS.SubmitTaskStateChange
  ( -- * Creating a Request
    SubmitTaskStateChange (..),
    newSubmitTaskStateChange,

    -- * Request Lenses
    submitTaskStateChange_attachments,
    submitTaskStateChange_cluster,
    submitTaskStateChange_containers,
    submitTaskStateChange_executionStoppedAt,
    submitTaskStateChange_managedAgents,
    submitTaskStateChange_pullStartedAt,
    submitTaskStateChange_pullStoppedAt,
    submitTaskStateChange_reason,
    submitTaskStateChange_status,
    submitTaskStateChange_task,

    -- * Destructuring the Response
    SubmitTaskStateChangeResponse (..),
    newSubmitTaskStateChangeResponse,

    -- * Response Lenses
    submitTaskStateChangeResponse_acknowledgment,
    submitTaskStateChangeResponse_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:/ 'newSubmitTaskStateChange' smart constructor.
data SubmitTaskStateChange = SubmitTaskStateChange'
  { -- | Any attachments associated with the state change request.
    SubmitTaskStateChange -> Maybe [AttachmentStateChange]
attachments :: Prelude.Maybe [AttachmentStateChange],
    -- | The short name or full Amazon Resource Name (ARN) of the cluster that
    -- hosts the task.
    SubmitTaskStateChange -> Maybe Text
cluster :: Prelude.Maybe Prelude.Text,
    -- | Any containers that\'s associated with the state change request.
    SubmitTaskStateChange -> Maybe [ContainerStateChange]
containers :: Prelude.Maybe [ContainerStateChange],
    -- | The Unix timestamp for the time when the task execution stopped.
    SubmitTaskStateChange -> Maybe POSIX
executionStoppedAt :: Prelude.Maybe Data.POSIX,
    -- | The details for the managed agent that\'s associated with the task.
    SubmitTaskStateChange -> Maybe [ManagedAgentStateChange]
managedAgents :: Prelude.Maybe [ManagedAgentStateChange],
    -- | The Unix timestamp for the time when the container image pull started.
    SubmitTaskStateChange -> Maybe POSIX
pullStartedAt :: Prelude.Maybe Data.POSIX,
    -- | The Unix timestamp for the time when the container image pull completed.
    SubmitTaskStateChange -> Maybe POSIX
pullStoppedAt :: Prelude.Maybe Data.POSIX,
    -- | The reason for the state change request.
    SubmitTaskStateChange -> Maybe Text
reason :: Prelude.Maybe Prelude.Text,
    -- | The status of the state change request.
    SubmitTaskStateChange -> Maybe Text
status :: Prelude.Maybe Prelude.Text,
    -- | The task ID or full ARN of the task in the state change request.
    SubmitTaskStateChange -> Maybe Text
task :: Prelude.Maybe Prelude.Text
  }
  deriving (SubmitTaskStateChange -> SubmitTaskStateChange -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SubmitTaskStateChange -> SubmitTaskStateChange -> Bool
$c/= :: SubmitTaskStateChange -> SubmitTaskStateChange -> Bool
== :: SubmitTaskStateChange -> SubmitTaskStateChange -> Bool
$c== :: SubmitTaskStateChange -> SubmitTaskStateChange -> Bool
Prelude.Eq, ReadPrec [SubmitTaskStateChange]
ReadPrec SubmitTaskStateChange
Int -> ReadS SubmitTaskStateChange
ReadS [SubmitTaskStateChange]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SubmitTaskStateChange]
$creadListPrec :: ReadPrec [SubmitTaskStateChange]
readPrec :: ReadPrec SubmitTaskStateChange
$creadPrec :: ReadPrec SubmitTaskStateChange
readList :: ReadS [SubmitTaskStateChange]
$creadList :: ReadS [SubmitTaskStateChange]
readsPrec :: Int -> ReadS SubmitTaskStateChange
$creadsPrec :: Int -> ReadS SubmitTaskStateChange
Prelude.Read, Int -> SubmitTaskStateChange -> ShowS
[SubmitTaskStateChange] -> ShowS
SubmitTaskStateChange -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SubmitTaskStateChange] -> ShowS
$cshowList :: [SubmitTaskStateChange] -> ShowS
show :: SubmitTaskStateChange -> String
$cshow :: SubmitTaskStateChange -> String
showsPrec :: Int -> SubmitTaskStateChange -> ShowS
$cshowsPrec :: Int -> SubmitTaskStateChange -> ShowS
Prelude.Show, forall x. Rep SubmitTaskStateChange x -> SubmitTaskStateChange
forall x. SubmitTaskStateChange -> Rep SubmitTaskStateChange x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SubmitTaskStateChange x -> SubmitTaskStateChange
$cfrom :: forall x. SubmitTaskStateChange -> Rep SubmitTaskStateChange x
Prelude.Generic)

-- |
-- Create a value of 'SubmitTaskStateChange' 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:
--
-- 'attachments', 'submitTaskStateChange_attachments' - Any attachments associated with the state change request.
--
-- 'cluster', 'submitTaskStateChange_cluster' - The short name or full Amazon Resource Name (ARN) of the cluster that
-- hosts the task.
--
-- 'containers', 'submitTaskStateChange_containers' - Any containers that\'s associated with the state change request.
--
-- 'executionStoppedAt', 'submitTaskStateChange_executionStoppedAt' - The Unix timestamp for the time when the task execution stopped.
--
-- 'managedAgents', 'submitTaskStateChange_managedAgents' - The details for the managed agent that\'s associated with the task.
--
-- 'pullStartedAt', 'submitTaskStateChange_pullStartedAt' - The Unix timestamp for the time when the container image pull started.
--
-- 'pullStoppedAt', 'submitTaskStateChange_pullStoppedAt' - The Unix timestamp for the time when the container image pull completed.
--
-- 'reason', 'submitTaskStateChange_reason' - The reason for the state change request.
--
-- 'status', 'submitTaskStateChange_status' - The status of the state change request.
--
-- 'task', 'submitTaskStateChange_task' - The task ID or full ARN of the task in the state change request.
newSubmitTaskStateChange ::
  SubmitTaskStateChange
newSubmitTaskStateChange :: SubmitTaskStateChange
newSubmitTaskStateChange =
  SubmitTaskStateChange'
    { $sel:attachments:SubmitTaskStateChange' :: Maybe [AttachmentStateChange]
attachments =
        forall a. Maybe a
Prelude.Nothing,
      $sel:cluster:SubmitTaskStateChange' :: Maybe Text
cluster = forall a. Maybe a
Prelude.Nothing,
      $sel:containers:SubmitTaskStateChange' :: Maybe [ContainerStateChange]
containers = forall a. Maybe a
Prelude.Nothing,
      $sel:executionStoppedAt:SubmitTaskStateChange' :: Maybe POSIX
executionStoppedAt = forall a. Maybe a
Prelude.Nothing,
      $sel:managedAgents:SubmitTaskStateChange' :: Maybe [ManagedAgentStateChange]
managedAgents = forall a. Maybe a
Prelude.Nothing,
      $sel:pullStartedAt:SubmitTaskStateChange' :: Maybe POSIX
pullStartedAt = forall a. Maybe a
Prelude.Nothing,
      $sel:pullStoppedAt:SubmitTaskStateChange' :: Maybe POSIX
pullStoppedAt = forall a. Maybe a
Prelude.Nothing,
      $sel:reason:SubmitTaskStateChange' :: Maybe Text
reason = forall a. Maybe a
Prelude.Nothing,
      $sel:status:SubmitTaskStateChange' :: Maybe Text
status = forall a. Maybe a
Prelude.Nothing,
      $sel:task:SubmitTaskStateChange' :: Maybe Text
task = forall a. Maybe a
Prelude.Nothing
    }

-- | Any attachments associated with the state change request.
submitTaskStateChange_attachments :: Lens.Lens' SubmitTaskStateChange (Prelude.Maybe [AttachmentStateChange])
submitTaskStateChange_attachments :: Lens' SubmitTaskStateChange (Maybe [AttachmentStateChange])
submitTaskStateChange_attachments = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SubmitTaskStateChange' {Maybe [AttachmentStateChange]
attachments :: Maybe [AttachmentStateChange]
$sel:attachments:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe [AttachmentStateChange]
attachments} -> Maybe [AttachmentStateChange]
attachments) (\s :: SubmitTaskStateChange
s@SubmitTaskStateChange' {} Maybe [AttachmentStateChange]
a -> SubmitTaskStateChange
s {$sel:attachments:SubmitTaskStateChange' :: Maybe [AttachmentStateChange]
attachments = Maybe [AttachmentStateChange]
a} :: SubmitTaskStateChange) 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 short name or full Amazon Resource Name (ARN) of the cluster that
-- hosts the task.
submitTaskStateChange_cluster :: Lens.Lens' SubmitTaskStateChange (Prelude.Maybe Prelude.Text)
submitTaskStateChange_cluster :: Lens' SubmitTaskStateChange (Maybe Text)
submitTaskStateChange_cluster = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SubmitTaskStateChange' {Maybe Text
cluster :: Maybe Text
$sel:cluster:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe Text
cluster} -> Maybe Text
cluster) (\s :: SubmitTaskStateChange
s@SubmitTaskStateChange' {} Maybe Text
a -> SubmitTaskStateChange
s {$sel:cluster:SubmitTaskStateChange' :: Maybe Text
cluster = Maybe Text
a} :: SubmitTaskStateChange)

-- | Any containers that\'s associated with the state change request.
submitTaskStateChange_containers :: Lens.Lens' SubmitTaskStateChange (Prelude.Maybe [ContainerStateChange])
submitTaskStateChange_containers :: Lens' SubmitTaskStateChange (Maybe [ContainerStateChange])
submitTaskStateChange_containers = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SubmitTaskStateChange' {Maybe [ContainerStateChange]
containers :: Maybe [ContainerStateChange]
$sel:containers:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe [ContainerStateChange]
containers} -> Maybe [ContainerStateChange]
containers) (\s :: SubmitTaskStateChange
s@SubmitTaskStateChange' {} Maybe [ContainerStateChange]
a -> SubmitTaskStateChange
s {$sel:containers:SubmitTaskStateChange' :: Maybe [ContainerStateChange]
containers = Maybe [ContainerStateChange]
a} :: SubmitTaskStateChange) 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 Unix timestamp for the time when the task execution stopped.
submitTaskStateChange_executionStoppedAt :: Lens.Lens' SubmitTaskStateChange (Prelude.Maybe Prelude.UTCTime)
submitTaskStateChange_executionStoppedAt :: Lens' SubmitTaskStateChange (Maybe UTCTime)
submitTaskStateChange_executionStoppedAt = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SubmitTaskStateChange' {Maybe POSIX
executionStoppedAt :: Maybe POSIX
$sel:executionStoppedAt:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe POSIX
executionStoppedAt} -> Maybe POSIX
executionStoppedAt) (\s :: SubmitTaskStateChange
s@SubmitTaskStateChange' {} Maybe POSIX
a -> SubmitTaskStateChange
s {$sel:executionStoppedAt:SubmitTaskStateChange' :: Maybe POSIX
executionStoppedAt = Maybe POSIX
a} :: SubmitTaskStateChange) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The details for the managed agent that\'s associated with the task.
submitTaskStateChange_managedAgents :: Lens.Lens' SubmitTaskStateChange (Prelude.Maybe [ManagedAgentStateChange])
submitTaskStateChange_managedAgents :: Lens' SubmitTaskStateChange (Maybe [ManagedAgentStateChange])
submitTaskStateChange_managedAgents = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SubmitTaskStateChange' {Maybe [ManagedAgentStateChange]
managedAgents :: Maybe [ManagedAgentStateChange]
$sel:managedAgents:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe [ManagedAgentStateChange]
managedAgents} -> Maybe [ManagedAgentStateChange]
managedAgents) (\s :: SubmitTaskStateChange
s@SubmitTaskStateChange' {} Maybe [ManagedAgentStateChange]
a -> SubmitTaskStateChange
s {$sel:managedAgents:SubmitTaskStateChange' :: Maybe [ManagedAgentStateChange]
managedAgents = Maybe [ManagedAgentStateChange]
a} :: SubmitTaskStateChange) 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 Unix timestamp for the time when the container image pull started.
submitTaskStateChange_pullStartedAt :: Lens.Lens' SubmitTaskStateChange (Prelude.Maybe Prelude.UTCTime)
submitTaskStateChange_pullStartedAt :: Lens' SubmitTaskStateChange (Maybe UTCTime)
submitTaskStateChange_pullStartedAt = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SubmitTaskStateChange' {Maybe POSIX
pullStartedAt :: Maybe POSIX
$sel:pullStartedAt:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe POSIX
pullStartedAt} -> Maybe POSIX
pullStartedAt) (\s :: SubmitTaskStateChange
s@SubmitTaskStateChange' {} Maybe POSIX
a -> SubmitTaskStateChange
s {$sel:pullStartedAt:SubmitTaskStateChange' :: Maybe POSIX
pullStartedAt = Maybe POSIX
a} :: SubmitTaskStateChange) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The Unix timestamp for the time when the container image pull completed.
submitTaskStateChange_pullStoppedAt :: Lens.Lens' SubmitTaskStateChange (Prelude.Maybe Prelude.UTCTime)
submitTaskStateChange_pullStoppedAt :: Lens' SubmitTaskStateChange (Maybe UTCTime)
submitTaskStateChange_pullStoppedAt = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SubmitTaskStateChange' {Maybe POSIX
pullStoppedAt :: Maybe POSIX
$sel:pullStoppedAt:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe POSIX
pullStoppedAt} -> Maybe POSIX
pullStoppedAt) (\s :: SubmitTaskStateChange
s@SubmitTaskStateChange' {} Maybe POSIX
a -> SubmitTaskStateChange
s {$sel:pullStoppedAt:SubmitTaskStateChange' :: Maybe POSIX
pullStoppedAt = Maybe POSIX
a} :: SubmitTaskStateChange) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The reason for the state change request.
submitTaskStateChange_reason :: Lens.Lens' SubmitTaskStateChange (Prelude.Maybe Prelude.Text)
submitTaskStateChange_reason :: Lens' SubmitTaskStateChange (Maybe Text)
submitTaskStateChange_reason = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SubmitTaskStateChange' {Maybe Text
reason :: Maybe Text
$sel:reason:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe Text
reason} -> Maybe Text
reason) (\s :: SubmitTaskStateChange
s@SubmitTaskStateChange' {} Maybe Text
a -> SubmitTaskStateChange
s {$sel:reason:SubmitTaskStateChange' :: Maybe Text
reason = Maybe Text
a} :: SubmitTaskStateChange)

-- | The status of the state change request.
submitTaskStateChange_status :: Lens.Lens' SubmitTaskStateChange (Prelude.Maybe Prelude.Text)
submitTaskStateChange_status :: Lens' SubmitTaskStateChange (Maybe Text)
submitTaskStateChange_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SubmitTaskStateChange' {Maybe Text
status :: Maybe Text
$sel:status:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe Text
status} -> Maybe Text
status) (\s :: SubmitTaskStateChange
s@SubmitTaskStateChange' {} Maybe Text
a -> SubmitTaskStateChange
s {$sel:status:SubmitTaskStateChange' :: Maybe Text
status = Maybe Text
a} :: SubmitTaskStateChange)

-- | The task ID or full ARN of the task in the state change request.
submitTaskStateChange_task :: Lens.Lens' SubmitTaskStateChange (Prelude.Maybe Prelude.Text)
submitTaskStateChange_task :: Lens' SubmitTaskStateChange (Maybe Text)
submitTaskStateChange_task = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SubmitTaskStateChange' {Maybe Text
task :: Maybe Text
$sel:task:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe Text
task} -> Maybe Text
task) (\s :: SubmitTaskStateChange
s@SubmitTaskStateChange' {} Maybe Text
a -> SubmitTaskStateChange
s {$sel:task:SubmitTaskStateChange' :: Maybe Text
task = Maybe Text
a} :: SubmitTaskStateChange)

instance Core.AWSRequest SubmitTaskStateChange where
  type
    AWSResponse SubmitTaskStateChange =
      SubmitTaskStateChangeResponse
  request :: (Service -> Service)
-> SubmitTaskStateChange -> Request SubmitTaskStateChange
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 SubmitTaskStateChange
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse SubmitTaskStateChange)))
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 Text -> Int -> SubmitTaskStateChangeResponse
SubmitTaskStateChangeResponse'
            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
"acknowledgment")
            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 SubmitTaskStateChange where
  hashWithSalt :: Int -> SubmitTaskStateChange -> Int
hashWithSalt Int
_salt SubmitTaskStateChange' {Maybe [AttachmentStateChange]
Maybe [ManagedAgentStateChange]
Maybe [ContainerStateChange]
Maybe Text
Maybe POSIX
task :: Maybe Text
status :: Maybe Text
reason :: Maybe Text
pullStoppedAt :: Maybe POSIX
pullStartedAt :: Maybe POSIX
managedAgents :: Maybe [ManagedAgentStateChange]
executionStoppedAt :: Maybe POSIX
containers :: Maybe [ContainerStateChange]
cluster :: Maybe Text
attachments :: Maybe [AttachmentStateChange]
$sel:task:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe Text
$sel:status:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe Text
$sel:reason:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe Text
$sel:pullStoppedAt:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe POSIX
$sel:pullStartedAt:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe POSIX
$sel:managedAgents:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe [ManagedAgentStateChange]
$sel:executionStoppedAt:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe POSIX
$sel:containers:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe [ContainerStateChange]
$sel:cluster:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe Text
$sel:attachments:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe [AttachmentStateChange]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [AttachmentStateChange]
attachments
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
cluster
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [ContainerStateChange]
containers
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
executionStoppedAt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [ManagedAgentStateChange]
managedAgents
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
pullStartedAt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
pullStoppedAt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
reason
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
status
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
task

instance Prelude.NFData SubmitTaskStateChange where
  rnf :: SubmitTaskStateChange -> ()
rnf SubmitTaskStateChange' {Maybe [AttachmentStateChange]
Maybe [ManagedAgentStateChange]
Maybe [ContainerStateChange]
Maybe Text
Maybe POSIX
task :: Maybe Text
status :: Maybe Text
reason :: Maybe Text
pullStoppedAt :: Maybe POSIX
pullStartedAt :: Maybe POSIX
managedAgents :: Maybe [ManagedAgentStateChange]
executionStoppedAt :: Maybe POSIX
containers :: Maybe [ContainerStateChange]
cluster :: Maybe Text
attachments :: Maybe [AttachmentStateChange]
$sel:task:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe Text
$sel:status:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe Text
$sel:reason:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe Text
$sel:pullStoppedAt:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe POSIX
$sel:pullStartedAt:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe POSIX
$sel:managedAgents:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe [ManagedAgentStateChange]
$sel:executionStoppedAt:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe POSIX
$sel:containers:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe [ContainerStateChange]
$sel:cluster:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe Text
$sel:attachments:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe [AttachmentStateChange]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [AttachmentStateChange]
attachments
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
cluster
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [ContainerStateChange]
containers
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
executionStoppedAt
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [ManagedAgentStateChange]
managedAgents
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
pullStartedAt
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
pullStoppedAt
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
reason
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
status
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
task

instance Data.ToHeaders SubmitTaskStateChange where
  toHeaders :: SubmitTaskStateChange -> 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.SubmitTaskStateChange" ::
                          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 SubmitTaskStateChange where
  toJSON :: SubmitTaskStateChange -> Value
toJSON SubmitTaskStateChange' {Maybe [AttachmentStateChange]
Maybe [ManagedAgentStateChange]
Maybe [ContainerStateChange]
Maybe Text
Maybe POSIX
task :: Maybe Text
status :: Maybe Text
reason :: Maybe Text
pullStoppedAt :: Maybe POSIX
pullStartedAt :: Maybe POSIX
managedAgents :: Maybe [ManagedAgentStateChange]
executionStoppedAt :: Maybe POSIX
containers :: Maybe [ContainerStateChange]
cluster :: Maybe Text
attachments :: Maybe [AttachmentStateChange]
$sel:task:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe Text
$sel:status:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe Text
$sel:reason:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe Text
$sel:pullStoppedAt:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe POSIX
$sel:pullStartedAt:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe POSIX
$sel:managedAgents:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe [ManagedAgentStateChange]
$sel:executionStoppedAt:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe POSIX
$sel:containers:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe [ContainerStateChange]
$sel:cluster:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe Text
$sel:attachments:SubmitTaskStateChange' :: SubmitTaskStateChange -> Maybe [AttachmentStateChange]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"attachments" 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 [AttachmentStateChange]
attachments,
            (Key
"cluster" 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 Text
cluster,
            (Key
"containers" 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 [ContainerStateChange]
containers,
            (Key
"executionStoppedAt" 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 POSIX
executionStoppedAt,
            (Key
"managedAgents" 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 [ManagedAgentStateChange]
managedAgents,
            (Key
"pullStartedAt" 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 POSIX
pullStartedAt,
            (Key
"pullStoppedAt" 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 POSIX
pullStoppedAt,
            (Key
"reason" 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 Text
reason,
            (Key
"status" 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 Text
status,
            (Key
"task" 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 Text
task
          ]
      )

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

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

-- | /See:/ 'newSubmitTaskStateChangeResponse' smart constructor.
data SubmitTaskStateChangeResponse = SubmitTaskStateChangeResponse'
  { -- | Acknowledgement of the state change.
    SubmitTaskStateChangeResponse -> Maybe Text
acknowledgment :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    SubmitTaskStateChangeResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (SubmitTaskStateChangeResponse
-> SubmitTaskStateChangeResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SubmitTaskStateChangeResponse
-> SubmitTaskStateChangeResponse -> Bool
$c/= :: SubmitTaskStateChangeResponse
-> SubmitTaskStateChangeResponse -> Bool
== :: SubmitTaskStateChangeResponse
-> SubmitTaskStateChangeResponse -> Bool
$c== :: SubmitTaskStateChangeResponse
-> SubmitTaskStateChangeResponse -> Bool
Prelude.Eq, ReadPrec [SubmitTaskStateChangeResponse]
ReadPrec SubmitTaskStateChangeResponse
Int -> ReadS SubmitTaskStateChangeResponse
ReadS [SubmitTaskStateChangeResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SubmitTaskStateChangeResponse]
$creadListPrec :: ReadPrec [SubmitTaskStateChangeResponse]
readPrec :: ReadPrec SubmitTaskStateChangeResponse
$creadPrec :: ReadPrec SubmitTaskStateChangeResponse
readList :: ReadS [SubmitTaskStateChangeResponse]
$creadList :: ReadS [SubmitTaskStateChangeResponse]
readsPrec :: Int -> ReadS SubmitTaskStateChangeResponse
$creadsPrec :: Int -> ReadS SubmitTaskStateChangeResponse
Prelude.Read, Int -> SubmitTaskStateChangeResponse -> ShowS
[SubmitTaskStateChangeResponse] -> ShowS
SubmitTaskStateChangeResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SubmitTaskStateChangeResponse] -> ShowS
$cshowList :: [SubmitTaskStateChangeResponse] -> ShowS
show :: SubmitTaskStateChangeResponse -> String
$cshow :: SubmitTaskStateChangeResponse -> String
showsPrec :: Int -> SubmitTaskStateChangeResponse -> ShowS
$cshowsPrec :: Int -> SubmitTaskStateChangeResponse -> ShowS
Prelude.Show, forall x.
Rep SubmitTaskStateChangeResponse x
-> SubmitTaskStateChangeResponse
forall x.
SubmitTaskStateChangeResponse
-> Rep SubmitTaskStateChangeResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep SubmitTaskStateChangeResponse x
-> SubmitTaskStateChangeResponse
$cfrom :: forall x.
SubmitTaskStateChangeResponse
-> Rep SubmitTaskStateChangeResponse x
Prelude.Generic)

-- |
-- Create a value of 'SubmitTaskStateChangeResponse' 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:
--
-- 'acknowledgment', 'submitTaskStateChangeResponse_acknowledgment' - Acknowledgement of the state change.
--
-- 'httpStatus', 'submitTaskStateChangeResponse_httpStatus' - The response's http status code.
newSubmitTaskStateChangeResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  SubmitTaskStateChangeResponse
newSubmitTaskStateChangeResponse :: Int -> SubmitTaskStateChangeResponse
newSubmitTaskStateChangeResponse Int
pHttpStatus_ =
  SubmitTaskStateChangeResponse'
    { $sel:acknowledgment:SubmitTaskStateChangeResponse' :: Maybe Text
acknowledgment =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:SubmitTaskStateChangeResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Acknowledgement of the state change.
submitTaskStateChangeResponse_acknowledgment :: Lens.Lens' SubmitTaskStateChangeResponse (Prelude.Maybe Prelude.Text)
submitTaskStateChangeResponse_acknowledgment :: Lens' SubmitTaskStateChangeResponse (Maybe Text)
submitTaskStateChangeResponse_acknowledgment = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SubmitTaskStateChangeResponse' {Maybe Text
acknowledgment :: Maybe Text
$sel:acknowledgment:SubmitTaskStateChangeResponse' :: SubmitTaskStateChangeResponse -> Maybe Text
acknowledgment} -> Maybe Text
acknowledgment) (\s :: SubmitTaskStateChangeResponse
s@SubmitTaskStateChangeResponse' {} Maybe Text
a -> SubmitTaskStateChangeResponse
s {$sel:acknowledgment:SubmitTaskStateChangeResponse' :: Maybe Text
acknowledgment = Maybe Text
a} :: SubmitTaskStateChangeResponse)

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

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