{-# 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.AppMesh.Types.VirtualNodeSpec
-- 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.AppMesh.Types.VirtualNodeSpec where

import Amazonka.AppMesh.Types.Backend
import Amazonka.AppMesh.Types.BackendDefaults
import Amazonka.AppMesh.Types.Listener
import Amazonka.AppMesh.Types.Logging
import Amazonka.AppMesh.Types.ServiceDiscovery
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

-- | An object that represents the specification of a virtual node.
--
-- /See:/ 'newVirtualNodeSpec' smart constructor.
data VirtualNodeSpec = VirtualNodeSpec'
  { -- | A reference to an object that represents the defaults for backends.
    VirtualNodeSpec -> Maybe BackendDefaults
backendDefaults :: Prelude.Maybe BackendDefaults,
    -- | The backends that the virtual node is expected to send outbound traffic
    -- to.
    VirtualNodeSpec -> Maybe [Backend]
backends :: Prelude.Maybe [Backend],
    -- | The listener that the virtual node is expected to receive inbound
    -- traffic from. You can specify one listener.
    VirtualNodeSpec -> Maybe [Listener]
listeners :: Prelude.Maybe [Listener],
    -- | The inbound and outbound access logging information for the virtual
    -- node.
    VirtualNodeSpec -> Maybe Logging
logging :: Prelude.Maybe Logging,
    -- | The service discovery information for the virtual node. If your virtual
    -- node does not expect ingress traffic, you can omit this parameter. If
    -- you specify a @listener@, then you must specify service discovery
    -- information.
    VirtualNodeSpec -> Maybe ServiceDiscovery
serviceDiscovery :: Prelude.Maybe ServiceDiscovery
  }
  deriving (VirtualNodeSpec -> VirtualNodeSpec -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VirtualNodeSpec -> VirtualNodeSpec -> Bool
$c/= :: VirtualNodeSpec -> VirtualNodeSpec -> Bool
== :: VirtualNodeSpec -> VirtualNodeSpec -> Bool
$c== :: VirtualNodeSpec -> VirtualNodeSpec -> Bool
Prelude.Eq, ReadPrec [VirtualNodeSpec]
ReadPrec VirtualNodeSpec
Int -> ReadS VirtualNodeSpec
ReadS [VirtualNodeSpec]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [VirtualNodeSpec]
$creadListPrec :: ReadPrec [VirtualNodeSpec]
readPrec :: ReadPrec VirtualNodeSpec
$creadPrec :: ReadPrec VirtualNodeSpec
readList :: ReadS [VirtualNodeSpec]
$creadList :: ReadS [VirtualNodeSpec]
readsPrec :: Int -> ReadS VirtualNodeSpec
$creadsPrec :: Int -> ReadS VirtualNodeSpec
Prelude.Read, Int -> VirtualNodeSpec -> ShowS
[VirtualNodeSpec] -> ShowS
VirtualNodeSpec -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VirtualNodeSpec] -> ShowS
$cshowList :: [VirtualNodeSpec] -> ShowS
show :: VirtualNodeSpec -> String
$cshow :: VirtualNodeSpec -> String
showsPrec :: Int -> VirtualNodeSpec -> ShowS
$cshowsPrec :: Int -> VirtualNodeSpec -> ShowS
Prelude.Show, forall x. Rep VirtualNodeSpec x -> VirtualNodeSpec
forall x. VirtualNodeSpec -> Rep VirtualNodeSpec x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep VirtualNodeSpec x -> VirtualNodeSpec
$cfrom :: forall x. VirtualNodeSpec -> Rep VirtualNodeSpec x
Prelude.Generic)

-- |
-- Create a value of 'VirtualNodeSpec' 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:
--
-- 'backendDefaults', 'virtualNodeSpec_backendDefaults' - A reference to an object that represents the defaults for backends.
--
-- 'backends', 'virtualNodeSpec_backends' - The backends that the virtual node is expected to send outbound traffic
-- to.
--
-- 'listeners', 'virtualNodeSpec_listeners' - The listener that the virtual node is expected to receive inbound
-- traffic from. You can specify one listener.
--
-- 'logging', 'virtualNodeSpec_logging' - The inbound and outbound access logging information for the virtual
-- node.
--
-- 'serviceDiscovery', 'virtualNodeSpec_serviceDiscovery' - The service discovery information for the virtual node. If your virtual
-- node does not expect ingress traffic, you can omit this parameter. If
-- you specify a @listener@, then you must specify service discovery
-- information.
newVirtualNodeSpec ::
  VirtualNodeSpec
