Initialization error when using unsafe.implicits.global within IOApp

[gvolpe]

While updating some examples that demonstrate what not to do, I bumped into this issue. Here's my example.

import scala.concurrent.duration._

import cats.effect._
import cats.effect.std.{ Semaphore, Supervisor }
import cats.effect.unsafe.implicits.global

object LeakyState extends IOApp.Simple {

  // global access
  val sem: Semaphore[IO] =
    Semaphore[IO](1).unsafeRunSync()

  def launchMissiles: IO[Unit] =
    sem.permit
      .use { _ =>
        IO.println("Launching missiles") >>
          IO.sleep(3.seconds) >>
          IO.println("Missiles launched, releasing lock")
      }

  def randomSleep: IO[Unit] =
    IO(scala.util.Random.nextInt(100)).flatMap { ms =>
      IO.sleep((ms + 700).millis)
    }.void

  def p1: IO[Unit] =
    sem.permit.use(_ => IO.println("Running P1")) >> randomSleep

  def p2: IO[Unit] =
    sem.permit.use(_ => IO.println("Running P2")) >> randomSleep

  def run: IO[Unit] =
    Supervisor[IO].use { s =>
      s.supervise(launchMissiles) *>
        s.supervise(p1.foreverM).void *>
        s.supervise(p2.foreverM).void *>
        IO.sleep(5.seconds).void
    }

}

Initializing (unsafely) the Semaphore fails with this error.

[info] running (fork) examples.state.LeakyState
[error] Exception in thread "main" java.lang.IllegalArgumentException: requirement failed
[error] 	at scala.Predef$.require(Predef.scala:325)
[error] 	at cats.effect.unsafe.IORuntimeCompanionPlatform.installGlobal(IORuntimeCompanionPlatform.scala:67)
[error] 	at cats.effect.IOApp.main(IOApp.scala:58)
[error] 	at cats.effect.IOApp.main$(IOApp.scala:35)
[error] 	at examples.state.LeakyState$.main(LeakyState.scala:9)
[error] 	at examples.state.LeakyState.main(LeakyState.scala)

Even when setting Compile / run / fork := true in build.sbt.

The workaround is to make it a lazy val together with forking enabled in sbt. So this does not work in Scastie: https://scastie.scala-lang.org/v7S7tnCsQ9yAL9gMSnxyhw

Since this example showcases exactly what users should not do, I don't expect a fix but raising the issue in case this could be a legit bug when interoping with side-effectful frameworks, e.g. initializing an ActorSystem within IOApp.

[oleg-py]

What happens here seems to be the following:

• LeakyState.<init> forces init of the unsafe.implicits.global which writes the mutable global where runtime is stored
• LeakyState.main() tries to overwrite the mutable global and fails.

This is different from general Scastie issue which arises b/c it keeps JARs loaded and needs manually adding turbo := false in extra sbt settings. Both those issues are super confusing btw. Also, it seems that it wouldn't help to use this.runtime there since it's not initialized in <init>

Would be great if we could somehow fix both issues.

[djspiewak]

Hmm, we can definitely turn this into a compile error, but I'm not exactly sure how we can fix it without creating even more surprising behavior.

The problem here is the fact that we have implemented the ability to configure the runtime by overrideing values in IOApp. This is cool, but we also want to make sure that people don't create redundant runtimes within their application when using IOApp and using unsafeRun at varying inner levels without Dispatcher. Thus, the global runtime and the IOApp runtime are the same thing, which in turn leads us to this awkward initialization problem.

The correct approach for users is probably to leverage a dual-type constructor (#1863) and initialize the Semaphore in SyncIO instead of IO. I think that, from our side, we should probably add a pair of dummy implicit IORuntimes to IOApp, just to make this common case an error. It won't be impossible to avoid this in general, but it'll be less likely.

[oleg-py]

Would initializing and setting the global runtime in <init> not help?

I'm 👎 on the two implicit thing. It just pushes the problem further a bit, but I can still hit the issue silently by having a global semaphore in some other object which uses unsafe runtime, and then just refer to it from IOApp in a val while also punishing the cases where I want to use the runtime from IOApp as an implicit (also, if it's done in <init>, a user of IOApp will be able to mark it as implicit and use directly instead of importing the global; which we can suggest for a fix).

One thing that definitely can be done quickly is adding a friendly error message, along the lines of:
"Detected an attempt to initialize IORuntime twice. This is possibly caused by using unsafe.implicits to unsafeRunSync in class initialization code, or compiling in turbo mode. In Scastie, try adding turbo := false to sbt configuration". That's a much better thing than "requirement failed".

Also how does the following sound:

• Subclass IORuntime in IOAppCompanion (e.g. IOAppRuntime);
• When setting the global, check if it's IOAppRuntime. If it is, then just silently use existing and don't make a new one (skip Scastie issue). If it's not (imported from unsafe and used prematurely), complain to console about runtime used prematurely, suggesting fixes and noting that the thread pools might not be shut down, and still not initialize a new one.

[lambdista]

I stumbled upon the same problem, at least I guess. Trying to switch to http4s 0.23.0-RC1, with cats-effect 3.1.1 and Scala 2.13.6, when I run the server I get:

Exception in thread "main" java.lang.IllegalArgumentException: requirement failed
  at scala.Predef$.require(Predef.scala:324)
  at cats.effect.unsafe.IORuntimeCompanionPlatform.installGlobal(IORuntimeCompanionPlatform.scala:67)
  at cats.effect.IOApp.main(IOApp.scala:58)
  at cats.effect.IOApp.main$(IOApp.scala:35)
  at api.Server$.main(Server.scala:19)
  at api.Server.main(Server.scala)

The server is:

import scala.concurrent.ExecutionContext.global

import cats.data.Kleisli
import cats.effect._
import org.http4s.{Request, Response}
import org.http4s.blaze.server.BlazeServerBuilder
import org.http4s.server.Router
import org.http4s.syntax.kleisli._

object Server extends IOApp {
  // port and host vals
  val httpApp: Kleisli[IO, Request[IO], Response[IO]] = ...

  override def run(args: List[String]): IO[ExitCode] =
    BlazeServerBuilder[IO](global)
      .bindHttp(port, host)
      .withHttpApp(httpApp)
      .serve
      .compile
      .drain
      .as(ExitCode.Success)
}

[djspiewak]

What is val httpApp doing? The OP issue arises when IORuntime.global is initialized prior to main getting a chance to run, which almost always means that some sort of val is hitting it.

[lambdista]

Indeed, I've just turned val httpApp into def httpApp and now the error is gone. Thanks. FTR: lazy val works too.

[vasilmkd]

But this situation is still far from ideal...

[djspiewak]

But this situation is still far from ideal...

Very much so. I'm still thinking about ways to resolve it