{-# 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.DevEndpoint
-- 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.DevEndpoint 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.WorkerType
import qualified Amazonka.Prelude as Prelude

-- | A development endpoint where a developer can remotely debug extract,
-- transform, and load (ETL) scripts.
--
-- /See:/ 'newDevEndpoint' smart constructor.
data DevEndpoint = DevEndpoint'
  { -- | A map of arguments used to configure the @DevEndpoint@.
    --
    -- Valid arguments are:
    --
    -- -   @\"--enable-glue-datacatalog\": \"\"@
    --
    -- You can specify a version of Python support for development endpoints by
    -- using the @Arguments@ parameter in the @CreateDevEndpoint@ or
    -- @UpdateDevEndpoint@ APIs. If no arguments are provided, the version
    -- defaults to Python 2.
    DevEndpoint -> Maybe (HashMap Text Text)
arguments :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The Amazon Web Services Availability Zone where this @DevEndpoint@ is
    -- located.
    DevEndpoint -> Maybe Text
availabilityZone :: Prelude.Maybe Prelude.Text,
    -- | The point in time at which this DevEndpoint was created.
    DevEndpoint -> Maybe POSIX
createdTimestamp :: Prelude.Maybe Data.POSIX,
    -- | The name of the @DevEndpoint@.
    DevEndpoint -> Maybe Text
endpointName :: Prelude.Maybe Prelude.Text,
    -- | The path to one or more Java @.jar@ files in an S3 bucket that should be
    -- loaded in your @DevEndpoint@.
    --
    -- You can only use pure Java\/Scala libraries with a @DevEndpoint@.
    DevEndpoint -> Maybe Text
extraJarsS3Path :: Prelude.Maybe Prelude.Text,
    -- | The paths to one or more Python libraries in an Amazon S3 bucket that
    -- should be loaded in your @DevEndpoint@. Multiple values must be complete
    -- paths separated by a comma.
    --
    -- You can only use pure Python libraries with a @DevEndpoint@. Libraries
    -- that rely on C extensions, such as the
    -- <http://pandas.pydata.org/ pandas> Python data analysis library, are not
    -- currently supported.
    DevEndpoint -> Maybe Text
extraPythonLibsS3Path :: Prelude.Maybe Prelude.Text,
    -- | The reason for a current failure in this @DevEndpoint@.
    DevEndpoint -> Maybe Text
failureReason :: Prelude.Maybe Prelude.Text,
    -- | Glue version determines the versions of Apache Spark and Python that
    -- Glue supports. The Python version indicates the version supported for
    -- running your ETL scripts on development endpoints.
    --
    -- For more information about the available Glue versions and corresponding
    -- Spark and Python versions, see
    -- <https://docs.aws.amazon.com/glue/latest/dg/add-job.html Glue version>
    -- in the developer guide.
    --
    -- Development endpoints that are created without specifying a Glue version
    -- default to Glue 0.9.
    --
    -- You can specify a version of Python support for development endpoints by
    -- using the @Arguments@ parameter in the @CreateDevEndpoint@ or
    -- @UpdateDevEndpoint@ APIs. If no arguments are provided, the version
    -- defaults to Python 2.
    DevEndpoint -> Maybe Text
glueVersion :: Prelude.Maybe Prelude.Text,
    -- | The point in time at which this @DevEndpoint@ was last modified.
    DevEndpoint -> Maybe POSIX
lastModifiedTimestamp :: Prelude.Maybe Data.POSIX,
    -- | The status of the last update.
    DevEndpoint -> Maybe Text
lastUpdateStatus :: Prelude.Maybe Prelude.Text,
    -- | The number of Glue Data Processing Units (DPUs) allocated to this
    -- @DevEndpoint@.
    DevEndpoint -> Maybe Int
numberOfNodes :: Prelude.Maybe Prelude.Int,
    -- | The number of workers of a defined @workerType@ that are allocated to
    -- the development endpoint.
    --
    -- The maximum number of workers you can define are 299 for @G.1X@, and 149
    -- for @G.2X@.
    DevEndpoint -> Maybe Int
numberOfWorkers :: Prelude.Maybe Prelude.Int,
    -- | A private IP address to access the @DevEndpoint@ within a VPC if the
    -- @DevEndpoint@ is created within one. The @PrivateAddress@ field is
    -- present only when you create the @DevEndpoint@ within your VPC.
    DevEndpoint -> Maybe Text
privateAddress :: Prelude.Maybe Prelude.Text,
    -- | The public IP address used by this @DevEndpoint@. The @PublicAddress@
    -- field is present only when you create a non-virtual private cloud (VPC)
    -- @DevEndpoint@.
    DevEndpoint -> Maybe Text
publicAddress :: Prelude.Maybe Prelude.Text,
    -- | The public key to be used by this @DevEndpoint@ for authentication. This
    -- attribute is provided for backward compatibility because the recommended
    -- attribute to use is public keys.
    DevEndpoint -> Maybe Text
publicKey :: Prelude.Maybe Prelude.Text,
    -- | A list of public keys to be used by the @DevEndpoints@ for
    -- authentication. Using this attribute is preferred over a single public
    -- key because the public keys allow you to have a different private key
    -- per client.
    --
    -- If you previously created an endpoint with a public key, you must remove
    -- that key to be able to set a list of public keys. Call the
    -- @UpdateDevEndpoint@ API operation with the public key content in the
    -- @deletePublicKeys@ attribute, and the list of new keys in the
    -- @addPublicKeys@ attribute.
    DevEndpoint -> Maybe [Text]
publicKeys :: Prelude.Maybe [Prelude.Text],
    -- | The Amazon Resource Name (ARN) of the IAM role used in this
    -- @DevEndpoint@.
    DevEndpoint -> Maybe Text
roleArn :: Prelude.Maybe Prelude.Text,
    -- | The name of the @SecurityConfiguration@ structure to be used with this
    -- @DevEndpoint@.
    DevEndpoint -> Maybe Text
securityConfiguration :: Prelude.Maybe Prelude.Text,
    -- | A list of security group identifiers used in this @DevEndpoint@.
    DevEndpoint -> Maybe [Text]
securityGroupIds :: Prelude.Maybe [Prelude.Text],
    -- | The current status of this @DevEndpoint@.
    DevEndpoint -> Maybe Text
status :: Prelude.Maybe Prelude.Text,
    -- | The subnet ID for this @DevEndpoint@.
    DevEndpoint -> Maybe Text
subnetId :: Prelude.Maybe Prelude.Text,
    -- | The ID of the virtual private cloud (VPC) used by this @DevEndpoint@.
    DevEndpoint -> Maybe Text
vpcId :: Prelude.Maybe Prelude.Text,
    -- | The type of predefined worker that is allocated to the development
    -- endpoint. Accepts a value of Standard, G.1X, or G.2X.
    --
    -- -   For the @Standard@ worker type, each worker provides 4 vCPU, 16 GB
    --     of memory and a 50GB disk, and 2 executors per worker.
    --
    -- -   For the @G.1X@ worker type, each worker maps to 1 DPU (4 vCPU, 16 GB
    --     of memory, 64 GB disk), and provides 1 executor per worker. We
    --     recommend this worker type for memory-intensive jobs.
    --
    -- -   For the @G.2X@ worker type, each worker maps to 2 DPU (8 vCPU, 32 GB
    --     of memory, 128 GB disk), and provides 1 executor per worker. We
    --     recommend this worker type for memory-intensive jobs.
    --
    -- Known issue: when a development endpoint is created with the @G.2X@
    -- @WorkerType@ configuration, the Spark drivers for the development
    -- endpoint will run on 4 vCPU, 16 GB of memory, and a 64 GB disk.
    DevEndpoint -> Maybe WorkerType
workerType :: Prelude.Maybe WorkerType,
    -- | The YARN endpoint address used by this @DevEndpoint@.
    DevEndpoint -> Maybe Text
yarnEndpointAddress :: Prelude.Maybe Prelude.Text,
    -- | The Apache Zeppelin port for the remote Apache Spark interpreter.
    DevEndpoint -> Maybe Int
zeppelinRemoteSparkInterpreterPort :: Prelude.Maybe Prelude.Int
  }
  deriving (DevEndpoint -> DevEndpoint -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DevEndpoint -> DevEndpoint -> Bool
$c/= :: DevEndpoint -> DevEndpoint -> Bool
== :: DevEndpoint -> DevEndpoint -> Bool
$c== :: DevEndpoint -> DevEndpoint -> Bool
Prelude.Eq, ReadPrec [DevEndpoint]
ReadPrec DevEndpoint
Int -> ReadS DevEndpoint
ReadS [DevEndpoint]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DevEndpoint]
$creadListPrec :: ReadPrec [DevEndpoint]
readPrec :: ReadPrec DevEndpoint
$creadPrec :: ReadPrec DevEndpoint
readList :: ReadS [DevEndpoint]
$creadList :: ReadS [DevEndpoint]
readsPrec :: Int -> ReadS DevEndpoint
$creadsPrec :: Int -> ReadS DevEndpoint
Prelude.Read, Int -> DevEndpoint -> ShowS
[DevEndpoint] -> ShowS
DevEndpoint -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DevEndpoint] -> ShowS
$cshowList :: [DevEndpoint] -> ShowS
show :: DevEndpoint -> String
$cshow :: DevEndpoint -> String
showsPrec :: Int -> DevEndpoint -> ShowS
$cshowsPrec :: Int -> DevEndpoint -> ShowS
Prelude.Show, forall x. Rep DevEndpoint x -> DevEndpoint
forall x. DevEndpoint -> Rep DevEndpoint x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DevEndpoint x -> DevEndpoint
$cfrom :: forall x. DevEndpoint -> Rep DevEndpoint x
Prelude.Generic)

