Add SysInfo class

Author: TsvetanMilanov

lib/declarations.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Describes process properties.
+ */
+interface IProcessInfo {
+	/**
+	 * The stdout of the process.
+	 */
+	stdout: string;
+
+	/**
+	 * The stderr of the process.
+	 */
+	stderr: string;
+
+	/**
+	 * The exit code of the process.
+	 */
+	exitCode?: number;
+}

lib/sys-info.ts

@@ -0,0 +1,56 @@
+import { ChildProcess } from "./wrappers/child-process";
+import * as Promise from "bluebird";
+import * as path from "path";
+
+export class SysInfo {
+	// Different java has different format for `java -version` command.
+	private static JAVA_VERSION_REGEXP = /(?:openjdk|java) version \"((?:\d+\.)+(?:\d+))/i;
+
+	// For other versions of java javac version output is not on first line.
+	// Thus can't use ^ for starts with in regex.
+	private static JAVA_COMPILER_VERSION_REGEXP = /javac (.*)/i;
+
+	private javaVerCache: string;
+	private javaCompilerVerCache: string;
+
+	constructor(private childProcess: ChildProcess) { }
+
+	public getJavaVersion(): Promise<string> {
+		if (!this.javaVerCache) {
+			return new Promise<string>((resolve, reject) => {
+				this.childProcess.spawnFromEvent("java", ["-version"], "exit")
+					.then((spawnResult) => {
+						this.javaVerCache = SysInfo.JAVA_VERSION_REGEXP.exec(spawnResult.stderr)[1];
+						resolve(this.javaVerCache);
+					})
+					.catch((err) => {
+						this.javaVerCache = null;
+						resolve(this.javaVerCache);
+					});
+			});
+		}
+
+		return Promise.resolve(this.javaVerCache);
+	}
+
+	public getJavaCompilerVersion(): Promise<string> {
+		if (!this.javaCompilerVerCache) {
+			return new Promise<string>((resolve, reject) => {
+				let javaCompileExecutableName = "javac";
+				let javaHome = process.env.JAVA_HOME;
+				let pathToJavaCompilerExecutable = javaHome ? path.join(javaHome, "bin", javaCompileExecutableName) : javaCompileExecutableName;
+				this.childProcess.exec(`"${pathToJavaCompilerExecutable}" -version`)
+					.then((output) => {
+						this.javaCompilerVerCache = output ? SysInfo.JAVA_COMPILER_VERSION_REGEXP.exec(output.stderr)[1] : null;
+						resolve(this.javaCompilerVerCache);
+					})
+					.catch((err) => {
+						this.javaCompilerVerCache = null;
+						resolve(this.javaCompilerVerCache);
+					});
+			});
+		}
+
+		return Promise.resolve(this.javaCompilerVerCache);
+	}
+}

lib/wrappers/child-process.ts

@@ -0,0 +1,78 @@
+import * as childProcess from "child_process";
+import * as Promise from "bluebird";
+
+export class ChildProcess {
+	public spawnFromEvent(command: string, args: string[], event: string, options?: childProcess.SpawnOptions, ignoreError: boolean = false): Promise<IProcessInfo> {
+		return new Promise<IProcessInfo>((resolve, reject) => {
+			let commandChildProcess = childProcess.spawn(command, args, options);
+			let capturedOut = "";
+			let capturedErr = "";
+
+			if (commandChildProcess.stdout) {
+				commandChildProcess.stdout.on("data", (data: string) => {
+					capturedOut += data;
+				});
+			}
+
+			if (commandChildProcess.stderr) {
+				commandChildProcess.stderr.on("data", (data: string) => {
+					capturedErr += data;
+				});
+			}
+
+			commandChildProcess.on(event, (arg: any) => {
+				let exitCode = typeof arg === "number" ? arg : arg && arg.code;
+				let result = {
+					stdout: capturedOut,
+					stderr: capturedErr,
+					exitCode: exitCode
+				};
+
+				if (ignoreError) {
+					resolve(result);
+				} else {
+					if (exitCode === 0) {
+						resolve(result);
+					} else {
+						let errorMessage = `Command ${command} failed with exit code ${exitCode}`;
+						if (capturedErr) {
+							errorMessage += ` Error output: \n ${capturedErr}`;
+						}
+
+						throw new Error(errorMessage);
+					}
+				}
+			});
+
+			commandChildProcess.once("error", (err: Error) => {
+				if (ignoreError) {
+					let result = {
+						stdout: capturedOut,
+						stderr: err.message,
+						exitCode: (<any>err).code
+					};
+					resolve(result);
+				} else {
+					throw err;
+				}
+			});
+		});
+	}
+
+	public exec(command: string, options?: childProcess.ExecOptions): Promise<IProcessInfo> {
+		return new Promise<IProcessInfo>((resolve, reject) => {
+			childProcess.exec(command, options, (err, stdout, stderr) => {
+				if (err) {
+					throw err;
+				}
+
+				let result: IProcessInfo = {
+					stdout,
+					stderr
+				};
+
+				resolve(result);
+			});
+		});
+	}
+}