kenshou-core-0.1.0.0: src/Kenshou/Core/RunSpec/Resolve.hs
module Kenshou.Core.RunSpec.Resolve (SpecError (..), resolveRunSpec) where
import Data.Aeson (Value)
import Data.List.NonEmpty (NonEmpty (..))
import Data.Map.Strict (Map)
import Data.Map.Strict qualified as Map
import Data.Text (Text)
import Data.Text qualified as Text
import Kenshou.Core.Bundle (Registry, lookupResource, lookupScenario)
import Kenshou.Core.Dimension (resolveDimensions)
import Kenshou.Core.Env (EnvRequirements (..), PostgresRequirement (..))
import Kenshou.Core.Id (mkSeed, newRunId)
import Kenshou.Core.Knob (resolveKnobs)
import Kenshou.Core.Phase (PhasePlan (..))
import Kenshou.Core.Resource (ResourceName, ResourceProvider (..), renderResourceName)
import Kenshou.Core.RunSpec
import Kenshou.Core.RunSpec qualified as RunSpec
import Kenshou.Core.Scenario (Placement (..), Scenario (..), Tier (..))
import System.Info qualified as System
import System.Random (randomIO)
newtype SpecError = SpecError Text deriving stock (Eq, Show)
resolveRunSpec :: Registry -> RunSpec -> IO (Either (NonEmpty SpecError) (Scenario, EffectiveRunSpec))
resolveRunSpec registry spec = case lookupScenario registry spec.scenario of
Nothing -> pure (Left (SpecError ("unknown scenario " <> Text.pack (show spec.scenario)) :| []))
Just scenario -> do
generatedRunId <- maybe newRunId pure spec.runId
randomSeed <- randomIO
let seedResult = maybe (mkSeed (randomSeed `mod` 9007199254740992)) Right spec.seed
knobsResult = resolveKnobs scenario.knobs spec.knobs
dimensionsResult = resolveDimensions scenario.dimensions spec.dimensions
pure do
checkedSeed <- firstOne seedResult
checkedKnobs <- mapErrors knobsResult
checkedDimensions <- mapErrors dimensionsResult
if maybe True (== scenario.revision) spec.scenarioRevision then pure () else Left (SpecError "scenario revision does not match registry" :| [])
validatePlacement scenario.placement spec.environment.placement
validatePostgres scenario spec.environment.postgres
validateExtraPostgres scenario spec.environment.extraPostgres
resources <- resolveResources registry scenario spec.environment.resources
let environment = (applyEnvironmentDefaults scenario spec.environment) {RunSpec.resources = resources}
phases = maybe scenario.phases id spec.phases
effective = EffectiveRunSpec generatedRunId scenario.id scenario.revision checkedKnobs checkedDimensions checkedSeed phases (maybe (tierTimeout scenario.tier phases) id spec.timeoutSeconds) environment spec.cohortExpectation spec.comparison spec.labels
pure (scenario, effective)
where
firstOne :: Either Text value -> Either (NonEmpty SpecError) value
firstOne = either (Left . (:| []) . SpecError) Right
mapErrors :: (Show problem) => Either (NonEmpty problem) value -> Either (NonEmpty SpecError) value
mapErrors = either (Left . fmap (SpecError . Text.pack . show)) Right
-- | Every resource the specification names must be required by the scenario, and
-- every required resource's value is normalized by its registered provider, so the
-- effective specification records the complete value.
resolveResources :: Registry -> Scenario -> Map ResourceName Value -> Either (NonEmpty SpecError) (Map ResourceName Value)
resolveResources registry scenario supplied = do
case [name | name <- Map.keys supplied, name `notElem` scenario.requires.resources] of
[] -> pure ()
extra : _ -> Left (SpecError ("environment names a resource the scenario does not require: " <> renderResourceName extra) :| [])
normalized <- traverse normalizeOne scenario.requires.resources
pure (Map.fromList normalized)
where
normalizeOne name = case lookupResource registry name of
Nothing -> Left (SpecError ("no registered provider for resource " <> renderResourceName name) :| [])
Just provider -> either (\problem -> Left (SpecError ("resource " <> renderResourceName name <> ": " <> problem) :| [])) (Right . (name,)) (provider.normalize (Map.lookup name supplied))
validatePlacement :: Placement -> SpecPlacement -> Either (NonEmpty SpecError) ()
validatePlacement PlaceCell RunLocal = Left (SpecError "scenario requires cell placement" :| [])
validatePlacement PlaceLocal RunOnCell = Left (SpecError "scenario requires local placement" :| [])
validatePlacement _ _ = Right ()
validatePostgres :: Scenario -> Maybe PostgresSpec -> Either (NonEmpty SpecError) ()
validatePostgres scenario postgresSpec = case (scenario.requires.postgres, postgresSpec) of
(Nothing, Just _) -> Left (SpecError "PostgreSQL is not applicable to this scenario" :| [])
(Just requirement, Just (PostgresExternal _)) | requirement.needsServerControl -> Left (SpecError "scenario requires control of an ephemeral PostgreSQL server" :| [])
_ -> Right ()
validateExtraPostgres :: Scenario -> Map.Map Text PostgresSpec -> Either (NonEmpty SpecError) ()
validateExtraPostgres scenario supplied =
case errors of
[] -> Right ()
first : rest -> Left (first :| rest)
where
required = Map.fromList scenario.requires.extraPostgres
unknown = Map.keys (supplied `Map.difference` required)
controlErrors =
[ SpecError ("extra PostgreSQL " <> name <> " requires an ephemeral server")
| (name, requirement) <- Map.toList required,
requirement.needsServerControl,
Just (PostgresExternal _) <- [Map.lookup name supplied]
]
errors = fmap (SpecError . ("unknown extra PostgreSQL environment " <>)) unknown <> controlErrors
applyEnvironmentDefaults :: Scenario -> EnvironmentSpec -> EnvironmentSpec
applyEnvironmentDefaults scenario environment =
environment
{ machineProfile = Just (maybe ("local/" <> Text.pack System.os <> "-" <> Text.pack System.arch) id environment.machineProfile),
postgres = case (scenario.requires.postgres, environment.postgres) of (Just _, Nothing) -> Just (PostgresEphemeral []); (_, existing) -> existing,
extraPostgres = Map.union environment.extraPostgres (Map.fromList [(name, PostgresEphemeral []) | (name, _) <- scenario.requires.extraPostgres])
}
tierTimeout :: Tier -> PhasePlan -> Int
tierTimeout TierSmoke _ = 120
tierTimeout TierStandard _ = 1200
tierTimeout TierExtended _ = 7200
tierTimeout TierSoak phases = ceiling (phases.warmUpSeconds + phases.steadySeconds + phases.drainSeconds) + 1800