{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.SSM.GetConnectionStatus
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Retrieves the Session Manager connection status for a managed node to
-- determine whether it is running and ready to receive Session Manager
-- connections.
module Amazonka.SSM.GetConnectionStatus
  ( -- * Creating a Request
    GetConnectionStatus (..),
    newGetConnectionStatus,

    -- * Request Lenses
    getConnectionStatus_target,

    -- * Destructuring the Response
    GetConnectionStatusResponse (..),
    newGetConnectionStatusResponse,

    -- * Response Lenses
    getConnectionStatusResponse_status,
    getConnectionStatusResponse_target,
    getConnectionStatusResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response
import Amazonka.SSM.Types

-- | /See:/ 'newGetConnectionStatus' smart constructor.
data GetConnectionStatus = GetConnectionStatus'
  { -- | The managed node ID.
    GetConnectionStatus -> Text
target :: Prelude.Text
  }
  deriving (GetConnectionStatus -> GetConnectionStatus -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetConnectionStatus -> GetConnectionStatus -> Bool
$c/= :: GetConnectionStatus -> GetConnectionStatus -> Bool
== :: GetConnectionStatus -> GetConnectionStatus -> Bool
$c== :: GetConnectionStatus -> GetConnectionStatus -> Bool
Prelude.Eq, ReadPrec [GetConnectionStatus]
ReadPrec GetConnectionStatus
Int -> ReadS GetConnectionStatus
ReadS [GetConnectionStatus]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetConnectionStatus]
$creadListPrec :: ReadPrec [GetConnectionStatus]
readPrec :: ReadPrec GetConnectionStatus
$creadPrec :: ReadPrec GetConnectionStatus
readList :: ReadS [GetConnectionStatus]
$creadList :: ReadS [GetConnectionStatus]
readsPrec :: Int -> ReadS GetConnectionStatus
$creadsPrec :: Int -> ReadS GetConnectionStatus
Prelude.Read, Int -> GetConnectionStatus -> ShowS
[GetConnectionStatus] -> ShowS
GetConnectionStatus -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetConnectionStatus] -> ShowS
$cshowList :: [GetConnectionStatus] -> ShowS
show :: GetConnectionStatus -> String
$cshow :: GetConnectionStatus -> String
showsPrec :: Int -> GetConnectionStatus -> ShowS
$cshowsPrec :: Int -> GetConnectionStatus -> ShowS
Prelude.Show, forall x. Rep GetConnectionStatus x -> GetConnectionStatus
forall x. GetConnectionStatus -> Rep GetConnectionStatus x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GetConnectionStatus x -> GetConnectionStatus
$cfrom :: forall x. GetConnectionStatus -> Rep GetConnectionStatus x
Prelude.Generic)

-- |
-- Create a value of 'GetConnectionStatus' 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:
--
-- 'target', 'getConnectionStatus_target' - The managed node ID.
newGetConnectionStatus ::
  -- | 'target'
  Prelude.Text ->
  GetConnectionStatus
newGetConnectionStatus :: Text -> GetConnectionStatus
newGetConnectionStatus Text
pTarget_ =
  GetConnectionStatus' {$sel:target:GetConnectionStatus' :: Text
target = Text
pTarget_}

-- | The managed node ID.
getConnectionStatus_target :: Lens.Lens' GetConnectionStatus Prelude.Text
getConnectionStatus_target :: Lens' GetConnectionStatus Text
getConnectionStatus_target = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetConnectionStatus' {Text
target :: Text
$sel:target:GetConnectionStatus' :: GetConnectionStatus -> Text
target} -> Text
target) (\s :: GetConnectionStatus
s@GetConnectionStatus' {} Text
a -> GetConnectionStatus
s {$sel:target:GetConnectionStatus' :: Text
target = Text
a} :: GetConnectionStatus)

instance Core.AWSRequest GetConnectionStatus where
  type
    AWSResponse GetConnectionStatus =
      GetConnectionStatusResponse
  request :: (Service -> Service)
