fix: shutdown the environment properly

and remove the various 'default' methods creating default
components with a default Environment. This is not safe
since one might forget to shutdown the env afterwards
and / or does not know who else is using it

Author: etorreborre

common/shared/src/main/scala/org/specs2/concurrent/ExecutionEnv.scala common/js/src/main/scala/org/specs2/concurrent/ExecutionEnv.scala

@@ -2,6 +2,7 @@ package org.specs2
 package concurrent
 
 import org.specs2.control.Logger
+import org.specs2.execute.*
 import org.specs2.main.Arguments
 
 import scala.concurrent.*, duration.*
@@ -10,7 +11,11 @@ import scala.concurrent.*, duration.*
   */
 case class ExecutionEnv(executorServices: ExecutorServices, timeFactor: Int):
 
-  def shutdown(): Unit = ()
+  def shutdown(): Unit =
+    ()
+
+  def await(future: Future[Result], timeout: Duration = Duration.Inf): Result =
+    Success()
 
   given executionContext: ExecutionContext = executorServices.executionContext
   given ec: ExecutionContext = executorServices.executionContext

common/jvm/src/main/scala/org/specs2/concurrent/ExecutionEnv.scala

@@ -0,0 +1,28 @@
+package org.specs2
+package concurrent
+
+import org.specs2.control.Logger
+import org.specs2.execute.*
+import org.specs2.main.Arguments
+
+import scala.concurrent.*, duration.*
+
+/** Execution environment
+  */
+case class ExecutionEnv(executorServices: ExecutorServices, timeFactor: Int):
+
+  def shutdown(): Unit =
+    executorServices.shutdownNow()
+
+  def await(future: Future[Result], timeout: Duration = Duration.Inf): Result =
+    Await.result(future, timeout)
+
+  given executionContext: ExecutionContext = executorServices.executionContext
+  given ec: ExecutionContext = executorServices.executionContext
+
+  lazy val scheduler = executorServices.scheduler
+
+  def schedule(action: =>Unit, duration: FiniteDuration): Unit =
+    executorServices.schedule(action, duration)
+
+object ExecutionEnv extends ExecutionEnvCompanionPlatform

core/jvm/src/main/scala/org/specs2/specification/core/EnvDefault.scala

@@ -18,7 +18,7 @@ object EnvDefault:
   val statsDirectoryPath: DirectoryPath =
     "target" / "specs2-reports" / "stats"
 
-  def default: Env =
+  lazy val default: Env =
     create(Arguments())
 
   def create(arguments: Arguments): Env =

core/shared/src/main/scala/org/specs2/reporter/CustomIntances.scala

@@ -9,7 +9,7 @@ import reflect.Classes
 import scala.reflect.ClassTag
 import Printer.*
 
