align jdk validation with vscode-java (#503)

Signed-off-by: Yan Zhang <[email protected]>

Author: Eskibear

src/java-runtime/assets/jdk.configure.project.tsx

@@ -58,7 +58,7 @@ export const ProjectRuntimePanel = (props: {
           <h3 className="font-weight-light">Workspace Overview</h3>
           {projectRuntimesTable}
           <details>
-            <summary> Click to see how:</summary>
+            <summary> Click to see how</summary>
 
             <p>For example, if you want to use Java 8, add below lines</p>
             <p>In <code>pom.xml</code> of a Maven project:</p>

src/java-runtime/index.ts

@@ -6,9 +6,9 @@ import * as path from "path";
 import * as request from "request-promise-native";
 import * as vscode from "vscode";
 import { getExtensionContext, loadTextFromFile } from "../utils";
-import { findJavaHomes, getJavaVersion, JavaRuntime } from "./utils/findJavaRuntime";
+import { findJavaHomes, JavaRuntime } from "./utils/findJavaRuntime";
 import architecture = require("arch");
-import { checkJavaRuntime } from "./utils/upstreamApi";
+import { resolveRequirements } from "./utils/upstreamApi";
 import { JavaRuntimeEntry, NatureId, ProjectRuntimeEntry, ProjectType } from "./types";
 import { sourceLevelDisplayName } from "./utils/misc";
 import { pathExists } from "fs-extra";
@@ -168,12 +168,9 @@ export async function validateJavaRuntime() {
   // option a) should check Java LS exported API for java_home
   // * option b) use the same way to check java_home as vscode-java
   try {
-    const upstreamJavaHome = await checkJavaRuntime();
-    if (upstreamJavaHome) {
-      const version = await getJavaVersion(upstreamJavaHome);
-      if (version && version >= 11) {
-        return true;
-      }
+    const runtime = await resolveRequirements();
+    if (runtime.java_version >=11 && runtime.java_home) {
+      return true;
     }
   } catch (error) {
   }
@@ -200,8 +197,7 @@ export async function findJavaRuntimeEntries(): Promise<{
   let javaDotHome;
   let javaHomeError;
   try {
-    javaDotHome = await checkJavaRuntime();
-    const javaVersion = await getJavaVersion(javaDotHome);
+    const {java_home: javaDotHome, java_version: javaVersion } = await resolveRequirements();
     if (!javaVersion || javaVersion < 11) {
       javaHomeError = `Java 11 or more recent is required to run the Java extension. Preferred JDK "${javaDotHome}" (version ${javaVersion}) doesn't meet the requirement. Please specify or install a recent JDK.`;
     }

src/java-runtime/utils/findJavaRuntime.ts

@@ -10,6 +10,7 @@ const expandHomeDir = require("expand-home-dir");
 const WinReg = require("winreg-utf8");
 const isWindows: boolean = process.platform.indexOf("win") === 0;
 const isMac: boolean = process.platform.indexOf("darwin") === 0;
+const isLinux: boolean = process.platform.indexOf("linux") === 0;
 const JAVAC_FILENAME = "javac" + (isWindows ? ".exe" : "");
 const JAVA_FILENAME = "java" + (isWindows ? ".exe" : "");
 
@@ -26,8 +27,9 @@ export async function findJavaHomes(): Promise<JavaRuntime[]> {
     const ret: JavaRuntime[] = [];
     const jdkMap = new Map<string, string[]>();
 
-    updateJDKs(jdkMap, await fromJavaHomeEnv(), "env.JAVA_HOME");
-    updateJDKs(jdkMap, await fromPathEnv(), "env.PATH");
+    updateJDKs(jdkMap, await fromEnv("JDK_HOME"), "env.JDK_HOME");
+    updateJDKs(jdkMap, await fromEnv("JAVA_HOME"), "env.JAVA_HOME");
+    updateJDKs(jdkMap, await fromPath(), "env.PATH");
     updateJDKs(jdkMap, await fromWindowsRegistry(), "WindowsRegistry");
     updateJDKs(jdkMap, await fromCommonPlaces(), "DefaultLocation");
 
@@ -59,18 +61,19 @@ function updateJDKs(map: Map<string, string[]>, newJdks: string[], source: strin
     }
 }
 
-async function fromJavaHomeEnv(): Promise<string[]> {
+async function fromEnv(name: string): Promise<string[]> {
     const ret: string[] = [];
-    if (process.env.JAVA_HOME) {
-        const javaHome = await verifyJavaHome(process.env.JAVA_HOME, JAVAC_FILENAME);
+    const proposed = process.env[name];
+    if (proposed) {
+        const javaHome = await verifyJavaHome(proposed, JAVAC_FILENAME);
         if (javaHome) {
             ret.push(javaHome);
         }
     }
     return ret;
 }
 
-async function fromPathEnv(): Promise<string[]> {
+async function fromPath(): Promise<string[]> {
     const ret: string[] = [];
 
     const paths = process.env.PATH ? process.env.PATH.split(path.delimiter).filter(Boolean) : [];
@@ -235,25 +238,39 @@ async function fromCommonPlaces(): Promise<string[]> {
         }
     }
 
+    // common place for Linux
+    if (isLinux) {
+        const jvmStore = "/usr/lib/jvm";
+        let jvms: string[] = [];
+        try {
+            jvms = await fse.readdir(jvmStore);
+        } catch (error) {
+            // ignore
+        }
+        for (const jvm of jvms) {
+            const proposed = path.join(jvmStore, jvm);
+            const javaHome = await verifyJavaHome(proposed, JAVAC_FILENAME);
+            if (javaHome) {
+                ret.push(javaHome);
+            }
+        }
+    }
+
     return ret;
 }
 
-
-
-async function verifyJavaHome(raw: string, javaFilename: string): Promise<string | undefined> {
+export async function verifyJavaHome(raw: string, javaFilename: string): Promise<string | undefined> {
     const dir = expandHomeDir(raw);
     const targetJavaFile = await findLinkedFile(path.resolve(dir, "bin", javaFilename));
     const proposed = path.dirname(path.dirname(targetJavaFile));
     if (await fse.pathExists(proposed)
-        && (await fse.lstat(proposed)).isDirectory()
         && await fse.pathExists(path.resolve(proposed, "bin", javaFilename))
     ) {
         return proposed;
     }
     return undefined;
 }
 
-
 // iterate through symbolic links until file is found
 async function findLinkedFile(file: string): Promise<string> {
     if (!await fse.pathExists(file) || !(await fse.lstat(file)).isSymbolicLink()) {
@@ -262,8 +279,7 @@ async function findLinkedFile(file: string): Promise<string> {
     return await findLinkedFile(await fse.readlink(file));
 }
 
-
-export async function getJavaVersion(javaHome: string): Promise<number | undefined> {
+export async function getJavaVersion(javaHome: string): Promise<number> {
     let javaVersion = await checkVersionInReleaseFile(javaHome);
     if (!javaVersion) {
         javaVersion = await checkVersionByCLI(javaHome);
@@ -319,7 +335,10 @@ async function checkVersionInReleaseFile(javaHome: string): Promise<number> {
 /**
  * Get version by parsing `JAVA_HOME/bin/java -version`
  */
-function checkVersionByCLI(javaHome: string): Promise<number> {
+async function checkVersionByCLI(javaHome: string): Promise<number> {
+    if (!javaHome) {
+        return 0;
+    }
     return new Promise((resolve, reject) => {
         const javaBin = path.join(javaHome, "bin", JAVA_FILENAME);
         cp.execFile(javaBin, ["-version"], {}, (error, stdout, stderr) => {

src/java-runtime/utils/upstreamApi.ts

@@ -9,28 +9,21 @@ import * as vscode from "vscode";
 import { env } from "vscode";
 
 const expandHomeDir = require("expand-home-dir");
-import findJavaHome = require("find-java-home");
+const REQUIRED_JDK_VERSION = 11;
+import { findJavaHomes, getJavaVersion, JavaRuntime } from "./findJavaRuntime";
 
 
 const isWindows = process.platform.indexOf("win") === 0;
 const JAVAC_FILENAME = "javac" + (isWindows ? ".exe" : "");
 
-export async function checkJavaRuntime(): Promise<string> {
+export async function resolveRequirements(): Promise<any> {
     return new Promise(async (resolve, reject) => {
         let source: string;
+        let javaVersion: number = 0;
         let javaHome = await checkJavaPreferences();
         if (javaHome) {
+            // java.home explictly specified
             source = `java.home variable defined in ${env.appName} settings`;
-        } else {
-            javaHome = process.env["JDK_HOME"];
-            if (javaHome) {
-                source = "JDK_HOME environment variable";
-            } else {
-                javaHome = process.env["JAVA_HOME"];
-                source = "JAVA_HOME environment variable";
-            }
-        }
-        if (javaHome) {
             javaHome = expandHomeDir(javaHome) as string;
             if (!await fse.pathExists(javaHome)) {
                 invalidJavaHome(reject, `The ${source} points to a missing or inaccessible folder (${javaHome})`);
@@ -43,20 +36,39 @@ export async function checkJavaRuntime(): Promise<string> {
                 }
                 invalidJavaHome(reject, msg);
             }
-            return resolve(javaHome);
-        }
-        // No settings, let's try to detect as last resort.
-        findJavaHome((err, home) => {
-            if (err) {
-                invalidJavaHome(reject, "Java runtime (JDK, not JRE) could not be located");
-            }
-            else {
-                resolve(home);
+            javaVersion = await getJavaVersion(javaHome);
+        } else {
+            // java.home not specified, search valid JDKs from env.JAVA_HOME, env.PATH, Registry(Window), Common directories
+            const javaRuntimes = await findJavaHomes();
+            const validJdks = javaRuntimes.filter(r => r.version >= REQUIRED_JDK_VERSION);
+            if (validJdks.length > 0) {
+                sortJdksBySource(validJdks);
+                javaHome = validJdks[0].home;
+                javaVersion = validJdks[0].version;
             }
-        });
+        }
+
+        if (javaVersion < REQUIRED_JDK_VERSION) {
+            invalidJavaHome(reject, `Java ${REQUIRED_JDK_VERSION} or more recent is required to run the Java extension. (Current version: ${javaVersion}, JDK: ${javaHome})`);
+        }
+
+        resolve({ java_home: javaHome, java_version: javaVersion });
     });
 }
 
+function sortJdksBySource(jdks: JavaRuntime[]) {
+    const rankedJdks = jdks as Array<JavaRuntime & { rank: number }>;
+    const sources = ["env.JDK_HOME", "env.JAVA_HOME", "env.PATH"];
+    for (const [index, source] of sources.entries()) {
+        for (const jdk of rankedJdks) {
+            if (jdk.rank === undefined && jdk.sources.includes(source)) {
+                jdk.rank = index;
+            }
+        }
+    }
+    rankedJdks.filter(jdk => jdk.rank === undefined).forEach(jdk => jdk.rank = sources.length);
+    rankedJdks.sort((a, b) => a.rank - b.rank);
+}
 
 function checkJavaPreferences(){
     return vscode.workspace.getConfiguration("java").get<string>("home");