{-# 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.RegisterContainerInstance
-- 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.
--
-- Registers an EC2 instance into the specified cluster. This instance
-- becomes available to place containers on.
module Amazonka.ECS.RegisterContainerInstance
  ( -- * Creating a Request
    RegisterContainerInstance (..),
    newRegisterContainerInstance,

    -- * Request Lenses
    registerContainerInstance_attributes,
    registerContainerInstance_cluster,
    registerContainerInstance_containerInstanceArn,
    registerContainerInstance_instanceIdentityDocument,
    registerContainerInstance_instanceIdentityDocumentSignature,
    registerContainerInstance_platformDevices,
    registerContainerInstance_tags,
    registerContainerInstance_totalResources,
    registerContainerInstance_versionInfo,

    -- * Destructuring the Response
    RegisterContainerInstanceResponse (..),
    newRegisterContainerInstanceResponse,

    -- * Response Lenses
    registerContainerInstanceResponse_containerInstance,
    registerContainerInstanceResponse_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:/ 'newRegisterContainerInstance' smart constructor.
data RegisterContainerInstance = RegisterContainerInstance'
  { -- | The container instance attributes that this container instance supports.
    RegisterContainerInstance -> Maybe [Attribute]
attributes :: Prelude.Maybe [Attribute],
    -- | The short name or full Amazon Resource Name (ARN) of the cluster to
    -- register your container instance with. If you do not specify a cluster,
    -- the default cluster is assumed.
    RegisterContainerInstance -> Maybe Text
cluster :: Prelude.Maybe Prelude.Text,
    -- | The ARN of the container instance (if it was previously registered).
    RegisterContainerInstance -> Maybe Text
containerInstanceArn :: Prelude.Maybe Prelude.Text,
    -- | The instance identity document for the EC2 instance to register. This
    -- document can be found by running the following command from the
    -- instance:
    -- @curl http:\/\/169.254.169.254\/latest\/dynamic\/instance-identity\/document\/@
    RegisterContainerInstance -> Maybe Text
instanceIdentityDocument :: Prelude.Maybe Prelude.Text,
    -- | The instance identity document signature for the EC2 instance to
    -- register. This signature can be found by running the following command
    -- from the instance:
    -- @curl http:\/\/169.254.169.254\/latest\/dynamic\/instance-identity\/signature\/@
    RegisterContainerInstance -> Maybe Text
instanceIdentityDocumentSignature :: Prelude.Maybe Prelude.Text,
    -- | The devices that are available on the container instance. The only
    -- supported device type is a GPU.
    RegisterContainerInstance -> Maybe [PlatformDevice]
platformDevices :: Prelude.Maybe [PlatformDevice],
    -- | The metadata that you apply to the container instance to help you
    -- categorize and organize them. Each tag consists of a key and an optional
    -- value. You define both.
    --
    -- The following basic restrictions apply to tags:
    --
    -- -   Maximum number of tags per resource - 50
    --
    -- -   For each resource, each tag key must be unique, and each tag key can
    --     have only one value.
    --
    -- -   Maximum key length - 128 Unicode characters in UTF-8
    --
    -- -   Maximum value length - 256 Unicode characters in UTF-8
    --
    -- -   If your tagging schema is used across multiple services and
    --     resources, remember that other services may have restrictions on
    --     allowed characters. Generally allowed characters are: letters,
    --     numbers, and spaces representable in UTF-8, and the following
    --     characters: + - = . _ : \/ \@.
    --
    -- -   Tag keys and values are case-sensitive.
    --
    -- -   Do not use @aws:@, @AWS:@, or any upper or lowercase combination of
    --     such as a prefix for either keys or values as it is reserved for
    --     Amazon Web Services use. You cannot edit or delete tag keys or
    --     values with this prefix. Tags with this prefix do not count against
    --     your tags per resource limit.
    RegisterContainerInstance -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The resources available on the instance.
    RegisterContainerInstance -> Maybe [Resource]
totalResources :: Prelude.Maybe [Resource],
    -- | The version information for the Amazon ECS container agent and Docker
    -- daemon that runs on the container instance.
    RegisterContainerInstance -> Maybe VersionInfo
versionInfo :: Prelude.Maybe VersionInfo
  }
  deriving (RegisterContainerInstance -> RegisterContainerInstance -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegisterContainerInstance -> RegisterContainerInstance -> Bool
$c/= :: RegisterContainerInstance -> RegisterContainerInstance -> Bool
== :: RegisterContainerInstance -> RegisterContainerInstance -> Bool
$c== :: RegisterContainerInstance -> RegisterContainerInstance -> Bool
Prelude.Eq, ReadPrec [RegisterContainerInstance]
ReadPrec RegisterContainerInstance
Int -> ReadS RegisterContainerInstance
ReadS [RegisterContainerInstance]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RegisterContainerInstance]
$creadListPrec :: ReadPrec [RegisterContainerInstance]
readPrec :: ReadPrec RegisterContainerInstance
$creadPrec :: ReadPrec RegisterContainerInstance
readList :: ReadS [RegisterContainerInstance]
$creadList :: ReadS [RegisterContainerInstance]
readsPrec :: Int -> ReadS RegisterContainerInstance
$creadsPrec :: Int -> ReadS RegisterContainerInstance
Prelude.Read, Int -> RegisterContainerInstance -> ShowS
[RegisterContainerInstance] -> ShowS
RegisterContainerInstance -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RegisterContainerInstance] -> ShowS
$cshowList :: [RegisterContainerInstance] -> ShowS
show :: RegisterContainerInstance -> String
$cshow :: RegisterContainerInstance -> String
showsPrec :: Int -> RegisterContainerInstance -> ShowS
$cshowsPrec :: Int -> RegisterContainerInstance -> ShowS
Prelude.Show, forall x.
Rep RegisterContainerInstance x -> RegisterContainerInstance
forall x.
RegisterContainerInstance -> Rep RegisterContainerInstance x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep RegisterContainerInstance x -> RegisterContainerInstance
$cfrom :: forall x.
RegisterContainerInstance -> Rep RegisterContainerInstance x
Prelude.Generic)

