{-# 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.FSx.ReleaseFileSystemNfsV3Locks
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Releases the file system lock from an Amazon FSx for OpenZFS file
-- system.
module Amazonka.FSx.ReleaseFileSystemNfsV3Locks
  ( -- * Creating a Request
    ReleaseFileSystemNfsV3Locks (..),
    newReleaseFileSystemNfsV3Locks,

    -- * Request Lenses
    releaseFileSystemNfsV3Locks_clientRequestToken,
    releaseFileSystemNfsV3Locks_fileSystemId,

    -- * Destructuring the Response
    ReleaseFileSystemNfsV3LocksResponse (..),
    newReleaseFileSystemNfsV3LocksResponse,

    -- * Response Lenses
    releaseFileSystemNfsV3LocksResponse_fileSystem,
    releaseFileSystemNfsV3LocksResponse_httpStatus,
  )
where

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

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

-- |
-- Create a value of 'ReleaseFileSystemNfsV3Locks' 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:
--
-- 'clientRequestToken', 'releaseFileSystemNfsV3Locks_clientRequestToken' - Undocumented member.
--
-- 'fileSystemId', 'releaseFileSystemNfsV3Locks_fileSystemId' - Undocumented member.
newReleaseFileSystemNfsV3Locks ::
  -- | 'fileSystemId'
  Prelude.Text ->
  ReleaseFileSystemNfsV3Locks
newReleaseFileSystemNfsV3Locks :: Text -> ReleaseFileSystemNfsV3Locks
newReleaseFileSystemNfsV3Locks Text
pFileSystemId_ =
  ReleaseFileSystemNfsV3Locks'
    { $sel:clientRequestToken:ReleaseFileSystemNfsV3Locks' :: Maybe Text
clientRequestToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:fileSystemId:ReleaseFileSystemNfsV3Locks' :: Text
fileSystemId = Text
pFileSystemId_
    }

-- | Undocumented member.
releaseFileSystemNfsV3Locks_clientRequestToken :: Lens.Lens' ReleaseFileSystemNfsV3Locks (Prelude.Maybe Prelude.Text)
releaseFileSystemNfsV3Locks_clientRequestToken :: Lens' ReleaseFileSystemNfsV3Locks (Maybe Text)
releaseFileSystemNfsV3Locks_clientRequestToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ReleaseFileSystemNfsV3Locks' {Maybe Text
clientRequestToken :: Maybe Text
$sel:clientRequestToken:ReleaseFileSystemNfsV3Locks' :: ReleaseFileSystemNfsV3Locks -> Maybe Text
clientRequestToken} -> Maybe Text
clientRequestToken) (\s :: ReleaseFileSystemNfsV3Locks
s@ReleaseFileSystemNfsV3Locks' {} Maybe Text
a -> ReleaseFileSystemNfsV3Locks
s {$sel:clientRequestToken:ReleaseFileSystemNfsV3Locks' :: Maybe Text
clientRequestToken = Maybe Text
a} :: ReleaseFileSystemNfsV3Locks)

-- | Undocumented member.
releaseFileSystemNfsV3Locks_fileSystemId :: Lens.Lens' ReleaseFileSystemNfsV3Locks Prelude.Text
releaseFileSystemNfsV3Locks_fileSystemId :: Lens' ReleaseFileSystemNfsV3Locks Text
releaseFileSystemNfsV3Locks_fileSystemId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ReleaseFileSystemNfsV3Locks' {Text
fileSystemId :: Text
$sel:fileSystemId:ReleaseFileSystemNfsV3Locks' :: ReleaseFileSystemNfsV3Locks -> Text
fileSystemId} -> Text
fileSystemId) (\s :: ReleaseFileSystemNfsV3Locks
s@ReleaseFileSystemNfsV3Locks' {} Text
a -> ReleaseFileSystemNfsV3Locks
s {$sel:fileSystemId:ReleaseFileSystemNfsV3Locks' :: Text
fileSystemId = Text
a} :: ReleaseFileSystemNfsV3Locks)

instance Core.AWSRequest ReleaseFileSystemNfsV3Locks where
  type
    AWSResponse ReleaseFileSystemNfsV3Locks =
      ReleaseFileSystemNfsV3LocksResponse
  request :: (Service -> Service)
