{-# 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.ElastiCache.Types.UpdateAction
-- 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.ElastiCache.Types.UpdateAction where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.ElastiCache.Types.CacheNodeUpdateStatus
import Amazonka.ElastiCache.Types.NodeGroupUpdateStatus
import Amazonka.ElastiCache.Types.ServiceUpdateSeverity
import Amazonka.ElastiCache.Types.ServiceUpdateStatus
import Amazonka.ElastiCache.Types.ServiceUpdateType
import Amazonka.ElastiCache.Types.SlaMet
import Amazonka.ElastiCache.Types.UpdateActionStatus
import qualified Amazonka.Prelude as Prelude

-- | The status of the service update for a specific replication group
--
-- /See:/ 'newUpdateAction' smart constructor.
data UpdateAction = UpdateAction'
  { -- | The ID of the cache cluster
    UpdateAction -> Maybe Text
cacheClusterId :: Prelude.Maybe Prelude.Text,
    -- | The status of the service update on the cache node
    UpdateAction -> Maybe [CacheNodeUpdateStatus]
cacheNodeUpdateStatus :: Prelude.Maybe [CacheNodeUpdateStatus],
    -- | The Elasticache engine to which the update applies. Either Redis or
    -- Memcached
    UpdateAction -> Maybe Text
engine :: Prelude.Maybe Prelude.Text,
    -- | The estimated length of time for the update to complete
    UpdateAction -> Maybe Text
estimatedUpdateTime :: Prelude.Maybe Prelude.Text,
    -- | The status of the service update on the node group
    UpdateAction -> Maybe [NodeGroupUpdateStatus]
nodeGroupUpdateStatus :: Prelude.Maybe [NodeGroupUpdateStatus],
    -- | The progress of the service update on the replication group
    UpdateAction -> Maybe Text
nodesUpdated :: Prelude.Maybe Prelude.Text,
    -- | The ID of the replication group
    UpdateAction -> Maybe Text
replicationGroupId :: Prelude.Maybe Prelude.Text,
    -- | The unique ID of the service update
    UpdateAction -> Maybe Text
serviceUpdateName :: Prelude.Maybe Prelude.Text,
    -- | The recommended date to apply the service update to ensure compliance.
    -- For information on compliance, see
    -- <https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/elasticache-compliance.html#elasticache-compliance-self-service Self-Service Security Updates for Compliance>.
    UpdateAction -> Maybe ISO8601
serviceUpdateRecommendedApplyByDate :: Prelude.Maybe Data.ISO8601,
    -- | The date the update is first available
    UpdateAction -> Maybe ISO8601
serviceUpdateReleaseDate :: Prelude.Maybe Data.ISO8601,
    -- | The severity of the service update
    UpdateAction -> Maybe ServiceUpdateSeverity
serviceUpdateSeverity :: Prelude.Maybe ServiceUpdateSeverity,
    -- | The status of the service update
    UpdateAction -> Maybe ServiceUpdateStatus
serviceUpdateStatus :: Prelude.Maybe ServiceUpdateStatus,
    -- | Reflects the nature of the service update
    UpdateAction -> Maybe ServiceUpdateType
serviceUpdateType :: Prelude.Maybe ServiceUpdateType,
    -- | If yes, all nodes in the replication group have been updated by the
    -- recommended apply-by date. If no, at least one node in the replication
    -- group have not been updated by the recommended apply-by date. If N\/A,
    -- the replication group was created after the recommended apply-by date.
    UpdateAction -> Maybe SlaMet
slaMet :: Prelude.Maybe SlaMet,
    -- | The date that the service update is available to a replication group
    UpdateAction -> Maybe ISO8601
updateActionAvailableDate :: Prelude.Maybe Data.ISO8601,
    -- | The status of the update action
    UpdateAction -> Maybe UpdateActionStatus
updateActionStatus :: Prelude.Maybe UpdateActionStatus,
    -- | The date when the UpdateActionStatus was last modified
    UpdateAction -> Maybe ISO8601
updateActionStatusModifiedDate :: Prelude.Maybe Data.ISO8601
  }
  deriving (UpdateAction -> UpdateAction -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateAction -> UpdateAction -> Bool
$c/= :: UpdateAction -> UpdateAction -> Bool
== :: UpdateAction -> UpdateAction -> Bool
$c== :: UpdateAction -> UpdateAction -> Bool
Prelude.Eq, ReadPrec [UpdateAction]
ReadPrec UpdateAction
Int -> ReadS UpdateAction
ReadS [UpdateAction]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdateAction]
$creadListPrec :: ReadPrec [UpdateAction]
readPrec :: ReadPrec UpdateAction
$creadPrec :: ReadPrec UpdateAction
readList :: ReadS [UpdateAction]
$creadList :: ReadS [UpdateAction]
readsPrec :: Int -> ReadS UpdateAction
$creadsPrec :: Int -> ReadS UpdateAction
Prelude.Read, Int -> UpdateAction -> ShowS
[UpdateAction] -> ShowS
UpdateAction -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateAction] -> ShowS
$cshowList :: [UpdateAction] -> ShowS
show :: UpdateAction -> String
$cshow :: UpdateAction -> String
showsPrec :: Int -> UpdateAction -> ShowS
$cshowsPrec :: Int -> UpdateAction -> ShowS
Prelude.Show, forall x. Rep UpdateAction x -> UpdateAction
forall x. UpdateAction -> Rep UpdateAction x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UpdateAction x -> UpdateAction
$cfrom :: forall x. UpdateAction -> Rep UpdateAction x
Prelude.Generic)