-- |
-- Create a value of 'RegisterContainerInstance' 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:
--
-- 'attributes', 'registerContainerInstance_attributes' - The container instance attributes that this container instance supports.
--
-- 'cluster', 'registerContainerInstance_cluster' - The short name or full Amazon Resource Name (ARN) of the cluster to
-- register your container instance with. If you do not specify a cluster,
-- the default cluster is assumed.
--
-- 'containerInstanceArn', 'registerContainerInstance_containerInstanceArn' - The ARN of the container instance (if it was previously registered).
--
-- 'instanceIdentityDocument', 'registerContainerInstance_instanceIdentityDocument' - The instance identity document for the EC2 instance to register. This
-- document can be found by running the following command from the
-- instance:
-- @curl http:\/\/169.254.169.254\/latest\/dynamic\/instance-identity\/document\/@
--
-- 'instanceIdentityDocumentSignature', 'registerContainerInstance_instanceIdentityDocumentSignature' - The instance identity document signature for the EC2 instance to
-- register. This signature can be found by running the following command
-- from the instance:
-- @curl http:\/\/169.254.169.254\/latest\/dynamic\/instance-identity\/signature\/@
--
-- 'platformDevices', 'registerContainerInstance_platformDevices' - The devices that are available on the container instance. The only
-- supported device type is a GPU.
--
-- 'tags', 'registerContainerInstance_tags' - The metadata that you apply to the container instance to help you
-- categorize and organize them. Each tag consists of a key and an optional
-- value. You define both.
--
-- The following basic restrictions apply to tags:
--
-- -   Maximum number of tags per resource - 50
--
-- -   For each resource, each tag key must be unique, and each tag key can
--     have only one value.
--
-- -   Maximum key length - 128 Unicode characters in UTF-8
--
-- -   Maximum value length - 256 Unicode characters in UTF-8
--
-- -   If your tagging schema is used across multiple services and
--     resources, remember that other services may have restrictions on
--     allowed characters. Generally allowed characters are: letters,
--     numbers, and spaces representable in UTF-8, and the following
--     characters: + - = . _ : \/ \@.
--
-- -   Tag keys and values are case-sensitive.
--
-- -   Do not use @aws:@, @AWS:@, or any upper or lowercase combination of
--     such as a prefix for either keys or values as it is reserved for
--     Amazon Web Services use. You cannot edit or delete tag keys or
--     values with this prefix. Tags with this prefix do not count against
--     your tags per resource limit.
--
-- 'totalResources', 'registerContainerInstance_totalResources' - The resources available on the instance.
--
-- 'versionInfo', 'registerContainerInstance_versionInfo' - The version information for the Amazon ECS container agent and Docker
-- daemon that runs on the container instance.
newRegisterContainerInstance ::
  RegisterContainerInstance
