{-# 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.ELBV2.RegisterTargets
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Registers the specified targets with the specified target group.
--
-- If the target is an EC2 instance, it must be in the @running@ state when
-- you register it.
--
-- By default, the load balancer routes requests to registered targets
-- using the protocol and port for the target group. Alternatively, you can
-- override the port for a target when you register it. You can register
-- each EC2 instance or IP address with the same target group multiple
-- times using different ports.
--
-- With a Network Load Balancer, you cannot register instances by instance
-- ID if they have the following instance types: C1, CC1, CC2, CG1, CG2,
-- CR1, CS1, G1, G2, HI1, HS1, M1, M2, M3, and T1. You can register
-- instances of these types by IP address.
module Amazonka.ELBV2.RegisterTargets
  ( -- * Creating a Request
    RegisterTargets (..),
    newRegisterTargets,

    -- * Request Lenses
    registerTargets_targetGroupArn,
    registerTargets_targets,

    -- * Destructuring the Response
    RegisterTargetsResponse (..),
    newRegisterTargetsResponse,

    -- * Response Lenses
    registerTargetsResponse_httpStatus,
  )
where

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

-- | /See:/ 'newRegisterTargets' smart constructor.
data RegisterTargets = RegisterTargets'
  { -- | The Amazon Resource Name (ARN) of the target group.
    RegisterTargets -> Text
targetGroupArn :: Prelude.Text,
    -- | The targets.
    RegisterTargets -> [TargetDescription]
targets :: [TargetDescription]
  }
  deriving (RegisterTargets -> RegisterTargets -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegisterTargets -> RegisterTargets -> Bool
$c/= :: RegisterTargets -> RegisterTargets -> Bool
== :: RegisterTargets -> RegisterTargets -> Bool
$c== :: RegisterTargets -> RegisterTargets -> Bool
Prelude.Eq, ReadPrec [RegisterTargets]
ReadPrec RegisterTargets
Int -> ReadS RegisterTargets
ReadS [RegisterTargets]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RegisterTargets]
$creadListPrec :: ReadPrec [RegisterTargets]
readPrec :: ReadPrec RegisterTargets
$creadPrec :: ReadPrec RegisterTargets
readList :: ReadS [RegisterTargets]
$creadList :: ReadS [RegisterTargets]
readsPrec :: Int -> ReadS RegisterTargets
$creadsPrec :: Int -> ReadS RegisterTargets
Prelude.Read, Int -> RegisterTargets -> ShowS
[RegisterTargets] -> ShowS
RegisterTargets -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RegisterTargets] -> ShowS
$cshowList :: [RegisterTargets] -> ShowS
show :: RegisterTargets -> String
$cshow :: RegisterTargets -> String
showsPrec :: Int -> RegisterTargets -> ShowS
$cshowsPrec :: Int -> RegisterTargets -> ShowS
Prelude.Show, forall x. Rep RegisterTargets x -> RegisterTargets
forall x. RegisterTargets -> Rep RegisterTargets x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RegisterTargets x -> RegisterTargets
$cfrom :: forall x. RegisterTargets -> Rep RegisterTargets x
Prelude.Generic)

-- |
-- Create a value of 'RegisterTargets' 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:
--
-- 'targetGroupArn', 'registerTargets_targetGroupArn' - The Amazon Resource Name (ARN) of the target group.
--
-- 'targets', 'registerTargets_targets' - The targets.
newRegisterTargets ::
  -- | 'targetGroupArn'
  Prelude.Text ->
  RegisterTargets
newRegisterTargets :: Text -> RegisterTargets
newRegisterTargets Text
pTargetGroupArn_ =
  RegisterTargets'
    { $sel:targetGroupArn:RegisterTargets' :: Text
targetGroupArn = Text
pTargetGroupArn_,
      $sel:targets:RegisterTargets' :: [TargetDescription]
targets = forall a. Monoid a => a
Prelude.mempty
    }