-- |
-- Create a value of 'UpdateAction' 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:
--
-- 'cacheClusterId', 'updateAction_cacheClusterId' - The ID of the cache cluster
--
-- 'cacheNodeUpdateStatus', 'updateAction_cacheNodeUpdateStatus' - The status of the service update on the cache node
--
-- 'engine', 'updateAction_engine' - The Elasticache engine to which the update applies. Either Redis or
-- Memcached
--
-- 'estimatedUpdateTime', 'updateAction_estimatedUpdateTime' - The estimated length of time for the update to complete
--
-- 'nodeGroupUpdateStatus', 'updateAction_nodeGroupUpdateStatus' - The status of the service update on the node group
--
-- 'nodesUpdated', 'updateAction_nodesUpdated' - The progress of the service update on the replication group
--
-- 'replicationGroupId', 'updateAction_replicationGroupId' - The ID of the replication group
--
-- 'serviceUpdateName', 'updateAction_serviceUpdateName' - The unique ID of the service update
--
-- 'serviceUpdateRecommendedApplyByDate', 'updateAction_serviceUpdateRecommendedApplyByDate' - The recommended date to apply the service update to ensure compliance.
-- For information on compliance, see
-- <https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/elasticache-compliance.html#elasticache-compliance-self-service Self-Service Security Updates for Compliance>.
--
-- 'serviceUpdateReleaseDate', 'updateAction_serviceUpdateReleaseDate' - The date the update is first available
--
-- 'serviceUpdateSeverity', 'updateAction_serviceUpdateSeverity' - The severity of the service update
--
-- 'serviceUpdateStatus', 'updateAction_serviceUpdateStatus' - The status of the service update
--
-- 'serviceUpdateType', 'updateAction_serviceUpdateType' - Reflects the nature of the service update
--
-- 'slaMet', 'updateAction_slaMet' - If yes, all nodes in the replication group have been updated by the
-- recommended apply-by date. If no, at least one node in the replication
-- group have not been updated by the recommended apply-by date. If N\/A,
-- the replication group was created after the recommended apply-by date.
--
-- 'updateActionAvailableDate', 'updateAction_updateActionAvailableDate' - The date that the service update is available to a replication group
--
-- 'updateActionStatus', 'updateAction_updateActionStatus' - The status of the update action
--
-- 'updateActionStatusModifiedDate', 'updateAction_updateActionStatusModifiedDate' - The date when the UpdateActionStatus was last modified
newUpdateAction ::
  UpdateAction
