{-# 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, Post, FormUrlEncoded, Header) import Data.ByteString (ByteString) import GHC.Generics (Generic) import Servant (Handler, err404, fieldLink, toUrlPiece) 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, isEnabled) 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, rangeSuffix) import Katip (KatipContextT, Katip, runKatipContextT, LogEnv, KatipContext, ls, Severity (..), logFM, katipAddContext, sl) import Data.Aeson (ToJSON (toJSON), FromJSON, object, (.=)) import Lucid (ToHtml, toHtml, renderBS, toHtmlRaw, HtmlT, Attributes) import qualified Lucid.Html5 as H5 import qualified Data.Map.Strict as M import Data.Foldable (for_) import qualified Data.Text as T import Web.FormUrlEncoded (FromForm, fromForm, parseUnique) import Lucid.Base (makeAttributes) import Data.Aeson.Key (fromText) data ImagePng instance MimeRender ImagePng GraphPng where mimeRender _ (GraphPng bs) = BS.fromStrict bs instance Accept ImagePng where contentType _ = "image" // "png" -- `servant-lucid` package would provide this and the instance for the original lucid(1) package -- but we have lucid2 data HTML instance Accept HTML where contentType _ = "text" // "html" instance ToHtml a => MimeRender HTML a where mimeRender _ = renderBS . toHtml newtype StatsPage = StatsPage (forall m. Monad m => HtmlT m ()) instance ToHtml StatsPage where toHtml (StatsPage inner) = inner toHtmlRaw = toHtml page_ :: Monad m => HtmlT m () -> HtmlT m () page_ inner = H5.doctypehtml_ $ do H5.head_ $ do H5.script_ [ H5.src_ "https://cdn.jsdelivr.net/npm/htmx.org@2.0.11/dist/htmx.min.js" , H5.integrity_ "sha384-2OatzQy1H+Zd/IIrjr1TcuDGqLXeHhbooAyJY1KdQMKnr4LZ22k31GBLdYKHmVjg" , H5.crossorigin_ "anonymous" ] ("" :: Text) H5.style_ css H5.body_ inner css :: Text css = T.unlines [ "body { font-family: system-ui, sans-serif; margin: 1rem auto; max-width: 40rem; padding: 0 1rem; }" , "table { border-collapse: collapse; }" , "th, td { padding: 0.4rem 0.75rem; border-bottom: 1px solid #ddd; text-align: left; }" , "input[type=submit] { padding: 0.25rem 0.75rem; cursor: pointer; }" , "img { max-width: 100%; }" ] type HxRequest = Header "HX-Request" Bool data API mode = API { getMetrics :: mode :- "metrics" :> Capture "graph" Graph :> QueryParam "range" Range :> Get '[ImagePng] GraphPng , getStats :: mode :- "stats" :> HxRequest :> QueryParam "range" Range :> Get '[HTML] StatsPage , getFlags :: mode :- "flags" :> Get '[JSON, HTML] FlagsResponse , putFlag :: mode :- "flags" :> Capture "name" Text :> ReqBody '[JSON, FormUrlEncoded] FlagValue :> Put '[HTML, JSON] FlagResponse , postFlag :: mode :- "flags" :> Capture "name" Text :> ReqBody '[JSON, FormUrlEncoded] FlagValue :> Post '[JSON, HTML] FlagResponse } deriving Generic newtype GraphPng = GraphPng ByteString newtype FlagValue = FlagValue Bool deriving FromJSON via Bool instance FromForm FlagValue where fromForm f = FlagValue <$> parseUnique "flag-value" f newtype FlagsResponse = FlagsResponse (Map Text Bool) deriving (ToJSON) via (Map Text Bool) data FlagResponse = FlagResponse Text Bool instance ToHtml FlagResponse where toHtml (FlagResponse name value) = flagRow name value toHtmlRaw = toHtml instance ToJSON FlagResponse where toJSON (FlagResponse k v) = object [fromText k .= v] flagsPage :: Monad m => FlagsResponse -> HtmlT m () flagsPage (FlagsResponse f) = page_ $ H5.table_ $ do H5.tr_ $ do H5.th_ "Name" H5.th_ "Value" H5.th_ "" for_ (M.toList f) $ uncurry flagRow flagRow :: Monad m => Text -> Bool -> HtmlT m () flagRow name value = H5.tr_ [H5.id_ (rowId name)] $ do H5.td_ (toHtml name) H5.td_ (toHtml (if value then "on" else "off" :: Text)) H5.td_ (toggle name value) where toggle :: Monad m => Text -> Bool -> HtmlT m () toggle key current = H5.form_ [H5.method_ "post", H5.action_ (postFlagsLink key)] $ do H5.input_ [H5.name_ "flag-value", H5.type_ "hidden", H5.value_ (T.pack (show (not current)))] H5.input_ [ H5.type_ "submit" , H5.value_ (if current then "Disable" else "Enable") , hxTrigger "click" , hxTarget ("#" <> rowId key) , hxPut (postFlagsLink key) , hxSwap "outerHTML" ] postFlagsLink k = "/" <> toUrlPiece (fieldLink putFlag k) rowId :: Text -> Text rowId = ("status-" <>) hxTrigger :: Text -> Attributes hxTrigger = makeAttributes "hx-trigger" hxTarget :: Text -> Attributes hxTarget = makeAttributes "hx-target" hxPut :: Text -> Attributes hxPut = makeAttributes "hx-put" hxGet :: Text -> Attributes hxGet = makeAttributes "hx-get" hxPushUrl :: Text -> Attributes hxPushUrl = makeAttributes "hx-push-url" hxSwap :: Text -> Attributes hxSwap = makeAttributes "hx-swap" instance ToHtml FlagsResponse where toHtml = flagsPage toHtmlRaw = toHtml getFlagsHandler :: Flags -> LoggingHandler FlagsResponse getFlagsHandler = fmap FlagsResponse . allFlags putFlagHandler :: Flags -> Text -> FlagValue -> LoggingHandler FlagResponse putFlagHandler flags name (FlagValue val) | name `S.notMember` validNames flags = throwM err404 | otherwise = checkpoint (Annotation (name, val)) $ katipAddContext (sl "flag" (name, val)) $ do setEnabled flags name val `catch` \e -> do logFM ErrorS (ls ("failed to persist handler flag: " <> show (e :: SomeException))) throwM err500 FlagResponse name <$> isEnabled flags name getMetricsHandler :: FilePath -> FilePath -> Graph -> Maybe Range -> LoggingHandler GraphPng 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 . GraphPng) g -- server :: FilePath -> FilePath -> API AsServer server :: FilePath -> FilePath -> Flags -> ServerT (NamedRoutes API) LoggingHandler server rrdPath rrdtool flags = API { getMetrics = getMetricsHandler rrdPath rrdtool , getStats = getStatsHandler , getFlags = getFlagsHandler flags , putFlag = putFlagHandler flags , postFlag = putFlagHandler flags -- This exists only for html forms } statsPage :: Maybe Bool -> Maybe Range -> StatsPage statsPage hx r = StatsPage $ if hx == Just True then statsContent r else page_ (statsContent r) statsContent :: Monad m => Maybe Range -> HtmlT m () statsContent r = H5.div_ [H5.id_ "stats"] $ do H5.ul_ $ for_ [minBound..maxBound] $ \range -> H5.li_ $ H5.a_ (link range) $ toHtml $ rangeSuffix range H5.h2_ "Traffic" H5.img_ [H5.src_ (src Traffic)] H5.h2_ "Memory" H5.img_ [H5.src_ (src Memory)] H5.h2_ "Ratelimit" H5.img_ [H5.src_ (src RateLimit)] where src m = "/" <> toUrlPiece (fieldLink getMetrics m r) link range = let url = "/" <> toUrlPiece (fieldLink getStats (Just range)) in [ H5.href_ url , hxGet url , hxTarget "#stats" , hxSwap "outerHTML" , hxPushUrl "true" ] getStatsHandler :: Maybe Bool -> Maybe Range -> LoggingHandler StatsPage getStatsHandler hx r = pure (statsPage hx r) 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