{-# 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