--
-- MinIO Haskell SDK, (C) 2018-2023 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.Credentials
import Network.Minio.Data
import Network.Minio.Errors
import Network.Minio.Sign.V4
import Network.Minio.Utils

data DriveInfo = DriveInfo
  { DriveInfo -> Bucket
diUuid :: Text,
    DriveInfo -> Bucket
diEndpoint :: Text,
    DriveInfo -> Bucket
diState :: Text
  }
  deriving stock (Int -> DriveInfo -> ShowS
[DriveInfo] -> ShowS
DriveInfo -> String
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
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 = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"DriveInfo" forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Bucket -> Bucket -> Bucket -> DriveInfo
DriveInfo
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"uuid"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"endpoint"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        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
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
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
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
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 = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ErasureInfo" forall a b. (a -> b) -> a -> b
$ \Object
v -> do
    Int
onlineDisks <- Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"OnlineDisks"
    Int
offlineDisks <- Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"OfflineDisks"
    StorageClass
stdClass <-
      Int -> Int -> StorageClass
StorageClass
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v
          forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"StandardSCData"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
          forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"StandardSCParity"
    StorageClass
rrClass <-
      Int -> Int -> StorageClass
StorageClass
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v
          forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"RRSCData"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
          forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"RRSCParity"
    [[DriveInfo]]
sets <- Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"Sets"
    forall (m :: * -> *) a. Monad m => a -> m a
return 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
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
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 = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Backend" forall a b. (a -> b) -> a -> b
$ \Object
v -> do
    Int
typ <- Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"Type"
    case Int
typ :: Int of
      Int
1 -> forall (m :: * -> *) a. Monad m => a -> m a
return Backend
BackendFS
      Int
2 -> ErasureInfo -> Backend
BackendErasure forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. FromJSON a => Value -> Parser a
parseJSON (Object -> Value
Object Object
v)
      Int
_ -> 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
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
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 = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ConnStats" forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Int64 -> Int64 -> ConnStats
ConnStats
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"transferred"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"received"

data ServerProps = ServerProps
  { ServerProps -> NominalDiffTime
spUptime :: NominalDiffTime,
    ServerProps -> Bucket
spVersion :: Text,
    ServerProps -> Bucket
spCommitId :: Text,
    ServerProps -> Bucket
spRegion :: Text,
    ServerProps -> [Bucket]
spSqsArns :: [Text]
  }
  deriving stock (Int -> ServerProps -> ShowS
[ServerProps] -> ShowS
ServerProps -> String
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
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 = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"SIServer" forall a b. (a -> b) -> a -> b
$ \Object
v -> do
    NominalDiffTime
uptimeNs <- Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"uptime"
    let uptime :: NominalDiffTime
uptime = NominalDiffTime
uptimeNs forall a. Fractional a => a -> a -> a
/ NominalDiffTime
1e9
    Bucket
ver <- Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"version"
    Bucket
commitId <- Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"commitID"
    Bucket
region <- Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"region"
    [Bucket]
arn <- Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sqsARN"
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ NominalDiffTime
-> Bucket -> Bucket -> Bucket -> [Bucket] -> ServerProps
ServerProps NominalDiffTime
uptime Bucket
ver Bucket
commitId Bucket
region [Bucket]
arn

data StorageInfo = StorageInfo
  { StorageInfo -> Int64
siUsed :: Int64,
    StorageInfo -> Backend
siBackend :: Backend
  }
  deriving stock (Int -> StorageInfo -> ShowS
[StorageInfo] -> ShowS
StorageInfo -> String
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
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 = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"StorageInfo" forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Int64 -> Backend -> StorageInfo
StorageInfo
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"Used"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"Backend"

data CountNAvgTime = CountNAvgTime
  { CountNAvgTime -> Int64
caCount :: Int64,
    CountNAvgTime -> Bucket
caAvgDuration :: Text
  }
  deriving stock (Int -> CountNAvgTime -> ShowS
[CountNAvgTime] -> ShowS
CountNAvgTime -> String
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
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 = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"CountNAvgTime" forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Int64 -> Bucket -> CountNAvgTime
CountNAvgTime
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"count"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        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
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
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 = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"HttpStats" forall a b. (a -> b) -> a -> b
$ \Object
v ->
    CountNAvgTime
-> CountNAvgTime
-> CountNAvgTime
-> CountNAvgTime
-> CountNAvgTime
-> CountNAvgTime
-> CountNAvgTime
-> CountNAvgTime
-> CountNAvgTime
-> CountNAvgTime
-> HttpStats
HttpStats
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"totalHEADs"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"successHEADs"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"totalGETs"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"successGETs"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"totalPUTs"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"successPUTs"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"totalPOSTs"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"successPOSTs"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"totalDELETEs"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        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
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
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 = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"SIData" forall a b. (a -> b) -> a -> b
$ \Object
v ->
    StorageInfo -> ConnStats -> HttpStats -> ServerProps -> SIData
SIData
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"storage"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"network"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"http"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"server"

data ServerInfo = ServerInfo
  { ServerInfo -> Bucket
siError :: Text,
    ServerInfo -> Bucket
siAddr :: Text,
    ServerInfo -> SIData
siData :: SIData
  }
  deriving stock (Int -> ServerInfo -> ShowS
[ServerInfo] -> ShowS
ServerInfo -> String
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
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 = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ServerInfo" forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Bucket -> Bucket -> SIData -> ServerInfo
ServerInfo
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"error"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"addr"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"data"

data ServerVersion = ServerVersion
  { ServerVersion -> Bucket
svVersion :: Text,
    ServerVersion -> Bucket
svCommitId :: Text
  }
  deriving stock (Int -> ServerVersion -> ShowS
[ServerVersion] -> ShowS
ServerVersion -> String
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
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 = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ServerVersion" forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Bucket -> Bucket -> ServerVersion
ServerVersion
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"version"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        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
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
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 = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ServiceStatus" forall a b. (a -> b) -> a -> b
$ \Object
v -> do
    ServerVersion
serverVersion <- Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"serverVersion"
    NominalDiffTime
uptimeNs <- Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"uptime"
    let uptime :: NominalDiffTime
uptime = NominalDiffTime
uptimeNs forall a. Fractional a => a -> a -> a
/ NominalDiffTime
1e9
    forall (m :: * -> *) a. Monad m => a -> m a
return 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
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
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" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= ServiceAction -> Bucket
serviceActionToText ServiceAction
a]

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

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

data HealStartResp = HealStartResp
  { HealStartResp -> Bucket
hsrClientToken :: Text,
    HealStartResp -> Bucket
hsrClientAddr :: Text,
    HealStartResp -> UTCTime
hsrStartTime :: UTCTime
  }
  deriving stock (Int -> HealStartResp -> ShowS
[HealStartResp] -> ShowS
HealStartResp -> String
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
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 = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"HealStartResp" forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Bucket -> Bucket -> UTCTime -> HealStartResp
HealStartResp
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"clientToken"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"clientAddress"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        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
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
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" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Bool
r, Key
"dryRun" 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" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Bool
r forall a. Semigroup a => a -> a -> a
<> Key
"dryRun" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Bool
d)

instance FromJSON HealOpts where
  parseJSON :: Value -> Parser HealOpts
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"HealOpts" forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Bool -> Bool -> HealOpts
HealOpts
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"recursive"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        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
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
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 = forall a. String -> (Bucket -> Parser a) -> Value -> Parser a
withText String
"HealItemType" forall a b. (a -> b) -> a -> b
$ \Bucket
v -> case Bucket
v of
    Bucket
"metadata" -> forall (m :: * -> *) a. Monad m => a -> m a
return HealItemType
HealItemMetadata
    Bucket
"bucket" -> forall (m :: * -> *) a. Monad m => a -> m a
return HealItemType
HealItemBucket
    Bucket
"object" -> forall (m :: * -> *) a. Monad m => a -> m a
return HealItemType
HealItemObject
    Bucket
"bucket-metadata" -> forall (m :: * -> *) a. Monad m => a -> m a
return HealItemType
HealItemBucketMetadata
    Bucket
_ -> forall a. String -> Value -> Parser a
typeMismatch String
"HealItemType" (Bucket -> Value
A.String Bucket
v)

data NodeSummary = NodeSummary
  { NodeSummary -> Bucket
nsName :: Text,
    NodeSummary -> Bool
nsErrSet :: Bool,
    NodeSummary -> Bucket
nsErrMessage :: Text
  }
  deriving stock (Int -> NodeSummary -> ShowS
[NodeSummary] -> ShowS
NodeSummary -> String
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
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 = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"NodeSummary" forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Bucket -> Bool -> Bucket -> NodeSummary
NodeSummary
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"errSet"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        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
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
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 = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"SetConfigResult" forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Bool -> [NodeSummary] -> SetConfigResult
SetConfigResult
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"status"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"nodeResults"

data HealResultItem = HealResultItem
  { HealResultItem -> Int
hriResultIdx :: Int,
    HealResultItem -> HealItemType
hriType :: HealItemType,
    HealResultItem -> Bucket
hriBucket :: Bucket,
    HealResultItem -> Bucket
hriObject :: Object,
    HealResultItem -> Bucket
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
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
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 = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"HealResultItem" forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Int
-> HealItemType
-> Bucket
-> Bucket
-> Bucket
-> Maybe Int
-> Maybe Int
-> Int
-> Int
-> Int
-> [DriveInfo]
-> [DriveInfo]
-> HealResultItem
HealResultItem
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"resultId"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"bucket"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"object"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"detail"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"parityBlocks"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"dataBlocks"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"diskCount"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"setCount"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"objectSize"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ( do
              Object
before <- Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"before"
              Object
before forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"drives"
          )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ( do
              Object
after <- Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"after"
              Object
after forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"drives"
          )

data HealStatus = HealStatus
  { HealStatus -> Bucket
hsSummary :: Text,
    HealStatus -> UTCTime
hsStartTime :: UTCTime,
    HealStatus -> HealOpts
hsSettings :: HealOpts,
    HealStatus -> Int
hsNumDisks :: Int,
    HealStatus -> Maybe Bucket
hsFailureDetail :: Maybe Text,
    HealStatus -> Maybe [HealResultItem]
hsItems :: Maybe [HealResultItem]
  }
  deriving stock (Int -> HealStatus -> ShowS
[HealStatus] -> ShowS
HealStatus -> String
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
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 = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"HealStatus" forall a b. (a -> b) -> a -> b
$ \Object
v ->
    Bucket
-> UTCTime
-> HealOpts
-> Int
-> Maybe Bucket
-> Maybe [HealResultItem]
-> HealStatus
HealStatus
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"Summary"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"StartTime"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"Settings"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"NumDisks"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"Detail"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v
        forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"Items"

healPath :: Maybe Bucket -> Maybe Text -> ByteString
healPath :: Maybe Bucket -> Maybe Bucket -> ByteString
healPath Maybe Bucket
bucket Maybe Bucket
prefix = do
  if forall a. Maybe a -> Bool
isJust Maybe Bucket
bucket
    then
      forall a b. ConvertUtf8 a b => a -> b
encodeUtf8 forall a b. (a -> b) -> a -> b
$
        Bucket
"v1/heal/"
          forall a. Semigroup a => a -> a -> a
<> forall a. a -> Maybe a -> a
fromMaybe Bucket
"" Maybe Bucket
bucket
          forall a. Semigroup a => a -> a -> a
<> Bucket
"/"
          forall a. Semigroup a => a -> a -> a
<> forall a. a -> Maybe a -> a
fromMaybe Bucket
"" Maybe Bucket
prefix
    else forall a b. ConvertUtf8 a b => a -> b
encodeUtf8 (Bucket
"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
        { ariMethod :: ByteString
ariMethod = ByteString
HT.methodGet,
          ariPayload :: Payload
ariPayload = ByteString -> Payload
PayloadBS ByteString
B.empty,
          ariPayloadHash :: Maybe ByteString
ariPayloadHash = forall a. Maybe a
Nothing,
          ariPath :: ByteString
ariPath = ByteString
"v1/service",
          ariHeaders :: [Header]
ariHeaders = [],
          ariQueryParams :: Query
ariQueryParams = []
        }

  let rspBS :: LByteString
rspBS = forall body. Response body -> body
NC.responseBody Response LByteString
rsp
  case forall a. FromJSON a => LByteString -> Either String a
eitherDecode LByteString
rspBS of
    Right ServiceStatus
ss -> forall (m :: * -> *) a. Monad m => a -> m a
return ServiceStatus
ss
    Left String
err -> forall (m :: * -> *) e a. (MonadIO m, Exception e) => e -> m a
throwIO forall a b. (a -> b) -> a -> b
$ Bucket -> MErrV
MErrVJsonParse forall a b. (a -> b) -> a -> b
$ String -> Bucket
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 forall a b. (a -> b) -> a -> b
$ LByteString -> ByteString
LBS.toStrict forall a b. (a -> b) -> a -> b
$ forall a. ToJSON a => a -> LByteString
A.encode ServiceAction
action
  forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$
    AdminReqInfo -> Minio (Response LByteString)
executeAdminRequest
      AdminReqInfo
        { ariMethod :: ByteString
ariMethod = ByteString
HT.methodPost,
          ariPayload :: Payload
ariPayload = Payload
payload,
          ariPayloadHash :: Maybe ByteString
ariPayloadHash = 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
        { ariMethod :: ByteString
ariMethod = ByteString
HT.methodGet,
          ariPayload :: Payload
ariPayload = ByteString -> Payload
PayloadBS ByteString
B.empty,
          ariPayloadHash :: Maybe ByteString
ariPayloadHash = forall a. Maybe a
Nothing,
          ariPath :: ByteString
ariPath = ByteString
"v1/config",
          ariHeaders :: [Header]
ariHeaders = [],
          ariQueryParams :: Query
ariQueryParams = []
        }
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ LByteString -> ByteString
LBS.toStrict forall a b. (a -> b) -> a -> b
$ 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
        { ariMethod :: ByteString
ariMethod = ByteString
HT.methodPut,
          ariPayload :: Payload
ariPayload = ByteString -> Payload
PayloadBS ByteString
config,
          ariPayloadHash :: Maybe ByteString
ariPayloadHash = forall a. Maybe a
Nothing,
          ariPath :: ByteString
ariPath = ByteString
"v1/config",
          ariHeaders :: [Header]
ariHeaders = [],
          ariQueryParams :: Query
ariQueryParams = []
        }

  let rspBS :: LByteString
rspBS = forall body. Response body -> body
NC.responseBody Response LByteString
rsp
  case forall a. FromJSON a => LByteString -> Either String a
eitherDecode LByteString
rspBS of
    Right SetConfigResult
scr -> forall (m :: * -> *) a. Monad m => a -> m a
return SetConfigResult
scr
    Left String
err -> forall (m :: * -> *) e a. (MonadIO m, Exception e) => e -> m a
throwIO forall a b. (a -> b) -> a -> b
$ Bucket -> MErrV
MErrVJsonParse forall a b. (a -> b) -> a -> b
$ String -> Bucket
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 Bucket -> Maybe Bucket -> Bucket -> Minio HealStatus
getHealStatus Maybe Bucket
bucket Maybe Bucket
prefix Bucket
token = do
  forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (forall a. Maybe a -> Bool
isNothing Maybe Bucket
bucket Bool -> Bool -> Bool
&& forall a. Maybe a -> Bool
isJust Maybe Bucket
prefix) forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) e a. (MonadIO m, Exception e) => e -> m a
throwIO MErrV
MErrVInvalidHealPath
  let qparams :: Query
qparams = QueryText -> Query
HT.queryTextToQuery [(Bucket
"clientToken", forall a. a -> Maybe a
Just Bucket
token)]
  Response LByteString
rsp <-
    AdminReqInfo -> Minio (Response LByteString)
executeAdminRequest
      AdminReqInfo
        { ariMethod :: ByteString
ariMethod = ByteString
HT.methodPost,
          ariPayload :: Payload
ariPayload = ByteString -> Payload
PayloadBS ByteString
B.empty,
          ariPayloadHash :: Maybe ByteString
ariPayloadHash = forall a. Maybe a
Nothing,
          ariPath :: ByteString
ariPath = Maybe Bucket -> Maybe Bucket -> ByteString
healPath Maybe Bucket
bucket Maybe Bucket
prefix,
          ariHeaders :: [Header]
ariHeaders = [],
          ariQueryParams :: Query
ariQueryParams = Query
qparams
        }
  let rspBS :: LByteString
rspBS = forall body. Response body -> body
NC.responseBody Response LByteString
rsp
  case forall a. FromJSON a => LByteString -> Either String a
eitherDecode LByteString
rspBS of
    Right HealStatus
hs -> forall (m :: * -> *) a. Monad m => a -> m a
return HealStatus
hs
    Left String
err -> forall (m :: * -> *) e a. (MonadIO m, Exception e) => e -> m a
throwIO forall a b. (a -> b) -> a -> b
$ Bucket -> MErrV
MErrVJsonParse forall a b. (a -> b) -> a -> b
$ String -> Bucket
T.pack String
err

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

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

  let rspBS :: LByteString
rspBS = forall body. Response body -> body
NC.responseBody Response LByteString
rsp
  case forall a. FromJSON a => LByteString -> Either String a
eitherDecode LByteString
rspBS of
    Right HealStartResp
hsr -> forall (m :: * -> *) a. Monad m => a -> m a
return HealStartResp
hsr
    Left String
err -> forall (m :: * -> *) e a. (MonadIO m, Exception e) => e -> m a
throwIO forall a b. (a -> b) -> a -> b
$ Bucket -> MErrV
MErrVJsonParse forall a b. (a -> b) -> a -> b
$ String -> Bucket
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 Bucket -> Maybe Bucket -> HealOpts -> Minio HealStartResp
startHeal Maybe Bucket
bucket Maybe Bucket
prefix HealOpts
opts = Maybe Bucket
-> Maybe Bucket -> HealOpts -> Bool -> Minio HealStartResp
doHeal Maybe Bucket
bucket Maybe Bucket
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 Bucket -> Maybe Bucket -> HealOpts -> Minio HealStartResp
forceStartHeal Maybe Bucket
bucket Maybe Bucket
prefix HealOpts
opts = Maybe Bucket
-> Maybe Bucket -> HealOpts -> Bool -> Minio HealStartResp
doHeal Maybe Bucket
bucket Maybe Bucket
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
        { ariMethod :: ByteString
ariMethod = ByteString
HT.methodGet,
          ariPayload :: Payload
ariPayload = ByteString -> Payload
PayloadBS ByteString
B.empty,
          ariPayloadHash :: Maybe ByteString
ariPayloadHash = forall a. Maybe a
Nothing,
          ariPath :: ByteString
ariPath = ByteString
"v1/info",
          ariHeaders :: [Header]
ariHeaders = [],
          ariQueryParams :: Query
ariQueryParams = []
        }
  let rspBS :: LByteString
rspBS = forall body. Response body -> body
NC.responseBody Response LByteString
rsp
  case forall a. FromJSON a => LByteString -> Either String a
eitherDecode LByteString
rspBS of
    Right [ServerInfo]
si -> forall (m :: * -> *) a. Monad m => a -> m a
return [ServerInfo]
si
    Left String
err -> forall (m :: * -> *) e a. (MonadIO m, Exception e) => e -> m a
throwIO forall a b. (a -> b) -> a -> b
$ Bucket -> MErrV
MErrVJsonParse forall a b. (a -> b) -> a -> b
$ String -> Bucket
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 <- forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks MinioConn -> Manager
mcConnManager
  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 <- 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
        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 <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO UTCTime
getCurrentTime

  Manager
mgr <- forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks MinioConn -> Manager
mcConnManager
  CredentialValue
cv <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ Creds -> Endpoint -> Manager -> IO CredentialValue
getCredential (ConnectInfo -> Creds
connectCreds ConnectInfo
ci) (ConnectInfo -> Endpoint
getEndpoint ConnectInfo
ci) Manager
mgr

  let hostHeader :: Header
hostHeader = (HeaderName
hHost, ConnectInfo -> ByteString
getHostAddr ConnectInfo
ci)
      newAreq :: AdminReqInfo
newAreq =
        AdminReqInfo
areq
          { ariPayloadHash :: Maybe ByteString
ariPayloadHash = forall a. a -> Maybe a
Just ByteString
sha256Hash,
            ariHeaders :: [Header]
ariHeaders =
              Header
hostHeader
                forall a. a -> [a] -> [a]
: ByteString -> Header
sha256Header ByteString
sha256Hash
                forall a. a -> [a] -> [a]
: AdminReqInfo -> [Header]
ariHeaders AdminReqInfo
areq
          }
      signReq :: Request
signReq = ConnectInfo -> AdminReqInfo -> Request
toRequest ConnectInfo
ci AdminReqInfo
newAreq
      sp :: SignParams
sp =
        Bucket
-> ScrubbedBytes
-> Maybe ScrubbedBytes
-> Service
-> UTCTime
-> Maybe Bucket
-> Maybe Int
-> Maybe ByteString
-> SignParams
SignParams
          (coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ CredentialValue -> AccessKey
cvAccessKey CredentialValue
cv)
          (coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ CredentialValue -> SecretKey
cvSecretKey CredentialValue
cv)
          (coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ CredentialValue -> Maybe SessionToken
cvSessionToken CredentialValue
cv)
          Service
ServiceS3
          UTCTime
timeStamp
          forall a. Maybe a
Nothing
          forall a. Maybe a
Nothing
          (AdminReqInfo -> Maybe ByteString
ariPayloadHash AdminReqInfo
newAreq)
      signHeaders :: [Header]
signHeaders = SignParams -> Request -> [Header]
signV4 SignParams
sp Request
signReq

  -- Update signReq with Authorization header containing v4 signature
  forall (m :: * -> *) a. Monad m => a -> m a
return
    Request
signReq
      { requestHeaders :: [Header]
NC.requestHeaders = AdminReqInfo -> [Header]
ariHeaders AdminReqInfo
newAreq forall a. [a] -> [a] -> [a]
++ [Header]
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 = forall a b. ConvertUtf8 a b => a -> b
encodeUtf8 forall a b. (a -> b) -> a -> b
$ ConnectInfo -> Bucket
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 forall a b. (a -> b) -> a -> b
$ AdminReqInfo -> Query
ariQueryParams AdminReqInfo
aReq,
          requestBody :: RequestBody
NC.requestBody = Payload -> RequestBody
getRequestBody (AdminReqInfo -> Payload
ariPayload AdminReqInfo
aReq)
        }