Merge pull request #25 from CodinGame/coderpad-fixes

Fixes for coderpad

Author: CGNonofr

src/index.ts

@@ -6,7 +6,7 @@ import { WillShutdownParams } from './customRequests'
 import { loadExtensionConfigurations } from './extensionConfiguration'
 import './hacks'
 import { createLanguageClientManager, LanguageClientManager, StatusChangeEvent } from './languageClient'
-import { LanguageClientId, registerLanguageClient } from './languageClientOptions'
+import { LanguageClientId, LanguageClientOptions, registerLanguageClient } from './languageClientOptions'
 import { StaticLanguageClientId } from './staticOptions'
 
 export {
@@ -25,5 +25,6 @@ export type {
   Infrastructure,
   WorkspaceFolder,
   TextDocument,
-  TextDocumentSaveReason
+  TextDocumentSaveReason,
+  LanguageClientOptions
 }

src/infrastructure.ts

@@ -5,7 +5,7 @@ import * as monaco from 'monaco-editor'
 import type * as vscode from 'vscode'
 import { getFile, updateFile } from './customRequests'
 import { LanguageClientManager } from './languageClient'
-import { LanguageClientId } from './languageClientOptions'
+import { LanguageClientId, LanguageClientOptions } from './languageClientOptions'
 
 export interface Infrastructure {
   /**
@@ -22,10 +22,11 @@ export interface Infrastructure {
    * Workspace folders
    */
   workspaceFolders?: typeof vscode.workspace.workspaceFolders
+
   /**
-   * The language server proxy is used, so we only need to load configurations for language servers which are not mutualized
+   * Does a mutualization proxy will be used, it means we don't need to load configurations for this server
    */
-  useMutualizedProxy: boolean
+  useMutualizedProxy (languageClientId: LanguageClientId, options: LanguageClientOptions): boolean
 
   /**
    * Save a file on the filesystem
@@ -35,11 +36,11 @@ export interface Infrastructure {
    */
   saveFileContent? (document: TextDocument, reason: TextDocumentSaveReason, languageClient: LanguageClientManager): Promise<void>
   /**
-   * Get a text file content
+   * Get a text file content as a model
    * @param resource the Uri of the file
    * @param languageClient The languageclient we're trying to get the file from
    */
-  getFileContent (resource: monaco.Uri, languageClient: LanguageClientManager): Promise<string | null>
+  getFileContent (resource: monaco.Uri, languageClient: LanguageClientManager): Promise<monaco.editor.ITextModel | null>
 
   /**
    * Open a connection to the language server
@@ -74,7 +75,7 @@ export abstract class CodinGameInfrastructure implements Infrastructure {
      * The domain of the server
      */
     public serverAddress: string,
-    public useMutualizedProxy: boolean,
+    private _useMutualizedProxy: boolean,
     /**
      * An optional sessionId when connecting to the session-mutualized server
      */
@@ -86,6 +87,10 @@ export abstract class CodinGameInfrastructure implements Infrastructure {
   ) {
   }
 
+  useMutualizedProxy (languageClientId: LanguageClientId, options: LanguageClientOptions): boolean {
+    return this._useMutualizedProxy && options.mutualizable
+  }
+
   public readonly automaticTextDocumentUpdate = false
   public readonly rootUri = 'file:///tmp/project'
   public readonly workspaceFolders: typeof vscode.workspace.workspaceFolders = [{
@@ -100,9 +105,10 @@ export abstract class CodinGameInfrastructure implements Infrastructure {
     }
   }
 
-  public async getFileContent (resource: monaco.Uri, languageClient: LanguageClientManager): Promise<string | null> {
+  public async getFileContent (resource: monaco.Uri, languageClient: LanguageClientManager): Promise<monaco.editor.ITextModel | null> {
     try {
-      return (await getFile(resource.toString(true), languageClient)).text
+      const content = (await getFile(resource.toString(true), languageClient)).text
+      return monaco.editor.createModel(content, undefined, resource)
     } catch (error) {
       console.error('File not found', resource.toString())
       return null

src/languageClient.ts

@@ -1,6 +1,6 @@
 import * as monaco from 'monaco-editor'
 import {
-  CloseAction, ErrorAction, MonacoLanguageClient, Emitter, Event, TextDocument, Services, State, DisposableCollection, CancellationToken, RequestType, NotificationType, Disposable
+  CloseAction, ErrorAction, MonacoLanguageClient, Emitter, Event, TextDocument, Services, State, DisposableCollection, CancellationToken, RequestType, NotificationType, Disposable, LogMessageNotification
 } from 'monaco-languageclient'
 import delay from 'delay'
 import { Uri } from 'monaco-editor'
@@ -32,12 +32,14 @@ export class LanguageClientManager implements LanguageClient {
   protected readonly onWillCloseEmitter = new Emitter<void>()
   protected readonly onWillShutdownEmitter = new Emitter<WillShutdownParams>()
   protected currentStatus: Status = 'connecting'
+  private useMutualizedProxy: boolean
 
   constructor (
     private id: LanguageClientId,
     private languageServerOptions: LanguageClientOptions,
     private infrastructure: Infrastructure
   ) {
+    this.useMutualizedProxy = this.infrastructure.useMutualizedProxy(this.id, this.languageServerOptions)
   }
 
   private updateStatus (status: Status) {
@@ -109,7 +111,7 @@ export class LanguageClientManager implements LanguageClient {
 
   public async start (): Promise<void> {
     try {
-      await loadExtensionConfigurations([this.id], this.infrastructure.useMutualizedProxy)
+      await loadExtensionConfigurations([this.id], this.useMutualizedProxy)
     } catch (error) {
       console.error('Unable to load extension configuration', error)
     }
@@ -201,11 +203,26 @@ export class LanguageClientManager implements LanguageClient {
           this.updateStatus('connecting')
           readyPromise = languageClient.onReady().then(async () => {
             const disposableCollection = new DisposableCollection()
-            await Promise.race([
-              new Promise<void>(resolve => {
+
+            let readyPromise: Promise<void>
+            const { maxInitializeDuration, readinessMessageMatcher } = this.languageServerOptions
+            if (readinessMessageMatcher != null && !this.useMutualizedProxy) {
+              readyPromise = new Promise<void>(resolve => {
+                disposableCollection.push(languageClient.onNotification(LogMessageNotification.type, logMessage => {
+                  if (readinessMessageMatcher.exec(logMessage.message) != null) {
+                    resolve()
+                  }
+                }))
+              })
+            } else {
+              readyPromise = new Promise<void>(resolve => {
                 disposableCollection.push(onServerResponse.event(resolve))
-              }),
-              delay(15000)
+              })
+            }
+
+            await Promise.race([
+              readyPromise,
+              delay(maxInitializeDuration ?? 15_000)
             ])
             disposableCollection.dispose()
           }, error => {
@@ -268,7 +285,7 @@ function createLanguageClientManager (
     throw new Error(`Unknown ${id} language server`)
   }
 
-  if (infrastructure.useMutualizedProxy && languageServerOptions.mutualizable) {
+  if (infrastructure.useMutualizedProxy(id, languageServerOptions) && languageServerOptions.mutualizable) {
     // When using the mutualized proxy, we don't need to synchronize the configuration nor send the initialization options
     languageServerOptions = {
       ...languageServerOptions,
@@ -289,8 +306,7 @@ function createLanguageClientManager (
 
   disposableCollection.push(registerTextModelContentProvider('file', {
     async provideTextContent (resource: Uri): Promise<monaco.editor.ITextModel | null> {
-      const content = await infrastructure.getFileContent(resource, languageClientManager)
-      return content != null ? monaco.editor.createModel(content, undefined, resource) : null
+      return await infrastructure.getFileContent(resource, languageClientManager)
     }
   }))
   disposableCollection.push(getServices().workspace.registerSaveDocumentHandler({

src/languageClientOptions.ts

@@ -3,7 +3,20 @@ import staticOptions, { StaticLanguageClientId } from './staticOptions'
 
 export type LanguageClientOptions = Pick<MonacoLanguageClientOptions, 'documentSelector' | 'synchronize' | 'initializationOptions' | 'middleware'> & {
   vscodeExtensionIds?: string[]
+  /**
+   * Is this language server mutualizable by the CodinGame mutualized proxy
+   */
   mutualizable: boolean
+  /**
+   * Maximum initialization duration. After this delay, the language server will be considered ready no matter what
+   * default: 15_000
+   */
+  maxInitializeDuration?: number
+
+  /**
+   * The language server will only be considered ready after this log message was received
+   */
+  readinessMessageMatcher?: RegExp
 }
 
 const dynamicOptions: Partial<Record<string, LanguageClientOptions>> = {}

src/staticOptions.ts

@@ -134,7 +134,8 @@ const staticOptions = asLanguageClientOptionsById({
     synchronize: {
       configurationSection: 'kotlin'
     },
-    mutualizable: false
+    mutualizable: false,
+    maxInitializeDuration: 60_000
   },
   lua: {
     documentSelector: [
@@ -272,7 +273,9 @@ const staticOptions = asLanguageClientOptionsById({
       configurationSection: 'metals'
     },
     mutualizable: false,
-    vscodeExtensionIds: ['scalameta']
+    vscodeExtensionIds: ['scalameta'],
+    maxInitializeDuration: 60_000,
+    readinessMessageMatcher: /compiled scala-project in/
   },
   sql: {
     documentSelector: [

src/tests/tools.ts

@@ -6,8 +6,9 @@ import {
   _Connection,
   _
 } from 'vscode-languageserver/lib/common/api'
+import { monaco } from '@codingame/monaco-editor-wrapper'
 import { getFile, updateFile } from '../customRequests'
-import { Infrastructure, LanguageClientManager, TextDocument, TextDocumentSaveReason } from '../'
+import { Infrastructure, LanguageClientId, LanguageClientManager, LanguageClientOptions, TextDocument, TextDocumentSaveReason } from '../'
 
 class PipedMessageReader extends AbstractMessageReader {
   private callback: DataCallback | undefined
@@ -120,9 +121,13 @@ export class TestInfrastructure implements Infrastructure {
 
   constructor (
     public automaticTextDocumentUpdate: boolean,
-    public useMutualizedProxy: boolean
+    public _useMutualizedProxy: boolean
   ) {}
 
+  useMutualizedProxy (languageClientId: LanguageClientId, options: LanguageClientOptions): boolean {
+    return this._useMutualizedProxy && options.mutualizable
+  }
+
   rootUri = 'file:///tmp/project'
   workspaceFolders = []
 
@@ -131,9 +136,10 @@ export class TestInfrastructure implements Infrastructure {
   }
 
   // use same method as CodinGameInfrastructure to be able to simply catch it
-  async getFileContent (resource: Uri, languageClient: LanguageClientManager): Promise<string | null> {
+  async getFileContent (resource: Uri, languageClient: LanguageClientManager): Promise<monaco.editor.ITextModel | null> {
     try {
-      return (await getFile(resource.toString(true), languageClient)).text
+      const content = (await getFile(resource.toString(true), languageClient)).text
+      return monaco.editor.createModel(content, undefined, resource)
     } catch (error) {
       console.error('File not found', resource.toString())
       return null