-- |
-- Create a value of 'DevEndpoint' 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:
--
-- 'arguments', 'devEndpoint_arguments' - A map of arguments used to configure the @DevEndpoint@.
--
-- Valid arguments are:
--
-- -   @\"--enable-glue-datacatalog\": \"\"@
--
-- You can specify a version of Python support for development endpoints by
-- using the @Arguments@ parameter in the @CreateDevEndpoint@ or
-- @UpdateDevEndpoint@ APIs. If no arguments are provided, the version
-- defaults to Python 2.
--
-- 'availabilityZone', 'devEndpoint_availabilityZone' - The Amazon Web Services Availability Zone where this @DevEndpoint@ is
-- located.
--
-- 'createdTimestamp', 'devEndpoint_createdTimestamp' - The point in time at which this DevEndpoint was created.
--
-- 'endpointName', 'devEndpoint_endpointName' - The name of the @DevEndpoint@.
--
-- 'extraJarsS3Path', 'devEndpoint_extraJarsS3Path' - The path to one or more Java @.jar@ files in an S3 bucket that should be
-- loaded in your @DevEndpoint@.
--
-- You can only use pure Java\/Scala libraries with a @DevEndpoint@.
--
-- 'extraPythonLibsS3Path', 'devEndpoint_extraPythonLibsS3Path' - The paths to one or more Python libraries in an Amazon S3 bucket that
-- should be loaded in your @DevEndpoint@. Multiple values must be complete
-- paths separated by a comma.
--
-- You can only use pure Python libraries with a @DevEndpoint@. Libraries
-- that rely on C extensions, such as the
-- <http://pandas.pydata.org/ pandas> Python data analysis library, are not
-- currently supported.
--
-- 'failureReason', 'devEndpoint_failureReason' - The reason for a current failure in this @DevEndpoint@.
--
-- 'glueVersion', 'devEndpoint_glueVersion' - Glue version determines the versions of Apache Spark and Python that
-- Glue supports. The Python version indicates the version supported for
-- running your ETL scripts on development endpoints.
--
-- For more information about the available Glue versions and corresponding
-- Spark and Python versions, see
-- <https://docs.aws.amazon.com/glue/latest/dg/add-job.html Glue version>
-- in the developer guide.
--
-- Development endpoints that are created without specifying a Glue version
-- default to Glue 0.9.
--
-- You can specify a version of Python support for development endpoints by
-- using the @Arguments@ parameter in the @CreateDevEndpoint@ or
-- @UpdateDevEndpoint@ APIs. If no arguments are provided, the version
-- defaults to Python 2.
--
-- 'lastModifiedTimestamp', 'devEndpoint_lastModifiedTimestamp' - The point in time at which this @DevEndpoint@ was last modified.
--
-- 'lastUpdateStatus', 'devEndpoint_lastUpdateStatus' - The status of the last update.
--
-- 'numberOfNodes', 'devEndpoint_numberOfNodes' - The number of Glue Data Processing Units (DPUs) allocated to this
-- @DevEndpoint@.
--
-- 'numberOfWorkers', 'devEndpoint_numberOfWorkers' - The number of workers of a defined @workerType@ that are allocated to
-- the development endpoint.
--
-- The maximum number of workers you can define are 299 for @G.1X@, and 149
-- for @G.2X@.
--
-- 'privateAddress', 'devEndpoint_privateAddress' - A private IP address to access the @DevEndpoint@ within a VPC if the
-- @DevEndpoint@ is created within one. The @PrivateAddress@ field is
-- present only when you create the @DevEndpoint@ within your VPC.
--
-- 'publicAddress', 'devEndpoint_publicAddress' - The public IP address used by this @DevEndpoint@. The @PublicAddress@
-- field is present only when you create a non-virtual private cloud (VPC)
-- @DevEndpoint@.
--
-- 'publicKey', 'devEndpoint_publicKey' - The public key to be used by this @DevEndpoint@ for authentication. This
-- attribute is provided for backward compatibility because the recommended
-- attribute to use is public keys.
--
-- 'publicKeys', 'devEndpoint_publicKeys' - A list of public keys to be used by the @DevEndpoints@ for
-- authentication. Using this attribute is preferred over a single public
-- key because the public keys allow you to have a different private key
-- per client.
--
-- If you previously created an endpoint with a public key, you must remove
-- that key to be able to set a list of public keys. Call the
-- @UpdateDevEndpoint@ API operation with the public key content in the
-- @deletePublicKeys@ attribute, and the list of new keys in the
-- @addPublicKeys@ attribute.
--
-- 'roleArn', 'devEndpoint_roleArn' - The Amazon Resource Name (ARN) of the IAM role used in this
-- @DevEndpoint@.
--
-- 'securityConfiguration', 'devEndpoint_securityConfiguration' - The name of the @SecurityConfiguration@ structure to be used with this
-- @DevEndpoint@.
--
-- 'securityGroupIds', 'devEndpoint_securityGroupIds' - A list of security group identifiers used in this @DevEndpoint@.
--
-- 'status', 'devEndpoint_status' - The current status of this @DevEndpoint@.
--
-- 'subnetId', 'devEndpoint_subnetId' - The subnet ID for this @DevEndpoint@.
--
-- 'vpcId', 'devEndpoint_vpcId' - The ID of the virtual private cloud (VPC) used by this @DevEndpoint@.
--
-- 'workerType', 'devEndpoint_workerType' - The type of predefined worker that is allocated to the development
-- endpoint. Accepts a value of Standard, G.1X, or G.2X.
--
-- -   For the @Standard@ worker type, each worker provides 4 vCPU, 16 GB
--     of memory and a 50GB disk, and 2 executors per worker.
--
-- -   For the @G.1X@ worker type, each worker maps to 1 DPU (4 vCPU, 16 GB
--     of memory, 64 GB disk), and provides 1 executor per worker. We
--     recommend this worker type for memory-intensive jobs.
--
-- -   For the @G.2X@ worker type, each worker maps to 2 DPU (8 vCPU, 32 GB
--     of memory, 128 GB disk), and provides 1 executor per worker. We
--     recommend this worker type for memory-intensive jobs.
--
-- Known issue: when a development endpoint is created with the @G.2X@
-- @WorkerType@ configuration, the Spark drivers for the development
-- endpoint will run on 4 vCPU, 16 GB of memory, and a 64 GB disk.
--
-- 'yarnEndpointAddress', 'devEndpoint_yarnEndpointAddress' - The YARN endpoint address used by this @DevEndpoint@.
--
-- 'zeppelinRemoteSparkInterpreterPort', 'devEndpoint_zeppelinRemoteSparkInterpreterPort' - The Apache Zeppelin port for the remote Apache Spark interpreter.
newDevEndpoint ::
  DevEndpoint