newUpdateAction :: UpdateAction
newUpdateAction =
  UpdateAction'
    { $sel:cacheClusterId:UpdateAction' :: Maybe Text
cacheClusterId = forall a. Maybe a
Prelude.Nothing,
      $sel:cacheNodeUpdateStatus:UpdateAction' :: Maybe [CacheNodeUpdateStatus]
cacheNodeUpdateStatus = forall a. Maybe a
Prelude.Nothing,
      $sel:engine:UpdateAction' :: Maybe Text
engine = forall a. Maybe a
Prelude.Nothing,
      $sel:estimatedUpdateTime:UpdateAction' :: Maybe Text
estimatedUpdateTime = forall a. Maybe a
Prelude.Nothing,
      $sel:nodeGroupUpdateStatus:UpdateAction' :: Maybe [NodeGroupUpdateStatus]
nodeGroupUpdateStatus = forall a. Maybe a
Prelude.Nothing,
      $sel:nodesUpdated:UpdateAction' :: Maybe Text
nodesUpdated = forall a. Maybe a
Prelude.Nothing,
      $sel:replicationGroupId:UpdateAction' :: Maybe Text
replicationGroupId = forall a. Maybe a
Prelude.Nothing,
      $sel:serviceUpdateName:UpdateAction' :: Maybe Text
serviceUpdateName = forall a. Maybe a
Prelude.Nothing,
      $sel:serviceUpdateRecommendedApplyByDate:UpdateAction' :: Maybe ISO8601
serviceUpdateRecommendedApplyByDate =
        forall a. Maybe a
Prelude.Nothing,
      $sel:serviceUpdateReleaseDate:UpdateAction' :: Maybe ISO8601
serviceUpdateReleaseDate = forall a. Maybe a
Prelude.Nothing,
      $sel:serviceUpdateSeverity:UpdateAction' :: Maybe ServiceUpdateSeverity
serviceUpdateSeverity = forall a. Maybe a
Prelude.Nothing,
      $sel:serviceUpdateStatus:UpdateAction' :: Maybe ServiceUpdateStatus
serviceUpdateStatus = forall a. Maybe a
Prelude.Nothing,
      $sel:serviceUpdateType:UpdateAction' :: Maybe ServiceUpdateType
serviceUpdateType = forall a. Maybe a
Prelude.Nothing,
      $sel:slaMet:UpdateAction' :: Maybe SlaMet
slaMet = forall a. Maybe a
Prelude.Nothing,
      $sel:updateActionAvailableDate:UpdateAction' :: Maybe ISO8601
updateActionAvailableDate = forall a. Maybe a
Prelude.Nothing,
      $sel:updateActionStatus:UpdateAction' :: Maybe UpdateActionStatus
updateActionStatus = forall a. Maybe a
Prelude.Nothing,
      $sel:updateActionStatusModifiedDate:UpdateAction' :: Maybe ISO8601
updateActionStatusModifiedDate = forall a. Maybe a
Prelude.Nothing
    }

-- | The ID of the cache cluster
updateAction_cacheClusterId :: Lens.Lens' UpdateAction (Prelude.Maybe Prelude.Text)
updateAction_cacheClusterId :: Lens' UpdateAction (Maybe Text)
updateAction_cacheClusterId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateAction' {Maybe Text
cacheClusterId :: Maybe Text
$sel:cacheClusterId:UpdateAction' :: UpdateAction -> Maybe Text
cacheClusterId} -> Maybe Text
cacheClusterId) (\s :: UpdateAction
s@UpdateAction' {} Maybe Text
a -> UpdateAction
s {$sel:cacheClusterId:UpdateAction' :: Maybe Text
cacheClusterId = Maybe Text
a} :: UpdateAction)

-- | The status of the service update on the cache node
updateAction_cacheNodeUpdateStatus :: Lens.Lens' UpdateAction (Prelude.Maybe [CacheNodeUpdateStatus])
updateAction_cacheNodeUpdateStatus :: Lens' UpdateAction (Maybe [CacheNodeUpdateStatus])
updateAction_cacheNodeUpdateStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateAction' {Maybe [CacheNodeUpdateStatus]
cacheNodeUpdateStatus :: Maybe [CacheNodeUpdateStatus]
$sel:cacheNodeUpdateStatus:UpdateAction' :: UpdateAction -> Maybe [CacheNodeUpdateStatus]
cacheNodeUpdateStatus} -> Maybe [CacheNodeUpdateStatus]
cacheNodeUpdateStatus) (\s :: UpdateAction
s@UpdateAction' {} Maybe [CacheNodeUpdateStatus]
a -> UpdateAction
s {$sel:cacheNodeUpdateStatus:UpdateAction' :: Maybe [CacheNodeUpdateStatus]
cacheNodeUpdateStatus = Maybe [CacheNodeUpdateStatus]
a} :: UpdateAction) 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 Elasticache engine to which the update applies. Either Redis or
-- Memcached
updateAction_engine :: Lens.Lens' UpdateAction (Prelude.Maybe Prelude.Text)
updateAction_engine :: Lens' UpdateAction (Maybe Text)
updateAction_engine = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateAction' {Maybe Text
engine :: Maybe Text
$sel:engine:UpdateAction' :: UpdateAction -> Maybe Text
engine} -> Maybe Text
engine) (\s :: UpdateAction
s@UpdateAction' {} Maybe Text
a -> UpdateAction
s {$sel:engine:UpdateAction' :: Maybe Text
engine = Maybe Text
a} :: UpdateAction)

