packages feed

kenshou-remote-0.1.0.0: src/Kenshou/Remote/Selftest.hs

module Kenshou.Remote.Selftest (bundle) where

import Control.Exception (SomeAsyncException, SomeException, bracket, fromException, throwIO, try)
import Data.Aeson (object, (.=))
import Data.List.NonEmpty (NonEmpty (..))
import Data.Map.Strict qualified as Map
import Data.Text (Text)
import Data.Text qualified as Text
import Kenshou.Core.Bundle (LayerBundle (..), mkBundle)
import Kenshou.Core.Context (RunContext (..), SummarySection (..), putSummary, requirePostgres)
import Kenshou.Core.Dimension (Dimensions (..), PgDurability (..), PgVersion (..), noDimensions, postgresDimensions)
import Kenshou.Core.Env (PostgresRequirement (..), noEnvironment)
import Kenshou.Core.Env qualified as Env
import Kenshou.Core.Env.Postgres (PgSettingsSnapshot (..), PostgresEnv (..), PostgresMode (..))
import Kenshou.Core.Id (parseScenarioId, selftestLayer)
import Kenshou.Core.Knob (Allowed (..), KnobName, KnobSpec (..), KnobType (..), KnobValue (..), knobText, mkKnobName)
import Kenshou.Core.Phase (zeroPhases)
import Kenshou.Core.RunSpec (EnvironmentSpec (..), SpecPlacement (..))
import Kenshou.Core.Scenario (Placement (..), Scenario (..), ScenarioReport, Tier (..), failedWith, passed)
import Kenshou.Core.Selftest.Schema (selftestSchema)
import Network.HTTP.Client (Request (..), RequestBody (..), httpLbs, newManager, parseRequest, responseStatus, responseTimeoutMicro)
import Network.HTTP.Client.TLS (tlsManagerSettings)
import Network.HTTP.Types.Status (statusCode)
import Network.Socket (SocketType (Stream), addrAddress, addrFamily, addrSocketType, close, connect, defaultHints, defaultProtocol, getAddrInfo, socket)
import System.Environment (lookupEnv)
import System.Exit (ExitCode (..))
import System.Process (readProcessWithExitCode)
import System.Timeout (timeout)

bundle :: LayerBundle
bundle = mkBundle selftestLayer [cellEnvironment] []

cellEnvironment :: Scenario
cellEnvironment =
  Scenario
    { id = either (error . show) id (parseScenarioId "selftest/remote/correctness/cell-environment"),
      revision = 2,
      summary = "Checks the environment supplied to a local or cell run.",
      tier = TierSmoke,
      placement = PlaceEither,
      knobs =
        [ KnobSpec expectPlacement "Expected execution placement" KnobText (VText "any") (OneOf (VText "any" :| [VText "local", VText "cell"])) [],
          KnobSpec otlpEndpoint "Optional OTLP HTTP endpoint to check" KnobText (VText "") AnyValue [],
          KnobSpec tcpEndpoint "Optional host:port to check for TCP reachability" KnobText (VText "") AnyValue []
        ],
      dimensions = postgresDimensions (PgFsyncOff :| [PgDurable]) (Pg18 :| [Pg17]) noDimensions,
      phases = zeroPhases,
      requires = noEnvironment {Env.postgres = Just (PostgresRequirement [selftestSchema] [] False)},
      knownDefect = Nothing,
      run = runCellEnvironment
    }

runCellEnvironment :: RunContext -> IO ScenarioReport
runCellEnvironment context = do
  cellId <- lookupEnv "CELL_RUN_ID"
  let postgres = requirePostgres context
      cell = context.environmentSpec.placement == RunOnCell
      requestedPlacement = knobText context.knobs expectPlacement
      placementOk = (requestedPlacement == "any" || requestedPlacement == if cell then "cell" else "local") && (cell == maybe False (not . null) cellId)
      modeOk = postgres.mode == if cell then PgExternal else PgEphemeral
      major = postgres.snapshot.serverVersionNum `div` 10000
      versionOk = major == case context.dimensions.pgVersion of Just Pg17 -> 17; Just Pg18 -> 18; Nothing -> 0
      durabilityOk = Map.lookup "fsync" postgres.snapshot.settings == Just (if context.dimensions.pgDurability == Just PgDurable then "on" else "off")
  fresh <- (== Right "0") <$> psql postgres.connectionString "SELECT count(*) FROM kenshou_selftest.roundtrip"
  otlp <- reachableOtlp (knobText context.knobs otlpEndpoint)
  tcp <- reachableTcp (knobText context.knobs tcpEndpoint)
  let checks =
        [ ("placement-as-expected", placementOk),
          ("postgres-mode-as-expected", modeOk),
          ("pg-version-honoured", versionOk),
          ("pg-durability-honoured", durabilityOk),
          ("database-is-fresh", fresh),
          ("otlp-reachable", otlp),
          ("tcp-endpoint-reachable", tcp)
        ]
      failures = [label | (label, False) <- checks]
  putSummary context Verdicts "cell-environment" (object ["checks" .= Map.fromList checks])
  pure (if null failures then passed else failedWith failures "cell environment differs from the declared run specification")

psql :: Text -> Text -> IO (Either Text Text)
psql connection query = do
  (code, output, errors) <- readProcessWithExitCode "psql" ["-d", Text.unpack connection, "-Atqc", Text.unpack query] ""
  pure case code of
    ExitSuccess -> Right (Text.strip (Text.pack output))
    _ -> Left (Text.strip (Text.pack errors))

reachableOtlp :: Text -> IO Bool
reachableOtlp endpoint
  | Text.null endpoint = pure True
  | otherwise = do
      result <- try @SomeException do
        request <- parseRequest (Text.unpack (Text.dropWhileEnd (== '/') endpoint <> "/v1/traces"))
        manager <- newManager tlsManagerSettings
        response <-
          httpLbs
            request
              { method = "POST",
                requestHeaders = [("Content-Type", "application/json")],
                requestBody = RequestBodyLBS "{\"resourceSpans\":[]}",
                responseTimeout = responseTimeoutMicro 2000000
              }
            manager
        pure (statusCode (responseStatus response) `elem` [200, 202, 204])
      recovered result

-- | Whether the first of a comma-separated list of host:port addresses accepts a
-- TCP connection within two seconds; an empty list is trivially reachable.
reachableTcp :: Text -> IO Bool
reachableTcp endpoints
  | Text.null endpoints = pure True
  | otherwise = do
      let firstAddress = Text.takeWhile (/= ',') endpoints
          (host, colonPort) = Text.breakOnEnd ":" firstAddress
      if Text.null host || Text.null colonPort
        then pure False
        else do
          result <- try @SomeException $ timeout 2000000 do
            addresses <- getAddrInfo (Just defaultHints {addrSocketType = Stream}) (Just (Text.unpack (Text.dropEnd 1 host))) (Just (Text.unpack colonPort))
            case addresses of
              [] -> pure False
              address : _ -> bracket (socket (addrFamily address) Stream defaultProtocol) close (\connection -> connect connection (addrAddress address) >> pure True)
          recovered (fmap (maybe False id) result)

recovered :: Either SomeException Bool -> IO Bool
recovered (Right available) = pure available
recovered (Left failure)
  | Just asynchronous <- fromException failure :: Maybe SomeAsyncException = throwIO asynchronous
  | otherwise = pure False

expectPlacement, otlpEndpoint, tcpEndpoint :: KnobName
expectPlacement = knobName "remote.expect-placement"
otlpEndpoint = knobName "remote.otlp-endpoint"
tcpEndpoint = knobName "remote.tcp-endpoint"

knobName :: Text -> KnobName
knobName = either (error . show) id . mkKnobName