newRegisterContainerInstance :: RegisterContainerInstance
newRegisterContainerInstance =
  RegisterContainerInstance'
    { $sel:attributes:RegisterContainerInstance' :: Maybe [Attribute]
attributes =
        forall a. Maybe a
Prelude.Nothing,
      $sel:cluster:RegisterContainerInstance' :: Maybe Text
cluster = forall a. Maybe a
Prelude.Nothing,
      $sel:containerInstanceArn:RegisterContainerInstance' :: Maybe Text
containerInstanceArn = forall a. Maybe a
Prelude.Nothing,
      $sel:instanceIdentityDocument:RegisterContainerInstance' :: Maybe Text
instanceIdentityDocument = forall a. Maybe a
Prelude.Nothing,
      $sel:instanceIdentityDocumentSignature:RegisterContainerInstance' :: Maybe Text
instanceIdentityDocumentSignature =
        forall a. Maybe a
Prelude.Nothing,
      $sel:platformDevices:RegisterContainerInstance' :: Maybe [PlatformDevice]
platformDevices = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:RegisterContainerInstance' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:totalResources:RegisterContainerInstance' :: Maybe [Resource]
totalResources = forall a. Maybe a
Prelude.Nothing,
      $sel:versionInfo:RegisterContainerInstance' :: Maybe VersionInfo
versionInfo = forall a. Maybe a
Prelude.Nothing
    }

-- | The container instance attributes that this container instance supports.
registerContainerInstance_attributes :: Lens.Lens' RegisterContainerInstance (Prelude.Maybe [Attribute])
registerContainerInstance_attributes :: Lens' RegisterContainerInstance (Maybe [Attribute])
registerContainerInstance_attributes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterContainerInstance' {Maybe [Attribute]
attributes :: Maybe [Attribute]
$sel:attributes:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe [Attribute]
attributes} -> Maybe [Attribute]
attributes) (\s :: RegisterContainerInstance
s@RegisterContainerInstance' {} Maybe [Attribute]
a -> RegisterContainerInstance
s {$sel:attributes:RegisterContainerInstance' :: Maybe [Attribute]
attributes = Maybe [Attribute]
a} :: RegisterContainerInstance) 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 to
-- register your container instance with. If you do not specify a cluster,
-- the default cluster is assumed.
registerContainerInstance_cluster :: Lens.Lens' RegisterContainerInstance (Prelude.Maybe Prelude.Text)
registerContainerInstance_cluster :: Lens' RegisterContainerInstance (Maybe Text)
registerContainerInstance_cluster = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterContainerInstance' {Maybe Text
cluster :: Maybe Text
$sel:cluster:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe Text
cluster} -> Maybe Text
cluster) (\s :: RegisterContainerInstance
s@RegisterContainerInstance' {} Maybe Text
a -> RegisterContainerInstance
s {$sel:cluster:RegisterContainerInstance' :: Maybe Text
cluster = Maybe Text
a} :: RegisterContainerInstance)

-- | The ARN of the container instance (if it was previously registered).
registerContainerInstance_containerInstanceArn :: Lens.Lens' RegisterContainerInstance (Prelude.Maybe Prelude.Text)
registerContainerInstance_containerInstanceArn :: Lens' RegisterContainerInstance (Maybe Text)
registerContainerInstance_containerInstanceArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterContainerInstance' {Maybe Text
containerInstanceArn :: Maybe Text
$sel:containerInstanceArn:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe Text
containerInstanceArn} -> Maybe Text
containerInstanceArn) (\s :: RegisterContainerInstance
s@RegisterContainerInstance' {} Maybe Text
a -> RegisterContainerInstance
s {$sel:containerInstanceArn:RegisterContainerInstance' :: Maybe Text
containerInstanceArn = Maybe Text
a} :: RegisterContainerInstance)

