243 lines
8.6 KiB
Haskell
243 lines
8.6 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, 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
|
|
|
|
|
|
|