Use OpenShift Terminal for Serverless

datho7561 · datho7561 · commit a58ad7a5080b · 2023-07-28T12:37:26.000-04:00
- Also fix a race condition that caused the terminal spawn to fail

Signed-off-by: David Thompson &lt;davthomp@redhat.com&gt;
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
@@ -17,7 +17,7 @@
                 "base": "$tsc-watch",
             },
             "presentation": {
-                "reveal": "silent",
+                "reveal": "never",
             },
         },
         {
diff --git a/src/cli.ts b/src/cli.ts
@@ -22,7 +22,6 @@ export interface CliExitData {
 export interface Cli {
     execute(cmd: string, opts?: cp.ExecOptions): Promise<CliExitData>;
     executeTool(command: CommandText, opts?: cp.ExecOptions): Promise<CliExitData>;
-    spawn(cmd: string, params: string[], opts: cp.SpawnOptions): cp.ChildProcess;
     spawnTool(cmd: CommandText, opts: cp.SpawnOptions): Promise<cp.ChildProcess>;
     executeInTerminal(cmd: CommandText, cwd?: string, terminalName?: string, addEnv?: {[key : string]: string}): void;
 }
@@ -157,10 +156,6 @@ export class CliChannel implements Cli {
         await OpenShiftTerminalManager.getInstance().createTerminal(command, name, cwd, merged);
     }
 
-    spawn(cmd: string, params: string[], opts: cp.SpawnOptions = {cwd: undefined, env: process.env}): cp.ChildProcess {
-        return cp.spawn(cmd, params, opts);
-    }
-
     async spawnTool(cmd: CommandText, opts: cp.SpawnOptions = {cwd: undefined, env: process.env}): Promise<cp.ChildProcess> {
         const toolLocation = await ToolsConfig.detect(cmd.command);
         const optWithTelemetryEnv = CliChannel.applyEnv(opts, CliChannel.createTelemetryEnv());
diff --git a/src/serveressFunction/build-run-deploy.ts b/src/serveressFunction/build-run-deploy.ts
@@ -3,23 +3,20 @@
  *  Licensed under the MIT License. See LICENSE file in the project root for license information.
  *-----------------------------------------------------------------------------------------------*/
 
-import { EventEmitter, Terminal, Uri, commands, window } from 'vscode';
-import { ClusterVersion, FunctionObject } from './types';
-import { ServerlessCommand, Utils } from './commands';
-import { Platform } from '../util/platform';
+import { commands, Uri, window } from 'vscode';
 import { OdoImpl } from '../odo';
-import { CliChannel } from '../cli';
-import { ChildProcess, SpawnOptions } from 'child_process';
+import { Platform } from '../util/platform';
+import { OpenShiftTerminalApi, OpenShiftTerminalManager } from '../webview/openshift-terminal/openShiftTerminal';
+import { ServerlessCommand, Utils } from './commands';
+import { ClusterVersion, FunctionObject } from './types';
 import { ServerlessFunctionView } from './view';
 
 export class BuildAndDeploy {
 
     private static instance: BuildAndDeploy;
 
-    private buildTerminalMap: Map<string, Terminal> = new Map<string, Terminal>();
-    public runTerminalMap: Map<string, Terminal> = new Map<string, Terminal>();
-    private buildEmiterMap: Map<string, EventEmitter<string>> = new Map<string, EventEmitter<string>>();
-    private buildPrcessMap: Map<Terminal, ChildProcess> = new Map<Terminal, ChildProcess>();
+    private buildTerminalMap = new Map<string, OpenShiftTerminalApi>();
+    public runTerminalMap = new Map<string, OpenShiftTerminalApi>();
 
     public static imageRegex = RegExp('[^/]+\\.[^/.]+\\/([^/.]+)(?:\\/[\\w\\s._-]*([\\w\\s._-]))*(?::[a-z0-9\\.-]+)?$');
 
@@ -46,38 +43,33 @@ export class BuildAndDeploy {
         }
     }
 
+    private pollForBuildTerminalDead(resolve: () => void, functionUri: Uri, timeout: number) {
+        return () => {
+            if (!this.buildTerminalMap.get(`build-${functionUri.fsPath}`)) {
+                resolve();
+            } else {
+                setTimeout(this.pollForBuildTerminalDead(resolve, functionUri, timeout * 2), timeout * 2);
+            }
+        }
+    }
+
     public async buildFunction(functionName: string, functionUri: Uri): Promise<void> {
-        const exisitingTerminal = this.buildTerminalMap.get(`build-${functionUri.fsPath}`);
-        const outputEmitter = this.buildEmiterMap.get(`build-${functionUri.fsPath}`);
-        if (exisitingTerminal) {
-            let exisitingProcess = this.buildPrcessMap.get(exisitingTerminal);
+        const existingTerminal = this.buildTerminalMap.get(`build-${functionUri.fsPath}`);
+
+        if (existingTerminal) {
             void window.showWarningMessage(`Do you want to restart ${functionName} build ?`, 'Yes', 'No').then(async (value: string) => {
                 if (value === 'Yes') {
-                    exisitingTerminal.show(true);
-                    await commands.executeCommand('workbench.action.terminal.clear')
-                    outputEmitter.fire(`Start Building ${functionName} \r\n`);
-                    exisitingProcess.kill('SIGINT')
-                    this.buildPrcessMap.delete(exisitingTerminal);
-                    const clusterVersion: ClusterVersion | null = await this.checkOpenShiftCluster();
-                    const buildImage = await this.getImage(functionUri);
-                    const opt: SpawnOptions = { cwd: functionUri.fsPath };
-                    void CliChannel.getInstance().spawnTool(ServerlessCommand.buildFunction(functionUri.fsPath, buildImage, clusterVersion), opt).then((cp) => {
-                        exisitingProcess = cp;
-                        this.buildPrcessMap.set(exisitingTerminal, cp);
-                        exisitingProcess.on('error', (err) => {
-                            void window.showErrorMessage(err.message);
-                        });
-                        exisitingProcess.stdout.on('data', (chunk) => {
-                            outputEmitter.fire(`${chunk as string}`.replaceAll('\n', '\r\n'));
-                        });
-                        exisitingProcess.stderr.on('data', (errChunk) => {
-                            outputEmitter.fire(`\x1b[31m${errChunk as string}\x1b[0m`.replaceAll('\n', '\r\n'));
-                            void window.showErrorMessage(`${errChunk as string}`);
-                        });
-                        exisitingProcess.on('exit', () => {
-                            outputEmitter.fire('\r\nPress any key to close this terminal\r\n');
-                        });
+                    existingTerminal.focusTerminal();
+                    existingTerminal.sendText('\u0003');
+
+                    // wait for old build to exit using polling with a back off
+                    await new Promise<void>((resolve) => {
+                        const INIT_TIMEOUT = 100;
+                        setTimeout(this.pollForBuildTerminalDead(resolve, functionUri, INIT_TIMEOUT), INIT_TIMEOUT);
                     });
+
+                    // start new build
+                    await this.buildProcess(functionUri, functionName);
                 }
             });
         } else {
@@ -88,115 +80,48 @@ export class BuildAndDeploy {
     private async buildProcess(functionUri: Uri, functionName: string) {
         const clusterVersion: ClusterVersion | null = await this.checkOpenShiftCluster();
         const buildImage = await this.getImage(functionUri);
-        const outputEmitter = new EventEmitter<string>();
-        let devProcess: ChildProcess;
-        let terminal = window.createTerminal({
-            name: `Build ${functionName}`,
-            pty: {
-                onDidWrite: outputEmitter.event,
-                open: () => {
-                    outputEmitter.fire(`Start Building ${functionName} \r\n`);
-                    const opt: SpawnOptions = { cwd: functionUri.fsPath };
-                    void CliChannel.getInstance().spawnTool(ServerlessCommand.buildFunction(functionUri.fsPath, buildImage, clusterVersion), opt).then((cp) => {
-                        this.buildPrcessMap.set(terminal, cp);
-                        devProcess = cp;
-                        devProcess.on('spawn', () => {
-                            terminal.show();
-                        });
-                        devProcess.on('error', (err) => {
-                            void window.showErrorMessage(err.message);
-                        });
-                        devProcess.stdout.on('data', (chunk) => {
-                            outputEmitter.fire(`${chunk as string}`.replaceAll('\n', '\r\n'));
-                        });
-                        devProcess.stderr.on('data', (errChunk) => {
-                            outputEmitter.fire(`\x1b[31m${errChunk as string}\x1b[0m`.replaceAll('\n', '\r\n'));
-                        });
-                        devProcess.on('exit', () => {
-                            outputEmitter.fire('\r\nPress any key to close this terminal\r\n');
-                        });
-                    });
-                },
-                close: () => {
-                    if (devProcess && devProcess.exitCode === null) { // if process is still running and user closed terminal
-                        devProcess.kill('SIGINT');
-                    }
-                    this.buildTerminalMap.delete(`build-${functionUri.fsPath}`);
-                    this.buildEmiterMap.delete(`build-${functionUri.fsPath}`);
-                    this.buildPrcessMap.delete(terminal);
-                    terminal = undefined;
-                },
-                handleInput: ((data: string) => {
-                    if (!devProcess) { // if any key pressed after process ends
-                        terminal.dispose();
-                    } else { // ctrl+C processed only once when there is no cleaning process
-                        outputEmitter.fire('^C\r\n');
-                        devProcess.kill('SIGINT');
-                        terminal.dispose();
-                    }
-                })
-            },
-        });
-        this.buildTerminalMap.set(`build-${functionUri.fsPath}`, terminal);
-        this.buildEmiterMap.set(`build-${functionUri.fsPath}`, outputEmitter);
+        const terminalKey = `build-${functionUri.fsPath}`;
+
+        const terminal = await OpenShiftTerminalManager.getInstance().createTerminal(
+            ServerlessCommand.buildFunction(functionUri.fsPath, buildImage, clusterVersion),
+            `Build ${functionName}`,
+            functionUri.fsPath,
+            process.env,
+            true,
+            {
+                onExit: () => {
+                    this.buildTerminalMap.delete(terminalKey)
+                }
+            }
+        );
+
+        this.buildTerminalMap.set(terminalKey, terminal);
     }
 
-    public runFunction(context: FunctionObject, runBuild = false) {
-        const outputEmitter = new EventEmitter<string>();
-        let runProcess: ChildProcess;
-        let terminal = window.createTerminal({
-            name: `Run ${context.name}`,
-            pty: {
-                onDidWrite: outputEmitter.event,
-                open: () => {
-                    outputEmitter.fire(`Running ${context.name} \r\n`);
-                    const opt: SpawnOptions = { cwd: context.folderURI.fsPath };
-                    void CliChannel.getInstance().spawnTool(ServerlessCommand.runFunction(context.folderURI.fsPath, runBuild), opt).then((cp) => {
-                        runProcess = cp;
-                        runProcess.on('spawn', () => {
-                            terminal.show();
-                        });
-                        runProcess.on('error', (err) => {
-                            void window.showErrorMessage(err.message);
-                        });
-                        runProcess.stdout.on('data', (chunk) => {
-                            outputEmitter.fire(`${chunk as string}`.replaceAll('\n', '\r\n'));
-                            void commands.executeCommand('openshift.Serverless.refresh', context);
-                        });
-                        runProcess.stderr.on('data', (errChunk) => {
-                            outputEmitter.fire(`\x1b[31m${errChunk as string}\x1b[0m`.replaceAll('\n', '\r\n'));
-                        });
-                        runProcess.on('exit', () => {
-                            outputEmitter.fire('\r\nPress any key to close this terminal\r\n');
-                        });
-                    });
+    public async runFunction(context: FunctionObject, runBuild = false) {
+        const terminal = await OpenShiftTerminalManager.getInstance().createTerminal(
+            ServerlessCommand.runFunction(context.folderURI.fsPath, runBuild),
+            `${runBuild ? 'Build and ' : ''}Run ${context.name}`,
+            context.folderURI.fsPath,
+            process.env,
+            true,
+            {
+                onSpawn: () => {
+                    void commands.executeCommand('openshift.Serverless.refresh', context);
                 },
-                close: () => {
-                    if (runProcess && runProcess.exitCode === null) { // if process is still running and user closed terminal
-                        runProcess.kill('SIGINT');
-                    }
+                onExit: () => {
                     this.runTerminalMap.delete(`run-${context.folderURI.fsPath}`);
-                    terminal = undefined;
                     void commands.executeCommand('openshift.Serverless.refresh', context);
-                },
-                handleInput: ((_data: string) => {
-                    if (!runProcess) {
-                        terminal.dispose();
-                    } else {
-                        outputEmitter.fire('^C\r\n');
-                        runProcess.kill('SIGINT');
-                        terminal.dispose()
-                    }
-                })
-            },
-        });
+                }
+            }
+        );
         this.runTerminalMap.set(`run-${context.folderURI.fsPath}`, terminal);
     }
 
     public stopFunction(context: FunctionObject) {
         const terminal = this.runTerminalMap.get(`run-${context.folderURI.fsPath}`);
         if (terminal) {
-            terminal.sendText('^C\r\n');
+            terminal.sendText('\u0003');
         }
     }
 
diff --git a/src/webview/openshift-terminal/openShiftTerminal.ts b/src/webview/openshift-terminal/openShiftTerminal.ts
@@ -9,15 +9,12 @@ import type * as pty from 'node-pty';
 import { platform } from 'os';
 import {
     CancellationToken,
-    ColorTheme,
-    Disposable,
+    ColorTheme, commands, Disposable,
     Webview,
     WebviewView,
     WebviewViewProvider,
-    WebviewViewResolveContext,
-    commands,
-    window,
-    workspace,
+    WebviewViewResolveContext, window,
+    workspace
 } from 'vscode';
 import { SerializeAddon } from 'xterm-addon-serialize';
 import { Terminal } from 'xterm-headless';
@@ -522,9 +519,6 @@ export class OpenShiftTerminalManager implements WebviewViewProvider {
         await commands.executeCommand('openShiftTerminalView.focus');
         // wait until the webview is ready to receive requests to create terminals
         await this.webviewResolved;
-        // issue request to create terminal in the webview
-        const newTermUUID = randomUUID();
-        await this.sendMessage({ kind: 'createTerminal', data: { uuid: newTermUUID, name } });
 
         const [cmd, ...args] = `${commandText}`.split(' ');
         let toolLocation: string | undefined;
@@ -547,6 +541,8 @@ export class OpenShiftTerminalManager implements WebviewViewProvider {
             throw new Error(msg);
         }
 
+        const newTermUUID = randomUUID();
+
         // create the object that manages the headless terminal and the pty.
         // the process is run as a child process under node.
         // the webview is synchronized to the pty and headless terminal using message passing
@@ -569,6 +565,9 @@ export class OpenShiftTerminalManager implements WebviewViewProvider {
             ),
         );
 
+        // issue request to create terminal in the webview
+        await this.sendMessage({ kind: 'createTerminal', data: { uuid: newTermUUID, name } });
+
         return {
             sendText: (text: string) => this.openShiftTerminals.get(newTermUUID).write(text),
             focusTerminal: () =>

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@`
`17`	`17`	`"base": "$tsc-watch",`
`18`	`18`	`},`
`19`	`19`	`"presentation": {`
`20`		`- "reveal": "silent",`
	`20`	`+ "reveal": "never",`
`21`	`21`	`},`
`22`	`22`	`},`
`23`	`23`	`{`