newDevEndpoint :: DevEndpoint
newDevEndpoint =
  DevEndpoint'
    { $sel:arguments:DevEndpoint' :: Maybe (HashMap Text Text)
arguments = forall a. Maybe a
Prelude.Nothing,
      $sel:availabilityZone:DevEndpoint' :: Maybe Text
availabilityZone = forall a. Maybe a
Prelude.Nothing,
      $sel:createdTimestamp:DevEndpoint' :: Maybe POSIX
createdTimestamp = forall a. Maybe a
Prelude.Nothing,
      $sel:endpointName:DevEndpoint' :: Maybe Text
endpointName = forall a. Maybe a
Prelude.Nothing,
      $sel:extraJarsS3Path:DevEndpoint' :: Maybe Text
extraJarsS3Path = forall a. Maybe a
Prelude.Nothing,
      $sel:extraPythonLibsS3Path:DevEndpoint' :: Maybe Text
extraPythonLibsS3Path = forall a. Maybe a
Prelude.Nothing,
      $sel:failureReason:DevEndpoint' :: Maybe Text
failureReason = forall a. Maybe a
Prelude.Nothing,
      $sel:glueVersion:DevEndpoint' :: Maybe Text
glueVersion = forall a. Maybe a
Prelude.Nothing,
      $sel:lastModifiedTimestamp:DevEndpoint' :: Maybe POSIX
lastModifiedTimestamp = forall a. Maybe a
Prelude.Nothing,
      $sel:lastUpdateStatus:DevEndpoint' :: Maybe Text
lastUpdateStatus = forall a. Maybe a
Prelude.Nothing,
      $sel:numberOfNodes:DevEndpoint' :: Maybe Int
numberOfNodes = forall a. Maybe a
Prelude.Nothing,
      $sel:numberOfWorkers:DevEndpoint' :: Maybe Int
numberOfWorkers = forall a. Maybe a
Prelude.Nothing,
      $sel:privateAddress:DevEndpoint' :: Maybe Text
privateAddress = forall a. Maybe a
Prelude.Nothing,
      $sel:publicAddress:DevEndpoint' :: Maybe Text
publicAddress = forall a. Maybe a
Prelude.Nothing,
      $sel:publicKey:DevEndpoint' :: Maybe Text
publicKey = forall a. Maybe a
Prelude.Nothing,
      $sel:publicKeys:DevEndpoint' :: Maybe [Text]
publicKeys = forall a. Maybe a
Prelude.Nothing,
      $sel:roleArn:DevEndpoint' :: Maybe Text
roleArn = forall a. Maybe a
Prelude.Nothing,
      $sel:securityConfiguration:DevEndpoint' :: Maybe Text
securityConfiguration = forall a. Maybe a
Prelude.Nothing,
      $sel:securityGroupIds:DevEndpoint' :: Maybe [Text]
securityGroupIds = forall a. Maybe a
Prelude.Nothing,
      $sel:status:DevEndpoint' :: Maybe Text
status = forall a. Maybe a
Prelude.Nothing,
      $sel:subnetId:DevEndpoint' :: Maybe Text
subnetId = forall a. Maybe a
Prelude.Nothing,
      $sel:vpcId:DevEndpoint' :: Maybe Text
vpcId = forall a. Maybe a
Prelude.Nothing,
      $sel:workerType:DevEndpoint' :: Maybe WorkerType
workerType = forall a. Maybe a
Prelude.Nothing,
      $sel:yarnEndpointAddress:DevEndpoint' :: Maybe Text
yarnEndpointAddress = forall a. Maybe a
Prelude.Nothing,
      $sel:zeppelinRemoteSparkInterpreterPort:DevEndpoint' :: Maybe Int
zeppelinRemoteSparkInterpreterPort = forall a. Maybe a
Prelude.Nothing
    }

