BC-7038 - advanced load testing

apps/server/src/apps/board-collaboration.app.ts

@@ -7,9 +7,9 @@ import { install as sourceMapInstall } from 'source-map-support';
 
 // application imports
 import { SwaggerDocumentOptions } from '@nestjs/swagger';
-import { DB_URL } from '@src/config';
+// import { DB_URL } from '@src/config';
 import { LegacyLogger, Logger } from '@src/core/logger';
-import { MongoIoAdapter } from '@src/infra/socketio';
+import { MongoIoAdapter, RedisIoAdapter } from '@src/infra/socketio';
 import { BoardCollaborationModule } from '@src/modules/board/board-collaboration.module';
 import { enableOpenApiDocs } from '@src/shared/controller/swagger';
 import express from 'express';
@@ -18,19 +18,29 @@ import {
 	createAndStartPrometheusMetricsAppIfEnabled,
 } from '@src/apps/helpers/prometheus-metrics';
 import { ExpressAdapter } from '@nestjs/platform-express';
+import { DB_URL } from '@src/config';
+import { IoAdapter } from '@nestjs/platform-socket.io';
 
 async function bootstrap() {
 	sourceMapInstall();
 
 	const nestExpress = express();
 	const nestExpressAdapter = new ExpressAdapter(nestExpress);
 	const nestApp = await NestFactory.create(BoardCollaborationModule, nestExpressAdapter);
-	nestApp.useLogger(await nestApp.resolve(LegacyLogger));
+	const legacyLogger = await nestApp.resolve(LegacyLogger);
+	nestApp.useLogger(legacyLogger);
 	nestApp.enableCors({ exposedHeaders: ['Content-Disposition'] });
 
-	const mongoIoAdapter = new MongoIoAdapter(nestApp);
-	await mongoIoAdapter.connectToMongoDb(DB_URL);
-	nestApp.useWebSocketAdapter(mongoIoAdapter);
+	let ioAdapter: IoAdapter;
+	// eslint-disable-next-line no-process-env
+	if (process.env.COLLABORATION_WEBSOCKET_ADAPTER === 'redis') {
+		ioAdapter = new RedisIoAdapter(nestApp);
+	} else {
+		const mongoAdapter = new MongoIoAdapter(nestApp);
+		await mongoAdapter.connectToMongoDb(DB_URL);
+		ioAdapter = mongoAdapter;
+	}
+	nestApp.useWebSocketAdapter(ioAdapter);
 
 	const options: SwaggerDocumentOptions = {
 		operationIdFactory: (_controllerKey: string, methodKey: string) => methodKey,

apps/server/src/infra/socketio/index.ts

@@ -1,3 +1,4 @@
 export { Socket } from './types';
 export { WsValidationPipe } from './ws-validation.pipe';
 export { MongoIoAdapter } from './mongodb-ioadapter';
+export { RedisIoAdapter } from './redis-ioadapter';

apps/server/src/infra/socketio/redis-ioadapter.spec.ts

@@ -0,0 +1,42 @@
+import { LegacyLogger } from '@src/core/logger';
+import { RedisIoAdapter } from './redis-ioadapter';
+
+jest.mock('@src/core/logger', () => {
+	return {
+		LegacyLogger: jest.fn().mockImplementation(() => {
+			return {
+				error: jest.fn(),
+			};
+		}),
+	};
+});
+
+const redisMock = {
+	on: jest.fn(),
+	psubscribe: jest.fn(),
+	subscribe: jest.fn(),
+};
+
+jest.mock('ioredis', () => {
+	return {
+		Redis: jest.fn().mockImplementation(() => redisMock),
+	};
+});
+
+describe('RedisIoAdapter', () => {
+	const setup = () => {
+		const legacyLogger = { error: jest.fn() } as unknown as LegacyLogger;
+		const redisIoAdapter = new RedisIoAdapter(legacyLogger);
+		return { redisIoAdapter, legacyLogger };
+	};
+
+	describe('createIOServer', () => {
+		it('should send several actions', () => {
+			const { redisIoAdapter } = setup();
+
+			redisIoAdapter.createIOServer(1234);
+
+			expect(redisMock.on).toHaveBeenCalledTimes(6);
+		});
+	});
+});

apps/server/src/infra/socketio/redis-ioadapter.ts

@@ -0,0 +1,49 @@
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import { IoAdapter } from '@nestjs/platform-socket.io';
+import { ServerOptions, Server } from 'socket.io';
+import { createAdapter } from '@socket.io/redis-adapter';
+import { Configuration } from '@hpi-schul-cloud/commons';
+import { Redis } from 'ioredis';
+import { LegacyLogger } from '@src/core/logger';
+
+export class RedisIoAdapter extends IoAdapter {
+	private adapterConstructor: ReturnType<typeof createAdapter> | undefined = undefined;
+
+	constructor(private readonly legacyLogger: LegacyLogger) {
+		super();
+	}
+
+	connectToRedis(): void {
+		const redisUri = Configuration.has('REDIS_URI') ? (Configuration.get('REDIS_URI') as string) : 'localhost:6379';
+		const pubClient = new Redis(redisUri);
+		const subClient = new Redis(redisUri);
+
+		pubClient.on('error', (err) => {
+			// istanbul ignore next
+			this.legacyLogger.error('pubClient error', err);
+		});
+
+		subClient.on('error', (err) => {
+			// istanbul ignore next
+			this.legacyLogger.error('subClient error', err);
+		});
+
+		this.adapterConstructor = createAdapter(pubClient, subClient);
+	}
+
+	createIOServer(port: number, options?: ServerOptions): Server {
+		this.connectToRedis();
+		// istanbul ignore next
+		if (!this.adapterConstructor) {
+			throw new Error('Redis adapter is not connected to Redis yet.');
+		}
+		const server = super.createIOServer(port, options) as Server;
+		// istanbul ignore next
+		if (server === undefined) {
+			throw new Error('Unable to create RedisServer');
+		}
+		server.adapter(this.adapterConstructor);
+		return server;
+	}
+}

apps/server/src/modules/board/gateway/board-collaboration.gateway.ts

@@ -197,6 +197,7 @@ export class BoardCollaborationGateway implements OnGatewayDisconnect {
 				...data,
 				newColumn,
 			};
+			await emitter.joinRoom(column);
 			emitter.emitToClientAndRoom(responsePayload, column);
 
 			// payload needs to be returned to allow the client to do sequential operation

apps/server/src/modules/board/loadtest/board-collaboration.load.spec.ts

@@ -0,0 +1,36 @@
+/* eslint-disable no-process-env */
+import { CreateBoardLoadTest, SocketConfiguration } from './types';
+import { viewersClass, collaborativeClass } from './helper/class-definitions';
+import { SocketConnectionManager } from './socket-connection-manager';
+import { LoadtestRunner } from './loadtest-runner';
+import { BoardLoadTest } from './board-load-test';
+
+describe('Board Collaboration Load Test', () => {
+	it('should run a basic load test', async () => {
+		const { COURSE_ID, TOKEN, TARGET_URL } = process.env;
+		const viewerClassesAmount = process.env.viewerClasses ? parseInt(process.env.viewerClasses, 10) : 20;
+		const collabClassesAmount = process.env.collabClasses ? parseInt(process.env.collabClasses, 10) : 0;
+		if (COURSE_ID && TOKEN && TARGET_URL) {
+			const socketConfiguration: SocketConfiguration = {
+				baseUrl: TARGET_URL,
+				path: '/board-collaboration',
+				token: TOKEN,
+				connectTimeout: 5000,
+			};
+
+			const socketConnectionManager = new SocketConnectionManager(socketConfiguration);
+			const createBoardLoadTest: CreateBoardLoadTest = (...args) => new BoardLoadTest(...args);
+			const runner = new LoadtestRunner(socketConnectionManager, createBoardLoadTest);
+			await runner.runLoadtest({
+				socketConfiguration,
+				courseId: COURSE_ID,
+				configurations: [
+					{ classDefinition: viewersClass, amount: viewerClassesAmount },
+					{ classDefinition: collaborativeClass, amount: collabClassesAmount },
+				],
+			});
+		} else {
+			expect('this should only be ran manually').toBeTruthy();
+		}
+	}, 600000);
+});

apps/server/src/modules/board/loadtest/board-load-test.spec.ts

@@ -0,0 +1,127 @@
+import { BoardLoadTest } from './board-load-test';
+import { fastEditor } from './helper/class-definitions';
+import { SocketConnectionManager } from './socket-connection-manager';
+import { ClassDefinition } from './types';
+import { SocketConnection } from './socket-connection';
+import { LoadtestClient } from './loadtest-client';
+
+jest.mock('./helper/sleep', () => {
+	return { sleep: () => Promise.resolve(true) };
+});
+
+jest.mock('./loadtest-client', () => {
+	return {
+		createColumn: jest.fn().mockResolvedValue({ id: 'some-id' }),
+		createCard: jest.fn().mockResolvedValue({ id: 'some-id' }),
+		createElement: jest.fn().mockResolvedValue({ id: 'some-id' }),
+		createAndUpdateLinkElement: jest.fn().mockResolvedValue({ id: 'some-id' }),
+		createAndUpdateTextElement: jest.fn().mockResolvedValue({ id: 'some-id' }),
+		updateCardTitle: jest.fn().mockResolvedValue({ id: 'some-id' }),
+		updateColumnTitle: jest.fn().mockResolvedValue({ id: 'some-id' }),
+	};
+});
+
+jest.mock('./socket-connection-manager');
+
+const testClass: ClassDefinition = {
+	name: 'viewersClass',
+	users: [{ ...fastEditor, amount: 5 }],
+};
+
+beforeEach(() => {
+	jest.resetAllMocks();
+	jest.useFakeTimers();
+});
+
+afterEach(() => {
+	jest.runOnlyPendingTimers();
+	jest.useRealTimers();
+});
+
+describe('BoardLoadTest', () => {
+	const setup = () => {
+		const socketConfiguration = { baseUrl: '', path: '', token: '' };
+		const socketConnectionManager = new SocketConnectionManager(socketConfiguration);
+		const socketConnection = new SocketConnection(socketConfiguration, console.log);
+
+		const boarLoadTest = new BoardLoadTest(socketConnectionManager, console.log);
+		return { boarLoadTest, socketConnectionManager, socketConnection };
+	};
+
+	describe('runBoardTest', () => {
+		describe('if no userProfiles are provided', () => {
+			it('should do nothing', async () => {
+				const { boarLoadTest } = setup();
+				const boardId = 'board-id';
+				const configuration = { name: 'my-configuration', users: [], simulateUsersTimeMs: 2000 };
+
+				const response = await boarLoadTest.runBoardTest(boardId, configuration);
+
+				expect(response).toBeUndefined();
+			});
+		});
+
+		describe('if userProfiles are provided', () => {
+			it('should create socketConnections for all users', async () => {
+				const { boarLoadTest, socketConnectionManager } = setup();
+				const boardId = 'board-id';
+
+				await boarLoadTest.runBoardTest(boardId, testClass);
+
+				expect(socketConnectionManager.createConnection).toHaveBeenCalledTimes(5);
+			});
+		});
+	});
+
+	describe('simulateUserActions', () => {
+		it('should create columns and cards', async () => {
+			const { boarLoadTest } = setup();
+			const loadtestClient = {
+				createColumn: jest.fn().mockResolvedValue({ id: 'some-id' }),
+				createCard: jest.fn().mockResolvedValue({ id: 'some-id' }),
+				createElement: jest.fn().mockResolvedValue({ id: 'some-id' }),
+				createAndUpdateLinkElement: jest.fn().mockResolvedValue({ id: 'some-id' }),
+				createAndUpdateTextElement: jest.fn().mockResolvedValue({ id: 'some-id' }),
+				updateCardTitle: jest.fn().mockResolvedValue({ id: 'some-id' }),
+				updateColumnTitle: jest.fn().mockResolvedValue({ id: 'some-id' }),
+			} as unknown as LoadtestClient;
+			const userProfile = fastEditor;
+
+			await boarLoadTest.simulateUserActions(loadtestClient, userProfile, 10);
+
+			expect(loadtestClient.createColumn).toHaveBeenCalled();
+			expect(loadtestClient.createCard).toHaveBeenCalled();
+		}, 10000);
+	});
+
+	describe('createColumn', () => {
+		it('should create a column', async () => {
+			const { boarLoadTest } = setup();
+
+			const loadtestClient = {
+				createColumn: jest.fn().mockResolvedValue({ id: 'some-id' }),
+				updateColumnTitle: jest.fn().mockResolvedValue({ id: 'some-id' }),
+			} as unknown as LoadtestClient;
+			await boarLoadTest.createColumn(loadtestClient);
+
+			expect(loadtestClient.createColumn).toHaveBeenCalled();
+		});
+	});
+
+	describe('createRandomCard', () => {
+		it('should create a card', async () => {
+			const { boarLoadTest } = setup();
+			boarLoadTest.trackColumn('some-id');
+
+			const loadtestClient = {
+				createCard: jest.fn().mockResolvedValue({ id: 'some-id' }),
+				updateCardTitle: jest.fn().mockResolvedValue({ id: 'some-id' }),
+				createAndUpdateLinkElement: jest.fn().mockResolvedValue({ id: 'some-id' }),
+				createAndUpdateTextElement: jest.fn().mockResolvedValue({ id: 'some-id' }),
+			} as unknown as LoadtestClient;
+			await boarLoadTest.createRandomCard(loadtestClient);
+
+			expect(loadtestClient.createCard).toHaveBeenCalled();
+		}, 100000);
+	});
+});