kenshou-core-0.1.0.0: src/Kenshou/Core/Role.hs
module Kenshou.Core.Role
( RoleName,
WorkerRole (..),
PostgresConnInfo (..),
WorkerInit (..),
ControlMessage (..),
WorkerMessage (..),
RoleContext (..),
mkRoleName,
renderRoleName,
)
where
import Data.Aeson
import Data.Aeson.Types (Pair, Parser)
import Data.Int (Int64)
import Data.Map.Strict (Map)
import Data.Map.Strict qualified as Map
import Data.Text (Text)
import Data.Text qualified as Text
import Data.Time (UTCTime)
import Kenshou.Core.Dimension (Dimensions)
import Kenshou.Core.Id (RunId, ScenarioId, Seed)
import Kenshou.Core.Knob (ResolvedKnobs)
import Kenshou.Core.Log (Logger)
import Kenshou.Core.Phase (PhaseName (..), renderPhaseName)
import Kenshou.Core.Resource.Types (ResourceName)
import Kenshou.Core.RunSpec (withLegacyResource)
newtype RoleName = RoleName Text deriving stock (Eq, Ord, Show)
data WorkerRole = WorkerRole
{ name :: RoleName,
summary :: Text,
run :: RoleContext -> IO ()
}
data PostgresConnInfo = PostgresConnInfo {connectionString :: Text, adminConnectionString :: Text} deriving stock (Eq, Show)
data WorkerInit = WorkerInit
{ runId :: RunId,
scenario :: ScenarioId,
role :: RoleName,
instanceName :: Text,
seed :: Seed,
knobs :: ResolvedKnobs,
dimensions :: Dimensions,
postgres :: Maybe PostgresConnInfo,
resources :: Map ResourceName Value,
telemetry :: Maybe Value,
outDir :: FilePath,
args :: Value
}
deriving stock (Eq, Show)
data ControlMessage = CtlInit WorkerInit | CtlStart | CtlPhase PhaseName | CtlStop Int | CtlCustom Text Value deriving stock (Eq, Show)
data WorkerMessage = WrkReady | WrkProgress Int64 UTCTime | WrkFacts [Value] | WrkCustom Text Value | WrkDone (Maybe Text) | WrkError Text deriving stock (Eq, Show)
data RoleContext = RoleContext
{ init :: WorkerInit,
receive :: IO (Maybe ControlMessage),
send :: WorkerMessage -> IO (),
logger :: Logger
}
mkRoleName :: Text -> Either Text RoleName
mkRoleName value = case Text.splitOn "/" value of
[layer, role] | not (Text.null layer) && not (Text.null role) -> Right (RoleName value)
_ -> Left "role name must be <layer>/<name>"
renderRoleName :: RoleName -> Text
renderRoleName (RoleName value) = value
instance ToJSON RoleName where toJSON = toJSON . renderRoleName
instance FromJSON RoleName where parseJSON = withText "RoleName" (either (fail . Text.unpack) pure . mkRoleName)
instance ToJSON PostgresConnInfo where toJSON value = object ["connectionString" .= value.connectionString, "adminConnectionString" .= value.adminConnectionString]
instance FromJSON PostgresConnInfo where parseJSON = withObject "PostgresConnInfo" \value -> PostgresConnInfo <$> value .: "connectionString" <*> value .: "adminConnectionString"
instance ToJSON WorkerInit where
toJSON value = object ["schema" .= ("kenshou.worker-init/v1" :: Text), "runId" .= value.runId, "scenario" .= value.scenario, "role" .= value.role, "instance" .= value.instanceName, "seed" .= value.seed, "knobs" .= value.knobs, "dimensions" .= value.dimensions, "postgres" .= value.postgres, "resources" .= value.resources, "telemetry" .= value.telemetry, "outDir" .= value.outDir, "args" .= value.args]
instance FromJSON WorkerInit where
parseJSON = withObject "WorkerInit" \value -> do
schema <- value .: "schema"
if schema /= ("kenshou.worker-init/v1" :: Text) then fail "unsupported worker-init schema" else pure ()
resources <- (value .:? "resources" .!= Map.empty) >>= withLegacyResource "worker-init" value
WorkerInit <$> value .: "runId" <*> value .: "scenario" <*> value .: "role" <*> value .: "instance" <*> value .: "seed" <*> value .: "knobs" <*> value .: "dimensions" <*> value .:? "postgres" <*> pure resources <*> value .:? "telemetry" <*> value .: "outDir" <*> value .: "args"
instance ToJSON ControlMessage where
toJSON (CtlInit value) = tagged "init" ["init" .= value]
toJSON CtlStart = tagged "start" []
toJSON (CtlPhase name) = tagged "phase" ["name" .= renderPhaseName name]
toJSON (CtlStop grace) = tagged "stop" ["graceMillis" .= grace]
toJSON (CtlCustom name payload) = tagged "custom" ["name" .= name, "payload" .= payload]
instance FromJSON ControlMessage where
parseJSON = withObject "ControlMessage" \value -> do
version <- value .: "v"
if version /= (1 :: Int) then fail "unsupported worker protocol version" else pure ()
messageType <- value .: "type" :: Parser Text
case messageType of
"init" -> CtlInit <$> value .: "init"
"start" -> pure CtlStart
"phase" -> CtlPhase <$> (value .: "name" >>= parsePhase)
"stop" -> CtlStop <$> value .: "graceMillis"
"custom" -> CtlCustom <$> value .: "name" <*> value .: "payload"
_ -> fail "unknown control message"
instance ToJSON WorkerMessage where
toJSON WrkReady = tagged "ready" []
toJSON (WrkProgress count at) = tagged "progress" ["count" .= count, "at" .= at]
toJSON (WrkFacts batch) = tagged "facts" ["batch" .= batch]
toJSON (WrkCustom name payload) = tagged "custom" ["name" .= name, "payload" .= payload]
toJSON (WrkDone detail) = tagged "done" ["detail" .= detail]
toJSON (WrkError message) = tagged "error" ["message" .= message]
instance FromJSON WorkerMessage where
parseJSON = withObject "WorkerMessage" \value -> do
version <- value .: "v"
if version /= (1 :: Int) then fail "unsupported worker protocol version" else pure ()
messageType <- value .: "type" :: Parser Text
case messageType of
"ready" -> pure WrkReady
"progress" -> WrkProgress <$> value .: "count" <*> value .: "at"
"facts" -> WrkFacts <$> value .: "batch"
"custom" -> WrkCustom <$> value .: "name" <*> value .: "payload"
"done" -> WrkDone <$> value .:? "detail"
"error" -> WrkError <$> value .: "message"
_ -> fail "unknown worker message"
tagged :: Text -> [Pair] -> Value
tagged messageType fields = object (["v" .= (1 :: Int), "type" .= messageType] <> fields)
parsePhase :: Text -> Parser PhaseName
parsePhase "warm-up" = pure WarmUp
parsePhase "steady" = pure Steady
parsePhase "drain" = pure Drain
parsePhase _ = fail "unknown phase"