newVirtualNodeSpec :: VirtualNodeSpec
newVirtualNodeSpec =
  VirtualNodeSpec'
    { $sel:backendDefaults:VirtualNodeSpec' :: Maybe BackendDefaults
backendDefaults = forall a. Maybe a
Prelude.Nothing,
      $sel:backends:VirtualNodeSpec' :: Maybe [Backend]
backends = forall a. Maybe a
Prelude.Nothing,
      $sel:listeners:VirtualNodeSpec' :: Maybe [Listener]
listeners = forall a. Maybe a
Prelude.Nothing,
      $sel:logging:VirtualNodeSpec' :: Maybe Logging
logging = forall a. Maybe a
Prelude.Nothing,
      $sel:serviceDiscovery:VirtualNodeSpec' :: Maybe ServiceDiscovery
serviceDiscovery = forall a. Maybe a
Prelude.Nothing
    }

-- | A reference to an object that represents the defaults for backends.
virtualNodeSpec_backendDefaults :: Lens.Lens' VirtualNodeSpec (Prelude.Maybe BackendDefaults)
virtualNodeSpec_backendDefaults :: Lens' VirtualNodeSpec (Maybe BackendDefaults)
virtualNodeSpec_backendDefaults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VirtualNodeSpec' {Maybe BackendDefaults
backendDefaults :: Maybe BackendDefaults
$sel:backendDefaults:VirtualNodeSpec' :: VirtualNodeSpec -> Maybe BackendDefaults
backendDefaults} -> Maybe BackendDefaults
backendDefaults) (\s :: VirtualNodeSpec
s@VirtualNodeSpec' {} Maybe BackendDefaults
a -> VirtualNodeSpec
s {$sel:backendDefaults:VirtualNodeSpec' :: Maybe BackendDefaults
backendDefaults = Maybe BackendDefaults
a} :: VirtualNodeSpec)

-- | The backends that the virtual node is expected to send outbound traffic
-- to.
virtualNodeSpec_backends :: Lens.Lens' VirtualNodeSpec (Prelude.Maybe [Backend])
virtualNodeSpec_backends :: Lens' VirtualNodeSpec (Maybe [Backend])
virtualNodeSpec_backends = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VirtualNodeSpec' {Maybe [Backend]
backends :: Maybe [Backend]
$sel:backends:VirtualNodeSpec' :: VirtualNodeSpec -> Maybe [Backend]
backends} -> Maybe [Backend]
backends) (\s :: VirtualNodeSpec
s@VirtualNodeSpec' {} Maybe [Backend]
a -> VirtualNodeSpec
s {$sel:backends:VirtualNodeSpec' :: Maybe [Backend]
backends = Maybe [Backend]
a} :: VirtualNodeSpec) 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 listener that the virtual node is expected to receive inbound
-- traffic from. You can specify one listener.
virtualNodeSpec_listeners :: Lens.Lens' VirtualNodeSpec (Prelude.Maybe [Listener])
virtualNodeSpec_listeners :: Lens' VirtualNodeSpec (Maybe [Listener])
virtualNodeSpec_listeners = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VirtualNodeSpec' {Maybe [Listener]
listeners :: Maybe [Listener]
$sel:listeners:VirtualNodeSpec' :: VirtualNodeSpec -> Maybe [Listener]
listeners} -> Maybe [Listener]
listeners) (\s :: VirtualNodeSpec
s@VirtualNodeSpec' {} Maybe [Listener]
a -> VirtualNodeSpec
s {$sel:listeners:VirtualNodeSpec' :: Maybe [Listener]
listeners = Maybe [Listener]
a} :: VirtualNodeSpec) 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 inbound and outbound access logging information for the virtual
-- node.
virtualNodeSpec_logging :: Lens.Lens' VirtualNodeSpec (Prelude.Maybe Logging)
virtualNodeSpec_logging :: Lens' VirtualNodeSpec (Maybe Logging)
virtualNodeSpec_logging = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VirtualNodeSpec' {Maybe Logging
logging :: Maybe Logging
$sel:logging:VirtualNodeSpec' :: VirtualNodeSpec -> Maybe Logging
logging} -> Maybe Logging
logging) (\s :: VirtualNodeSpec
s@VirtualNodeSpec' {} Maybe Logging
a -> VirtualNodeSpec
s {$sel:logging:VirtualNodeSpec' :: Maybe Logging
logging = Maybe Logging
a} :: VirtualNodeSpec)

-- | The service discovery information for the virtual node. If your virtual
-- node does not expect ingress traffic, you can omit this parameter. If
-- you specify a @listener@, then you must specify service discovery
-- information.
virtualNodeSpec_serviceDiscovery :: Lens.Lens' VirtualNodeSpec (Prelude.Maybe ServiceDiscovery)
virtualNodeSpec_serviceDiscovery :: Lens' VirtualNodeSpec (Maybe ServiceDiscovery)
virtualNodeSpec_serviceDiscovery = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VirtualNodeSpec' {Maybe ServiceDiscovery
serviceDiscovery :: Maybe ServiceDiscovery
$sel:serviceDiscovery:VirtualNodeSpec' :: VirtualNodeSpec -> Maybe ServiceDiscovery
serviceDiscovery} -> Maybe ServiceDiscovery
serviceDiscovery) (\s :: VirtualNodeSpec
s@VirtualNodeSpec' {} Maybe ServiceDiscovery
a -> VirtualNodeSpec
s {$sel:serviceDiscovery:VirtualNodeSpec' :: Maybe ServiceDiscovery
serviceDiscovery = Maybe ServiceDiscovery
a} :: VirtualNodeSpec)