-- | The instance identity document for the EC2 instance to register. This
-- document can be found by running the following command from the
-- instance:
-- @curl http:\/\/169.254.169.254\/latest\/dynamic\/instance-identity\/document\/@
registerContainerInstance_instanceIdentityDocument :: Lens.Lens' RegisterContainerInstance (Prelude.Maybe Prelude.Text)
registerContainerInstance_instanceIdentityDocument :: Lens' RegisterContainerInstance (Maybe Text)
registerContainerInstance_instanceIdentityDocument = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterContainerInstance' {Maybe Text
instanceIdentityDocument :: Maybe Text
$sel:instanceIdentityDocument:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe Text
instanceIdentityDocument} -> Maybe Text
instanceIdentityDocument) (\s :: RegisterContainerInstance
s@RegisterContainerInstance' {} Maybe Text
a -> RegisterContainerInstance
s {$sel:instanceIdentityDocument:RegisterContainerInstance' :: Maybe Text
instanceIdentityDocument = Maybe Text
a} :: RegisterContainerInstance)

-- | The instance identity document signature for the EC2 instance to
-- register. This signature can be found by running the following command
-- from the instance:
-- @curl http:\/\/169.254.169.254\/latest\/dynamic\/instance-identity\/signature\/@
registerContainerInstance_instanceIdentityDocumentSignature :: Lens.Lens' RegisterContainerInstance (Prelude.Maybe Prelude.Text)
registerContainerInstance_instanceIdentityDocumentSignature :: Lens' RegisterContainerInstance (Maybe Text)
registerContainerInstance_instanceIdentityDocumentSignature = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterContainerInstance' {Maybe Text
instanceIdentityDocumentSignature :: Maybe Text
$sel:instanceIdentityDocumentSignature:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe Text
instanceIdentityDocumentSignature} -> Maybe Text
instanceIdentityDocumentSignature) (\s :: RegisterContainerInstance
s@RegisterContainerInstance' {} Maybe Text
a -> RegisterContainerInstance
s {$sel:instanceIdentityDocumentSignature:RegisterContainerInstance' :: Maybe Text
instanceIdentityDocumentSignature = Maybe Text
a} :: RegisterContainerInstance)

