@theia/core 1.27.0-next.9 → 1.27.0

package/src/electron-main/messaging/electron-messaging-contribution.ts

@@ -16,24 +16,23 @@
 
 import { IpcMainEvent, ipcMain, WebContents } from '@theia/electron/shared/electron';
 import { inject, injectable, named, postConstruct } from 'inversify';
-import { MessageConnection } from 'vscode-ws-jsonrpc';
-import { createWebSocketConnection } from 'vscode-ws-jsonrpc/lib/socket/connection';
 import { ContributionProvider } from '../../common/contribution-provider';
-import { WebSocketChannel } from '../../common/messaging/web-socket-channel';
 import { MessagingContribution } from '../../node/messaging/messaging-contribution';
-import { ConsoleLogger } from '../../node/messaging/logger';
 import { ElectronConnectionHandler, THEIA_ELECTRON_IPC_CHANNEL_NAME } from '../../electron-common/messaging/electron-connection-handler';
 import { ElectronMainApplicationContribution } from '../electron-main-application';
 import { ElectronMessagingService } from './electron-messaging-service';
+import { Channel, ChannelCloseEvent, ChannelMultiplexer, MessageProvider } from '../../common/message-rpc/channel';
+import { Emitter, Event, WriteBuffer } from '../../common';
+import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '../../common/message-rpc/uint8-array-message-buffer';
 
 /**
  * This component replicates the role filled by `MessagingContribution` but for Electron.
  * Unlike the WebSocket based implementation, we do not expect to receive
  * connection events. Instead, we'll create channels based on incoming `open`
  * events on the `ipcMain` channel.
- *
  * This component allows communication between renderer process (frontend) and electron main process.
  */