-> GetConnectionStatus -> Request GetConnectionStatus
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy GetConnectionStatus
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse GetConnectionStatus)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe ConnectionStatus
-> Maybe Text -> Int -> GetConnectionStatusResponse
GetConnectionStatusResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (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 -> Either String (Maybe a)
Data..?> Key
"Target")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable GetConnectionStatus where
  hashWithSalt :: Int -> GetConnectionStatus -> Int
hashWithSalt Int
_salt GetConnectionStatus' {Text
target :: Text
$sel:target:GetConnectionStatus' :: GetConnectionStatus -> Text
..} =
    Int
_salt forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
target

instance Prelude.NFData GetConnectionStatus where
  rnf :: GetConnectionStatus -> ()
rnf GetConnectionStatus' {Text
target :: Text
$sel:target:GetConnectionStatus' :: GetConnectionStatus -> Text
..} = forall a. NFData a => a -> ()
Prelude.rnf Text
target

instance Data.ToHeaders GetConnectionStatus where
  toHeaders :: GetConnectionStatus -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"AmazonSSM.GetConnectionStatus" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON GetConnectionStatus where
  toJSON :: GetConnectionStatus -> Value
toJSON GetConnectionStatus' {Text
target :: Text
$sel:target:GetConnectionStatus' :: GetConnectionStatus -> Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [forall a. a -> Maybe a
Prelude.Just (Key
"Target" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
target)]
      )

instance Data.ToPath GetConnectionStatus where
  toPath :: GetConnectionStatus -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

instance Data.ToQuery GetConnectionStatus where
  toQuery :: GetConnectionStatus -> QueryString
toQuery = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newGetConnectionStatusResponse' smart constructor.
data GetConnectionStatusResponse = GetConnectionStatusResponse'
  { -- | The status of the connection to the managed node. For example,
    -- \'Connected\' or \'Not Connected\'.
    GetConnectionStatusResponse -> Maybe ConnectionStatus
status :: Prelude.Maybe ConnectionStatus,
    -- | The ID of the managed node to check connection status.
    GetConnectionStatusResponse -> Maybe Text
target :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    GetConnectionStatusResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (GetConnectionStatusResponse -> GetConnectionStatusResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetConnectionStatusResponse -> GetConnectionStatusResponse -> Bool
$c/= :: GetConnectionStatusResponse -> GetConnectionStatusResponse -> Bool
== :: GetConnectionStatusResponse -> GetConnectionStatusResponse -> Bool
$c== :: GetConnectionStatusResponse -> GetConnectionStatusResponse -> Bool
Prelude.Eq, ReadPrec [GetConnectionStatusResponse]
ReadPrec GetConnectionStatusResponse
Int -> ReadS GetConnectionStatusResponse
ReadS [GetConnectionStatusResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetConnectionStatusResponse]
$creadListPrec :: ReadPrec [GetConnectionStatusResponse]
readPrec :: ReadPrec GetConnectionStatusResponse
$creadPrec :: ReadPrec GetConnectionStatusResponse
readList :: ReadS [GetConnectionStatusResponse]
$creadList :: ReadS [GetConnectionStatusResponse]
readsPrec :: Int -> ReadS GetConnectionStatusResponse
$creadsPrec :: Int -> ReadS GetConnectionStatusResponse
Prelude.Read, Int -> GetConnectionStatusResponse -> ShowS
[GetConnectionStatusResponse] -> ShowS
GetConnectionStatusResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetConnectionStatusResponse] -> ShowS
$cshowList :: [GetConnectionStatusResponse] -> ShowS
show :: GetConnectionStatusResponse -> String
$cshow :: GetConnectionStatusResponse -> String
showsPrec :: Int -> GetConnectionStatusResponse -> ShowS
$cshowsPrec :: Int -> GetConnectionStatusResponse -> ShowS
Prelude.Show, forall x.
Rep GetConnectionStatusResponse x -> GetConnectionStatusResponse
forall x.
GetConnectionStatusResponse -> Rep GetConnectionStatusResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetConnectionStatusResponse x -> GetConnectionStatusResponse
$cfrom :: forall x.
GetConnectionStatusResponse -> Rep GetConnectionStatusResponse x
Prelude.Generic)

