@theia/core 1.71.0-next.36 → 1.71.0-next.41

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

@@ -154,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 }>();
@@ -182,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();
@@ -214,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}`);
@@ -231,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 });
@@ -285,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/node/messaging/websocket-frontend-connection-service.ts

@@ -92,6 +92,7 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
         this.closeTimeouts.delete(frontEndId);
 
         connection.onCloseEmitter.fire({ reason });
+        connection.drainBuffer();
         connection.close();
     }
 
@@ -179,6 +180,10 @@ export class ReconnectableSocketChannel extends AbstractChannel {
         this.socket = undefined;
     }
 
+    drainBuffer(): void {
+        this.socketBuffer.drain();
+    }
+
     override getWriteBuffer(): WriteBuffer {
         const writeBuffer = new Uint8ArrayWriteBuffer();
         writeBuffer.onCommit(data => {