-- | A map of arguments used to configure the @DevEndpoint@.
--
-- Valid arguments are:
--
-- -   @\"--enable-glue-datacatalog\": \"\"@
--
-- You can specify a version of Python support for development endpoints by
-- using the @Arguments@ parameter in the @CreateDevEndpoint@ or
-- @UpdateDevEndpoint@ APIs. If no arguments are provided, the version
-- defaults to Python 2.
devEndpoint_arguments :: Lens.Lens' DevEndpoint (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
devEndpoint_arguments :: Lens' DevEndpoint (Maybe (HashMap Text Text))
devEndpoint_arguments = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe (HashMap Text Text)
arguments :: Maybe (HashMap Text Text)
$sel:arguments:DevEndpoint' :: DevEndpoint -> Maybe (HashMap Text Text)
arguments} -> Maybe (HashMap Text Text)
arguments) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe (HashMap Text Text)
a -> DevEndpoint
s {$sel:arguments:DevEndpoint' :: Maybe (HashMap Text Text)
arguments = Maybe (HashMap Text Text)
a} :: DevEndpoint) 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 Amazon Web Services Availability Zone where this @DevEndpoint@ is
-- located.
devEndpoint_availabilityZone :: Lens.Lens' DevEndpoint (Prelude.Maybe Prelude.Text)
devEndpoint_availabilityZone :: Lens' DevEndpoint (Maybe Text)
devEndpoint_availabilityZone = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe Text
availabilityZone :: Maybe Text
$sel:availabilityZone:DevEndpoint' :: DevEndpoint -> Maybe Text
availabilityZone} -> Maybe Text
availabilityZone) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe Text
a -> DevEndpoint
s {$sel:availabilityZone:DevEndpoint' :: Maybe Text
availabilityZone = Maybe Text
a} :: DevEndpoint)

-- | The point in time at which this DevEndpoint was created.
devEndpoint_createdTimestamp :: Lens.Lens' DevEndpoint (Prelude.Maybe Prelude.UTCTime)
devEndpoint_createdTimestamp :: Lens' DevEndpoint (Maybe UTCTime)
devEndpoint_createdTimestamp = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe POSIX
createdTimestamp :: Maybe POSIX
$sel:createdTimestamp:DevEndpoint' :: DevEndpoint -> Maybe POSIX
createdTimestamp} -> Maybe POSIX
createdTimestamp) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe POSIX
a -> DevEndpoint
s {$sel:createdTimestamp:DevEndpoint' :: Maybe POSIX
createdTimestamp = Maybe POSIX
a} :: DevEndpoint) 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 name of the @DevEndpoint@.
devEndpoint_endpointName :: Lens.Lens' DevEndpoint (Prelude.Maybe Prelude.Text)
devEndpoint_endpointName :: Lens' DevEndpoint (Maybe Text)
devEndpoint_endpointName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe Text
endpointName :: Maybe Text
$sel:endpointName:DevEndpoint' :: DevEndpoint -> Maybe Text
endpointName} -> Maybe Text
endpointName) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe Text
a -> DevEndpoint
s {$sel:endpointName:DevEndpoint' :: Maybe Text
endpointName = Maybe Text
a} :: DevEndpoint)

-- | The path to one or more Java @.jar@ files in an S3 bucket that should be
-- loaded in your @DevEndpoint@.
--
-- You can only use pure Java\/Scala libraries with a @DevEndpoint@.
devEndpoint_extraJarsS3Path :: Lens.Lens' DevEndpoint (Prelude.Maybe Prelude.Text)
devEndpoint_extraJarsS3Path :: Lens' DevEndpoint (Maybe Text)
devEndpoint_extraJarsS3Path = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe Text
extraJarsS3Path :: Maybe Text
$sel:extraJarsS3Path:DevEndpoint' :: DevEndpoint -> Maybe Text
extraJarsS3Path} -> Maybe Text
extraJarsS3Path) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe Text
a -> DevEndpoint
s {$sel:extraJarsS3Path:DevEndpoint' :: Maybe Text
extraJarsS3Path = Maybe Text
a} :: DevEndpoint)

