fix: Adapt to api, make it so IConnectionProvider returns a MessageTransports

CGNonofr · CGNonofr · commit 5e48d2a26a23 · 2022-05-23T14:10:41.000+02:00
diff --git a/src/createLanguageClient.ts b/src/createLanguageClient.ts
@@ -1,37 +1,73 @@
-import { MessageSignature, MessageConnection } from '@codingame/monaco-jsonrpc'
+import { MessageReader, MessageWriter, Message, Event, DataCallback, Disposable, PartialMessageInfo } from 'vscode-jsonrpc'
 import { Uri } from 'monaco-editor'
 import {
-  MonacoLanguageClient,
-  createConnection, ConnectionErrorHandler, ConnectionCloseHandler, IConnection, Middleware, ErrorHandler, IConnectionProvider, InitializeParams, RegistrationRequest, RegistrationParams, UnregistrationRequest, UnregistrationParams, LanguageClientOptions
+  MonacoLanguageClient, Middleware, ErrorHandler, IConnectionProvider, InitializeParams, RegistrationRequest, RegistrationParams, UnregistrationRequest, UnregistrationParams, LanguageClientOptions, MessageTransports, InitializeRequest
 } from 'monaco-languageclient'
-import once from 'once'
 import { registerExtensionFeatures } from './extensions'
 import { LanguageClientId } from './languageClientOptions'
 import { Infrastructure } from './infrastructure'
 