-- | The devices that are available on the container instance. The only
-- supported device type is a GPU.
registerContainerInstance_platformDevices :: Lens.Lens' RegisterContainerInstance (Prelude.Maybe [PlatformDevice])
registerContainerInstance_platformDevices :: Lens' RegisterContainerInstance (Maybe [PlatformDevice])
registerContainerInstance_platformDevices = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterContainerInstance' {Maybe [PlatformDevice]
platformDevices :: Maybe [PlatformDevice]
$sel:platformDevices:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe [PlatformDevice]
platformDevices} -> Maybe [PlatformDevice]
platformDevices) (\s :: RegisterContainerInstance
s@RegisterContainerInstance' {} Maybe [PlatformDevice]
a -> RegisterContainerInstance
s {$sel:platformDevices:RegisterContainerInstance' :: Maybe [PlatformDevice]
platformDevices = Maybe [PlatformDevice]
a} :: RegisterContainerInstance) 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 metadata that you apply to the container instance to help you
-- categorize and organize them. Each tag consists of a key and an optional
-- value. You define both.
--
-- The following basic restrictions apply to tags:
--
-- -   Maximum number of tags per resource - 50
--
-- -   For each resource, each tag key must be unique, and each tag key can
--     have only one value.
--
-- -   Maximum key length - 128 Unicode characters in UTF-8
--
-- -   Maximum value length - 256 Unicode characters in UTF-8
--
-- -   If your tagging schema is used across multiple services and
--     resources, remember that other services may have restrictions on
--     allowed characters. Generally allowed characters are: letters,
--     numbers, and spaces representable in UTF-8, and the following
--     characters: + - = . _ : \/ \@.
--
-- -   Tag keys and values are case-sensitive.
--
-- -   Do not use @aws:@, @AWS:@, or any upper or lowercase combination of
--     such as a prefix for either keys or values as it is reserved for
--     Amazon Web Services use. You cannot edit or delete tag keys or
--     values with this prefix. Tags with this prefix do not count against
--     your tags per resource limit.
registerContainerInstance_tags :: Lens.Lens' RegisterContainerInstance (Prelude.Maybe [Tag])
registerContainerInstance_tags :: Lens' RegisterContainerInstance (Maybe [Tag])
registerContainerInstance_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterContainerInstance' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: RegisterContainerInstance
s@RegisterContainerInstance' {} Maybe [Tag]
a -> RegisterContainerInstance
s {$sel:tags:RegisterContainerInstance' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: RegisterContainerInstance) 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 resources available on the instance.
registerContainerInstance_totalResources :: Lens.Lens' RegisterContainerInstance (Prelude.Maybe [Resource])
registerContainerInstance_totalResources :: Lens' RegisterContainerInstance (Maybe [Resource])
registerContainerInstance_totalResources = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterContainerInstance' {Maybe [Resource]
totalResources :: Maybe [Resource]
$sel:totalResources:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe [Resource]
totalResources} -> Maybe [Resource]
totalResources) (\s :: RegisterContainerInstance
s@RegisterContainerInstance' {} Maybe [Resource]
a -> RegisterContainerInstance
s {$sel:totalResources:RegisterContainerInstance' :: Maybe [Resource]
totalResources = Maybe [Resource]
a} :: RegisterContainerInstance) 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 version information for the Amazon ECS container agent and Docker
-- daemon that runs on the container instance.
registerContainerInstance_versionInfo :: Lens.Lens' RegisterContainerInstance (Prelude.Maybe VersionInfo)
registerContainerInstance_versionInfo :: Lens' RegisterContainerInstance (Maybe VersionInfo)
registerContainerInstance_versionInfo = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterContainerInstance' {Maybe VersionInfo
versionInfo :: Maybe VersionInfo
$sel:versionInfo:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe VersionInfo
versionInfo} -> Maybe VersionInfo
versionInfo) (\s :: RegisterContainerInstance
s@RegisterContainerInstance' {} Maybe VersionInfo
a -> RegisterContainerInstance
s {$sel:versionInfo:RegisterContainerInstance' :: Maybe VersionInfo
versionInfo = Maybe VersionInfo
a} :: RegisterContainerInstance)

instance Core.AWSRequest RegisterContainerInstance where
  type
    AWSResponse RegisterContainerInstance =
      RegisterContainerInstanceResponse
  request :: (Service -> Service)
-> RegisterContainerInstance -> Request RegisterContainerInstance
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 RegisterContainerInstance
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse RegisterContainerInstance)))
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 ContainerInstance -> Int -> RegisterContainerInstanceResponse
RegisterContainerInstanceResponse'
            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
"containerInstance")
            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 RegisterContainerInstance where
  hashWithSalt :: Int -> RegisterContainerInstance -> Int
hashWithSalt Int
_salt RegisterContainerInstance' {Maybe [PlatformDevice]
Maybe [Resource]
Maybe [Tag]
Maybe [Attribute]
Maybe Text
Maybe VersionInfo
versionInfo :: Maybe VersionInfo
totalResources :: Maybe [Resource]
tags :: Maybe [Tag]
platformDevices :: Maybe [PlatformDevice]
instanceIdentityDocumentSignature :: Maybe Text
instanceIdentityDocument :: Maybe Text
containerInstanceArn :: Maybe Text
cluster :: Maybe Text
attributes :: Maybe [Attribute]
$sel:versionInfo:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe VersionInfo
$sel:totalResources:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe [Resource]
$sel:tags:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe [Tag]
$sel:platformDevices:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe [PlatformDevice]
$sel:instanceIdentityDocumentSignature:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe Text
$sel:instanceIdentityDocument:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe Text
$sel:containerInstanceArn:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe Text
$sel:cluster:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe Text
$sel:attributes:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe [Attribute]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Attribute]
attributes
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
cluster
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
containerInstanceArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
instanceIdentityDocument
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
instanceIdentityDocumentSignature
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [PlatformDevice]
platformDevices
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Resource]
totalResources
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe VersionInfo
versionInfo

