snapshot of https://github.com/RocketChat/Rocket.Chat.git (develop, 2026-09-16; blobs > 131072B omitted)

packages/apps/tests/server/runtime/deno/LivenessManager.test.ts

@@ -0,0 +1,271 @@
+import * as assert from 'node:assert';
+import type { ChildProcess } from 'node:child_process';
+import { EventEmitter } from 'node:stream';
+import { describe, it, beforeEach, afterEach, mock, type Mock } from 'node:test';
+
+import debugFactory from 'debug';
+
+import type { BaseRuntimeSubprocessController } from '../../../../src/server/runtime/base/BaseRuntimeSubprocessController';
+import { COMMAND_PING, LivenessManager } from '../../../../src/server/runtime/base/LivenessManager';
+import { ProcessMessenger } from '../../../../src/server/runtime/base/ProcessMessenger';
+
+describe('LivenessManager ping mechanism', () => {
+	const PING_INTERVAL_MS = 100;
+	const PING_TIMEOUT_MS = 50;
+	const CONSECUTIVE_TIMEOUT_LIMIT = 3;
+	const MAX_RESTARTS = Infinity;
+	const RESTART_ATTEMPT_DELAY_MS = 10;
+
+	let mockController: BaseRuntimeSubprocessController;
+	let mockMessenger: ProcessMessenger;
+	let mockSubprocess: ChildProcess;
+	let debug: debug.Debugger;
+	let livenessManager: LivenessManager;
+	let controllerEventEmitter: EventEmitter;
+	let subprocessEventEmitter: EventEmitter;
+	let sendMock: Mock<ProcessMessenger['send']>;
+
+	beforeEach(() => {
+		debug = debugFactory('test:liveness-manager');
+		mock.timers.enable({ apis: ['setTimeout', 'setInterval', 'Date'] });
+		mock.timers.setTime(0);
+
+		// Create event emitters for controller and subprocess
+		controllerEventEmitter = new EventEmitter();
+		subprocessEventEmitter = new EventEmitter();
+
+		// Mock controller
+		mockController = {
+			getProcessState: () => 'ready',
+			restartApp: async () => Promise.resolve(),
+			stopApp: async () => Promise.resolve(),
+			on: (event: string, listener: (...args: any[]) => void) => {
+				controllerEventEmitter.on(event, listener);
+				return mockController;
+			},
+			once: (event: string, listener: (...args: any[]) => void) => {
+				controllerEventEmitter.once(event, listener);
+				return mockController;
+			},
+			off: (event: string, listener: (...args: any[]) => void) => {
+				controllerEventEmitter.off(event, listener);
+				return mockController;
+			},
+			emit: (event: string, ...args: any[]) => {
+				return controllerEventEmitter.emit(event, ...args);
+			},
+			addListener: () => mockController,
+			removeListener: () => mockController,
+			removeAllListeners: () => mockController,
+			setMaxListeners: () => mockController,
+			getMaxListeners: () => 10,
+			listeners: (): any[] => [],
+			rawListeners: (): any[] => [],
+			listenerCount: (): number => 0,
+			prependListener: () => mockController,
+			prependOnceListener: () => mockController,
+			eventNames: (): string[] => [],
+		} as unknown as BaseRuntimeSubprocessController;
+
+		// Mock subprocess
+		mockSubprocess = {
+			pid: 12345,
+			once: (event: string, listener: (...args: any[]) => void) => {
+				subprocessEventEmitter.once(event, listener);
+				return mockSubprocess;
+			},
+			on: () => mockSubprocess,
+			off: () => mockSubprocess,
+			emit: (event: string, ...args: any[]) => {
+				return subprocessEventEmitter.emit(event, ...args);
+			},
+		} as unknown as ChildProcess;
+
+		// Mock messenger
+		mockMessenger = new ProcessMessenger();
+		mockMessenger.setReceiver(mockSubprocess);
+
+		sendMock = mock.method(mockMessenger, 'send', () => Promise.resolve());
+
+		// Create LivenessManager with fast ping options for testing
+		livenessManager = new LivenessManager(
+			{
+				controller: mockController,
+				messenger: mockMessenger,
+				debug,
+			},
+			{
+				pingTimeoutInMS: PING_TIMEOUT_MS,
+				pingIntervalInMS: PING_INTERVAL_MS,
+				consecutiveTimeoutLimit: CONSECUTIVE_TIMEOUT_LIMIT,
+				maxRestarts: MAX_RESTARTS,
+				restartAttemptDelayInMS: RESTART_ATTEMPT_DELAY_MS,
+			},
+		);
+
+		livenessManager.attach(mockSubprocess);
+	});
+
+	afterEach(() => {
+		// Stop the liveness manager to clean up intervals
+		livenessManager.stop();
+
+		// Clear all event listeners
+		controllerEventEmitter.removeAllListeners();
+		subprocessEventEmitter.removeAllListeners();
+
+		mock.timers.reset();
+		sendMock.mock.restore();
+	});
+
+	it('should update lastHeartbeatTimestamp when heartbeat event is emitted', () => {
+		controllerEventEmitter.emit('constructed');
+
+		const initialTimestamp = livenessManager.getRuntimeData().lastHeartbeatTimestamp;
+		assert.strictEqual(initialTimestamp, 0);
+
+		mock.timers.tick(50);
+
+		controllerEventEmitter.emit('heartbeat');
+
+		const newTimestamp = livenessManager.getRuntimeData().lastHeartbeatTimestamp;
+		assert.strictEqual(newTimestamp, 50);
+	});
+
+	it('should ping when heartbeat is stale', () => {
+		controllerEventEmitter.emit('constructed');
+
+		mock.timers.tick(PING_INTERVAL_MS);
+
+		assert.strictEqual(sendMock.mock.calls.length, 1);
+		assert.deepStrictEqual(sendMock.mock.calls[0].arguments, [COMMAND_PING]);
+	});
+
+	it('should not ping when heartbeat is recent', () => {
+		controllerEventEmitter.emit('constructed');
+
+		// Wait half the interval to update the heartbeat
+		mock.timers.tick(PING_INTERVAL_MS / 2);
+
+		controllerEventEmitter.emit('heartbeat');
+
+		// Wait for the rest of the interval that would trigger the ping
+		mock.timers.tick(PING_INTERVAL_MS / 2);
+
+		// Ping should not have been sent
+		assert.strictEqual(sendMock.mock.calls.length, 0);
+	});
+
+	it('should handle successful ping/pong', () => {
+		controllerEventEmitter.emit('constructed');
+
+		// Wait for the full interval
+		mock.timers.tick(PING_INTERVAL_MS);
+
+		// Verify ping was sent
+		assert.strictEqual(sendMock.mock.calls.length, 1);
+		assert.deepStrictEqual(sendMock.mock.calls[0].arguments, [COMMAND_PING]);
+
+		// Advance time to simulate latency
+		mock.timers.tick(20);
+
+		// Emit pong response
+		controllerEventEmitter.emit('pong');
+
+		// Verify consecutive timeout count was reset
+		const runtimeData = livenessManager.getRuntimeData();
+		assert.strictEqual(runtimeData.pingTimeoutConsecutiveCount, 0);
+
+		// Verify heartbeat timestamp was updated
+		const newTimestamp = runtimeData.lastHeartbeatTimestamp;
+		assert.strictEqual(newTimestamp, PING_INTERVAL_MS + 20);
+	});
+
+	it('should keep track of consecutive timeouts, and clear the count on a heartbeat', () => {
+		controllerEventEmitter.emit('constructed');
+
+		// Wait for the full interval
+		mock.timers.tick(PING_INTERVAL_MS);
+
+		// Verify ping was sent
+		assert.strictEqual(sendMock.mock.calls.length, 1);
+		assert.deepStrictEqual(sendMock.mock.calls[0].arguments, [COMMAND_PING]);
+
+		// Timeout the ping
+		mock.timers.tick(PING_TIMEOUT_MS);
+
+		// Verify consecutive timeout count incremented
+		let runtimeData = livenessManager.getRuntimeData();
+		assert.strictEqual(runtimeData.pingTimeoutConsecutiveCount, 1);
+
+		// Tick the rest of the interval to next ping
+		mock.timers.tick(PING_INTERVAL_MS - PING_TIMEOUT_MS);
+
+		// Verify ping was sent
+		assert.strictEqual(sendMock.mock.calls.length, 2);
+
+		// Timeout the ping
+		mock.timers.tick(PING_TIMEOUT_MS);
+
+		// Verify consecutive timeout count incremented
+		runtimeData = livenessManager.getRuntimeData();
+		assert.strictEqual(runtimeData.pingTimeoutConsecutiveCount, 2);
+
+		controllerEventEmitter.emit('heartbeat');
+
+		mock.timers.tick(PING_INTERVAL_MS - PING_TIMEOUT_MS);
+
+		// Shouldn't have called ping due to recent heartbeat
+		assert.strictEqual(sendMock.mock.calls.length, 2);
+
+		// Verify consecutive timeout count was reset
+		runtimeData = livenessManager.getRuntimeData();
+		assert.strictEqual(runtimeData.pingTimeoutConsecutiveCount, 0);
+	});
+
+	it('should call restart when consecutive timeout count reaches limit from options', async () => {
+		(livenessManager as any).options.consecutiveTimeoutLimit = 2;
+		const restartSpy = mock.method(livenessManager as any, 'restartProcess', () => Promise.resolve());
+
+		controllerEventEmitter.emit('constructed');
+
+		// Wait for the full interval
+		mock.timers.tick(PING_INTERVAL_MS);
+
+		// Verify ping was sent
+		assert.strictEqual(sendMock.mock.calls.length, 1);
+		assert.deepStrictEqual(sendMock.mock.calls[0].arguments, [COMMAND_PING]);
+
+		// Timeout the ping
+		mock.timers.tick(PING_TIMEOUT_MS);
+
+		// Verify consecutive timeout count incremented
+		let runtimeData = livenessManager.getRuntimeData();
+		assert.strictEqual(runtimeData.pingTimeoutConsecutiveCount, 1);
+
+		// Wait for ping handler to finish
+		await livenessManager.getPendingPing();
+
+		// Tick the rest of the interval to next ping
+		mock.timers.tick(PING_INTERVAL_MS - PING_TIMEOUT_MS);
+
+		// Verify ping was sent
+		assert.strictEqual(sendMock.mock.calls.length, 2);
+
+		// Timeout the ping
+		mock.timers.tick(PING_TIMEOUT_MS);
+
+		// Wait for ping handler to finish
+		await livenessManager.getPendingPing();
+
+		// Verify consecutive timeout count incremented
+		runtimeData = livenessManager.getRuntimeData();
+		assert.strictEqual(runtimeData.pingTimeoutConsecutiveCount, 2);
+
+		// Verify that restart has been called due to reaching consecutive timeout limit
+		assert.strictEqual(restartSpy.mock.calls.length, 1);
+		assert.deepStrictEqual(restartSpy.mock.calls[0].arguments, ['Too many pings timed out']);
+
+		restartSpy.mock.restore();
+	});
+});