-- | The estimated length of time for the update to complete
updateAction_estimatedUpdateTime :: Lens.Lens' UpdateAction (Prelude.Maybe Prelude.Text)
updateAction_estimatedUpdateTime :: Lens' UpdateAction (Maybe Text)
updateAction_estimatedUpdateTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateAction' {Maybe Text
estimatedUpdateTime :: Maybe Text
$sel:estimatedUpdateTime:UpdateAction' :: UpdateAction -> Maybe Text
estimatedUpdateTime} -> Maybe Text
estimatedUpdateTime) (\s :: UpdateAction
s@UpdateAction' {} Maybe Text
a -> UpdateAction
s {$sel:estimatedUpdateTime:UpdateAction' :: Maybe Text
estimatedUpdateTime = Maybe Text
a} :: UpdateAction)

-- | The status of the service update on the node group
updateAction_nodeGroupUpdateStatus :: Lens.Lens' UpdateAction (Prelude.Maybe [NodeGroupUpdateStatus])
updateAction_nodeGroupUpdateStatus :: Lens' UpdateAction (Maybe [NodeGroupUpdateStatus])
updateAction_nodeGroupUpdateStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateAction' {Maybe [NodeGroupUpdateStatus]
nodeGroupUpdateStatus :: Maybe [NodeGroupUpdateStatus]
$sel:nodeGroupUpdateStatus:UpdateAction' :: UpdateAction -> Maybe [NodeGroupUpdateStatus]
nodeGroupUpdateStatus} -> Maybe [NodeGroupUpdateStatus]
nodeGroupUpdateStatus) (\s :: UpdateAction
s@UpdateAction' {} Maybe [NodeGroupUpdateStatus]
a -> UpdateAction
s {$sel:nodeGroupUpdateStatus:UpdateAction' :: Maybe [NodeGroupUpdateStatus]
nodeGroupUpdateStatus = Maybe [NodeGroupUpdateStatus]
a} :: UpdateAction) 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 progress of the service update on the replication group
updateAction_nodesUpdated :: Lens.Lens' UpdateAction (Prelude.Maybe Prelude.Text)
updateAction_nodesUpdated :: Lens' UpdateAction (Maybe Text)
updateAction_nodesUpdated = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateAction' {Maybe Text
nodesUpdated :: Maybe Text
$sel:nodesUpdated:UpdateAction' :: UpdateAction -> Maybe Text
nodesUpdated} -> Maybe Text
nodesUpdated) (\s :: UpdateAction
s@UpdateAction' {} Maybe Text
a -> UpdateAction
s {$sel:nodesUpdated:UpdateAction' :: Maybe Text
nodesUpdated = Maybe Text
a} :: UpdateAction)

-- | The ID of the replication group
updateAction_replicationGroupId :: Lens.Lens' UpdateAction (Prelude.Maybe Prelude.Text)
updateAction_replicationGroupId :: Lens' UpdateAction (Maybe Text)
updateAction_replicationGroupId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateAction' {Maybe Text
replicationGroupId :: Maybe Text
$sel:replicationGroupId:UpdateAction' :: UpdateAction -> Maybe Text
replicationGroupId} -> Maybe Text
replicationGroupId) (\s :: UpdateAction
s@UpdateAction' {} Maybe Text
a -> UpdateAction
s {$sel:replicationGroupId:UpdateAction' :: Maybe Text
replicationGroupId = Maybe Text
a} :: UpdateAction)

-- | The unique ID of the service update
updateAction_serviceUpdateName :: Lens.Lens' UpdateAction (Prelude.Maybe Prelude.Text)
updateAction_serviceUpdateName :: Lens' UpdateAction (Maybe Text)
updateAction_serviceUpdateName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateAction' {Maybe Text
serviceUpdateName :: Maybe Text
$sel:serviceUpdateName:UpdateAction' :: UpdateAction -> Maybe Text
serviceUpdateName} -> Maybe Text
serviceUpdateName) (\s :: UpdateAction
s@UpdateAction' {} Maybe Text
a -> UpdateAction
s {$sel:serviceUpdateName:UpdateAction' :: Maybe Text
serviceUpdateName = Maybe Text
a} :: UpdateAction)

