fix(vscode): recovers server process if terminated

extensions/vscode/package.json

@@ -17,12 +17,14 @@
     "Machine Learning",
     "Other"
   ],
-  "activationEvents": [],
+  "activationEvents": [
+    "onStartupFinished"
+  ],
   "main": "./out/extension.js",
   "contributes": {
     "commands": [
       {
-        "command": "posit.publisher.start",
+        "command": "posit.publisher.open",
         "title": "Open Publisher",
         "category": "Posit",
         "icon": {
@@ -48,7 +50,7 @@
     "menus": {
       "editor/title": [
         {
-          "command": "posit.publisher.start",
+          "command": "posit.publisher.open",
           "group": "navigation"
         }
       ]

extensions/vscode/src/extension.ts

@@ -2,6 +2,7 @@
 // Import the module and reference it with the alias vscode in your code below
 import * as vscode from 'vscode';
 
+import * as ports from './ports';
 import  { Service } from './services';
 
 // Once the extension is activate, hang on to the service so that we can stop it on deactivation.
@@ -11,16 +12,18 @@ let service: Service;
 // Your extension is activated the very first time the command is executed
 export async function activate(context: vscode.ExtensionContext) {
 
+	const port = await ports.acquire();
+	service = new Service(port);
+	await service.start(context);
+
 	context.subscriptions.push(
-		vscode.commands.registerCommand('posit.publisher.start', async () => {
-			service = await Service.get(context);
-			await service.start();
+		vscode.commands.registerCommand('posit.publisher.open', async () => {
+			await service.open(context);
 		})
 	);
 
 	context.subscriptions.push(
 		vscode.commands.registerCommand('posit.publisher.close', async () => {
-			service = await Service.get(context);
 			await service.stop();
 		})
 	);

extensions/vscode/src/panels.ts

@@ -1,31 +1,21 @@
 import * as vscode from 'vscode';
 
-const DEFAULT_COLUMN = vscode.ViewColumn.Beside;
+import { HOST } from '.';
 
-export interface IPanel extends vscode.Disposable {
-    show: () => Promise<undefined>;
-}
+const DEFAULT_COLUMN = vscode.ViewColumn.Beside;
 
-export class Panel implements IPanel {
+export class Panel {
 
-    private readonly context: vscode.ExtensionContext;
     private readonly url: string;
 
     private column: vscode.ViewColumn = DEFAULT_COLUMN;
     private panel?: vscode.WebviewPanel;
 
-    /**
-     * Creates a Panel implementation.
-     *
-     * @param {vscode.ExtensionContext} context - The extension content
-     * @param {string} url - The server url (i.e., http://localhost:8080)
-     */
-    constructor(context: vscode.ExtensionContext, url: string) {
-        this.context = context;
-        this.url = url;
+    constructor(port: number) {
+        this.url = `http://${HOST}:${port}`;
     }
 
-    async show(): Promise<undefined> {
+    async show(context: vscode.ExtensionContext): Promise<undefined> {
         // reveal panel if defined
         if (this.panel !== undefined) {
             this.panel.reveal(this.column);
@@ -55,7 +45,7 @@ export class Panel implements IPanel {
                 this.column = event.webviewPanel.viewColumn || DEFAULT_COLUMN;
             },
             null,
-            this.context.subscriptions
+            context.subscriptions
         );
 
         // register dispose
@@ -65,7 +55,7 @@ export class Panel implements IPanel {
                 this.panel = undefined;
             },
             null,
-            this.context.subscriptions
+            context.subscriptions
         );
     }
 

extensions/vscode/src/ports.ts

@@ -1,23 +1,5 @@
 import getPort = require('get-port');
-import * as wait from 'wait-on';
-
-import { HOST } from '.';
 
 export const acquire = async (): Promise<number> => {
     return getPort();
 };
-
-export const ping = async (port: number, timeout: number = 30 * 1000): Promise<boolean> => {
-    try {
-        await wait({
-            resources: [
-                `http-get://${HOST}:${port}`
-            ],
-            timeout: timeout
-        });
-        return true;
-    } catch (e) {
-        console.warn("failed waiting for port", e);
-        return false;
-    }
-};

extensions/vscode/src/servers.ts

@@ -0,0 +1,70 @@
+import * as retry from 'retry';
+import * as vscode from 'vscode';
+import * as wait from 'wait-on';
+
+import { HOST } from '.';
+
+import * as commands from './commands';
+import { Terminal } from './terminals';
+import * as workspaces from './workspaces';
+
+export class Server implements Server, vscode.Disposable {
+
+    readonly port: number;
+    readonly terminal: Terminal;
+
+    constructor (port: number) {
+        this.port = port;
+        this.terminal = new Terminal();
+    }
+
+    async start(context: vscode.ExtensionContext): Promise<void> {
+        const isRunning = await this.isRunning();
+        if (!isRunning) {
+            const message = vscode.window.setStatusBarMessage("Starting Posit Publisher. Please wait...");
+            const path = workspaces.path();
+            const command: commands.Command = await commands.create(context, path!, this.port);
+            this.terminal.get().sendText(command);
+            await this.isRunning();
+            // The server will respond as ready before the API has fully initialized. Wait an additional second for good measure.
+            await new Promise(_ => setTimeout(_, 1000));
+            message.dispose();
+        }
+    }
+
+    async stop(): Promise<void> {
+        const message = vscode.window.setStatusBarMessage("Shutting down Posit Publisher. Please wait...");
+        const operation = retry.operation();
+		operation.attempt(async () => {
+			// send "CTRL+C" command
+			this.terminal.get().sendText("\u0003");
+			const isRunning = await this.isRunning();
+
+			if (isRunning) {
+                // throw error to invoke retry
+				throw Error("application is still running");
+			}
+		});
+        message.dispose();
+    }
+
+    dispose() {
+        this.terminal.dispose();
+    }
+
+    private async isRunning(): Promise<boolean> {
+        try {
+            await wait({
+                resources: [
+                    `http-get://${HOST}:${this.port}`
+                ],
+                timeout: 1000
+            });
+            return true;
+        } catch (e) {
+            console.warn("failed waiting for port", e);
+            return false;
+        }
+    }
+
+}