Prompt for parameters during installation (#34)

Author: itowlson

package-lock.json

@@ -223,8 +223,10 @@
     "dependencies": {
         "@types/lodash": "^4.14.113",
         "@types/shelljs": "^0.8.0",
+        "@types/tmp": "0.0.33",
         "lodash": "^4.17.10",
-        "shelljs": "^0.7.7"
+        "shelljs": "^0.7.7",
+        "tmp": "^0.0.33"
     },
     "devDependencies": {
         "typescript": "^2.6.1",
@@ -237,4 +239,4 @@
         "type": "git",
         "url": "https://github.com/deis/duffle-vscode"
     }
-}
+}

package.json

@@ -8,6 +8,8 @@ import { succeeded, map, Errorable } from '../utils/errorable';
 import * as shell from '../utils/shell';
 import { cantHappen } from '../utils/never';
 import { promptBundle, BundleSelection, fileBundleSelection, repoBundleSelection } from '../utils/bundleselection';
+import { promptForParameters } from '../utils/parameters';
+import { withOptionalTempFile } from '../utils/tempfile';
 
 export async function install(target?: any): Promise<void> {
     if (!target) {
@@ -50,7 +52,12 @@ async function installCore(bundlePick: BundleSelection): Promise<void> {
         return;
     }
 
-    const installResult = await installTo(bundlePick, name);
+    const parameterValues = await promptForParameters(bundlePick, 'Install', 'Enter installation parameters');
+    if (parameterValues.cancelled) {
+        return;
+    }
+
+    const installResult = await installToViaTempFile(bundlePick, name, parameterValues.values);
 
     if (succeeded(installResult)) {
         await refreshBundleExplorer();
@@ -59,17 +66,22 @@ async function installCore(bundlePick: BundleSelection): Promise<void> {
     await showDuffleResult('install', (bundleId) => bundleId, installResult);
 }
 
-async function installTo(bundlePick: BundleSelection, name: string): Promise<Errorable<string>> {
+async function installToViaTempFile(bundlePick: BundleSelection, name: string, parameterValues: any): Promise<Errorable<string>> {
+    const parametersJSON = parameterValues ? JSON.stringify(parameterValues, undefined, 2) : undefined;
+    return withOptionalTempFile(parametersJSON, 'json', (paramsFile) => installTo(bundlePick, name, paramsFile));
+}
+
+async function installTo(bundlePick: BundleSelection, name: string, paramsFile: string | undefined): Promise<Errorable<string>> {
     if (bundlePick.kind === 'folder') {
         const folderPath = bundlePick.path;
         const bundlePath = path.join(folderPath, "cnab", "bundle.json");
         const installResult = await longRunning(`Duffle installing ${bundlePath}`,
-            () => duffle.installFile(shell.shell, bundlePath, name)
+            () => duffle.installFile(shell.shell, bundlePath, name, paramsFile)
         );
         return map(installResult, (_) => bundlePath);
     } else if (bundlePick.kind === 'repo') {
         const installResult = await longRunning(`Duffle installing ${bundlePick.bundle}`,
-            () => duffle.installBundle(shell.shell, bundlePick.bundle, name)
+            () => duffle.installBundle(shell.shell, bundlePick.label /* because bundlePick.bundle doesn't work */, name, paramsFile)
         );
         return map(installResult, (_) => bundlePick.bundle);
     }

src/commands/install.ts

@@ -11,3 +11,11 @@ export interface RepoBundle {
     readonly repository: string;
     readonly version: string;
 }
+
+export interface ParameterDefinition {
+    readonly name: string;
+    readonly type: string;
+    readonly allowedValues?: (number | string | boolean)[];
+    readonly defaultValue?: number | string | boolean;
+    readonly metadata?: { description?: string };
+}

src/duffle/duffle.objectmodel.ts

@@ -88,12 +88,16 @@ export async function build(sh: shell.Shell, folderPath: string): Promise<Errora
     return await invokeObj(sh, 'build', '.', { cwd: folderPath }, (s) => null);
 }
 
-export async function installFile(sh: shell.Shell, bundleFilePath: string, name: string): Promise<Errorable<null>> {
-    return await invokeObj(sh, 'install', `${name} -f "${bundleFilePath}"`, {}, (s) => null);
+export async function installFile(sh: shell.Shell, bundleFilePath: string, name: string, paramsFile: string | undefined): Promise<Errorable<null>> {
+    return await invokeObj(sh, 'install', `${name} -f "${bundleFilePath}" ${paramsArg(paramsFile)}`, {}, (s) => null);
 }
 
-export async function installBundle(sh: shell.Shell, bundleName: string, name: string): Promise<Errorable<null>> {
-    return await invokeObj(sh, 'install', `${name} ${bundleName}`, {}, (s) => null);
+export async function installBundle(sh: shell.Shell, bundleName: string, name: string, paramsFile: string | undefined): Promise<Errorable<null>> {
+    return await invokeObj(sh, 'install', `${name} ${bundleName} ${paramsArg(paramsFile)}`, {}, (s) => null);
+}
+
+function paramsArg(file: string | undefined): string {
+    return file ? `-p "${file}"` : '';
 }
 
 function fromHeaderedTable<T>(lines: string[]): T[] {

src/duffle/duffle.ts

@@ -0,0 +1,32 @@
+import * as vscode from 'vscode';
+
+export const END_DIALOG_FN = "endDialog()";
+
+export function dialog(tabTitle: string, htmlBody: string, formId: string): Promise<any> {
+    return new Promise<any>((resolve, reject) => {
+        const postbackScript = `<script>
+        function ${END_DIALOG_FN} {
+            const vscode = acquireVsCodeApi();
+            const s = {};
+            for (const e of document.forms['${formId}'].elements) {
+                s[e.name] = e.value;
+            }
+            vscode.postMessage(s);
+        }
+        </script>`;
+
+        const html = postbackScript + htmlBody;
+        const w = vscode.window.createWebviewPanel('duffle-dialog', tabTitle, vscode.ViewColumn.Active, {
+            retainContextWhenHidden: false,
+            enableScripts: true,
+        });
+        w.webview.html = html;
+        const cancelSubscription = w.onDidDispose(() => resolve(undefined));
+        w.webview.onDidReceiveMessage((m) => {
+            cancelSubscription.dispose();
+            w.dispose();
+            resolve(m);
+        });
+        w.reveal();
+    });
+}

src/utils/dialog.ts

@@ -0,0 +1,96 @@
+import * as path from 'path';
+
+import { fs } from './fs';
+import { ParameterDefinition } from "../duffle/duffle.objectmodel";
+import { BundleSelection } from "./bundleselection";
+import { END_DIALOG_FN, dialog } from "./dialog";
+import { cantHappen } from './never';
+
+interface ParameterValues {
+    readonly cancelled: false;
+    readonly values: any;
+}
+
+interface Cancelled {
+    readonly cancelled: true;
+}
+
+export type ParameterValuesPromptResult = ParameterValues | Cancelled;
+
+export async function promptForParameters(bundlePick: BundleSelection, actionName: string, prompt: string): Promise<ParameterValuesPromptResult> {
+    const definitions = await bundleParameters(bundlePick);
+    if (!definitions || definitions.length === 0) {
+        return { cancelled: false, values: {} };
+    }
+
+    const parameterFormId = 'pvform';
+
+    const html = `<h1>${prompt}</h1>
+    <form id='${parameterFormId}'>
+    ${parameterEntryTable(definitions)}
+    </form>
+    <p><button onclick='${END_DIALOG_FN}'>${actionName}</button></p>`;
+
+    const parameterValues = await dialog(`${actionName} ${bundlePick.label}`, html, parameterFormId);
+    if (!parameterValues) {
+        return { cancelled: true };
+    }
+
+    return { cancelled: false, values: parameterValues };
+}
+
+function parameterEntryTable(ps: ParameterDefinition[]): string {
+    const rows = ps.map(parameterEntryRow).join('');
+    return `<table>${rows}</table>`;
+}
+
+function parameterEntryRow(p: ParameterDefinition): string {
+    return `<tr valign="baseline">
+    <td><b>${p.name}</b></td>
+    <td>${inputWidget(p)}</td>
+</tr>
+<tr>
+    <td colspan="2" style="font-size:80%">${p.metadata ? p.metadata.description : ''}</td>
+</tr>
+`;
+}
+
+function inputWidget(p: ParameterDefinition): string {
+    if (p.type === "boolean") {
+        return `<select name="${p.name}"><option>True</option><option>False</option></select>`;
+    }
+    if (p.allowedValues) {
+        const opts = p.allowedValues.map((av) => `<option>${av}</option>`).join('');
+        return `<select name="${p.name}">${opts}</select>`;
+    }
+    const defval = p.defaultValue ? `${p.defaultValue}` : '';
+    return `<input name="${p.name}" type="text" value="${defval}" />`;
+}
+
+function localPath(bundleRef: string): string {
+    const bits = bundleRef.split('/');
+    const last = bits.pop()!;
+    bits.push('bundles', last);
+    return bits.join('/');
+}
+
+async function bundleParameters(bundlePick: BundleSelection): Promise<ParameterDefinition[]> {
+    if (bundlePick.kind === "folder") {
+        return await parseParametersFromJSONFile(path.join(bundlePick.path, "bundle.json"));
+    } else if (bundlePick.kind === "repo") {
+        return await parseParametersFromJSONFile(path.join(process.env["USERPROFILE"]!, ".duffle", "repositories", localPath(bundlePick.bundle) + '.json'));
+    }
+    return cantHappen(bundlePick);
+}
+
+async function parseParametersFromJSONFile(jsonFile: string): Promise<ParameterDefinition[]> {
+    const json = await fs.readFile(jsonFile, 'utf8');
+    const parameters = JSON.parse(json).parameters;
+    const defs: ParameterDefinition[] = [];
+    if (parameters) {
+        for (const k in parameters) {
+            defs.push({ name: k, ...parameters[k] });
+        }
+    }
+    return defs;
+}

src/utils/parameters.ts

@@ -0,0 +1,18 @@
+import * as tmp from 'tmp';
+
+import { fs } from './fs';
+
+export async function withOptionalTempFile<T>(content: string | undefined, fileType: string, fn: (filename: string | undefined) => Promise<T>): Promise<T> {
+    if (!content) {
+        return fn(undefined);
+    }
+
+    const tempFile = tmp.fileSync({ prefix: "vsduffle-", postfix: `.${fileType}` });
+    await fs.writeFile(tempFile.name, content);
+
+    try {
+        return await fn(tempFile.name);
+    } finally {
+        tempFile.removeCallback();
+    }
+}