-case class CustomInstances(arguments: Arguments, loader: ClassLoader, logger: Logger):
+case class CustomInstances(env: Env, loader: ClassLoader, logger: Logger):
 
   /** create a built-in specs2 printer */
   def createPrinterInstance(
@@ -18,15 +18,15 @@ case class CustomInstances(arguments: Arguments, loader: ClassLoader, logger: Lo
       failureMessage: String,
       noRequiredMessage: String
   ): Operation[Option[Printer]] =
-    if arguments.isSet(name.name) then
+    if env.arguments.isSet(name.name) then
       createInstance[Printer](name.name, className, _ => failureMessage, noRequiredMessage)
     else noInstance(noRequiredMessage)
 
   /** create a custom instance */
   def createCustomInstance[T <: AnyRef](name: String, failureMessage: String => String, noRequiredMessage: String)(using
       m: ClassTag[T]
   ): Operation[Option[T]] =
-    arguments.commandLine.value(name) match
+    env.arguments.commandLine.value(name) match
       case Some(className) => createInstance[T](name, className, failureMessage, noRequiredMessage)
       case _               => noInstance(noRequiredMessage)
 
@@ -37,7 +37,7 @@ case class CustomInstances(arguments: Arguments, loader: ClassLoader, logger: Lo
       noRequiredMessage: String
   )(using m: ClassTag[T]): Operation[Option[T]] =
     for
-      instance <- Classes.createInstanceEither[T](className, loader, EnvDefault.create(arguments).defaultInstances)
+      instance <- Classes.createInstanceEither[T](className, loader, env.defaultInstances)
       result <-
         instance match
           case Right(i) => Operation.ok(Option(i))
@@ -50,7 +50,7 @@ case class CustomInstances(arguments: Arguments, loader: ClassLoader, logger: Lo
       t: Throwable,
       forceVerbose: Option[Boolean] = None
   ): Operation[Option[T]] =
-    val verbose = forceVerbose.getOrElse(arguments.verbose)
+    val verbose = forceVerbose.getOrElse(env.arguments.verbose)
     logger.info("", verbose) >>
       logger.info(message, verbose) >>
       logger.info("", verbose) >>
@@ -59,13 +59,13 @@ case class CustomInstances(arguments: Arguments, loader: ClassLoader, logger: Lo
 
   /** print a message if a class can not be instantiated */
   def noInstance[T](message: String): Operation[Option[T]] =
-    logger.info(message, arguments.verbose) >> Operation.ok(None)
+    logger.info(message, env.arguments.verbose) >> Operation.ok(None)
 
 object CustomInstances:
 
   def default: CustomInstances =
-    create(Arguments())
+    create(EnvDefault.default)
 
-  def create(args: Arguments, logger: Logger = NoLogger): CustomInstances =
+  def create(env: Env, logger: Logger = NoLogger): CustomInstances =
     val loader = Thread.currentThread.getContextClassLoader
-    CustomInstances(args, loader, logger)
+    CustomInstances(env, loader, logger)

core/shared/src/main/scala/org/specs2/reporter/PrinterFactory.scala

@@ -72,8 +72,5 @@ case class PrinterFactory(arguments: Arguments, customInstances: CustomInstances
 
 object PrinterFactory:
 
-  def default: PrinterFactory =
-    create(EnvDefault.default)
-
   def create(env: Env): PrinterFactory =
-    PrinterFactory(env.arguments, CustomInstances.create(env.arguments, env.systemLogger), env.systemLogger)
+    PrinterFactory(env.arguments, CustomInstances.create(env, env.systemLogger), env.systemLogger)

core/shared/src/main/scala/org/specs2/reporter/TextPrinter.scala

@@ -281,6 +281,6 @@ case class TextPrinter(env: Env) extends Printer {
 }
 
 object TextPrinter {
-  val default: TextPrinter =
+  lazy val default: TextPrinter =
     TextPrinter(Env())
 }

core/shared/src/main/scala/org/specs2/runner/ClassRunner.scala

@@ -71,14 +71,14 @@ trait ClassRunnerMain:
         yield stats
 
     try execute(actions, env, exit)
-    finally env.awaitShutdown()
+    finally env.shutdown()
 
   /** Create a ClassRunner from the default environment containing the command line arguments
     */
   def createClassRunner(env: Env): Operation[ClassRunner] =
     val arguments = env.arguments
     val loader = env.getClass.getClassLoader
-    val customInstances = CustomInstances(arguments, loader, env.systemLogger)
+    val customInstances = CustomInstances(env, loader, env.systemLogger)
     val printerFactory = PrinterFactory(arguments, customInstances, env.systemLogger)
     val specFactory = DefaultSpecFactory(env, loader)
 
@@ -101,7 +101,7 @@ object TextRunner extends ClassRunnerMain:
     val logger = PrinterLogger.stringPrinterLogger
     val env1 = env.setPrinterLogger(logger).setArguments(env.arguments.overrideWith(arguments))
     val loader = Thread.currentThread.getContextClassLoader
-    val customInstances = CustomInstances(arguments, loader, StringOutputLogger(logger))
+    val customInstances = CustomInstances(env1, loader, StringOutputLogger(logger))
 
     val action =
       for

core/shared/src/main/scala/org/specs2/runner/FilesRunner.scala

@@ -9,13 +9,17 @@ import specification.core.*
 import reporter.*
 import runner.Runner.*
 import org.specs2.fp.syntax.*
-import SpecificationsFinder.*
 import main.FilesRunnerArguments.*
 
 trait FilesRunner:
   /** run any specifications found via arguments */
   def run: Action[Stats]
 
+object FilesRunner:
+
+  def create(env: Env, finder: SpecificationsFinder): FilesRunner =
+    DefaultFilesRunner(env, finder)
+
 case class DefaultFilesRunner(env: Env, specificationsFinder: SpecificationsFinder) extends FilesRunner:
 
   val logger = env.systemLogger
@@ -79,4 +83,4 @@ trait FilesRunnerMain:
     val env = EnvDefault.create(Arguments(args*))
     val specificationsFinder = DefaultSpecificationsFinder(env)
     try execute(DefaultFilesRunner(env, specificationsFinder).run, env, exit)
-    finally env.awaitShutdown()
+    finally env.shutdown()

core/shared/src/main/scala/org/specs2/runner/SbtRunner.scala

@@ -30,7 +30,8 @@ abstract class BaseSbtRunner(args: Array[String], remoteArgs: Array[String], loa
 
   lazy val commandLineArguments = Arguments(args ++ remoteArgs*)
 
-  lazy val env = EnvDefault.create(commandLineArguments).setCustomClassLoader(loader)
+  lazy val env: Env =
+    EnvDefault.create(commandLineArguments).setCustomClassLoader(loader)
 
   def tasks(taskDefs: Array[TaskDef]): Array[Task] =
     taskDefs.toList.map(newTask).toArray
@@ -40,13 +41,8 @@ abstract class BaseSbtRunner(args: Array[String], remoteArgs: Array[String], loa
     SbtTask(aTaskDef, env, loader, this)
 
   def done =
-    env.shutdown
-      .onComplete {
-        case Failure(e) =>
-          loggers.foreach(_.error("error while finalizing resources: " + e.getMessage))
-        case Success(failures) =>
-          failures.toList.foreach { result => loggers.foreach(_.error(result.message)) }
-      }(using env.specs2ExecutionContext)
+    val result = env.shutdown()
+    if !result.isSuccess then loggers.foreach(_.error(result.message))
     ""
 
   def deserializeTask(task: String, deserializer: String => TaskDef): Task =
@@ -75,7 +71,7 @@ object sbtRun extends MasterSbtRunner(Array(), Array(), Thread.currentThread.get
     given ee: ExecutionEnv = env.specs2ExecutionEnv
 
     try exit(start(arguments*))
-    finally Action.future(env.shutdown).runVoid(ee)
+    finally env.shutdown()
 
   def exit(action: Action[Stats])(using ee: ExecutionEnv): Unit =
     action
@@ -176,7 +172,7 @@ case class SbtTask(aTaskDef: TaskDef, env: Env, loader: ClassLoader, base: BaseS
       loggers: Array[Logger]
   ): Action[Stats] =
 
-    val customInstances = CustomInstances(arguments, loader, env.systemLogger)
+    val customInstances = CustomInstances(env, loader, env.systemLogger)
     val specFactory = DefaultSpecFactory(env, loader)
     val makeSpecs =
       if arguments.isSet("all") then

core/shared/src/main/scala/org/specs2/runner/SpecFactory.scala

@@ -11,8 +11,8 @@ trait SpecFactory:
 
 object SpecFactory:
 
-  def default: SpecFactory =
-    DefaultSpecFactory(Env(), Thread.currentThread.getContextClassLoader)
+  def create(env: Env): SpecFactory =
+    DefaultSpecFactory(env, Thread.currentThread.getContextClassLoader)
 
 case class DefaultSpecFactory(env: Env, classLoader: ClassLoader) extends SpecFactory:
 

core/shared/src/main/scala/org/specs2/runner/SpecificationsFinder.scala

@@ -202,5 +202,5 @@ case class DefaultSpecificationsFinder(env: Env) extends SpecificationsFinder:
 
 object SpecificationsFinder:
 
-  val default: SpecificationsFinder =
-    DefaultSpecificationsFinder(EnvDefault.default)
+  def create(env: Env): SpecificationsFinder =
+    DefaultSpecificationsFinder(env)

core/shared/src/main/scala/org/specs2/specification/core/Env.scala

@@ -85,13 +85,13 @@ case class Env(
     copy(arguments = arguments.setTimeout(duration))
 
   /** @return a list of finalization failures by resource key if any */
-  def shutdown: Future[List[Result]] =
+  private def startShutdown: Future[List[Result]] =
     given ExecutionContext = specs2ExecutionContext
     val results: Action[List[(String, Result)]] = resources.toList.traverse { case (key, resource) =>
       resource.finalizer.startExecution(this).executionResult.map(r => (key, r))
     }
 
-    val failures = results
+    results
       .map { (rs: List[(String, Result)]) =>
         rs
           .filter(_._2.isIssue)
@@ -101,19 +101,16 @@ case class Env(
       }
       .runFuture(specs2ExecutionEnv)
 
-    failures.onComplete { _ =>
-      try specs2ExecutionEnv.shutdown()
-      finally executionEnv.shutdown()
-    }
-    failures
-
-  def shutdownResult: Future[Result] =
+  private def startShutdownResult: Future[Result] =
     given ExecutionContext = specs2ExecutionContext
-    shutdown.map(vs => AsResult(vs))
+    startShutdown.map(vs => AsResult(vs))
 
   /** be sure to only call this method on the JVM! */
-  def awaitShutdown(): Unit =
-    Await.result(shutdown, Duration.Inf)
+  def shutdown(timeout: Duration = Duration.Inf): Result =
+    val result = specs2ExecutionEnv.await(startShutdownResult, timeout)
+    try executionEnv.shutdown()
+    finally specs2ExecutionEnv.shutdown()
+    result
 
   /** set new PrinterLogger */
   def setPrinterLogger(logger: PrinterLogger) =

core/shared/src/main/scala/org/specs2/specification/core/OwnEnv.scala

@@ -37,4 +37,4 @@ trait OwnEnv extends AfterSpec:
     ownEnv.executionContext
 
   def afterSpec: Fragments =
-    step(ownEnv.shutdownResult)
+    step(ownEnv.shutdown())

core/shared/src/main/scala/org/specs2/specification/core/OwnExecutionEnv.scala

@@ -32,4 +32,4 @@ trait OwnExecutionEnv extends AfterSpec:
     ownEnv.executionContext
 
   def afterSpec: Fragments =
-    step(ownEnv.shutdownResult)
+    step(ownEnv.shutdown())

core/shared/src/main/scala/specs2/files.scala

@@ -16,6 +16,6 @@ object files:
     val arguments = Arguments(args.drop(1)*)
     val env = EnvDefault.create(arguments)
 
-    val filesRunner = DefaultFilesRunner(env, SpecificationsFinder.default)
+    val filesRunner = FilesRunner.create(env, SpecificationsFinder.create(env))
     try Runner.execute(filesRunner.run, env, exit)
-    finally env.awaitShutdown()
+    finally env.shutdown()

core/shared/src/main/scala/specs2/run.scala

@@ -20,7 +20,7 @@ object run extends ClassRunnerMain:
     yield result
 
     try Runner.execute(action, env, exit = false)
-    finally env.awaitShutdown()
+    finally env.shutdown()
 
   /** main method for the command line */
   def main(args: Array[String]) =

junit/src/main/scala/org/specs2/runner/JUnitRunner.scala

@@ -33,7 +33,7 @@ class JUnitRunner(klass: Class[?]) extends org.junit.runner.Runner with Filterab
 
   def getDescription(env: Env): org.junit.runner.Description =
     try JUnitDescriptions.createDescription(specStructure)(env.specs2ExecutionEnv)
-    catch { case NonFatal(t) => env.awaitShutdown(); throw t; }
+    catch { case NonFatal(t) => env.shutdown(); throw t; }
 
   /** specification structure for the environment */
   lazy val specStructure: SpecStructure =
@@ -45,13 +45,13 @@ class JUnitRunner(klass: Class[?]) extends org.junit.runner.Runner with Filterab
       runWithEnv(n, env).runAction(env.specs2ExecutionEnv) match
         case Right(_) => ()
         case Left(t)  => n.fireTestFailure(new Failure(getDescription, new RuntimeException(t)))
-    finally env.awaitShutdown()
+    finally env.shutdown()
 
   /** run the specification with a Notifier and an environment */
   def runWithEnv(runNotifier: RunNotifier, env: Env): Action[Stats] =
     val loader = Thread.currentThread.getContextClassLoader
     val arguments = env.arguments
-    val customInstances = CustomInstances(arguments, loader, env.systemLogger)
+    val customInstances = CustomInstances(env, loader, env.systemLogger)
     val printerFactory = PrinterFactory(arguments, customInstances, env.systemLogger)
     val junitPrinter = JUnitPrinter(env, runNotifier)
 
@@ -64,7 +64,7 @@ class JUnitRunner(klass: Class[?]) extends org.junit.runner.Runner with Filterab
       stats <-
         if arguments.isSet("all") then
           for
-            ss <- SpecFactory.default.createLinkedSpecs(specStructure).toAction
+            ss <- SpecFactory.create(env).createLinkedSpecs(specStructure).toAction
             sorted <- Action.pure(SpecStructure.topologicalSort(ss)(env.specs2ExecutionEnv).getOrElse(ss))
             stats <- reporter.report(sorted.toList)
           yield stats