packages feed

kenshou-evidence-0.1.0.0: src/Kenshou/Evidence/Frontmatter.hs

module Kenshou.Evidence.Frontmatter
  ( EvidenceRecord (..),
    ComparisonEvidence (..),
    AttestationEvidence (..),
    AttestationCheck (..),
    FieldError (..),
    recordToDocument,
    comparisonToDocument,
    attestationToDocument,
    recordFromDocument,
    comparisonFromDocument,
  )
where

import Data.Aeson (FromJSON (..), Result (..), ToJSON (..), Value (..), fromJSON, object, withObject, withText, (.:), (.:?), (.=))
import Data.Aeson.Types (Parser)
import Data.Text (Text)
import Data.Text qualified as Text
import Data.Word (Word64)
import Kenshou.Core.Id (ScenarioId (..), renderKind, renderLayer, renderScenarioId, unSegment)
import Kenshou.Core.Outcome (Outcome, renderOutcome)
import Kenshou.Evidence.Types (ComponentRef (..), ComponentSource (..), DataKind (..), DataLink (..), Purpose (..), Revision (..), Sha256 (..), SubjectKind (..), mkRevision, mkSha256)
import Okf.Actor (Actor (ProcessActor, ProducerActor), parseActor)
import Okf.Document (Generated (..), OKFDocument (..), OkfCommon (..), frontmatterLookup, okfCommon, readGenerated, setField, setGenerated)

newtype FieldError = FieldError Text deriving stock (Eq, Show)

data EvidenceRecord = EvidenceRecord
  { title :: !Text,
    description :: !Text,
    generatedAt :: !Text,
    runId :: !Text,
    purpose :: !Purpose,
    scenario :: !ScenarioId,
    tier :: !Text,
    placement :: !Text,
    outcome :: !Outcome,
    startedAt :: !Text,
    finishedAt :: !Text,
    subject :: !Text,
    subjectKind :: !SubjectKind,
    harnessRevision :: !Revision,
    harnessDirty :: !Bool,
    computations :: ![Text],
    dataLinks :: ![DataLink],
    cohort :: !Text,
    solverPlanHash :: !Sha256,
    components :: ![ComponentRef],
    environment :: !Value,
    seed :: !Word64,
    compatibilityKey :: !Sha256,
    knobs :: ![(Text, Value)],
    dimensions :: ![(Text, Text)],
    knownDefects :: ![Text],
    produced :: ![Text],
    previousRun :: !(Maybe Text),
    body :: !Text
  }
  deriving stock (Eq, Show)

data ComparisonEvidence = ComparisonEvidence
  { title :: !Text,
    description :: !Text,
    generatedAt :: !Text,
    runId :: !Text,
    purpose :: !Purpose,
    scenario :: !ScenarioId,
    tier :: !Text,
    placement :: !Text,
    outcome :: !Outcome,
    startedAt :: !Text,
    finishedAt :: !Text,
    subject :: !Text,
    subjectKind :: !SubjectKind,
    harnessRevision :: !Revision,
    harnessDirty :: !Bool,
    computations :: ![Text],
    dataLinks :: ![DataLink],
    comparison :: !Value,
    body :: !Text
  }
  deriving stock (Eq, Show)

data AttestationCheck = AttestationCheck
  { name :: !Text,
    result :: !Text,
    detail :: !(Maybe Text)
  }
  deriving stock (Eq, Show)

instance ToJSON AttestationCheck where
  toJSON check = object (["name" .= check.name, "result" .= check.result] <> maybe [] (\detail -> ["detail" .= detail]) check.detail)

data AttestationEvidence = AttestationEvidence
  { title :: !Text,
    description :: !Text,
    generatedAt :: !Text,
    attestationId :: !Text,
    run :: !Text,
    attesterRevision :: !Revision,
    attestedAt :: !Text,
    verdict :: !Text,
    checks :: ![AttestationCheck],
    dataDigests :: ![Sha256],
    exception :: !(Maybe Value),
    body :: !Text
  }
  deriving stock (Eq, Show)