-- | The recommended date to apply the service update to ensure compliance.
-- For information on compliance, see
-- <https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/elasticache-compliance.html#elasticache-compliance-self-service Self-Service Security Updates for Compliance>.
updateAction_serviceUpdateRecommendedApplyByDate :: Lens.Lens' UpdateAction (Prelude.Maybe Prelude.UTCTime)
updateAction_serviceUpdateRecommendedApplyByDate :: Lens' UpdateAction (Maybe UTCTime)
updateAction_serviceUpdateRecommendedApplyByDate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateAction' {Maybe ISO8601
serviceUpdateRecommendedApplyByDate :: Maybe ISO8601
$sel:serviceUpdateRecommendedApplyByDate:UpdateAction' :: UpdateAction -> Maybe ISO8601
serviceUpdateRecommendedApplyByDate} -> Maybe ISO8601
serviceUpdateRecommendedApplyByDate) (\s :: UpdateAction
s@UpdateAction' {} Maybe ISO8601
a -> UpdateAction
s {$sel:serviceUpdateRecommendedApplyByDate:UpdateAction' :: Maybe ISO8601
serviceUpdateRecommendedApplyByDate = Maybe ISO8601
a} :: UpdateAction) 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 date the update is first available
updateAction_serviceUpdateReleaseDate :: Lens.Lens' UpdateAction (Prelude.Maybe Prelude.UTCTime)
updateAction_serviceUpdateReleaseDate :: Lens' UpdateAction (Maybe UTCTime)
updateAction_serviceUpdateReleaseDate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateAction' {Maybe ISO8601
serviceUpdateReleaseDate :: Maybe ISO8601
$sel:serviceUpdateReleaseDate:UpdateAction' :: UpdateAction -> Maybe ISO8601
serviceUpdateReleaseDate} -> Maybe ISO8601
serviceUpdateReleaseDate) (\s :: UpdateAction
s@UpdateAction' {} Maybe ISO8601
a -> UpdateAction
s {$sel:serviceUpdateReleaseDate:UpdateAction' :: Maybe ISO8601
serviceUpdateReleaseDate = Maybe ISO8601
a} :: UpdateAction) 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 severity of the service update
updateAction_serviceUpdateSeverity :: Lens.Lens' UpdateAction (Prelude.Maybe ServiceUpdateSeverity)
updateAction_serviceUpdateSeverity :: Lens' UpdateAction (Maybe ServiceUpdateSeverity)
updateAction_serviceUpdateSeverity = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateAction' {Maybe ServiceUpdateSeverity
serviceUpdateSeverity :: Maybe ServiceUpdateSeverity
$sel:serviceUpdateSeverity:UpdateAction' :: UpdateAction -> Maybe ServiceUpdateSeverity
serviceUpdateSeverity} -> Maybe ServiceUpdateSeverity
serviceUpdateSeverity) (\s :: UpdateAction
s@UpdateAction' {} Maybe ServiceUpdateSeverity
a -> UpdateAction
s {$sel:serviceUpdateSeverity:UpdateAction' :: Maybe ServiceUpdateSeverity
serviceUpdateSeverity = Maybe ServiceUpdateSeverity
a} :: UpdateAction)

-- | The status of the service update
updateAction_serviceUpdateStatus :: Lens.Lens' UpdateAction (Prelude.Maybe ServiceUpdateStatus)
updateAction_serviceUpdateStatus :: Lens' UpdateAction (Maybe ServiceUpdateStatus)
updateAction_serviceUpdateStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateAction' {Maybe ServiceUpdateStatus
serviceUpdateStatus :: Maybe ServiceUpdateStatus
$sel:serviceUpdateStatus:UpdateAction' :: UpdateAction -> Maybe ServiceUpdateStatus
serviceUpdateStatus} -> Maybe ServiceUpdateStatus
serviceUpdateStatus) (\s :: UpdateAction
s@UpdateAction' {} Maybe ServiceUpdateStatus
a -> UpdateAction
s {$sel:serviceUpdateStatus:UpdateAction' :: Maybe ServiceUpdateStatus
serviceUpdateStatus = Maybe ServiceUpdateStatus
a} :: UpdateAction)

