{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.CodeDeploy.Types.LoadBalancerInfo
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.CodeDeploy.Types.LoadBalancerInfo where

import Amazonka.CodeDeploy.Types.ELBInfo
import Amazonka.CodeDeploy.Types.TargetGroupInfo
import Amazonka.CodeDeploy.Types.TargetGroupPairInfo
import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import qualified Amazonka.Prelude as Prelude

-- | Information about the Elastic Load Balancing load balancer or target
-- group used in a deployment.
--
-- /See:/ 'newLoadBalancerInfo' smart constructor.
data LoadBalancerInfo = LoadBalancerInfo'
  { -- | An array that contains information about the load balancer to use for
    -- load balancing in a deployment. In Elastic Load Balancing, load
    -- balancers are used with Classic Load Balancers.
    --
    -- Adding more than one load balancer to the array is not supported.
    LoadBalancerInfo -> Maybe [ELBInfo]
elbInfoList :: Prelude.Maybe [ELBInfo],
    -- | An array that contains information about the target group to use for
    -- load balancing in a deployment. In Elastic Load Balancing, target groups
    -- are used with Application Load Balancers.
    --
    -- Adding more than one target group to the array is not supported.
    LoadBalancerInfo -> Maybe [TargetGroupInfo]
targetGroupInfoList :: Prelude.Maybe [TargetGroupInfo],
    -- | The target group pair information. This is an array of
    -- @TargeGroupPairInfo@ objects with a maximum size of one.
    LoadBalancerInfo -> Maybe [TargetGroupPairInfo]
targetGroupPairInfoList :: Prelude.Maybe [TargetGroupPairInfo]
  }
  deriving (LoadBalancerInfo -> LoadBalancerInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LoadBalancerInfo -> LoadBalancerInfo -> Bool
$c/= :: LoadBalancerInfo -> LoadBalancerInfo -> Bool
== :: LoadBalancerInfo -> LoadBalancerInfo -> Bool
$c== :: LoadBalancerInfo -> LoadBalancerInfo -> Bool
Prelude.Eq, ReadPrec [LoadBalancerInfo]
ReadPrec LoadBalancerInfo
Int -> ReadS LoadBalancerInfo
ReadS [LoadBalancerInfo]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [LoadBalancerInfo]
$creadListPrec :: ReadPrec [LoadBalancerInfo]
readPrec :: ReadPrec LoadBalancerInfo
$creadPrec :: ReadPrec LoadBalancerInfo
readList :: ReadS [LoadBalancerInfo]
$creadList :: ReadS [LoadBalancerInfo]
readsPrec :: Int -> ReadS LoadBalancerInfo
$creadsPrec :: Int -> ReadS LoadBalancerInfo
Prelude.Read, Int -> LoadBalancerInfo -> ShowS
[LoadBalancerInfo] -> ShowS
LoadBalancerInfo -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LoadBalancerInfo] -> ShowS
$cshowList :: [LoadBalancerInfo] -> ShowS
show :: LoadBalancerInfo -> String
$cshow :: LoadBalancerInfo -> String
showsPrec :: Int -> LoadBalancerInfo -> ShowS
$cshowsPrec :: Int -> LoadBalancerInfo -> ShowS
Prelude.Show, forall x. Rep LoadBalancerInfo x -> LoadBalancerInfo
forall x. LoadBalancerInfo -> Rep LoadBalancerInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LoadBalancerInfo x -> LoadBalancerInfo
$cfrom :: forall x. LoadBalancerInfo -> Rep LoadBalancerInfo x
Prelude.Generic)

-- |
-- Create a value of 'LoadBalancerInfo' 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:
--
-- 'elbInfoList', 'loadBalancerInfo_elbInfoList' - An array that contains information about the load balancer to use for
-- load balancing in a deployment. In Elastic Load Balancing, load
-- balancers are used with Classic Load Balancers.
--
-- Adding more than one load balancer to the array is not supported.
--
-- 'targetGroupInfoList', 'loadBalancerInfo_targetGroupInfoList' - An array that contains information about the target group to use for
-- load balancing in a deployment. In Elastic Load Balancing, target groups
-- are used with Application Load Balancers.
--
-- Adding more than one target group to the array is not supported.
--
-- 'targetGroupPairInfoList', 'loadBalancerInfo_targetGroupPairInfoList' - The target group pair information. This is an array of
-- @TargeGroupPairInfo@ objects with a maximum size of one.
newLoadBalancerInfo ::
  LoadBalancerInfo