instance Data.FromJSON VirtualNodeSpec where
  parseJSON :: Value -> Parser VirtualNodeSpec
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"VirtualNodeSpec"
      ( \Object
x ->
          Maybe BackendDefaults
-> Maybe [Backend]
-> Maybe [Listener]
-> Maybe Logging
-> Maybe ServiceDiscovery
-> VirtualNodeSpec
VirtualNodeSpec'
            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
"backendDefaults")
            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
"backends" 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
"listeners" 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
"logging")
            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
"serviceDiscovery")
      )

instance Prelude.Hashable VirtualNodeSpec where
  hashWithSalt :: Int -> VirtualNodeSpec -> Int
hashWithSalt Int
_salt VirtualNodeSpec' {Maybe [Listener]
Maybe [Backend]
Maybe Logging
Maybe ServiceDiscovery
Maybe BackendDefaults
serviceDiscovery :: Maybe ServiceDiscovery
logging :: Maybe Logging
listeners :: Maybe [Listener]
backends :: Maybe [Backend]
backendDefaults :: Maybe BackendDefaults
$sel:serviceDiscovery:VirtualNodeSpec' :: VirtualNodeSpec -> Maybe ServiceDiscovery
$sel:logging:VirtualNodeSpec' :: VirtualNodeSpec -> Maybe Logging
$sel:listeners:VirtualNodeSpec' :: VirtualNodeSpec -> Maybe [Listener]
$sel:backends:VirtualNodeSpec' :: VirtualNodeSpec -> Maybe [Backend]
$sel:backendDefaults:VirtualNodeSpec' :: VirtualNodeSpec -> Maybe BackendDefaults
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe BackendDefaults
backendDefaults
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Backend]
backends
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Listener]
listeners
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Logging
logging
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ServiceDiscovery
serviceDiscovery

instance Prelude.NFData VirtualNodeSpec where
  rnf :: VirtualNodeSpec -> ()
rnf VirtualNodeSpec' {Maybe [Listener]
Maybe [Backend]
Maybe Logging
Maybe ServiceDiscovery
Maybe BackendDefaults
serviceDiscovery :: Maybe ServiceDiscovery
logging :: Maybe Logging
listeners :: Maybe [Listener]
backends :: Maybe [Backend]
backendDefaults :: Maybe BackendDefaults
$sel:serviceDiscovery:VirtualNodeSpec' :: VirtualNodeSpec -> Maybe ServiceDiscovery
$sel:logging:VirtualNodeSpec' :: VirtualNodeSpec -> Maybe Logging
$sel:listeners:VirtualNodeSpec' :: VirtualNodeSpec -> Maybe [Listener]
$sel:backends:VirtualNodeSpec' :: VirtualNodeSpec -> Maybe [Backend]
$sel:backendDefaults:VirtualNodeSpec' :: VirtualNodeSpec -> Maybe BackendDefaults
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe BackendDefaults
backendDefaults
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Backend]
backends
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Listener]
listeners
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Logging
logging
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ServiceDiscovery
serviceDiscovery

instance Data.ToJSON VirtualNodeSpec where
  toJSON :: VirtualNodeSpec -> Value
toJSON VirtualNodeSpec' {Maybe [Listener]
Maybe [Backend]
Maybe Logging
Maybe ServiceDiscovery
Maybe BackendDefaults
serviceDiscovery :: Maybe ServiceDiscovery
logging :: Maybe Logging
listeners :: Maybe [Listener]
backends :: Maybe [Backend]
backendDefaults :: Maybe BackendDefaults
$sel:serviceDiscovery:VirtualNodeSpec' :: VirtualNodeSpec -> Maybe ServiceDiscovery
$sel:logging:VirtualNodeSpec' :: VirtualNodeSpec -> Maybe Logging
$sel:listeners:VirtualNodeSpec' :: VirtualNodeSpec -> Maybe [Listener]
$sel:backends:VirtualNodeSpec' :: VirtualNodeSpec -> Maybe [Backend]
$sel:backendDefaults:VirtualNodeSpec' :: VirtualNodeSpec -> Maybe BackendDefaults
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"backendDefaults" 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 BackendDefaults
backendDefaults,
            (Key
"backends" 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 [Backend]
backends,
            (Key
"listeners" 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 [Listener]
listeners,
            (Key
"logging" 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 Logging
logging,
            (Key
"serviceDiscovery" 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 ServiceDiscovery
serviceDiscovery
          ]
      )