@theia/core 1.71.0-next.8 → 1.71.0

package/src/common/message-rpc/channel.spec.ts

@@ -18,6 +18,7 @@ import { assert, expect, spy, use } from 'chai';
 import * as spies from 'chai-spies';
 import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from './uint8-array-message-buffer';
 import { ChannelMultiplexer, ForwardingChannel, MessageProvider } from './channel';
+import { RpcProtocol } from './rpc-protocol';
 
 use(spies);
 
@@ -84,5 +85,120 @@ describe('Message Channel', () => {
 
             expect(openChannelSpy).to.be.called.exactly(4);
         });
+
+        it('should reject pending open() promises when underlying channel closes', async () => {
+            const pipe = new ChannelPipe();
+            const leftMultiplexer = new ChannelMultiplexer(pipe.left);
+            // Don't create a right multiplexer, so no AckOpen will arrive
+
+            const openPromise = leftMultiplexer.open('test');
+
+            // Close the underlying channel
+            pipe.left.onCloseEmitter.fire({ reason: 'test close' });
+
+            // The open promise should reject, not hang forever
+            try {
+                await openPromise;
+                assert.fail('Expected open() promise to be rejected');
+            } catch (err) {
+                expect(err).to.be.instanceOf(Error);
+                expect((err as Error).message).to.contain('test close');
+            }
+        });
+
+        it('should fire onClose on sub-channels when underlying channel closes', async () => {
+            const pipe = new ChannelPipe();
+            const leftMultiplexer = new ChannelMultiplexer(pipe.left);
+            const rightMultiplexer = new ChannelMultiplexer(pipe.right);
+
+            const leftChannel = await leftMultiplexer.open('test');
+            const rightChannel = rightMultiplexer.getOpenChannel('test');
+            assert.isDefined(rightChannel);
+
+            const leftCloseSpy = spy(() => { });
+            leftChannel.onClose(leftCloseSpy);
+
+            // Close the underlying channel from the remote side
+            pipe.left.onCloseEmitter.fire({ reason: 'underlying closed' });
+
+            expect(leftCloseSpy).to.have.been.called();
+        });
+    });
+
+    describe('Channel close event ordering', () => {
+        it('should not deliver onClose after close() has been called', () => {
+            const channel = new ForwardingChannel('test', () => { }, () => new Uint8ArrayWriteBuffer());
+
+            const closeSpy = spy(() => { });
+            channel.onClose(closeSpy);
+
+            // Bug pattern: close() first (disposes emitters), then fire (no-op)
+            channel.close();
+            channel.onCloseEmitter.fire({ reason: 'too late' });
+
+            // The listener should not be called because close() already disposed the emitter
+            expect(closeSpy).to.not.have.been.called();
+        });
+
+        it('should deliver onClose when fired before close()', () => {
+            const channel = new ForwardingChannel('test', () => { }, () => new Uint8ArrayWriteBuffer());
+
+            const closeSpy = spy(() => { });
+            channel.onClose(closeSpy);
+
+            // Correct pattern: fire first, then close
+            channel.onCloseEmitter.fire({ reason: 'proper close' });
+            channel.close();
+
+            expect(closeSpy).to.have.been.called();
+        });
+    });
+
+    describe('RPC protocol with write buffer overflow', () => {
+        it('should reject the promise when commit fails due to buffer overflow', async () => {
+            // Simulate a channel whose write buffer throws on commit (e.g. SocketWriteBuffer overflow)
+            const channel = new ForwardingChannel('test', () => { }, () => {
+                const buffer = new Uint8ArrayWriteBuffer();
+                buffer.onCommit(() => {
+                    throw new Error('Max disconnected buffer size exceeded');
+                });
+                return buffer;
+            });
+
+            const protocol = new RpcProtocol(channel, undefined, { mode: 'clientOnly' });
+
+            // sendRequest should return a rejected promise, not throw synchronously
+            const promise = protocol.sendRequest('testMethod', []);
+
+            try {
+                await promise;
+                assert.fail('Expected promise to be rejected');
+            } catch (err) {
+                expect(err).to.be.instanceOf(Error);
+                expect((err as Error).message).to.contain('buffer size exceeded');
+            }
+        });
+
+        it('should not leak pending requests when commit fails', async () => {
+            const channel = new ForwardingChannel('test', () => { }, () => {
+                const buffer = new Uint8ArrayWriteBuffer();
+                buffer.onCommit(() => {
+                    throw new Error('Max disconnected buffer size exceeded');
+                });
+                return buffer;
+            });
+
+            const protocol = new RpcProtocol(channel, undefined, { mode: 'clientOnly' });
+
+            // sendRequest should return a rejected promise and clean up pendingRequests
+            try {
+                await protocol.sendRequest('testMethod', []);
+            } catch {
+                // expected: the promise is rejected due to buffer overflow
+            }
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            expect((protocol as any).pendingRequests.size).to.equal(0);
+        });
     });
 });

