{-# 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.ECS.Types.DeploymentConfiguration -- 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.ECS.Types.DeploymentConfiguration 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.DeploymentAlarms import Amazonka.ECS.Types.DeploymentCircuitBreaker import qualified Amazonka.Prelude as Prelude -- | Optional deployment parameters that control how many tasks run during a -- deployment and the ordering of stopping and starting tasks. -- -- /See:/ 'newDeploymentConfiguration' smart constructor. data DeploymentConfiguration = DeploymentConfiguration' { -- | Information about the CloudWatch alarms. DeploymentConfiguration -> Maybe DeploymentAlarms alarms :: Prelude.Maybe DeploymentAlarms, -- | The deployment circuit breaker can only be used for services using the -- rolling update (@ECS@) deployment type. -- -- The __deployment circuit breaker__ determines whether a service -- deployment will fail if the service can\'t reach a steady state. If -- deployment circuit breaker is enabled, a service deployment will -- transition to a failed state and stop launching new tasks. If rollback -- is enabled, when a service deployment fails, the service is rolled back -- to the last deployment that completed successfully. DeploymentConfiguration -> Maybe DeploymentCircuitBreaker deploymentCircuitBreaker :: Prelude.Maybe DeploymentCircuitBreaker, -- | If a service is using the rolling update (@ECS@) deployment type, the -- @maximumPercent@ parameter represents an upper limit on the number of -- your service\'s tasks that are allowed in the @RUNNING@ or @PENDING@ -- state during a deployment, as a percentage of the @desiredCount@ -- (rounded down to the nearest integer). This parameter enables you to -- define the deployment batch size. For example, if your service is using -- the @REPLICA@ service scheduler and has a @desiredCount@ of four tasks -- and a @maximumPercent@ value of 200%, the scheduler may start four new -- tasks before stopping the four older tasks (provided that the cluster -- resources required to do this are available). The default -- @maximumPercent@ value for a service using the @REPLICA@ service -- scheduler is 200%. -- -- If a service is using either the blue\/green (@CODE_DEPLOY@) or -- @EXTERNAL@ deployment types and tasks that use the EC2 launch type, the -- __maximum percent__ value is set to the default value and is used to -- define the upper limit on the number of the tasks in the service that -- remain in the @RUNNING@ state while the container instances are in the -- @DRAINING@ state. If the tasks in the service use the Fargate launch -- type, the maximum percent value is not used, although it is returned -- when describing your service. DeploymentConfiguration -> Maybe Int maximumPercent :: Prelude.Maybe Prelude.Int, -- | If a service is using the rolling update (@ECS@) deployment type, the -- @minimumHealthyPercent@ represents a lower limit on the number of your -- service\'s tasks that must remain in the @RUNNING@ state during a -- deployment, as a percentage of the @desiredCount@ (rounded up to the -- nearest integer). This parameter enables you to deploy without using -- additional cluster capacity. For example, if your service has a -- @desiredCount@ of four tasks and a @minimumHealthyPercent@ of 50%, the -- service scheduler may stop two existing tasks to free up cluster -- capacity before starting two new tasks. -- -- For services that /do not/ use a load balancer, the following should be -- noted: -- -- - A service is considered healthy if all essential containers within -- the tasks in the service pass their health checks. -- -- - If a task has no essential containers with a health check defined, -- the service scheduler will wait for 40 seconds after a task reaches -- a @RUNNING@ state before the task is counted towards the minimum -- healthy percent total. -- -- - If a task has one or more essential containers with a health check -- defined, the service scheduler will wait for the task to reach a -- healthy status before counting it towards the minimum healthy -- percent total. A task is considered healthy when all essential -- containers within the task have passed their health checks. The -- amount of time the service scheduler can wait for is determined by -- the container health check settings. -- -- For services are that /do/ use a load balancer, the following should be -- noted: -- -- - If a task has no essential containers with a health check defined, -- the service scheduler will wait for the load balancer target group -- health check to return a healthy status before counting the task -- towards the minimum healthy percent total. -- -- - If a task has an essential container with a health check defined, -- the service scheduler will wait for both the task to reach a healthy -- status and the load balancer target group health check to return a -- healthy status before counting the task towards the minimum healthy -- percent total. -- -- If a service is using either the blue\/green (@CODE_DEPLOY@) or -- @EXTERNAL@ deployment types and is running tasks that use the EC2 launch -- type, the __minimum healthy percent__ value is set to the default value -- and is used to define the lower limit on the number of the tasks in the -- service that remain in the @RUNNING@ state while the container instances -- are in the @DRAINING@ state. If a service is using either the -- blue\/green (@CODE_DEPLOY@) or @EXTERNAL@ deployment types and is -- running tasks that use the Fargate launch type, the minimum healthy -- percent value is not used, although it is returned when describing your -- service. DeploymentConfiguration -> Maybe Int minimumHealthyPercent :: Prelude.Maybe Prelude.Int } deriving (DeploymentConfiguration -> DeploymentConfiguration -> Bool forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a /= :: DeploymentConfiguration -> DeploymentConfiguration -> Bool $c/= :: DeploymentConfiguration -> DeploymentConfiguration -> Bool == :: DeploymentConfiguration -> DeploymentConfiguration -> Bool $c== :: DeploymentConfiguration -> DeploymentConfiguration -> Bool Prelude.Eq, ReadPrec [DeploymentConfiguration] ReadPrec DeploymentConfiguration Int -> ReadS DeploymentConfiguration ReadS [DeploymentConfiguration] forall a. (Int -> ReadS a) -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a readListPrec :: ReadPrec [DeploymentConfiguration] $creadListPrec :: ReadPrec [DeploymentConfiguration] readPrec :: ReadPrec DeploymentConfiguration $creadPrec :: ReadPrec DeploymentConfiguration readList :: ReadS [DeploymentConfiguration] $creadList :: ReadS [DeploymentConfiguration] readsPrec :: Int -> ReadS DeploymentConfiguration $creadsPrec :: Int -> ReadS DeploymentConfiguration Prelude.Read, Int -> DeploymentConfiguration -> ShowS [DeploymentConfiguration] -> ShowS DeploymentConfiguration -> String forall a. (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a showList :: [DeploymentConfiguration] -> ShowS $cshowList :: [DeploymentConfiguration] -> ShowS show :: DeploymentConfiguration -> String $cshow :: DeploymentConfiguration -> String showsPrec :: Int -> DeploymentConfiguration -> ShowS $cshowsPrec :: Int -> DeploymentConfiguration -> ShowS Prelude.Show, forall x. Rep DeploymentConfiguration x -> DeploymentConfiguration forall x. DeploymentConfiguration -> Rep DeploymentConfiguration x forall a. (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a $cto :: forall x. Rep DeploymentConfiguration x -> DeploymentConfiguration $cfrom :: forall x. DeploymentConfiguration -> Rep DeploymentConfiguration x Prelude.Generic) -- | -- Create a value of 'DeploymentConfiguration' 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: -- -- 'alarms', 'deploymentConfiguration_alarms' - Information about the CloudWatch alarms. -- -- 'deploymentCircuitBreaker', 'deploymentConfiguration_deploymentCircuitBreaker' - The deployment circuit breaker can only be used for services using the -- rolling update (@ECS@) deployment type. -- -- The __deployment circuit breaker__ determines whether a service -- deployment will fail if the service can\'t reach a steady state. If -- deployment circuit breaker is enabled, a service deployment will -- transition to a failed state and stop launching new tasks. If rollback -- is enabled, when a service deployment fails, the service is rolled back -- to the last deployment that completed successfully. -- -- 'maximumPercent', 'deploymentConfiguration_maximumPercent' - If a service is using the rolling update (@ECS@) deployment type, the -- @maximumPercent@ parameter represents an upper limit on the number of -- your service\'s tasks that are allowed in the @RUNNING@ or @PENDING@ -- state during a deployment, as a percentage of the @desiredCount@ -- (rounded down to the nearest integer). This parameter enables you to -- define the deployment batch size. For example, if your service is using -- the @REPLICA@ service scheduler and has a @desiredCount@ of four tasks -- and a @maximumPercent@ value of 200%, the scheduler may start four new -- tasks before stopping the four older tasks (provided that the cluster -- resources required to do this are available). The default -- @maximumPercent@ value for a service using the @REPLICA@ service -- scheduler is 200%. -- -- If a service is using either the blue\/green (@CODE_DEPLOY@) or -- @EXTERNAL@ deployment types and tasks that use the EC2 launch type, the -- __maximum percent__ value is set to the default value and is used to -- define the upper limit on the number of the tasks in the service that -- remain in the @RUNNING@ state while the container instances are in the -- @DRAINING@ state. If the tasks in the service use the Fargate launch -- type, the maximum percent value is not used, although it is returned -- when describing your service. -- -- 'minimumHealthyPercent', 'deploymentConfiguration_minimumHealthyPercent' - If a service is using the rolling update (@ECS@) deployment type, the -- @minimumHealthyPercent@ represents a lower limit on the number of your -- service\'s tasks that must remain in the @RUNNING@ state during a -- deployment, as a percentage of the @desiredCount@ (rounded up to the -- nearest integer). This parameter enables you to deploy without using -- additional cluster capacity. For example, if your service has a -- @desiredCount@ of four tasks and a @minimumHealthyPercent@ of 50%, the -- service scheduler may stop two existing tasks to free up cluster -- capacity before starting two new tasks. -- -- For services that /do not/ use a load balancer, the following should be -- noted: -- -- - A service is considered healthy if all essential containers within -- the tasks in the service pass their health checks. -- -- - If a task has no essential containers with a health check defined, -- the service scheduler will wait for 40 seconds after a task reaches -- a @RUNNING@ state before the task is counted towards the minimum -- healthy percent total. -- -- - If a task has one or more essential containers with a health check -- defined, the service scheduler will wait for the task to reach a -- healthy status before counting it towards the minimum healthy -- percent total. A task is considered healthy when all essential -- containers within the task have passed their health checks. The -- amount of time the service scheduler can wait for is determined by -- the container health check settings. -- -- For services are that /do/ use a load balancer, the following should be -- noted: -- -- - If a task has no essential containers with a health check defined, -- the service scheduler will wait for the load balancer target group -- health check to return a healthy status before counting the task -- towards the minimum healthy percent total. -- -- - If a task has an essential container with a health check defined, -- the service scheduler will wait for both the task to reach a healthy -- status and the load balancer target group health check to return a -- healthy status before counting the task towards the minimum healthy -- percent total. -- -- If a service is using either the blue\/green (@CODE_DEPLOY@) or -- @EXTERNAL@ deployment types and is running tasks that use the EC2 launch -- type, the __minimum healthy percent__ value is set to the default value -- and is used to define the lower limit on the number of the tasks in the -- service that remain in the @RUNNING@ state while the container instances -- are in the @DRAINING@ state. If a service is using either the -- blue\/green (@CODE_DEPLOY@) or @EXTERNAL@ deployment types and is -- running tasks that use the Fargate launch type, the minimum healthy -- percent value is not used, although it is returned when describing your -- service. newDeploymentConfiguration :: DeploymentConfiguration newDeploymentConfiguration :: DeploymentConfiguration newDeploymentConfiguration = DeploymentConfiguration' { $sel:alarms:DeploymentConfiguration' :: Maybe DeploymentAlarms alarms = forall a. Maybe a Prelude.Nothing, $sel:deploymentCircuitBreaker:DeploymentConfiguration' :: Maybe DeploymentCircuitBreaker deploymentCircuitBreaker = forall a. Maybe a Prelude.Nothing, $sel:maximumPercent:DeploymentConfiguration' :: Maybe Int maximumPercent = forall a. Maybe a Prelude.Nothing, $sel:minimumHealthyPercent:DeploymentConfiguration' :: Maybe Int minimumHealthyPercent = forall a. Maybe a Prelude.Nothing } -- | Information about the CloudWatch alarms. deploymentConfiguration_alarms :: Lens.Lens' DeploymentConfiguration (Prelude.Maybe DeploymentAlarms) deploymentConfiguration_alarms :: Lens' DeploymentConfiguration (Maybe DeploymentAlarms) deploymentConfiguration_alarms = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b Lens.lens (\DeploymentConfiguration' {Maybe DeploymentAlarms alarms :: Maybe DeploymentAlarms $sel:alarms:DeploymentConfiguration' :: DeploymentConfiguration -> Maybe DeploymentAlarms alarms} -> Maybe DeploymentAlarms alarms) (\s :: DeploymentConfiguration s@DeploymentConfiguration' {} Maybe DeploymentAlarms a -> DeploymentConfiguration s {$sel:alarms:DeploymentConfiguration' :: Maybe DeploymentAlarms alarms = Maybe DeploymentAlarms a} :: DeploymentConfiguration) -- | The deployment circuit breaker can only be used for services using the -- rolling update (@ECS@) deployment type. -- -- The __deployment circuit breaker__ determines whether a service -- deployment will fail if the service can\'t reach a steady state. If -- deployment circuit breaker is enabled, a service deployment will -- transition to a failed state and stop launching new tasks. If rollback -- is enabled, when a service deployment fails, the service is rolled back -- to the last deployment that completed successfully. deploymentConfiguration_deploymentCircuitBreaker :: Lens.Lens' DeploymentConfiguration (Prelude.Maybe DeploymentCircuitBreaker) deploymentConfiguration_deploymentCircuitBreaker :: Lens' DeploymentConfiguration (Maybe DeploymentCircuitBreaker) deploymentConfiguration_deploymentCircuitBreaker = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b Lens.lens (\DeploymentConfiguration' {Maybe DeploymentCircuitBreaker deploymentCircuitBreaker :: Maybe DeploymentCircuitBreaker $sel:deploymentCircuitBreaker:DeploymentConfiguration' :: DeploymentConfiguration -> Maybe DeploymentCircuitBreaker deploymentCircuitBreaker} -> Maybe DeploymentCircuitBreaker deploymentCircuitBreaker) (\s :: DeploymentConfiguration s@DeploymentConfiguration' {} Maybe DeploymentCircuitBreaker a -> DeploymentConfiguration s {$sel:deploymentCircuitBreaker:DeploymentConfiguration' :: Maybe DeploymentCircuitBreaker deploymentCircuitBreaker = Maybe DeploymentCircuitBreaker a} :: DeploymentConfiguration) -- | If a service is using the rolling update (@ECS@) deployment type, the -- @maximumPercent@ parameter represents an upper limit on the number of -- your service\'s tasks that are allowed in the @RUNNING@ or @PENDING@ -- state during a deployment, as a percentage of the @desiredCount@ -- (rounded down to the nearest integer). This parameter enables you to -- define the deployment batch size. For example, if your service is using -- the @REPLICA@ service scheduler and has a @desiredCount@ of four tasks -- and a @maximumPercent@ value of 200%, the scheduler may start four new -- tasks before stopping the four older tasks (provided that the cluster -- resources required to do this are available). The default -- @maximumPercent@ value for a service using the @REPLICA@ service -- scheduler is 200%. -- -- If a service is using either the blue\/green (@CODE_DEPLOY@) or -- @EXTERNAL@ deployment types and tasks that use the EC2 launch type, the -- __maximum percent__ value is set to the default value and is used to -- define the upper limit on the number of the tasks in the service that -- remain in the @RUNNING@ state while the container instances are in the -- @DRAINING@ state. If the tasks in the service use the Fargate launch -- type, the maximum percent value is not used, although it is returned -- when describing your service. deploymentConfiguration_maximumPercent :: Lens.Lens' DeploymentConfiguration (Prelude.Maybe Prelude.Int) deploymentConfiguration_maximumPercent :: Lens' DeploymentConfiguration (Maybe Int) deploymentConfiguration_maximumPercent = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b Lens.lens (\DeploymentConfiguration' {Maybe Int maximumPercent :: Maybe Int $sel:maximumPercent:DeploymentConfiguration' :: DeploymentConfiguration -> Maybe Int maximumPercent} -> Maybe Int maximumPercent) (\s :: DeploymentConfiguration s@DeploymentConfiguration' {} Maybe Int a -> DeploymentConfiguration s {$sel:maximumPercent:DeploymentConfiguration' :: Maybe Int maximumPercent = Maybe Int a} :: DeploymentConfiguration) -- | If a service is using the rolling update (@ECS@) deployment type, the -- @minimumHealthyPercent@ represents a lower limit on the number of your -- service\'s tasks that must remain in the @RUNNING@ state during a -- deployment, as a percentage of the @desiredCount@ (rounded up to the -- nearest integer). This parameter enables you to deploy without using -- additional cluster capacity. For example, if your service has a -- @desiredCount@ of four tasks and a @minimumHealthyPercent@ of 50%, the -- service scheduler may stop two existing tasks to free up cluster -- capacity before starting two new tasks. -- -- For services that /do not/ use a load balancer, the following should be -- noted: -- -- - A service is considered healthy if all essential containers within -- the tasks in the service pass their health checks. -- -- - If a task has no essential containers with a health check defined, -- the service scheduler will wait for 40 seconds after a task reaches -- a @RUNNING@ state before the task is counted towards the minimum -- healthy percent total. -- -- - If a task has one or more essential containers with a health check -- defined, the service scheduler will wait for the task to reach a -- healthy status before counting it towards the minimum healthy -- percent total. A task is considered healthy when all essential -- containers within the task have passed their health checks. The -- amount of time the service scheduler can wait for is determined by -- the container health check settings. -- -- For services are that /do/ use a load balancer, the following should be -- noted: -- -- - If a task has no essential containers with a health check defined, -- the service scheduler will wait for the load balancer target group -- health check to return a healthy status before counting the task -- towards the minimum healthy percent total. -- -- - If a task has an essential container with a health check defined, -- the service scheduler will wait for both the task to reach a healthy -- status and the load balancer target group health check to return a -- healthy status before counting the task towards the minimum healthy -- percent total. -- -- If a service is using either the blue\/green (@CODE_DEPLOY@) or -- @EXTERNAL@ deployment types and is running tasks that use the EC2 launch -- type, the __minimum healthy percent__ value is set to the default value -- and is used to define the lower limit on the number of the tasks in the -- service that remain in the @RUNNING@ state while the container instances -- are in the @DRAINING@ state. If a service is using either the -- blue\/green (@CODE_DEPLOY@) or @EXTERNAL@ deployment types and is -- running tasks that use the Fargate launch type, the minimum healthy -- percent value is not used, although it is returned when describing your -- service. deploymentConfiguration_minimumHealthyPercent :: Lens.Lens' DeploymentConfiguration (Prelude.Maybe Prelude.Int) deploymentConfiguration_minimumHealthyPercent :: Lens' DeploymentConfiguration (Maybe Int) deploymentConfiguration_minimumHealthyPercent = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b Lens.lens (\DeploymentConfiguration' {Maybe Int minimumHealthyPercent :: Maybe Int $sel:minimumHealthyPercent:DeploymentConfiguration' :: DeploymentConfiguration -> Maybe Int minimumHealthyPercent} -> Maybe Int minimumHealthyPercent) (\s :: DeploymentConfiguration s@DeploymentConfiguration' {} Maybe Int a -> DeploymentConfiguration s {$sel:minimumHealthyPercent:DeploymentConfiguration' :: Maybe Int minimumHealthyPercent = Maybe Int a} :: DeploymentConfiguration) instance Data.FromJSON DeploymentConfiguration where parseJSON :: Value -> Parser DeploymentConfiguration parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a Data.withObject String "DeploymentConfiguration" ( \Object x -> Maybe DeploymentAlarms -> Maybe DeploymentCircuitBreaker -> Maybe Int -> Maybe Int -> DeploymentConfiguration DeploymentConfiguration' 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 "alarms") 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 "deploymentCircuitBreaker") 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 "maximumPercent") 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 "minimumHealthyPercent") ) instance Prelude.Hashable DeploymentConfiguration where hashWithSalt :: Int -> DeploymentConfiguration -> Int hashWithSalt Int _salt DeploymentConfiguration' {Maybe Int Maybe DeploymentAlarms Maybe DeploymentCircuitBreaker minimumHealthyPercent :: Maybe Int maximumPercent :: Maybe Int deploymentCircuitBreaker :: Maybe DeploymentCircuitBreaker alarms :: Maybe DeploymentAlarms $sel:minimumHealthyPercent:DeploymentConfiguration' :: DeploymentConfiguration -> Maybe Int $sel:maximumPercent:DeploymentConfiguration' :: DeploymentConfiguration -> Maybe Int $sel:deploymentCircuitBreaker:DeploymentConfiguration' :: DeploymentConfiguration -> Maybe DeploymentCircuitBreaker $sel:alarms:DeploymentConfiguration' :: DeploymentConfiguration -> Maybe DeploymentAlarms ..} = Int _salt forall a. Hashable a => Int -> a -> Int `Prelude.hashWithSalt` Maybe DeploymentAlarms alarms forall a. Hashable a => Int -> a -> Int `Prelude.hashWithSalt` Maybe DeploymentCircuitBreaker deploymentCircuitBreaker forall a. Hashable a => Int -> a -> Int `Prelude.hashWithSalt` Maybe Int maximumPercent forall a. Hashable a => Int -> a -> Int `Prelude.hashWithSalt` Maybe Int minimumHealthyPercent instance Prelude.NFData DeploymentConfiguration where rnf :: DeploymentConfiguration -> () rnf DeploymentConfiguration' {Maybe Int Maybe DeploymentAlarms Maybe DeploymentCircuitBreaker minimumHealthyPercent :: Maybe Int maximumPercent :: Maybe Int deploymentCircuitBreaker :: Maybe DeploymentCircuitBreaker alarms :: Maybe DeploymentAlarms $sel:minimumHealthyPercent:DeploymentConfiguration' :: DeploymentConfiguration -> Maybe Int $sel:maximumPercent:DeploymentConfiguration' :: DeploymentConfiguration -> Maybe Int $sel:deploymentCircuitBreaker:DeploymentConfiguration' :: DeploymentConfiguration -> Maybe DeploymentCircuitBreaker $sel:alarms:DeploymentConfiguration' :: DeploymentConfiguration -> Maybe DeploymentAlarms ..} = forall a. NFData a => a -> () Prelude.rnf Maybe DeploymentAlarms alarms seq :: forall a b. a -> b -> b `Prelude.seq` forall a. NFData a => a -> () Prelude.rnf Maybe DeploymentCircuitBreaker deploymentCircuitBreaker seq :: forall a b. a -> b -> b `Prelude.seq` forall a. NFData a => a -> () Prelude.rnf Maybe Int maximumPercent seq :: forall a b. a -> b -> b `Prelude.seq` forall a. NFData a => a -> () Prelude.rnf Maybe Int minimumHealthyPercent instance Data.ToJSON DeploymentConfiguration where toJSON :: DeploymentConfiguration -> Value toJSON DeploymentConfiguration' {Maybe Int Maybe DeploymentAlarms Maybe DeploymentCircuitBreaker minimumHealthyPercent :: Maybe Int maximumPercent :: Maybe Int deploymentCircuitBreaker :: Maybe DeploymentCircuitBreaker alarms :: Maybe DeploymentAlarms $sel:minimumHealthyPercent:DeploymentConfiguration' :: DeploymentConfiguration -> Maybe Int $sel:maximumPercent:DeploymentConfiguration' :: DeploymentConfiguration -> Maybe Int $sel:deploymentCircuitBreaker:DeploymentConfiguration' :: DeploymentConfiguration -> Maybe DeploymentCircuitBreaker $sel:alarms:DeploymentConfiguration' :: DeploymentConfiguration -> Maybe DeploymentAlarms ..} = [Pair] -> Value Data.object ( forall a. [Maybe a] -> [a] Prelude.catMaybes [ (Key "alarms" 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 DeploymentAlarms alarms, (Key "deploymentCircuitBreaker" 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 DeploymentCircuitBreaker deploymentCircuitBreaker, (Key "maximumPercent" 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 Int maximumPercent, (Key "minimumHealthyPercent" 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 Int minimumHealthyPercent ] )