-- | The paths to one or more Python libraries in an Amazon S3 bucket that
-- should be loaded in your @DevEndpoint@. Multiple values must be complete
-- paths separated by a comma.
--
-- You can only use pure Python libraries with a @DevEndpoint@. Libraries
-- that rely on C extensions, such as the
-- <http://pandas.pydata.org/ pandas> Python data analysis library, are not
-- currently supported.
devEndpoint_extraPythonLibsS3Path :: Lens.Lens' DevEndpoint (Prelude.Maybe Prelude.Text)
devEndpoint_extraPythonLibsS3Path :: Lens' DevEndpoint (Maybe Text)
devEndpoint_extraPythonLibsS3Path = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe Text
extraPythonLibsS3Path :: Maybe Text
$sel:extraPythonLibsS3Path:DevEndpoint' :: DevEndpoint -> Maybe Text
extraPythonLibsS3Path} -> Maybe Text
extraPythonLibsS3Path) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe Text
a -> DevEndpoint
s {$sel:extraPythonLibsS3Path:DevEndpoint' :: Maybe Text
extraPythonLibsS3Path = Maybe Text
a} :: DevEndpoint)

-- | The reason for a current failure in this @DevEndpoint@.
devEndpoint_failureReason :: Lens.Lens' DevEndpoint (Prelude.Maybe Prelude.Text)
devEndpoint_failureReason :: Lens' DevEndpoint (Maybe Text)
devEndpoint_failureReason = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe Text
failureReason :: Maybe Text
$sel:failureReason:DevEndpoint' :: DevEndpoint -> Maybe Text
failureReason} -> Maybe Text
failureReason) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe Text
a -> DevEndpoint
s {$sel:failureReason:DevEndpoint' :: Maybe Text
failureReason = Maybe Text
a} :: DevEndpoint)

-- | Glue version determines the versions of Apache Spark and Python that
-- Glue supports. The Python version indicates the version supported for
-- running your ETL scripts on development endpoints.
--
-- For more information about the available Glue versions and corresponding
-- Spark and Python versions, see
-- <https://docs.aws.amazon.com/glue/latest/dg/add-job.html Glue version>
-- in the developer guide.
--
-- Development endpoints that are created without specifying a Glue version
-- default to Glue 0.9.
--
-- You can specify a version of Python support for development endpoints by
-- using the @Arguments@ parameter in the @CreateDevEndpoint@ or
-- @UpdateDevEndpoint@ APIs. If no arguments are provided, the version
-- defaults to Python 2.
devEndpoint_glueVersion :: Lens.Lens' DevEndpoint (Prelude.Maybe Prelude.Text)
devEndpoint_glueVersion :: Lens' DevEndpoint (Maybe Text)
devEndpoint_glueVersion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe Text
glueVersion :: Maybe Text
$sel:glueVersion:DevEndpoint' :: DevEndpoint -> Maybe Text
glueVersion} -> Maybe Text
glueVersion) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe Text
a -> DevEndpoint
s {$sel:glueVersion:DevEndpoint' :: Maybe Text
glueVersion = Maybe Text
a} :: DevEndpoint)

-- | The point in time at which this @DevEndpoint@ was last modified.
devEndpoint_lastModifiedTimestamp :: Lens.Lens' DevEndpoint (Prelude.Maybe Prelude.UTCTime)
devEndpoint_lastModifiedTimestamp :: Lens' DevEndpoint (Maybe UTCTime)
devEndpoint_lastModifiedTimestamp = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe POSIX
lastModifiedTimestamp :: Maybe POSIX
$sel:lastModifiedTimestamp:DevEndpoint' :: DevEndpoint -> Maybe POSIX
lastModifiedTimestamp} -> Maybe POSIX
lastModifiedTimestamp) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe POSIX
a -> DevEndpoint
s {$sel:lastModifiedTimestamp:DevEndpoint' :: Maybe POSIX
lastModifiedTimestamp = Maybe POSIX
a} :: DevEndpoint) 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 last update.
devEndpoint_lastUpdateStatus :: Lens.Lens' DevEndpoint (Prelude.Maybe Prelude.Text)
devEndpoint_lastUpdateStatus :: Lens' DevEndpoint (Maybe Text)
devEndpoint_lastUpdateStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe Text
lastUpdateStatus :: Maybe Text
$sel:lastUpdateStatus:DevEndpoint' :: DevEndpoint -> Maybe Text
lastUpdateStatus} -> Maybe Text
lastUpdateStatus) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe Text
a -> DevEndpoint
s {$sel:lastUpdateStatus:DevEndpoint' :: Maybe Text
lastUpdateStatus = Maybe Text
a} :: DevEndpoint)

-- | The number of Glue Data Processing Units (DPUs) allocated to this
-- @DevEndpoint@.
devEndpoint_numberOfNodes :: Lens.Lens' DevEndpoint (Prelude.Maybe Prelude.Int)
devEndpoint_numberOfNodes :: Lens' DevEndpoint (Maybe Int)
devEndpoint_numberOfNodes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe Int
numberOfNodes :: Maybe Int
$sel:numberOfNodes:DevEndpoint' :: DevEndpoint -> Maybe Int
numberOfNodes} -> Maybe Int
numberOfNodes) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe Int
a -> DevEndpoint
s {$sel:numberOfNodes:DevEndpoint' :: Maybe Int
numberOfNodes = Maybe Int
a} :: DevEndpoint)

-- | The number of workers of a defined @workerType@ that are allocated to
-- the development endpoint.
--
-- The maximum number of workers you can define are 299 for @G.1X@, and 149
-- for @G.2X@.
devEndpoint_numberOfWorkers :: Lens.Lens' DevEndpoint (Prelude.Maybe Prelude.Int)
devEndpoint_numberOfWorkers :: Lens' DevEndpoint (Maybe Int)
devEndpoint_numberOfWorkers = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe Int
numberOfWorkers :: Maybe Int
$sel:numberOfWorkers:DevEndpoint' :: DevEndpoint -> Maybe Int
numberOfWorkers} -> Maybe Int
numberOfWorkers) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe Int
a -> DevEndpoint
s {$sel:numberOfWorkers:DevEndpoint' :: Maybe Int
numberOfWorkers = Maybe Int
a} :: DevEndpoint)

