Merge pull request #479 from krassowski/fix-connection-timeout-and-status

Increase connection timeout and improve status for initialization

Author: krassowski

CHANGELOG.md

@@ -15,12 +15,15 @@
   - improved status icon contrast when status item is active ([#465])
   - connection manager now properly keeps track of notebooks when multiple notebooks are open ([#474])
   - new cells added after kernel restart now work properly; kernel changes are handled correctly ([#478])
+  - increase total timeout for language server connection ([#479])
+  - fix status communication during initialization ([#479])
 
 [#449]: https://github.com/krassowski/jupyterlab-lsp/pull/449
 [#465]: https://github.com/krassowski/jupyterlab-lsp/pull/465
 [#474]: https://github.com/krassowski/jupyterlab-lsp/pull/474
 [#476]: https://github.com/krassowski/jupyterlab-lsp/pull/476
 [#478]: https://github.com/krassowski/jupyterlab-lsp/pull/478
+[#479]: https://github.com/krassowski/jupyterlab-lsp/pull/479
 [#480]: https://github.com/krassowski/jupyterlab-lsp/pull/480
 [#481]: https://github.com/krassowski/jupyterlab-lsp/pull/481
 

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

@@ -423,7 +423,7 @@ const shortMessageByStatus: StatusMap = {
   waiting: 'Waiting...',
   initialized: 'Fully initialized',
   initialized_but_some_missing: 'Initialized (additional servers needed)',
-  initializing: 'Partially initialized',
+  initializing: 'Initializing...',
   connecting: 'Connecting...'
 };
 
@@ -555,15 +555,23 @@ export namespace LSPStatus {
       let initialized_documents = new Set<VirtualDocument>();
       let absent_documents = new Set<VirtualDocument>();
       // detected documents with LSP servers available
-      let documents_with_servers = new Set<VirtualDocument>();
+      let documents_with_available_servers = new Set<VirtualDocument>();
+      // detected documents with LSP servers known
+      let documents_with_known_servers = new Set<VirtualDocument>();
 
       detected_documents.forEach((document, uri) => {
         let connection = this._connection_manager.connections.get(uri);
+        let server_id = this._connection_manager.language_server_manager.getServerId(
+          { language: document.language }
+        );
+        if (server_id !== null) {
+          documents_with_known_servers.add(document);
+        }
         if (!connection) {
           absent_documents.add(document);
           return;
         } else {
-          documents_with_servers.add(document);
+          documents_with_available_servers.add(document);
         }
 
         if (connection.isConnected) {
@@ -590,9 +598,14 @@ export namespace LSPStatus {
         status = 'waiting';
       } else if (initialized_documents.size === detected_documents.size) {
         status = 'initialized';
-      } else if (initialized_documents.size === documents_with_servers.size) {
+      } else if (
+        initialized_documents.size === documents_with_available_servers.size &&
+        detected_documents.size > documents_with_known_servers.size
+      ) {
         status = 'initialized_but_some_missing';
-      } else if (connected_documents.size === documents_with_servers.size) {
+      } else if (
+        connected_documents.size === documents_with_available_servers.size
+      ) {
         status = 'initializing';
       } else {
         status = 'connecting';

packages/jupyterlab-lsp/src/connection_manager.ts

@@ -283,18 +283,43 @@ export class DocumentConnectionManager {
     }
   }
 
-  async connect(options: ISocketConnectionOptions) {
+  async connect(
+    options: ISocketConnectionOptions,
+    firstTimeoutSeconds = 30,
+    secondTimeoutMinutes = 5
+  ) {
     this.console.log('connection requested', options);
     let connection = await this.connect_socket(options);
 
     let { virtual_document, document_path } = options;
 
     if (!connection.isReady) {
       try {
-        await until_ready(() => connection.isReady, 200, 200);
+        // user feedback hinted that 40 seconds was too short and some users are willing to wait more;
+        // to make the best of both worlds we first check frequently (6.6 times a second) for the first
+        // 30 seconds, and show the warning early in case if something is wrong; we then continue retrying
+        // for another 5 minutes, but only once per second.
+        await until_ready(
+          () => connection.isReady,
+          Math.round((firstTimeoutSeconds * 1000) / 150),
+          150
+        );
       } catch {
-        this.console.warn(`Connect timed out for ${virtual_document.uri}`);
-        return;
+        this.console.warn(
+          `LSP: Connection to ${virtual_document.uri} timed out after ${firstTimeoutSeconds} seconds, will continue retrying for another ${secondTimeoutMinutes} minutes`
+        );
+        try {
+          await until_ready(
+            () => connection.isReady,
+            60 * secondTimeoutMinutes,
+            1000
+          );
+        } catch {
+          this.console.warn(
+            `LSP: Connection to ${virtual_document.uri} timed out again after ${secondTimeoutMinutes} minutes, giving up`
+          );
+          return;
+        }
       }
     }