--jvm tries to find Java executable system-wide.

build.sbt

@@ -721,6 +721,7 @@ lazy val componentModulesPaths =
     (`runtime-instrument-runtime-server` / Compile / exportedModuleBin).value,
     (`runtime-language-arrow` / Compile / exportedModuleBin).value,
     (`runtime-language-epb` / Compile / exportedModuleBin).value,
+    (`runtime-version-manager` / Compile / exportedModuleBin).value,
     (`persistance` / Compile / exportedModuleBin).value,
     (`cli` / Compile / exportedModuleBin).value,
     (`json-rpc-server` / Compile / exportedModuleBin).value,
@@ -1610,7 +1611,8 @@ lazy val `version-output` = (project in file("lib/scala/version-output"))
           defaultDevEnsoVersion = defaultDevEnsoVersion,
           ensoVersion           = ensoVersion,
           scalacVersion         = scalacVersion,
-          graalVersion          = graalVersion,
+          graalVersion          = graalMavenPackagesVersion,
+          javaVersion           = graalVersion,
           currentEdition        = currentEdition
         )
     }.taskValue
@@ -3517,6 +3519,7 @@ lazy val `engine-runner` = project
       (`pkg` / Compile / exportedModule).value,
       (`engine-runner-common` / Compile / exportedModule).value,
       (`runtime-parser` / Compile / exportedModule).value,
+      (`runtime-version-manager` / Compile / exportedModule).value,
       (`version-output` / Compile / exportedModule).value,
       (`engine-common` / Compile / exportedModule).value,
       (`polyglot-api` / Compile / exportedModule).value,
@@ -3691,6 +3694,7 @@ lazy val `engine-runner` = project
   .dependsOn(`library-manager`)
   .dependsOn(`edition-updater`)
   .dependsOn(`runtime-parser`)
+  .dependsOn(`runtime-version-manager`)
   .dependsOn(`logging-service`)
   .dependsOn(`logging-service-logback` % Runtime)
   .dependsOn(`engine-runner-common`)
@@ -4328,15 +4332,34 @@ lazy val `connected-lock-manager-server` = project
 
 lazy val `runtime-version-manager` = project
   .in(file("lib/scala/runtime-version-manager"))
+  .enablePlugins(JPMSPlugin)
   .configs(Test)
   .settings(
     frgaalJavaCompilerSetting,
+    scalaModuleDependencySetting,
+    mixedJavaScalaProjectSetting,
     resolvers += Resolver.bintrayRepo("gn0s1s", "releases"),
     libraryDependencies ++= Seq(
       "com.typesafe.scala-logging" %% "scala-logging"    % scalaLoggingVersion,
       "org.apache.commons"          % "commons-compress" % commonsCompressVersion,
-      "org.scalatest"              %% "scalatest"        % scalatestVersion % Test,
-      akkaHttp
+      "org.scalatest"              %% "scalatest"        % scalatestVersion % Test
+    ),
+    Compile / moduleDependencies ++= Seq(
+      "org.apache.commons" % "commons-compress" % commonsCompressVersion,
+      "org.slf4j"          % "slf4j-api"        % slf4jVersion
+    ),
+    Compile / internalModuleDependencies := Seq(
+      (`cli` / Compile / exportedModule).value,
+      (`distribution-manager` / Compile / exportedModule).value,
+      (`downloader` / Compile / exportedModule).value,
+      (`editions` / Compile / exportedModule).value,
+      (`edition-updater` / Compile / exportedModule).value,
+      (`logging-utils` / Compile / exportedModule).value,
+      (`pkg` / Compile / exportedModule).value,
+      (`semver` / Compile / exportedModule).value,
+      (`scala-libs-wrapper` / Compile / exportedModule).value,
+      (`scala-yaml` / Compile / exportedModule).value,
+      (`version-output` / Compile / exportedModule).value
     )
   )
   .dependsOn(pkg)

