feat(*): first working implementation

Author: toverux

package.json

@@ -22,7 +22,11 @@
   "homepage": "https://github.com/mitmadness/UnityInvoker#readme",
   "devDependencies": {
     "@types/node": "^7.0.12",
+    "@types/pify": "^0.0.28",
     "tslint": "^5.1.0",
     "typescript": "^2.2.2"
+  },
+  "dependencies": {
+    "pify": "^2.3.0"
   }
 }

src/index.ts

@@ -0,0 +1,15 @@
+import { IUnityOptions } from './unity_cli_options';
+import { UnityProcess } from './unity_process';
+
+export { IUnityOptions } from './unity_cli_options';
+export * from './unity_finder';
+export { LinuxPlayerArch, OSXPlayerArch, WindowsPlayerArch, RendererType } from './unity_process';
+export { UnityCrashError } from './unity_invoker';
+
+export function invokeUnity(options: IUnityOptions = {}): UnityProcess {
+    return new UnityProcess().withOptions(options);
+}
+
+export function invokeHeadlessUnity(options: IUnityOptions = {}): UnityProcess {
+    return invokeUnity(options).logFile(null).batchmode().noGraphics().quit();
+}

src/logger.ts

@@ -0,0 +1,5 @@
+export type SimpleLogger = (message: string) => void;
+
+export function noopLogger(): void {
+    // do nothing
+}

src/unity_cli_options.ts

@@ -0,0 +1,101 @@
+export type Flag = boolean;
+
+export type BuildTarget =
+    'win32'|'win64'|'osx'|'linux'|'linux64'|'ios'|'android'|'web'|'webstreamed'|
+    'webgl'|'xboxone'|'ps4'|'psp2'|'wsaplayer'|'tizen'|'samsungtv'|string;
+
+export interface IUnityOptions {
+    [customOption: string]: Flag|string|string[]|undefined;
+
+    batchmode?: Flag;
+
+    buildLinux32Player?: string;
+
+    buildLinux64Player?: string;
+
+    buildLinuxUniversalPlayer?: string;
+
+    buildOSXPlayer?: string;
+
+    buildOSX64Player?: string;
+
+    buildOSXUniversalPlayer?: string;
+
+    buildTarget?: BuildTarget|string;
+
+    buildWindowsPlayer?: string;
+
+    buildWindows64Player?: string;
+
+    cleanedLogFile?: Flag;
+
+    createProject?: string;
+
+    editorTestsCategories?: string;
+
+    editorTestsFilter?: string;
+
+    editorTestsResultFile?: string;
+
+    executeMethod?: string;
+
+    exportPackage?: string;
+
+    'force-d3d9'?: Flag;
+
+    'force-d3d11'?: Flag;
+
+    'force-glcore'?: Flag;
+
+    'force-glcore32'?: Flag;
+
+    'force-glcore33'?: Flag;
+
+    'force-glcore40'?: Flag;
+
+    'force-glcore41'?: Flag;
+
+    'force-glcore42'?: Flag;
+
+    'force-glcore43'?: Flag;
+
+    'force-glcore44'?: Flag;
+
+    'force-glcore45'?: Flag;
+
+    'force-gles'?: Flag;
+
+    'force-gles30'?: Flag;
+
+    'force-gles31'?: Flag;
+
+    'force-gles32'?: Flag;
+
+    'force-clamped'?: Flag;
+
+    'force-free'?: Flag;
+
+    importPackage?: string;
+
+    logFile?: string|Flag;
+
+    nographics?: Flag;
+
+    password?: string;
+
+    projectPath?: string;
+
+    quit?: Flag;
+
+    returnlicense?: Flag;
+
+    runEditorTests?: Flag;
+
+    serial?: string;
+
+    'silent-crashes'?: Flag;
+
+    username?: string;
+
+    'disable-assembly-updater'?: Flag|string[];
+}

src/unity_finder.ts