-> ReleaseFileSystemNfsV3Locks
-> Request ReleaseFileSystemNfsV3Locks
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 ReleaseFileSystemNfsV3Locks
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ReleaseFileSystemNfsV3Locks)))
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 FileSystem -> Int -> ReleaseFileSystemNfsV3LocksResponse
ReleaseFileSystemNfsV3LocksResponse'
            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
"FileSystem")
            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 ReleaseFileSystemNfsV3Locks where
  hashWithSalt :: Int -> ReleaseFileSystemNfsV3Locks -> Int
hashWithSalt Int
_salt ReleaseFileSystemNfsV3Locks' {Maybe Text
Text
fileSystemId :: Text
clientRequestToken :: Maybe Text
$sel:fileSystemId:ReleaseFileSystemNfsV3Locks' :: ReleaseFileSystemNfsV3Locks -> Text
$sel:clientRequestToken:ReleaseFileSystemNfsV3Locks' :: ReleaseFileSystemNfsV3Locks -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientRequestToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
fileSystemId

instance Prelude.NFData ReleaseFileSystemNfsV3Locks where
  rnf :: ReleaseFileSystemNfsV3Locks -> ()
rnf ReleaseFileSystemNfsV3Locks' {Maybe Text
Text
fileSystemId :: Text
clientRequestToken :: Maybe Text
$sel:fileSystemId:ReleaseFileSystemNfsV3Locks' :: ReleaseFileSystemNfsV3Locks -> Text
$sel:clientRequestToken:ReleaseFileSystemNfsV3Locks' :: ReleaseFileSystemNfsV3Locks -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientRequestToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
fileSystemId

instance Data.ToHeaders ReleaseFileSystemNfsV3Locks where
  toHeaders :: ReleaseFileSystemNfsV3Locks -> 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
"AWSSimbaAPIService_v20180301.ReleaseFileSystemNfsV3Locks" ::
                          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 ReleaseFileSystemNfsV3Locks where
  toJSON :: ReleaseFileSystemNfsV3Locks -> Value
toJSON ReleaseFileSystemNfsV3Locks' {Maybe Text
Text
fileSystemId :: Text
clientRequestToken :: Maybe Text
$sel:fileSystemId:ReleaseFileSystemNfsV3Locks' :: ReleaseFileSystemNfsV3Locks -> Text
$sel:clientRequestToken:ReleaseFileSystemNfsV3Locks' :: ReleaseFileSystemNfsV3Locks -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"ClientRequestToken" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
clientRequestToken,
            forall a. a -> Maybe a
Prelude.Just (Key
"FileSystemId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
fileSystemId)
          ]
      )

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

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

-- | /See:/ 'newReleaseFileSystemNfsV3LocksResponse' smart constructor.
data ReleaseFileSystemNfsV3LocksResponse = ReleaseFileSystemNfsV3LocksResponse'
  { ReleaseFileSystemNfsV3LocksResponse -> Maybe FileSystem
fileSystem :: Prelude.Maybe FileSystem,
    -- | The response's http status code.
    ReleaseFileSystemNfsV3LocksResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ReleaseFileSystemNfsV3LocksResponse
-> ReleaseFileSystemNfsV3LocksResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ReleaseFileSystemNfsV3LocksResponse
-> ReleaseFileSystemNfsV3LocksResponse -> Bool
$c/= :: ReleaseFileSystemNfsV3LocksResponse
-> ReleaseFileSystemNfsV3LocksResponse -> Bool
== :: ReleaseFileSystemNfsV3LocksResponse
-> ReleaseFileSystemNfsV3LocksResponse -> Bool
$c== :: ReleaseFileSystemNfsV3LocksResponse
-> ReleaseFileSystemNfsV3LocksResponse -> Bool
Prelude.Eq, ReadPrec [ReleaseFileSystemNfsV3LocksResponse]
ReadPrec ReleaseFileSystemNfsV3LocksResponse
Int -> ReadS ReleaseFileSystemNfsV3LocksResponse
ReadS [ReleaseFileSystemNfsV3LocksResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ReleaseFileSystemNfsV3LocksResponse]
$creadListPrec :: ReadPrec [ReleaseFileSystemNfsV3LocksResponse]
readPrec :: ReadPrec ReleaseFileSystemNfsV3LocksResponse
$creadPrec :: ReadPrec ReleaseFileSystemNfsV3LocksResponse
readList :: ReadS [ReleaseFileSystemNfsV3LocksResponse]
$creadList :: ReadS [ReleaseFileSystemNfsV3LocksResponse]
readsPrec :: Int -> ReadS ReleaseFileSystemNfsV3LocksResponse
$creadsPrec :: Int -> ReadS ReleaseFileSystemNfsV3LocksResponse
Prelude.Read, Int -> ReleaseFileSystemNfsV3LocksResponse -> ShowS
[ReleaseFileSystemNfsV3LocksResponse] -> ShowS
ReleaseFileSystemNfsV3LocksResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ReleaseFileSystemNfsV3LocksResponse] -> ShowS
$cshowList :: [ReleaseFileSystemNfsV3LocksResponse] -> ShowS
show :: ReleaseFileSystemNfsV3LocksResponse -> String
$cshow :: ReleaseFileSystemNfsV3LocksResponse -> String
showsPrec :: Int -> ReleaseFileSystemNfsV3LocksResponse -> ShowS
$cshowsPrec :: Int -> ReleaseFileSystemNfsV3LocksResponse -> ShowS
Prelude.Show, forall x.
Rep ReleaseFileSystemNfsV3LocksResponse x
-> ReleaseFileSystemNfsV3LocksResponse
forall x.
ReleaseFileSystemNfsV3LocksResponse
-> Rep ReleaseFileSystemNfsV3LocksResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ReleaseFileSystemNfsV3LocksResponse x
-> ReleaseFileSystemNfsV3LocksResponse
$cfrom :: forall x.
ReleaseFileSystemNfsV3LocksResponse
-> Rep ReleaseFileSystemNfsV3LocksResponse x
Prelude.Generic)

