Improve server start implementation and provide better error reporting

- Report error for spawn() failures
- Register callback for server exit, error and stderr to catch such
  errors
- If error happens report the error with detailed message from stderr
- Do healthCheck in 1 second intervals until it is successful or the
  overall timeout of 10s happens
- Remove unnecessary warning messages when stopping server after startup
  failures.

Signed-off-by: Bernd Hufmann <bernd.hufmann@ericsson.com>

Author: bhufmann

src/trace-server.ts

@@ -13,7 +13,7 @@ const key = 'pid';
 const millis = 10000;
 const none = -1;
 const prefix = 'Trace Server';
-const suffix = ' failure or so.';
+const suffix = ' failure.';
 const SHUTDOWN_DELAY = 2000;
 
 export class TraceServer {
@@ -24,15 +24,21 @@ export class TraceServer {
         const server = spawn(this.getPath(from), this.getArgs(from));
 
         if (!server.pid) {
-            this.showError(prefix + ' startup' + suffix);
+            // Failed to spawn the child process due to errors, PID is undefined and an error is emitted.
+            await new Promise<void>(resolve => {
+                server.once('error', error => {
+                    this.showError(prefix + ' startup' + suffix + ': ' + error);
+                });
+                resolve();
+            });
             return;
         }
         this.server = server;
         await context?.workspaceState.update(key, this.server.pid);
         await this.waitFor(context);
     }
 
-    async stopOrReset(context: vscode.ExtensionContext | undefined) {
+    async stopOrReset(context: vscode.ExtensionContext | undefined, reportNotStopped: boolean = true) {
         const pid: number | undefined = context?.workspaceState.get(key);
         const not = prefix + ' not stopped as none running or owned by us.';
         if (pid === none) {
@@ -66,7 +72,7 @@ export class TraceServer {
                     });
                 }
             );
-        } else {
+        } else if (reportNotStopped) {
             vscode.window.showWarningMessage(not);
         }
         await context?.workspaceState.update(key, none);
@@ -168,27 +174,57 @@ export class TraceServer {
             },
             async progress => {
                 progress.report({ message: 'starting up...' });
-                let timeout = false;
-                const timeoutId = setTimeout(() => (timeout = true), millis);
-
-                // eslint-disable-next-line no-constant-condition
-                while (true) {
-                    if (await this.isUp()) {
-                        this.showStatus(true);
-                        clearTimeout(timeoutId);
-                        break;
-                    }
-                    if (timeout) {
-                        this.showError(prefix + ' startup timed-out after ' + millis + 'ms.');
-                        await this.stopOrReset(context);
-                        break;
+                try {
+                    let timeout = false;
+                    const timeoutId = setTimeout(() => (timeout = true), millis);
+
+                    let stderr = '';
+                    this.server?.stderr?.on('data', data => {
+                        stderr = data;
+                    });
+
+                    let errorString: string | undefined;
+                    this.server?.once('exit', code => {
+                        errorString = 'Code: ' + code + (stderr !== '.' ? '. Error message: ' + stderr : '');
+                    });
+
+                    this.server?.once('error', error => {
+                        errorString = 'Error occurred. Error message: ' + error;
+                    });
+
+                    // eslint-disable-next-line no-constant-condition
+                    while (true) {
+                        if (await this.isUp()) {
+                            clearTimeout(timeoutId);
+                            this.showStatus(true);
+                            break;
+                        }
+
+                        // Check if trace server exited with error
+                        if (errorString !== undefined) {
+                            throw new Error(errorString);
+                        }
+
+                        // Check for overall timeout
+                        if (timeout) {
+                            throw new Error(prefix + ' startup timed-out after ' + millis + 'ms.');
+                        }
+
+                        // Wait before trying again
+                        await new Promise<void>(resolve => setTimeout(() => resolve(), 1000));
                     }
+                } catch (error) {
+                    this.showErrorDetailed(prefix + ' starting up' + suffix, error as Error);
+                    await this.stopOrReset(context, false);
+                    return;
+                } finally {
+                    this.server?.removeAllListeners();
                 }
             }
         );
     }
 
-    private async isUp() {
+    private async isUp(): Promise<boolean> {
         const client = new TspClient(this.getServerUrl());
         const health = await client.checkHealth();
         const status = health.getModel()?.status;
@@ -198,18 +234,15 @@ export class TraceServer {
     private async showError(message: string) {
         console.error(message);
         vscode.window.showErrorMessage(message);
-        const disclaimer = ' running, despite this error.';
         const up = await this.isUp();
         if (up) {
-            vscode.window.showWarningMessage(prefix + ' is still' + disclaimer);
-        } else {
-            vscode.window.showWarningMessage(prefix + ' is not' + disclaimer);
+            vscode.window.showWarningMessage(prefix + ' is still running, despite this error.');
         }
         this.setStatusIfAvailable(up);
     }
 
     private showErrorDetailed(message: string, error: Error) {
-        const details = error.name + ' - ' + error.message;
+        const details = error.name + ' - ' + error?.message;
         vscode.window.showErrorMessage(details);
         console.error(details);
         this.showError(message);