{-# 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.Glue.Types.Session
-- 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.Glue.Types.Session where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.Glue.Types.ConnectionsList
import Amazonka.Glue.Types.SessionCommand
import Amazonka.Glue.Types.SessionStatus
import qualified Amazonka.Prelude as Prelude

-- | The period in which a remote Spark runtime environment is running.
--
-- /See:/ 'newSession' smart constructor.
data Session = Session'
  { -- | The command object.See SessionCommand.
    Session -> Maybe SessionCommand
command :: Prelude.Maybe SessionCommand,
    -- | The number of connections used for the session.
    Session -> Maybe ConnectionsList
connections :: Prelude.Maybe ConnectionsList,
    -- | The time and date when the session was created.
    Session -> Maybe POSIX
createdOn :: Prelude.Maybe Data.POSIX,
    -- | A map array of key-value pairs. Max is 75 pairs.
    Session -> Maybe (HashMap Text Text)
defaultArguments :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The description of the session.
    Session -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The error message displayed during the session.
    Session -> Maybe Text
errorMessage :: Prelude.Maybe Prelude.Text,
    -- | The Glue version determines the versions of Apache Spark and Python that
    -- Glue supports. The GlueVersion must be greater than 2.0.
    Session -> Maybe Text
glueVersion :: Prelude.Maybe Prelude.Text,
    -- | The ID of the session.
    Session -> Maybe Text
id :: Prelude.Maybe Prelude.Text,
    -- | The number of Glue data processing units (DPUs) that can be allocated
    -- when the job runs. A DPU is a relative measure of processing power that
    -- consists of 4 vCPUs of compute capacity and 16 GB memory.
    Session -> Maybe Double
maxCapacity :: Prelude.Maybe Prelude.Double,
    -- | The code execution progress of the session.
    Session -> Maybe Double
progress :: Prelude.Maybe Prelude.Double,
    -- | The name or Amazon Resource Name (ARN) of the IAM role associated with
    -- the Session.
    Session -> Maybe Text
role' :: Prelude.Maybe Prelude.Text,
    -- | The name of the SecurityConfiguration structure to be used with the
    -- session.
    Session -> Maybe Text
securityConfiguration :: Prelude.Maybe Prelude.Text,
    -- | The session status.
    Session -> Maybe SessionStatus
status :: Prelude.Maybe SessionStatus
  }
  deriving (Session -> Session -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Session -> Session -> Bool
$c/= :: Session -> Session -> Bool
== :: Session -> Session -> Bool
$c== :: Session -> Session -> Bool
Prelude.Eq, ReadPrec [Session]
ReadPrec Session
Int -> ReadS Session
ReadS [Session]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Session]
$creadListPrec :: ReadPrec [Session]
readPrec :: ReadPrec Session
$creadPrec :: ReadPrec Session
readList :: ReadS [Session]
$creadList :: ReadS [Session]
readsPrec :: Int -> ReadS Session
$creadsPrec :: Int -> ReadS Session
Prelude.Read, Int -> Session -> ShowS
[Session] -> ShowS
Session -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Session] -> ShowS
$cshowList :: [Session] -> ShowS
show :: Session -> String
$cshow :: Session -> String
showsPrec :: Int -> Session -> ShowS
$cshowsPrec :: Int -> Session -> ShowS
Prelude.Show, forall x. Rep Session x -> Session
forall x. Session -> Rep Session x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Session x -> Session
$cfrom :: forall x. Session -> Rep Session x
Prelude.Generic)

-- |
-- Create a value of 'Session' 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:
--
-- 'command', 'session_command' - The command object.See SessionCommand.
--
-- 'connections', 'session_connections' - The number of connections used for the session.
--
-- 'createdOn', 'session_createdOn' - The time and date when the session was created.
--
-- 'defaultArguments', 'session_defaultArguments' - A map array of key-value pairs. Max is 75 pairs.
--
-- 'description', 'session_description' - The description of the session.
--
-- 'errorMessage', 'session_errorMessage' - The error message displayed during the session.
--
-- 'glueVersion', 'session_glueVersion' - The Glue version determines the versions of Apache Spark and Python that
-- Glue supports. The GlueVersion must be greater than 2.0.
--
-- 'id', 'session_id' - The ID of the session.
--
-- 'maxCapacity', 'session_maxCapacity' - The number of Glue data processing units (DPUs) that can be allocated
-- when the job runs. A DPU is a relative measure of processing power that
-- consists of 4 vCPUs of compute capacity and 16 GB memory.
--
-- 'progress', 'session_progress' - The code execution progress of the session.
--
-- 'role'', 'session_role' - The name or Amazon Resource Name (ARN) of the IAM role associated with
-- the Session.
--
-- 'securityConfiguration', 'session_securityConfiguration' - The name of the SecurityConfiguration structure to be used with the
-- session.
--
-- 'status', 'session_status' - The session status.
newSession ::
  Session
