Bc 4256 integration tldraw

.github/workflows/dependency-review.yml

@@ -13,4 +13,5 @@ jobs:
       - name: 'Dependency Review'
         uses: actions/dependency-review-action@v3
         with:
-          allow-licenses: AGPL-3.0-only, LGPL-3.0, MIT, Apache-2.0, BSD-2-Clause, BSD-3-Clause, ISC, X11, 0BSD, GPL-3.0, Unlicense
+          allow-licenses: AGPL-3.0-only, LGPL-3.0, MIT, Apache-2.0, BSD-2-Clause, BSD-3-Clause, ISC, X11, 0BSD, GPL-3.0, BSD-3-Clause AND BSD-3-Clause-Clear, Unlicense
+          allow-dependencies-licenses: 'pkg:npm/parse-mongo-url'

.github/workflows/push.yml

@@ -133,7 +133,7 @@ jobs:
     needs:
       - build_and_push
       - branch_meta
-    uses: hpi-schul-cloud/dof_app_deploy/.github/workflows/deploy.yml@main
+    uses: hpi-schul-cloud/dof_app_deploy/.github/workflows/deploy.yml@BC-4256-Integration-tldraw
     with:
       branch: ${{ needs.branch_meta.outputs.branch }}
     secrets:

ansible/roles/schulcloud-server-core/tasks/main.yml

@@ -83,3 +83,15 @@
       kubeconfig: ~/.kube/config
       namespace: "{{ NAMESPACE }}"
       template: amqp-files-deployment.yml.j2
+
+  - name: TlDrawServerDeployment
+    kubernetes.core.k8s:
+      kubeconfig: ~/.kube/config
+      namespace: "{{ NAMESPACE }}"
+      template: tldraw-deployment.yml.j2
+
+  - name: TlDrawServerService
+    kubernetes.core.k8s:
+      kubeconfig: ~/.kube/config
+      namespace: "{{ NAMESPACE }}"
+      template: tldraw-svc.yml.j2

ansible/roles/schulcloud-server-core/templates/tldraw-deployment.yml.j2

@@ -0,0 +1,50 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: tldraw-deployment
+  namespace: {{ NAMESPACE }}
+  labels:
+    app: tldraw
+spec:
+  replicas: {{ TLDRAW_EDITOR_REPLICAS|default("1", true) }}
+  strategy:
+    type: RollingUpdate
+    rollingUpdate:
+      maxSurge: 1
+      #maxUnavailable: 1
+  revisionHistoryLimit: 4
+  paused: false
+  selector:
+    matchLabels:
+      app: tldraw
+  template:
+    metadata:
+      labels:
+        app: tldraw
+    spec:
+      securityContext:
+        runAsUser: 1000
+        runAsGroup: 1000
+        fsGroup: 1000
+        runAsNonRoot: true
+      containers:
+      - name: tldraw
+        image: {{ SCHULCLOUD_SERVER_IMAGE }}:{{ SCHULCLOUD_SERVER_IMAGE_TAG }}
+        imagePullPolicy: IfNotPresent
+        ports:
+        - containerPort: 3345
+          name: tldraw
+          protocol: TCP
+        envFrom:
+        - configMapRef:
+            name: api-configmap
+        - secretRef:
+            name: api-secret
+        command: ['npm', 'run', 'nest:start:tldraw:prod']
+        resources:
+          limits:
+            cpu: {{ TLDRAW_EDITOR_CPU_LIMITS|default("2000m", true) }}
+            memory: {{ TLDRAW_EDITOR_MEMORY_LIMITS|default("500Mi", true) }}
+          requests:
+            cpu: {{ TLDRAW_EDITOR_CPU_REQUESTS|default("100m", true) }}
+            memory: {{ TLDRAW_EDITOR_MEMORY_REQUESTS|default("50Mi", true) }}

ansible/roles/schulcloud-server-core/templates/tldraw-svc.yml.j2

@@ -0,0 +1,16 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: tldraw-svc
+  namespace: {{ NAMESPACE }}
+  labels:
+    app: tldraw
+spec:
+  type: ClusterIP
+  ports:
+    - port: 3345
+      targetPort: 3345
+      protocol: TCP
+      name: tldraw
+  selector:
+    app: tldraw

apps/server/src/apps/tldraw.app.ts

