packages feed

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

{-# LANGUAGE FieldSelectors #-}

module Kenshou.Plan.Suite
  ( SuiteMode (..),
    SuiteExclusion (..),
    SuiteSelection (..),
    PolicyPatch (..),
    Suite (..),
    readSuite,
    decodeSuite,
    suitePolicy,
    applySuite,
  )
where

import Control.Applicative ((<|>))
import Data.Aeson
import Data.Aeson.Types (Parser)
import Data.Bifunctor (first)
import Data.ByteString (ByteString)
import Data.ByteString qualified as ByteString
import Data.List.NonEmpty qualified as NonEmpty
import Data.Set qualified as Set
import Data.Text (Text)
import Data.Text qualified as Text
import Kenshou.Core.Id (Seed, parseKind)
import Kenshou.Core.RunSpec (SpecPlacement (..))
import Kenshou.Core.Scenario (Tier (..))
import Kenshou.Plan.Catalog (ScenarioInfo)
import Kenshou.Plan.Change
import Kenshou.Plan.Policy
import Kenshou.Plan.Policy qualified as Policy
import Kenshou.Plan.Selector

data SuiteMode = SuiteAll | SuiteChanged deriving stock (Eq, Show)

data SuiteExclusion = SuiteExclusion {select :: Selector, why :: Text}
  deriving stock (Eq, Show)

data SuiteSelection = SuiteSelection
  { mode :: SuiteMode,
    always :: [Selector],
    exclude :: [SuiteExclusion]
  }
  deriving stock (Eq, Show)

data PolicyPatch = PolicyPatch
  { maxTier :: Maybe Tier,
    kinds :: Maybe [Text],
    placement :: Maybe SpecPlacement,
    dimensionPolicy :: Maybe DimensionPolicy,
    knobPolicy :: Maybe KnobPolicy,
    trials :: Maybe Int,
    budgetMinutes :: Maybe Int
  }
  deriving stock (Eq, Show)

data Suite = Suite
  { name :: Text,
    description :: Text,
    selection :: SuiteSelection,
    policy :: PolicyPatch,
    directlyChanged :: Maybe PolicyPatch
  }
  deriving stock (Eq, Show)

readSuite :: FilePath -> IO (Either Text Suite)
readSuite path = decodeSuite <$> ByteString.readFile path

decodeSuite :: ByteString -> Either Text Suite
decodeSuite = first Text.pack . eitherDecodeStrict'

suitePolicy :: Seed -> Suite -> Either Text PlanPolicy
suitePolicy seed suite = applyPatch suite.policy (defaultPlanPolicy seed)

applySuite :: Suite -> [ScenarioInfo] -> [Selected] -> [Selected]
applySuite suite catalog changed = applyDirectlyChanged (applySelectors [] exclusions (base <> alwaysSelected))
  where
    base = case suite.selection.mode of SuiteAll -> selectAll catalog; SuiteChanged -> changed
    alwaysSelected = selectBySelectors Everything ("suite " <> suite.name <> " always") suite.selection.always catalog
    exclusions = fmap (.select) suite.selection.exclude
    applyDirectlyChanged = case suite.directlyChanged of
      Nothing -> id
      Just patch -> fmap (raiseDirect patch)
    raiseDirect patch selected
      | minimum (fmap (.distance) (NonEmpty.toList selected.reasons)) == 0 =
          selected
            { minPolicy = fmap (renderDimensionPolicy . max (maybe DefaultOnly parseMinimum selected.minPolicy)) patch.dimensionPolicy <|> selected.minPolicy,
              minKnobPolicy = fmap (renderKnobPolicy . max (maybe KnobDefaults parseMinimumKnob selected.minKnobPolicy)) patch.knobPolicy <|> selected.minKnobPolicy
            }
      | otherwise = selected
    parseMinimum value = maybe DefaultOnly (\parsed -> parsed) (parseDimensionPolicy value)
    parseMinimumKnob value = maybe KnobDefaults (\parsed -> parsed) (parseKnobPolicy value)

applyPatch :: PolicyPatch -> PlanPolicy -> Either Text PlanPolicy
applyPatch patch base = do
  kinds <- maybe (Right base.kinds) (fmap Set.fromList . traverse parseKind) patch.kinds
  pure
    base
      { Policy.maxTier = maybe base.maxTier (\value -> value) patch.maxTier,
        Policy.kinds = kinds,
        Policy.placement = maybe base.placement (\value -> value) patch.placement,
        Policy.dimensionPolicy = maybe base.dimensionPolicy (\value -> value) patch.dimensionPolicy,
        Policy.knobPolicy = maybe base.knobPolicy (\value -> value) patch.knobPolicy,
        Policy.trials = maybe base.trials (\value -> value) patch.trials,
        Policy.budgetMinutes = patch.budgetMinutes <|> base.budgetMinutes
      }

instance FromJSON Suite where
  parseJSON = withObject "Suite" \value -> do
    schema <- value .: "schema"
    if schema /= ("kenshou.suite/v1" :: Text) then fail "unsupported suite schema" else pure ()
    Suite <$> value .: "name" <*> value .: "description" <*> value .: "selection" <*> value .: "policy" <*> value .:? "directlyChanged"

instance FromJSON SuiteSelection where
  parseJSON = withObject "SuiteSelection" \value -> SuiteSelection <$> (value .: "mode" >>= parseMode) <*> (value .:? "always" .!= [] >>= traverse parseSelectorValue) <*> value .:? "exclude" .!= []
    where
      parseMode ("all" :: Text) = pure SuiteAll
      parseMode "changed" = pure SuiteChanged
      parseMode other = fail ("unknown suite mode " <> Text.unpack other)

instance FromJSON SuiteExclusion where
  parseJSON = withObject "SuiteExclusion" \value -> SuiteExclusion <$> (value .: "select" >>= parseSelectorValue) <*> value .: "why"

instance FromJSON PolicyPatch where
  parseJSON = withObject "PolicyPatch" \value ->
    PolicyPatch
      <$> (value .:? "maxTier" >>= traverse parseTier)
      <*> value .:? "kinds"
      <*> (value .:? "placement" >>= traverse parsePlacement)
      <*> (value .:? "dimensionPolicy" >>= traverse parseDimension)
      <*> (value .:? "knobPolicy" >>= traverse parseKnob)
      <*> value .:? "trials"
      <*> value .:? "budgetMinutes"
    where
      parseTier "smoke" = pure TierSmoke
      parseTier "standard" = pure TierStandard
      parseTier "extended" = pure TierExtended
      parseTier "soak" = pure TierSoak
      parseTier other = fail ("unknown tier " <> Text.unpack other)
      parsePlacement "local" = pure RunLocal
      parsePlacement "cell" = pure RunOnCell
      parsePlacement other = fail ("unknown placement " <> Text.unpack other)
      parseDimension raw = maybe (fail ("unknown dimension policy " <> Text.unpack raw)) pure (parseDimensionPolicy raw)
      parseKnob raw = maybe (fail ("unknown knob policy " <> Text.unpack raw)) pure (parseKnobPolicy raw)

parseSelectorValue :: Text -> Parser Selector
parseSelectorValue = either (fail . Text.unpack) pure . parseSelector