+
 @injectable()
 export class ElectronMessagingContribution implements ElectronMainApplicationContribution, ElectronMessagingService {
 
@@ -43,89 +42,112 @@ export class ElectronMessagingContribution implements ElectronMainApplicationCon
     @inject(ContributionProvider) @named(ElectronConnectionHandler)
     protected readonly connectionHandlers: ContributionProvider<ElectronConnectionHandler>;
 
-    protected readonly channelHandlers = new MessagingContribution.ConnectionHandlers<WebSocketChannel>();
-    protected readonly windowChannels = new Map<number, Map<number, WebSocketChannel>>();
+    protected readonly channelHandlers = new MessagingContribution.ConnectionHandlers<Channel>();
+    /**
+     * Each electron window has a main chanel and its own multiplexer to route multiple client messages the same IPC connection.
+     */
+    protected readonly windowChannelMultiplexer = new Map<number, { channel: ElectronWebContentChannel, multiPlexer: ChannelMultiplexer }>();
 
     @postConstruct()
     protected init(): void {
-        ipcMain.on(THEIA_ELECTRON_IPC_CHANNEL_NAME, (event: IpcMainEvent, data: string) => {
-            this.handleIpcMessage(event, data);
+        ipcMain.on(THEIA_ELECTRON_IPC_CHANNEL_NAME, (event: IpcMainEvent, data: Uint8Array) => {
+            this.handleIpcEvent(event, data);
         });
     }
 
+    protected handleIpcEvent(event: IpcMainEvent, data: Uint8Array): void {
+        const sender = event.sender;
+        // Get the multiplexer for a given window id
+        try {
+            const windowChannelData = this.windowChannelMultiplexer.get(sender.id) ?? this.createWindowChannelData(sender);
+            windowChannelData!.channel.onMessageEmitter.fire(() => new Uint8ArrayReadBuffer(data));
+        } catch (error) {
+            console.error('IPC: Failed to handle message', { error, data });
+        }
+    }
+
+    // Creates a new multiplexer for a given sender/window
+    protected createWindowChannelData(sender: Electron.WebContents): { channel: ElectronWebContentChannel, multiPlexer: ChannelMultiplexer } {
+        const mainChannel = this.createWindowMainChannel(sender);
+        const multiPlexer = new ChannelMultiplexer(mainChannel);
+        multiPlexer.onDidOpenChannel(openEvent => {
+            const { channel, id } = openEvent;
+            if (this.channelHandlers.route(id, channel)) {
+                console.debug(`Opening channel for service path '${id}'.`);
+                channel.onClose(() => console.debug(`Closing channel on service path '${id}'.`));
+            }
+        });
+
+        sender.once('did-navigate', () => multiPlexer.onUnderlyingChannelClose({ reason: 'Window was refreshed' })); // When refreshing the browser window.
+        sender.once('destroyed', () => multiPlexer.onUnderlyingChannelClose({ reason: 'Window was closed' })); // When closing the browser window.
+        const data = { channel: mainChannel, multiPlexer };
+        this.windowChannelMultiplexer.set(sender.id, data);
+        return data;
+    }
+
+    /**
+     * Creates the main channel to a window.
+     * @param sender The window that the channel should be established to.
+     */
+    protected createWindowMainChannel(sender: WebContents): ElectronWebContentChannel {
+        return new ElectronWebContentChannel(sender);
+    }
+
     onStart(): void {
         for (const contribution of this.messagingContributions.getContributions()) {
             contribution.configure(this);
         }
         for (const connectionHandler of this.connectionHandlers.getContributions()) {
             this.channelHandlers.push(connectionHandler.path, (params, channel) => {
-                const connection = createWebSocketConnection(channel, new ConsoleLogger());
-                connectionHandler.onConnection(connection);
+                connectionHandler.onConnection(channel);
             });
         }
     }
 
-    listen(spec: string, callback: (params: ElectronMessagingService.PathParams, connection: MessageConnection) => void): void {
-        this.ipcChannel(spec, (params, channel) => {
-            const connection = createWebSocketConnection(channel, new ConsoleLogger());
-            callback(params, connection);
-        });
-    }
-
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ipcChannel(spec: string, callback: (params: any, channel: WebSocketChannel) => void): void {
+    ipcChannel(spec: string, callback: (params: any, channel: Channel) => void): void {
         this.channelHandlers.push(spec, callback);
     }
+}
+
+/**
+ * Used to establish a connection between the ipcMain and the Electron frontend (window).
+ * Messages a transferred via electron IPC.
+ */
+export class ElectronWebContentChannel implements Channel {
+    protected readonly onCloseEmitter: Emitter<ChannelCloseEvent> = new Emitter();
+    get onClose(): Event<ChannelCloseEvent> {
+        return this.onCloseEmitter.event;
+    }
 
-    protected handleIpcMessage(event: IpcMainEvent, data: string): void {
-        const sender = event.sender;
-        try {
-            // Get the channel map for a given window id
-            let channels = this.windowChannels.get(sender.id)!;
-            if (!channels) {
-                this.windowChannels.set(sender.id, channels = new Map<number, WebSocketChannel>());
-            }
-            // Start parsing the message to extract the channel id and route
-            const message: WebSocketChannel.Message = JSON.parse(data.toString());
-            // Someone wants to open a logical channel
-            if (message.kind === 'open') {
-                const { id, path } = message;
-                const channel = this.createChannel(id, sender);
-                if (this.channelHandlers.route(path, channel)) {
-                    channel.ready();
-                    channels.set(id, channel);
-                    channel.onClose(() => channels.delete(id));
-                } else {
-                    console.error('Cannot find a service for the path: ' + path);
-                }
-            } else {
-                const { id } = message;
-                const channel = channels.get(id);
-                if (channel) {
-                    channel.handleMessage(message);
-                } else {
-                    console.error('The ipc channel does not exist', id);
-                }
-            }
-            const close = () => {
-                for (const channel of Array.from(channels.values())) {
-                    channel.close(undefined, 'webContent destroyed');
-                }
-                channels.clear();
-            };
-            sender.once('did-navigate', close); // When refreshing the browser window.
-            sender.once('destroyed', close); // When closing the browser window.
-        } catch (error) {
-            console.error('IPC: Failed to handle message', { error, data });
-        }
+    // Make the message emitter public so that we can easily forward messages received from the ipcMain.
+    readonly onMessageEmitter: Emitter<MessageProvider> = new Emitter();
+    get onMessage(): Event<MessageProvider> {
+        return this.onMessageEmitter.event;
+    }
+
+    protected readonly onErrorEmitter: Emitter<unknown> = new Emitter();
+    get onError(): Event<unknown> {
+        return this.onErrorEmitter.event;
+    }
+
+    constructor(protected readonly sender: Electron.WebContents) {
     }
 
-    protected createChannel(id: number, sender: WebContents): WebSocketChannel {
-        return new WebSocketChannel(id, content => {
-            if (!sender.isDestroyed()) {
-                sender.send(THEIA_ELECTRON_IPC_CHANNEL_NAME, content);
+    getWriteBuffer(): WriteBuffer {
+        const writer = new Uint8ArrayWriteBuffer();
+
+        writer.onCommit(buffer => {
+            if (!this.sender.isDestroyed()) {
+                this.sender.send(THEIA_ELECTRON_IPC_CHANNEL_NAME, buffer);
             }
         });
-    }
 
+        return writer;
+    }
+    close(): void {
+        this.onCloseEmitter.dispose();
+        this.onMessageEmitter.dispose();
+        this.onErrorEmitter.dispose();
+    }
 }

package/src/electron-main/messaging/electron-messaging-service.ts

@@ -14,20 +14,14 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import type { MessageConnection } from 'vscode-jsonrpc';
-import type { WebSocketChannel } from '../../common/messaging/web-socket-channel';
+import { Channel } from '../../common/message-rpc/channel';
 
 export interface ElectronMessagingService {
-    /**
-     * Accept a JSON-RPC connection on the given path.
-     * A path supports the route syntax: https://github.com/rcs/route-parser#what-can-i-use-in-my-routes.
-     */
-    listen(path: string, callback: (params: ElectronMessagingService.PathParams, connection: MessageConnection) => void): void;
     /**
      * Accept an ipc channel on the given path.
      * A path supports the route syntax: https://github.com/rcs/route-parser#what-can-i-use-in-my-routes.
      */
-    ipcChannel(path: string, callback: (params: ElectronMessagingService.PathParams, socket: WebSocketChannel) => void): void;
+    ipcChannel(path: string, callback: (params: ElectronMessagingService.PathParams, socket: Channel) => void): void;
 }
 export namespace ElectronMessagingService {
     export interface PathParams {

package/src/node/messaging/binary-message-pipe.ts

@@ -0,0 +1,168 @@
+// *****************************************************************************
+// Copyright (C) 2022 STMicroelectronics and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { Duplex } from 'stream';
+import { Disposable, Emitter, Event } from '../../common';
+import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '../../common/message-rpc/uint8-array-message-buffer';
+
+/**
+ * A `BinaryMessagePipe` is capable of sending and retrieving binary messages i.e. {@link Uint8Array}s over
+ * and underlying streamed process pipe/fd. The message length of individual messages is encoding at the beginning of
+ * a new message. This makes it possible to extract messages from the streamed data.
+ */
+export class BinaryMessagePipe implements Disposable {
+    static readonly MESSAGE_START_IDENTIFIER = '<MessageStart>';
+    protected dataHandler = (chunk: Uint8Array) => this.handleChunk(chunk);
+
+    protected onMessageEmitter = new Emitter<Uint8Array>();
+    protected cachedMessageData: StreamedMessageData = {
+        chunks: [],
+        missingBytes: 0
+    };
+
+    get onMessage(): Event<Uint8Array> {
+        return this.onMessageEmitter.event;
+    }
+
+    constructor(protected readonly underlyingPipe: Duplex) {
+        underlyingPipe.on('data', this.dataHandler);
+    }
+
+    send(message: Uint8Array): void {
+        this.underlyingPipe.write(this.encodeMessageStart(message));
+        this.underlyingPipe.write(message);
+    }
+
+    protected handleChunk(chunk: Uint8Array): void {
+        if (this.cachedMessageData.missingBytes === 0) {
+            // There is no currently streamed message => We expect that the beginning of the chunk is the message start for a new message
+            this.handleNewMessage(chunk);
+        } else {
+            // The chunk contains message data intended for the currently cached message
+            this.handleMessageContentChunk(chunk);
+        }
+    }
+
+    protected handleNewMessage(chunk: Uint8Array): void {
+        if (chunk.byteLength < this.messageStartByteLength) {
+            // The chunk only contains a part of the encoded message start
+            this.cachedMessageData.partialMessageStart = chunk;
+            return;
+        }
+
+        const messageLength = this.readMessageStart(chunk);
+
+        if (chunk.length - this.messageStartByteLength > messageLength) {
+            // The initial chunk contains more than one binary message => Fire `onMessage` for first message and handle remaining content
+            const firstMessage = chunk.slice(this.messageStartByteLength, this.messageStartByteLength + messageLength);
+            this.onMessageEmitter.fire(firstMessage);
+            this.handleNewMessage(chunk.slice(this.messageStartByteLength + messageLength));
+
+        } else if (chunk.length - this.messageStartByteLength === messageLength) {
+            // The initial chunk contains exactly one complete message. => Directly fire the `onMessage` event.
+            this.onMessageEmitter.fire(chunk.slice(this.messageStartByteLength));
+        } else {
+            // The initial chunk contains only part of the message content => Cache message data
+            this.cachedMessageData.chunks = [chunk.slice(this.messageStartByteLength)];
+            this.cachedMessageData.missingBytes = messageLength - chunk.byteLength + this.messageStartByteLength;
+        }
+    }
+
+    protected handleMessageContentChunk(chunk: Uint8Array): void {
+        if (this.cachedMessageData) {
+            if (chunk.byteLength < this.cachedMessageData.missingBytes) {
+                // The chunk only contains parts of the missing bytes for the cached message.
+                this.cachedMessageData.chunks.push(chunk);
+                this.cachedMessageData.missingBytes -= chunk.byteLength;
+            } else if (chunk.byteLength === this.cachedMessageData.missingBytes) {
+                // Chunk contains exactly the missing data for the cached message
+                this.cachedMessageData.chunks.push(chunk);
+                this.emitCachedMessage();
+            } else {
+                // Chunk contains missing data for the cached message + data for the next message
+                const messageEnd = this.cachedMessageData.missingBytes;
+                const missingData = chunk.slice(0, messageEnd);
+                this.cachedMessageData.chunks.push(missingData);
+                this.emitCachedMessage();
+                this.handleNewMessage(chunk.slice(messageEnd));
+            }
+
+        }
+    }
+
+    protected emitCachedMessage(): void {
+        const message = Buffer.concat(this.cachedMessageData.chunks);
+        this.onMessageEmitter.fire(message);
+        this.cachedMessageData.chunks = [];
+        this.cachedMessageData.missingBytes = 0;
+    }
+
+    /**
+     * Encodes the start of a new message into a {@link Uint8Array}.
+     * The message start consists of a identifier string and the length of the following message.
+     * @returns the buffer contains the encoded message start
+     */
+    protected encodeMessageStart(message: Uint8Array): Uint8Array {
+        const writer = new Uint8ArrayWriteBuffer()
+            .writeString(BinaryMessagePipe.MESSAGE_START_IDENTIFIER)
+            .writeUint32(message.length);
+        const messageStart = writer.getCurrentContents();
+        writer.dispose();
+        return messageStart;
+    }
+
+    protected get messageStartByteLength(): number {
+        // 4 bytes for length of id + id string length + 4 bytes for length of message
+        return 4 + BinaryMessagePipe.MESSAGE_START_IDENTIFIER.length + 4;
+    }
+
+    /**
+     * Reads the start of a new message from a stream chunk (or cached message) received from the underlying pipe.
+     * The message start is expected to consist of an identifier string and the length of the message.
+     * @param chunk The stream chunk.
+     * @returns The length of the message content to read.
+     * @throws An error if the message start can not be read successfully.
+     */
+    protected readMessageStart(chunk: Uint8Array): number {
+        const messageData = this.cachedMessageData.partialMessageStart ? Buffer.concat([this.cachedMessageData.partialMessageStart, chunk]) : chunk;
+        this.cachedMessageData.partialMessageStart = undefined;
+
+        const reader = new Uint8ArrayReadBuffer(messageData);
+        const identifier = reader.readString();
+
+        if (identifier !== BinaryMessagePipe.MESSAGE_START_IDENTIFIER) {
+            throw new Error(`Could not read message start. The start identifier should be '${BinaryMessagePipe.MESSAGE_START_IDENTIFIER}' but was '${identifier}`);
+        }
+        const length = reader.readUint32();
+        return length;
+    }
+
+    dispose(): void {
+        this.underlyingPipe.removeListener('data', this.dataHandler);
+        this.underlyingPipe.end();
+        this.onMessageEmitter.dispose();
+        this.cachedMessageData = {
+            chunks: [],
+            missingBytes: 0
+        };
+    }
+}
+
+interface StreamedMessageData {
+    chunks: Uint8Array[];
+    missingBytes: number;
+    partialMessageStart?: Uint8Array;
+}

package/src/node/messaging/ipc-bootstrap.ts

@@ -16,20 +16,12 @@
 
 import 'reflect-metadata';
 import { dynamicRequire } from '../dynamic-require';
-import { ConsoleLogger } from 'vscode-ws-jsonrpc/lib/logger';
-import { createMessageConnection, IPCMessageReader, IPCMessageWriter, Trace } from 'vscode-ws-jsonrpc';
+import { IPCChannel } from './ipc-channel';
 import { checkParentAlive, IPCEntryPoint } from './ipc-protocol';
 
 checkParentAlive();
 
 const entryPoint = IPCEntryPoint.getScriptFromEnv();
-const reader = new IPCMessageReader(process);
-const writer = new IPCMessageWriter(process);
-const logger = new ConsoleLogger();
-const connection = createMessageConnection(reader, writer, logger);
-connection.trace(Trace.Off, {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    log: (message: any, data?: string) => console.log(message, data)
-});
 
-dynamicRequire<{ default: IPCEntryPoint }>(entryPoint).default(connection);
+dynamicRequire<{ default: IPCEntryPoint }>(entryPoint).default(new IPCChannel());
+

package/src/node/messaging/ipc-channel.ts

@@ -0,0 +1,97 @@
+// *****************************************************************************
+// Copyright (C) 2022 STMicroelectronics and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import * as cp from 'child_process';
+import { Socket } from 'net';
+import { Duplex } from 'stream';
+import { Channel, ChannelCloseEvent, Disposable, DisposableCollection, Emitter, Event, MessageProvider, WriteBuffer } from '../../common';
+import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '../../common/message-rpc/uint8-array-message-buffer';
+import { BinaryMessagePipe } from './binary-message-pipe';
+
+/**
+ * A {@link Channel} to send messages between two processes using a dedicated pipe/fd for binary messages.
+ * This fd is opened as 5th channel in addition to the default stdios (stdin, stdout, stderr, ipc). This means the default channels
+ * are not blocked and can be used by the respective process for additional custom message handling.
+ */
+export class IPCChannel implements Channel {
+
+    protected readonly onCloseEmitter: Emitter<ChannelCloseEvent> = new Emitter();
+    get onClose(): Event<ChannelCloseEvent> {
+        return this.onCloseEmitter.event;
+    }
+
+    protected readonly onMessageEmitter: Emitter<MessageProvider> = new Emitter();
+    get onMessage(): Event<MessageProvider> {
+        return this.onMessageEmitter.event;
+    }
+
+    protected readonly onErrorEmitter: Emitter<unknown> = new Emitter();
+    get onError(): Event<unknown> {
+        return this.onErrorEmitter.event;
+    }
+
+    protected messagePipe: BinaryMessagePipe;
+    protected toDispose = new DisposableCollection();
+
+    protected ipcErrorListener: (error: Error) => void = error => this.onErrorEmitter.fire(error);
+
+    constructor(childProcess?: cp.ChildProcess) {
+        if (childProcess) {
+            this.setupChildProcess(childProcess);
+        } else {
+            this.setupProcess();
+        }
+        this.messagePipe.onMessage(message => {
+            this.onMessageEmitter.fire(() => new Uint8ArrayReadBuffer(message));
+        });
+        this.toDispose.pushAll([this.onCloseEmitter, this.onMessageEmitter, this.onErrorEmitter]);
+    }
+
+    protected setupChildProcess(childProcess: cp.ChildProcess): void {
+        childProcess.once('exit', code => this.onCloseEmitter.fire({ reason: 'Child process has been terminated', code: code ?? undefined }));
+        this.messagePipe = new BinaryMessagePipe(childProcess.stdio[4] as Duplex);
+        childProcess.on('error', this.ipcErrorListener);
+        this.toDispose.push(Disposable.create(() => {
+            childProcess.removeListener('error', this.ipcErrorListener);
+            this.messagePipe.dispose();
+        }));
+    }
+
+    protected setupProcess(): void {
+        process.once('beforeExit', code => this.onCloseEmitter.fire({ reason: 'Process is about to be terminated', code }));
+        this.messagePipe = new BinaryMessagePipe(new Socket({ fd: 4 }));
+        process.on('uncaughtException', this.ipcErrorListener);
+        this.toDispose.push(Disposable.create(() => {
+            (process as NodeJS.EventEmitter).removeListener('uncaughtException', this.ipcErrorListener);
+            this.messagePipe.dispose();
+        }));
+    }
+
+    getWriteBuffer(): WriteBuffer {
+        const result = new Uint8ArrayWriteBuffer();
+        result.onCommit(buffer => {
+            this.messagePipe.send(buffer);
+        });
+
+        return result;
+    }
+
+    close(): void {
+        this.toDispose.dispose();
+    }
+
+}

package/src/node/messaging/ipc-connection-provider.ts

@@ -15,10 +15,11 @@
 // *****************************************************************************
 
 import * as cp from 'child_process';
+import { inject, injectable } from 'inversify';
 import * as path from 'path';
-import { injectable, inject } from 'inversify';
-import { Trace, Tracer, IPCMessageReader, IPCMessageWriter, createMessageConnection, MessageConnection, Message } from 'vscode-ws-jsonrpc';
-import { ILogger, ConnectionErrorHandler, DisposableCollection, Disposable } from '../../common';
+import { createInterface } from 'readline';
+import { Channel, ConnectionErrorHandler, Disposable, DisposableCollection, ILogger } from '../../common';
+import { IPCChannel } from './ipc-channel';
 import { createIpcEnv } from './ipc-protocol';
 
 export interface ResolvedIPCConnectionOptions {
@@ -40,7 +41,7 @@ export class IPCConnectionProvider {
     @inject(ILogger)
     protected readonly logger: ILogger;
 
-    listen(options: IPCConnectionOptions, acceptor: (connection: MessageConnection) => void): Disposable {
+    listen(options: IPCConnectionOptions, acceptor: (connection: Channel) => void): Disposable {
         return this.doListen({
             logger: this.logger,
             args: [],
@@ -48,19 +49,21 @@ export class IPCConnectionProvider {
         }, acceptor);
     }
 
-    protected doListen(options: ResolvedIPCConnectionOptions, acceptor: (connection: MessageConnection) => void): Disposable {
+    protected doListen(options: ResolvedIPCConnectionOptions, acceptor: (connection: Channel) => void): Disposable {
         const childProcess = this.fork(options);
-        const connection = this.createConnection(childProcess, options);
+        const channel = new IPCChannel(childProcess);
         const toStop = new DisposableCollection();
         const toCancelStop = toStop.push(Disposable.create(() => childProcess.kill()));
         const errorHandler = options.errorHandler;
         if (errorHandler) {
-            connection.onError((e: [Error, Message | undefined, number | undefined]) => {
-                if (errorHandler.shouldStop(e[0], e[1], e[2])) {
+            let errorCount = 0;
+            channel.onError((err: Error) => {
+                errorCount++;
+                if (errorHandler.shouldStop(err, errorCount)) {
                     toStop.dispose();
                 }
             });
-            connection.onClose(() => {
+            channel.onClose(() => {
                 if (toStop.disposed) {
                     return;
                 }
@@ -70,36 +73,15 @@ export class IPCConnectionProvider {
                 }
             });
         }
-        acceptor(connection);
+        acceptor(channel);
         return toStop;
     }
 
-    protected createConnection(childProcess: cp.ChildProcess, options: ResolvedIPCConnectionOptions): MessageConnection {
-        const reader = new IPCMessageReader(childProcess);
-        const writer = new IPCMessageWriter(childProcess);
-        const connection = createMessageConnection(reader, writer, {
-            error: (message: string) => this.logger.error(`[${options.serverName}: ${childProcess.pid}] ${message}`),
-            warn: (message: string) => this.logger.warn(`[${options.serverName}: ${childProcess.pid}] ${message}`),
-            info: (message: string) => this.logger.info(`[${options.serverName}: ${childProcess.pid}] ${message}`),
-            log: (message: string) => this.logger.info(`[${options.serverName}: ${childProcess.pid}] ${message}`)
-        });
-        const tracer: Tracer = {
-            log: (message: unknown, data?: string) => this.logger.debug(`[${options.serverName}: ${childProcess.pid}] ${message}` + (typeof data === 'string' ? ' ' + data : ''))
-        };
-        connection.trace(Trace.Verbose, tracer);
-        this.logger.isDebug().then(isDebug => {
-            if (!isDebug) {
-                connection.trace(Trace.Off, tracer);
-            }
-        });
-        return connection;
-    }
-
     protected fork(options: ResolvedIPCConnectionOptions): cp.ChildProcess {
         const forkOptions: cp.ForkOptions = {
-            silent: true,
             env: createIpcEnv(options),
-            execArgv: []
+            execArgv: [],
+            stdio: ['pipe', 'pipe', 'pipe', 'ipc', 'pipe']
         };
         const inspectArgPrefix = `--${options.serverName}-inspect`;
         const inspectArg = process.argv.find(v => v.startsWith(inspectArgPrefix));
@@ -108,8 +90,9 @@ export class IPCConnectionProvider {
         }
 
         const childProcess = cp.fork(path.join(__dirname, 'ipc-bootstrap'), options.args, forkOptions);
-        childProcess.stdout!.on('data', data => this.logger.info(`[${options.serverName}: ${childProcess.pid}] ${data.toString().trim()}`));
-        childProcess.stderr!.on('data', data => this.logger.error(`[${options.serverName}: ${childProcess.pid}] ${data.toString().trim()}`));
+
+        createInterface(childProcess.stdout!).on('line', line => this.logger.info(`[${options.serverName}: ${childProcess.pid}] ${line}`));
+        createInterface(childProcess.stderr!).on('line', line => this.logger.error(`[${options.serverName}: ${childProcess.pid}] ${line}`));
 
         this.logger.debug(`[${options.serverName}: ${childProcess.pid}] IPC started`);
         childProcess.once('exit', () => this.logger.debug(`[${options.serverName}: ${childProcess.pid}] IPC exited`));

package/src/node/messaging/ipc-protocol.ts

@@ -15,14 +15,14 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { MessageConnection } from 'vscode-ws-jsonrpc';
+import { Channel } from '../../common/message-rpc/channel';
 
 const THEIA_PARENT_PID = 'THEIA_PARENT_PID';
 const THEIA_ENTRY_POINT = 'THEIA_ENTRY_POINT';
 
 export const ipcEntryPoint: string | undefined = process.env[THEIA_ENTRY_POINT];
 
-export type IPCEntryPoint = (connection: MessageConnection) => void;
+export type IPCEntryPoint = (connection: Channel) => void;
 export namespace IPCEntryPoint {
     /**
      * Throws if `THEIA_ENTRY_POINT` is undefined or empty.