kenshou-core-0.1.0.0: src/Kenshou/Core/Env/Postgres.hs
module Kenshou.Core.Env.Postgres
( PgSettingsSnapshot (..),
PostgresMode (..),
StopMode (..),
ServerControl (..),
PostgresEnv (..),
EnvError (..),
withPostgresEnv,
withPostgresEnvKeeping,
withPostgresEnvNamed,
)
where
import Control.Exception (finally)
import Control.Monad (unless)
import Data.Aeson (ToJSON (..), object, (.=))
import Data.Char (isAlphaNum, toLower)
import Data.IORef
import Data.Map.Strict (Map)
import Data.Map.Strict qualified as Map
import Data.Monoid (Last (..))
import Data.Text (Text)
import Data.Text qualified as Text
import EphemeralPg qualified as Pg
import Kenshou.Core.Dimension (Dimensions (..), PgDurability (..), PgVersion (..))
import Kenshou.Core.Env (MigrationSet, MigrationSetName, PostgresRequirement (..))
import Kenshou.Core.Env.Migration (composePlan, migrateDatabase)
import Kenshou.Core.Id (RunId, renderRunId)
import Kenshou.Core.Log (Logger, Severity (Warning), logAt)
import Kenshou.Core.RunSpec (ConnectionSource (..), PostgresSpec (..))
import System.Directory (copyFile, createDirectoryIfMissing, doesFileExist)
import System.Environment (getEnv, lookupEnv, setEnv)
import System.Exit (ExitCode (..))
import System.FilePath ((</>))
import System.Posix.User (getRealUserID)
import System.Process (readProcessWithExitCode)
data PgSettingsSnapshot = PgSettingsSnapshot
{ serverVersion :: Text,
serverVersionNum :: Int,
settings :: Map Text Text,
superuser :: Bool,
collation :: Text,
encoding :: Text
}
deriving stock (Eq, Show)
data PostgresMode = PgEphemeral | PgExternal deriving stock (Eq, Show)
data StopMode = StopFast | StopImmediate deriving stock (Eq, Show)
data ServerControl = ServerControl {currentServer :: IO Pg.Database, restartServer :: IO (), stopServer :: StopMode -> IO (), startServer :: IO ()}
data PostgresEnv = PostgresEnv
{ mode :: PostgresMode,
connectionString :: Text,
tcpEndpoint :: Maybe (Text, Int),
adminConnectionString :: Text,
databaseName :: Text,
newDatabase :: Text -> IO Text,
snapshot :: PgSettingsSnapshot,
control :: Maybe ServerControl
}
newtype EnvError = EnvError Text deriving stock (Eq, Show)
instance ToJSON PgSettingsSnapshot where
toJSON snapshot = object ["serverVersion" .= snapshot.serverVersion, "serverVersionNum" .= snapshot.serverVersionNum, "settings" .= snapshot.settings, "superuser" .= snapshot.superuser, "collation" .= snapshot.collation, "encoding" .= snapshot.encoding]
withPostgresEnv :: Map MigrationSetName MigrationSet -> Logger -> FilePath -> RunId -> PostgresRequirement -> PostgresSpec -> Dimensions -> (PostgresEnv -> IO value) -> IO (Either EnvError value)
withPostgresEnv sets = withPostgresEnvKeeping sets False
withPostgresEnvKeeping :: Map MigrationSetName MigrationSet -> Bool -> Logger -> FilePath -> RunId -> PostgresRequirement -> PostgresSpec -> Dimensions -> (PostgresEnv -> IO value) -> IO (Either EnvError value)
withPostgresEnvKeeping sets keepEnvironment = withPostgresEnvNamed sets keepEnvironment Nothing
-- | Like 'withPostgresEnvKeeping', for a named context of a scenario. On an
-- external server several contexts share one server, so the context name
-- becomes part of every database name the run creates there.
withPostgresEnvNamed :: Map MigrationSetName MigrationSet -> Bool -> Maybe Text -> Logger -> FilePath -> RunId -> PostgresRequirement -> PostgresSpec -> Dimensions -> (PostgresEnv -> IO value) -> IO (Either EnvError value)
withPostgresEnvNamed sets keepEnvironment contextName logger runDirectory runId requirement postgresSpec dimensions action = case postgresSpec of
PostgresEphemeral extraSettings -> withSelectedBinaries dimensions.pgVersion $ do
createDirectoryIfMissing True (runDirectory </> "logs")
uid <- getRealUserID
let temporaryRoot = "/tmp/ephpg-kenshou-" <> show uid
createDirectoryIfMissing True temporaryRoot
let durabilitySettings = case dimensions.pgDurability of
Just PgDurable -> [("fsync", "on"), ("synchronous_commit", "on"), ("full_page_writes", "on")]
_ -> [("fsync", "off"), ("synchronous_commit", "off"), ("full_page_writes", "off")]
settings = [("listen_addresses", "'127.0.0.1'"), ("log_min_messages", "'WARNING'"), ("log_line_prefix", "'%m [%p] %a '"), ("logging_collector", "on"), ("log_directory", "'log'"), ("log_filename", "'postgres.log'")] <> durabilitySettings <> requirement.settings <> extraSettings
config = Pg.defaultConfig {Pg.databaseName = "kenshou_template", Pg.temporaryRoot = Last (Just temporaryRoot), Pg.postgresSettings = settings}
started <- Pg.startCached config Pg.defaultCacheConfig
case started of
Left err -> pure (Left (EnvError (Text.pack (show err))))
Right database -> do
databaseRef <- newIORef database
let cleanup = do
current <- readIORef databaseRef
let postgresLog = current.dataDirectory </> "log" </> "postgres.log"
exists <- doesFileExist postgresLog
if exists then copyFile postgresLog (runDirectory </> "logs" </> "postgres.log") else pure ()
Pg.stop current
if keepEnvironment
then setup databaseRef database >>= either (pure . Left) (\environment -> logAt logger Warning "leaving ephemeral PostgreSQL running" [] >> fmap Right (action environment))
else (setup databaseRef database >>= either (pure . Left) (fmap Right . action)) `finally` cleanup
PostgresExternal source -> do
connection <- resolveConnection source
case connection of
Left err -> pure (Left err)
Right maintenanceConnection -> do
initialSnapshot <- snapshotDatabase maintenanceConnection
case initialSnapshot >>= \snapshot -> validateExternal dimensions snapshot *> validatePreloadedLibraries requirement snapshot of
Left err -> pure (Left err)
Right () -> do
unless (null (filter ((/= "shared_preload_libraries") . fst) requirement.settings)) $ logAt logger Warning "external PostgreSQL settings cannot be applied" []
withExternalDatabases sets keepEnvironment maintenanceConnection runId contextName requirement action
where
setup databaseRef database = do
migration <- migrateIfNeeded sets (Pg.connectionString database) requirement
case migration of
Left err -> pure (Left err)
Right () -> do
cloned <- runCommand "createdb" ["-h", database.socketDirectory, "-p", show database.port, "-U", Text.unpack database.user, "-T", "kenshou_template", "kenshou_run"]
case cloned of
Left err -> pure (Left err)
Right () -> do
let connection = connectionFor database "kenshou_run"
snapshot <- snapshotDatabase connection
pure (makeEnvironment databaseRef database connection <$> snapshot)
makeEnvironment databaseRef database connection snapshot =
PostgresEnv PgEphemeral connection (Just ("127.0.0.1", fromIntegral database.port)) (Pg.connectionString database) "kenshou_run" (cloneDatabase database) snapshot (Just (serverControl databaseRef))
cloneDatabase database label = do
let name = "kenshou_" <> label
result <- runCommand "createdb" ["-h", database.socketDirectory, "-p", show database.port, "-U", Text.unpack database.user, "-T", "kenshou_template", Text.unpack name]
either (ioError . userError . show) (const (pure (connectionFor database name))) result
serverControl databaseRef = ServerControl (readIORef databaseRef) restart stopNow start
where
restart = do
current <- readIORef databaseRef
Pg.restart current >>= either (ioError . userError . show) (writeIORef databaseRef)
stopNow mode = do
current <- readIORef databaseRef
let modeText = case mode of StopFast -> "fast"; StopImmediate -> "immediate"
runCommand "pg_ctl" ["-D", current.dataDirectory, "stop", "-m", modeText, "-w"] >>= either (ioError . userError . show) pure
start = do
current <- readIORef databaseRef
Pg.restart current >>= either (ioError . userError . show) (writeIORef databaseRef)
withExternalDatabases :: Map MigrationSetName MigrationSet -> Bool -> Text -> RunId -> Maybe Text -> PostgresRequirement -> (PostgresEnv -> IO value) -> IO (Either EnvError value)
withExternalDatabases sets keepEnvironment maintenanceConnection runId contextName requirement action = do
counter <- newIORef (0 :: Int)
created <- newIORef []
let context = maybe "" (\name -> "_" <> Text.take 16 (Text.map (\character -> if isAlphaNum character then toLower character else '_') name)) contextName
prefix = Text.take 13 (Text.filter (/= '-') (renderRunId runId)) <> context
templateName = "kenshou_" <> prefix <> "_template"
runName = "kenshou_" <> prefix
remember name = modifyIORef' created (name :)
create name template = do
result <- psqlUnit maintenanceConnection ("create database " <> name <> maybe "" (" template " <>) template)
case result of Left err -> pure (Left err); Right () -> remember name >> pure (Right ())
cleanup = readIORef created >>= mapM_ (\name -> psqlUnit maintenanceConnection ("drop database if exists " <> name <> " with (force)") >> pure ())
setup = do
createdTemplate <- create templateName Nothing
case createdTemplate of
Left err -> pure (Left err)
Right () -> do
let templateConnection = connectionForExternal maintenanceConnection templateName
migrated <- migrateIfNeeded sets templateConnection requirement
case migrated of
Left err -> pure (Left err)
Right () -> do
createdRun <- create runName (Just templateName)
case createdRun of
Left err -> pure (Left err)
Right () -> do
let runConnection = connectionForExternal maintenanceConnection runName
snapshot <- snapshotDatabase runConnection
pure $ fmap (externalEnvironment counter created maintenanceConnection templateName runName runConnection) snapshot
if keepEnvironment
then setup >>= either (pure . Left) (fmap Right . action)
else (setup >>= either (pure . Left) (fmap Right . action)) `finally` cleanup
externalEnvironment :: IORef Int -> IORef [Text] -> Text -> Text -> Text -> Text -> PgSettingsSnapshot -> PostgresEnv
externalEnvironment counter created maintenanceConnection templateName runName connection snapshot =
PostgresEnv PgExternal connection (externalTcpEndpoint maintenanceConnection) maintenanceConnection runName clone snapshot Nothing
where
clone label = do
number <- atomicModifyIORef' counter (\value -> let next = value + 1 in (next, next))
let safeLabel = Text.map (\character -> if isAlphaNum character then character else '_') label
name = "kenshou_" <> safeLabel <> "_" <> Text.pack (show number)
result <- psqlUnit maintenanceConnection ("create database " <> name <> " template " <> templateName)
case result of
Left err -> ioError (userError (show err))
Right () -> modifyIORef' created (name :) >> pure (connectionForExternal maintenanceConnection name)
resolveConnection :: ConnectionSource -> IO (Either EnvError Text)
resolveConnection (ConnLiteral value) = pure (Right value)
resolveConnection (ConnFromEnv name) = maybe (Left (EnvError ("environment variable is not set: " <> name))) (Right . Text.pack) <$> lookupEnv (Text.unpack name)
migrateIfNeeded :: Map MigrationSetName MigrationSet -> Text -> PostgresRequirement -> IO (Either EnvError ())
migrateIfNeeded _ _ requirement | null requirement.schemas = pure (Right ())
migrateIfNeeded sets connection requirement = case composePlan sets requirement.schemas of
Left err -> pure (Left (EnvError (Text.pack (show err))))
Right plan -> fmap (either (Left . EnvError . Text.pack . show) Right) (migrateDatabase connection plan)
connectionFor :: Pg.Database -> Text -> Text
connectionFor database name = Text.unwords ["host=" <> Text.pack database.socketDirectory, "port=" <> Text.pack (show database.port), "dbname=" <> name, "user=" <> database.user]
snapshotDatabase :: Text -> IO (Either EnvError PgSettingsSnapshot)
snapshotDatabase connection = do
let setting name = psql connection ("show " <> name)
version <- setting "server_version"
versionNumber <- setting "server_version_num"
settingPairs <- traverse (\name -> fmap ((name,) <$>) (setting name)) fingerprintSettings
collation <- psql connection "select datcollate from pg_database where datname=current_database()"
encoding <- psql connection "select pg_encoding_to_char(encoding) from pg_database where datname=current_database()"
superuser <- psql connection "select rolsuper::text from pg_roles where rolname=current_user"
pure do
serverVersion <- version
numberText <- versionNumber
serverVersionNum <- maybe (Left (EnvError "invalid server_version_num")) Right (readMaybeText numberText)
resolvedSettings <- sequence settingPairs
databaseCollation <- collation
databaseEncoding <- encoding
isSuperuser <- (== "true") . Text.toCaseFold <$> superuser
pure (PgSettingsSnapshot serverVersion serverVersionNum (Map.fromList resolvedSettings) isSuperuser databaseCollation databaseEncoding)
fingerprintSettings :: [Text]
fingerprintSettings =
[ "fsync",
"synchronous_commit",
"full_page_writes",
"wal_level",
"shared_buffers",
"effective_cache_size",
"work_mem",
"max_connections",
"checkpoint_timeout",
"checkpoint_completion_target",
"max_wal_size",
"wal_buffers",
"random_page_cost",
"autovacuum",
"shared_preload_libraries"
]
validateExternal :: Dimensions -> PgSettingsSnapshot -> Either EnvError ()
validateExternal dimensions snapshot = do
case dimensions.pgVersion of
Just Pg17 | snapshot.serverVersionNum < 170000 || snapshot.serverVersionNum >= 180000 -> Left (EnvError "external PostgreSQL does not match pg.version=17")
Just Pg18 | snapshot.serverVersionNum < 180000 || snapshot.serverVersionNum >= 190000 -> Left (EnvError "external PostgreSQL does not match pg.version=18")
_ -> Right ()
let actual name = Text.toCaseFold <$> Map.lookup name snapshot.settings
case dimensions.pgDurability of
Just PgFsyncOff | actual "fsync" /= Just "off" || actual "synchronous_commit" /= Just "off" -> Left (EnvError "external PostgreSQL does not match pg.durability=fsync-off")
Just PgDurable | actual "fsync" /= Just "on" || actual "synchronous_commit" == Just "off" -> Left (EnvError "external PostgreSQL does not match pg.durability=durable")
_ -> Right ()
validatePreloadedLibraries :: PostgresRequirement -> PgSettingsSnapshot -> Either EnvError ()
validatePreloadedLibraries requirement snapshot =
case filter (`notElem` available) requested of
[] -> Right ()
missing -> Left (EnvError ("external PostgreSQL is missing required preloaded libraries: " <> Text.intercalate ", " missing))
where
requested = concatMap (libraries . snd) (filter ((== "shared_preload_libraries") . fst) requirement.settings)
available = libraries (Map.findWithDefault "" "shared_preload_libraries" snapshot.settings)
libraries = filter (not . Text.null) . fmap (Text.toCaseFold . Text.strip) . Text.splitOn "," . Text.dropAround (== '\'') . Text.strip
psql :: Text -> Text -> IO (Either EnvError Text)
psql connection query = do
(code, output, err) <- readProcessWithExitCode "psql" ["-d", Text.unpack connection, "-Atqc", Text.unpack query] ""
pure case code of ExitSuccess -> Right (Text.strip (Text.pack output)); _ -> Left (EnvError (Text.strip (Text.pack err)))
psqlUnit :: Text -> Text -> IO (Either EnvError ())
psqlUnit connection query = fmap (const ()) <$> psql connection query
connectionForExternal :: Text -> Text -> Text
connectionForExternal maintenanceConnection name = maintenanceConnection <> " dbname=" <> name
externalTcpEndpoint :: Text -> Maybe (Text, Int)
externalTcpEndpoint connection = do
host <- lookupWord "host"
portText <- lookupWord "port"
port <- readMaybeText portText
pure (host, port)
where
pairs = [(key, Text.drop 1 rest) | word <- Text.words connection, let (key, rest) = Text.breakOn "=" word, not (Text.null rest)]
lookupWord key = lookup key pairs
runCommand :: FilePath -> [String] -> IO (Either EnvError ())
runCommand command arguments = do
(code, _, err) <- readProcessWithExitCode command arguments ""
pure case code of ExitSuccess -> Right (); _ -> Left (EnvError (Text.strip (Text.pack err)))
withSelectedBinaries :: Maybe PgVersion -> IO (Either EnvError value) -> IO (Either EnvError value)
withSelectedBinaries version action = do
(original, validation) <- prepare
case validation of
Left err -> restore original >> pure (Left err)
Right () -> action `finally` restore original
where
prepare = do
original <- getEnv "PATH"
let (variable, expectedMajor) = case version of Just Pg17 -> ("KENSHOU_PG17_BIN", 17 :: Int); _ -> ("KENSHOU_PG18_BIN", 18)
binaryDirectory <- lookupEnv variable
maybe (pure ()) (\directory -> setEnv "PATH" (directory <> ":" <> original)) binaryDirectory
(code, output, err) <- readProcessWithExitCode "postgres" ["--version"] ""
let versionText = Text.pack output
matches = (" " <> Text.pack (show expectedMajor) <> ".") `Text.isInfixOf` versionText
validation = if code == ExitSuccess && matches then Right () else Left (EnvError (Text.pack (variable <> " is unset or does not select PostgreSQL " <> show expectedMajor <> ": " <> err <> output)))
pure (original, validation)
restore = setEnv "PATH"
readMaybeText :: (Read value) => Text -> Maybe value
readMaybeText value = case reads (Text.unpack value) of [(parsed, "")] -> Just parsed; _ -> Nothing