-- | A private IP address to access the @DevEndpoint@ within a VPC if the
-- @DevEndpoint@ is created within one. The @PrivateAddress@ field is
-- present only when you create the @DevEndpoint@ within your VPC.
devEndpoint_privateAddress :: Lens.Lens' DevEndpoint (Prelude.Maybe Prelude.Text)
devEndpoint_privateAddress :: Lens' DevEndpoint (Maybe Text)
devEndpoint_privateAddress = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe Text
privateAddress :: Maybe Text
$sel:privateAddress:DevEndpoint' :: DevEndpoint -> Maybe Text
privateAddress} -> Maybe Text
privateAddress) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe Text
a -> DevEndpoint
s {$sel:privateAddress:DevEndpoint' :: Maybe Text
privateAddress = Maybe Text
a} :: DevEndpoint)

-- | The public IP address used by this @DevEndpoint@. The @PublicAddress@
-- field is present only when you create a non-virtual private cloud (VPC)
-- @DevEndpoint@.
devEndpoint_publicAddress :: Lens.Lens' DevEndpoint (Prelude.Maybe Prelude.Text)
devEndpoint_publicAddress :: Lens' DevEndpoint (Maybe Text)
devEndpoint_publicAddress = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe Text
publicAddress :: Maybe Text
$sel:publicAddress:DevEndpoint' :: DevEndpoint -> Maybe Text
publicAddress} -> Maybe Text
publicAddress) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe Text
a -> DevEndpoint
s {$sel:publicAddress:DevEndpoint' :: Maybe Text
publicAddress = Maybe Text
a} :: DevEndpoint)

-- | The public key to be used by this @DevEndpoint@ for authentication. This
-- attribute is provided for backward compatibility because the recommended
-- attribute to use is public keys.
devEndpoint_publicKey :: Lens.Lens' DevEndpoint (Prelude.Maybe Prelude.Text)
devEndpoint_publicKey :: Lens' DevEndpoint (Maybe Text)
devEndpoint_publicKey = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe Text
publicKey :: Maybe Text
$sel:publicKey:DevEndpoint' :: DevEndpoint -> Maybe Text
publicKey} -> Maybe Text
publicKey) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe Text
a -> DevEndpoint
s {$sel:publicKey:DevEndpoint' :: Maybe Text
publicKey = Maybe Text
a} :: DevEndpoint)

-- | A list of public keys to be used by the @DevEndpoints@ for
-- authentication. Using this attribute is preferred over a single public
-- key because the public keys allow you to have a different private key
-- per client.
--
-- If you previously created an endpoint with a public key, you must remove
-- that key to be able to set a list of public keys. Call the
-- @UpdateDevEndpoint@ API operation with the public key content in the
-- @deletePublicKeys@ attribute, and the list of new keys in the
-- @addPublicKeys@ attribute.
devEndpoint_publicKeys :: Lens.Lens' DevEndpoint (Prelude.Maybe [Prelude.Text])
devEndpoint_publicKeys :: Lens' DevEndpoint (Maybe [Text])
devEndpoint_publicKeys = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe [Text]
publicKeys :: Maybe [Text]
$sel:publicKeys:DevEndpoint' :: DevEndpoint -> Maybe [Text]
publicKeys} -> Maybe [Text]
publicKeys) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe [Text]
a -> DevEndpoint
s {$sel:publicKeys:DevEndpoint' :: Maybe [Text]
publicKeys = Maybe [Text]
a} :: DevEndpoint) 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 Amazon Resource Name (ARN) of the IAM role used in this
-- @DevEndpoint@.
devEndpoint_roleArn :: Lens.Lens' DevEndpoint (Prelude.Maybe Prelude.Text)
devEndpoint_roleArn :: Lens' DevEndpoint (Maybe Text)
devEndpoint_roleArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe Text
roleArn :: Maybe Text
$sel:roleArn:DevEndpoint' :: DevEndpoint -> Maybe Text
roleArn} -> Maybe Text
roleArn) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe Text
a -> DevEndpoint
s {$sel:roleArn:DevEndpoint' :: Maybe Text
roleArn = Maybe Text
a} :: DevEndpoint)

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

-- | A list of security group identifiers used in this @DevEndpoint@.
devEndpoint_securityGroupIds :: Lens.Lens' DevEndpoint (Prelude.Maybe [Prelude.Text])
devEndpoint_securityGroupIds :: Lens' DevEndpoint (Maybe [Text])
devEndpoint_securityGroupIds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe [Text]
securityGroupIds :: Maybe [Text]
$sel:securityGroupIds:DevEndpoint' :: DevEndpoint -> Maybe [Text]
securityGroupIds} -> Maybe [Text]
securityGroupIds) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe [Text]
a -> DevEndpoint
s {$sel:securityGroupIds:DevEndpoint' :: Maybe [Text]
securityGroupIds = Maybe [Text]
a} :: DevEndpoint) 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 current status of this @DevEndpoint@.
devEndpoint_status :: Lens.Lens' DevEndpoint (Prelude.Maybe Prelude.Text)
devEndpoint_status :: Lens' DevEndpoint (Maybe Text)
devEndpoint_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe Text
status :: Maybe Text
$sel:status:DevEndpoint' :: DevEndpoint -> Maybe Text
status} -> Maybe Text
status) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe Text
a -> DevEndpoint
s {$sel:status:DevEndpoint' :: Maybe Text
status = Maybe Text
a} :: DevEndpoint)

-- | The subnet ID for this @DevEndpoint@.
devEndpoint_subnetId :: Lens.Lens' DevEndpoint (Prelude.Maybe Prelude.Text)
devEndpoint_subnetId :: Lens' DevEndpoint (Maybe Text)
devEndpoint_subnetId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe Text
subnetId :: Maybe Text
$sel:subnetId:DevEndpoint' :: DevEndpoint -> Maybe Text
subnetId} -> Maybe Text
subnetId) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe Text
a -> DevEndpoint
s {$sel:subnetId:DevEndpoint' :: Maybe Text
subnetId = Maybe Text
a} :: DevEndpoint)