-- | Reflects the nature of the service update
updateAction_serviceUpdateType :: Lens.Lens' UpdateAction (Prelude.Maybe ServiceUpdateType)
updateAction_serviceUpdateType :: Lens' UpdateAction (Maybe ServiceUpdateType)
updateAction_serviceUpdateType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateAction' {Maybe ServiceUpdateType
serviceUpdateType :: Maybe ServiceUpdateType
$sel:serviceUpdateType:UpdateAction' :: UpdateAction -> Maybe ServiceUpdateType
serviceUpdateType} -> Maybe ServiceUpdateType
serviceUpdateType) (\s :: UpdateAction
s@UpdateAction' {} Maybe ServiceUpdateType
a -> UpdateAction
s {$sel:serviceUpdateType:UpdateAction' :: Maybe ServiceUpdateType
serviceUpdateType = Maybe ServiceUpdateType
a} :: UpdateAction)

-- | If yes, all nodes in the replication group have been updated by the
-- recommended apply-by date. If no, at least one node in the replication
-- group have not been updated by the recommended apply-by date. If N\/A,
-- the replication group was created after the recommended apply-by date.
updateAction_slaMet :: Lens.Lens' UpdateAction (Prelude.Maybe SlaMet)
updateAction_slaMet :: Lens' UpdateAction (Maybe SlaMet)
updateAction_slaMet = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateAction' {Maybe SlaMet
slaMet :: Maybe SlaMet
$sel:slaMet:UpdateAction' :: UpdateAction -> Maybe SlaMet
slaMet} -> Maybe SlaMet
slaMet) (\s :: UpdateAction
s@UpdateAction' {} Maybe SlaMet
a -> UpdateAction
s {$sel:slaMet:UpdateAction' :: Maybe SlaMet
slaMet = Maybe SlaMet
a} :: UpdateAction)

-- | The date that the service update is available to a replication group
updateAction_updateActionAvailableDate :: Lens.Lens' UpdateAction (Prelude.Maybe Prelude.UTCTime)
updateAction_updateActionAvailableDate :: Lens' UpdateAction (Maybe UTCTime)
updateAction_updateActionAvailableDate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateAction' {Maybe ISO8601
updateActionAvailableDate :: Maybe ISO8601
$sel:updateActionAvailableDate:UpdateAction' :: UpdateAction -> Maybe ISO8601
updateActionAvailableDate} -> Maybe ISO8601
updateActionAvailableDate) (\s :: UpdateAction
s@UpdateAction' {} Maybe ISO8601
a -> UpdateAction
s {$sel:updateActionAvailableDate:UpdateAction' :: Maybe ISO8601
updateActionAvailableDate = Maybe ISO8601
a} :: UpdateAction) 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 status of the update action
updateAction_updateActionStatus :: Lens.Lens' UpdateAction (Prelude.Maybe UpdateActionStatus)
updateAction_updateActionStatus :: Lens' UpdateAction (Maybe UpdateActionStatus)
updateAction_updateActionStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateAction' {Maybe UpdateActionStatus
updateActionStatus :: Maybe UpdateActionStatus
$sel:updateActionStatus:UpdateAction' :: UpdateAction -> Maybe UpdateActionStatus
updateActionStatus} -> Maybe UpdateActionStatus
updateActionStatus) (\s :: UpdateAction
s@UpdateAction' {} Maybe UpdateActionStatus
a -> UpdateAction
s {$sel:updateActionStatus:UpdateAction' :: Maybe UpdateActionStatus
updateActionStatus = Maybe UpdateActionStatus
a} :: UpdateAction)

-- | The date when the UpdateActionStatus was last modified
updateAction_updateActionStatusModifiedDate :: Lens.Lens' UpdateAction (Prelude.Maybe Prelude.UTCTime)
updateAction_updateActionStatusModifiedDate :: Lens' UpdateAction (Maybe UTCTime)
updateAction_updateActionStatusModifiedDate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateAction' {Maybe ISO8601
updateActionStatusModifiedDate :: Maybe ISO8601
$sel:updateActionStatusModifiedDate:UpdateAction' :: UpdateAction -> Maybe ISO8601
updateActionStatusModifiedDate} -> Maybe ISO8601
updateActionStatusModifiedDate) (\s :: UpdateAction
s@UpdateAction' {} Maybe ISO8601
a -> UpdateAction
s {$sel:updateActionStatusModifiedDate:UpdateAction' :: Maybe ISO8601
updateActionStatusModifiedDate = Maybe ISO8601
a} :: UpdateAction) 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

instance Data.FromXML UpdateAction where
  parseXML :: [Node] -> Either String UpdateAction
parseXML [Node]
x =
    Maybe Text