newLoadBalancerInfo :: LoadBalancerInfo
newLoadBalancerInfo =
  LoadBalancerInfo'
    { $sel:elbInfoList:LoadBalancerInfo' :: Maybe [ELBInfo]
elbInfoList = forall a. Maybe a
Prelude.Nothing,
      $sel:targetGroupInfoList:LoadBalancerInfo' :: Maybe [TargetGroupInfo]
targetGroupInfoList = forall a. Maybe a
Prelude.Nothing,
      $sel:targetGroupPairInfoList:LoadBalancerInfo' :: Maybe [TargetGroupPairInfo]
targetGroupPairInfoList = forall a. Maybe a
Prelude.Nothing
    }

-- | An array that contains information about the load balancer to use for
-- load balancing in a deployment. In Elastic Load Balancing, load
-- balancers are used with Classic Load Balancers.
--
-- Adding more than one load balancer to the array is not supported.
loadBalancerInfo_elbInfoList :: Lens.Lens' LoadBalancerInfo (Prelude.Maybe [ELBInfo])
loadBalancerInfo_elbInfoList :: Lens' LoadBalancerInfo (Maybe [ELBInfo])
loadBalancerInfo_elbInfoList = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancerInfo' {Maybe [ELBInfo]
elbInfoList :: Maybe [ELBInfo]
$sel:elbInfoList:LoadBalancerInfo' :: LoadBalancerInfo -> Maybe [ELBInfo]
elbInfoList} -> Maybe [ELBInfo]
elbInfoList) (\s :: LoadBalancerInfo
s@LoadBalancerInfo' {} Maybe [ELBInfo]
a -> LoadBalancerInfo
s {$sel:elbInfoList:LoadBalancerInfo' :: Maybe [ELBInfo]
elbInfoList = Maybe [ELBInfo]
a} :: LoadBalancerInfo) 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

-- | An array that contains information about the target group to use for
-- load balancing in a deployment. In Elastic Load Balancing, target groups
-- are used with Application Load Balancers.
--
-- Adding more than one target group to the array is not supported.
loadBalancerInfo_targetGroupInfoList :: Lens.Lens' LoadBalancerInfo (Prelude.Maybe [TargetGroupInfo])
loadBalancerInfo_targetGroupInfoList :: Lens' LoadBalancerInfo (Maybe [TargetGroupInfo])
loadBalancerInfo_targetGroupInfoList = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancerInfo' {Maybe [TargetGroupInfo]
targetGroupInfoList :: Maybe [TargetGroupInfo]
$sel:targetGroupInfoList:LoadBalancerInfo' :: LoadBalancerInfo -> Maybe [TargetGroupInfo]
targetGroupInfoList} -> Maybe [TargetGroupInfo]
targetGroupInfoList) (\s :: LoadBalancerInfo
s@LoadBalancerInfo' {} Maybe [TargetGroupInfo]
a -> LoadBalancerInfo
s {$sel:targetGroupInfoList:LoadBalancerInfo' :: Maybe [TargetGroupInfo]
targetGroupInfoList = Maybe [TargetGroupInfo]
a} :: LoadBalancerInfo) 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 target group pair information. This is an array of
-- @TargeGroupPairInfo@ objects with a maximum size of one.
loadBalancerInfo_targetGroupPairInfoList :: Lens.Lens' LoadBalancerInfo (Prelude.Maybe [TargetGroupPairInfo])
loadBalancerInfo_targetGroupPairInfoList :: Lens' LoadBalancerInfo (Maybe [TargetGroupPairInfo])
loadBalancerInfo_targetGroupPairInfoList = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancerInfo' {Maybe [TargetGroupPairInfo]
targetGroupPairInfoList :: Maybe [TargetGroupPairInfo]
$sel:targetGroupPairInfoList:LoadBalancerInfo' :: LoadBalancerInfo -> Maybe [TargetGroupPairInfo]
targetGroupPairInfoList} -> Maybe [TargetGroupPairInfo]
targetGroupPairInfoList) (\s :: LoadBalancerInfo
s@LoadBalancerInfo' {} Maybe [TargetGroupPairInfo]
a -> LoadBalancerInfo
s {$sel:targetGroupPairInfoList:LoadBalancerInfo' :: Maybe [TargetGroupPairInfo]
targetGroupPairInfoList = Maybe [TargetGroupPairInfo]
a} :: LoadBalancerInfo) 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