newSession :: Session
newSession =
  Session'
    { $sel:command:Session' :: Maybe SessionCommand
command = forall a. Maybe a
Prelude.Nothing,
      $sel:connections:Session' :: Maybe ConnectionsList
connections = forall a. Maybe a
Prelude.Nothing,
      $sel:createdOn:Session' :: Maybe POSIX
createdOn = forall a. Maybe a
Prelude.Nothing,
      $sel:defaultArguments:Session' :: Maybe (HashMap Text Text)
defaultArguments = forall a. Maybe a
Prelude.Nothing,
      $sel:description:Session' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:errorMessage:Session' :: Maybe Text
errorMessage = forall a. Maybe a
Prelude.Nothing,
      $sel:glueVersion:Session' :: Maybe Text
glueVersion = forall a. Maybe a
Prelude.Nothing,
      $sel:id:Session' :: Maybe Text
id = forall a. Maybe a
Prelude.Nothing,
      $sel:maxCapacity:Session' :: Maybe Double
maxCapacity = forall a. Maybe a
Prelude.Nothing,
      $sel:progress:Session' :: Maybe Double
progress = forall a. Maybe a
Prelude.Nothing,
      $sel:role':Session' :: Maybe Text
role' = forall a. Maybe a
Prelude.Nothing,
      $sel:securityConfiguration:Session' :: Maybe Text
securityConfiguration = forall a. Maybe a
Prelude.Nothing,
      $sel:status:Session' :: Maybe SessionStatus
status = forall a. Maybe a
Prelude.Nothing
    }

-- | The command object.See SessionCommand.
session_command :: Lens.Lens' Session (Prelude.Maybe SessionCommand)
session_command :: Lens' Session (Maybe SessionCommand)
session_command = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Session' {Maybe SessionCommand
command :: Maybe SessionCommand
$sel:command:Session' :: Session -> Maybe SessionCommand
command} -> Maybe SessionCommand
command) (\s :: Session
s@Session' {} Maybe SessionCommand
a -> Session
s {$sel:command:Session' :: Maybe SessionCommand
command = Maybe SessionCommand
a} :: Session)

-- | The number of connections used for the session.
session_connections :: Lens.Lens' Session (Prelude.Maybe ConnectionsList)
session_connections :: Lens' Session (Maybe ConnectionsList)
session_connections = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Session' {Maybe ConnectionsList
connections :: Maybe ConnectionsList
$sel:connections:Session' :: Session -> Maybe ConnectionsList
connections} -> Maybe ConnectionsList
connections) (\s :: Session
s@Session' {} Maybe ConnectionsList
a -> Session
s {$sel:connections:Session' :: Maybe ConnectionsList
connections = Maybe ConnectionsList
a} :: Session)

-- | The time and date when the session was created.
session_createdOn :: Lens.Lens' Session (Prelude.Maybe Prelude.UTCTime)
session_createdOn :: Lens' Session (Maybe UTCTime)
session_createdOn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Session' {Maybe POSIX
createdOn :: Maybe POSIX
$sel:createdOn:Session' :: Session -> Maybe POSIX
createdOn} -> Maybe POSIX
createdOn) (\s :: Session
s@Session' {} Maybe POSIX
a -> Session
s {$sel:createdOn:Session' :: Maybe POSIX
createdOn = Maybe POSIX
a} :: Session) 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

-- | A map array of key-value pairs. Max is 75 pairs.
session_defaultArguments :: Lens.Lens' Session (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
session_defaultArguments :: Lens' Session (Maybe (HashMap Text Text))
session_defaultArguments = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Session' {Maybe (HashMap Text Text)
defaultArguments :: Maybe (HashMap Text Text)
$sel:defaultArguments:Session' :: Session -> Maybe (HashMap Text Text)
defaultArguments} -> Maybe (HashMap Text Text)
defaultArguments) (\s :: Session
s@Session' {} Maybe (HashMap Text Text)
a -> Session
s {$sel:defaultArguments:Session' :: Maybe (HashMap Text Text)
defaultArguments = Maybe (HashMap Text Text)
a} :: Session) 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 description of the session.
session_description :: Lens.Lens' Session (Prelude.Maybe Prelude.Text)
session_description :: Lens' Session (Maybe Text)
session_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Session' {Maybe Text
description :: Maybe Text
$sel:description:Session' :: Session -> Maybe Text
description} -> Maybe Text
description) (\s :: Session
s@Session' {} Maybe Text
a -> Session
s {$sel:description:Session' :: Maybe Text
description = Maybe Text
a} :: Session)

