Is there a way to use sbt run with all its niceness but also load the application eagerly?

[hilcode]

I really like being able to see the console output and being able to kill the app by just hitting enter but it's super annoying to have to make a request just so that the application actually starts.

[wsargent]

You can use sbt runProd.

[hilcode]

Unfortunately, runProd is nothing like run: it starts the app in the background (making it a pain to stop) and shows no console output.

[francisdb]

and https://github.com/spray/sbt-revolver

[hilcode]

Mmm, I don't really want to add a plugin for this and it changes how the app behaves. I have no problem killing and restarting the app, the pain is that it doesn't load eagerly.

Still, thank you for the pointer.

[francisdb]

There is a very old related ticket
#4967

I wonder what part of the play code exactly is triggering the application load after the first request

[hilcode]

Too bad that ticket just got closed without providing a good reason or an alternative. :-(

It would seem simple enough to add an --eager flag or something like that to sbt run?

(Mind you, I don't even understand what the benefits are of not running the initialization code: the app is useless until that happens whether you run in "dev" or "prod" mode.)

[francisdb]

My guess is that it's done to avoid continuous compiling/restarting when not required. Could be a heavy hit on a laptop battery for example.
But I also hit this in the past where I wanted to test app startup and had to force a request every time.

[mkurz]

In dev mode, the code that triggers an application reload / (re-)compile can be found here:

playframework/transport/server/play-server/src/main/scala/play/core/server/DevServerStart.scala

Lines 179 to 197 in 18bf4b0

	def get: Try[Application] = {
	// Block here while the reload happens. Reloading may take seconds or minutes
	// so this is a potentially very long operation!
	// TODO: Make this method return a Future[Application] so we don't need to block more than one thread.
	if (isShutdown.get()) {
	// If the app was shutdown already, we return the old app (if it exists)
	// This avoids that reload will be called which might triggers a compilation
	lastState
	} else {
	synchronized {
	buildLink.reload match {
	case cl: ClassLoader => reload(cl) // New application classes
	case null => lastState // No change in the application classes
	case NonFatal(t) => Failure(t) // An error we can display
	case t: Throwable => throw t // An error that we can't handle
	}
	}
	}
	}

So what happens is that in a server backend this applicationProvider.get is called, which in DEV mode checks if a file was modified and eventually a re-compile happens:

playframework/transport/server/play-akka-http-server/src/main/scala/play/core/server/AkkaHttpServer.scala

Line 302 in 18bf4b0

val tryApp = applicationProvider.get

As you can see this happens inside the handleRequest method.
So to load/compile the app eagerly, this get method(or the reload method?) has to be called once. I am not sure if it is as easy as that, but it would be worth a try. Also, I would prefer if that would be not the default, but only when running Play with a flag (or sbt setting).

Feel free to give it a shot and provide a pull request 😉

[hilcode]

Thank you. I did see this code but I will explore a bit more. And yes, I agree that we should not just change the default behaviour. :-)