@@ -0,0 +1,31 @@
+/* istanbul ignore file */
+/* eslint-disable no-console */
+import { NestFactory } from '@nestjs/core';
+import { install as sourceMapInstall } from 'source-map-support';
+import { TldrawModule } from '@src/modules/tldraw';
+import { Logger } from '@src/core/logger';
+import * as WebSocket from 'ws';
+import { WsAdapter } from '@nestjs/platform-ws';
+import { enableOpenApiDocs } from '@shared/controller/swagger';
+import { AppStartLoggable } from '@src/apps/helpers/app-start-loggable';
+
+async function bootstrap() {
+	sourceMapInstall();
+
+	const nestApp = await NestFactory.create(TldrawModule);
+	const wss = new WebSocket.Server({ noServer: true });
+	nestApp.useWebSocketAdapter(new WsAdapter(wss));
+	nestApp.enableCors();
+	enableOpenApiDocs(nestApp, 'docs');
+
+	const logger = await nestApp.resolve(Logger);
+	await nestApp.init();
+
+	logger.info(
+		new AppStartLoggable({
+			appName: 'Tldraw server app',
+		})
+	);
+}
+
+void bootstrap();

apps/server/src/config/database.config.ts

@@ -4,9 +4,10 @@ interface GlobalConstants {
 	DB_URL: string;
 	DB_PASSWORD?: string;
 	DB_USERNAME?: string;
+	TLDRAW_DB_URL: string;
 }
 
 const usedGlobals: GlobalConstants = globals;
 
 /** Database URL */
-export const { DB_URL, DB_PASSWORD, DB_USERNAME } = usedGlobals;
+export const { DB_URL, DB_PASSWORD, DB_USERNAME, TLDRAW_DB_URL } = usedGlobals;

apps/server/src/modules/authentication/index.ts

@@ -1,2 +1,3 @@
 export * from './interface';
 export * from './guard/jwt-auth.guard';
+export * from './authentication.module';

apps/server/src/modules/tldraw/config.ts

@@ -0,0 +1,28 @@
+import { Configuration } from '@hpi-schul-cloud/commons';
+import { NodeEnvType } from '@src/modules/server';
+import { TLDRAW_DB_URL } from '@src/config';
+
+export interface TldrawConfig {
+	NEST_LOG_LEVEL: string;
+	INCOMING_REQUEST_TIMEOUT: number;
+	NODE_ENV: string;
+	TLDRAW_DB_COLLECTION_NAME: string;
+	TLDRAW_DB_FLUSH_SIZE: string;
+	TLDRAW_DB_MULTIPLE_COLLECTIONS: boolean;
+	CONNECTION_STRING: string;
+	FEATURE_TLDRAW_ENABLED: boolean;
+}
+
+const tldrawConfig = {
+	NEST_LOG_LEVEL: Configuration.get('NEST_LOG_LEVEL') as string,
+	INCOMING_REQUEST_TIMEOUT: Configuration.get('INCOMING_REQUEST_TIMEOUT_API') as number,
+	NODE_ENV: Configuration.get('NODE_ENV') as NodeEnvType,
+	TLDRAW_DB_COLLECTION_NAME: Configuration.get('TLDRAW__DB_COLLECTION_NAME') as string,
+	TLDRAW_DB_FLUSH_SIZE: Configuration.get('TLDRAW__DB_FLUSH_SIZE') as number,
+	TLDRAW_DB_MULTIPLE_COLLECTIONS: Configuration.get('TLDRAW__DB_MULTIPLE_COLLECTIONS') as boolean,
+	FEATURE_TLDRAW_ENABLED: Configuration.get('FEATURE_TLDRAW_ENABLED') as boolean,
+	CONNECTION_STRING: TLDRAW_DB_URL,
+};
+
+export const SOCKET_PORT = Configuration.get('TLDRAW__SOCKET_PORT') as number;
+export const config = () => tldrawConfig;

apps/server/src/modules/tldraw/gateway/api-test/tldraw.gateway.api.spec.ts

