88 lines
3.5 KiB
Haskell
88 lines
3.5 KiB
Haskell
{-# LANGUAGE OverloadedStrings #-}
|
|
{-# LANGUAGE DerivingVia #-}
|
|
module HttpServer where
|
|
|
|
import Control.Monad (forever)
|
|
import Control.Monad.IO.Class (liftIO, MonadIO)
|
|
import qualified Data.ByteString as BS
|
|
import Data.Void (Void)
|
|
import Network.Wai.Handler.Warp (run)
|
|
import Servant.API ((:>), Capture, Get, QueryParam, (:-), MimeRender (..), Accept (..), NamedRoutes, JSON, ReqBody, Put)
|
|
import Data.ByteString (ByteString)
|
|
import GHC.Generics (Generic)
|
|
import Servant (Handler, err404)
|
|
import Control.Monad.Catch (throwM, catch, MonadCatch, MonadThrow, SomeException)
|
|
import Servant.Server (err500, ServerT)
|
|
import Data.Maybe (fromMaybe)
|
|
import Data.Map.Strict (Map)
|
|
import qualified Data.Set as S
|
|
import Data.Text (Text)
|
|
import HomeAssistant.Runtime.Flags (Flags, allFlags, setEnabled, validNames)
|
|
import Control.Exception.Annotated (checkpoint, Annotation (Annotation))
|
|
import Servant.Server.Generic (genericServeT)
|
|
import Network.Wai (Application)
|
|
import Network.HTTP.Media ((//))
|
|
import HomeAssistant.Runtime.Graphing (Graph, Range (..), lookupGraph, graphs, renderGraph)
|
|
import Katip (KatipContextT, Katip, runKatipContextT, LogEnv, KatipContext, ls, Severity (..), logFM)
|
|
|
|
data ImagePng
|
|
|
|
instance MimeRender ImagePng ByteString where
|
|
mimeRender _ = BS.fromStrict
|
|
|
|
instance Accept ImagePng where
|
|
contentType _ = "image" // "png"
|
|
|
|
|
|
data API mode = API
|
|
{ getMetrics :: mode :- "metrics" :> Capture "graph" Graph :> QueryParam "range" Range :> Get '[ImagePng] ByteString
|
|
, getFlags :: mode :- "flags" :> Get '[JSON] (Map Text Bool)
|
|
, putFlag :: mode :- "flags" :> Capture "name" Text :> ReqBody '[JSON] Bool :> Put '[JSON] (Map Text Bool)
|
|
}
|
|
deriving Generic
|
|
|
|
|
|
getFlagsHandler :: Flags -> LoggingHandler (Map Text Bool)
|
|
getFlagsHandler flags = allFlags flags
|
|
|
|
putFlagHandler :: Flags -> Text -> Bool -> LoggingHandler (Map Text Bool)
|
|
putFlagHandler flags name val
|
|
| name `S.notMember` validNames flags = throwM err404
|
|
| otherwise = do
|
|
setEnabled flags name val `catch` \e -> do
|
|
logFM ErrorS (ls ("failed to persist handler flag: " <> show (e :: SomeException)))
|
|
throwM err500
|
|
allFlags flags
|
|
|
|
|
|
getMetricsHandler :: FilePath -> FilePath -> Graph -> Maybe Range -> LoggingHandler ByteString
|
|
getMetricsHandler rrdPath rrdtool graphMode mRange = checkpoint (Annotation (graphMode, mRange)) $ do
|
|
case lookupGraph graphs graphMode of
|
|
Nothing -> throwM err404
|
|
Just spec -> do
|
|
let range = fromMaybe OneDay mRange
|
|
g <- renderGraph rrdPath rrdtool spec range
|
|
either (\e -> logFM ErrorS (ls e) >> throwM err500) pure g
|
|
|
|
-- server :: FilePath -> FilePath -> API AsServer
|
|
server :: FilePath -> FilePath -> Flags -> ServerT (NamedRoutes API) LoggingHandler
|
|
server rrdPath rrdtool flags = API
|
|
{ getMetrics = getMetricsHandler rrdPath rrdtool
|
|
, getFlags = getFlagsHandler flags
|
|
, putFlag = putFlagHandler flags
|
|
}
|
|
|
|
servantApp :: LogEnv -> FilePath -> FilePath -> Flags -> Application
|
|
servantApp le rrdPath rrdtool flags = genericServeT (toHandler le) (server rrdPath rrdtool flags)
|
|
|
|
runHttpServer :: MonadIO m => LogEnv -> FilePath -> FilePath -> Flags -> Int -> m Void
|
|
runHttpServer le rrdPath rrdtool flags port = liftIO $ forever $ run port (servantApp le rrdPath rrdtool flags)
|
|
|
|
newtype LoggingHandler a = LoggingHandler (KatipContextT Handler a)
|
|
deriving (Functor, Applicative, Monad, MonadIO, Katip, KatipContext, MonadCatch, MonadThrow) via (KatipContextT Handler)
|
|
|
|
toHandler :: LogEnv -> (forall a. LoggingHandler a -> Handler a)
|
|
toHandler le (LoggingHandler k) = runKatipContextT le () "http" k
|
|
|
|
|