Add priority setting for servers handling the same language

Author: krassowski

atest/03_Notebook.robot

@@ -47,7 +47,7 @@ Moving Cells Around
 Foreign Extractors
     ${file} =    Set Variable    Foreign extractors.ipynb
     Configure JupyterLab Plugin
-    ...    {"language_servers": {"texlab": {"serverSettings": {"latex.lint.onChange": true}}, "bash-langauge-server": {"bashIde.highlightParsingErrors": true}}}
+    ...    {"language_servers": {"texlab": {"serverSettings": {"latex.lint.onChange": true}}, "bash-langauge-server": {"bashIde.highlightParsingErrors": true}}, "pylsp": {"priority": 1000}}
     Capture Page Screenshot    10-configured.png
     Reset Application State
     Setup Notebook    Python    ${file}

docs/Configuring.ipynb

@@ -66,7 +66,8 @@
     "    `mkdir \"new directory\"` should be split into `[\"mkdir\", \"new directory\"]`;\n",
     "    If you have Python installed, you can use `shlex.split(\"your command\")` to\n",
     "    get such an array.\n",
-    "- the `languages` which the language server will respond to, and\n",
+    "- the `languages` which the language server will respond to (language names\n",
+    "  should be given in lowercase), and\n",
     "- the schema `version` of the spec (currently `2`)\n",
     "- `mime_types` by which the notebooks and files will be matched to the language\n",
     "  server:\n",

docs/Language Servers.ipynb

@@ -137,8 +137,9 @@
     "\n",
     "These servers have support for notebooks and file editors. The `pyls` and\n",
     "`r-languageserver` are well-tested, while `jedi` and `Julia` servers are\n",
-    "experimental. Please only install one language server per language (`jedi` or\n",
-    "`pyls` for Python - not both)."
+    "experimental. If you choose to install multiple language servers for the same\n",
+    "language, the one with the highest `priority` (which can be set in the _Advanced\n",
+    "Settings Editor_) will be used."
    ]
   },
   {

packages/jupyterlab-lsp/schema/plugin.json

@@ -16,6 +16,12 @@
           "description": "Configuration to be sent to language server over LSP when initialized: see the specific language server's documentation for more",
           "type": "object",
           "default": {}
+        },
+        "priority": {
+          "title": "Priority of the server",
+          "description": "When multiple servers match specific document/language, the server with higher priority will be used",
+          "type": "number",
+          "default": 50
         }
       }
     }

packages/jupyterlab-lsp/src/components/statusbar.tsx

@@ -35,7 +35,12 @@ import { LSPConnection } from '../connection';
 import { DocumentConnectionManager } from '../connection_manager';
 import { SERVER_EXTENSION_404 } from '../errors';
 import { LanguageServerManager } from '../manager';
-import { ILSPAdapterManager, ILanguageServerManager } from '../tokens';
+import {
+  ILSPAdapterManager,
+  ILanguageServerManager,
+  TSessionMap,
+  TLanguageServerId
+} from '../tokens';
 import { VirtualDocument, collect_documents } from '../virtual/document';
 
 import { codeCheckIcon, codeClockIcon, codeWarningIcon } from './icons';
@@ -464,34 +469,44 @@ export namespace LSPStatus {
       }, this);
     }
 
-    get available_servers(): Array<SCHEMA.LanguageServerSession> {
-      return Array.from(this.language_server_manager.sessions.values());
+    get available_servers(): TSessionMap {
+      return this.language_server_manager.sessions;
     }
 
     get supported_languages(): Set<string> {
       const languages = new Set<string>();
-      for (let server of this.available_servers) {
+      for (let server of this.available_servers.values()) {
         for (let language of server.spec.languages) {
           languages.add(language.toLocaleLowerCase());
         }
       }
       return languages;
     }
 
-    private is_server_running(server: SCHEMA.LanguageServerSession): boolean {
-      for (let language of server.spec.languages) {
-        if (this.detected_languages.has(language.toLocaleLowerCase())) {
+    private is_server_running(
+      id: TLanguageServerId,
+      server: SCHEMA.LanguageServerSession
+    ): boolean {
+      for (const language of this.detected_languages) {
+        const matchedServers = this.language_server_manager.getMatchingServers({
+          language
+        });
+        // TODO server.status === "started" ?
+        // TODO update once multiple servers are allowed
+        if (matchedServers[0] === id) {
           return true;
         }
       }
-      return false;
     }
 
     get documents_by_server(): Map<
       SCHEMA.LanguageServerSession,
       Map<string, VirtualDocument[]>
     > {
-      let data = new Map();
+      let data = new Map<
+        SCHEMA.LanguageServerSession,
+        Map<string, VirtualDocument[]>
+      >();
       if (!this.adapter?.virtual_editor) {
         return data;
       }
@@ -501,19 +516,17 @@ export namespace LSPStatus {
 
       for (let document of documents.values()) {
         let language = document.language.toLocaleLowerCase();
-        let servers = this.available_servers.filter(
-          server => server.spec.languages.indexOf(language) !== -1
+        let server_ids = this._connection_manager.language_server_manager.getMatchingServers(
+          { language: document.language }
         );
-        if (servers.length > 1) {
-          console.warn('More than one server per language for', language);
-        }
-        if (servers.length === 0) {
+        if (server_ids.length === 0) {
           continue;
         }
-        let server = servers[0];
+        // For now only use the server with the highest priority
+        let server = this.language_server_manager.sessions.get(server_ids[0]);
 
         if (!data.has(server)) {
-          data.set(server, new Map<string, VirtualDocument>());
+          data.set(server, new Map<string, VirtualDocument[]>());
         }
 
         let documents_map = data.get(server);
@@ -529,9 +542,9 @@ export namespace LSPStatus {
     }
 
     get servers_available_not_in_use(): Array<SCHEMA.LanguageServerSession> {
-      return this.available_servers.filter(
-        server => !this.is_server_running(server)
-      );
+      return [...this.available_servers.entries()]
+        .filter(([id, server]) => !this.is_server_running(id, server))
+        .map(([id, server]) => server);
     }
 
     get detected_languages(): Set<string> {
@@ -577,7 +590,7 @@ export namespace LSPStatus {
 
       detected_documents.forEach((document, uri) => {
         let connection = this._connection_manager.connections.get(uri);
-        let server_id = this._connection_manager.language_server_manager.getServerId(
+        let server_id = this._connection_manager.language_server_manager.getMatchingServers(
           { language: document.language }
         );
         if (server_id !== null) {

packages/jupyterlab-lsp/src/connection_manager.ts

@@ -1,13 +1,14 @@
 import { PageConfig, URLExt } from '@jupyterlab/coreutils';
 import { Signal } from '@lumino/signaling';
+import type * as protocol from 'vscode-languageserver-protocol';
 
 import type * as ConnectionModuleType from './connection';
 import {
   ILSPLogConsole,
-  ILanguageServerConfiguration,
   ILanguageServerManager,
   TLanguageServerConfigurations,
-  TLanguageServerId
+  TLanguageServerId,
+  TServerKeys
 } from './tokens';
 import { expandDottedPaths, sleep, until_ready } from './utils';
 import { IForeignContext, VirtualDocument } from './virtual/document';
@@ -134,9 +135,14 @@ export class DocumentConnectionManager {
       language
     );
 
-    const language_server_id = this.language_server_manager.getServerId({
+    const matchingServers = this.language_server_manager.getMatchingServers({
       language
     });
+    this.console.debug('Matching servers: ', matchingServers);
+
+    // for now use only the server with the highest priority.
+    const language_server_id =
+      matchingServers.length === 0 ? null : matchingServers[0];
 
     // lazily load 1) the underlying library (1.5mb) and/or 2) a live WebSocket-
     // like connection: either already connected or potentially in the process
@@ -161,13 +167,21 @@ export class DocumentConnectionManager {
    * "serverSettings" keyword in the setting registry. New keywords can
    * be added and extra functionality implemented here when needed.
    */
-  public updateServerConfigurations(allServerSettings: any) {
-    for (let language_server_id in allServerSettings) {
-      const parsedSettings = expandDottedPaths(
-        allServerSettings[language_server_id].serverSettings
-      );
+  public updateServerConfigurations(
+    allServerSettings: TLanguageServerConfigurations
+  ) {
+    let language_server_id: TServerKeys;
+    this.language_server_manager.setConfiguration(allServerSettings);
+
+    for (language_server_id in allServerSettings) {
+      if (!allServerSettings.hasOwnProperty(language_server_id)) {
+        continue;
+      }
+      const rawSettings = allServerSettings[language_server_id];
 
-      const serverSettings: ILanguageServerConfiguration = {
+      const parsedSettings = expandDottedPaths(rawSettings.serverSettings);
+
+      const serverSettings: protocol.DidChangeConfigurationParams = {
         settings: parsedSettings
       };
 
@@ -351,9 +365,14 @@ export namespace DocumentConnectionManager {
       ? rootUri
       : virtualDocumentsUri;
 
-    const language_server_id = Private.getLanguageServerManager().getServerId({
-      language
-    });
+    // for now take the best match only
+    const matchingServers = Private.getLanguageServerManager().getMatchingServers(
+      {
+        language
+      }
+    );
+    const language_server_id =
+      matchingServers.length === 0 ? null : matchingServers[0];
 
     if (language_server_id === null) {
       throw `No language server installed for language ${language}`;
@@ -441,7 +460,7 @@ namespace Private {
 
   export function updateServerConfiguration(
     language_server_id: TLanguageServerId,
-    settings: ILanguageServerConfiguration
+    settings: protocol.DidChangeConfigurationParams
   ): void {
     const connection = _connections.get(language_server_id);
     if (connection) {

packages/jupyterlab-lsp/src/editor_integration/testutils.ts

@@ -71,7 +71,7 @@ export interface ITestEnvironment {
 export class MockLanguageServerManager extends LanguageServerManager {
   async fetchSessions() {
     this._sessions = new Map();
-    this._sessions.set('pyls', {
+    this._sessions.set('pylsp', {
       spec: {
         languages: ['python']
       }
@@ -111,7 +111,9 @@ export class MockExtension implements ILSPExtension {
     this.app = null;
     this.feature_manager = new FeatureManager();
     this.editor_type_manager = new VirtualEditorManager();
-    this.language_server_manager = new MockLanguageServerManager({});
+    this.language_server_manager = new MockLanguageServerManager({
+      console: new BrowserConsole()
+    });
     this.connection_manager = new DocumentConnectionManager({
       language_server_manager: this.language_server_manager,
       console: new BrowserConsole()

packages/jupyterlab-lsp/src/index.ts

@@ -146,10 +146,12 @@ export class LSPExtension implements ILSPExtension {
     status_bar: IStatusBar | null
   ) {
     const trans = (translator || nullTranslator).load('jupyterlab-lsp');
-    this.language_server_manager = new LanguageServerManager({});
+    this.language_server_manager = new LanguageServerManager({
+      console: this.console.scope('LanguageServerManager')
+    });
     this.connection_manager = new DocumentConnectionManager({
       language_server_manager: this.language_server_manager,
-      console: this.console
+      console: this.console.scope('DocumentConnectionManager')
     });
 
     const statusButtonExtension = new StatusButtonExtension({

packages/jupyterlab-lsp/src/manager.ts

@@ -3,7 +3,13 @@ import { ServerConnection } from '@jupyterlab/services';
 import { Signal } from '@lumino/signaling';
 
 import * as SCHEMA from './_schema';
-import { ILanguageServerManager, TSessionMap } from './tokens';
+import {
+  ILanguageServerManager,
+  ILSPLogConsole,
+  TLanguageServerConfigurations,
+  TLanguageServerId,
+  TSessionMap
+} from './tokens';
 
 export class LanguageServerManager implements ILanguageServerManager {
   protected _sessionsChanged: Signal<ILanguageServerManager, void> = new Signal<
@@ -16,13 +22,17 @@ export class LanguageServerManager implements ILanguageServerManager {
   private _statusCode: number;
   private _retries: number;
   private _retriesInterval: number;
+  private _configuration: TLanguageServerConfigurations;
+  private console: ILSPLogConsole;
 
   constructor(options: ILanguageServerManager.IOptions) {
     this._settings = options.settings || ServerConnection.makeSettings();
     this._baseUrl = options.baseUrl || PageConfig.getBaseUrl();
     this._retries = options.retries || 2;
     this._retriesInterval = options.retriesInterval || 10000;
     this._statusCode = null;
+    this._configuration = {};
+    this.console = options.console;
     this.fetchSessions().catch(console.warn);
   }
 
@@ -38,16 +48,44 @@ export class LanguageServerManager implements ILanguageServerManager {
     return this._sessions;
   }
 
-  getServerId(options: ILanguageServerManager.IGetServerIdOptions) {
+  setConfiguration(configuration: TLanguageServerConfigurations): void {
+    this._configuration = configuration;
+  }
+
+  getMatchingServers(options: ILanguageServerManager.IGetServerIdOptions) {
+    const matchingSessionsKeys: TLanguageServerId[] = [];
+    const config = this._configuration;
+
     // most things speak language
+    // if language is not known, it is guessed based on MIME type earlier
+    // so some language should be available by now (which can be not obvious, e.g. "plain" for txt documents)
     for (const [key, session] of this._sessions.entries()) {
       if (options.language) {
-        if (session.spec.languages.indexOf(options.language) !== -1) {
-          return key;
+        if (
+          session.spec.languages.indexOf(
+            options.language.toLocaleLowerCase()
+          ) !== -1
+        ) {
+          matchingSessionsKeys.push(key);
         }
+      } else {
+        this.console.error(
+          'Cannot match server by language: language not available; ensure that kernel and specs provide language and MIME type'
+        );
       }
     }
-    return null;
+
+    return matchingSessionsKeys.sort((a, b) => {
+      const a_priority = config[a]?.priority ?? 50;
+      const b_priority = config[b]?.priority ?? 50;
+      if (a_priority == b_priority) {
+        this.console.warn(
+          `Two matching servers: ${a} and ${b} have the same priority; choose which one to use by changing the priority in Advanced Settings Editor`
+        );
+      }
+      // higher priority = higher in the list (descending order)
+      return b_priority - a_priority;
+    });
   }
 
   get statusCode(): number {
@@ -81,19 +119,21 @@ export class LanguageServerManager implements ILanguageServerManager {
       return;
     }
 
-    for (const key of Object.keys(sessions)) {
-      if (this._sessions.has(key)) {
-        Object.assign(this._sessions.get(key), sessions[key]);
+    for (let key of Object.keys(sessions)) {
+      let id: TLanguageServerId = key as TLanguageServerId;
+      if (this._sessions.has(id)) {
+        Object.assign(this._sessions.get(id), sessions[key]);
       } else {
-        this._sessions.set(key, sessions[key]);
+        this._sessions.set(id, sessions[key]);
       }
     }
 
     const oldKeys = this._sessions.keys();
 
     for (const oldKey in oldKeys) {
       if (!sessions[oldKey]) {
-        this._sessions.delete(oldKey);
+        let oldId = oldKey as TLanguageServerId;
+        this._sessions.delete(oldId);
       }
     }