instance Prelude.NFData RegisterContainerInstance where
  rnf :: RegisterContainerInstance -> ()
rnf RegisterContainerInstance' {Maybe [PlatformDevice]
Maybe [Resource]
Maybe [Tag]
Maybe [Attribute]
Maybe Text
Maybe VersionInfo
versionInfo :: Maybe VersionInfo
totalResources :: Maybe [Resource]
tags :: Maybe [Tag]
platformDevices :: Maybe [PlatformDevice]
instanceIdentityDocumentSignature :: Maybe Text
instanceIdentityDocument :: Maybe Text
containerInstanceArn :: Maybe Text
cluster :: Maybe Text
attributes :: Maybe [Attribute]
$sel:versionInfo:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe VersionInfo
$sel:totalResources:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe [Resource]
$sel:tags:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe [Tag]
$sel:platformDevices:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe [PlatformDevice]
$sel:instanceIdentityDocumentSignature:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe Text
$sel:instanceIdentityDocument:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe Text
$sel:containerInstanceArn:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe Text
$sel:cluster:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe Text
$sel:attributes:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe [Attribute]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Attribute]
attributes
      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 Text
containerInstanceArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
instanceIdentityDocument
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
instanceIdentityDocumentSignature
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [PlatformDevice]
platformDevices
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Tag]
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Resource]
totalResources
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe VersionInfo
versionInfo

instance Data.ToHeaders RegisterContainerInstance where
  toHeaders :: RegisterContainerInstance -> 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.RegisterContainerInstance" ::
                          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 RegisterContainerInstance where
  toJSON :: RegisterContainerInstance -> Value
