implement better handling for switching python environments, no reload needed

d-biehl · d-biehl · commit 81554631b623 · 2021-06-08T19:07:35.000+02:00
diff --git a/robotcode/language_server/common/protocol.py b/robotcode/language_server/common/protocol.py
@@ -165,7 +165,7 @@ async def _initialize(
             raise
         except BaseException as e:
             raise JsonRPCErrorException(
-                JsonRPCErrors.INTERNAL_ERROR, f"Can't start language server: {e}", InitializeError(retry=True)
+                JsonRPCErrors.INTERNAL_ERROR, f"Can't start language server: {e}", InitializeError(retry=False)
             ) from e
 
         return InitializeResult(
diff --git a/robotcode/language_server/robotframework/protocol.py b/robotcode/language_server/robotframework/protocol.py
@@ -34,7 +34,7 @@ def check_robotframework() -> None:
     try:
         __import__("robot")
     except ImportError as e:
-        raise Exception("RobotFramework not found, please install.") from e
+        raise Exception("'robot' module not found, please install RobotFramework.") from e
 
     if get_robot_version() < (4, 0):
         raise Exception("Wrong RobotFramework version. Expect version >= 4.0")
diff --git a/vscode-client/extension.ts b/vscode-client/extension.ts
@@ -2,7 +2,7 @@ import * as net from "net";
 import * as path from "path";
 import * as vscode from "vscode";
 import { LanguageClient, LanguageClientOptions, ServerOptions } from "vscode-languageclient/node";
-import { sleep } from "./utils";
+import { sleep, Mutex } from "./utils";
 
 const LANGUAGE_SERVER_DEFAULT_TCP_PORT = 6610;
 const LANGUAGE_SERVER_DEFAULT_HOST = "127.0.0.1";
@@ -40,8 +40,21 @@ function getPythonCommand(folder: vscode.WorkspaceFolder | undefined): string |
     return result;
 }
 
+let clientsMutex = new Mutex();
 let clients: Map<string, LanguageClient> = new Map();
 
+async function pythonExcetionDidChangeExecutionDetails(uri: vscode.Uri | undefined) {
+    if (uri && clients.has(uri.toString())) {
+        await clientsMutex.dispatch(async () => {
+            let client = clients.get(uri.toString());
+            clients.delete(uri.toString());
+            await client?.stop();
+        });
+
+        await getLanguageClientForResource(uri);
+    }
+}
+
 let _sortedWorkspaceFolders: string[] | undefined;
 function sortedWorkspaceFolders(): string[] {
     if (_sortedWorkspaceFolders === undefined) {
@@ -61,7 +74,6 @@ function sortedWorkspaceFolders(): string[] {
     }
     return _sortedWorkspaceFolders;
 }
-vscode.workspace.onDidChangeWorkspaceFolders(() => (_sortedWorkspaceFolders = undefined));
 
 function getOuterMostWorkspaceFolder(folder: vscode.WorkspaceFolder): vscode.WorkspaceFolder {
     let sorted = sortedWorkspaceFolders();
@@ -84,64 +96,73 @@ async function getLanguageClientForDocument(document: vscode.TextDocument): Prom
 }
 
 async function getLanguageClientForResource(resource: string | vscode.Uri): Promise<LanguageClient | undefined> {
-    let uri = resource instanceof vscode.Uri ? resource : vscode.Uri.parse(resource);
-    let workspaceFolder = vscode.workspace.getWorkspaceFolder(uri);
+    let client = await clientsMutex.dispatch(async () => {
+        let uri = resource instanceof vscode.Uri ? resource : vscode.Uri.parse(resource);
+        let workspaceFolder = vscode.workspace.getWorkspaceFolder(uri);
 
-    if (!workspaceFolder) {
-        return;
-    }
+        if (!workspaceFolder) {
+            return undefined;
+        }
 
-    workspaceFolder = getOuterMostWorkspaceFolder(workspaceFolder);
+        workspaceFolder = getOuterMostWorkspaceFolder(workspaceFolder);
 
-    var result = clients.get(workspaceFolder.uri.toString());
+        var result = clients.get(workspaceFolder.uri.toString());
 
-    if (!result) {
-        let config = vscode.workspace.getConfiguration(CONFIG_SECTION, uri);
+        if (!result) {
+            let config = vscode.workspace.getConfiguration(CONFIG_SECTION, uri);
 
-        let mode = config.get<string>("languageServer.mode", "stdio");
+            let mode = config.get<string>("languageServer.mode", "stdio");
 
-        const serverOptions: ServerOptions =
-            mode === "tcp" ? getServerOptionsTCP(workspaceFolder) : getServerOptionsStdIo(workspaceFolder);
-        let name = `RobotCode Language Server mode=${mode} for workspace folder "${workspaceFolder.name}"`;
+            const serverOptions: ServerOptions =
+                mode === "tcp" ? getServerOptionsTCP(workspaceFolder) : getServerOptionsStdIo(workspaceFolder);
+            let name = `RobotCode Language Server mode=${mode} for workspace folder "${workspaceFolder.name}"`;
 
-        let outputChannel = mode === "stdio" ? vscode.window.createOutputChannel(name) : undefined;
+            let outputChannel = mode === "stdio" ? vscode.window.createOutputChannel(name) : undefined;
 
-        let clientOptions: LanguageClientOptions = {
-            documentSelector: [
-                { scheme: "file", language: "robotframework", pattern: `${workspaceFolder.uri.fsPath}/**/*` },
-            ],
-            synchronize: {
-                configurationSection: [CONFIG_SECTION, "python"],
-            },
-            initializationOptions: {
-                storageUri: extensionContext?.storageUri?.toString(),
-                globalStorageUri: extensionContext?.globalStorageUri?.toString(),
-            },
-            diagnosticCollectionName: "robotcode",
-            workspaceFolder: workspaceFolder,
-            outputChannel: outputChannel,
-            markdown: {
-                isTrusted: true,
-            },
-            progressOnInitialization: true,
-        };
+            let clientOptions: LanguageClientOptions = {
+                documentSelector: [
+                    { scheme: "file", language: "robotframework", pattern: `${workspaceFolder.uri.fsPath}/**/*` },
+                ],
+                synchronize: {
+                    configurationSection: [CONFIG_SECTION, "python"],
+                },
+                initializationOptions: {
+                    storageUri: extensionContext?.storageUri?.toString(),
+                    globalStorageUri: extensionContext?.globalStorageUri?.toString(),
+                },
+                diagnosticCollectionName: "robotcode",
+                workspaceFolder: workspaceFolder,
+                outputChannel: outputChannel,
+                markdown: {
+                    isTrusted: true,
+                },
+                progressOnInitialization: true,
+            };
 
-        OUTPUT_CHANNEL.appendLine(`start Language client: ${name}`);
-        result = new LanguageClient(name, serverOptions, clientOptions);
-        clients.set(workspaceFolder.uri.toString(), result);
+            OUTPUT_CHANNEL.appendLine(`start Language client: ${name}`);
+            result = new LanguageClient(name, serverOptions, clientOptions);
+            clients.set(workspaceFolder.uri.toString(), result);
+        }
+        return result;
+    });
 
-        result.start();
-    }
+    if (client) {
+        if (client.needsStart()) {
+            client.start();
+        }
 
-    var counter = 0;
-    while (!result.initializeResult && counter < 10_000) {
-        await sleep(100);
-        counter++;
-    }
+        var counter = 0;
+        while (!client.initializeResult && counter < 10_000) {
+            await sleep(100);
+            counter++;
+        }
 
-    await result.onReady();
+        await client.onReady().catch((reason) => {
+            OUTPUT_CHANNEL.appendLine("puhhh: " + reason);
+        });
+    }
 
-    return result;
+    return client;
 }
 
 function getServerOptionsTCP(folder: vscode.WorkspaceFolder) {
@@ -173,7 +194,7 @@ function getServerOptionsStdIo(folder: vscode.WorkspaceFolder) {
 
     let pythonCommand = getPythonCommand(folder);
 
-    if (pythonCommand === undefined) {
+    if (!pythonCommand) {
         throw new Error("Can't find a valid python executable.");
     }
 
@@ -481,6 +502,7 @@ export async function activateAsync(context: vscode.ExtensionContext) {
     OUTPUT_CHANNEL.appendLine("Python Extension is active");
 
     context.subscriptions.push(
+        pythonExtension.exports.settings.onDidChangeExecutionDetails(pythonExcetionDidChangeExecutionDetails),
         vscode.commands.registerCommand("robotcode.runSuite", async (resource) => {
             return await debugSuiteOrTestcase(resource ?? vscode.window.activeTextEditor?.document.uri, undefined, {
                 noDebug: true,
@@ -520,13 +542,17 @@ export async function activateAsync(context: vscode.ExtensionContext) {
                 return await debugSuiteOrTestcase(res, realTest);
             }
         ),
-        vscode.workspace.onDidChangeWorkspaceFolders((event) => {
+        vscode.workspace.onDidChangeWorkspaceFolders(async (event) => {
             for (let folder of event.removed) {
-                let client = clients.get(folder.uri.toString());
-                if (client) {
-                    clients.delete(folder.uri.toString());
-                    client.stop();
-                }
+                await clientsMutex.dispatch(async () => {
+                    _sortedWorkspaceFolders = undefined;
+
+                    let client = clients.get(folder.uri.toString());
+                    if (client) {
+                        clients.delete(folder.uri.toString());
+                        client.stop();
+                    }
+                });
             }
         }),
         vscode.debug.registerDebugConfigurationProvider("robotcode", new RobotCodeDebugConfigurationProvider()),
@@ -603,7 +629,7 @@ export async function activateAsync(context: vscode.ExtensionContext) {
 
         vscode.workspace.onDidChangeConfiguration((event) => {
             for (let s of [
-                "python.pythonPath",
+                //"python.pythonPath",
                 "robotcode.python",
                 "robotcode.languageServer.mode",
                 "robotcode.languageServer.tcpPort",
@@ -669,10 +695,10 @@ export async function activateAsync(context: vscode.ExtensionContext) {
     );
 
     for (let document of vscode.workspace.textDocuments) {
-        await getLanguageClientForDocument(document);
+        getLanguageClientForDocument(document);
     }
 
-    await updateEditorContext();
+    updateEditorContext();
 }
 
 function displayProgress(promise: Promise<any>) {
diff --git a/vscode-client/utils.ts b/vscode-client/utils.ts
@@ -20,4 +20,29 @@ export async function waitForPromise<T>(promise: Promise<T>, timeout: number): P
                 reject(e);
             });
     });
-}
+}
+
+export class Mutex {
+    private mutex = Promise.resolve();
+
+    lock(): PromiseLike<() => void> {
+        let begin: (unlock: () => void) => void = (unlock) => {};
+
+        this.mutex = this.mutex.then(() => {
+            return new Promise(begin);
+        });
+
+        return new Promise((res) => {
+            begin = res;
+        });
+    }
+
+    async dispatch<T>(fn: (() => T) | (() => PromiseLike<T>)): Promise<T> {
+        const unlock = await this.lock();
+        try {
+            return await Promise.resolve(fn()).finally(() => unlock());
+        } finally {
+            unlock();
+        }
+    }
+}