-- | The Amazon Resource Name (ARN) of the target group.
registerTargets_targetGroupArn :: Lens.Lens' RegisterTargets Prelude.Text
registerTargets_targetGroupArn :: Lens' RegisterTargets Text
registerTargets_targetGroupArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterTargets' {Text
targetGroupArn :: Text
$sel:targetGroupArn:RegisterTargets' :: RegisterTargets -> Text
targetGroupArn} -> Text
targetGroupArn) (\s :: RegisterTargets
s@RegisterTargets' {} Text
a -> RegisterTargets
s {$sel:targetGroupArn:RegisterTargets' :: Text
targetGroupArn = Text
a} :: RegisterTargets)

-- | The targets.
registerTargets_targets :: Lens.Lens' RegisterTargets [TargetDescription]
registerTargets_targets :: Lens' RegisterTargets [TargetDescription]
registerTargets_targets = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterTargets' {[TargetDescription]
targets :: [TargetDescription]
$sel:targets:RegisterTargets' :: RegisterTargets -> [TargetDescription]
targets} -> [TargetDescription]
targets) (\s :: RegisterTargets
s@RegisterTargets' {} [TargetDescription]
a -> RegisterTargets
s {$sel:targets:RegisterTargets' :: [TargetDescription]
targets = [TargetDescription]
a} :: RegisterTargets) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Core.AWSRequest RegisterTargets where
  type
    AWSResponse RegisterTargets =
      RegisterTargetsResponse
  request :: (Service -> Service) -> RegisterTargets -> Request RegisterTargets
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.postQuery (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy RegisterTargets
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse RegisterTargets)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
Text
-> (Int
    -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXMLWrapper
      Text
"RegisterTargetsResult"
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Int -> RegisterTargetsResponse
RegisterTargetsResponse'
            forall (f :: * -> *) a b. Functor 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 RegisterTargets where
  hashWithSalt :: Int -> RegisterTargets -> Int
hashWithSalt Int
_salt RegisterTargets' {[TargetDescription]
Text
targets :: [TargetDescription]
targetGroupArn :: Text
$sel:targets:RegisterTargets' :: RegisterTargets -> [TargetDescription]
$sel:targetGroupArn:RegisterTargets' :: RegisterTargets -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
targetGroupArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` [TargetDescription]
targets

instance Prelude.NFData RegisterTargets where
  rnf :: RegisterTargets -> ()
rnf RegisterTargets' {[TargetDescription]
Text
targets :: [TargetDescription]
targetGroupArn :: Text
$sel:targets:RegisterTargets' :: RegisterTargets -> [TargetDescription]
$sel:targetGroupArn:RegisterTargets' :: RegisterTargets -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
targetGroupArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [TargetDescription]
targets

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

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

instance Data.ToQuery RegisterTargets where
  toQuery :: RegisterTargets -> QueryString
toQuery RegisterTargets' {[TargetDescription]
Text
targets :: [TargetDescription]
targetGroupArn :: Text
$sel:targets:RegisterTargets' :: RegisterTargets -> [TargetDescription]
$sel:targetGroupArn:RegisterTargets' :: RegisterTargets -> Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"RegisterTargets" :: Prelude.ByteString),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2015-12-01" :: Prelude.ByteString),
        ByteString
"TargetGroupArn" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
targetGroupArn,
        ByteString
"Targets" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"member" [TargetDescription]
targets
      ]

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

-- |
-- Create a value of 'RegisterTargetsResponse' 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:
--
-- 'httpStatus', 'registerTargetsResponse_httpStatus' - The response's http status code.
newRegisterTargetsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  RegisterTargetsResponse
newRegisterTargetsResponse :: Int -> RegisterTargetsResponse
newRegisterTargetsResponse Int
pHttpStatus_ =
  RegisterTargetsResponse' {$sel:httpStatus:RegisterTargetsResponse' :: Int
httpStatus = Int
pHttpStatus_}

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

instance Prelude.NFData RegisterTargetsResponse where
  rnf :: RegisterTargetsResponse -> ()
rnf RegisterTargetsResponse' {Int
httpStatus :: Int
$sel:httpStatus:RegisterTargetsResponse' :: RegisterTargetsResponse -> Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus