diff --git a/waspc/cli/exe/Main.hs b/waspc/cli/exe/Main.hs index 95a161f7a5..5deff2d0c6 100644 --- a/waspc/cli/exe/Main.hs +++ b/waspc/cli/exe/Main.hs @@ -20,6 +20,7 @@ import Wasp.Cli.Command.Clean (clean) import Wasp.Cli.Command.Compile (compileCommand) import Wasp.Cli.Command.CreateNewProject (createNewProject) import Wasp.Cli.Command.CreateNewProject.AvailableTemplates (availableStarterTemplates) +import Wasp.Cli.Command.Db (runCommandThatRequiresDbRunning) import qualified Wasp.Cli.Command.Db.Migrate as Command.Db.Migrate import qualified Wasp.Cli.Command.Db.Reset as Command.Db.Reset import qualified Wasp.Cli.Command.Db.Seed as Command.Db.Seed @@ -38,7 +39,6 @@ import qualified Wasp.Cli.Command.Telemetry as Telemetry import Wasp.Cli.Command.Test (test) import Wasp.Cli.Command.Uninstall (uninstall) import Wasp.Cli.Terminal (title) -import Wasp.Cli.Util.Parser (ArgsParser (..), withArguments) import Wasp.Util (indent) import Wasp.Util.InstallMethod (getInstallationCommand, legacyVersionsNote) import qualified Wasp.Util.Terminal as Term @@ -157,7 +157,7 @@ printUsage = cmd " completion Prints help on bash completion.", cmd " uninstall [--force] Removes Wasp from your system.", title " IN PROJECT", - cmd " start [--client-port ] [--server-port ] [--client-url ] [--server-url ]", + cmd " start [--client-port ] [--server-port ] [--client-url ] [--server-url ] [--db-port ] [--db-image ] [--db-volume-mount-path ]", " Runs Wasp app in development mode, watching for file changes.", " Optionally specify the ports the client and the server run on.", " If not specified, Wasp picks the first free port when the default one is taken.", @@ -218,10 +218,10 @@ dbCli args = case args of -- These commands don't require an existing and running database. "start" : optionalStartArgs -> runCommand $ Command.Start.Db.start optionalStartArgs -- These commands require an existing and running database. - "reset" : resetArgs -> runCommand $ withArguments Command.Db.Reset.resetArgsParser Command.Db.Reset.reset resetArgs - "migrate-dev" : optionalMigrateArgs -> runCommand $ withArguments Command.Db.Migrate.migrateArgsParser Command.Db.Migrate.migrateDev optionalMigrateArgs - "seed" : seedArgs -> runCommand $ withArguments Command.Db.Seed.seedArgsParser Command.Db.Seed.seed seedArgs - "studio" : studioArgs -> runCommand $ withArguments (ArgsParser "wasp db studio" (pure ())) (const Command.Db.Studio.studio) studioArgs + "reset" : resetArgs -> runCommandThatRequiresDbRunning Command.Db.Reset.resetArgsParser Command.Db.Reset.reset resetArgs + "migrate-dev" : optionalMigrateArgs -> runCommandThatRequiresDbRunning Command.Db.Migrate.migrateArgsParser Command.Db.Migrate.migrateDev optionalMigrateArgs + "seed" : seedArgs -> runCommandThatRequiresDbRunning Command.Db.Seed.seedArgsParser Command.Db.Seed.seed seedArgs + "studio" : studioArgs -> runCommandThatRequiresDbRunning Command.Db.Studio.studioArgsParser (const Command.Db.Studio.studio) studioArgs _unknownDbCommand -> printDbUsage >> exitFailure {- ORMOLU_DISABLE -} @@ -236,7 +236,7 @@ printDbUsage = cmd $ intercalate "\n" [ " start [--db-port ] [--db-image ] [--db-volume-mount-path ]", " Alias for `wasp start db`.", - " Starts managed development database for you.", + " Runs a development database and streams its logs until Ctrl+C.", " Optionally specify a custom port, Docker image, or Docker volume mount path.", " If the port is not specified, Wasp picks the first free port when the default one is taken." ], @@ -251,10 +251,20 @@ printDbUsage = " supplied migration name or asking for one.", " OPTIONS:", " --name [migration-name]", - " --create-only" + " --create-only", + " --db-port ", + " --db-image ", + " --db-volume-mount-path " ], cmd " studio GUI for inspecting your database.", "", + title "DATABASE OPTIONS", + " --db-port Host port when starting managed PostgreSQL.", + " --db-image Docker image when starting managed PostgreSQL.", + " --db-volume-mount-path ", + " Data path inside a new PostgreSQL container.", + " These options also work with reset, seed, migrate-dev, and studio.", + "", title "EXAMPLES", " wasp db migrate-dev", " wasp db migrate-dev --name \"Added User entity\"", diff --git a/waspc/cli/src/Wasp/Cli/Command/Db.hs b/waspc/cli/src/Wasp/Cli/Command/Db.hs index e34eb3eda5..1d2702bd39 100644 --- a/waspc/cli/src/Wasp/Cli/Command/Db.hs +++ b/waspc/cli/src/Wasp/Cli/Command/Db.hs @@ -1,17 +1,30 @@ module Wasp.Cli.Command.Db - ( makeDbCommand, + ( runCommandThatRequiresDbRunning, + makeDbCommand, ) where import qualified Wasp.AppSpec as AS -import Wasp.Cli.Command (Command, require) +import Wasp.Cli.Command (Command, require, runCommand) +import Wasp.Cli.Command.Call (Arguments) import Wasp.Cli.Command.Compile (defaultCompileOptions, withSetupGoals) +import qualified Wasp.Cli.Command.Db.DevDb as DevDb +import Wasp.Cli.Command.Db.StartOptions (dbStartOptionsParser) import Wasp.Cli.Command.Require.DbConnectionEstablished (DbConnectionEstablished (DbConnectionEstablished)) import Wasp.Cli.Command.Require.InWaspProject (InWaspProject (InWaspProject)) import Wasp.Cli.Command.Require.WaspSpecAvailable (WaspSpecAvailable (WaspSpecAvailable)) import Wasp.Cli.Compile (waitEnsureCompile) +import Wasp.Cli.Util.Parser (ArgsParser (..), withArguments) import Wasp.Generator.Setup (SetupGoal) +runCommandThatRequiresDbRunning :: ArgsParser a -> (a -> Command ()) -> Arguments -> IO () +runCommandThatRequiresDbRunning parser command args = + runCommand $ withArguments databaseArgsParser run args + where + databaseArgsParser = parser {optParser = (,) <$> dbStartOptionsParser <*> parser.optParser} + run (dbStartOptions, commandArgs) = + DevDb.withDevDb dbStartOptions $ \_ -> command commandArgs + -- | Prepares what a db command needs before it runs: a compile, -- post-compile setup, and a reachable database. -- diff --git a/waspc/cli/src/Wasp/Cli/Command/Db/DevDb.hs b/waspc/cli/src/Wasp/Cli/Command/Db/DevDb.hs new file mode 100644 index 0000000000..33d3ca26b2 --- /dev/null +++ b/waspc/cli/src/Wasp/Cli/Command/Db/DevDb.hs @@ -0,0 +1,206 @@ +module Wasp.Cli.Command.Db.DevDb + ( withDevDb, + withPostgresSession, + DatabaseStartPolicy (..), + DatabaseSession (..), + DatabaseUrlSource (..), + findDatabaseUrlSource, + ) +where + +import Control.Concurrent.Async (Async, async, cancel, race, wait) +import Control.Exception (IOException, try) +import Control.Monad (unless, when) +import Control.Monad.Catch (bracket, bracketOnError, finally) +import qualified Control.Monad.Except as E +import Control.Monad.IO.Class (liftIO) +import Data.List (intercalate) +import Data.Maybe (fromMaybe, isJust) +import Network.Socket (PortNumber) +import StrongPath (Abs, Dir, Path') +import System.Environment (lookupEnv) +import System.Exit (ExitCode) +import System.IO.Error (ioeGetErrorString) +import Text.Printf (printf) +import qualified Wasp.AppSpec as AS +import qualified Wasp.AppSpec.App as AS.App +import qualified Wasp.AppSpec.App.Db as AS.App.Db +import qualified Wasp.AppSpec.Valid as ASV +import Wasp.Cli.Command (Command, CommandError (CommandError), require) +import Wasp.Cli.Command.Compile (analyze) +import qualified Wasp.Cli.Command.Db.Docker as Docker +import Wasp.Cli.Command.Db.StartOptions (DbStartOptions (..)) +import Wasp.Cli.Command.Message (cliSendMessageC) +import Wasp.Cli.Command.Require.InWaspProject (InWaspProject (InWaspProject)) +import Wasp.Cli.Command.Require.WaspSpecAvailable (WaspSpecAvailable (WaspSpecAvailable)) +import Wasp.Cli.Port (resolvePort) +import Wasp.Db.Postgres (defaultPostgresDockerImageSpec, defaultPostgresPort) +import qualified Wasp.Message as Msg +import Wasp.Project.Common (WaspProjectDir) +import Wasp.Project.Db (databaseUrlEnvVarName) +import qualified Wasp.Project.Db.Dev.Postgres as Dev.Postgres +import Wasp.Util.Docker (DockerImageName, DockerVolumeMountPath) + +withDevDb :: DbStartOptions -> (Maybe Dev.Postgres.DevDbSpec -> Command a) -> Command a +withDevDb options action = do + InWaspProject waspProjectDir <- require + WaspSpecAvailable <- require + appSpec <- analyze waspProjectDir + databaseUrlSource <- liftIO $ findDatabaseUrlSource appSpec + case databaseUrlSource of + Just _ -> do + throwIfDbStartOptionsSupplied "DATABASE_URL is set." options + action Nothing + Nothing -> case ASV.getValidDbSystem appSpec of + AS.App.Db.SQLite -> do + throwIfDbStartOptionsSupplied "This project uses SQLite." options + action Nothing + AS.App.Db.PostgreSQL -> + withPostgresSession waspProjectDir (ASV.getApp appSpec).name options AllowExistingDatabase $ + action . Just . getDatabaseForSession + +data DatabaseStartPolicy = RequireNewDatabase | AllowExistingDatabase + deriving (Eq) + +data DatabaseSession + = ReusedDatabase Dev.Postgres.DevDbSpec + | StartedDatabase Dev.Postgres.DevDbSpec String (Async ExitCode) + +withPostgresSession :: Path' Abs (Dir WaspProjectDir) -> String -> DbStartOptions -> DatabaseStartPolicy -> (DatabaseSession -> Command a) -> Command a +withPostgresSession waspProjectDir appName options policy action = do + startupPlan <- prepareDatabaseStartup waspProjectDir appName options policy + bracket (acquire startupPlan) release use + where + acquire (ReuseDatabase session) = return session + acquire (CreateDatabase db image mountPath) = + bracketOnError + (withDatabaseError "Could not start PostgreSQL" $ Dev.Postgres.createDevPostgresContainer db image mountPath) + Docker.removeContainer + ( \containerId -> do + databaseJob <- liftIO $ async $ Docker.runDockerJobAndPrintOutput ["start", "--attach", containerId] + return $ StartedDatabase db containerId databaseJob + ) + + use session = do + case session of + StartedDatabase db _ databaseJob -> do + result <- + withDatabaseError "Could not start PostgreSQL" $ + race (wait databaseJob) (Dev.Postgres.waitForDevDbReady db) + case result of + Left _ -> E.throwError $ CommandError "Could not start PostgreSQL" "The Docker process exited before PostgreSQL was ready. Check the database output above." + Right () -> return () + when (policy == RequireNewDatabase) $ cliSendMessageC $ Msg.Info $ unlines $ additionalInfoLines db + _ -> return () + action session + + release (StartedDatabase _ containerId databaseJob) = + Docker.stopDatabase containerId `finally` (liftIO (cancel databaseJob) `finally` Docker.removeContainer containerId) + release _ = return () + +data DatabaseStartupPlan + = ReuseDatabase DatabaseSession + | CreateDatabase Dev.Postgres.DevDbSpec DockerImageName DockerVolumeMountPath + +prepareDatabaseStartup :: Path' Abs (Dir WaspProjectDir) -> String -> DbStartOptions -> DatabaseStartPolicy -> Command DatabaseStartupPlan +prepareDatabaseStartup waspProjectDir appName options policy = do + Docker.ensureDockerDaemonAvailable + + liftIO (Dev.Postgres.discoverProjectsRunningDevDb waspProjectDir appName) >>= \case + Just runningDb -> case policy of + RequireNewDatabase -> + E.throwError $ + CommandError + "PostgreSQL already running" + ( printf + "This project's database is already running on port %s. Stop the command that started it, or run `docker stop %s` before starting it again.\n%s" + (show runningDb.port) + runningDb.dockerContainerName + (unlines $ additionalInfoLines runningDb) + ) + AllowExistingDatabase -> ReuseDatabase <$> prepareExistingDatabase runningDb + Nothing -> prepareStartupOnPort =<< resolveDevDbPort + where + dbDockerImage = fromMaybe (fst defaultPostgresDockerImageSpec) options.dbImage + dbDockerVolumeMountPath = fromMaybe (snd defaultPostgresDockerImageSpec) options.dbVolumeMountPath + + resolveDevDbPort :: Command PortNumber + resolveDevDbPort = + resolvePort + options.dbPort + defaultPostgresPort + [] + "Choose a different port with --db-port, or free up this one." + "Free at least one of those ports by exiting the program listening on it, or choose the port yourself with --db-port." + + prepareExistingDatabase :: Dev.Postgres.DevDbSpec -> Command DatabaseSession + prepareExistingDatabase devDbSpec = do + withDatabaseError "PostgreSQL is not ready" $ Dev.Postgres.waitForDevDbReady devDbSpec + cliSendMessageC $ Msg.Info "PostgreSQL was already running for this project. Wasp did not start it and will not stop it." + unless (null $ suppliedOptionNames options) $ cliSendMessageC $ Msg.Warning "Database options not used" (printf "These options only apply when starting a new container: %s. Stop the running database before changing them." (intercalate ", " (suppliedOptionNames options))) + return $ ReusedDatabase devDbSpec + + prepareStartupOnPort :: PortNumber -> Command DatabaseStartupPlan + prepareStartupOnPort port = do + let devDbSpec = Dev.Postgres.makeDevPostgresDbSpec waspProjectDir appName port + Docker.ensureImageAvailable dbDockerImage + cliSendMessageC $ Msg.Start "Starting PostgreSQL..." + cliSendMessageC $ Msg.Info $ unlines dockerRunInfoLines + return $ CreateDatabase devDbSpec dbDockerImage dbDockerVolumeMountPath + + -- These lines describe what Docker is about to use, so we print them + -- only when starting the database: an already running container might have + -- been started with a different image or mount path than the current + -- invocation's arguments. + dockerRunInfoLines :: [String] + dockerRunInfoLines = + [ " ℹ Using Docker image: " <> dbDockerImage, + " with the data volume mounted at: " <> dbDockerVolumeMountPath + ] + +getDatabaseForSession :: DatabaseSession -> Dev.Postgres.DevDbSpec +getDatabaseForSession (ReusedDatabase db) = db +getDatabaseForSession (StartedDatabase db _ _) = db + +data DatabaseUrlSource = EnvironmentVariable | ServerDotEnvFile + +findDatabaseUrlSource :: AS.AppSpec -> IO (Maybe DatabaseUrlSource) +findDatabaseUrlSource appSpec = do + envUrl <- lookupEnv databaseUrlEnvVarName + return $ + if isJust envUrl + then Just EnvironmentVariable + else + if any ((== databaseUrlEnvVarName) . fst) appSpec.devEnvVarsServer + then Just ServerDotEnvFile + else Nothing + +throwIfDbStartOptionsSupplied :: String -> DbStartOptions -> Command () +throwIfDbStartOptionsSupplied reason options = + unless (null optionNames) $ E.throwError $ CommandError "Database options do not apply" (printf "%s These options only apply to Wasp-managed PostgreSQL: %s. Remove them to continue." reason (intercalate ", " optionNames)) + where + optionNames = suppliedOptionNames options + +suppliedOptionNames :: DbStartOptions -> [String] +suppliedOptionNames options = + ["--db-port" | isJust options.dbPort] + ++ ["--db-image" | isJust options.dbImage] + ++ ["--db-volume-mount-path" | isJust options.dbVolumeMountPath] + +additionalInfoLines :: Dev.Postgres.DevDbSpec -> [String] +additionalInfoLines devDbSpec = + [ "", + "Additional info:", + " ℹ Connection URL, in case you might want to connect with external tools:", + " " <> Dev.Postgres.getDevConnectionUrl devDbSpec, + " ℹ Database data is persisted in a Docker volume with the following name" + <> " (useful to know if you will want to delete it at some point):", + " " <> devDbSpec.dockerVolumeName + ] + +withDatabaseError :: String -> IO a -> Command a +withDatabaseError title action = do + result <- liftIO $ try action + case result of + Left (err :: IOException) -> E.throwError $ CommandError title $ ioeGetErrorString err + Right value -> return value diff --git a/waspc/cli/src/Wasp/Cli/Command/Db/Docker.hs b/waspc/cli/src/Wasp/Cli/Command/Db/Docker.hs new file mode 100644 index 0000000000..95ea5c5c1c --- /dev/null +++ b/waspc/cli/src/Wasp/Cli/Command/Db/Docker.hs @@ -0,0 +1,90 @@ +module Wasp.Cli.Command.Db.Docker + ( ensureDockerDaemonAvailable, + ensureImageAvailable, + runDockerJobAndPrintOutput, + stopDatabase, + removeContainer, + ) +where + +import Control.Concurrent (Chan, newChan, readChan) +import Control.Concurrent.Async (concurrently) +import Control.Monad (forM_, when) +import qualified Control.Monad.Except as E +import Control.Monad.IO.Class (liftIO) +import Data.List (isInfixOf) +import System.Exit (ExitCode (..)) +import System.Process (CreateProcess (create_group), proc, readCreateProcessWithExitCode, readProcessWithExitCode) +import Text.Printf (printf) +import Wasp.Cli.Command (Command, CommandError (CommandError)) +import Wasp.Cli.Command.Common (throwIfExeIsNotAvailable) +import Wasp.Cli.Command.Message (cliSendMessageC) +import qualified Wasp.Job as Job +import Wasp.Job.IO.PrefixedWriter (printJobMessagePrefixed, runPrefixedWriter) +import Wasp.Job.Process (runProcessAsJob) +import qualified Wasp.Message as Msg +import Wasp.Util.Docker (DockerImageName) +import qualified Wasp.Util.Docker as Docker + +ensureDockerDaemonAvailable :: Command () +ensureDockerDaemonAvailable = do + throwIfExeIsNotAvailable + "docker" + "To run PostgreSQL dev database, Wasp needs `docker` installed and in PATH." + liftIO Docker.checkDockerDaemonConnection >>= \case + Right () -> return () + Left dockerError -> + E.throwError $ + CommandError + "Couldn't connect to the Docker daemon" + ( "To run PostgreSQL dev database, Wasp needs Docker to be running." + <> " Make sure Docker is started (e.g. by opening Docker Desktop) and try again.\n\n" + <> "Docker reported:\n" + <> dockerError + ) + +ensureImageAvailable :: DockerImageName -> Command () +ensureImageAvailable dbDockerImage = do + (imageStatus, _, _) <- liftIO $ readProcessWithExitCode "docker" ["image", "inspect", dbDockerImage] "" + when (imageStatus /= ExitSuccess) $ do + cliSendMessageC $ Msg.Start $ printf "Pulling PostgreSQL image %s..." dbDockerImage + pullStatus <- liftIO $ runDockerJobAndPrintOutput ["pull", dbDockerImage] + when (pullStatus /= ExitSuccess) $ E.throwError $ CommandError "Could not pull PostgreSQL image" (printf "Check the image name, registry access, and network connection. Image: %s" dbDockerImage) + +runDockerJobAndPrintOutput :: [String] -> IO ExitCode +runDockerJobAndPrintOutput args = do + chan <- newChan + fst <$> concurrently (runProcessAsJob (proc "docker" args) Job.Db chan) (printDbMessages chan) + +printDbMessages :: Chan Job.JobMessage -> IO () +printDbMessages chan = runPrefixedWriter go + where + go = do + message <- liftIO $ readChan chan + case Job._data message of + Job.JobOutput output _ -> do + printJobMessagePrefixed $ Job.JobMessage (Job.JobOutput output Job.Stdout) Job.Db + go + Job.JobExit _ -> return () + +stopDatabase :: String -> Command () +stopDatabase containerId = do + cliSendMessageC $ Msg.Start "Stopping database..." + failure <- runDockerCleanup ["stop", containerId] + forM_ failure $ \errors -> + cliSendMessageC $ Msg.Warning "Could not stop PostgreSQL" (printf "Wasp will try to remove the container. %s" errors) + +removeContainer :: String -> Command () +removeContainer containerId = do + failure <- runDockerCleanup ["rm", "--force", containerId] + forM_ failure $ \errors -> + cliSendMessageC $ Msg.Warning "Could not remove PostgreSQL container" (printf "Try `docker rm --force %s`. %s" containerId errors) + +runDockerCleanup :: [String] -> Command (Maybe String) +runDockerCleanup args = do + -- create_group keeps terminal Ctrl+C from interrupting Docker's cleanup command. + (status, _, errors) <- liftIO $ readCreateProcessWithExitCode ((proc "docker" args) {create_group = True}) "" + return $ + if status == ExitSuccess || "No such container" `isInfixOf` errors + then Nothing + else Just errors diff --git a/waspc/cli/src/Wasp/Cli/Command/Db/StartOptions.hs b/waspc/cli/src/Wasp/Cli/Command/Db/StartOptions.hs new file mode 100644 index 0000000000..9286663401 --- /dev/null +++ b/waspc/cli/src/Wasp/Cli/Command/Db/StartOptions.hs @@ -0,0 +1,37 @@ +module Wasp.Cli.Command.Db.StartOptions + ( DbStartOptions (..), + dbStartOptionsParser, + ) +where + +import Network.Socket (PortNumber) +import qualified Options.Applicative as Opt +import Wasp.Cli.Util.PortArgument (portParser) +import Wasp.Db.Postgres (defaultPostgresPort) +import Wasp.Util.Docker (DockerImageName, DockerVolumeMountPath) + +data DbStartOptions = DbStartOptions + { dbPort :: Maybe PortNumber, + dbImage :: Maybe DockerImageName, + dbVolumeMountPath :: Maybe DockerVolumeMountPath + } + deriving (Eq, Show) + +dbStartOptionsParser :: Opt.Parser DbStartOptions +dbStartOptionsParser = + DbStartOptions + <$> Opt.optional (portParser "db-port" ("Port to run the dev database on (default: " ++ show defaultPostgresPort ++ ")")) + <*> Opt.optional + ( Opt.strOption + ( Opt.long "db-image" + <> Opt.metavar "IMAGE" + <> Opt.help "Docker image to use for the database" + ) + ) + <*> Opt.optional + ( Opt.strOption + ( Opt.long "db-volume-mount-path" + <> Opt.metavar "PATH" + <> Opt.help "Path inside Docker container where database files are stored" + ) + ) diff --git a/waspc/cli/src/Wasp/Cli/Command/Db/Studio.hs b/waspc/cli/src/Wasp/Cli/Command/Db/Studio.hs index eeb64b3fce..30e1998f35 100644 --- a/waspc/cli/src/Wasp/Cli/Command/Db/Studio.hs +++ b/waspc/cli/src/Wasp/Cli/Command/Db/Studio.hs @@ -1,5 +1,6 @@ module Wasp.Cli.Command.Db.Studio ( studio, + studioArgsParser, ) where @@ -12,6 +13,7 @@ import Wasp.Cli.Command.Db (makeDbCommand) import Wasp.Cli.Command.Message (cliSendMessageC) import Wasp.Cli.Command.Require.InWaspProject (InWaspProject (InWaspProject)) import Wasp.Cli.Command.Require.ValidNodeAndNpm (ValidNodeAndNpm (ValidNodeAndNpm)) +import Wasp.Cli.Util.Parser (ArgsParser (..)) import Wasp.Generator.DbGenerator.Jobs (runStudio) import Wasp.Generator.Setup (SetupGoal (PrismaCliReady)) import Wasp.Job.IO (readJobMessagesAndPrintThemPrefixed) @@ -30,3 +32,6 @@ studio = makeDbCommand [PrismaCliReady] $ \_appSpec -> do _ <- liftIO $ readJobMessagesAndPrintThemPrefixed chan `concurrently` runStudio genProjectDir chan error "This should never happen, studio should never stop." + +studioArgsParser :: ArgsParser () +studioArgsParser = ArgsParser "wasp db studio" (pure ()) diff --git a/waspc/cli/src/Wasp/Cli/Command/Start.hs b/waspc/cli/src/Wasp/Cli/Command/Start.hs index 87d89420ad..d838d36f97 100644 --- a/waspc/cli/src/Wasp/Cli/Command/Start.hs +++ b/waspc/cli/src/Wasp/Cli/Command/Start.hs @@ -9,6 +9,7 @@ import Control.Monad.Except (throwError) import Control.Monad.IO.Class (liftIO) import StrongPath (Abs, Dir, Path', ()) import qualified StrongPath as SP +import Text.Printf (printf) import Wasp.AppComponentUrl (AppComponentUrl) import Wasp.AppSpec (AppSpec) import Wasp.Cli.AppComponentPorts (findAppComponentPorts) @@ -16,6 +17,7 @@ import Wasp.Cli.AppComponentUrls (makeAppComponentUrls) import Wasp.Cli.Command (Command, CommandError (..), require) import Wasp.Cli.Command.Call (Arguments) import Wasp.Cli.Command.Compile (compile, printWarningsAndErrorsIfAny) +import qualified Wasp.Cli.Command.Db.DevDb as DevDb import Wasp.Cli.Command.Message (cliSendMessageC) import Wasp.Cli.Command.News (fetchAndListMustSeeNewsIfDue) import Wasp.Cli.Command.Require.DbConnectionEstablished (DbConnectionEstablished (DbConnectionEstablished)) @@ -33,13 +35,14 @@ import Wasp.Generator.WebAppGenerator.RunConfig (WebAppRunConfig) import qualified Wasp.Message as Msg import Wasp.Project (CompileError, CompileWarning) import Wasp.Project.Common (WaspProjectDir, findFileInWaspProjectDir, generatedAppDirInWaspProjectDir) +import qualified Wasp.Project.Db.Dev.Postgres as Dev.Postgres import qualified Wasp.Project.Env as Env -- | Does initial compile of wasp code and then runs the generated project. -- It also listens for any file changes and recompiles and restarts generated project accordingly. start :: Arguments -> Command () start = withArguments startArgsParser $ \args -> - ProjectLock.acquireWatcher $ \projectLock -> do + ProjectLock.acquireWatcher $ \projectLock -> DevDb.withDevDb args.dbStartOptions $ \managedDb -> do -- We check for the news only in `wasp start`, and only periodically, -- to avoid being too aggressive. Specifically: -- - We don't run it in other `wasp` commands because we don't want to @@ -66,7 +69,10 @@ start = withArguments startArgsParser $ \args -> cliSendMessageC $ Msg.Start "Listening for file changes..." cliSendMessageC $ Msg.Start "Starting up generated project..." - cliSendMessageC $ Msg.Info $ showRunConfigUrls runConfigs + let databaseUrlLine = case managedDb of + Nothing -> "" + Just db -> printf " ℹ Database: %s\n" (Dev.Postgres.getDevConnectionUrl db) + cliSendMessageC $ Msg.Info $ showRunConfigUrls runConfigs <> databaseUrlLine watchOrStartResult <- liftIO $ do -- This MVar is used to exchange information between the two processes below running in diff --git a/waspc/cli/src/Wasp/Cli/Command/Start/ArgumentsParser.hs b/waspc/cli/src/Wasp/Cli/Command/Start/ArgumentsParser.hs index 8482db6206..ed4bf69e6b 100644 --- a/waspc/cli/src/Wasp/Cli/Command/Start/ArgumentsParser.hs +++ b/waspc/cli/src/Wasp/Cli/Command/Start/ArgumentsParser.hs @@ -7,6 +7,7 @@ where import Network.Socket (PortNumber) import Network.URI (URI) import qualified Options.Applicative as Opt +import Wasp.Cli.Command.Db.StartOptions (DbStartOptions, dbStartOptionsParser) import Wasp.Cli.Util.HttpUrlArgument (httpUrlParser) import Wasp.Cli.Util.Parser (ArgsParser (..)) import Wasp.Cli.Util.PortArgument (portParser) @@ -15,7 +16,8 @@ data StartArgs = StartArgs { clientPort :: Maybe PortNumber, serverPort :: Maybe PortNumber, clientUrl :: Maybe URI, - serverUrl :: Maybe URI + serverUrl :: Maybe URI, + dbStartOptions :: DbStartOptions } deriving (Eq, Show) @@ -27,3 +29,4 @@ startArgsParser = <*> Opt.optional (portParser "server-port" "Port to run the server on") <*> Opt.optional (httpUrlParser "client-url" "URL at which the client is reachable") <*> Opt.optional (httpUrlParser "server-url" "URL at which the server is reachable") + <*> dbStartOptionsParser diff --git a/waspc/cli/src/Wasp/Cli/Command/Start/Db.hs b/waspc/cli/src/Wasp/Cli/Command/Start/Db.hs index 64148f4e97..fef50a95dd 100644 --- a/waspc/cli/src/Wasp/Cli/Command/Start/Db.hs +++ b/waspc/cli/src/Wasp/Cli/Command/Start/Db.hs @@ -3,15 +3,11 @@ module Wasp.Cli.Command.Start.Db ) where -import Control.Monad (when) +import Control.Concurrent.Async (wait) +import Control.Monad (forM_) import qualified Control.Monad.Except as E import Control.Monad.IO.Class (liftIO) -import Data.Maybe (isJust) -import Network.Socket (PortNumber) -import qualified Options.Applicative as Opt import StrongPath (Abs, Dir, File', Path', Rel, fromRelFile) -import System.Environment (lookupEnv) -import System.Exit (exitFailure) import Text.Printf (printf) import qualified Wasp.AppSpec as AS import qualified Wasp.AppSpec.App as AS.App @@ -19,22 +15,23 @@ import qualified Wasp.AppSpec.App.Db as AS.App.Db import qualified Wasp.AppSpec.Valid as ASV import Wasp.Cli.Command (Command, CommandError (CommandError), require) import Wasp.Cli.Command.Call (Arguments) -import Wasp.Cli.Command.Common (throwIfExeIsNotAvailable) import Wasp.Cli.Command.Compile (analyze) +import Wasp.Cli.Command.Db.DevDb + ( DatabaseSession (..), + DatabaseStartPolicy (..), + DatabaseUrlSource (..), + findDatabaseUrlSource, + withPostgresSession, + ) +import Wasp.Cli.Command.Db.StartOptions (DbStartOptions, dbStartOptionsParser) import Wasp.Cli.Command.Message (cliSendMessageC) import Wasp.Cli.Command.Require.InWaspProject (InWaspProject (InWaspProject)) import Wasp.Cli.Command.Require.WaspSpecAvailable (WaspSpecAvailable (WaspSpecAvailable)) -import Wasp.Cli.Port (resolvePort) import Wasp.Cli.Util.Parser (ArgsParser (..), withArguments) -import Wasp.Cli.Util.PortArgument (portParser) -import Wasp.Db.Postgres (defaultPostgresDockerImageSpec, defaultPostgresPort) import qualified Wasp.Message as Msg import Wasp.Project.Common (WaspProjectDir) import Wasp.Project.Db (databaseUrlEnvVarName) -import qualified Wasp.Project.Db.Dev.Postgres as Dev.Postgres import Wasp.Project.Env (dotEnvServer) -import Wasp.Util.Docker (DockerImageName, DockerVolumeMountPath) -import qualified Wasp.Util.Docker as Docker -- | Starts a "managed" dev database, where "managed" means that -- Wasp creates it and connects the Wasp app with it. @@ -56,142 +53,38 @@ start = withArguments startDbArgsParser $ \args -> do startPostgresDevDb waspProjectDir app.name - (dbPort args) - (dbImage args) - (dbVolumeMountPath args) + args where noteSQLiteDoesntNeedStart = cliSendMessageC . Msg.Info $ "Nothing to do! You are all good, you are using SQLite which doesn't need to be started." -startDbArgsParser :: ArgsParser StartDbArgs -startDbArgsParser = - ArgsParser "wasp start db" $ - StartDbArgs - <$> Opt.optional (portParser "db-port" ("Port to run the dev database on (default: " ++ show defaultPostgresPort ++ ")")) - <*> Opt.strOption - ( Opt.long "db-image" - <> Opt.metavar "IMAGE" - <> Opt.help "Docker image to use for the database" - <> Opt.showDefault - <> Opt.value (fst defaultPostgresDockerImageSpec) - ) - <*> Opt.strOption - ( Opt.long "db-volume-mount-path" - <> Opt.metavar "PATH" - <> Opt.help "Path inside Docker container where database files are stored" - <> Opt.showDefault - <> Opt.value (snd defaultPostgresDockerImageSpec) - ) - -data StartDbArgs = StartDbArgs - { dbPort :: Maybe PortNumber, - dbImage :: DockerImageName, - dbVolumeMountPath :: DockerVolumeMountPath - } +startDbArgsParser :: ArgsParser DbStartOptions +startDbArgsParser = ArgsParser "wasp start db" dbStartOptionsParser throwIfCustomDbAlreadyInUse :: AS.AppSpec -> Command () -throwIfCustomDbAlreadyInUse spec = do - throwIfDbUrlInEnv - throwIfDbUrlInServerDotEnv spec - where - throwIfDbUrlInEnv :: Command () - throwIfDbUrlInEnv = do - dbUrl <- liftIO $ lookupEnv databaseUrlEnvVarName - when (isJust dbUrl) $ - throwCustomDbAlreadyInUseError - ( "Wasp has detected existing " - <> databaseUrlEnvVarName - <> " var in your environment.\n" - <> "To have Wasp run the dev database for you, make sure you remove that env var first." - ) - - throwIfDbUrlInServerDotEnv :: AS.AppSpec -> Command () - throwIfDbUrlInServerDotEnv appSpec = - when (isThereDbUrlInServerDotEnv appSpec) $ - throwCustomDbAlreadyInUseError - ( printf - ( "Wasp has detected that you have defined %s env var in your %s file.\n" - <> "To have Wasp run the dev database for you, make sure you remove that env var first." - ) - databaseUrlEnvVarName - (fromRelFile (dotEnvServer :: Path' (Rel WaspProjectDir) File')) - ) - where - isThereDbUrlInServerDotEnv = any ((== databaseUrlEnvVarName) . fst) . AS.devEnvVarsServer - - throwCustomDbAlreadyInUseError :: String -> Command () - throwCustomDbAlreadyInUseError msg = - E.throwError $ CommandError "You are using custom database already" msg - -startPostgresDevDb :: Path' Abs (Dir WaspProjectDir) -> String -> Maybe PortNumber -> DockerImageName -> DockerVolumeMountPath -> Command () -startPostgresDevDb waspProjectDir appName requestedDbPort dbDockerImage dbDockerVolumeMountPath = do - throwIfExeIsNotAvailable - "docker" - "To run PostgreSQL dev database, Wasp needs `docker` installed and in PATH." - throwIfDockerDaemonIsNotReachable - - liftIO (Dev.Postgres.discoverProjectsRunningDevDb waspProjectDir appName) >>= \case - Just runningDb -> noteDbIsAlreadyRunningAndExit runningDb - Nothing -> startDbOnPort =<< resolveDevDbPort +throwIfCustomDbAlreadyInUse appSpec = do + databaseUrlSource <- liftIO $ findDatabaseUrlSource appSpec + forM_ databaseUrlSource $ \source -> + E.throwError $ CommandError "You are using custom database already" (message source) where - throwIfDockerDaemonIsNotReachable :: Command () - throwIfDockerDaemonIsNotReachable = - liftIO Docker.checkDockerDaemonConnection >>= \case - Right () -> return () - Left dockerError -> - E.throwError $ - CommandError - "Couldn't connect to the Docker daemon" - ( "To run PostgreSQL dev database, Wasp needs Docker to be running." - <> " Make sure Docker is started (e.g. by opening Docker Desktop) and try again.\n\n" - <> "Docker reported:\n" - <> dockerError - ) - - resolveDevDbPort :: Command PortNumber - resolveDevDbPort = - resolvePort - requestedDbPort - defaultPostgresPort - [] - "Choose a different port with --db-port, or free up this one." - "Free at least one of those ports by exiting the program listening on it, or choose the port yourself with --db-port." - - noteDbIsAlreadyRunningAndExit :: Dev.Postgres.DevDbSpec -> Command () - noteDbIsAlreadyRunningAndExit devDbSpec = do - cliSendMessageC . Msg.Info . unlines $ - ("Your PostgreSQL dev database is already running on port " ++ show devDbSpec.port ++ ".") - : additionalInfoLines devDbSpec - liftIO exitFailure - - startDbOnPort :: PortNumber -> Command () - startDbOnPort port = do - let devDbSpec = Dev.Postgres.makeDevPostgresDbSpec waspProjectDir appName port - cliSendMessageC . Msg.Info . unlines $ - "✨ Starting a PostgreSQL dev database (based on your Wasp config) ✨" - : additionalInfoLines devDbSpec - <> dockerRunInfoLines - cliSendMessageC $ Msg.Info "..." - liftIO $ Dev.Postgres.runDevPostgresDb devDbSpec dbDockerImage dbDockerVolumeMountPath - - additionalInfoLines :: Dev.Postgres.DevDbSpec -> [String] - additionalInfoLines devDbSpec = - [ "", - "Additional info:", - " ℹ Connection URL, in case you might want to connect with external tools:", - " " <> Dev.Postgres.getDevConnectionUrl devDbSpec, - " ℹ Database data is persisted in a Docker volume with the following name" - <> " (useful to know if you will want to delete it at some point):", - " " <> devDbSpec.dockerVolumeName - ] - - -- These lines describe what `docker run` is about to use, so we print them - -- only when starting the database: an already running container might have - -- been started with a different image or mount path than the current - -- invocation's arguments. - dockerRunInfoLines :: [String] - dockerRunInfoLines = - [ " ℹ Using Docker image: " <> dbDockerImage, - " with the data volume mounted at: " <> dbDockerVolumeMountPath - ] + message source = case source of + EnvironmentVariable -> + printf + "Wasp has detected existing %s var in your environment.\nTo have Wasp run the dev database for you, make sure you remove that env var first." + databaseUrlEnvVarName + ServerDotEnvFile -> + printf + "Wasp has detected that you have defined %s env var in your %s file.\nTo have Wasp run the dev database for you, make sure you remove that env var first." + databaseUrlEnvVarName + (fromRelFile (dotEnvServer :: Path' (Rel WaspProjectDir) File')) + +startPostgresDevDb :: Path' Abs (Dir WaspProjectDir) -> String -> DbStartOptions -> Command () +startPostgresDevDb waspProjectDir appName options = + withPostgresSession waspProjectDir appName options RequireNewDatabase $ \case + StartedDatabase _ _ databaseJob -> do + cliSendMessageC $ Msg.Info "PostgreSQL is running. Ctrl+C stops PostgreSQL." + _ <- liftIO $ wait databaseJob + E.throwError $ CommandError "PostgreSQL stopped" "The database container exited. Check the PostgreSQL logs above." + ReusedDatabase _ -> + E.throwError $ CommandError "Database not started" "No managed PostgreSQL database was started." diff --git a/waspc/cli/tests/DbMigrateTest.hs b/waspc/cli/tests/DbMigrateTest.hs new file mode 100644 index 0000000000..a297c0badb --- /dev/null +++ b/waspc/cli/tests/DbMigrateTest.hs @@ -0,0 +1,24 @@ +module DbMigrateTest where + +import qualified Options.Applicative as Opt +import Test.Hspec +import Wasp.Cli.Command.Db.Migrate (migrateArgsParser) +import Wasp.Cli.Command.Db.StartOptions (DbStartOptions (..), dbStartOptionsParser) +import Wasp.Cli.Util.Parser (ArgsParser (optParser)) +import Wasp.Generator.DbGenerator.Common (MigrateArgs (..), defaultMigrateArgs) + +spec_databaseOptions :: Spec +spec_databaseOptions = do + it "parses database and migration options together" $ do + parseOptions ["--name", "new model", "--db-image", "postgis:18", "--create-only", "--db-port", "5544"] + `shouldBe` Right (DbStartOptions (Just 5544) (Just "postgis:18") Nothing, MigrateArgs (Just "new model") True) + parseOptions [] `shouldBe` Right (DbStartOptions Nothing Nothing Nothing, defaultMigrateArgs) + where + parseOptions = parse ((,) <$> dbStartOptionsParser <*> optParser migrateArgsParser) + +parse :: Opt.Parser a -> [String] -> Either String a +parse parser args = + case Opt.execParserPure Opt.defaultPrefs (Opt.info parser Opt.fullDesc) args of + Opt.Success value -> Right value + Opt.Failure failure -> Left $ fst $ Opt.renderFailure failure "wasp db migrate-dev" + Opt.CompletionInvoked _ -> Left "Unexpected completion" diff --git a/waspc/e2e-tests/Tests/WaspDbStartTest.hs b/waspc/e2e-tests/Tests/WaspDbStartTest.hs index 533a2c92f5..1c612c06ac 100644 --- a/waspc/e2e-tests/Tests/WaspDbStartTest.hs +++ b/waspc/e2e-tests/Tests/WaspDbStartTest.hs @@ -1,9 +1,10 @@ module Tests.WaspDbStartTest (waspDbStartTest) where +import Control.Monad.Reader (ask) import ShellCommands ( ShellCommand, ShellCommandBuilder, - WaspProjectContext, + WaspProjectContext (..), assertCommandOutputContains, createTestWaspProject, inTestWaspProjectDir, @@ -34,91 +35,104 @@ waspDbStartTest = ] ), TestCase - "fail-postgresql-project-when-dev-db-not-running" + "fail-sqlite-docker-option" ( sequence [ createTestWaspProject minimalStarterTemplate, inTestWaspProjectDir - [ setWaspDbToPSQL, - assertCommandOutputContains - (return waspCliDbMigrateDevFails) - "The database needs to be running" + [ assertCommandOutputContains + (return "! $WASP_CLI_CMD db migrate-dev --db-image postgres:18") + "only apply to Wasp-managed PostgreSQL" ] ] ), - -- NOTE: Tasty runs test cases in parallel, so the PostgreSQL scenarios (which - -- compete for the same host ports) are all in a single sequential test case. - TestCase - "succeed-postgresql-project" - ( skipIfDockerDisabled . sequence $ - [ createTestWaspProject minimalStarterTemplate, - inTestWaspProjectDir - [ setWaspDbToPSQL, - -- Test 1: Does `wasp db start` work? - waspCliDbStartInBackground, - -- Test 2: Does a Wasp command find the database and connect to it - -- after `wasp db start` says it's ready? - waitUntilDevDbReportsItIsReady, - waspCliDbMigrateDev "first_migration", - -- Test 3: Does the second `wasp db start` detect and report - -- an already running dev database? - assertCommandOutputContains - (return waspCliDbStartFails) - "already running on port", - -- Test 4: - -- - Does SIGINT stop the database and delete the container? - -- If it didn't delete the container, the next `wasp db start` would fail - -- with a container name conflict. - -- - Does `wasp db start` find a new port when the default one is taken? - stopWaspCliDbStartWithSigint, - occupyDefaultDevDbPort, - waspCliDbStartInBackground, - waitUntilDevDbReportsItIsReady, - -- Test 5: Does a Wasp command find and connect to the database - -- even when it's running on a non-default port? - waspCliDbMigrateDev "no_new_migration", - removeDefaultDevDbPortHolder, - stopWaspCliDbStartWithSigint, - -- Test 6: Can the user remove the volume reported by `wasp db start`? - removeReportedDevDbVolume - ] - ] - ) + postgresTestCase + "migration-reuses-running-database" + [ waspCliDbStartInBackground (Just 15432), + waitUntilDevDbReportsItIsReady, + waspCliDbMigrateDev "first_migration", + assertDevDbRunning, + assertCommandOutputContains + (return waspCliDbStartFails) + "PostgreSQL already running", + stopDevDbAndWait, + assertDevDbRemoved, + removeReportedDevDbVolume + ], + postgresTestCase + "migration-and-reset-recreate-missing-database" + [ waspCliDbStartInBackground (Just 15435), + waitUntilDevDbReportsItIsReady, + dropDevDb, + waspCliDbMigrateDev "first_migration", + dropDevDb, + return "$WASP_CLI_CMD db reset --force", + assertDevDbRunning, + stopDevDbAndWait, + assertDevDbRemoved, + removeReportedDevDbVolume + ], + postgresTestCase + "startup-uses-another-port-when-default-is-occupied" + [ occupyDefaultDevDbPort, + waspCliDbStartInBackground Nothing, + waitUntilDevDbReportsItIsReady, + waspCliDbMigrateDev "first_migration", + assertDevDbRunning, + removeDefaultDevDbPortHolder, + stopDevDbAndWait, + assertDevDbRemoved, + removeReportedDevDbVolume + ], + postgresTestCase + "migration-starts-and-removes-database" + [ return "$WASP_CLI_CMD db migrate-dev --name first_migration --db-port 15433", + assertDevDbRemoved + ], + postgresTestCase + "reset-starts-and-removes-database" + [ return "$WASP_CLI_CMD db reset --force --db-port 15434", + assertDevDbRemoved + ] ] where waspCliDbStartFails :: ShellCommand waspCliDbStartFails = "! $WASP_CLI_CMD db start" - waspCliDbMigrateDevFails :: ShellCommand - waspCliDbMigrateDevFails = "! $WASP_CLI_CMD db migrate-dev" +postgresTestCase :: String -> [ShellCommandBuilder WaspProjectContext ShellCommand] -> TestCase +postgresTestCase name commands = + TestCase name + $ skipIfDockerDisabled + $ sequence + [ createTestWaspProject minimalStarterTemplate, + inTestWaspProjectDir $ [setWaspDbToPSQL, installDbCleanup] ++ commands + ] -- | `wasp db start` runs the database in the foreground, so we background it. -- We capture its output to test whether it correctly reports its readiness and volume name. -waspCliDbStartInBackground :: ShellCommandBuilder WaspProjectContext ShellCommand -waspCliDbStartInBackground = +waspCliDbStartInBackground :: Maybe Int -> ShellCommandBuilder WaspProjectContext ShellCommand +waspCliDbStartInBackground port = return $ - "rm -f " ++ devDbOutputFile ++ " && { $WASP_CLI_CMD db start > " ++ devDbOutputFile ++ " 2>&1 & echo $! > db-start.pid ; }" - --- | Stops the dev db the way Ctrl+C on `wasp db start` would - Postgres --- receives SIGINT and shuts down. --- --- We send the signal directly the container instead of `wasp db start` because --- Wasp ignores SIGINT when it has a child process. Wasp expects the child to --- handle the signal and exits after the child exits. --- --- In a terminal, Ctrl+C sends SIGINT to the entire process group, which means --- both Wasp and the container get it. Wasp ignores it, the container handles it --- and exists, which then causes Wasp to exit. -stopWaspCliDbStartWithSigint :: ShellCommandBuilder WaspProjectContext ShellCommand -stopWaspCliDbStartWithSigint = + "rm -f " ++ devDbOutputFile ++ " && { $WASP_CLI_CMD db start" ++ portOption ++ " > " ++ devDbOutputFile ++ " 2>&1 & echo $! > db-start.pid ; }" + where + portOption = maybe "" ((" --db-port " ++) . show) port + +-- Signal PostgreSQL directly to avoid relying on terminal signal forwarding. +-- Wait for Wasp to finish cleanup before checking the container or volume. +-- Wasp reports the stopped database as an error, so a nonzero exit is expected. +stopDevDbAndWait :: ShellCommandBuilder WaspProjectContext ShellCommand +stopDevDbAndWait = return $ - "{ docker kill --signal INT \"$(docker ps -q --filter volume=" + "{ docker kill --signal INT \"$(docker ps -q --filter \"volume=" ++ reportedDevDbVolumeName - ++ ")\" && wait \"$(cat db-start.pid)\" || true ; }" + ++ "\")\" && { wait \"$(cat db-start.pid)\" || true; } && rm db-start.pid; }" +-- Wasp prints the volume name after its database readiness check succeeds. waitUntilDevDbReportsItIsReady :: ShellCommandBuilder WaspProjectContext ShellCommand waitUntilDevDbReportsItIsReady = return $ - "{ retries=180; until grep -q 'listening on IPv4 address' " + "{ retries=180; until grep -q '" + ++ Dev.Postgres.waspDevDbDockerVolumePrefix + ++ "' " ++ devDbOutputFile ++ "; do retries=$((retries - 1)); [ \"$retries\" -gt 0 ] || exit 1; sleep 1; done ; }" @@ -126,10 +140,11 @@ devDbOutputFile :: FilePath devDbOutputFile = "db-start-output.log" occupyDefaultDevDbPort :: ShellCommandBuilder WaspProjectContext ShellCommand -occupyDefaultDevDbPort = +occupyDefaultDevDbPort = do + containerName <- devDbPortHolderContainerName return $ "docker run -d --rm --name " - ++ devDbPortHolderContainerName + ++ containerName ++ " -p " ++ defaultPort ++ ":" @@ -139,7 +154,7 @@ occupyDefaultDevDbPort = defaultPort = show defaultPostgresPort removeDefaultDevDbPortHolder :: ShellCommandBuilder WaspProjectContext ShellCommand -removeDefaultDevDbPortHolder = return $ "docker rm -f " ++ devDbPortHolderContainerName +removeDefaultDevDbPortHolder = ("docker rm -f " ++) <$> devDbPortHolderContainerName removeReportedDevDbVolume :: ShellCommandBuilder WaspProjectContext ShellCommand removeReportedDevDbVolume = @@ -149,7 +164,41 @@ removeReportedDevDbVolume = -- because it's the same place users learn it from. reportedDevDbVolumeName :: String reportedDevDbVolumeName = - "$(grep -o -m 1 '" ++ Dev.Postgres.waspDevDbDockerVolumePrefix ++ "[^ ]*' " ++ devDbOutputFile ++ ")" + "$(grep -o -m 1 '" ++ Dev.Postgres.waspDevDbDockerVolumePrefix ++ "[a-zA-Z0-9_-]*' " ++ devDbOutputFile ++ ")" -devDbPortHolderContainerName :: String -devDbPortHolderContainerName = "wasp-e2e-tests-db-port-holder" +devDbPortHolderContainerName :: ShellCommandBuilder WaspProjectContext String +devDbPortHolderContainerName = do + db <- testDevDb + return $ db.dockerContainerName ++ "-port-holder" + +testDevDb :: ShellCommandBuilder WaspProjectContext Dev.Postgres.DevDbSpec +testDevDb = do + context <- ask + return $ Dev.Postgres.makeDevPostgresDbSpec context.waspProjectDir "waspApp" defaultPostgresPort + +assertDevDbRunning :: ShellCommandBuilder WaspProjectContext ShellCommand +assertDevDbRunning = + return $ "test -n \"$(docker ps -q --filter \"volume=" ++ reportedDevDbVolumeName ++ "\")\"" + +dropDevDb :: ShellCommandBuilder WaspProjectContext ShellCommand +dropDevDb = do + db <- testDevDb + return $ unwords ["docker", "exec", db.dockerContainerName, "dropdb", "--username", db.user, "--force", db.dbName] + +assertDevDbRemoved :: ShellCommandBuilder WaspProjectContext ShellCommand +assertDevDbRemoved = do + db <- testDevDb + return $ "test -z \"$(docker ps -aq --filter \"volume=" ++ db.dockerVolumeName ++ "\")\"" + +installDbCleanup :: ShellCommandBuilder WaspProjectContext ShellCommand +installDbCleanup = do + db <- testDevDb + portHolder <- devDbPortHolderContainerName + return $ + "trap 'if [ -f db-start.pid ]; then kill \"$(cat db-start.pid)\" 2>/dev/null || true; wait \"$(cat db-start.pid)\" 2>/dev/null || true; fi; docker rm -f " + ++ db.dockerContainerName + ++ " " + ++ portHolder + ++ " >/dev/null 2>&1 || true; docker volume rm " + ++ db.dockerVolumeName + ++ " >/dev/null 2>&1 || true' EXIT" diff --git a/waspc/src/Wasp/Project/Db/Dev/Postgres.hs b/waspc/src/Wasp/Project/Db/Dev/Postgres.hs index df67620861..5e1b068c9b 100644 --- a/waspc/src/Wasp/Project/Db/Dev/Postgres.hs +++ b/waspc/src/Wasp/Project/Db/Dev/Postgres.hs @@ -1,7 +1,8 @@ -- | This module captures how Wasp runs a PostgreSQL dev database. module Wasp.Project.Db.Dev.Postgres ( makeDevPostgresDbSpec, - runDevPostgresDb, + createDevPostgresContainer, + waitForDevDbReady, DevDbSpec (..), getDevConnectionUrl, discoverProjectsRunningDevDb, @@ -9,13 +10,16 @@ module Wasp.Project.Db.Dev.Postgres ) where +import Control.Monad (unless) import Network.Socket (PortNumber) import StrongPath (Abs, Dir, Path') -import System.Process (callCommand) +import System.Exit (ExitCode (..)) +import System.Process (CreateProcess (create_group), proc, readCreateProcessWithExitCode, readProcessWithExitCode) import Text.Printf (printf) import Wasp.Db.Postgres (defaultPostgresPort, makeConnectionUrl, postgresMaxDbNameLength) import Wasp.Project.Common (WaspProjectDir, makeAppUniqueId) import Wasp.Util.Docker (DockerImageName, DockerVolumeMountPath, discoverHostPortForDockerContainersInternalPort) +import qualified Wasp.Util.IO.Retry as Retry data DevDbSpec = DevDbSpec { dockerVolumeName :: String, @@ -41,26 +45,48 @@ getDevConnectionUrl :: DevDbSpec -> String getDevConnectionUrl devDbSpec = makeConnectionUrl devDbSpec.user devDbSpec.password devDbSpec.port devDbSpec.dbName -runDevPostgresDb :: DevDbSpec -> DockerImageName -> DockerVolumeMountPath -> IO () -runDevPostgresDb devDbSpec dbDockerImage dbDockerVolumeMountPath = - callCommand runDbCommand +createDevPostgresContainer :: DevDbSpec -> DockerImageName -> DockerVolumeMountPath -> IO String +createDevPostgresContainer db image mountPath = do + -- create_group keeps Docker outside the terminal's Ctrl+C group so it can return the container ID needed for cleanup. + (status, output, errors) <- readCreateProcessWithExitCode ((proc "docker" args) {create_group = True}) "" + case (status, words output) of + (ExitSuccess, [containerId]) -> return containerId + _ -> ioError $ userError $ printf "Could not create PostgreSQL container. %s" errors where -- NOTE: POSTGRES_PASSWORD, POSTGRES_USER, POSTGRES_DB below are really used by the docker image -- only when initializing the database -> if the volume was created previously, they will be ignored. -- This is how the postgres Docker image works. - runDbCommand = - unwords - [ "docker run", - printf "--name %s" devDbSpec.dockerContainerName, - "--rm", - printf "--publish %s:%s" (show devDbSpec.port) (show postgresImageInternalPort), - printf "-v %s:%s" devDbSpec.dockerVolumeName dbDockerVolumeMountPath, - printf "--env POSTGRES_PASSWORD=%s" devDbSpec.password, - printf "--env POSTGRES_USER=%s" devDbSpec.user, - printf "--env POSTGRES_DB=%s" devDbSpec.dbName, - dbDockerImage + args = + concat + [ ["create", "--rm"], + ["--name", db.dockerContainerName], + ["--publish", printf "%s:%s" (show db.port) (show defaultPostgresPort)], + ["-v", printf "%s:%s" db.dockerVolumeName mountPath], + ["--env", printf "POSTGRES_PASSWORD=%s" db.password], + ["--env", printf "POSTGRES_USER=%s" db.user], + ["--env", printf "POSTGRES_DB=%s" db.dbName], + [image] + ] + +waitForDevDbReady :: DevDbSpec -> IO () +waitForDevDbReady devDbSpec = do + ready <- Retry.retryUntil (Retry.constPause 1000000) 59 $ isPostgresAcceptingConnections devDbSpec + unless ready $ do + (_, output, errors) <- readProcessWithExitCode "docker" ["logs", "--tail", "30", devDbSpec.dockerContainerName] "" + ioError $ userError $ printf "PostgreSQL did not become ready. Check the logs below, then try again.\n%s%s" output errors + +isPostgresAcceptingConnections :: DevDbSpec -> IO Bool +isPostgresAcceptingConnections devDbSpec = do + (exitCode, _, _) <- readProcessWithExitCode "docker" args "" + return $ exitCode == ExitSuccess + where + args = + concat + [ ["exec", devDbSpec.dockerContainerName, "pg_isready"], + ["-h", "127.0.0.1"], + ["-U", devDbSpec.user], + ["-d", "postgres", "-q"] ] - postgresImageInternalPort = defaultPostgresPort -- | Returns all relevant info about this Wasp project's dev detabase if its -- container is running, 'Nothing' otherwise. diff --git a/waspc/src/Wasp/Util/IO/Retry.hs b/waspc/src/Wasp/Util/IO/Retry.hs index d429803e2d..c97f1d600f 100644 --- a/waspc/src/Wasp/Util/IO/Retry.hs +++ b/waspc/src/Wasp/Util/IO/Retry.hs @@ -2,6 +2,7 @@ module Wasp.Util.IO.Retry ( retry, + retryUntil, retryWithCallback, constPause, linearPause, @@ -15,6 +16,7 @@ module Wasp.Util.IO.Retry where import Control.Concurrent (threadDelay) +import Data.Either (isRight) import Numeric.Natural (Natural) import Prelude hiding (readFile, writeFile) @@ -25,6 +27,16 @@ import Prelude hiding (readFile, writeFile) retry :: (MonadRetry m) => PauseStrategy -> Natural -> m (Either e a) -> m (Either e a) retry pauseStrategy maxNumRetries = retryWithCallback pauseStrategy maxNumRetries (\_ _ -> pure ()) +-- | Repeats a check until it returns True or the retries are exhausted. +retryUntil :: (MonadRetry m) => PauseStrategy -> Natural -> m Bool -> m Bool +retryUntil pauseStrategy maxNumRetries check = do + result <- retry pauseStrategy maxNumRetries attempt + return $ isRight result + where + attempt = do + ready <- check + return $ if ready then Right () else Left () + -- | Same as 'retry', but also runs provided onRetry callback after each failed try -- that will be retried, right before the pause. The callback receives the number -- of failed tries so far (starting at 1) and the error from the latest try. diff --git a/waspc/tests/Util/IO/RetryTest.hs b/waspc/tests/Util/IO/RetryTest.hs index 4afdaf99ad..18087f8180 100644 --- a/waspc/tests/Util/IO/RetryTest.hs +++ b/waspc/tests/Util/IO/RetryTest.hs @@ -4,6 +4,7 @@ module Util.IO.RetryTest where import Control.Monad (forM_) import Control.Monad.State (MonadState (get), State, modify, runState) +import Data.Either (isRight) import Numeric.Natural (Natural) import Test.Hspec (Spec, describe, it, shouldBe) import qualified Wasp.Util.IO.Retry as R @@ -38,6 +39,14 @@ spec_RetryTest = do it "for expPause" $ testPause (R.expPause 10) (10, 20, 40) it "for customPause" $ testPause (R.customPause (^ (2 :: Int))) (1, 4, 9) + describe "retryUntil" $ do + it "stops when the check succeeds" $ do + runState (R.retryUntil (R.constPause 42) 5 (isRight <$> mockAction (NumFails 1))) [] + `shouldBe` (True, [ActionCall, ThreadDelayCall 42, ActionCall]) + it "returns False after the last attempt without another pause" $ do + runState (R.retryUntil (R.constPause 42) 1 (isRight <$> mockAction (NumFails 3))) [] + `shouldBe` (False, [ActionCall, ThreadDelayCall 42, ActionCall]) + describe "retryWithCallback" $ do it "does not call onRetry when action succeeds on the first try" $ do runMockRetryWithCallback (R.constPause 42) 2 (mockAction (NumFails 0)) diff --git a/waspc/waspc.cabal b/waspc/waspc.cabal index 9e72ee4cf2..e7f312b24e 100644 --- a/waspc/waspc.cabal +++ b/waspc/waspc.cabal @@ -469,9 +469,12 @@ library cli-lib Wasp.Cli.Command.CreateNewProject.StarterTemplates.GhReleaseArchive Wasp.Cli.Command.CreateNewProject.StarterTemplates.Templating Wasp.Cli.Command.Db + Wasp.Cli.Command.Db.DevDb + Wasp.Cli.Command.Db.Docker Wasp.Cli.Command.Db.Migrate Wasp.Cli.Command.Db.Reset Wasp.Cli.Command.Db.Seed + Wasp.Cli.Command.Db.StartOptions Wasp.Cli.Command.Db.Studio Wasp.Cli.Command.Deploy Wasp.Cli.Command.Deps @@ -648,6 +651,7 @@ test-suite wasp-cli-tests hspec, network, network-uri, + optparse-applicative, QuickCheck, tasty, tasty-hspec, @@ -655,6 +659,7 @@ test-suite wasp-cli-tests waspc, other-modules: + DbMigrateTest Paths_waspc TerminalTest Wasp.Cli.Command.CreateNewProject.ProjectDescriptionTest