Add priority setting for servers handling the same language

CHANGELOG.md

@@ -1,8 +1,14 @@
 ## Changelog
 
-### (unreleased)
+### `@krassowski/jupyterlab-lsp 3.7.0` (unreleased)
 
-- Add ability to deactivate Kernel completions or LSP completion through the settings.
+- features:
+
+  - add ability to deactivate Kernel completions or LSP completion through the settings ([#586], thanks @Carreau)
+  - allow to set a priority for LSP server, allowing to choose which server to use when multiple servers are installed ([#588])
+
+[#586]: https://github.com/krassowski/jupyterlab-lsp/pull/586
+[#588]: https://github.com/krassowski/jupyterlab-lsp/pull/588
 
 ### `jupyter-lsp 1.2.0` (2021-04-26)
 

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.length && 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,10 +590,11 @@ 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_ids = this._connection_manager.language_server_manager.getMatchingServers(
           { language: document.language }
         );
-        if (server_id !== null) {
+
+        if (server_ids.length !== 0) {
           documents_with_known_servers.add(document);
         }
         if (!connection) {

packages/jupyterlab-lsp/src/connection.ts

@@ -12,13 +12,17 @@ import * as lsProtocol from 'vscode-languageserver-protocol';
 
 import { until_ready } from './utils';
 
-interface ILSPOptions extends ILspOptions {}
+interface ILSPOptions extends ILspOptions {
+  serverIdentifier?: string;
+}
 
 export class LSPConnection extends LspWsConnection {
   protected documentsToOpen: IDocumentInfo[];
+  public serverIdentifier: string;
 
   constructor(options: ILSPOptions) {
     super(options);
+    this.serverIdentifier = options?.serverIdentifier;
     this.documentsToOpen = [];
   }
 

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}`;
@@ -425,7 +444,8 @@ namespace Private {
       const connection = new LSPConnection({
         languageId: language,
         serverUri: uris.server,
-        rootUri: uris.base
+        rootUri: uris.base,
+        serverIdentifier: language_server_id
       });
       // TODO: remove remaining unbounded users of connection.on
       connection.setMaxListeners(999);
@@ -441,7 +461,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()
@@ -240,7 +242,8 @@ function FeatureSupport<TBase extends TestEnvironmentConstructor>(Base: TBase) {
       return new LSPConnection({
         languageId: this.document_options.language,
         serverUri: 'ws://localhost:8080',
-        rootUri: 'file:///unit-test'
+        rootUri: 'file:///unit-test',
+        serverIdentifier: 'pylsp'
       });
     }
 

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({