package/src/common/message-rpc/channel.ts

@@ -14,6 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { injectable } from 'inversify';
 import { Disposable, DisposableCollection } from '../disposable';
 import { Emitter, Event } from '../event';
 import { ReadBuffer, WriteBuffer } from './message-buffer';
@@ -71,6 +72,7 @@ export type MessageProvider = () => ReadBuffer;
  *  Reusable abstract {@link Channel} implementation that sets up
  *  the basic channel event listeners and offers a generic close method.
  */
+@injectable()
 export abstract class AbstractChannel implements Channel {
 
     onCloseEmitter: Emitter<ChannelCloseEvent> = new Emitter();
@@ -152,7 +154,7 @@ export enum MessageTypes {
  * messages and always in one go.
  */
 export class ChannelMultiplexer implements Disposable {
-    protected pendingOpen: Map<string, (channel: ForwardingChannel) => void> = new Map();
+    private pendingOpen: Map<string, { resolve: (channel: ForwardingChannel) => void, reject: (err: Error) => void }> = new Map();
     protected openChannels: Map<string, ForwardingChannel> = new Map();
 
     protected readonly onOpenChannelEmitter = new Emitter<{ id: string, channel: Channel }>();
@@ -180,9 +182,11 @@ export class ChannelMultiplexer implements Disposable {
     onUnderlyingChannelClose(event?: ChannelCloseEvent): void {
         if (!this.toDispose.disposed) {
             this.toDispose.push(Disposable.create(() => {
+                const reason = event?.reason ?? 'Multiplexer main channel has been closed from the remote side!';
+                this.pendingOpen.forEach(pending => pending.reject(new Error(reason)));
                 this.pendingOpen.clear();
                 this.openChannels.forEach(channel => {
-                    channel.onCloseEmitter.fire(event ?? { reason: 'Multiplexer main channel has been closed from the remote side!' });
+                    channel.onCloseEmitter.fire(event ?? { reason });
                 });
 
                 this.openChannels.clear();
@@ -212,13 +216,13 @@ export class ChannelMultiplexer implements Disposable {
     }
 
     protected handleAckOpen(id: string): void {
-        // edge case: both side try to open a channel at the same time.
-        const resolve = this.pendingOpen.get(id);
-        if (resolve) {
+        // edge case: both sides try to open a channel at the same time.
+        const pending = this.pendingOpen.get(id);
+        if (pending) {
             const channel = this.createChannel(id);
             this.pendingOpen.delete(id);
             this.openChannels.set(id, channel);
-            resolve(channel);
+            pending.resolve(channel);
             this.onOpenChannelEmitter.fire({ id, channel });
         } else {
             console.error(`not expecting ack-open on for ${id}`);
@@ -229,10 +233,10 @@ export class ChannelMultiplexer implements Disposable {
         if (!this.openChannels.has(id)) {
             const channel = this.createChannel(id);
             this.openChannels.set(id, channel);
-            const resolve = this.pendingOpen.get(id);
-            if (resolve) {
-                // edge case: both side try to open a channel at the same time.
-                resolve(channel);
+            const pending = this.pendingOpen.get(id);
+            if (pending) {
+                // edge case: both sides try to open a channel at the same time.
+                pending.resolve(channel);
             }
             this.underlyingChannel.getWriteBuffer().writeUint8(MessageTypes.AckOpen).writeString(id).commit();
             this.onOpenChannelEmitter.fire({ id, channel });
@@ -283,7 +287,7 @@ export class ChannelMultiplexer implements Disposable {
             throw new Error(`Another channel with the id '${id}' is already open.`);
         }
         const result = new Promise<Channel>((resolve, reject) => {
-            this.pendingOpen.set(id, resolve);
+            this.pendingOpen.set(id, { resolve, reject });
         });
         this.underlyingChannel.getWriteBuffer().writeUint8(MessageTypes.Open).writeString(id).commit();
         return result;

package/src/common/message-rpc/rpc-protocol.ts

@@ -178,9 +178,18 @@ export class RpcProtocol {
         const disposableWrapper = new DisposableWrapper();
         this.pendingRequestCancellationEventListeners.set(id, disposableWrapper);
 
-        const output = this.channel.getWriteBuffer();
-        this.encoder.request(output, id, method, args);
-        output.commit();
+        try {
+            const output = this.channel.getWriteBuffer();
+            this.encoder.request(output, id, method, args);
+            output.commit();
+        } catch (err) {
+            // The message could not be sent (e.g. write buffer overflow).
+            // Clean up the pending request and reject the promise.
+            this.pendingRequests.delete(id);
+            this.disposeCancellationEventListener(id);
+            reply.reject(err);
+            return reply.promise;
+        }
 
         if (cancellationToken?.isCancellationRequested) {
             this.sendCancel(id);

package/src/common/message-rpc/uint8-array-message-buffer.ts

@@ -113,7 +113,7 @@ export class Uint8ArrayWriteBuffer implements WriteBuffer, Disposable {
         return this;
     }
 
-    private onCommitEmitter = new Emitter<Uint8Array>();
+    private onCommitEmitter = new Emitter<Uint8Array>({ errorHandling: 'propagate' });
     get onCommit(): Event<Uint8Array> {
         return this.onCommitEmitter.event;
     }

package/src/common/messaging/index.ts

@@ -17,3 +17,4 @@
 export * from './handler';
 export * from './proxy-factory';
 export * from './connection-error-handler';
+export * from './socket-write-buffer';

package/src/common/messaging/socket-write-buffer.ts

@@ -14,13 +14,19 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { injectable } from 'inversify';
 import { WebSocket } from './web-socket-channel';
 
+@injectable()
 export class SocketWriteBuffer {
-    private static DISCONNECTED_BUFFER_SIZE = 100 * 1024;
+    private static readonly DEFAULT_DISCONNECTED_BUFFER_SIZE = 100 * 1024;
 
-    private disconnectedBuffer: Uint8Array | undefined;
-    private bufferWritePosition = 0;
+    protected disconnectedBuffer: Uint8Array | undefined;
+    protected bufferWritePosition = 0;
+
+    protected get maxBufferSize(): number {
+        return SocketWriteBuffer.DEFAULT_DISCONNECTED_BUFFER_SIZE;
+    }
 
     buffer(data: Uint8Array): void {
         this.ensureWriteBuffer(data.byteLength);
@@ -30,7 +36,7 @@ export class SocketWriteBuffer {
 
     protected ensureWriteBuffer(byteLength: number): void {
         if (!this.disconnectedBuffer) {
-            this.disconnectedBuffer = new Uint8Array(SocketWriteBuffer.DISCONNECTED_BUFFER_SIZE);
+            this.disconnectedBuffer = new Uint8Array(this.maxBufferSize);
             this.bufferWritePosition = 0;
         }
 

package/src/common/performance/index.ts

@@ -16,4 +16,5 @@
 
 export * from './measurement';
 export * from './stopwatch';
+export * from './simple-stopwatch';
 export * from './measurement-protocol';

package/src/common/performance/simple-stopwatch.ts

@@ -0,0 +1,91 @@
+// *****************************************************************************
+// Copyright (C) 2026 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { LogLevel } from '../logger';
+import { Measurement, MeasurementOptions } from './measurement';
+import { Stopwatch } from './stopwatch';
+
+/**
+ * A simple {@link Stopwatch} that uses a caller-supplied time function and logs
+ * via `console`. Usable without Inversify DI: this class does not assign nor
+ * use the inherited `logger` field.
+ */
+export class SimpleStopwatch extends Stopwatch {
+
+    constructor(owner: string, now: () => number) {
+        super({ owner, now });
+    }
+
+    start(name: string, options?: MeasurementOptions): Measurement {
+        const now = this.defaultLogOptions.now;
+        const startTime = now();
+
+        return this.createMeasurement(name, () => ({
+            startTime,
+            duration: now() - startTime
+        }), options);
+    }
+
+    protected override log(measurement: Measurement, activity: string, options: {
+        now: () => number;
+        owner?: string;
+        context?: string;
+        arguments?: any[];
+    } & MeasurementOptions): void {
+        const elapsed = measurement.stop();
+        const level = this.logLevel(elapsed, options);
+
+        if (Number.isNaN(elapsed)) {
+            switch (level) {
+                case LogLevel.ERROR:
+                case LogLevel.FATAL:
+                    break;
+                default:
+                    return;
+            }
+        }
+
+        const origin = options.owner ?? 'application';
+        const timeFromStart = `${(options.now() / 1000).toFixed(3)} s since ${origin} start`;
+        const whatWasMeasured = options.context ? `[${options.context}] ${activity}` : activity;
+        const message = `${whatWasMeasured}: ${elapsed.toFixed(1)} ms [${timeFromStart}]`;
+        const args = options.arguments ?? [];
+
+        switch (level) {
+            case LogLevel.FATAL:
+            case LogLevel.ERROR:
+                console.error(message, ...args);
+                break;
+            case LogLevel.WARN:
+                console.warn(message, ...args);
+                break;
+            case LogLevel.INFO:
+                console.info(message, ...args);
+                break;
+            case LogLevel.DEBUG:
+                console.debug(message, ...args);
+                break;
+            case LogLevel.TRACE:
+                console.trace(message, ...args);
+                break;
+            default:
+                console.log(message, ...args);
+                break;
+        }
+    }
+}