toJSON RegisterContainerInstance' {Maybe [PlatformDevice]
Maybe [Resource]
Maybe [Tag]
Maybe [Attribute]
Maybe Text
Maybe VersionInfo
versionInfo :: Maybe VersionInfo
totalResources :: Maybe [Resource]
tags :: Maybe [Tag]
platformDevices :: Maybe [PlatformDevice]
instanceIdentityDocumentSignature :: Maybe Text
instanceIdentityDocument :: Maybe Text
containerInstanceArn :: Maybe Text
cluster :: Maybe Text
attributes :: Maybe [Attribute]
$sel:versionInfo:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe VersionInfo
$sel:totalResources:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe [Resource]
$sel:tags:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe [Tag]
$sel:platformDevices:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe [PlatformDevice]
$sel:instanceIdentityDocumentSignature:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe Text
$sel:instanceIdentityDocument:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe Text
$sel:containerInstanceArn:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe Text
$sel:cluster:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe Text
$sel:attributes:RegisterContainerInstance' :: RegisterContainerInstance -> Maybe [Attribute]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"attributes" 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 [Attribute]
attributes,
            (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
"containerInstanceArn" 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
containerInstanceArn,
            (Key
"instanceIdentityDocument" 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
instanceIdentityDocument,
            (Key
"instanceIdentityDocumentSignature" 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
instanceIdentityDocumentSignature,
            (Key
"platformDevices" 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 [PlatformDevice]
platformDevices,
            (Key
"tags" 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]
tags,
            (Key
"totalResources" 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 [Resource]
totalResources,
            (Key
"versionInfo" 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 VersionInfo
versionInfo
          ]
      )

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

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

-- | /See:/ 'newRegisterContainerInstanceResponse' smart constructor.
data RegisterContainerInstanceResponse = RegisterContainerInstanceResponse'
  { -- | The container instance that was registered.
    RegisterContainerInstanceResponse -> Maybe ContainerInstance
containerInstance :: Prelude.Maybe ContainerInstance,
    -- | The response's http status code.
    RegisterContainerInstanceResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (RegisterContainerInstanceResponse
-> RegisterContainerInstanceResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegisterContainerInstanceResponse
-> RegisterContainerInstanceResponse -> Bool
$c/= :: RegisterContainerInstanceResponse
-> RegisterContainerInstanceResponse -> Bool
== :: RegisterContainerInstanceResponse
-> RegisterContainerInstanceResponse -> Bool
$c== :: RegisterContainerInstanceResponse
-> RegisterContainerInstanceResponse -> Bool
Prelude.Eq, ReadPrec [RegisterContainerInstanceResponse]
ReadPrec RegisterContainerInstanceResponse
Int -> ReadS RegisterContainerInstanceResponse
ReadS [RegisterContainerInstanceResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RegisterContainerInstanceResponse]
$creadListPrec :: ReadPrec [RegisterContainerInstanceResponse]
readPrec :: ReadPrec RegisterContainerInstanceResponse
$creadPrec :: ReadPrec RegisterContainerInstanceResponse
readList :: ReadS [RegisterContainerInstanceResponse]
$creadList :: ReadS [RegisterContainerInstanceResponse]
readsPrec :: Int -> ReadS RegisterContainerInstanceResponse
$creadsPrec :: Int -> ReadS RegisterContainerInstanceResponse
Prelude.Read, Int -> RegisterContainerInstanceResponse -> ShowS
[RegisterContainerInstanceResponse] -> ShowS
RegisterContainerInstanceResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RegisterContainerInstanceResponse] -> ShowS
$cshowList :: [RegisterContainerInstanceResponse] -> ShowS
show :: RegisterContainerInstanceResponse -> String
$cshow :: RegisterContainerInstanceResponse -> String
showsPrec :: Int -> RegisterContainerInstanceResponse -> ShowS
$cshowsPrec :: Int -> RegisterContainerInstanceResponse -> ShowS
Prelude.Show, forall x.
Rep RegisterContainerInstanceResponse x
-> RegisterContainerInstanceResponse
forall x.
RegisterContainerInstanceResponse
-> Rep RegisterContainerInstanceResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep RegisterContainerInstanceResponse x
-> RegisterContainerInstanceResponse
$cfrom :: forall x.
RegisterContainerInstanceResponse
-> Rep RegisterContainerInstanceResponse x
Prelude.Generic)

-- |
-- Create a value of 'RegisterContainerInstanceResponse' 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:
--
-- 'containerInstance', 'registerContainerInstanceResponse_containerInstance' - The container instance that was registered.
--
-- 'httpStatus', 'registerContainerInstanceResponse_httpStatus' - The response's http status code.
newRegisterContainerInstanceResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  RegisterContainerInstanceResponse
newRegisterContainerInstanceResponse :: Int -> RegisterContainerInstanceResponse
newRegisterContainerInstanceResponse Int
pHttpStatus_ =
  RegisterContainerInstanceResponse'
    { $sel:containerInstance:RegisterContainerInstanceResponse' :: Maybe ContainerInstance
containerInstance =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:RegisterContainerInstanceResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The container instance that was registered.
registerContainerInstanceResponse_containerInstance :: Lens.Lens' RegisterContainerInstanceResponse (Prelude.Maybe ContainerInstance)
registerContainerInstanceResponse_containerInstance :: Lens' RegisterContainerInstanceResponse (Maybe ContainerInstance)
registerContainerInstanceResponse_containerInstance = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterContainerInstanceResponse' {Maybe ContainerInstance
containerInstance :: Maybe ContainerInstance
$sel:containerInstance:RegisterContainerInstanceResponse' :: RegisterContainerInstanceResponse -> Maybe ContainerInstance
containerInstance} -> Maybe ContainerInstance
containerInstance) (\s :: RegisterContainerInstanceResponse
s@RegisterContainerInstanceResponse' {} Maybe ContainerInstance
a -> RegisterContainerInstanceResponse
s {$sel:containerInstance:RegisterContainerInstanceResponse' :: Maybe ContainerInstance
containerInstance = Maybe ContainerInstance
a} :: RegisterContainerInstanceResponse)

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

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