-> Maybe [CacheNodeUpdateStatus]
-> Maybe Text
-> Maybe Text
-> Maybe [NodeGroupUpdateStatus]
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe ISO8601
-> Maybe ISO8601
-> Maybe ServiceUpdateSeverity
-> Maybe ServiceUpdateStatus
-> Maybe ServiceUpdateType
-> Maybe SlaMet
-> Maybe ISO8601
-> Maybe UpdateActionStatus
-> Maybe ISO8601
-> UpdateAction
UpdateAction'
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"CacheClusterId")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"CacheNodeUpdateStatus"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"CacheNodeUpdateStatus")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"Engine")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"EstimatedUpdateTime")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"NodeGroupUpdateStatus"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"NodeGroupUpdateStatus")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"NodesUpdated")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"ReplicationGroupId")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"ServiceUpdateName")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"ServiceUpdateRecommendedApplyByDate")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"ServiceUpdateReleaseDate")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"ServiceUpdateSeverity")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"ServiceUpdateStatus")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"ServiceUpdateType")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"SlaMet")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"UpdateActionAvailableDate")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"UpdateActionStatus")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"UpdateActionStatusModifiedDate")

instance Prelude.Hashable UpdateAction where
  hashWithSalt :: Int -> UpdateAction -> Int
hashWithSalt Int
_salt UpdateAction' {Maybe [NodeGroupUpdateStatus]
Maybe [CacheNodeUpdateStatus]
Maybe Text
Maybe ISO8601
Maybe ServiceUpdateSeverity
Maybe ServiceUpdateStatus
Maybe ServiceUpdateType
Maybe SlaMet
Maybe UpdateActionStatus
updateActionStatusModifiedDate :: Maybe ISO8601
updateActionStatus :: Maybe UpdateActionStatus
updateActionAvailableDate :: Maybe ISO8601
slaMet :: Maybe SlaMet
serviceUpdateType :: Maybe ServiceUpdateType
serviceUpdateStatus :: Maybe ServiceUpdateStatus
serviceUpdateSeverity :: Maybe ServiceUpdateSeverity
serviceUpdateReleaseDate :: Maybe ISO8601
serviceUpdateRecommendedApplyByDate :: Maybe ISO8601
serviceUpdateName :: Maybe Text
replicationGroupId :: Maybe Text
nodesUpdated :: Maybe Text
nodeGroupUpdateStatus :: Maybe [NodeGroupUpdateStatus]
estimatedUpdateTime :: Maybe Text
engine :: Maybe Text
cacheNodeUpdateStatus :: Maybe [CacheNodeUpdateStatus]
cacheClusterId :: Maybe Text
$sel:updateActionStatusModifiedDate:UpdateAction' :: UpdateAction -> Maybe ISO8601
$sel:updateActionStatus:UpdateAction' :: UpdateAction -> Maybe UpdateActionStatus
$sel:updateActionAvailableDate:UpdateAction' :: UpdateAction -> Maybe ISO8601
$sel:slaMet:UpdateAction' :: UpdateAction -> Maybe SlaMet
$sel:serviceUpdateType:UpdateAction' :: UpdateAction -> Maybe ServiceUpdateType
$sel:serviceUpdateStatus:UpdateAction' :: UpdateAction -> Maybe ServiceUpdateStatus
$sel:serviceUpdateSeverity:UpdateAction' :: UpdateAction -> Maybe ServiceUpdateSeverity
$sel:serviceUpdateReleaseDate:UpdateAction' :: UpdateAction -> Maybe ISO8601
$sel:serviceUpdateRecommendedApplyByDate:UpdateAction' :: UpdateAction -> Maybe ISO8601
$sel:serviceUpdateName:UpdateAction' :: UpdateAction -> Maybe Text
$sel:replicationGroupId:UpdateAction' :: UpdateAction -> Maybe Text
$sel:nodesUpdated:UpdateAction' :: UpdateAction -> Maybe Text
$sel:nodeGroupUpdateStatus:UpdateAction' :: UpdateAction -> Maybe [NodeGroupUpdateStatus]
$sel:estimatedUpdateTime:UpdateAction' :: UpdateAction -> Maybe Text
$sel:engine:UpdateAction' :: UpdateAction -> Maybe Text
$sel:cacheNodeUpdateStatus:UpdateAction' :: UpdateAction -> Maybe [CacheNodeUpdateStatus]
$sel:cacheClusterId:UpdateAction' :: UpdateAction -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
cacheClusterId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [CacheNodeUpdateStatus]
cacheNodeUpdateStatus
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
engine
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
estimatedUpdateTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [NodeGroupUpdateStatus]
nodeGroupUpdateStatus
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nodesUpdated
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
replicationGroupId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
serviceUpdateName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ISO8601
serviceUpdateRecommendedApplyByDate
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ISO8601
serviceUpdateReleaseDate
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ServiceUpdateSeverity
serviceUpdateSeverity
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ServiceUpdateStatus
serviceUpdateStatus
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ServiceUpdateType
serviceUpdateType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SlaMet
slaMet
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ISO8601
updateActionAvailableDate
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe UpdateActionStatus
updateActionStatus
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ISO8601
updateActionStatusModifiedDate