@@ -0,0 +1,165 @@
+import { WsAdapter } from '@nestjs/platform-ws';
+import { Test } from '@nestjs/testing';
+import WebSocket from 'ws';
+import { TextEncoder } from 'util';
+import { INestApplication } from '@nestjs/common';
+import { CoreModule } from '@src/core';
+import { ConfigModule } from '@nestjs/config';
+import { createConfigModuleOptions } from '@src/config';
+import { config } from '@src/modules/tldraw/config';
+import * as Utils from '../../utils/utils';
+import { TldrawGateway } from '../tldraw.gateway';
+
+describe('WebSocketGateway (WsAdapter)', () => {
+	let app: INestApplication;
+	let gateway: TldrawGateway;
+	let ws: WebSocket;
+
+	const gatewayPort = 3346;
+	const wsUrl = `ws://localhost:${gatewayPort}`;
+	const testMessage =
+		'AZQBAaCbuLANBIsBeyJ0ZFVzZXIiOnsiaWQiOiJkNGIxZThmYi0yMWUwLTQ3ZDAtMDI0Y' +
+		'S0zZGEwYjMzNjQ3MjIiLCJjb2xvciI6IiNGMDRGODgiLCJwb2ludCI6WzAsMF0sInNlbGVjdGVkSWRzIjpbXSwiYWN' +
+		'0aXZlU2hhcGVzIjpbXSwic2Vzc2lvbiI6ZmFsc2V9fQ==';
+
+	const setupWs = async (docName?: string) => {
+		if (docName) {
+			ws = new WebSocket(`${wsUrl}/${docName}`);
+		} else {
+			ws = new WebSocket(`${wsUrl}`);
+		}
+		await new Promise((resolve) => {
+			ws.on('open', resolve);
+		});
+	};
+
+	const delay = (ms: number) =>
+		new Promise((resolve) => {
+			setTimeout(resolve, ms);
+		});
+
+	const getMessage = () => new TextEncoder().encode(testMessage);
+
+	beforeAll(async () => {
+		const imports = [CoreModule, ConfigModule.forRoot(createConfigModuleOptions(config))];
+		const testingModule = await Test.createTestingModule({
+			imports,
+			providers: [TldrawGateway],
+		}).compile();
+		gateway = testingModule.get<TldrawGateway>(TldrawGateway);
+		app = testingModule.createNestApplication();
+		app.useWebSocketAdapter(new WsAdapter(app));
+		await app.init();
+	});
+
+	afterAll(async () => {
+		await app.close();
+	});
+
+	beforeEach(() => {
+		jest.useFakeTimers({ advanceTimers: true, doNotFake: ['setInterval', 'clearInterval', 'setTimeout'] });
+	});
+
+	afterEach(() => {
+		jest.clearAllMocks();
+	});
+
+	describe('when tldraw is correctly setup', () => {
+		const setup = async () => {
+			const handleConnectionSpy = jest.spyOn(gateway, 'handleConnection');
+			jest.spyOn(Uint8Array.prototype, 'reduce').mockReturnValue(1);
+
+			await setupWs('TEST');
+
+			const { buffer } = getMessage();
+
+			return { handleConnectionSpy, buffer };
+		};
+
+		it(`should handle connection and data transfer`, async () => {
+			const { handleConnectionSpy, buffer } = await setup();
+			ws.send(buffer, () => {});
+
+			expect(handleConnectionSpy).toHaveBeenCalled();
+			expect(handleConnectionSpy).toHaveBeenCalledTimes(1);
+
+			await delay(2000);
+			ws.close();
+		});
+
+		it(`check if client will receive message`, async () => {
+			const { buffer } = await setup();
+			ws.send(buffer, () => {});
+
+			gateway.server.on('connection', (client) => {
+				client.on('message', (payload) => {
+					expect(payload).toBeInstanceOf(ArrayBuffer);
+				});
+			});
+
+			await delay(200);
+			ws.close();
+		});
+	});
+
+	describe('when tldraw doc has multiple clients', () => {
+		const setup = async () => {
+			const handleConnectionSpy = jest.spyOn(gateway, 'handleConnection');
+			await setupWs('TEST2');
+			const ws2 = new WebSocket(`${wsUrl}/TEST2`);
+			await new Promise((resolve) => {
+				ws2.on('open', resolve);
+			});
+
+			const { buffer } = getMessage();
+
+			return {
+				handleConnectionSpy,
+				ws2,
+				buffer,
+			};
+		};
+
+		it(`should handle 2 connections at same doc and data transfer`, async () => {
+			const { handleConnectionSpy, ws2, buffer } = await setup();
+			ws.send(buffer);
+			ws2.send(buffer);
+
+			expect(handleConnectionSpy).toHaveBeenCalled();
+			expect(handleConnectionSpy).toHaveBeenCalledTimes(2);
+
+			await delay(200);
+			ws.close();
+			ws2.close();
+		}, 120000);
+	});
+
+	describe('when tldraw is not correctly setup', () => {
+		const setup = async () => {
+			const handleConnectionSpy = jest.spyOn(gateway, 'handleConnection');
+			const utilsSpy = jest.spyOn(Utils, 'messageHandler').mockReturnValue();
+
+			await setupWs();
+
+			return {
+				handleConnectionSpy,
+				utilsSpy,
+			};
+		};
+
+		it(`should refuse connection if there is no docName`, async () => {
+			const { handleConnectionSpy, utilsSpy } = await setup();
+
+			const { buffer } = getMessage();
+			ws.send(buffer);
+
+			expect(gateway.server).toBeDefined();
+			expect(handleConnectionSpy).toHaveBeenCalled();
+			expect(handleConnectionSpy).toHaveBeenCalledTimes(1);
+			expect(utilsSpy).not.toHaveBeenCalled();
+
+			await delay(200);
+			ws.close();
+		});
+	});
+});

apps/server/src/modules/tldraw/gateway/index.ts

@@ -0,0 +1 @@
+export * from './tldraw.gateway';