-- |
-- Create a value of 'ReleaseFileSystemNfsV3LocksResponse' 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:
--
-- 'fileSystem', 'releaseFileSystemNfsV3LocksResponse_fileSystem' - Undocumented member.
--
-- 'httpStatus', 'releaseFileSystemNfsV3LocksResponse_httpStatus' - The response's http status code.
newReleaseFileSystemNfsV3LocksResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ReleaseFileSystemNfsV3LocksResponse
newReleaseFileSystemNfsV3LocksResponse :: Int -> ReleaseFileSystemNfsV3LocksResponse
newReleaseFileSystemNfsV3LocksResponse Int
pHttpStatus_ =
  ReleaseFileSystemNfsV3LocksResponse'
    { $sel:fileSystem:ReleaseFileSystemNfsV3LocksResponse' :: Maybe FileSystem
fileSystem =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ReleaseFileSystemNfsV3LocksResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Undocumented member.
releaseFileSystemNfsV3LocksResponse_fileSystem :: Lens.Lens' ReleaseFileSystemNfsV3LocksResponse (Prelude.Maybe FileSystem)
releaseFileSystemNfsV3LocksResponse_fileSystem :: Lens' ReleaseFileSystemNfsV3LocksResponse (Maybe FileSystem)
releaseFileSystemNfsV3LocksResponse_fileSystem = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ReleaseFileSystemNfsV3LocksResponse' {Maybe FileSystem
fileSystem :: Maybe FileSystem
$sel:fileSystem:ReleaseFileSystemNfsV3LocksResponse' :: ReleaseFileSystemNfsV3LocksResponse -> Maybe FileSystem
fileSystem} -> Maybe FileSystem
fileSystem) (\s :: ReleaseFileSystemNfsV3LocksResponse
s@ReleaseFileSystemNfsV3LocksResponse' {} Maybe FileSystem
a -> ReleaseFileSystemNfsV3LocksResponse
s {$sel:fileSystem:ReleaseFileSystemNfsV3LocksResponse' :: Maybe FileSystem
fileSystem = Maybe FileSystem
a} :: ReleaseFileSystemNfsV3LocksResponse)

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

instance
  Prelude.NFData
    ReleaseFileSystemNfsV3LocksResponse
  where
  rnf :: ReleaseFileSystemNfsV3LocksResponse -> ()
rnf ReleaseFileSystemNfsV3LocksResponse' {Int
Maybe FileSystem
httpStatus :: Int
fileSystem :: Maybe FileSystem
$sel:httpStatus:ReleaseFileSystemNfsV3LocksResponse' :: ReleaseFileSystemNfsV3LocksResponse -> Int
$sel:fileSystem:ReleaseFileSystemNfsV3LocksResponse' :: ReleaseFileSystemNfsV3LocksResponse -> Maybe FileSystem
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe FileSystem
fileSystem
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus