packages feed

kenshou-core-0.1.0.0: src/Kenshou/Plan/Catalog.hs

{-# LANGUAGE FieldSelectors #-}

module Kenshou.Plan.Catalog
  ( ScenarioInfo (..),
    CatalogDocument (..),
    fromScenario,
    fromBundles,
    readCatalogFile,
    decodeCatalog,
  )
where

import Data.Aeson
import Data.Aeson.Key qualified as Key
import Data.Aeson.KeyMap qualified as KeyMap
import Data.Aeson.Types (Parser)
import Data.Bifunctor (first)
import Data.ByteString (ByteString)
import Data.ByteString qualified as ByteString
import Data.List.NonEmpty (NonEmpty (..))
import Data.Text (Text)
import Data.Text qualified as Text
import Kenshou.Core.Bundle (LayerBundle, allScenarios, mkRegistry)
import Kenshou.Core.Dimension
import Kenshou.Core.Id (ScenarioId)
import Kenshou.Core.Knob
import Kenshou.Core.Scenario

data ScenarioInfo = ScenarioInfo
  { id :: ScenarioId,
    revision :: Int,
    summary :: Text,
    tier :: Tier,
    placement :: Placement,
    knobs :: [KnobSpec],
    dimensions :: DimensionSupport,
    knownDefect :: Maybe KnownDefect
  }
  deriving stock (Eq, Show)

newtype CatalogDocument = CatalogDocument {scenarios :: [ScenarioInfo]}
  deriving stock (Eq, Show)

fromScenario :: Scenario -> ScenarioInfo
fromScenario scenario =
  ScenarioInfo
    { id = scenario.id,
      revision = scenario.revision,
      summary = scenario.summary,
      tier = scenario.tier,
      placement = scenario.placement,
      knobs = scenario.knobs,
      dimensions = scenario.dimensions,
      knownDefect = scenario.knownDefect
    }

fromBundles :: [LayerBundle] -> [ScenarioInfo]
fromBundles bundles = case mkRegistry bundles of
  Left _ -> []
  Right registry -> fmap fromScenario (allScenarios registry)

readCatalogFile :: FilePath -> IO (Either Text [ScenarioInfo])
readCatalogFile path = decodeCatalog <$> ByteString.readFile path

decodeCatalog :: ByteString -> Either Text [ScenarioInfo]
decodeCatalog bytes = first Text.pack do
  document <- eitherDecodeStrict' bytes :: Either String CatalogDocument
  pure document.scenarios

instance FromJSON CatalogDocument where
  parseJSON = withObject "CatalogDocument" \value -> do
    schema <- value .:? "schema" .!= ("kenshou.scenario-list/v1" :: Text)
    if schema /= "kenshou.scenario-list/v1" then fail "unsupported catalog schema" else pure ()
    CatalogDocument <$> value .: "scenarios"

instance ToJSON CatalogDocument where
  toJSON document = object ["schema" .= ("kenshou.scenario-list/v1" :: Text), "scenarios" .= document.scenarios, "roles" .= ([] :: [Value])]

instance FromJSON ScenarioInfo where
  parseJSON = withObject "ScenarioInfo" \value ->
    ScenarioInfo
      <$> value .: "id"
      <*> value .:? "revision" .!= 1
      <*> value .:? "summary" .!= ""
      <*> (value .:? "tier" .!= "smoke" >>= parseTier)
      <*> (value .:? "placement" .!= "either" >>= parsePlacement)
      <*> value .:? "knobs" .!= []
      <*> value .:? "dimensions" .!= noDimensions
      <*> pure Nothing

instance ToJSON ScenarioInfo where
  toJSON scenario =
    object
      [ "id" .= scenario.id,
        "revision" .= scenario.revision,
        "summary" .= scenario.summary,
        "tier" .= renderTier scenario.tier,
        "placement" .= renderPlacement scenario.placement,
        "knobs" .= scenario.knobs,
        "dimensions" .= scenario.dimensions,
        "knownDefect" .= fmap defectReferences scenario.knownDefect
      ]
    where
      defectReferences defect = case individualKnownDefects defect of
        [single] -> toJSON single.reference
        many -> toJSON (fmap (.reference) many)

parseTier :: Text -> Parser Tier
parseTier = \case
  "smoke" -> pure TierSmoke
  "standard" -> pure TierStandard
  "extended" -> pure TierExtended
  "soak" -> pure TierSoak
  value -> fail ("unknown tier " <> Text.unpack value)

parsePlacement :: Text -> Parser Placement
parsePlacement = \case
  "local" -> pure PlaceLocal
  "cell" -> pure PlaceCell
  "either" -> pure PlaceEither
  value -> fail ("unknown placement " <> Text.unpack value)

instance ToJSON KnobSpec where
  toJSON spec =
    object
      [ "name" .= spec.name,
        "summary" .= spec.summary,
        "type" .= knobTypeText spec.knobType,
        "default" .= spec.def,
        "allowed" .= allowedValue spec.allowed,
        "variants" .= spec.variants
      ]

instance FromJSON KnobSpec where
  parseJSON = withObject "KnobSpec" \value -> do
    name <- value .: "name"
    summary <- value .:? "summary" .!= ""
    knobType <- value .: "type" >>= parseKnobType
    def <- value .: "default"
    allowed <- value .:? "allowed" >>= maybe (pure AnyValue) parseAllowed
    variants <- value .:? "variants" .!= []
    pure KnobSpec {name, summary, knobType, def, allowed, variants}

knobTypeText :: KnobType -> Text
knobTypeText KnobBool = "bool"
knobTypeText KnobInt = "int"
knobTypeText KnobDouble = "double"
knobTypeText KnobText = "text"

parseKnobType :: Text -> Parser KnobType
parseKnobType = \case
  "bool" -> pure KnobBool
  "int" -> pure KnobInt
  "double" -> pure KnobDouble
  "text" -> pure KnobText
  value -> fail ("unknown knob type " <> Text.unpack value)

allowedValue :: Allowed -> Value
allowedValue AnyValue = object ["kind" .= ("any" :: Text)]
allowedValue (OneOf values) = object ["kind" .= ("one-of" :: Text), "values" .= values]
allowedValue (IntRange low high) = object ["kind" .= ("int-range" :: Text), "min" .= low, "max" .= high]
allowedValue (DoubleRange low high) = object ["kind" .= ("double-range" :: Text), "min" .= low, "max" .= high]

parseAllowed :: Value -> Parser Allowed
parseAllowed = withObject "Allowed" \value ->
  value .: "kind" >>= \case
    ("any" :: Text) -> pure AnyValue
    "one-of" -> do
      values <- value .: "values"
      case values of [] -> fail "one-of must not be empty"; first : rest -> pure (OneOf (first :| rest))
    "int-range" -> IntRange <$> value .: "min" <*> value .: "max"
    "double-range" -> DoubleRange <$> value .: "min" <*> value .: "max"
    other -> fail ("unknown allowed kind " <> Text.unpack other)

instance ToJSON DimensionSupport where
  toJSON support =
    object
      [ "telemetry.tracing" .= supported renderTracing support.tracing,
        "telemetry.metrics" .= supported renderMetrics support.metrics,
        "pg.durability" .= supported renderDurability support.pgDurability,
        "pg.version" .= supported renderVersion support.pgVersion
      ]
    where
      supported _ NotApplicable = Null
      supported render (Supported value) = object ["values" .= fmap render value.values, "default" .= render value.def]

instance FromJSON DimensionSupport where
  parseJSON = withObject "DimensionSupport" \value ->
    DimensionSupport
      <$> parseSupported value "telemetry.tracing" parseTracing
      <*> parseSupported value "telemetry.metrics" parseMetrics
      <*> parseSupported value "pg.durability" parseDurability
      <*> parseSupported value "pg.version" parseVersion
    where
      parseSupported objectValue name parse = case KeyMap.lookup (Key.fromText name) objectValue of
        Nothing -> pure NotApplicable
        Just Null -> pure NotApplicable
        Just raw ->
          withObject
            "Support"
            ( \supportValue -> do
                rawValues <- supportValue .: "values"
                rawDefault <- supportValue .: "default"
                values <- traverse (maybe (fail ("unknown value in " <> Text.unpack name)) pure . parse) rawValues
                def <- maybe (fail ("unknown default in " <> Text.unpack name)) pure (parse rawDefault)
                case values of [] -> fail "dimension support must not be empty"; first : rest -> pure (Supported (Support (first :| rest) def))
            )
            raw