-- | The error message displayed during the session.
session_errorMessage :: Lens.Lens' Session (Prelude.Maybe Prelude.Text)
session_errorMessage :: Lens' Session (Maybe Text)
session_errorMessage = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Session' {Maybe Text
errorMessage :: Maybe Text
$sel:errorMessage:Session' :: Session -> Maybe Text
errorMessage} -> Maybe Text
errorMessage) (\s :: Session
s@Session' {} Maybe Text
a -> Session
s {$sel:errorMessage:Session' :: Maybe Text
errorMessage = Maybe Text
a} :: Session)

-- | The Glue version determines the versions of Apache Spark and Python that
-- Glue supports. The GlueVersion must be greater than 2.0.
session_glueVersion :: Lens.Lens' Session (Prelude.Maybe Prelude.Text)
session_glueVersion :: Lens' Session (Maybe Text)
session_glueVersion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Session' {Maybe Text
glueVersion :: Maybe Text
$sel:glueVersion:Session' :: Session -> Maybe Text
glueVersion} -> Maybe Text
glueVersion) (\s :: Session
s@Session' {} Maybe Text
a -> Session
s {$sel:glueVersion:Session' :: Maybe Text
glueVersion = Maybe Text
a} :: Session)

-- | The ID of the session.
session_id :: Lens.Lens' Session (Prelude.Maybe Prelude.Text)
session_id :: Lens' Session (Maybe Text)
session_id = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Session' {Maybe Text
id :: Maybe Text
$sel:id:Session' :: Session -> Maybe Text
id} -> Maybe Text
id) (\s :: Session
s@Session' {} Maybe Text
a -> Session
s {$sel:id:Session' :: Maybe Text
id = Maybe Text
a} :: Session)

-- | The number of Glue data processing units (DPUs) that can be allocated
-- when the job runs. A DPU is a relative measure of processing power that
-- consists of 4 vCPUs of compute capacity and 16 GB memory.
session_maxCapacity :: Lens.Lens' Session (Prelude.Maybe Prelude.Double)
session_maxCapacity :: Lens' Session (Maybe Double)
session_maxCapacity = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Session' {Maybe Double
maxCapacity :: Maybe Double
$sel:maxCapacity:Session' :: Session -> Maybe Double
maxCapacity} -> Maybe Double
maxCapacity) (\s :: Session
s@Session' {} Maybe Double
a -> Session
s {$sel:maxCapacity:Session' :: Maybe Double
maxCapacity = Maybe Double
a} :: Session)

-- | The code execution progress of the session.
session_progress :: Lens.Lens' Session (Prelude.Maybe Prelude.Double)
session_progress :: Lens' Session (Maybe Double)
session_progress = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Session' {Maybe Double
progress :: Maybe Double
$sel:progress:Session' :: Session -> Maybe Double
progress} -> Maybe Double
progress) (\s :: Session
s@Session' {} Maybe Double
a -> Session
s {$sel:progress:Session' :: Maybe Double
progress = Maybe Double
a} :: Session)

-- | The name or Amazon Resource Name (ARN) of the IAM role associated with
-- the Session.
session_role :: Lens.Lens' Session (Prelude.Maybe Prelude.Text)
session_role :: Lens' Session (Maybe Text)
session_role = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Session' {Maybe Text
role' :: Maybe Text
$sel:role':Session' :: Session -> Maybe Text
role'} -> Maybe Text
role') (\s :: Session
s@Session' {} Maybe Text
a -> Session
s {$sel:role':Session' :: Maybe Text
role' = Maybe Text
a} :: Session)

-- | The name of the SecurityConfiguration structure to be used with the
-- session.
session_securityConfiguration :: Lens.Lens' Session (Prelude.Maybe Prelude.Text)
session_securityConfiguration :: Lens' Session (Maybe Text)
session_securityConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Session' {Maybe Text
securityConfiguration :: Maybe Text
$sel:securityConfiguration:Session' :: Session -> Maybe Text
securityConfiguration} -> Maybe Text
securityConfiguration) (\s :: Session
s@Session' {} Maybe Text
a -> Session
s {$sel:securityConfiguration:Session' :: Maybe Text
securityConfiguration = Maybe Text
a} :: Session)

-- | The session status.
session_status :: Lens.Lens' Session (Prelude.Maybe SessionStatus)
session_status :: Lens' Session (Maybe SessionStatus)
session_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Session' {Maybe SessionStatus
status :: Maybe SessionStatus
$sel:status:Session' :: Session -> Maybe SessionStatus
status} -> Maybe SessionStatus
status) (\s :: Session
s@Session' {} Maybe SessionStatus
a -> Session
s {$sel:status:Session' :: Maybe SessionStatus
status = Maybe SessionStatus
a} :: Session)