instance Data.FromJSON LoadBalancerInfo where
  parseJSON :: Value -> Parser LoadBalancerInfo
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"LoadBalancerInfo"
      ( \Object
x ->
          Maybe [ELBInfo]
-> Maybe [TargetGroupInfo]
-> Maybe [TargetGroupPairInfo]
-> LoadBalancerInfo
LoadBalancerInfo'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"elbInfoList" forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"targetGroupInfoList"
                            forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"targetGroupPairInfoList"
                            forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty
                        )
      )

instance Prelude.Hashable LoadBalancerInfo where
  hashWithSalt :: Int -> LoadBalancerInfo -> Int
hashWithSalt Int
_salt LoadBalancerInfo' {Maybe [ELBInfo]
Maybe [TargetGroupInfo]
Maybe [TargetGroupPairInfo]
targetGroupPairInfoList :: Maybe [TargetGroupPairInfo]
targetGroupInfoList :: Maybe [TargetGroupInfo]
elbInfoList :: Maybe [ELBInfo]
$sel:targetGroupPairInfoList:LoadBalancerInfo' :: LoadBalancerInfo -> Maybe [TargetGroupPairInfo]
$sel:targetGroupInfoList:LoadBalancerInfo' :: LoadBalancerInfo -> Maybe [TargetGroupInfo]
$sel:elbInfoList:LoadBalancerInfo' :: LoadBalancerInfo -> Maybe [ELBInfo]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [ELBInfo]
elbInfoList
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [TargetGroupInfo]
targetGroupInfoList
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [TargetGroupPairInfo]
targetGroupPairInfoList

instance Prelude.NFData LoadBalancerInfo where
  rnf :: LoadBalancerInfo -> ()
rnf LoadBalancerInfo' {Maybe [ELBInfo]
Maybe [TargetGroupInfo]
Maybe [TargetGroupPairInfo]
targetGroupPairInfoList :: Maybe [TargetGroupPairInfo]
targetGroupInfoList :: Maybe [TargetGroupInfo]
elbInfoList :: Maybe [ELBInfo]
$sel:targetGroupPairInfoList:LoadBalancerInfo' :: LoadBalancerInfo -> Maybe [TargetGroupPairInfo]
$sel:targetGroupInfoList:LoadBalancerInfo' :: LoadBalancerInfo -> Maybe [TargetGroupInfo]
$sel:elbInfoList:LoadBalancerInfo' :: LoadBalancerInfo -> Maybe [ELBInfo]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [ELBInfo]
elbInfoList
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [TargetGroupInfo]
targetGroupInfoList
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [TargetGroupPairInfo]
targetGroupPairInfoList

instance Data.ToJSON LoadBalancerInfo where
  toJSON :: LoadBalancerInfo -> Value
toJSON LoadBalancerInfo' {Maybe [ELBInfo]
Maybe [TargetGroupInfo]
Maybe [TargetGroupPairInfo]
targetGroupPairInfoList :: Maybe [TargetGroupPairInfo]
targetGroupInfoList :: Maybe [TargetGroupInfo]
elbInfoList :: Maybe [ELBInfo]
$sel:targetGroupPairInfoList:LoadBalancerInfo' :: LoadBalancerInfo -> Maybe [TargetGroupPairInfo]
$sel:targetGroupInfoList:LoadBalancerInfo' :: LoadBalancerInfo -> Maybe [TargetGroupInfo]
$sel:elbInfoList:LoadBalancerInfo' :: LoadBalancerInfo -> Maybe [ELBInfo]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"elbInfoList" 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 [ELBInfo]
elbInfoList,
            (Key
"targetGroupInfoList" 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 [TargetGroupInfo]
targetGroupInfoList,
            (Key
"targetGroupPairInfoList" 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 [TargetGroupPairInfo]
targetGroupPairInfoList
          ]
      )