engine/launcher/src/main/scala/org/enso/launcher/distribution/DefaultManagers.scala

@@ -39,10 +39,6 @@ object DefaultManagers {
   lazy val temporaryDirectoryManager =
     TemporaryDirectoryManager(distributionManager, defaultResourceManager)
 
-  /** Default [[RuntimeComponentConfiguration]]. */
-  lazy val componentConfig: RuntimeComponentConfiguration =
-    new GraalVMComponentConfiguration
-
   /** Creates a [[RuntimeVersionManager]] that uses the default distribution. */
   def runtimeVersionManager(
     globalCLIOptions: GlobalCLIOptions,
@@ -55,12 +51,11 @@ object DefaultManagers {
         alwaysInstallMissing
       ),
       distributionManager,
+      new GraalVersionManager(distributionManager, LauncherEnvironment),
       temporaryDirectoryManager,
       defaultResourceManager,
       EngineRepository.defaultEngineReleaseProvider,
       GraalCEReleaseProvider.default,
-      componentConfig,
-      RuntimeComponentUpdaterFactory.Default,
       InstallerKind.Launcher
     )
 }

engine/runner/src/main/java/module-info.java

@@ -9,6 +9,7 @@
   requires org.enso.logging.config;
   requires org.enso.logging.utils;
   requires org.enso.runtime.parser;
+  requires org.enso.runtime.version.manager;
   requires org.enso.runner.common;
   requires org.enso.pkg;
   requires org.enso.polyglot.api;

engine/runner/src/main/java/org/enso/runner/JavaFinder.java

@@ -0,0 +1,91 @@
+package org.enso.runner;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Comparator;
+import org.enso.distribution.DistributionManager;
+import org.enso.distribution.Environment;
+import org.enso.runtimeversionmanager.components.GraalRuntime;
+import org.enso.runtimeversionmanager.components.GraalVMVersion;
+import org.enso.runtimeversionmanager.components.GraalVersionManager;
+import org.enso.version.BuildVersion;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/** Utility class that tries to find installed JDK on the system. */
+final class JavaFinder {
+  private static final Logger logger = LoggerFactory.getLogger(JavaFinder.class);
+
+  private JavaFinder() {}
+
+  /**
+   * Tries to find {@code java} executable on the system. If a system-wide JDK is not found, tries
+   * to find it in the {@link DistributionManager distribution} runtimes.
+   *
+   * @return null if cannot be found. Otherwise, returns the absolute path to the executable, or
+   *     simply {@code java} if it is on the {@code PATH}.
+   */
+  static String findJavaExecutable() {
+    var javaInRuntime = findJavaExecutableInDistributionRuntimes();
+    if (javaInRuntime != null) {
+      return javaInRuntime.toAbsolutePath().toString();
+    }
+    logger.warn("No appropriate JDK found in the distribution runtimes. Trying system-wide JDK.");
+    var javaHome = System.getenv("JAVA_HOME");
+    if (javaHome != null) {
+      var java = new File(javaHome, "bin/java").getAbsoluteFile();
+      if (java.exists()) {
+        return java.getAbsolutePath();
+      }
+    }
+    if (isJavaOnPath()) {
+      return "java";
+    }
+    return null;
+  }
+
+  /**
+   * Tries to find {@code java} executable in the distribution runtime with the same version that
+   * was used for building, or a newer one.
+   *
+   * @return null if not found.
+   */
+  private static Path findJavaExecutableInDistributionRuntimes() {
+    var env = new Environment() {};
+    var distributionManager = new DistributionManager(env);
+    var graalVersionManager = new GraalVersionManager(distributionManager, env);
+    var versionUsedForBuild =
+        new GraalVMVersion(BuildVersion.graalVersion(), BuildVersion.javaVersion());
+    var runtimeWithExactVersionMatch = graalVersionManager.findGraalRuntime(versionUsedForBuild);
+    if (runtimeWithExactVersionMatch != null) {
+      return runtimeWithExactVersionMatch.javaExecutable();
+    }
+    // Try to find newer runtime (JDK).
+    var newerRuntime =
+        graalVersionManager.getAllRuntimes().stream()
+            .sorted(Comparator.comparing(GraalRuntime::version))
+            .filter(runtime -> runtime.version().compareTo(versionUsedForBuild) > 0)
+            .findFirst();
+    if (newerRuntime.isPresent()) {
+      logger.warn(
+          "Found newer JDK [{}] than the one used for build [{}]",
+          newerRuntime.get().version(),
+          versionUsedForBuild);
+      return newerRuntime.get().javaExecutable();
+    }
+    logger.warn("No JDK found in the distribution runtimes.");
+    return null;
+  }
+
+  private static boolean isJavaOnPath() {
+    try {
+      ProcessBuilder processBuilder = new ProcessBuilder("java", "-h");
+      Process process = processBuilder.start();
+      int exitCode = process.waitFor();
+      return exitCode == 0;
+    } catch (IOException | InterruptedException e) {
+      return false;
+    }
+  }
+}