-- | The ID of the virtual private cloud (VPC) used by this @DevEndpoint@.
devEndpoint_vpcId :: Lens.Lens' DevEndpoint (Prelude.Maybe Prelude.Text)
devEndpoint_vpcId :: Lens' DevEndpoint (Maybe Text)
devEndpoint_vpcId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe Text
vpcId :: Maybe Text
$sel:vpcId:DevEndpoint' :: DevEndpoint -> Maybe Text
vpcId} -> Maybe Text
vpcId) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe Text
a -> DevEndpoint
s {$sel:vpcId:DevEndpoint' :: Maybe Text
vpcId = Maybe Text
a} :: DevEndpoint)

-- | The type of predefined worker that is allocated to the development
-- endpoint. Accepts a value of Standard, G.1X, or G.2X.
--
-- -   For the @Standard@ worker type, each worker provides 4 vCPU, 16 GB
--     of memory and a 50GB disk, and 2 executors per worker.
--
-- -   For the @G.1X@ worker type, each worker maps to 1 DPU (4 vCPU, 16 GB
--     of memory, 64 GB disk), and provides 1 executor per worker. We
--     recommend this worker type for memory-intensive jobs.
--
-- -   For the @G.2X@ worker type, each worker maps to 2 DPU (8 vCPU, 32 GB
--     of memory, 128 GB disk), and provides 1 executor per worker. We
--     recommend this worker type for memory-intensive jobs.
--
-- Known issue: when a development endpoint is created with the @G.2X@
-- @WorkerType@ configuration, the Spark drivers for the development
-- endpoint will run on 4 vCPU, 16 GB of memory, and a 64 GB disk.
devEndpoint_workerType :: Lens.Lens' DevEndpoint (Prelude.Maybe WorkerType)
devEndpoint_workerType :: Lens' DevEndpoint (Maybe WorkerType)
devEndpoint_workerType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe WorkerType
workerType :: Maybe WorkerType
$sel:workerType:DevEndpoint' :: DevEndpoint -> Maybe WorkerType
workerType} -> Maybe WorkerType
workerType) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe WorkerType
a -> DevEndpoint
s {$sel:workerType:DevEndpoint' :: Maybe WorkerType
workerType = Maybe WorkerType
a} :: DevEndpoint)

-- | The YARN endpoint address used by this @DevEndpoint@.
devEndpoint_yarnEndpointAddress :: Lens.Lens' DevEndpoint (Prelude.Maybe Prelude.Text)
devEndpoint_yarnEndpointAddress :: Lens' DevEndpoint (Maybe Text)
devEndpoint_yarnEndpointAddress = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe Text
yarnEndpointAddress :: Maybe Text
$sel:yarnEndpointAddress:DevEndpoint' :: DevEndpoint -> Maybe Text
yarnEndpointAddress} -> Maybe Text
yarnEndpointAddress) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe Text
a -> DevEndpoint
s {$sel:yarnEndpointAddress:DevEndpoint' :: Maybe Text
yarnEndpointAddress = Maybe Text
a} :: DevEndpoint)

-- | The Apache Zeppelin port for the remote Apache Spark interpreter.
devEndpoint_zeppelinRemoteSparkInterpreterPort :: Lens.Lens' DevEndpoint (Prelude.Maybe Prelude.Int)
devEndpoint_zeppelinRemoteSparkInterpreterPort :: Lens' DevEndpoint (Maybe Int)
devEndpoint_zeppelinRemoteSparkInterpreterPort = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DevEndpoint' {Maybe Int
zeppelinRemoteSparkInterpreterPort :: Maybe Int
$sel:zeppelinRemoteSparkInterpreterPort:DevEndpoint' :: DevEndpoint -> Maybe Int
zeppelinRemoteSparkInterpreterPort} -> Maybe Int
zeppelinRemoteSparkInterpreterPort) (\s :: DevEndpoint
s@DevEndpoint' {} Maybe Int
a -> DevEndpoint
s {$sel:zeppelinRemoteSparkInterpreterPort:DevEndpoint' :: Maybe Int
zeppelinRemoteSparkInterpreterPort = Maybe Int
a} :: DevEndpoint)

instance Data.FromJSON DevEndpoint where
  parseJSON :: Value -> Parser DevEndpoint
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"DevEndpoint"
      ( \Object
x ->
          Maybe (HashMap Text Text)
-> Maybe Text
-> Maybe POSIX
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe POSIX
-> Maybe Text
-> Maybe Int
-> Maybe Int
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe [Text]
-> Maybe Text
-> Maybe Text
-> Maybe [Text]
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe WorkerType
-> Maybe Text
-> Maybe Int
-> DevEndpoint
DevEndpoint'
            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
"Arguments" 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
"AvailabilityZone")
            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
"CreatedTimestamp")
            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
"EndpointName")
            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
"ExtraJarsS3Path")
            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
"ExtraPythonLibsS3Path")
            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
"FailureReason")
            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
"LastModifiedTimestamp")
            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
"LastUpdateStatus")
            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
"NumberOfNodes")
            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
"NumberOfWorkers")
            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
"PrivateAddress")
            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
"PublicAddress")
            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
"PublicKey")
            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
"PublicKeys" 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
"RoleArn")
            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
"SecurityGroupIds"
                            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
"Status")
            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
"SubnetId")
            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
"VpcId")
            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
"WorkerType")
            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
"YarnEndpointAddress")
            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
"ZeppelinRemoteSparkInterpreterPort")
      )

instance Prelude.Hashable DevEndpoint where
  hashWithSalt :: Int -> DevEndpoint -> Int
hashWithSalt Int
_salt DevEndpoint' {Maybe Int
Maybe [Text]
Maybe Text
Maybe (HashMap Text Text)
Maybe POSIX
Maybe WorkerType
zeppelinRemoteSparkInterpreterPort :: Maybe Int
yarnEndpointAddress :: Maybe Text
workerType :: Maybe WorkerType
vpcId :: Maybe Text
subnetId :: Maybe Text
status :: Maybe Text
securityGroupIds :: Maybe [Text]
securityConfiguration :: Maybe Text
roleArn :: Maybe Text
publicKeys :: Maybe [Text]
publicKey :: Maybe Text
publicAddress :: Maybe Text
privateAddress :: Maybe Text
numberOfWorkers :: Maybe Int
numberOfNodes :: Maybe Int
lastUpdateStatus :: Maybe Text
lastModifiedTimestamp :: Maybe POSIX
glueVersion :: Maybe Text
failureReason :: Maybe Text
extraPythonLibsS3Path :: Maybe Text
extraJarsS3Path :: Maybe Text
endpointName :: Maybe Text
createdTimestamp :: Maybe POSIX
availabilityZone :: Maybe Text
arguments :: Maybe (HashMap Text Text)
$sel:zeppelinRemoteSparkInterpreterPort:DevEndpoint' :: DevEndpoint -> Maybe Int
$sel:yarnEndpointAddress:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:workerType:DevEndpoint' :: DevEndpoint -> Maybe WorkerType
$sel:vpcId:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:subnetId:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:status:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:securityGroupIds:DevEndpoint' :: DevEndpoint -> Maybe [Text]
$sel:securityConfiguration:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:roleArn:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:publicKeys:DevEndpoint' :: DevEndpoint -> Maybe [Text]
$sel:publicKey:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:publicAddress:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:privateAddress:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:numberOfWorkers:DevEndpoint' :: DevEndpoint -> Maybe Int
$sel:numberOfNodes:DevEndpoint' :: DevEndpoint -> Maybe Int
$sel:lastUpdateStatus:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:lastModifiedTimestamp:DevEndpoint' :: DevEndpoint -> Maybe POSIX
$sel:glueVersion:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:failureReason:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:extraPythonLibsS3Path:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:extraJarsS3Path:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:endpointName:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:createdTimestamp:DevEndpoint' :: DevEndpoint -> Maybe POSIX
$sel:availabilityZone:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:arguments:DevEndpoint' :: DevEndpoint -> Maybe (HashMap Text Text)
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
arguments
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
availabilityZone
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
createdTimestamp
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
endpointName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
extraJarsS3Path
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
extraPythonLibsS3Path
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
failureReason
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
glueVersion
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
lastModifiedTimestamp
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
lastUpdateStatus
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
numberOfNodes
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
numberOfWorkers
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
privateAddress
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
publicAddress
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
publicKey
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
publicKeys
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
roleArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
securityConfiguration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
securityGroupIds
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
status
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
subnetId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
vpcId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe WorkerType
workerType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
yarnEndpointAddress
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
zeppelinRemoteSparkInterpreterPort

instance Prelude.NFData DevEndpoint where
  rnf :: DevEndpoint -> ()
rnf DevEndpoint' {Maybe Int
Maybe [Text]
Maybe Text
Maybe (HashMap Text Text)
Maybe POSIX
Maybe WorkerType
zeppelinRemoteSparkInterpreterPort :: Maybe Int
yarnEndpointAddress :: Maybe Text
workerType :: Maybe WorkerType
vpcId :: Maybe Text
subnetId :: Maybe Text
status :: Maybe Text
securityGroupIds :: Maybe [Text]
securityConfiguration :: Maybe Text
roleArn :: Maybe Text
publicKeys :: Maybe [Text]
publicKey :: Maybe Text
publicAddress :: Maybe Text
privateAddress :: Maybe Text
numberOfWorkers :: Maybe Int
numberOfNodes :: Maybe Int
lastUpdateStatus :: Maybe Text
lastModifiedTimestamp :: Maybe POSIX
glueVersion :: Maybe Text
failureReason :: Maybe Text
extraPythonLibsS3Path :: Maybe Text
extraJarsS3Path :: Maybe Text
endpointName :: Maybe Text
createdTimestamp :: Maybe POSIX
availabilityZone :: Maybe Text
arguments :: Maybe (HashMap Text Text)
$sel:zeppelinRemoteSparkInterpreterPort:DevEndpoint' :: DevEndpoint -> Maybe Int
$sel:yarnEndpointAddress:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:workerType:DevEndpoint' :: DevEndpoint -> Maybe WorkerType
$sel:vpcId:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:subnetId:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:status:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:securityGroupIds:DevEndpoint' :: DevEndpoint -> Maybe [Text]
$sel:securityConfiguration:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:roleArn:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:publicKeys:DevEndpoint' :: DevEndpoint -> Maybe [Text]
$sel:publicKey:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:publicAddress:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:privateAddress:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:numberOfWorkers:DevEndpoint' :: DevEndpoint -> Maybe Int
$sel:numberOfNodes:DevEndpoint' :: DevEndpoint -> Maybe Int
$sel:lastUpdateStatus:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:lastModifiedTimestamp:DevEndpoint' :: DevEndpoint -> Maybe POSIX
$sel:glueVersion:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:failureReason:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:extraPythonLibsS3Path:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:extraJarsS3Path:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:endpointName:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:createdTimestamp:DevEndpoint' :: DevEndpoint -> Maybe POSIX
$sel:availabilityZone:DevEndpoint' :: DevEndpoint -> Maybe Text
$sel:arguments:DevEndpoint' :: DevEndpoint -> Maybe (HashMap Text Text)
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
arguments
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
availabilityZone
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
createdTimestamp
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
endpointName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
extraJarsS3Path
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
extraPythonLibsS3Path
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
failureReason
      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 POSIX
lastModifiedTimestamp
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
lastUpdateStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
numberOfNodes
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
numberOfWorkers
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
privateAddress
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
publicAddress
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
publicKey
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
publicKeys
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
roleArn
      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 [Text]
securityGroupIds
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
status
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
subnetId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
vpcId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe WorkerType
workerType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe Text
yarnEndpointAddress
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe Int
zeppelinRemoteSparkInterpreterPort