attestationToDocument :: AttestationEvidence -> OKFDocument
attestationToDocument record =
  OKFDocument
    { frontmatter = foldl (\front (name, value) -> setField name value front) generated fields,
      body = record.body
    }
  where
    generated =
      setGenerated
        Generated {generatedBy = ProcessActor "kenshou-attester/0.1.0.0", generatedAt = Just record.generatedAt}
        (okfCommon OkfCommon {commonType = "Attestation", commonTitle = Just record.title, commonDescription = Just record.description, commonTimestamp = Nothing})
    fields =
      [ ("attestationId", String record.attestationId),
        ("run", String record.run),
        ("attester", String "process:kenshou-attester/0.1.0.0"),
        ("attesterRevision", toJSON record.attesterRevision),
        ("attestedAt", String record.attestedAt),
        ("verdict", String record.verdict),
        ("checks", toJSON record.checks),
        ("dataDigests", toJSON record.dataDigests)
      ]
        <> maybe [] (\value -> [("exception", value)]) record.exception

comparisonToDocument :: ComparisonEvidence -> OKFDocument
comparisonToDocument record =
  OKFDocument
    { frontmatter = foldl (\front (name, value) -> setField name value front) generated fields,
      body = record.body
    }
  where
    generated =
      setGenerated
        Generated {generatedBy = ProducerActor "kenshou-record" "0.1.0.0", generatedAt = Just record.generatedAt}
        (okfCommon OkfCommon {commonType = "Verification Run", commonTitle = Just record.title, commonDescription = Just record.description, commonTimestamp = Nothing})
    scenarioId = record.scenario
    fields =
      [ ("runId", toJSON record.runId),
        ("recordKind", String "comparison"),
        ("purpose", String (purposeText record.purpose)),
        ("scenario", String (renderScenarioId scenarioId)),
        ("layer", String (renderLayer scenarioId.layer)),
        ("component", String (unSegment scenarioId.component)),
        ("kind", String (renderKind scenarioId.kind)),
        ("tier", String record.tier),
        ("placement", String record.placement),
        ("outcome", String (renderOutcome record.outcome)),
        ("startedAt", String record.startedAt),
        ("finishedAt", String record.finishedAt),
        ("subject", String record.subject),
        ("subjectKind", String (subjectKindText record.subjectKind)),
        ("harnessRevision", toJSON record.harnessRevision),
        ("harnessDirty", Bool record.harnessDirty),
        ("computations", toJSON record.computations),
        ("data", toJSON record.dataLinks),
        ("comparison", record.comparison)
      ]

recordToDocument :: EvidenceRecord -> OKFDocument
recordToDocument record =
  OKFDocument
    { frontmatter = foldl (\front (name, value) -> setField name value front) generated fields,
      body = record.body
    }
  where
    generated =
      setGenerated
        Generated {generatedBy = ProducerActor "kenshou-record" "0.1.0.0", generatedAt = Just record.generatedAt}
        (okfCommon OkfCommon {commonType = "Verification Run", commonTitle = Just record.title, commonDescription = Just record.description, commonTimestamp = Nothing})
    scenarioId = record.scenario
    fields =
      [ ("runId", toJSON record.runId),
        ("recordKind", String "run"),
        ("purpose", String (purposeText record.purpose)),
        ("scenario", String (renderScenarioId scenarioId)),
        ("layer", String (renderLayer scenarioId.layer)),
        ("component", String (unSegment scenarioId.component)),
        ("kind", String (renderKind scenarioId.kind)),
        ("tier", String record.tier),
        ("placement", String record.placement),
        ("outcome", String (renderOutcome record.outcome)),
        ("startedAt", String record.startedAt),
        ("finishedAt", String record.finishedAt),
        ("subject", String record.subject),
        ("subjectKind", String (subjectKindText record.subjectKind)),
        ("harnessRevision", toJSON record.harnessRevision),
        ("harnessDirty", Bool record.harnessDirty),
        ("computations", toJSON record.computations),
        ("data", toJSON record.dataLinks),
        ("cohort", String record.cohort),
        ("solverPlanHash", toJSON record.solverPlanHash),
        ("components", toJSON record.components),
        ("environment", record.environment),
        ("seed", toJSON record.seed),
        ("compatibilityKey", toJSON record.compatibilityKey)
      ]
        <> optionalList "knobs" [object ["name" .= name, "value" .= value] | (name, value) <- record.knobs]
        <> optionalList "dimensions" [object ["name" .= name, "value" .= value] | (name, value) <- record.dimensions]
        <> optionalList "knownDefects" record.knownDefects
        <> optionalList "produced" record.produced
        <> maybe [] (\path -> [("previousRun", String path)]) record.previousRun

    optionalList name values = [(name, toJSON values) | not (null values)]

recordFromDocument :: OKFDocument -> Either [FieldError] EvidenceRecord
recordFromDocument document = do
  let front = document.frontmatter
      required :: Text -> Either [FieldError] Value
      required name = maybe (Left [FieldError ("missing " <> name)]) Right (frontmatterLookup name front)
      typed :: (FromJSON value) => Text -> Either [FieldError] value
      typed name =
        required name >>= \value -> case fromJSON value of
          Error message -> Left [FieldError (name <> ": " <> Text.pack message)]
          Success decoded -> Right decoded
      optional :: (FromJSON value) => Text -> Either [FieldError] (Maybe value)
      optional name = case frontmatterLookup name front of
        Nothing -> Right Nothing
        Just value -> case fromJSON value of
          Error message -> Left [FieldError (name <> ": " <> Text.pack message)]
          Success decoded -> Right (Just decoded)
  recordType <- typed "type"
  if (recordType :: Text) /= "Verification Run" then Left [FieldError "type must be Verification Run"] else pure ()
  kind <- typed "recordKind"
  if (kind :: Text) /= "run" then Left [FieldError "recordKind must be run"] else pure ()
  title <- typed "title"
  description <- typed "description"
  generatedAt <- case readGenerated front of
    Just Generated {generatedBy, generatedAt = Just at}
      | generatedBy == parseActor "kenshou-record/0.1.0.0" -> Right at
    _ -> Left [FieldError "generated must name kenshou-record/0.1.0.0 and a time"]
  runId <- typed "runId"
  purpose <- typed "purpose"
  scenario <- typed "scenario"
  tier <- typed "tier"
  placement <- typed "placement"
  outcome <- typed "outcome"
  startedAt <- typed "startedAt"
  finishedAt <- typed "finishedAt"
  subject <- typed "subject"
  subjectKind <- typed "subjectKind"
  harnessRevision <- typed "harnessRevision"
  harnessDirty <- typed "harnessDirty"
  computations <- typed "computations"
  dataLinks <- typed "data"
  cohort <- typed "cohort"
  solverPlanHash <- typed "solverPlanHash"
  components <- typed "components"
  environment <- typed "environment"
  seed <- typed "seed"
  compatibilityKey <- typed "compatibilityKey"
  rawKnobs <- maybe [] id <$> optional "knobs"
  rawDimensions <- maybe [] id <$> optional "dimensions"
  let knobs = [(name, value) | NamedValue name value <- rawKnobs]
      dimensions = [(name, value) | NamedText name value <- rawDimensions]
  knownDefects <- maybe [] id <$> optional "knownDefects"
  produced <- maybe [] id <$> optional "produced"
  previousRun <- optional "previousRun"
  pure EvidenceRecord {title, description, generatedAt, runId, purpose, scenario, tier, placement, outcome, startedAt, finishedAt, subject, subjectKind, harnessRevision, harnessDirty, computations, dataLinks, cohort, solverPlanHash, components, environment, seed, compatibilityKey, knobs, dimensions, knownDefects, produced, previousRun, body = document.body}

comparisonFromDocument :: OKFDocument -> Either [FieldError] ComparisonEvidence
comparisonFromDocument document = do
  let front = document.frontmatter
      typed :: (FromJSON value) => Text -> Either [FieldError] value
      typed name = case frontmatterLookup name front of
        Nothing -> Left [FieldError ("missing " <> name)]
        Just value -> case fromJSON value of
          Error message -> Left [FieldError (name <> ": " <> Text.pack message)]
          Success decoded -> Right decoded
  recordType <- typed "type"
  if (recordType :: Text) /= "Verification Run" then Left [FieldError "type must be Verification Run"] else pure ()
  kind <- typed "recordKind"
  if (kind :: Text) /= "comparison" then Left [FieldError "recordKind must be comparison"] else pure ()
  generatedAt <- case readGenerated front of
    Just Generated {generatedBy, generatedAt = Just at}
      | generatedBy == parseActor "kenshou-record/0.1.0.0" -> Right at
    _ -> Left [FieldError "generated must name kenshou-record/0.1.0.0 and a time"]
  title <- typed "title"
  description <- typed "description"
  runId <- typed "runId"
  purpose <- typed "purpose"
  scenario <- typed "scenario"
  tier <- typed "tier"
  placement <- typed "placement"
  outcome <- typed "outcome"
  startedAt <- typed "startedAt"
  finishedAt <- typed "finishedAt"
  subject <- typed "subject"
  subjectKind <- typed "subjectKind"
  harnessRevision <- typed "harnessRevision"
  harnessDirty <- typed "harnessDirty"
  computations <- typed "computations"
  dataLinks <- typed "data"
  comparison <- typed "comparison"
  pure ComparisonEvidence {title, description, generatedAt, runId, purpose, scenario, tier, placement, outcome, startedAt, finishedAt, subject, subjectKind, harnessRevision, harnessDirty, computations, dataLinks, comparison, body = document.body}

purposeText :: Purpose -> Text
purposeText Nightly = "nightly"
purposeText Release = "release"
purposeText Baseline = "baseline"
purposeText Investigation = "investigation"

subjectKindText :: SubjectKind -> Text
subjectKindText SubjectProject = "project"
subjectKindText SubjectPackage = "package"

dataKindText :: DataKind -> Text
dataKindText RunSpecData = "run-spec"
dataKindText RunResultData = "run-result"
dataKindText ManifestData = "manifest"
dataKindText CellManifestData = "cell-manifest"
dataKindText SamplesData = "samples"
dataKindText SeriesData = "series"
dataKindText VerdictsData = "verdicts"
dataKindText DiagnosisData = "diagnosis"
dataKindText LogsData = "logs"
dataKindText ComparisonData = "comparison"

instance ToJSON Sha256 where toJSON (Sha256 digest) = String digest

instance FromJSON Sha256 where
  parseJSON = withText "SHA-256" (either (fail . Text.unpack) pure . mkSha256)

instance ToJSON Revision where toJSON (Revision revision) = String revision

instance FromJSON Revision where
  parseJSON = withText "revision" (either (fail . Text.unpack) pure . mkRevision)

instance FromJSON Purpose where
  parseJSON = withText "purpose" \case
    "nightly" -> pure Nightly
    "release" -> pure Release
    "baseline" -> pure Baseline
    "investigation" -> pure Investigation
    _ -> fail "unknown purpose"

instance FromJSON SubjectKind where
  parseJSON = withText "subject kind" \case
    "project" -> pure SubjectProject
    "package" -> pure SubjectPackage
    _ -> fail "unknown subject kind"

instance ToJSON DataLink where
  toJSON link = object ["kind" .= dataKindText link.kind, "uri" .= link.uri, "digest" .= link.digest, "mediaType" .= link.mediaType, "bytes" .= link.bytes]

instance FromJSON DataLink where
  parseJSON = withObject "data link" \value -> do
    rawKind <- value .: "kind" :: Parser Text
    kind <- parseKind rawKind
    DataLink kind <$> value .: "uri" <*> value .: "digest" <*> value .: "mediaType" <*> value .: "bytes"
    where
      parseKind = \case
        "run-spec" -> pure RunSpecData
        "run-result" -> pure RunResultData
        "manifest" -> pure ManifestData
        "cell-manifest" -> pure CellManifestData
        "samples" -> pure SamplesData
        "series" -> pure SeriesData
        "verdicts" -> pure VerdictsData
        "diagnosis" -> pure DiagnosisData
        "logs" -> pure LogsData
        "comparison" -> pure ComparisonData
        _ -> fail "unknown data kind"

instance ToJSON ComponentRef where
  toJSON component =
    object $
      ["project" .= component.project, "package" .= component.package, "version" .= component.version, "source" .= sourceText component.source]
        <> maybe [] (\revision -> ["revision" .= revision]) component.revision
    where
      sourceText FromHackage = "hackage" :: Text
      sourceText FromGit = "git"

instance FromJSON ComponentRef where
  parseJSON = withObject "component" \value -> do
    project <- value .: "project"
    package <- value .: "package"
    version <- value .: "version"
    rawSource <- value .: "source" :: Parser Text
    source <- case rawSource of
      "hackage" -> pure FromHackage
      "git" -> pure FromGit
      _ -> fail "unknown component source"
    revision <- value .:? "revision"
    pure ComponentRef {project, package, version, source, revision}

data NamedValue = NamedValue Text Value

instance FromJSON NamedValue where
  parseJSON = withObject "name/value" \value -> NamedValue <$> value .: "name" <*> value .: "value"

data NamedText = NamedText Text Text

instance FromJSON NamedText where
  parseJSON = withObject "name/value" \value -> NamedText <$> value .: "name" <*> value .: "value"