-- |
-- Create a value of 'GetConnectionStatusResponse' 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:
--
-- 'status', 'getConnectionStatusResponse_status' - The status of the connection to the managed node. For example,
-- \'Connected\' or \'Not Connected\'.
--
-- 'target', 'getConnectionStatusResponse_target' - The ID of the managed node to check connection status.
--
-- 'httpStatus', 'getConnectionStatusResponse_httpStatus' - The response's http status code.
newGetConnectionStatusResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  GetConnectionStatusResponse
newGetConnectionStatusResponse :: Int -> GetConnectionStatusResponse
newGetConnectionStatusResponse Int
pHttpStatus_ =
  GetConnectionStatusResponse'
    { $sel:status:GetConnectionStatusResponse' :: Maybe ConnectionStatus
status =
        forall a. Maybe a
Prelude.Nothing,
      $sel:target:GetConnectionStatusResponse' :: Maybe Text
target = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:GetConnectionStatusResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The status of the connection to the managed node. For example,
-- \'Connected\' or \'Not Connected\'.
getConnectionStatusResponse_status :: Lens.Lens' GetConnectionStatusResponse (Prelude.Maybe ConnectionStatus)
getConnectionStatusResponse_status :: Lens' GetConnectionStatusResponse (Maybe ConnectionStatus)
getConnectionStatusResponse_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetConnectionStatusResponse' {Maybe ConnectionStatus
status :: Maybe ConnectionStatus
$sel:status:GetConnectionStatusResponse' :: GetConnectionStatusResponse -> Maybe ConnectionStatus
status} -> Maybe ConnectionStatus
status) (\s :: GetConnectionStatusResponse
s@GetConnectionStatusResponse' {} Maybe ConnectionStatus
a -> GetConnectionStatusResponse
s {$sel:status:GetConnectionStatusResponse' :: Maybe ConnectionStatus
status = Maybe ConnectionStatus
a} :: GetConnectionStatusResponse)

-- | The ID of the managed node to check connection status.
getConnectionStatusResponse_target :: Lens.Lens' GetConnectionStatusResponse (Prelude.Maybe Prelude.Text)
getConnectionStatusResponse_target :: Lens' GetConnectionStatusResponse (Maybe Text)
getConnectionStatusResponse_target = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetConnectionStatusResponse' {Maybe Text
target :: Maybe Text
$sel:target:GetConnectionStatusResponse' :: GetConnectionStatusResponse -> Maybe Text
target} -> Maybe Text
target) (\s :: GetConnectionStatusResponse
s@GetConnectionStatusResponse' {} Maybe Text
a -> GetConnectionStatusResponse
s {$sel:target:GetConnectionStatusResponse' :: Maybe Text
target = Maybe Text
a} :: GetConnectionStatusResponse)

-- | The response's http status code.
getConnectionStatusResponse_httpStatus :: Lens.Lens' GetConnectionStatusResponse Prelude.Int
getConnectionStatusResponse_httpStatus :: Lens' GetConnectionStatusResponse Int
getConnectionStatusResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetConnectionStatusResponse' {Int
httpStatus :: Int
$sel:httpStatus:GetConnectionStatusResponse' :: GetConnectionStatusResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: GetConnectionStatusResponse
s@GetConnectionStatusResponse' {} Int
a -> GetConnectionStatusResponse
s {$sel:httpStatus:GetConnectionStatusResponse' :: Int
httpStatus = Int
a} :: GetConnectionStatusResponse)

instance Prelude.NFData GetConnectionStatusResponse where
  rnf :: GetConnectionStatusResponse -> ()
rnf GetConnectionStatusResponse' {Int
Maybe Text
Maybe ConnectionStatus
httpStatus :: Int
target :: Maybe Text
status :: Maybe ConnectionStatus
$sel:httpStatus:GetConnectionStatusResponse' :: GetConnectionStatusResponse -> Int
$sel:target:GetConnectionStatusResponse' :: GetConnectionStatusResponse -> Maybe Text
$sel:status:GetConnectionStatusResponse' :: GetConnectionStatusResponse -> Maybe ConnectionStatus
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe ConnectionStatus
status
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
target
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus