--
-- MinIO Haskell SDK, (C) 2018 MinIO, Inc.
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
--     http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
--

module Network.Minio.AdminAPI
  ( -- * MinIO Admin API

    --------------------

    -- | Provides MinIO admin API and related types. It is in
    -- experimental state.
    DriveInfo (..),
    ErasureInfo (..),
    Backend (..),
    ConnStats (..),
    HttpStats (..),
    ServerProps (..),
    CountNAvgTime (..),
    StorageClass (..),
    StorageInfo (..),
    SIData (..),
    ServerInfo (..),
    getServerInfo,
    HealOpts (..),
    HealResultItem (..),
    HealStatus (..),
    HealStartResp (..),
    startHeal,
    forceStartHeal,
    getHealStatus,
    SetConfigResult (..),
    NodeSummary (..),
    setConfig,
    getConfig,
    ServerVersion (..),
    ServiceStatus (..),
    serviceStatus,
    ServiceAction (..),
    serviceSendAction,
  )
where

import Data.Aeson
  ( FromJSON,
    ToJSON,
    Value (Object),
    eitherDecode,
    object,
    pairs,
    parseJSON,
    toEncoding,
    toJSON,
    withObject,
    withText,
    (.:),
    (.:?),
    (.=),
  )
import qualified Data.Aeson as A
import Data.Aeson.Types (typeMismatch)
import qualified Data.ByteString as B
import qualified Data.ByteString.Lazy as LBS
import qualified Data.Text as T
import Data.Time (NominalDiffTime, getCurrentTime)
import Lib.Prelude
import Network.HTTP.Conduit (Response)
import qualified Network.HTTP.Conduit as NC
import qualified Network.HTTP.Types as HT
import Network.HTTP.Types.Header (hHost)
import Network.Minio.APICommon
import Network.Minio.Data
import Network.Minio.Errors
import Network.Minio.Sign.V4
import Network.Minio.Utils

data DriveInfo = DriveInfo
  { DriveInfo -> Text
diUuid :: Text,
    DriveInfo -> Text
diEndpoint :: Text,
    DriveInfo -> Text
diState :: Text
  }
  deriving stock (Int -> DriveInfo -> ShowS
[DriveInfo] -> ShowS
DriveInfo -> String
(Int -> DriveInfo -> ShowS)
-> (DriveInfo -> String)
-> ([DriveInfo] -> ShowS)
-> Show DriveInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DriveInfo] -> ShowS
$cshowList :: [DriveInfo] -> ShowS
show :: DriveInfo -> String
$cshow :: DriveInfo -> String
showsPrec :: Int -> DriveInfo -> ShowS
$cshowsPrec :: Int -> DriveInfo -> ShowS
Show, DriveInfo -> DriveInfo -> Bool
(DriveInfo -> DriveInfo -> Bool)
-> (DriveInfo -> DriveInfo -> Bool) -> Eq DriveInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DriveInfo -> DriveInfo -> Bool
$c/= :: DriveInfo -> DriveInfo -> Bool
== :: DriveInfo -> DriveInfo -> Bool
$c== :: DriveInfo -> DriveInfo -> Bool
Eq)

instance FromJSON DriveInfo where
  parseJSON :: Value -> Parser DriveInfo
parseJSON = String -> (Object -> Parser DriveInfo) -> Value -> Parser DriveInfo
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"DriveInfo" ((Object -> Parser DriveInfo) -> Value -> Parser DriveInfo)
-> (Object -> Parser DriveInfo) -> Value -> Parser DriveInfo
forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Text -> Text -> Text -> DriveInfo
DriveInfo
      (Text -> Text -> Text -> DriveInfo)
-> Parser Text -> Parser (Text -> Text -> DriveInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"uuid"
      Parser (Text -> Text -> DriveInfo)
-> Parser Text -> Parser (Text -> DriveInfo)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"endpoint"
      Parser (Text -> DriveInfo) -> Parser Text -> Parser DriveInfo
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"state"

data StorageClass = StorageClass
  { StorageClass -> Int
scParity :: Int,
    StorageClass -> Int
scData :: Int
  }
  deriving stock (Int -> StorageClass -> ShowS
[StorageClass] -> ShowS
StorageClass -> String
(Int -> StorageClass -> ShowS)
-> (StorageClass -> String)
-> ([StorageClass] -> ShowS)
-> Show StorageClass
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StorageClass] -> ShowS
$cshowList :: [StorageClass] -> ShowS
show :: StorageClass -> String
$cshow :: StorageClass -> String
showsPrec :: Int -> StorageClass -> ShowS
$cshowsPrec :: Int -> StorageClass -> ShowS
Show, StorageClass -> StorageClass -> Bool
(StorageClass -> StorageClass -> Bool)
-> (StorageClass -> StorageClass -> Bool) -> Eq StorageClass
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StorageClass -> StorageClass -> Bool
$c/= :: StorageClass -> StorageClass -> Bool
== :: StorageClass -> StorageClass -> Bool
$c== :: StorageClass -> StorageClass -> Bool
Eq)

data ErasureInfo = ErasureInfo
  { ErasureInfo -> Int
eiOnlineDisks :: Int,
    ErasureInfo -> Int
eiOfflineDisks :: Int,
    ErasureInfo -> StorageClass
eiStandard :: StorageClass,
    ErasureInfo -> StorageClass
eiReducedRedundancy :: StorageClass,
    ErasureInfo -> [[DriveInfo]]
eiSets :: [[DriveInfo]]
  }
  deriving stock (Int -> ErasureInfo -> ShowS
[ErasureInfo] -> ShowS
ErasureInfo -> String
(Int -> ErasureInfo -> ShowS)
-> (ErasureInfo -> String)
-> ([ErasureInfo] -> ShowS)
-> Show ErasureInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ErasureInfo] -> ShowS
$cshowList :: [ErasureInfo] -> ShowS
show :: ErasureInfo -> String
$cshow :: ErasureInfo -> String
showsPrec :: Int -> ErasureInfo -> ShowS
$cshowsPrec :: Int -> ErasureInfo -> ShowS
Show, ErasureInfo -> ErasureInfo -> Bool
(ErasureInfo -> ErasureInfo -> Bool)
-> (ErasureInfo -> ErasureInfo -> Bool) -> Eq ErasureInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ErasureInfo -> ErasureInfo -> Bool
$c/= :: ErasureInfo -> ErasureInfo -> Bool
== :: ErasureInfo -> ErasureInfo -> Bool
$c== :: ErasureInfo -> ErasureInfo -> Bool
Eq)

instance FromJSON ErasureInfo where
  parseJSON :: Value -> Parser ErasureInfo
parseJSON = String
-> (Object -> Parser ErasureInfo) -> Value -> Parser ErasureInfo
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ErasureInfo" ((Object -> Parser ErasureInfo) -> Value -> Parser ErasureInfo)
-> (Object -> Parser ErasureInfo) -> Value -> Parser ErasureInfo
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
    Int
onlineDisks <- Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"OnlineDisks"
    Int
offlineDisks <- Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"OfflineDisks"
    StorageClass
stdClass <-
      Int -> Int -> StorageClass
StorageClass
        (Int -> Int -> StorageClass)
-> Parser Int -> Parser (Int -> StorageClass)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"StandardSCData"
        Parser (Int -> StorageClass) -> Parser Int -> Parser StorageClass
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"StandardSCParity"
    StorageClass
rrClass <-
      Int -> Int -> StorageClass
StorageClass
        (Int -> Int -> StorageClass)
-> Parser Int -> Parser (Int -> StorageClass)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"RRSCData"
        Parser (Int -> StorageClass) -> Parser Int -> Parser StorageClass
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"RRSCParity"
    [[DriveInfo]]
sets <- Object
v Object -> Key -> Parser [[DriveInfo]]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"Sets"
    ErasureInfo -> Parser ErasureInfo
forall (m :: * -> *) a. Monad m => a -> m a
return (ErasureInfo -> Parser ErasureInfo)
-> ErasureInfo -> Parser ErasureInfo
forall a b. (a -> b) -> a -> b
$ Int
-> Int
-> StorageClass
-> StorageClass
-> [[DriveInfo]]
-> ErasureInfo
ErasureInfo Int
onlineDisks Int
offlineDisks StorageClass
stdClass StorageClass
rrClass [[DriveInfo]]
sets

data Backend
  = BackendFS
  | BackendErasure ErasureInfo
  deriving stock (Int -> Backend -> ShowS
[Backend] -> ShowS
Backend -> String
(Int -> Backend -> ShowS)
-> (Backend -> String) -> ([Backend] -> ShowS) -> Show Backend
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Backend] -> ShowS
$cshowList :: [Backend] -> ShowS
show :: Backend -> String
$cshow :: Backend -> String
showsPrec :: Int -> Backend -> ShowS
$cshowsPrec :: Int -> Backend -> ShowS
Show, Backend -> Backend -> Bool
(Backend -> Backend -> Bool)
-> (Backend -> Backend -> Bool) -> Eq Backend
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Backend -> Backend -> Bool
$c/= :: Backend -> Backend -> Bool
== :: Backend -> Backend -> Bool
$c== :: Backend -> Backend -> Bool
Eq)

instance FromJSON Backend where
  parseJSON :: Value -> Parser Backend
parseJSON = String -> (Object -> Parser Backend) -> Value -> Parser Backend
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Backend" ((Object -> Parser Backend) -> Value -> Parser Backend)
-> (Object -> Parser Backend) -> Value -> Parser Backend
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
    Int
typ <- Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"Type"
    case Int
typ :: Int of
      Int
1 -> Backend -> Parser Backend
forall (m :: * -> *) a. Monad m => a -> m a
return Backend
BackendFS
      Int
2 -> ErasureInfo -> Backend
BackendErasure (ErasureInfo -> Backend) -> Parser ErasureInfo -> Parser Backend
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser ErasureInfo
forall a. FromJSON a => Value -> Parser a
parseJSON (Object -> Value
Object Object
v)
      Int
_ -> String -> Value -> Parser Backend
forall a. String -> Value -> Parser a
typeMismatch String
"BackendType" (Object -> Value
Object Object
v)

data ConnStats = ConnStats
  { ConnStats -> Int64
csTransferred :: Int64,
    ConnStats -> Int64
csReceived :: Int64
  }
  deriving stock (Int -> ConnStats -> ShowS
[ConnStats] -> ShowS
ConnStats -> String
(Int -> ConnStats -> ShowS)
-> (ConnStats -> String)
-> ([ConnStats] -> ShowS)
-> Show ConnStats
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConnStats] -> ShowS
$cshowList :: [ConnStats] -> ShowS
show :: ConnStats -> String
$cshow :: ConnStats -> String
showsPrec :: Int -> ConnStats -> ShowS
$cshowsPrec :: Int -> ConnStats -> ShowS
Show, ConnStats -> ConnStats -> Bool
(ConnStats -> ConnStats -> Bool)
-> (ConnStats -> ConnStats -> Bool) -> Eq ConnStats
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConnStats -> ConnStats -> Bool
$c/= :: ConnStats -> ConnStats -> Bool
== :: ConnStats -> ConnStats -> Bool
$c== :: ConnStats -> ConnStats -> Bool
Eq)

instance FromJSON ConnStats where
  parseJSON :: Value -> Parser ConnStats
parseJSON = String -> (Object -> Parser ConnStats) -> Value -> Parser ConnStats
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ConnStats" ((Object -> Parser ConnStats) -> Value -> Parser ConnStats)
-> (Object -> Parser ConnStats) -> Value -> Parser ConnStats
forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Int64 -> Int64 -> ConnStats
ConnStats
      (Int64 -> Int64 -> ConnStats)
-> Parser Int64 -> Parser (Int64 -> ConnStats)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Int64
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"transferred"
      Parser (Int64 -> ConnStats) -> Parser Int64 -> Parser ConnStats
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int64
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"received"

data ServerProps = ServerProps
  { ServerProps -> NominalDiffTime
spUptime :: NominalDiffTime,
    ServerProps -> Text
spVersion :: Text,
    ServerProps -> Text
spCommitId :: Text,
    ServerProps -> Text
spRegion :: Text,
    ServerProps -> [Text]
spSqsArns :: [Text]
  }
  deriving stock (Int -> ServerProps -> ShowS
[ServerProps] -> ShowS
ServerProps -> String
(Int -> ServerProps -> ShowS)
-> (ServerProps -> String)
-> ([ServerProps] -> ShowS)
-> Show ServerProps
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ServerProps] -> ShowS
$cshowList :: [ServerProps] -> ShowS
show :: ServerProps -> String
$cshow :: ServerProps -> String
showsPrec :: Int -> ServerProps -> ShowS
$cshowsPrec :: Int -> ServerProps -> ShowS
Show, ServerProps -> ServerProps -> Bool
(ServerProps -> ServerProps -> Bool)
-> (ServerProps -> ServerProps -> Bool) -> Eq ServerProps
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ServerProps -> ServerProps -> Bool
$c/= :: ServerProps -> ServerProps -> Bool
== :: ServerProps -> ServerProps -> Bool
$c== :: ServerProps -> ServerProps -> Bool
Eq)

instance FromJSON ServerProps where
  parseJSON :: Value -> Parser ServerProps
parseJSON = String
-> (Object -> Parser ServerProps) -> Value -> Parser ServerProps
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"SIServer" ((Object -> Parser ServerProps) -> Value -> Parser ServerProps)
-> (Object -> Parser ServerProps) -> Value -> Parser ServerProps
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
    NominalDiffTime
uptimeNs <- Object
v Object -> Key -> Parser NominalDiffTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"uptime"
    let uptime :: NominalDiffTime
uptime = NominalDiffTime
uptimeNs NominalDiffTime -> NominalDiffTime -> NominalDiffTime
forall a. Fractional a => a -> a -> a
/ NominalDiffTime
1e9
    Text
ver <- Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"version"
    Text
commitId <- Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"commitID"
    Text
region <- Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"region"
    [Text]
arn <- Object
v Object -> Key -> Parser [Text]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sqsARN"
    ServerProps -> Parser ServerProps
forall (m :: * -> *) a. Monad m => a -> m a
return (ServerProps -> Parser ServerProps)
-> ServerProps -> Parser ServerProps
forall a b. (a -> b) -> a -> b
$ NominalDiffTime -> Text -> Text -> Text -> [Text] -> ServerProps
ServerProps NominalDiffTime
uptime Text
ver Text
commitId Text
region [Text]
arn

data StorageInfo = StorageInfo
  { StorageInfo -> Int64
siUsed :: Int64,
    StorageInfo -> Backend
siBackend :: Backend
  }
  deriving stock (Int -> StorageInfo -> ShowS
[StorageInfo] -> ShowS
StorageInfo -> String
(Int -> StorageInfo -> ShowS)
-> (StorageInfo -> String)
-> ([StorageInfo] -> ShowS)
-> Show StorageInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StorageInfo] -> ShowS
$cshowList :: [StorageInfo] -> ShowS
show :: StorageInfo -> String
$cshow :: StorageInfo -> String
showsPrec :: Int -> StorageInfo -> ShowS
$cshowsPrec :: Int -> StorageInfo -> ShowS
Show, StorageInfo -> StorageInfo -> Bool
(StorageInfo -> StorageInfo -> Bool)
-> (StorageInfo -> StorageInfo -> Bool) -> Eq StorageInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StorageInfo -> StorageInfo -> Bool
$c/= :: StorageInfo -> StorageInfo -> Bool
== :: StorageInfo -> StorageInfo -> Bool
$c== :: StorageInfo -> StorageInfo -> Bool
Eq)

instance FromJSON StorageInfo where
  parseJSON :: Value -> Parser StorageInfo
parseJSON = String
-> (Object -> Parser StorageInfo) -> Value -> Parser StorageInfo
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"StorageInfo" ((Object -> Parser StorageInfo) -> Value -> Parser StorageInfo)
-> (Object -> Parser StorageInfo) -> Value -> Parser StorageInfo
forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Int64 -> Backend -> StorageInfo
StorageInfo
      (Int64 -> Backend -> StorageInfo)
-> Parser Int64 -> Parser (Backend -> StorageInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Int64
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"Used"
      Parser (Backend -> StorageInfo)
-> Parser Backend -> Parser StorageInfo
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Backend
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"Backend"

data CountNAvgTime = CountNAvgTime
  { CountNAvgTime -> Int64
caCount :: Int64,
    CountNAvgTime -> Text
caAvgDuration :: Text
  }
  deriving stock (Int -> CountNAvgTime -> ShowS
[CountNAvgTime] -> ShowS
CountNAvgTime -> String
(Int -> CountNAvgTime -> ShowS)
-> (CountNAvgTime -> String)
-> ([CountNAvgTime] -> ShowS)
-> Show CountNAvgTime
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CountNAvgTime] -> ShowS
$cshowList :: [CountNAvgTime] -> ShowS
show :: CountNAvgTime -> String
$cshow :: CountNAvgTime -> String
showsPrec :: Int -> CountNAvgTime -> ShowS
$cshowsPrec :: Int -> CountNAvgTime -> ShowS
Show, CountNAvgTime -> CountNAvgTime -> Bool
(CountNAvgTime -> CountNAvgTime -> Bool)
-> (CountNAvgTime -> CountNAvgTime -> Bool) -> Eq CountNAvgTime
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CountNAvgTime -> CountNAvgTime -> Bool
$c/= :: CountNAvgTime -> CountNAvgTime -> Bool
== :: CountNAvgTime -> CountNAvgTime -> Bool
$c== :: CountNAvgTime -> CountNAvgTime -> Bool
Eq)

instance FromJSON CountNAvgTime where
  parseJSON :: Value -> Parser CountNAvgTime
parseJSON = String
-> (Object -> Parser CountNAvgTime)
-> Value
-> Parser CountNAvgTime
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"CountNAvgTime" ((Object -> Parser CountNAvgTime) -> Value -> Parser CountNAvgTime)
-> (Object -> Parser CountNAvgTime)
-> Value
-> Parser CountNAvgTime
forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Int64 -> Text -> CountNAvgTime
CountNAvgTime
      (Int64 -> Text -> CountNAvgTime)
-> Parser Int64 -> Parser (Text -> CountNAvgTime)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Int64
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"count"
      Parser (Text -> CountNAvgTime)
-> Parser Text -> Parser CountNAvgTime
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"avgDuration"

data HttpStats = HttpStats
  { HttpStats -> CountNAvgTime
hsTotalHeads :: CountNAvgTime,
    HttpStats -> CountNAvgTime
hsSuccessHeads :: CountNAvgTime,
    HttpStats -> CountNAvgTime
hsTotalGets :: CountNAvgTime,
    HttpStats -> CountNAvgTime
hsSuccessGets :: CountNAvgTime,
    HttpStats -> CountNAvgTime
hsTotalPuts :: CountNAvgTime,
    HttpStats -> CountNAvgTime
hsSuccessPuts :: CountNAvgTime,
    HttpStats -> CountNAvgTime
hsTotalPosts :: CountNAvgTime,
    HttpStats -> CountNAvgTime
hsSuccessPosts :: CountNAvgTime,
    HttpStats -> CountNAvgTime
hsTotalDeletes :: CountNAvgTime,
    HttpStats -> CountNAvgTime
hsSuccessDeletes :: CountNAvgTime
  }
  deriving stock (Int -> HttpStats -> ShowS
[HttpStats] -> ShowS
HttpStats -> String
(Int -> HttpStats -> ShowS)
-> (HttpStats -> String)
-> ([HttpStats] -> ShowS)
-> Show HttpStats
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HttpStats] -> ShowS
$cshowList :: [HttpStats] -> ShowS
show :: HttpStats -> String
$cshow :: HttpStats -> String
showsPrec :: Int -> HttpStats -> ShowS
$cshowsPrec :: Int -> HttpStats -> ShowS
Show, HttpStats -> HttpStats -> Bool
(HttpStats -> HttpStats -> Bool)
-> (HttpStats -> HttpStats -> Bool) -> Eq HttpStats
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HttpStats -> HttpStats -> Bool
$c/= :: HttpStats -> HttpStats -> Bool
== :: HttpStats -> HttpStats -> Bool
$c== :: HttpStats -> HttpStats -> Bool
Eq)

instance FromJSON HttpStats where
  parseJSON :: Value -> Parser HttpStats
parseJSON = String -> (Object -> Parser HttpStats) -> Value -> Parser HttpStats
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"HttpStats" ((Object -> Parser HttpStats) -> Value -> Parser HttpStats)
-> (Object -> Parser HttpStats) -> Value -> Parser HttpStats
forall a b. (a -> b) -> a -> b
$ \Object
v ->
    CountNAvgTime
-> CountNAvgTime
-> CountNAvgTime
-> CountNAvgTime
-> CountNAvgTime
-> CountNAvgTime
-> CountNAvgTime
-> CountNAvgTime
-> CountNAvgTime
-> CountNAvgTime
-> HttpStats
HttpStats
      (CountNAvgTime
 -> CountNAvgTime
 -> CountNAvgTime
 -> CountNAvgTime
 -> CountNAvgTime
 -> CountNAvgTime
 -> CountNAvgTime
 -> CountNAvgTime
 -> CountNAvgTime
 -> CountNAvgTime
 -> HttpStats)
-> Parser CountNAvgTime
-> Parser
     (CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> HttpStats)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser CountNAvgTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"totalHEADs"
      Parser
  (CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> HttpStats)
-> Parser CountNAvgTime
-> Parser
     (CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> HttpStats)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser CountNAvgTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"successHEADs"
      Parser
  (CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> HttpStats)
-> Parser CountNAvgTime
-> Parser
     (CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> HttpStats)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser CountNAvgTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"totalGETs"
      Parser
  (CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> HttpStats)
-> Parser CountNAvgTime
-> Parser
     (CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> HttpStats)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser CountNAvgTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"successGETs"
      Parser
  (CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> HttpStats)
-> Parser CountNAvgTime
-> Parser
     (CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> CountNAvgTime
      -> HttpStats)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser CountNAvgTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"totalPUTs"
      Parser
  (CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> CountNAvgTime
   -> HttpStats)
-> Parser CountNAvgTime
-> Parser
     (CountNAvgTime
      -> CountNAvgTime -> CountNAvgTime -> CountNAvgTime -> HttpStats)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser CountNAvgTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"successPUTs"
      Parser
  (CountNAvgTime
   -> CountNAvgTime -> CountNAvgTime -> CountNAvgTime -> HttpStats)
-> Parser CountNAvgTime
-> Parser
     (CountNAvgTime -> CountNAvgTime -> CountNAvgTime -> HttpStats)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser CountNAvgTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"totalPOSTs"
      Parser
  (CountNAvgTime -> CountNAvgTime -> CountNAvgTime -> HttpStats)
-> Parser CountNAvgTime
-> Parser (CountNAvgTime -> CountNAvgTime -> HttpStats)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser CountNAvgTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"successPOSTs"
      Parser (CountNAvgTime -> CountNAvgTime -> HttpStats)
-> Parser CountNAvgTime -> Parser (CountNAvgTime -> HttpStats)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser CountNAvgTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"totalDELETEs"
      Parser (CountNAvgTime -> HttpStats)
-> Parser CountNAvgTime -> Parser HttpStats
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser CountNAvgTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"successDELETEs"

data SIData = SIData
  { SIData -> StorageInfo
sdStorage :: StorageInfo,
    SIData -> ConnStats
sdConnStats :: ConnStats,
    SIData -> HttpStats
sdHttpStats :: HttpStats,
    SIData -> ServerProps
sdProps :: ServerProps
  }
  deriving stock (Int -> SIData -> ShowS
[SIData] -> ShowS
SIData -> String
(Int -> SIData -> ShowS)
-> (SIData -> String) -> ([SIData] -> ShowS) -> Show SIData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SIData] -> ShowS
$cshowList :: [SIData] -> ShowS
show :: SIData -> String
$cshow :: SIData -> String
showsPrec :: Int -> SIData -> ShowS
$cshowsPrec :: Int -> SIData -> ShowS
Show, SIData -> SIData -> Bool
(SIData -> SIData -> Bool)
-> (SIData -> SIData -> Bool) -> Eq SIData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SIData -> SIData -> Bool
$c/= :: SIData -> SIData -> Bool
== :: SIData -> SIData -> Bool
$c== :: SIData -> SIData -> Bool
Eq)

instance FromJSON SIData where
  parseJSON :: Value -> Parser SIData
parseJSON = String -> (Object -> Parser SIData) -> Value -> Parser SIData
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"SIData" ((Object -> Parser SIData) -> Value -> Parser SIData)
-> (Object -> Parser SIData) -> Value -> Parser SIData
forall a b. (a -> b) -> a -> b
$ \Object
v ->
    StorageInfo -> ConnStats -> HttpStats -> ServerProps -> SIData
SIData
      (StorageInfo -> ConnStats -> HttpStats -> ServerProps -> SIData)
-> Parser StorageInfo
-> Parser (ConnStats -> HttpStats -> ServerProps -> SIData)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser StorageInfo
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"storage"
      Parser (ConnStats -> HttpStats -> ServerProps -> SIData)
-> Parser ConnStats -> Parser (HttpStats -> ServerProps -> SIData)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser ConnStats
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"network"
      Parser (HttpStats -> ServerProps -> SIData)
-> Parser HttpStats -> Parser (ServerProps -> SIData)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser HttpStats
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"http"
      Parser (ServerProps -> SIData)
-> Parser ServerProps -> Parser SIData
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser ServerProps
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"server"

data ServerInfo = ServerInfo
  { ServerInfo -> Text
siError :: Text,
    ServerInfo -> Text
siAddr :: Text,
    ServerInfo -> SIData
siData :: SIData
  }
  deriving stock (Int -> ServerInfo -> ShowS
[ServerInfo] -> ShowS
ServerInfo -> String
(Int -> ServerInfo -> ShowS)
-> (ServerInfo -> String)
-> ([ServerInfo] -> ShowS)
-> Show ServerInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ServerInfo] -> ShowS
$cshowList :: [ServerInfo] -> ShowS
show :: ServerInfo -> String
$cshow :: ServerInfo -> String
showsPrec :: Int -> ServerInfo -> ShowS
$cshowsPrec :: Int -> ServerInfo -> ShowS
Show, ServerInfo -> ServerInfo -> Bool
(ServerInfo -> ServerInfo -> Bool)
-> (ServerInfo -> ServerInfo -> Bool) -> Eq ServerInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ServerInfo -> ServerInfo -> Bool
$c/= :: ServerInfo -> ServerInfo -> Bool
== :: ServerInfo -> ServerInfo -> Bool
$c== :: ServerInfo -> ServerInfo -> Bool
Eq)

instance FromJSON ServerInfo where
  parseJSON :: Value -> Parser ServerInfo
parseJSON = String
-> (Object -> Parser ServerInfo) -> Value -> Parser ServerInfo
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ServerInfo" ((Object -> Parser ServerInfo) -> Value -> Parser ServerInfo)
-> (Object -> Parser ServerInfo) -> Value -> Parser ServerInfo
forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Text -> Text -> SIData -> ServerInfo
ServerInfo
      (Text -> Text -> SIData -> ServerInfo)
-> Parser Text -> Parser (Text -> SIData -> ServerInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"error"
      Parser (Text -> SIData -> ServerInfo)
-> Parser Text -> Parser (SIData -> ServerInfo)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"addr"
      Parser (SIData -> ServerInfo) -> Parser SIData -> Parser ServerInfo
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser SIData
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"data"

data ServerVersion = ServerVersion
  { ServerVersion -> Text
svVersion :: Text,
    ServerVersion -> Text
svCommitId :: Text
  }
  deriving stock (Int -> ServerVersion -> ShowS
[ServerVersion] -> ShowS
ServerVersion -> String
(Int -> ServerVersion -> ShowS)
-> (ServerVersion -> String)
-> ([ServerVersion] -> ShowS)
-> Show ServerVersion
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ServerVersion] -> ShowS
$cshowList :: [ServerVersion] -> ShowS
show :: ServerVersion -> String
$cshow :: ServerVersion -> String
showsPrec :: Int -> ServerVersion -> ShowS
$cshowsPrec :: Int -> ServerVersion -> ShowS
Show, ServerVersion -> ServerVersion -> Bool
(ServerVersion -> ServerVersion -> Bool)
-> (ServerVersion -> ServerVersion -> Bool) -> Eq ServerVersion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ServerVersion -> ServerVersion -> Bool
$c/= :: ServerVersion -> ServerVersion -> Bool
== :: ServerVersion -> ServerVersion -> Bool
$c== :: ServerVersion -> ServerVersion -> Bool
Eq)

instance FromJSON ServerVersion where
  parseJSON :: Value -> Parser ServerVersion
parseJSON = String
-> (Object -> Parser ServerVersion)
-> Value
-> Parser ServerVersion
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ServerVersion" ((Object -> Parser ServerVersion) -> Value -> Parser ServerVersion)
-> (Object -> Parser ServerVersion)
-> Value
-> Parser ServerVersion
forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Text -> Text -> ServerVersion
ServerVersion
      (Text -> Text -> ServerVersion)
-> Parser Text -> Parser (Text -> ServerVersion)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"version"
      Parser (Text -> ServerVersion)
-> Parser Text -> Parser ServerVersion
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"commitID"

data ServiceStatus = ServiceStatus
  { ServiceStatus -> ServerVersion
ssVersion :: ServerVersion,
    ServiceStatus -> NominalDiffTime
ssUptime :: NominalDiffTime
  }
  deriving stock (Int -> ServiceStatus -> ShowS
[ServiceStatus] -> ShowS
ServiceStatus -> String
(Int -> ServiceStatus -> ShowS)
-> (ServiceStatus -> String)
-> ([ServiceStatus] -> ShowS)
-> Show ServiceStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ServiceStatus] -> ShowS
$cshowList :: [ServiceStatus] -> ShowS
show :: ServiceStatus -> String
$cshow :: ServiceStatus -> String
showsPrec :: Int -> ServiceStatus -> ShowS
$cshowsPrec :: Int -> ServiceStatus -> ShowS
Show, ServiceStatus -> ServiceStatus -> Bool
(ServiceStatus -> ServiceStatus -> Bool)
-> (ServiceStatus -> ServiceStatus -> Bool) -> Eq ServiceStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ServiceStatus -> ServiceStatus -> Bool
$c/= :: ServiceStatus -> ServiceStatus -> Bool
== :: ServiceStatus -> ServiceStatus -> Bool
$c== :: ServiceStatus -> ServiceStatus -> Bool
Eq)

instance FromJSON ServiceStatus where
  parseJSON :: Value -> Parser ServiceStatus
parseJSON = String
-> (Object -> Parser ServiceStatus)
-> Value
-> Parser ServiceStatus
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ServiceStatus" ((Object -> Parser ServiceStatus) -> Value -> Parser ServiceStatus)
-> (Object -> Parser ServiceStatus)
-> Value
-> Parser ServiceStatus
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
    ServerVersion
serverVersion <- Object
v Object -> Key -> Parser ServerVersion
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"serverVersion"
    NominalDiffTime
uptimeNs <- Object
v Object -> Key -> Parser NominalDiffTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"uptime"
    let uptime :: NominalDiffTime
uptime = NominalDiffTime
uptimeNs NominalDiffTime -> NominalDiffTime -> NominalDiffTime
forall a. Fractional a => a -> a -> a
/ NominalDiffTime
1e9
    ServiceStatus -> Parser ServiceStatus
forall (m :: * -> *) a. Monad m => a -> m a
return (ServiceStatus -> Parser ServiceStatus)
-> ServiceStatus -> Parser ServiceStatus
forall a b. (a -> b) -> a -> b
$ ServerVersion -> NominalDiffTime -> ServiceStatus
ServiceStatus ServerVersion
serverVersion NominalDiffTime
uptime

data ServiceAction
  = ServiceActionRestart
  | ServiceActionStop
  deriving stock (Int -> ServiceAction -> ShowS
[ServiceAction] -> ShowS
ServiceAction -> String
(Int -> ServiceAction -> ShowS)
-> (ServiceAction -> String)
-> ([ServiceAction] -> ShowS)
-> Show ServiceAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ServiceAction] -> ShowS
$cshowList :: [ServiceAction] -> ShowS
show :: ServiceAction -> String
$cshow :: ServiceAction -> String
showsPrec :: Int -> ServiceAction -> ShowS
$cshowsPrec :: Int -> ServiceAction -> ShowS
Show, ServiceAction -> ServiceAction -> Bool
(ServiceAction -> ServiceAction -> Bool)
-> (ServiceAction -> ServiceAction -> Bool) -> Eq ServiceAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ServiceAction -> ServiceAction -> Bool
$c/= :: ServiceAction -> ServiceAction -> Bool
== :: ServiceAction -> ServiceAction -> Bool
$c== :: ServiceAction -> ServiceAction -> Bool
Eq)

instance ToJSON ServiceAction where
  toJSON :: ServiceAction -> Value
toJSON ServiceAction
a = [Pair] -> Value
object [Key
"action" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= ServiceAction -> Text
serviceActionToText ServiceAction
a]

serviceActionToText :: ServiceAction -> Text
serviceActionToText :: ServiceAction -> Text
serviceActionToText ServiceAction
a = case ServiceAction
a of
  ServiceAction
ServiceActionRestart -> Text
"restart"
  ServiceAction
ServiceActionStop -> Text
"stop"

adminPath :: ByteString
adminPath :: ByteString
adminPath = ByteString
"/minio/admin"

data HealStartResp = HealStartResp
  { HealStartResp -> Text
hsrClientToken :: Text,
    HealStartResp -> Text
hsrClientAddr :: Text,
    HealStartResp -> UTCTime
hsrStartTime :: UTCTime
  }
  deriving stock (Int -> HealStartResp -> ShowS
[HealStartResp] -> ShowS
HealStartResp -> String
(Int -> HealStartResp -> ShowS)
-> (HealStartResp -> String)
-> ([HealStartResp] -> ShowS)
-> Show HealStartResp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HealStartResp] -> ShowS
$cshowList :: [HealStartResp] -> ShowS
show :: HealStartResp -> String
$cshow :: HealStartResp -> String
showsPrec :: Int -> HealStartResp -> ShowS
$cshowsPrec :: Int -> HealStartResp -> ShowS
Show, HealStartResp -> HealStartResp -> Bool
(HealStartResp -> HealStartResp -> Bool)
-> (HealStartResp -> HealStartResp -> Bool) -> Eq HealStartResp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HealStartResp -> HealStartResp -> Bool
$c/= :: HealStartResp -> HealStartResp -> Bool
== :: HealStartResp -> HealStartResp -> Bool
$c== :: HealStartResp -> HealStartResp -> Bool
Eq)

instance FromJSON HealStartResp where
  parseJSON :: Value -> Parser HealStartResp
parseJSON = String
-> (Object -> Parser HealStartResp)
-> Value
-> Parser HealStartResp
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"HealStartResp" ((Object -> Parser HealStartResp) -> Value -> Parser HealStartResp)
-> (Object -> Parser HealStartResp)
-> Value
-> Parser HealStartResp
forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Text -> Text -> UTCTime -> HealStartResp
HealStartResp
      (Text -> Text -> UTCTime -> HealStartResp)
-> Parser Text -> Parser (Text -> UTCTime -> HealStartResp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"clientToken"
      Parser (Text -> UTCTime -> HealStartResp)
-> Parser Text -> Parser (UTCTime -> HealStartResp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"clientAddress"
      Parser (UTCTime -> HealStartResp)
-> Parser UTCTime -> Parser HealStartResp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser UTCTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"startTime"

data HealOpts = HealOpts
  { HealOpts -> Bool
hoRecursive :: Bool,
    HealOpts -> Bool
hoDryRun :: Bool
  }
  deriving stock (Int -> HealOpts -> ShowS
[HealOpts] -> ShowS
HealOpts -> String
(Int -> HealOpts -> ShowS)
-> (HealOpts -> String) -> ([HealOpts] -> ShowS) -> Show HealOpts
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HealOpts] -> ShowS
$cshowList :: [HealOpts] -> ShowS
show :: HealOpts -> String
$cshow :: HealOpts -> String
showsPrec :: Int -> HealOpts -> ShowS
$cshowsPrec :: Int -> HealOpts -> ShowS
Show, HealOpts -> HealOpts -> Bool
(HealOpts -> HealOpts -> Bool)
-> (HealOpts -> HealOpts -> Bool) -> Eq HealOpts
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HealOpts -> HealOpts -> Bool
$c/= :: HealOpts -> HealOpts -> Bool
== :: HealOpts -> HealOpts -> Bool
$c== :: HealOpts -> HealOpts -> Bool
Eq)

instance ToJSON HealOpts where
  toJSON :: HealOpts -> Value
toJSON (HealOpts Bool
r Bool
d) =
    [Pair] -> Value
object [Key
"recursive" Key -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Bool
r, Key
"dryRun" Key -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Bool
d]
  toEncoding :: HealOpts -> Encoding
toEncoding (HealOpts Bool
r Bool
d) =
    Series -> Encoding
pairs (Key
"recursive" Key -> Bool -> Series
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Bool
r Series -> Series -> Series
forall a. Semigroup a => a -> a -> a
<> Key
"dryRun" Key -> Bool -> Series
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Bool
d)

instance FromJSON HealOpts where
  parseJSON :: Value -> Parser HealOpts
parseJSON = String -> (Object -> Parser HealOpts) -> Value -> Parser HealOpts
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"HealOpts" ((Object -> Parser HealOpts) -> Value -> Parser HealOpts)
-> (Object -> Parser HealOpts) -> Value -> Parser HealOpts
forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Bool -> Bool -> HealOpts
HealOpts
      (Bool -> Bool -> HealOpts)
-> Parser Bool -> Parser (Bool -> HealOpts)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"recursive"
      Parser (Bool -> HealOpts) -> Parser Bool -> Parser HealOpts
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"dryRun"

data HealItemType
  = HealItemMetadata
  | HealItemBucket
  | HealItemBucketMetadata
  | HealItemObject
  deriving stock (Int -> HealItemType -> ShowS
[HealItemType] -> ShowS
HealItemType -> String
(Int -> HealItemType -> ShowS)
-> (HealItemType -> String)
-> ([HealItemType] -> ShowS)
-> Show HealItemType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HealItemType] -> ShowS
$cshowList :: [HealItemType] -> ShowS
show :: HealItemType -> String
$cshow :: HealItemType -> String
showsPrec :: Int -> HealItemType -> ShowS
$cshowsPrec :: Int -> HealItemType -> ShowS
Show, HealItemType -> HealItemType -> Bool
(HealItemType -> HealItemType -> Bool)
-> (HealItemType -> HealItemType -> Bool) -> Eq HealItemType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HealItemType -> HealItemType -> Bool
$c/= :: HealItemType -> HealItemType -> Bool
== :: HealItemType -> HealItemType -> Bool
$c== :: HealItemType -> HealItemType -> Bool
Eq)

instance FromJSON HealItemType where
  parseJSON :: Value -> Parser HealItemType
parseJSON = String
-> (Text -> Parser HealItemType) -> Value -> Parser HealItemType
forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"HealItemType" ((Text -> Parser HealItemType) -> Value -> Parser HealItemType)
-> (Text -> Parser HealItemType) -> Value -> Parser HealItemType
forall a b. (a -> b) -> a -> b
$ \Text
v -> case Text
v of
    Text
"metadata" -> HealItemType -> Parser HealItemType
forall (m :: * -> *) a. Monad m => a -> m a
return HealItemType
HealItemMetadata
    Text
"bucket" -> HealItemType -> Parser HealItemType
forall (m :: * -> *) a. Monad m => a -> m a
return HealItemType
HealItemBucket
    Text
"object" -> HealItemType -> Parser HealItemType
forall (m :: * -> *) a. Monad m => a -> m a
return HealItemType
HealItemObject
    Text
"bucket-metadata" -> HealItemType -> Parser HealItemType
forall (m :: * -> *) a. Monad m => a -> m a
return HealItemType
HealItemBucketMetadata
    Text
_ -> String -> Value -> Parser HealItemType
forall a. String -> Value -> Parser a
typeMismatch String
"HealItemType" (Text -> Value
A.String Text
v)

data NodeSummary = NodeSummary
  { NodeSummary -> Text
nsName :: Text,
    NodeSummary -> Bool
nsErrSet :: Bool,
    NodeSummary -> Text
nsErrMessage :: Text
  }
  deriving stock (Int -> NodeSummary -> ShowS
[NodeSummary] -> ShowS
NodeSummary -> String
(Int -> NodeSummary -> ShowS)
-> (NodeSummary -> String)
-> ([NodeSummary] -> ShowS)
-> Show NodeSummary
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NodeSummary] -> ShowS
$cshowList :: [NodeSummary] -> ShowS
show :: NodeSummary -> String
$cshow :: NodeSummary -> String
showsPrec :: Int -> NodeSummary -> ShowS
$cshowsPrec :: Int -> NodeSummary -> ShowS
Show, NodeSummary -> NodeSummary -> Bool
(NodeSummary -> NodeSummary -> Bool)
-> (NodeSummary -> NodeSummary -> Bool) -> Eq NodeSummary
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NodeSummary -> NodeSummary -> Bool
$c/= :: NodeSummary -> NodeSummary -> Bool
== :: NodeSummary -> NodeSummary -> Bool
$c== :: NodeSummary -> NodeSummary -> Bool
Eq)

instance FromJSON NodeSummary where
  parseJSON :: Value -> Parser NodeSummary
parseJSON = String
-> (Object -> Parser NodeSummary) -> Value -> Parser NodeSummary
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"NodeSummary" ((Object -> Parser NodeSummary) -> Value -> Parser NodeSummary)
-> (Object -> Parser NodeSummary) -> Value -> Parser NodeSummary
forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Text -> Bool -> Text -> NodeSummary
NodeSummary
      (Text -> Bool -> Text -> NodeSummary)
-> Parser Text -> Parser (Bool -> Text -> NodeSummary)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
      Parser (Bool -> Text -> NodeSummary)
-> Parser Bool -> Parser (Text -> NodeSummary)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"errSet"
      Parser (Text -> NodeSummary) -> Parser Text -> Parser NodeSummary
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"errMsg"

data SetConfigResult = SetConfigResult
  { SetConfigResult -> Bool
scrStatus :: Bool,
    SetConfigResult -> [NodeSummary]
scrNodeSummary :: [NodeSummary]
  }
  deriving stock (Int -> SetConfigResult -> ShowS
[SetConfigResult] -> ShowS
SetConfigResult -> String
(Int -> SetConfigResult -> ShowS)
-> (SetConfigResult -> String)
-> ([SetConfigResult] -> ShowS)
-> Show SetConfigResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SetConfigResult] -> ShowS
$cshowList :: [SetConfigResult] -> ShowS
show :: SetConfigResult -> String
$cshow :: SetConfigResult -> String
showsPrec :: Int -> SetConfigResult -> ShowS
$cshowsPrec :: Int -> SetConfigResult -> ShowS
Show, SetConfigResult -> SetConfigResult -> Bool
(SetConfigResult -> SetConfigResult -> Bool)
-> (SetConfigResult -> SetConfigResult -> Bool)
-> Eq SetConfigResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SetConfigResult -> SetConfigResult -> Bool
$c/= :: SetConfigResult -> SetConfigResult -> Bool
== :: SetConfigResult -> SetConfigResult -> Bool
$c== :: SetConfigResult -> SetConfigResult -> Bool
Eq)

instance FromJSON SetConfigResult where
  parseJSON :: Value -> Parser SetConfigResult
parseJSON = String
-> (Object -> Parser SetConfigResult)
-> Value
-> Parser SetConfigResult
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"SetConfigResult" ((Object -> Parser SetConfigResult)
 -> Value -> Parser SetConfigResult)
-> (Object -> Parser SetConfigResult)
-> Value
-> Parser SetConfigResult
forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Bool -> [NodeSummary] -> SetConfigResult
SetConfigResult
      (Bool -> [NodeSummary] -> SetConfigResult)
-> Parser Bool -> Parser ([NodeSummary] -> SetConfigResult)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"status"
      Parser ([NodeSummary] -> SetConfigResult)
-> Parser [NodeSummary] -> Parser SetConfigResult
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser [NodeSummary]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"nodeResults"

data HealResultItem = HealResultItem
  { HealResultItem -> Int
hriResultIdx :: Int,
    HealResultItem -> HealItemType
hriType :: HealItemType,
    HealResultItem -> Text
hriBucket :: Bucket,
    HealResultItem -> Text
hriObject :: Object,
    HealResultItem -> Text
hriDetail :: Text,
    HealResultItem -> Maybe Int
hriParityBlocks :: Maybe Int,
    HealResultItem -> Maybe Int
hriDataBlocks :: Maybe Int,
    HealResultItem -> Int
hriDiskCount :: Int,
    HealResultItem -> Int
hriSetCount :: Int,
    HealResultItem -> Int
hriObjectSize :: Int,
    HealResultItem -> [DriveInfo]
hriBefore :: [DriveInfo],
    HealResultItem -> [DriveInfo]
hriAfter :: [DriveInfo]
  }
  deriving stock (Int -> HealResultItem -> ShowS
[HealResultItem] -> ShowS
HealResultItem -> String
(Int -> HealResultItem -> ShowS)
-> (HealResultItem -> String)
-> ([HealResultItem] -> ShowS)
-> Show HealResultItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HealResultItem] -> ShowS
$cshowList :: [HealResultItem] -> ShowS
show :: HealResultItem -> String
$cshow :: HealResultItem -> String
showsPrec :: Int -> HealResultItem -> ShowS
$cshowsPrec :: Int -> HealResultItem -> ShowS
Show, HealResultItem -> HealResultItem -> Bool
(HealResultItem -> HealResultItem -> Bool)
-> (HealResultItem -> HealResultItem -> Bool) -> Eq HealResultItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HealResultItem -> HealResultItem -> Bool
$c/= :: HealResultItem -> HealResultItem -> Bool
== :: HealResultItem -> HealResultItem -> Bool
$c== :: HealResultItem -> HealResultItem -> Bool
Eq)

instance FromJSON HealResultItem where
  parseJSON :: Value -> Parser HealResultItem
parseJSON = String
-> (Object -> Parser HealResultItem)
-> Value
-> Parser HealResultItem
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"HealResultItem" ((Object -> Parser HealResultItem)
 -> Value -> Parser HealResultItem)
-> (Object -> Parser HealResultItem)
-> Value
-> Parser HealResultItem
forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Int
-> HealItemType
-> Text
-> Text
-> Text
-> Maybe Int
-> Maybe Int
-> Int
-> Int
-> Int
-> [DriveInfo]
-> [DriveInfo]
-> HealResultItem
HealResultItem
      (Int
 -> HealItemType
 -> Text
 -> Text
 -> Text
 -> Maybe Int
 -> Maybe Int
 -> Int
 -> Int
 -> Int
 -> [DriveInfo]
 -> [DriveInfo]
 -> HealResultItem)
-> Parser Int
-> Parser
     (HealItemType
      -> Text
      -> Text
      -> Text
      -> Maybe Int
      -> Maybe Int
      -> Int
      -> Int
      -> Int
      -> [DriveInfo]
      -> [DriveInfo]
      -> HealResultItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"resultId"
      Parser
  (HealItemType
   -> Text
   -> Text
   -> Text
   -> Maybe Int
   -> Maybe Int
   -> Int
   -> Int
   -> Int
   -> [DriveInfo]
   -> [DriveInfo]
   -> HealResultItem)
-> Parser HealItemType
-> Parser
     (Text
      -> Text
      -> Text
      -> Maybe Int
      -> Maybe Int
      -> Int
      -> Int
      -> Int
      -> [DriveInfo]
      -> [DriveInfo]
      -> HealResultItem)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser HealItemType
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type"
      Parser
  (Text
   -> Text
   -> Text
   -> Maybe Int
   -> Maybe Int
   -> Int
   -> Int
   -> Int
   -> [DriveInfo]
   -> [DriveInfo]
   -> HealResultItem)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Maybe Int
      -> Maybe Int
      -> Int
      -> Int
      -> Int
      -> [DriveInfo]
      -> [DriveInfo]
      -> HealResultItem)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"bucket"
      Parser
  (Text
   -> Text
   -> Maybe Int
   -> Maybe Int
   -> Int
   -> Int
   -> Int
   -> [DriveInfo]
   -> [DriveInfo]
   -> HealResultItem)
-> Parser Text
-> Parser
     (Text
      -> Maybe Int
      -> Maybe Int
      -> Int
      -> Int
      -> Int
      -> [DriveInfo]
      -> [DriveInfo]
      -> HealResultItem)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"object"
      Parser
  (Text
   -> Maybe Int
   -> Maybe Int
   -> Int
   -> Int
   -> Int
   -> [DriveInfo]
   -> [DriveInfo]
   -> HealResultItem)
-> Parser Text
-> Parser
     (Maybe Int
      -> Maybe Int
      -> Int
      -> Int
      -> Int
      -> [DriveInfo]
      -> [DriveInfo]
      -> HealResultItem)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"detail"
      Parser
  (Maybe Int
   -> Maybe Int
   -> Int
   -> Int
   -> Int
   -> [DriveInfo]
   -> [DriveInfo]
   -> HealResultItem)
-> Parser (Maybe Int)
-> Parser
     (Maybe Int
      -> Int
      -> Int
      -> Int
      -> [DriveInfo]
      -> [DriveInfo]
      -> HealResultItem)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Int)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"parityBlocks"
      Parser
  (Maybe Int
   -> Int
   -> Int
   -> Int
   -> [DriveInfo]
   -> [DriveInfo]
   -> HealResultItem)
-> Parser (Maybe Int)
-> Parser
     (Int -> Int -> Int -> [DriveInfo] -> [DriveInfo] -> HealResultItem)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Int)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"dataBlocks"
      Parser
  (Int -> Int -> Int -> [DriveInfo] -> [DriveInfo] -> HealResultItem)
-> Parser Int
-> Parser
     (Int -> Int -> [DriveInfo] -> [DriveInfo] -> HealResultItem)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"diskCount"
      Parser (Int -> Int -> [DriveInfo] -> [DriveInfo] -> HealResultItem)
-> Parser Int
-> Parser (Int -> [DriveInfo] -> [DriveInfo] -> HealResultItem)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"setCount"
      Parser (Int -> [DriveInfo] -> [DriveInfo] -> HealResultItem)
-> Parser Int
-> Parser ([DriveInfo] -> [DriveInfo] -> HealResultItem)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"objectSize"
      Parser ([DriveInfo] -> [DriveInfo] -> HealResultItem)
-> Parser [DriveInfo] -> Parser ([DriveInfo] -> HealResultItem)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ( do
              Object
before <- Object
v Object -> Key -> Parser Object
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"before"
              Object
before Object -> Key -> Parser [DriveInfo]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"drives"
          )
      Parser ([DriveInfo] -> HealResultItem)
-> Parser [DriveInfo] -> Parser HealResultItem
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ( do
              Object
after <- Object
v Object -> Key -> Parser Object
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"after"
              Object
after Object -> Key -> Parser [DriveInfo]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"drives"
          )

data HealStatus = HealStatus
  { HealStatus -> Text
hsSummary :: Text,
    HealStatus -> UTCTime
hsStartTime :: UTCTime,
    HealStatus -> HealOpts
hsSettings :: HealOpts,
    HealStatus -> Int
hsNumDisks :: Int,
    HealStatus -> Maybe Text
hsFailureDetail :: Maybe Text,
    HealStatus -> Maybe [HealResultItem]
hsItems :: Maybe [HealResultItem]
  }
  deriving stock (Int -> HealStatus -> ShowS
[HealStatus] -> ShowS
HealStatus -> String
(Int -> HealStatus -> ShowS)
-> (HealStatus -> String)
-> ([HealStatus] -> ShowS)
-> Show HealStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HealStatus] -> ShowS
$cshowList :: [HealStatus] -> ShowS
show :: HealStatus -> String
$cshow :: HealStatus -> String
showsPrec :: Int -> HealStatus -> ShowS
$cshowsPrec :: Int -> HealStatus -> ShowS
Show, HealStatus -> HealStatus -> Bool
(HealStatus -> HealStatus -> Bool)
-> (HealStatus -> HealStatus -> Bool) -> Eq HealStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HealStatus -> HealStatus -> Bool
$c/= :: HealStatus -> HealStatus -> Bool
== :: HealStatus -> HealStatus -> Bool
$c== :: HealStatus -> HealStatus -> Bool
Eq)

instance FromJSON HealStatus where
  parseJSON :: Value -> Parser HealStatus
parseJSON = String
-> (Object -> Parser HealStatus) -> Value -> Parser HealStatus
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"HealStatus" ((Object -> Parser HealStatus) -> Value -> Parser HealStatus)
-> (Object -> Parser HealStatus) -> Value -> Parser HealStatus
forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Text
-> UTCTime
-> HealOpts
-> Int
-> Maybe Text
-> Maybe [HealResultItem]
-> HealStatus
HealStatus
      (Text
 -> UTCTime
 -> HealOpts
 -> Int
 -> Maybe Text
 -> Maybe [HealResultItem]
 -> HealStatus)
-> Parser Text
-> Parser
     (UTCTime
      -> HealOpts
      -> Int
      -> Maybe Text
      -> Maybe [HealResultItem]
      -> HealStatus)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"Summary"
      Parser
  (UTCTime
   -> HealOpts
   -> Int
   -> Maybe Text
   -> Maybe [HealResultItem]
   -> HealStatus)
-> Parser UTCTime
-> Parser
     (HealOpts
      -> Int -> Maybe Text -> Maybe [HealResultItem] -> HealStatus)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser UTCTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"StartTime"
      Parser
  (HealOpts
   -> Int -> Maybe Text -> Maybe [HealResultItem] -> HealStatus)
-> Parser HealOpts
-> Parser
     (Int -> Maybe Text -> Maybe [HealResultItem] -> HealStatus)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser HealOpts
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"Settings"
      Parser (Int -> Maybe Text -> Maybe [HealResultItem] -> HealStatus)
-> Parser Int
-> Parser (Maybe Text -> Maybe [HealResultItem] -> HealStatus)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"NumDisks"
      Parser (Maybe Text -> Maybe [HealResultItem] -> HealStatus)
-> Parser (Maybe Text)
-> Parser (Maybe [HealResultItem] -> HealStatus)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"Detail"
      Parser (Maybe [HealResultItem] -> HealStatus)
-> Parser (Maybe [HealResultItem]) -> Parser HealStatus
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe [HealResultItem])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"Items"

healPath :: Maybe Bucket -> Maybe Text -> ByteString
healPath :: Maybe Text -> Maybe Text -> ByteString
healPath Maybe Text
bucket Maybe Text
prefix = do
  if Maybe Text -> Bool
forall a. Maybe a -> Bool
isJust Maybe Text
bucket
    then
      Text -> ByteString
forall a b. ConvertUtf8 a b => a -> b
encodeUtf8 (Text -> ByteString) -> Text -> ByteString
forall a b. (a -> b) -> a -> b
$
        Text
"v1/heal/"
          Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text -> Maybe Text -> Text
forall a. a -> Maybe a -> a
fromMaybe Text
"" Maybe Text
bucket
          Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"/"
          Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text -> Maybe Text -> Text
forall a. a -> Maybe a -> a
fromMaybe Text
"" Maybe Text
prefix
    else Text -> ByteString
forall a b. ConvertUtf8 a b => a -> b
encodeUtf8 (Text
"v1/heal/" :: Text)

-- | Get server version and uptime.
serviceStatus :: Minio ServiceStatus
serviceStatus :: Minio ServiceStatus
serviceStatus = do
  Response LByteString
rsp <-
    AdminReqInfo -> Minio (Response LByteString)
executeAdminRequest
      AdminReqInfo :: ByteString
-> Maybe ByteString
-> Payload
-> ByteString
-> [Header]
-> Query
-> AdminReqInfo
AdminReqInfo
        { ariMethod :: ByteString
ariMethod = ByteString
HT.methodGet,
          ariPayload :: Payload
ariPayload = ByteString -> Payload
PayloadBS ByteString
B.empty,
          ariPayloadHash :: Maybe ByteString
ariPayloadHash = Maybe ByteString
forall a. Maybe a
Nothing,
          ariPath :: ByteString
ariPath = ByteString
"v1/service",
          ariHeaders :: [Header]
ariHeaders = [],
          ariQueryParams :: Query
ariQueryParams = []
        }

  let rspBS :: LByteString
rspBS = Response LByteString -> LByteString
forall body. Response body -> body
NC.responseBody Response LByteString
rsp
  case LByteString -> Either String ServiceStatus
forall a. FromJSON a => LByteString -> Either String a
eitherDecode LByteString
rspBS of
    Right ServiceStatus
ss -> ServiceStatus -> Minio ServiceStatus
forall (m :: * -> *) a. Monad m => a -> m a
return ServiceStatus
ss
    Left String
err -> MErrV -> Minio ServiceStatus
forall (m :: * -> *) e a. (MonadIO m, Exception e) => e -> m a
throwIO (MErrV -> Minio ServiceStatus) -> MErrV -> Minio ServiceStatus
forall a b. (a -> b) -> a -> b
$ Text -> MErrV
MErrVJsonParse (Text -> MErrV) -> Text -> MErrV
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack String
err

-- | Send service restart or stop action to MinIO server.
serviceSendAction :: ServiceAction -> Minio ()
serviceSendAction :: ServiceAction -> Minio ()
serviceSendAction ServiceAction
action = do
  let payload :: Payload
payload = ByteString -> Payload
PayloadBS (ByteString -> Payload) -> ByteString -> Payload
forall a b. (a -> b) -> a -> b
$ LByteString -> ByteString
LBS.toStrict (LByteString -> ByteString) -> LByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ ServiceAction -> LByteString
forall a. ToJSON a => a -> LByteString
A.encode ServiceAction
action
  Minio (Response LByteString) -> Minio ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Minio (Response LByteString) -> Minio ())
-> Minio (Response LByteString) -> Minio ()
forall a b. (a -> b) -> a -> b
$
    AdminReqInfo -> Minio (Response LByteString)
executeAdminRequest
      AdminReqInfo :: ByteString
-> Maybe ByteString
-> Payload
-> ByteString
-> [Header]
-> Query
-> AdminReqInfo
AdminReqInfo
        { ariMethod :: ByteString
ariMethod = ByteString
HT.methodPost,
          ariPayload :: Payload
ariPayload = Payload
payload,
          ariPayloadHash :: Maybe ByteString
ariPayloadHash = Maybe ByteString
forall a. Maybe a
Nothing,
          ariPath :: ByteString
ariPath = ByteString
"v1/service",
          ariHeaders :: [Header]
ariHeaders = [],
          ariQueryParams :: Query
ariQueryParams = []
        }

-- | Get the current config file from server.
getConfig :: Minio ByteString
getConfig :: Minio ByteString
getConfig = do
  Response LByteString
rsp <-
    AdminReqInfo -> Minio (Response LByteString)
executeAdminRequest
      AdminReqInfo :: ByteString
-> Maybe ByteString
-> Payload
-> ByteString
-> [Header]
-> Query
-> AdminReqInfo
AdminReqInfo
        { ariMethod :: ByteString
ariMethod = ByteString
HT.methodGet,
          ariPayload :: Payload
ariPayload = ByteString -> Payload
PayloadBS ByteString
B.empty,
          ariPayloadHash :: Maybe ByteString
ariPayloadHash = Maybe ByteString
forall a. Maybe a
Nothing,
          ariPath :: ByteString
ariPath = ByteString
"v1/config",
          ariHeaders :: [Header]
ariHeaders = [],
          ariQueryParams :: Query
ariQueryParams = []
        }
  ByteString -> Minio ByteString
forall (m :: * -> *) a. Monad m => a -> m a
return (ByteString -> Minio ByteString) -> ByteString -> Minio ByteString
forall a b. (a -> b) -> a -> b
$ LByteString -> ByteString
LBS.toStrict (LByteString -> ByteString) -> LByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ Response LByteString -> LByteString
forall body. Response body -> body
NC.responseBody Response LByteString
rsp

-- | Set a new config to the server.
setConfig :: ByteString -> Minio SetConfigResult
setConfig :: ByteString -> Minio SetConfigResult
setConfig ByteString
config = do
  Response LByteString
rsp <-
    AdminReqInfo -> Minio (Response LByteString)
executeAdminRequest
      AdminReqInfo :: ByteString
-> Maybe ByteString
-> Payload
-> ByteString
-> [Header]
-> Query
-> AdminReqInfo
AdminReqInfo
        { ariMethod :: ByteString
ariMethod = ByteString
HT.methodPut,
          ariPayload :: Payload
ariPayload = ByteString -> Payload
PayloadBS ByteString
config,
          ariPayloadHash :: Maybe ByteString
ariPayloadHash = Maybe ByteString
forall a. Maybe a
Nothing,
          ariPath :: ByteString
ariPath = ByteString
"v1/config",
          ariHeaders :: [Header]
ariHeaders = [],
          ariQueryParams :: Query
ariQueryParams = []
        }

  let rspBS :: LByteString
rspBS = Response LByteString -> LByteString
forall body. Response body -> body
NC.responseBody Response LByteString
rsp
  case LByteString -> Either String SetConfigResult
forall a. FromJSON a => LByteString -> Either String a
eitherDecode LByteString
rspBS of
    Right SetConfigResult
scr -> SetConfigResult -> Minio SetConfigResult
forall (m :: * -> *) a. Monad m => a -> m a
return SetConfigResult
scr
    Left String
err -> MErrV -> Minio SetConfigResult
forall (m :: * -> *) e a. (MonadIO m, Exception e) => e -> m a
throwIO (MErrV -> Minio SetConfigResult) -> MErrV -> Minio SetConfigResult
forall a b. (a -> b) -> a -> b
$ Text -> MErrV
MErrVJsonParse (Text -> MErrV) -> Text -> MErrV
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack String
err

-- | Get the progress of currently running heal task, this API should be
-- invoked right after `startHeal`. `token` is obtained after `startHeal`
-- which should be used to get the heal status.
getHealStatus :: Maybe Bucket -> Maybe Text -> Text -> Minio HealStatus
getHealStatus :: Maybe Text -> Maybe Text -> Text -> Minio HealStatus
getHealStatus Maybe Text
bucket Maybe Text
prefix Text
token = do
  Bool -> Minio () -> Minio ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Maybe Text -> Bool
forall a. Maybe a -> Bool
isNothing Maybe Text
bucket Bool -> Bool -> Bool
&& Maybe Text -> Bool
forall a. Maybe a -> Bool
isJust Maybe Text
prefix) (Minio () -> Minio ()) -> Minio () -> Minio ()
forall a b. (a -> b) -> a -> b
$ MErrV -> Minio ()
forall (m :: * -> *) e a. (MonadIO m, Exception e) => e -> m a
throwIO MErrV
MErrVInvalidHealPath
  let qparams :: Query
qparams = QueryText -> Query
HT.queryTextToQuery [(Text
"clientToken", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
token)]
  Response LByteString
rsp <-
    AdminReqInfo -> Minio (Response LByteString)
executeAdminRequest
      AdminReqInfo :: ByteString
-> Maybe ByteString
-> Payload
-> ByteString
-> [Header]
-> Query
-> AdminReqInfo
AdminReqInfo
        { ariMethod :: ByteString
ariMethod = ByteString
HT.methodPost,
          ariPayload :: Payload
ariPayload = ByteString -> Payload
PayloadBS ByteString
B.empty,
          ariPayloadHash :: Maybe ByteString
ariPayloadHash = Maybe ByteString
forall a. Maybe a
Nothing,
          ariPath :: ByteString
ariPath = Maybe Text -> Maybe Text -> ByteString
healPath Maybe Text
bucket Maybe Text
prefix,
          ariHeaders :: [Header]
ariHeaders = [],
          ariQueryParams :: Query
ariQueryParams = Query
qparams
        }
  let rspBS :: LByteString
rspBS = Response LByteString -> LByteString
forall body. Response body -> body
NC.responseBody Response LByteString
rsp
  case LByteString -> Either String HealStatus
forall a. FromJSON a => LByteString -> Either String a
eitherDecode LByteString
rspBS of
    Right HealStatus
hs -> HealStatus -> Minio HealStatus
forall (m :: * -> *) a. Monad m => a -> m a
return HealStatus
hs
    Left String
err -> MErrV -> Minio HealStatus
forall (m :: * -> *) e a. (MonadIO m, Exception e) => e -> m a
throwIO (MErrV -> Minio HealStatus) -> MErrV -> Minio HealStatus
forall a b. (a -> b) -> a -> b
$ Text -> MErrV
MErrVJsonParse (Text -> MErrV) -> Text -> MErrV
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack String
err

doHeal :: Maybe Bucket -> Maybe Text -> HealOpts -> Bool -> Minio HealStartResp
doHeal :: Maybe Text -> Maybe Text -> HealOpts -> Bool -> Minio HealStartResp
doHeal Maybe Text
bucket Maybe Text
prefix HealOpts
opts Bool
forceStart = do
  Bool -> Minio () -> Minio ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Maybe Text -> Bool
forall a. Maybe a -> Bool
isNothing Maybe Text
bucket Bool -> Bool -> Bool
&& Maybe Text -> Bool
forall a. Maybe a -> Bool
isJust Maybe Text
prefix) (Minio () -> Minio ()) -> Minio () -> Minio ()
forall a b. (a -> b) -> a -> b
$ MErrV -> Minio ()
forall (m :: * -> *) e a. (MonadIO m, Exception e) => e -> m a
throwIO MErrV
MErrVInvalidHealPath
  let payload :: Payload
payload = ByteString -> Payload
PayloadBS (ByteString -> Payload) -> ByteString -> Payload
forall a b. (a -> b) -> a -> b
$ LByteString -> ByteString
LBS.toStrict (LByteString -> ByteString) -> LByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ HealOpts -> LByteString
forall a. ToJSON a => a -> LByteString
A.encode HealOpts
opts
  let qparams :: Query
qparams =
        Query -> Query -> Bool -> Query
forall a. a -> a -> Bool -> a
bool
          []
          (QueryText -> Query
HT.queryTextToQuery [(Text
"forceStart", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"true")])
          Bool
forceStart

  Response LByteString
rsp <-
    AdminReqInfo -> Minio (Response LByteString)
executeAdminRequest
      AdminReqInfo :: ByteString
-> Maybe ByteString
-> Payload
-> ByteString
-> [Header]
-> Query
-> AdminReqInfo
AdminReqInfo
        { ariMethod :: ByteString
ariMethod = ByteString
HT.methodPost,
          ariPayload :: Payload
ariPayload = Payload
payload,
          ariPayloadHash :: Maybe ByteString
ariPayloadHash = Maybe ByteString
forall a. Maybe a
Nothing,
          ariPath :: ByteString
ariPath = Maybe Text -> Maybe Text -> ByteString
healPath Maybe Text
bucket Maybe Text
prefix,
          ariHeaders :: [Header]
ariHeaders = [],
          ariQueryParams :: Query
ariQueryParams = Query
qparams
        }

  let rspBS :: LByteString
rspBS = Response LByteString -> LByteString
forall body. Response body -> body
NC.responseBody Response LByteString
rsp
  case LByteString -> Either String HealStartResp
forall a. FromJSON a => LByteString -> Either String a
eitherDecode LByteString
rspBS of
    Right HealStartResp
hsr -> HealStartResp -> Minio HealStartResp
forall (m :: * -> *) a. Monad m => a -> m a
return HealStartResp
hsr
    Left String
err -> MErrV -> Minio HealStartResp
forall (m :: * -> *) e a. (MonadIO m, Exception e) => e -> m a
throwIO (MErrV -> Minio HealStartResp) -> MErrV -> Minio HealStartResp
forall a b. (a -> b) -> a -> b
$ Text -> MErrV
MErrVJsonParse (Text -> MErrV) -> Text -> MErrV
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack String
err

-- | Start a heal sequence that scans data under given (possible empty)
-- `bucket` and `prefix`. The `recursive` bool turns on recursive
-- traversal under the given path. `dryRun` does not mutate on-disk data,
-- but performs data validation. Two heal sequences on overlapping paths
-- may not be initiated. The progress of a heal should be followed using
-- the `HealStatus` API. The server accumulates results of the heal
-- traversal and waits for the client to receive and acknowledge
-- them using the status API
startHeal :: Maybe Bucket -> Maybe Text -> HealOpts -> Minio HealStartResp
startHeal :: Maybe Text -> Maybe Text -> HealOpts -> Minio HealStartResp
startHeal Maybe Text
bucket Maybe Text
prefix HealOpts
opts = Maybe Text -> Maybe Text -> HealOpts -> Bool -> Minio HealStartResp
doHeal Maybe Text
bucket Maybe Text
prefix HealOpts
opts Bool
False

-- | Similar to start a heal sequence, but force start a new heal sequence
-- even if an active heal is under progress.
forceStartHeal :: Maybe Bucket -> Maybe Text -> HealOpts -> Minio HealStartResp
forceStartHeal :: Maybe Text -> Maybe Text -> HealOpts -> Minio HealStartResp
forceStartHeal Maybe Text
bucket Maybe Text
prefix HealOpts
opts = Maybe Text -> Maybe Text -> HealOpts -> Bool -> Minio HealStartResp
doHeal Maybe Text
bucket Maybe Text
prefix HealOpts
opts Bool
True

-- | Fetches information for all cluster nodes, such as server
-- properties, storage information, network statistics, etc.
getServerInfo :: Minio [ServerInfo]
getServerInfo :: Minio [ServerInfo]
getServerInfo = do
  Response LByteString
rsp <-
    AdminReqInfo -> Minio (Response LByteString)
executeAdminRequest
      AdminReqInfo :: ByteString
-> Maybe ByteString
-> Payload
-> ByteString
-> [Header]
-> Query
-> AdminReqInfo
AdminReqInfo
        { ariMethod :: ByteString
ariMethod = ByteString
HT.methodGet,
          ariPayload :: Payload
ariPayload = ByteString -> Payload
PayloadBS ByteString
B.empty,
          ariPayloadHash :: Maybe ByteString
ariPayloadHash = Maybe ByteString
forall a. Maybe a
Nothing,
          ariPath :: ByteString
ariPath = ByteString
"v1/info",
          ariHeaders :: [Header]
ariHeaders = [],
          ariQueryParams :: Query
ariQueryParams = []
        }
  let rspBS :: LByteString
rspBS = Response LByteString -> LByteString
forall body. Response body -> body
NC.responseBody Response LByteString
rsp
  case LByteString -> Either String [ServerInfo]
forall a. FromJSON a => LByteString -> Either String a
eitherDecode LByteString
rspBS of
    Right [ServerInfo]
si -> [ServerInfo] -> Minio [ServerInfo]
forall (m :: * -> *) a. Monad m => a -> m a
return [ServerInfo]
si
    Left String
err -> MErrV -> Minio [ServerInfo]
forall (m :: * -> *) e a. (MonadIO m, Exception e) => e -> m a
throwIO (MErrV -> Minio [ServerInfo]) -> MErrV -> Minio [ServerInfo]
forall a b. (a -> b) -> a -> b
$ Text -> MErrV
MErrVJsonParse (Text -> MErrV) -> Text -> MErrV
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack String
err

executeAdminRequest :: AdminReqInfo -> Minio (Response LByteString)
executeAdminRequest :: AdminReqInfo -> Minio (Response LByteString)
executeAdminRequest AdminReqInfo
ari = do
  Request
req <- AdminReqInfo -> Minio Request
buildAdminRequest AdminReqInfo
ari
  Manager
mgr <- (MinioConn -> Manager) -> Minio Manager
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks MinioConn -> Manager
mcConnManager
  Request -> Manager -> Minio (Response LByteString)
forall (m :: * -> *).
MonadIO m =>
Request -> Manager -> m (Response LByteString)
httpLbs Request
req Manager
mgr

buildAdminRequest :: AdminReqInfo -> Minio NC.Request
buildAdminRequest :: AdminReqInfo -> Minio Request
buildAdminRequest AdminReqInfo
areq = do
  ConnectInfo
ci <- (MinioConn -> ConnectInfo) -> Minio ConnectInfo
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks MinioConn -> ConnectInfo
mcConnInfo
  ByteString
sha256Hash <-
    if ConnectInfo -> Bool
connectIsSecure ConnectInfo
ci
      then -- if secure connection
        ByteString -> Minio ByteString
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
"UNSIGNED-PAYLOAD"
      else -- otherwise compute sha256
        Payload -> Minio ByteString
getPayloadSHA256Hash (AdminReqInfo -> Payload
ariPayload AdminReqInfo
areq)

  UTCTime
timeStamp <- IO UTCTime -> Minio UTCTime
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO UTCTime
getCurrentTime

  let hostHeader :: Header
hostHeader = (HeaderName
hHost, ConnectInfo -> ByteString
getHostAddr ConnectInfo
ci)
      newAreq :: AdminReqInfo
newAreq =
        AdminReqInfo
areq
          { ariPayloadHash :: Maybe ByteString
ariPayloadHash = ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just ByteString
sha256Hash,
            ariHeaders :: [Header]
ariHeaders =
              Header
hostHeader
                Header -> [Header] -> [Header]
forall a. a -> [a] -> [a]
: ByteString -> Header
sha256Header ByteString
sha256Hash
                Header -> [Header] -> [Header]
forall a. a -> [a] -> [a]
: AdminReqInfo -> [Header]
ariHeaders AdminReqInfo
areq
          }
      signReq :: Request
signReq = ConnectInfo -> AdminReqInfo -> Request
toRequest ConnectInfo
ci AdminReqInfo
newAreq
      sp :: SignParams
sp =
        Text
-> Text
-> UTCTime
-> Maybe Text
-> Maybe Int
-> Maybe ByteString
-> SignParams
SignParams
          (ConnectInfo -> Text
connectAccessKey ConnectInfo
ci)
          (ConnectInfo -> Text
connectSecretKey ConnectInfo
ci)
          UTCTime
timeStamp
          Maybe Text
forall a. Maybe a
Nothing
          Maybe Int
forall a. Maybe a
Nothing
          (AdminReqInfo -> Maybe ByteString
ariPayloadHash AdminReqInfo
newAreq)
      signHeaders :: [(ByteString, ByteString)]
signHeaders = SignParams -> Request -> [(ByteString, ByteString)]
signV4 SignParams
sp Request
signReq

  -- Update signReq with Authorization header containing v4 signature
  Request -> Minio Request
forall (m :: * -> *) a. Monad m => a -> m a
return
    Request
signReq
      { requestHeaders :: [Header]
NC.requestHeaders = AdminReqInfo -> [Header]
ariHeaders AdminReqInfo
newAreq [Header] -> [Header] -> [Header]
forall a. [a] -> [a] -> [a]
++ [(ByteString, ByteString)] -> [Header]
mkHeaderFromPairs [(ByteString, ByteString)]
signHeaders
      }
  where
    toRequest :: ConnectInfo -> AdminReqInfo -> NC.Request
    toRequest :: ConnectInfo -> AdminReqInfo -> Request
toRequest ConnectInfo
ci AdminReqInfo
aReq =
      Request
NC.defaultRequest
        { method :: ByteString
NC.method = AdminReqInfo -> ByteString
ariMethod AdminReqInfo
aReq,
          secure :: Bool
NC.secure = ConnectInfo -> Bool
connectIsSecure ConnectInfo
ci,
          host :: ByteString
NC.host = Text -> ByteString
forall a b. ConvertUtf8 a b => a -> b
encodeUtf8 (Text -> ByteString) -> Text -> ByteString
forall a b. (a -> b) -> a -> b
$ ConnectInfo -> Text
connectHost ConnectInfo
ci,
          port :: Int
NC.port = ConnectInfo -> Int
connectPort ConnectInfo
ci,
          path :: ByteString
NC.path = ByteString -> [ByteString] -> ByteString
B.intercalate ByteString
"/" [ByteString
adminPath, AdminReqInfo -> ByteString
ariPath AdminReqInfo
aReq],
          requestHeaders :: [Header]
NC.requestHeaders = AdminReqInfo -> [Header]
ariHeaders AdminReqInfo
aReq,
          queryString :: ByteString
NC.queryString = Bool -> Query -> ByteString
HT.renderQuery Bool
False (Query -> ByteString) -> Query -> ByteString
forall a b. (a -> b) -> a -> b
$ AdminReqInfo -> Query
ariQueryParams AdminReqInfo
aReq,
          requestBody :: RequestBody
NC.requestBody = Payload -> RequestBody
getRequestBody (AdminReqInfo -> Payload
ariPayload AdminReqInfo
aReq)
        }