engine/runner/src/main/java/org/enso/runner/Main.java

@@ -1337,22 +1337,13 @@ private void launch(String[] args) throws IOException, InterruptedException, URI
         println(JVM_OPTION + " option has no effect - already running in JVM " + current);
       } else {
         var commandAndArgs = new ArrayList<String>();
-        JVM_FOUND:
         if (jvm == null) {
-          var env = new Environment() {};
-          var dm = new DistributionManager(env);
-          var paths = dm.paths();
-          var files = paths.runtimes().toFile().listFiles();
-          if (files != null) {
-            for (var d : files) {
-              var java = new File(new File(d, "bin"), "java").getAbsoluteFile();
-              if (java.exists()) {
-                commandAndArgs.add(java.getPath());
-                break JVM_FOUND;
-              }
-            }
+          var javaExe = JavaFinder.findJavaExecutable();
+          if (javaExe == null) {
+            println("Cannot find java executable");
+            throw exitFail();
           }
-          commandAndArgs.add("java");
+          commandAndArgs.add(javaExe);
         } else {
           commandAndArgs.add(new File(new File(new File(jvm), "bin"), "java").getAbsolutePath());
         }

lib/scala/project-manager/src/main/scala/org/enso/projectmanager/versionmanagement/DefaultDistributionConfiguration.scala

@@ -52,12 +52,6 @@ object DefaultDistributionConfiguration
   lazy val temporaryDirectoryManager =
     TemporaryDirectoryManager(distributionManager, resourceManager)
 
-  lazy val componentConfiguration: RuntimeComponentConfiguration =
-    new GraalVMComponentConfiguration
-
-  lazy val runtimeComponentUpdaterFactory: RuntimeComponentUpdaterFactory =
-    RuntimeComponentUpdaterFactory.Default
-
   /** @inheritdoc */
   def engineReleaseProvider: ReleaseProvider[EngineRelease] =
     EngineRepository.defaultEngineReleaseProvider
@@ -67,15 +61,15 @@ object DefaultDistributionConfiguration
     userInterface: RuntimeVersionManagementUserInterface
   ): RuntimeVersionManager =
     new RuntimeVersionManager(
-      environment               = this.environment,
-      userInterface             = userInterface,
-      distributionManager       = distributionManager,
+      environment         = this.environment,
+      userInterface       = userInterface,
+      distributionManager = distributionManager,
+      graalVersionManager =
+        new GraalVersionManager(distributionManager, environment),
       temporaryDirectoryManager = temporaryDirectoryManager,
       resourceManager           = resourceManager,
       engineReleaseProvider     = engineReleaseProvider,
       runtimeReleaseProvider    = GraalCEReleaseProvider.default,
-      componentConfig           = componentConfiguration,
-      componentUpdaterFactory   = runtimeComponentUpdaterFactory,
       installerKind             = InstallerKind.ProjectManager
     )
 

lib/scala/project-manager/src/test/scala/org/enso/projectmanager/TestDistributionConfiguration.scala

@@ -7,7 +7,7 @@ import org.enso.editions.updater.EditionManager
 import java.nio.file.Path
 import org.enso.projectmanager.versionmanagement.DistributionConfiguration
 import org.enso.runtimeversionmanager.components.{
-  GraalVMComponentConfiguration,
+  GraalVersionManager,
   InstallerKind,
   RuntimeVersionManagementUserInterface,
   RuntimeVersionManager
@@ -28,7 +28,6 @@ import org.enso.runtimeversionmanager.releases.{
 import org.enso.runtimeversionmanager.runner.{JVMSettings, JavaCommand}
 import org.enso.runtimeversionmanager.test.{
   FakeEnvironment,
-  NoopComponentUpdaterFactory,
   TestLocalLockManager
 }
 import org.enso.testkit.HasTestDirectory
@@ -60,6 +59,9 @@ class TestDistributionConfiguration(
 
   lazy val distributionManager = new DistributionManager(environment)
 
+  lazy val graalVersionManager =
+    new GraalVersionManager(distributionManager, environment)
+
   lazy val lockManager = new TestLocalLockManager
 
   lazy val resourceManager = new ResourceManager(lockManager)
@@ -69,22 +71,17 @@ class TestDistributionConfiguration(
   lazy val temporaryDirectoryManager =
     TemporaryDirectoryManager(distributionManager, resourceManager)
 
-  lazy val componentConfig = new GraalVMComponentConfiguration
-
-  lazy val componentUpdaterFactory = NoopComponentUpdaterFactory
-
   override def makeRuntimeVersionManager(
     userInterface: RuntimeVersionManagementUserInterface
   ): RuntimeVersionManager = new RuntimeVersionManager(
     environment               = environment,
     userInterface             = userInterface,
     distributionManager       = distributionManager,
     temporaryDirectoryManager = temporaryDirectoryManager,
+    graalVersionManager       = graalVersionManager,
     resourceManager           = resourceManager,
     engineReleaseProvider     = engineReleaseProvider,
     runtimeReleaseProvider    = runtimeReleaseProvider,
-    componentConfig           = componentConfig,
-    componentUpdaterFactory   = componentUpdaterFactory,
     installerKind             = InstallerKind.ProjectManager
   )
 

lib/scala/runtime-version-manager-test/src/main/scala/org/enso/runtimeversionmanager/test/RuntimeVersionManagerTest.scala

@@ -9,7 +9,7 @@ import org.enso.distribution.{
 }
 import org.enso.pkg.{Config, PackageManager}
 import org.enso.runtimeversionmanager.components.{
-  GraalVMComponentConfiguration,
+  GraalVersionManager,
   InstallerKind,
   RuntimeVersionManagementUserInterface,
   RuntimeVersionManager
@@ -51,22 +51,21 @@ class RuntimeVersionManagerTest
   ): (DistributionManager, RuntimeVersionManager, Environment) = {
     val env                 = fakeInstalledEnvironment(environmentOverrides)
     val distributionManager = new PortableDistributionManager(env)
+    val graalVersionManager = new GraalVersionManager(distributionManager, env)
 
     val resourceManager = TestLocalResourceManager.create()
     val temporaryDirectoryManager =
       TemporaryDirectoryManager(distributionManager, resourceManager)
-    val componentConfig = new GraalVMComponentConfiguration
 
     val runtimeVersionManager = new RuntimeVersionManager(
       env,
       userInterface,
       distributionManager,
+      graalVersionManager,
       temporaryDirectoryManager,
       resourceManager,
       engineProvider,
       runtimeProvider,
-      componentConfig,
-      NoopComponentUpdaterFactory,
       installerKind
     )