Emit onSocketTimeout at most once every 20s

Author: alexdima

src/vs/base/parts/ipc/common/ipc.net.ts

@@ -778,6 +778,7 @@ export class PersistentProtocol implements IMessagePassingProtocol {
 	private _incomingAckTimeout: any | null;
 
 	private _lastReplayRequestTime: number;
+	private _lastSocketTimeoutTime: number;
 
 	private _socket: ISocket;
 	private _socketWriter: ProtocolWriter;
@@ -819,6 +820,7 @@ export class PersistentProtocol implements IMessagePassingProtocol {
 		this._incomingAckTimeout = null;
 
 		this._lastReplayRequestTime = 0;
+		this._lastSocketTimeoutTime = Date.now();
 
 		this._socketDisposables = [];
 		this._socket = socket;
@@ -887,6 +889,7 @@ export class PersistentProtocol implements IMessagePassingProtocol {
 		this._socket.dispose();
 
 		this._lastReplayRequestTime = 0;
+		this._lastSocketTimeoutTime = Date.now();
 
 		this._socket = socket;
 		this._socketWriter = new ProtocolWriter(this._socket);
@@ -1063,26 +1066,36 @@ export class PersistentProtocol implements IMessagePassingProtocol {
 		const oldestUnacknowledgedMsg = this._outgoingUnackMsg.peek()!;
 		const timeSinceOldestUnacknowledgedMsg = Date.now() - oldestUnacknowledgedMsg.writtenTime;
 		const timeSinceLastReceivedSomeData = Date.now() - this._socketReader.lastReadTime;
+		const timeSinceLastTimeout = Date.now() - this._lastSocketTimeoutTime;
 
 		if (
 			timeSinceOldestUnacknowledgedMsg >= ProtocolConstants.TimeoutTime
 			&& timeSinceLastReceivedSomeData >= ProtocolConstants.TimeoutTime
+			&& timeSinceLastTimeout >= ProtocolConstants.TimeoutTime
 		) {
 			// It's been a long time since our sent message was acknowledged
 			// and a long time since we received some data
 
 			// But this might be caused by the event loop being busy and failing to read messages
 			if (!this._loadEstimator.hasHighLoad()) {
 				// Trash the socket
+				this._lastSocketTimeoutTime = Date.now();
 				this._onSocketTimeout.fire(undefined);
 				return;
 			}
 		}
 
+		const minimumTimeUntilTimeout = Math.max(
+			ProtocolConstants.TimeoutTime - timeSinceOldestUnacknowledgedMsg,
+			ProtocolConstants.TimeoutTime - timeSinceLastReceivedSomeData,
+			ProtocolConstants.TimeoutTime - timeSinceLastTimeout,
+			500
+		);
+
 		this._outgoingAckTimeout = setTimeout(() => {
 			this._outgoingAckTimeout = null;
 			this._recvAckCheck();
-		}, Math.max(ProtocolConstants.TimeoutTime - timeSinceOldestUnacknowledgedMsg, 500));
+		}, minimumTimeUntilTimeout);
 	}
 
 	private _sendAck(): void {

src/vs/base/parts/ipc/test/node/ipc.net.test.ts

@@ -9,7 +9,7 @@ import { createServer, Socket } from 'net';
 import { tmpdir } from 'os';
 import { Barrier, timeout } from 'vs/base/common/async';
 import { VSBuffer } from 'vs/base/common/buffer';
-import { Emitter } from 'vs/base/common/event';
+import { Emitter, Event } from 'vs/base/common/event';
 import { Disposable, DisposableStore } from 'vs/base/common/lifecycle';
 import { ILoadEstimator, PersistentProtocol, Protocol, ProtocolConstants, SocketCloseEvent, SocketDiagnosticsEventType } from 'vs/base/parts/ipc/common/ipc.net';
 import { createRandomIPCHandle, createStaticIPCHandle, NodeSocket, WebSocketNodeSocket } from 'vs/base/parts/ipc/node/ipc.net';
@@ -431,6 +431,58 @@ suite('PersistentProtocol reconnection', () => {
 		);
 	});
 
+	test('onSocketTimeout is emitted at most once every 20s', async () => {
+		await runWithFakedTimers(
+			{
+				useFakeTimers: true,
+				useSetImmediate: true,
+				maxTaskCount: 1000
+			},
+			async () => {
+
+				const loadEstimator: ILoadEstimator = {
+					hasHighLoad: () => false
+				};
+				const ether = new Ether();
+				const aSocket = new NodeSocket(ether.a);
+				const a = new PersistentProtocol(aSocket, null, loadEstimator);
+				const aMessages = new MessageStream(a);
+				const bSocket = new NodeSocket(ether.b);
+				const b = new PersistentProtocol(bSocket, null, loadEstimator);
+				const bMessages = new MessageStream(b);
+
+				// never receive acks
+				b.pauseSocketWriting();
+
+				// send message a1 to have something unacknowledged
+				a.send(VSBuffer.fromString('a1'));
+
+				// wait for the first timeout to fire
+				await Event.toPromise(a.onSocketTimeout);
+
+				let timeoutFiredAgain = false;
+				const timeoutListener = a.onSocketTimeout(() => {
+					timeoutFiredAgain = true;
+				});
+
+				// send more messages
+				a.send(VSBuffer.fromString('a2'));
+				a.send(VSBuffer.fromString('a3'));
+
+				// wait for 10s
+				await timeout(ProtocolConstants.TimeoutTime / 2);
+
+				assert.strictEqual(timeoutFiredAgain, false);
+
+				timeoutListener.dispose();
+				aMessages.dispose();
+				bMessages.dispose();
+				a.dispose();
+				b.dispose();
+			}
+		);
+	});
+
 	test('writing can be paused', async () => {
 		await runWithFakedTimers({ useFakeTimers: true, maxTaskCount: 100 }, async () => {
 			const loadEstimator: ILoadEstimator = {