instance Data.FromJSON Session where
  parseJSON :: Value -> Parser Session
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"Session"
      ( \Object
x ->
          Maybe SessionCommand
-> Maybe ConnectionsList
-> Maybe POSIX
-> Maybe (HashMap Text Text)
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Double
-> Maybe Double
-> Maybe Text
-> Maybe Text
-> Maybe SessionStatus
-> Session
Session'
            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
"Command")
            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
"Connections")
            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
"CreatedOn")
            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
"DefaultArguments"
                            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
"Description")
            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
"ErrorMessage")
            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
"GlueVersion")
            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
"Id")
            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
"MaxCapacity")
            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
"Progress")
            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
"Role")
            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
"SecurityConfiguration")
            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
"Status")
      )

instance Prelude.Hashable Session where
  hashWithSalt :: Int -> Session -> Int
hashWithSalt Int
_salt Session' {Maybe Double
Maybe Text
Maybe (HashMap Text Text)
Maybe POSIX
Maybe ConnectionsList
Maybe SessionCommand
Maybe SessionStatus
status :: Maybe SessionStatus
securityConfiguration :: Maybe Text
role' :: Maybe Text
progress :: Maybe Double
maxCapacity :: Maybe Double
id :: Maybe Text
glueVersion :: Maybe Text
errorMessage :: Maybe Text
description :: Maybe Text
defaultArguments :: Maybe (HashMap Text Text)
createdOn :: Maybe POSIX
connections :: Maybe ConnectionsList
command :: Maybe SessionCommand
$sel:status:Session' :: Session -> Maybe SessionStatus
$sel:securityConfiguration:Session' :: Session -> Maybe Text
$sel:role':Session' :: Session -> Maybe Text
$sel:progress:Session' :: Session -> Maybe Double
$sel:maxCapacity:Session' :: Session -> Maybe Double
$sel:id:Session' :: Session -> Maybe Text
$sel:glueVersion:Session' :: Session -> Maybe Text
$sel:errorMessage:Session' :: Session -> Maybe Text
$sel:description:Session' :: Session -> Maybe Text
$sel:defaultArguments:Session' :: Session -> Maybe (HashMap Text Text)
$sel:createdOn:Session' :: Session -> Maybe POSIX
$sel:connections:Session' :: Session -> Maybe ConnectionsList
$sel:command:Session' :: Session -> Maybe SessionCommand
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SessionCommand
command
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ConnectionsList
connections
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
createdOn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
defaultArguments
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
errorMessage
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
glueVersion
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
id
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Double
maxCapacity
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Double
progress
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
role'
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
securityConfiguration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SessionStatus
status

instance Prelude.NFData Session where
  rnf :: Session -> ()
rnf Session' {Maybe Double
Maybe Text
Maybe (HashMap Text Text)
Maybe POSIX
Maybe ConnectionsList
Maybe SessionCommand
Maybe SessionStatus
status :: Maybe SessionStatus
securityConfiguration :: Maybe Text
role' :: Maybe Text
progress :: Maybe Double
maxCapacity :: Maybe Double
id :: Maybe Text
glueVersion :: Maybe Text
errorMessage :: Maybe Text
description :: Maybe Text
defaultArguments :: Maybe (HashMap Text Text)
createdOn :: Maybe POSIX
connections :: Maybe ConnectionsList
command :: Maybe SessionCommand
$sel:status:Session' :: Session -> Maybe SessionStatus
$sel:securityConfiguration:Session' :: Session -> Maybe Text
$sel:role':Session' :: Session -> Maybe Text
$sel:progress:Session' :: Session -> Maybe Double
$sel:maxCapacity:Session' :: Session -> Maybe Double
$sel:id:Session' :: Session -> Maybe Text
$sel:glueVersion:Session' :: Session -> Maybe Text
$sel:errorMessage:Session' :: Session -> Maybe Text
$sel:description:Session' :: Session -> Maybe Text
$sel:defaultArguments:Session' :: Session -> Maybe (HashMap Text Text)
$sel:createdOn:Session' :: Session -> Maybe POSIX
$sel:connections:Session' :: Session -> Maybe ConnectionsList
$sel:command:Session' :: Session -> Maybe SessionCommand
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe SessionCommand
command
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ConnectionsList
connections
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
createdOn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
defaultArguments
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
errorMessage
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
glueVersion
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
id
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Double
maxCapacity
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Double
progress
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
role'
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
securityConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SessionStatus
status