-async function messageConnectionToConnection (messageConnection: MessageConnection, errorHandler: ConnectionErrorHandler, closeHandler: () => void): Promise<IConnection> {
-  const connection = createConnection(messageConnection, errorHandler, closeHandler)
+interface MessageMiddleware {
+  (message: Message): Message
+}
+
+class MiddlewareMessageWriter implements MessageWriter {
+  constructor (private delegate: MessageWriter, private middleware: MessageMiddleware) {}
+
+  onError: Event<[Error, Message | undefined, number | undefined]> = (cb) => {
+    return this.delegate.onError(cb)
+  }
+
+  onClose: Event<void> = (cb) => {
+    return this.delegate.onClose(cb)
+  }
+
+  dispose (): void {
+    this.delegate.dispose()
+  }
+
+  write (msg: Message): Promise<void> {
+    return this.delegate.write(this.middleware(msg))
+  }
+
+  end (): void {
+    return this.delegate.end()
+  }
+}
+class MiddlewareMessageReader implements MessageReader {
+  constructor (private delegate: MessageReader, private middleware: MessageMiddleware) {}
+
+  onError: Event<Error> = (cb) => {
+    return this.delegate.onError(cb)
+  }
+
+  onClose: Event<void> = (cb) => {
+    return this.delegate.onClose(cb)
+  }
+
+  onPartialMessage: Event<PartialMessageInfo> = (cb) => {
+    return this.delegate.onPartialMessage(cb)
+  }
 
+  listen (callback: DataCallback): Disposable {
+    return this.delegate.listen(message => {
+      callback(this.middleware(message))
+    })
+  }
+
+  dispose (): void {
+    this.delegate.dispose()
+  }
+}
+
+function hackTransports (transports: MessageTransports): MessageTransports {
   const existingRegistrations = new Set<string>()
-  const fixedConnection: IConnection = {
-    ...connection,
-    initialize: (params: InitializeParams) => {
-      // Hack to fix url converted from /toto/tata to \\toto\tata in windows
-      const rootPath = params.rootPath?.replace(/\\/g, '/')
-      const fixedParams: InitializeParams = {
-        ...params,
-        rootPath,
-        rootUri: rootPath != null ? Uri.from({ scheme: 'file', path: rootPath }).toString() : null
-      }
-      return connection.initialize(fixedParams)
-    },
-    onRequest (...args: Parameters<typeof connection.onRequest>) {
-      return connection.onRequest(args[0], (...params) => {
-        // Hack for https://github.com/OmniSharp/omnisharp-roslyn/issues/2119
-        const method = (args[0] as MessageSignature).method
-        if (method === RegistrationRequest.type.method) {
-          const registrationParams = params[0] as unknown as RegistrationParams
-          registrationParams.registrations = registrationParams.registrations.filter(registration => {
+  return {
+    reader: new MiddlewareMessageReader(transports.reader, message => {
+      if (Message.isRequest(message)) {
+        if (message.method === RegistrationRequest.type.method) {
+          const registrationParams = message.params as RegistrationParams
+          const filteredRegistrations = registrationParams.registrations.filter(registration => {
             const alreadyExisting = existingRegistrations.has(registration.id)
             if (alreadyExisting) {
               console.warn('Registration already existing', registration.id, registration.method)
@@ -41,64 +77,53 @@ async function messageConnectionToConnection (messageConnection: MessageConnecti
           registrationParams.registrations.forEach(registration => {
             existingRegistrations.add(registration.id)
           })
+          const fixedParams: RegistrationParams = {
+            ...registrationParams,
+            registrations: filteredRegistrations
+          }
+          return {
+            ...message,
+            params: fixedParams
+          }
         }
-        if (method === UnregistrationRequest.type.method) {
-          const unregistrationParams = params[0] as unknown as UnregistrationParams
+        if (message.method === UnregistrationRequest.type.method) {
+          const unregistrationParams = message.params as UnregistrationParams
           for (const unregistration of unregistrationParams.unregisterations) {
             existingRegistrations.delete(unregistration.id)
           }
         }
-        return args[1](...params)
-      })
-    },
-    dispose: () => {
-      try {
-        connection.dispose()
-      } catch (error) {
-        // The dispose should NEVER fail or the lsp client is not properly cleaned
-        // see https://github.com/microsoft/vscode-languageserver-node/blob/master/client/src/client.ts#L3105
-        console.warn('[LSP]', 'Error while disposing connection', error)
       }
-      // Hack, when the language client is removed, the connection is disposed but the closeHandler is not always properly called
-      // The language client is then still active but without a proper connection and errors will occurs
-      closeHandler()
-    },
-    shutdown: async () => {
-      // The shutdown should NEVER fail or the connection is not closed and the lsp client is not properly cleaned
-      // see https://github.com/microsoft/vscode-languageserver-node/blob/master/client/src/client.ts#L3103
-      try {
-        await connection.shutdown()
-      } catch (error) {
-        console.warn('[LSP]', 'Error while shutdown lsp', error)
+      return message
+    }),
+    writer: new MiddlewareMessageWriter(transports.writer, message => {
+      if (Message.isRequest(message) && message.method === InitializeRequest.type.method) {
+        const params = message.params as InitializeParams
+        // Hack to fix url converted from /toto/tata to \\toto\tata in windows
+        const rootPath = params.rootPath?.replace(/\\/g, '/')
+        const fixedParams: InitializeParams = {
+          ...params,
+          rootPath,
+          rootUri: rootPath != null ? Uri.from({ scheme: 'file', path: rootPath }).toString() : null
+        }
+        return {
+          ...message,
+          params: fixedParams
+        }
       }
-    }
+      return message
+    })
   }
-
-  return fixedConnection
 }
 
-const RETRY_DELAY = 3000
 class CGLSPConnectionProvider implements IConnectionProvider {
   constructor (
     private id: LanguageClientId,
     private infrastructure: Infrastructure
   ) {
   }
 
-  async get (errorHandler: ConnectionErrorHandler, closeHandler: ConnectionCloseHandler) {
-    const onceDelayedCloseHandler = once(() => {
-      setTimeout(() => {
-        closeHandler()
-      }, RETRY_DELAY)
-    })
-    try {
-      const connection = await this.infrastructure.openConnection(this.id)
-
-      return await messageConnectionToConnection(connection, errorHandler, onceDelayedCloseHandler)
-    } catch (err) {
-      onceDelayedCloseHandler()
-      throw err
-    }
+  async get () {
+    return hackTransports(await this.infrastructure.openConnection(this.id))
   }
 }
 
diff --git a/src/infrastructure.ts b/src/infrastructure.ts
@@ -1,6 +1,5 @@
-import { ConsoleLogger, createWebSocketConnection, toSocket } from '@codingame/monaco-jsonrpc'
-import { MessageConnection } from 'vscode-languageserver-protocol'
-import { TextDocument, TextDocumentSaveReason } from 'monaco-languageclient'
+import { IWebSocket, WebSocketMessageReader, WebSocketMessageWriter, toSocket } from '@codingame/monaco-jsonrpc'
+import { MessageTransports, TextDocument, TextDocumentSaveReason } from 'monaco-languageclient'
 import * as monaco from 'monaco-editor'
 import type * as vscode from 'vscode'
 import { getFile, updateFile } from './customRequests'
@@ -46,27 +45,25 @@ export interface Infrastructure {
    * Open a connection to the language server
    * @param id The language server id
    */
-  openConnection (id: LanguageClientId): Promise<MessageConnection>
+  openConnection (id: LanguageClientId): Promise<MessageTransports>
 }
 
-function openWebsocketConnection (url: URL | string): Promise<MessageConnection> {
-  return new Promise<MessageConnection>((resolve, reject) => {
-    const webSocket = new WebSocket(url)
+async function openWebsocketConnection (url: URL | string): Promise<MessageTransports> {
+  const webSocket = new WebSocket(url)
+  const socket: IWebSocket = toSocket(webSocket)
 
-    webSocket.onopen = () => {
-      const socket = toSocket(webSocket)
-      const webSocketConnection = createWebSocketConnection(socket, new ConsoleLogger())
-      webSocketConnection.onDispose(() => {
-        webSocket.close()
-      })
+  const reader = new WebSocketMessageReader(socket)
+  const writer = new WebSocketMessageWriter(socket)
 
-      resolve(webSocketConnection)
-    }
-
-    webSocket.onerror = () => {
-      reject(new Error('Unable to connect to server'))
-    }
+  await new Promise((resolve, reject) => {
+    webSocket.addEventListener('open', resolve)
+    webSocket.addEventListener('error', reject)
   })
+
+  return {
+    reader,
+    writer
+  }
 }
 
 export abstract class CodinGameInfrastructure implements Infrastructure {
@@ -120,7 +117,7 @@ export abstract class CodinGameInfrastructure implements Infrastructure {
    */
   protected abstract getSecurityToken(): Promise<string>
 
-  public async openConnection (id: LanguageClientId): Promise<MessageConnection> {
+  public async openConnection (id: LanguageClientId): Promise<MessageTransports> {
     const url = new URL(this.sessionId != null ? `run/${this.sessionId}/${id}` : `run/${id}`, this.serverAddress)
     this.libraryUrls?.forEach(libraryUrl => url.searchParams.append('libraryUrl', libraryUrl))
     url.searchParams.append('token', await this.getSecurityToken())