@@ -0,0 +1,36 @@
+import * as fs from 'fs';
+import * as pify from 'pify';
+
+const candidateUnityPaths = [
+    '/opt/Unity/Editor/Unity', // Debian / Ubuntu
+    '/Applications/Unity/Unity.app/Contents/MacOS/Unity', // MacOS
+    'C:\\Program Files (x86)\\Unity\\Editor\\Unity.exe', // Windows x86
+    'C:\\Program Files\\Unity\\Editor\\Unity.exe' // Windows x64
+];
+
+let unityBinaryPath: string;
+
+export async function getUnityPath(): Promise<string> {
+    // this is not a pure function and it caches its result
+    if (unityBinaryPath) { return unityBinaryPath; }
+
+    //=> Try all paths, take the first
+    for (const path of candidateUnityPaths) {
+        try {
+            await pify(fs.access)(path, fs.constants.X_OK);
+            return unityBinaryPath = path;
+        } catch (err) { /* pass */ }
+    }
+
+    //=> Oops, no Unity installation found
+    const triedPaths = candidateUnityPaths.map(path => `"${path}"`).join(', ');
+
+    throw new Error(
+        `Unable to locate Unity installation, tried all of these paths: ${triedPaths}. ` +
+        `Please use setUnityPath('/path/to/unity/executable').`
+    );
+}
+
+export function setUnityPath(executablePath: string): void {
+    unityBinaryPath = executablePath;
+}

src/unity_invoker.ts

@@ -0,0 +1,81 @@
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import * as pify from 'pify';
+import { SimpleLogger } from './logger';
+import { IUnityOptions } from './unity_cli_options';
+import { getUnityPath } from './unity_finder';
+
+export async function runUnityProcess(options: IUnityOptions, logger: SimpleLogger): Promise<string> {
+    //=> Generating an argv array from the arguments object
+    const argv = toArgv(options);
+
+    //=> Spawn Unity process
+    const unityProcess = spawn(await getUnityPath(), argv);
+
+    //=> Watch process' stdout to log in real time, and keep the complete output in case of crash
+    let stdoutAggregator = '';
+    function stdoutHandler(buffer: Buffer) {
+        const message = buffer.toString();
+        stdoutAggregator += message;
+        logger(message.trim());
+    }
+
+    unityProcess.stdout.on('data', stdoutHandler);
+    unityProcess.stderr.on('data', stdoutHandler);
+
+    //=> Watch for the process to terminate, check return code
+    return new Promise<string>((resolve, reject) => {
+        unityProcess.once('close', async (close) => {
+            if (close === 0) {
+                resolve(stdoutAggregator);
+            } else {
+                const crashPath = await logUnityCrash(stdoutAggregator);
+                reject(new UnityCrashError(
+                    `Unity process crashed! Editor log has been written to ${crashPath}`,
+                    stdoutAggregator
+                ));
+            }
+        });
+    });
+}
+
+export function toArgv(options: IUnityOptions): string[] {
+    const argv: string[] = [];
+
+    Object.keys(options).forEach((key) => {
+        const value = options[key];
+
+        //=> Pass on false, null, undefined, etc (disabled flags).
+        if (!value) { return; }
+
+        //=> Enabled flags + options with value(s)
+        argv.push(`-${key}`);
+
+        //=> Options with value(s)
+        if (Array.isArray(value)) {
+            const values = value as string[];
+            values.forEach(v => argv.push(v));
+        } else if (typeof value !== 'boolean') {
+            argv.push(value);
+        }
+    });
+
+    return argv;
+}
+
+async function logUnityCrash(unityLog: string): Promise<string> {
+    const crashPath = path.join(os.tmpdir(), 'unity_crash.abcompiler.log');
+
+    await pify(fs.writeFile)(crashPath, unityLog);
+
+    return crashPath;
+}
+
+export class UnityCrashError extends Error {
+    constructor(message: string, public readonly unityLog: string) {
+        super(message);
+        Object.setPrototypeOf(this, UnityCrashError.prototype);
+    }
+}