instance Prelude.NFData UpdateAction where
  rnf :: UpdateAction -> ()
rnf UpdateAction' {Maybe [NodeGroupUpdateStatus]
Maybe [CacheNodeUpdateStatus]
Maybe Text
Maybe ISO8601
Maybe ServiceUpdateSeverity
Maybe ServiceUpdateStatus
Maybe ServiceUpdateType
Maybe SlaMet
Maybe UpdateActionStatus
updateActionStatusModifiedDate :: Maybe ISO8601
updateActionStatus :: Maybe UpdateActionStatus
updateActionAvailableDate :: Maybe ISO8601
slaMet :: Maybe SlaMet
serviceUpdateType :: Maybe ServiceUpdateType
serviceUpdateStatus :: Maybe ServiceUpdateStatus
serviceUpdateSeverity :: Maybe ServiceUpdateSeverity
serviceUpdateReleaseDate :: Maybe ISO8601
serviceUpdateRecommendedApplyByDate :: Maybe ISO8601
serviceUpdateName :: Maybe Text
replicationGroupId :: Maybe Text
nodesUpdated :: Maybe Text
nodeGroupUpdateStatus :: Maybe [NodeGroupUpdateStatus]
estimatedUpdateTime :: Maybe Text
engine :: Maybe Text
cacheNodeUpdateStatus :: Maybe [CacheNodeUpdateStatus]
cacheClusterId :: Maybe Text
$sel:updateActionStatusModifiedDate:UpdateAction' :: UpdateAction -> Maybe ISO8601
$sel:updateActionStatus:UpdateAction' :: UpdateAction -> Maybe UpdateActionStatus
$sel:updateActionAvailableDate:UpdateAction' :: UpdateAction -> Maybe ISO8601
$sel:slaMet:UpdateAction' :: UpdateAction -> Maybe SlaMet
$sel:serviceUpdateType:UpdateAction' :: UpdateAction -> Maybe ServiceUpdateType
$sel:serviceUpdateStatus:UpdateAction' :: UpdateAction -> Maybe ServiceUpdateStatus
$sel:serviceUpdateSeverity:UpdateAction' :: UpdateAction -> Maybe ServiceUpdateSeverity
$sel:serviceUpdateReleaseDate:UpdateAction' :: UpdateAction -> Maybe ISO8601
$sel:serviceUpdateRecommendedApplyByDate:UpdateAction' :: UpdateAction -> Maybe ISO8601
$sel:serviceUpdateName:UpdateAction' :: UpdateAction -> Maybe Text
$sel:replicationGroupId:UpdateAction' :: UpdateAction -> Maybe Text
$sel:nodesUpdated:UpdateAction' :: UpdateAction -> Maybe Text
$sel:nodeGroupUpdateStatus:UpdateAction' :: UpdateAction -> Maybe [NodeGroupUpdateStatus]
$sel:estimatedUpdateTime:UpdateAction' :: UpdateAction -> Maybe Text
$sel:engine:UpdateAction' :: UpdateAction -> Maybe Text
$sel:cacheNodeUpdateStatus:UpdateAction' :: UpdateAction -> Maybe [CacheNodeUpdateStatus]
$sel:cacheClusterId:UpdateAction' :: UpdateAction -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
cacheClusterId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [CacheNodeUpdateStatus]
cacheNodeUpdateStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
engine
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
estimatedUpdateTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [NodeGroupUpdateStatus]
nodeGroupUpdateStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nodesUpdated
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
replicationGroupId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
serviceUpdateName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ISO8601
serviceUpdateRecommendedApplyByDate
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ISO8601
serviceUpdateReleaseDate
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ServiceUpdateSeverity
serviceUpdateSeverity
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ServiceUpdateStatus
serviceUpdateStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ServiceUpdateType
serviceUpdateType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SlaMet
slaMet
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ISO8601
updateActionAvailableDate
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe UpdateActionStatus
updateActionStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe ISO8601
updateActionStatusModifiedDate