-
Notifications
You must be signed in to change notification settings - Fork 74
/
getJavaHome.ts
152 lines (140 loc) · 4.34 KB
/
getJavaHome.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
import { TaskEither, chain } from "fp-ts/lib/TaskEither";
import * as TE from "fp-ts/lib/TaskEither";
import * as E from "fp-ts/lib/Either";
import { pipe } from "fp-ts/lib/function";
import _locateJavaHome from "@viperproject/locate-java-home";
import * as semver from "semver";
import {
ILocateJavaHomeOptions,
IJavaHomeInfo,
} from "@viperproject/locate-java-home/js/es5/lib/interfaces";
import { toPromise } from "./util";
import fs from "fs";
import path from "path";
import { spawn } from "promisify-child-process";
import { OutputChannel } from "./interfaces/OutputChannel";
export type JavaVersion = "11" | "17" | "21";
/**
* Computes the user's Java Home path, using various strategies:
*
* - JAVA_HOME environment variable
* - realpath for `java` if it's presented in PATH enviroment variable
* - the most recent compatible Java version found on the computer
* (with a preference for JDK over JRE)
*
* @param javaVersion metals.javaVersion value as read from the configuration or default
*/
export async function getJavaHome(
javaVersion: JavaVersion,
outputChannel: OutputChannel
): Promise<string | undefined> {
const fromEnvValue = await fromEnv(javaVersion, outputChannel);
return fromEnvValue ? fromEnvValue : await locate(javaVersion);
}
const versionRegex = /\"\d\d/;
async function validateJavaVersion(
javaHome: string,
javaVersion: JavaVersion,
outputChannel: OutputChannel
): Promise<boolean> {
const javaBin = path.join(javaHome, "bin", "java");
try {
const javaVersionOut = spawn(javaBin, ["-version"], {
encoding: "utf8",
});
javaVersionOut.stderr?.on("data", (out: Buffer) => {
outputChannel.appendLine(`${javaBin} -version:`);
const msg = out.toString().trim();
outputChannel.appendLine(msg);
});
const javaInfoStr = (await javaVersionOut).stderr as string;
const matches = javaInfoStr.match(versionRegex);
if (matches) {
return +matches[0].slice(1, 3) >= +javaVersion;
}
} catch (error) {
outputChannel.appendLine(`failed while running ${javaBin} -version`);
outputChannel.appendLine(`${error}`);
}
return false;
}
export async function fromEnv(
javaVersion: JavaVersion,
outputChannel: OutputChannel
): Promise<string | undefined> {
const javaHome = process.env["JAVA_HOME"];
if (javaHome) {
const isValid = await validateJavaVersion(
javaHome,
javaVersion,
outputChannel
);
if (isValid) return javaHome;
}
return undefined;
}
function locate(javaVersion: JavaVersion): Promise<undefined | string> {
return toPromise(
pipe(
locateJavaHome({ version: `>=${javaVersion}` }),
chain((javaHomes) => {
if (!javaHomes || javaHomes.length === 0) {
return TE.right(undefined);
} else {
const jdkHomes = javaHomes.filter((j) => j.isJDK);
const fromBinPath = matchesBinFromPath(jdkHomes);
const jdkHome = fromBinPath ? fromBinPath : latestJdk(jdkHomes);
if (jdkHome) {
return TE.right(jdkHome.path);
} else {
return TE.right(javaHomes[0].path);
}
}
})
)
);
}
function matchesBinFromPath(
jdkHomes: IJavaHomeInfo[]
): IJavaHomeInfo | undefined {
const value = process.env["PATH"];
if (value && jdkHomes.length > 0) {
const result = value
.split(path.delimiter)
.map((p) => path.join(p, "java"))
.filter((p) => fs.existsSync(p));
if (result.length > 0) {
const realpath = fs.realpathSync(result[0]);
const matched = jdkHomes.find((home) => {
const javaBin = path.join(home.path, "bin", "java");
return javaBin == realpath;
});
return matched;
} else {
return undefined;
}
} else {
return undefined;
}
}
function latestJdk(jdkHomes: IJavaHomeInfo[]): IJavaHomeInfo | undefined {
if (jdkHomes.length > 0) {
return jdkHomes.sort((a, b) => {
const byVersion = -semver.compare(a.version, b.version);
if (byVersion === 0) return b.security - a.security;
else return byVersion;
})[0];
} else {
return undefined;
}
}
function locateJavaHome(
opts: ILocateJavaHomeOptions
): TaskEither<Error, IJavaHomeInfo[] | undefined> {
return () =>
new Promise((resolve) =>
_locateJavaHome(opts, (err, res) =>
err != null ? resolve(E.left(err)) : resolve(E.right(res))
)
);
}