Adding a Pusher container as a middleware/dispatcher between front and back

pusher/src/App.ts

@@ -0,0 +1,32 @@
+// lib/app.ts
+import {IoSocketController} from "./Controller/IoSocketController"; //TODO fix import by "_Controller/..."
+import {AuthenticateController} from "./Controller/AuthenticateController"; //TODO fix import by "_Controller/..."
+import {MapController} from "./Controller/MapController";
+import {PrometheusController} from "./Controller/PrometheusController";
+import {FileController} from "./Controller/FileController";
+import {DebugController} from "./Controller/DebugController";
+import {App as uwsApp} from "./Server/sifrr.server";
+
+class App {
+    public app: uwsApp;
+    public ioSocketController: IoSocketController;
+    public authenticateController: AuthenticateController;
+    public fileController: FileController;
+    public mapController: MapController;
+    public prometheusController: PrometheusController;
+    private debugController: DebugController;
+
+    constructor() {
+        this.app = new uwsApp();
+
+        //create socket controllers
+        this.ioSocketController = new IoSocketController(this.app);
+        this.authenticateController = new AuthenticateController(this.app);
+        this.fileController = new FileController(this.app);
+        this.mapController = new MapController(this.app);
+        this.prometheusController = new PrometheusController(this.app);
+        this.debugController = new DebugController(this.app);
+    }
+}
+
+export default new App().app;

pusher/src/Controller/AuthenticateController.ts

@@ -0,0 +1,135 @@
+import { v4 } from 'uuid';
+import {HttpRequest, HttpResponse, TemplatedApp} from "uWebSockets.js";
+import {BaseController} from "./BaseController";
+import {adminApi} from "../Services/AdminApi";
+import {jwtTokenManager} from "../Services/JWTTokenManager";
+import {parse} from "query-string";
+
+export interface TokenInterface {
+    userUuid: string
+}
+
+export class AuthenticateController extends BaseController {
+
+    constructor(private App : TemplatedApp) {
+        super();
+        this.register();
+        this.verify();
+        this.anonymLogin();
+    }
+
+    //Try to login with an admin token
+    private register(){
+        this.App.options("/register", (res: HttpResponse, req: HttpRequest) => {
+            this.addCorsHeaders(res);
+
+            res.end();
+        });
+
+        this.App.post("/register", (res: HttpResponse, req: HttpRequest) => {
+            (async () => {
+                res.onAborted(() => {
+                    console.warn('Login request was aborted');
+                })
+                const param = await res.json();
+
+                //todo: what to do if the organizationMemberToken is already used?
+                const organizationMemberToken:string|null = param.organizationMemberToken;
+
+                try {
+                    if (typeof organizationMemberToken != 'string') throw new Error('No organization token');
+                    const data = await adminApi.fetchMemberDataByToken(organizationMemberToken);
+                    const userUuid = data.userUuid;
+                    const organizationSlug = data.organizationSlug;
+                    const worldSlug = data.worldSlug;
+                    const roomSlug = data.roomSlug;
+                    const mapUrlStart = data.mapUrlStart;
+                    const textures = data.textures;
+
+                    const authToken = jwtTokenManager.createJWTToken(userUuid);
+                    res.writeStatus("200 OK");
+                    this.addCorsHeaders(res);
+                    res.end(JSON.stringify({
+                        authToken,
+                        userUuid,
+                        organizationSlug,
+                        worldSlug,
+                        roomSlug,
+                        mapUrlStart,
+                        textures
+                    }));
+
+                } catch (e) {
+                    console.error("An error happened", e)
+                    res.writeStatus(e.status || "500 Internal Server Error");
+                    this.addCorsHeaders(res);
+                    res.end('An error happened');
+                }
+
+
+            })();
+        });
+
+    }
+
+    private verify(){
+        this.App.options("/verify", (res: HttpResponse, req: HttpRequest) => {
+            this.addCorsHeaders(res);
+
+            res.end();
+        });
+
+        this.App.get("/verify", (res: HttpResponse, req: HttpRequest) => {
+            (async () => {
+                const query = parse(req.getQuery());
+
+                res.onAborted(() => {
+                    console.warn('verify request was aborted');
+                })
+
+                try {
+                    await jwtTokenManager.getUserUuidFromToken(query.token as string);
+                } catch (e) {
+                    res.writeStatus("400 Bad Request");
+                    this.addCorsHeaders(res);
+                    res.end(JSON.stringify({
+                        "success": false,
+                        "message": "Invalid JWT token"
+                    }));
+                    return;
+                }
+                res.writeStatus("200 OK");
+                this.addCorsHeaders(res);
+                res.end(JSON.stringify({
+                    "success": true
+                }));
+            })();
+        });
+
+    }
+
+    //permit to login on application. Return token to connect on Websocket IO.
+    private anonymLogin(){
+        this.App.options("/anonymLogin", (res: HttpResponse, req: HttpRequest) => {
+            this.addCorsHeaders(res);
+
+            res.end();
+        });
+
+        this.App.post("/anonymLogin", (res: HttpResponse, req: HttpRequest) => {
+
+            res.onAborted(() => {
+                console.warn('Login request was aborted');
+            })
+
+            const userUuid = v4();
+            const authToken = jwtTokenManager.createJWTToken(userUuid);
+            res.writeStatus("200 OK");
+            this.addCorsHeaders(res);
+            res.end(JSON.stringify({
+                authToken,
+                userUuid,
+            }));
+        });
+    }
+}

pusher/src/Controller/BaseController.ts

@@ -0,0 +1,11 @@
+import {HttpRequest, HttpResponse} from "uWebSockets.js";
+import {ADMIN_API_TOKEN} from "../Enum/EnvironmentVariable";
+
+
+export class BaseController {
+    protected addCorsHeaders(res: HttpResponse): void {
+        res.writeHeader('access-control-allow-headers', 'Origin, X-Requested-With, Content-Type, Accept');
+        res.writeHeader('access-control-allow-methods', 'GET, POST, OPTIONS, PUT, PATCH, DELETE');
+        res.writeHeader('access-control-allow-origin', '*');
+    }
+}

pusher/src/Controller/DebugController.ts

@@ -0,0 +1,45 @@
+import {ADMIN_API_TOKEN} from "../Enum/EnvironmentVariable";
+import {IoSocketController} from "_Controller/IoSocketController";
+import {stringify} from "circular-json";
+import {HttpRequest, HttpResponse} from "uWebSockets.js";
+import { parse } from 'query-string';
+import {App} from "../Server/sifrr.server";
+import {socketManager} from "../Services/SocketManager";
+
+export class DebugController {
+    constructor(private App : App) {
+        this.getDump();
+    }
+
+
+    getDump(){
+        this.App.get("/dump", (res: HttpResponse, req: HttpRequest) => {
+            const query = parse(req.getQuery());
+
+            if (query.token !== ADMIN_API_TOKEN) {
+                return res.status(401).send('Invalid token sent!');
+            }
+
+            return res.writeStatus('200 OK').writeHeader('Content-Type', 'application/json').end(stringify(
+                socketManager.getWorlds(),
+                (key: unknown, value: unknown) => {
+                    if(value instanceof Map) {
+                        const obj: any = {}; // eslint-disable-line @typescript-eslint/no-explicit-any
+                        for (const [mapKey, mapValue] of value.entries()) {
+                            obj[mapKey] = mapValue;
+                        }
+                        return obj;
+                    } else if(value instanceof Set) {
+                            const obj: Array<unknown> = [];
+                            for (const [setKey, setValue] of value.entries()) {
+                                obj.push(setValue);
+                            }
+                            return obj;
+                    } else {
+                        return value;
+                    }
+                }
+            ));
+        });
+    }
+}

pusher/src/Controller/FileController.ts

@@ -0,0 +1,161 @@
+import {App} from "../Server/sifrr.server";
+
+import {v4} from "uuid";
+import {HttpRequest, HttpResponse} from "uWebSockets.js";
+import {BaseController} from "./BaseController";
+import { Readable } from 'stream'
+
+interface UploadedFileBuffer {
+    buffer: Buffer,
+    expireDate: Date
+}
+
+export class FileController extends BaseController {
+    private uploadedFileBuffers: Map<string, UploadedFileBuffer> = new Map<string, UploadedFileBuffer>();
+
+    constructor(private App : App) {
+        super();
+        this.App = App;
+        this.uploadAudioMessage();
+        this.downloadAudioMessage();
+
+        // Cleanup every 1 minute
+        setInterval(this.cleanup.bind(this), 60000);
+    }
+
+    /**
+     * Clean memory from old files
+     */
+    cleanup(): void {
+        const now = new Date();
+        for (const [id, file] of this.uploadedFileBuffers) {
+            if (file.expireDate < now) {
+                this.uploadedFileBuffers.delete(id);
+            }
+        }
+    }
+
+    uploadAudioMessage(){
+        this.App.options("/upload-audio-message", (res: HttpResponse, req: HttpRequest) => {
+            this.addCorsHeaders(res);
+
+            res.end();
+        });
+
+        this.App.post("/upload-audio-message", (res: HttpResponse, req: HttpRequest) => {
+            (async () => {
+                res.onAborted(() => {
+                    console.warn('upload-audio-message request was aborted');
+                })
+
+                try {
+                    const audioMessageId = v4();
+
+                    const params = await res.formData({
+                        onFile: (fieldname: string,
+                                 file: NodeJS.ReadableStream,
+                                 filename: string,
+                                 encoding: string,
+                                 mimetype: string) => {
+                            (async () => {
+                                console.log('READING FILE', fieldname)
+
+                                const chunks: Buffer[] = []
+                                for await (const chunk of file) {
+                                    if (!(chunk instanceof Buffer)) {
+                                        throw new Error('Unexpected chunk');
+                                    }
+                                    chunks.push(chunk)
+                                }
+                                // Let's expire in 1 minute.
+                                const expireDate = new Date();
+                                expireDate.setMinutes(expireDate.getMinutes() + 1);
+                                this.uploadedFileBuffers.set(audioMessageId, {
+                                    buffer: Buffer.concat(chunks),
+                                    expireDate
+                                });
+                            })();
+                        }
+                    });
+
+                    res.writeStatus("200 OK");
+                    this.addCorsHeaders(res);
+                    res.end(JSON.stringify({
+                        id: audioMessageId,
+                        path: `/download-audio-message/${audioMessageId}`
+                    }));
+
+                } catch (e) {
+                    console.log("An error happened", e)
+                    res.writeStatus(e.status || "500 Internal Server Error");
+                    this.addCorsHeaders(res);
+                    res.end('An error happened');
+                }
+            })();
+        });
+    }
+
+    downloadAudioMessage(){
+        this.App.options("/download-audio-message/*", (res: HttpResponse, req: HttpRequest) => {
+            this.addCorsHeaders(res);
+
+            res.end();
+        });
+
+        this.App.get("/download-audio-message/:id", (res: HttpResponse, req: HttpRequest) => {
+
+            res.onAborted(() => {
+                console.warn('upload-audio-message request was aborted');
+            })
+
+            const id = req.getParameter(0);
+
+            const file = this.uploadedFileBuffers.get(id);
+            if (file === undefined) {
+                res.writeStatus("404 Not found");
+                this.addCorsHeaders(res);
+                res.end("Cannot find file");
+                return;
+            }
+
+            const readable = new Readable()
+            readable._read = () => {} // _read is required but you can noop it
+            readable.push(file.buffer);
+            readable.push(null);
+
+            const size = file.buffer.byteLength;
+
+            res.writeStatus("200 OK");
+
+            readable.on('data', buffer => {
+                const chunk = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength),
+                    lastOffset = res.getWriteOffset();
+
+                // First try
+                const [ok, done] = res.tryEnd(chunk, size);
+
+                if (done) {
+                    readable.destroy();
+                } else if (!ok) {
+                    // pause because backpressure
+                    readable.pause();
+
+                    // Save unsent chunk for later
+                    res.ab = chunk;
+                    res.abOffset = lastOffset;
+
+                    // Register async handlers for drainage
+                    res.onWritable(offset => {
+                        const [ok, done] = res.tryEnd(res.ab.slice(offset - res.abOffset), size);
+                        if (done) {
+                            readable.destroy();
+                        } else if (ok) {
+                            readable.resume();
+                        }
+                        return ok;
+                    });
+                }
+            });
+        });
+    }
+}

pusher/src/Controller/IoSocketController.ts

@@ -0,0 +1,334 @@
+import {CharacterLayer, ExSocketInterface} from "../Model/Websocket/ExSocketInterface"; //TODO fix import by "_Model/.."
+import {GameRoomPolicyTypes} from "../Model/PusherRoom";
+import {PointInterface} from "../Model/Websocket/PointInterface";
+import {
+    SetPlayerDetailsMessage,
+    SubMessage,
+    BatchMessage,
+    ItemEventMessage,
+    ViewportMessage,
+    ClientToServerMessage,
+    SilentMessage,
+    WebRtcSignalToServerMessage,
+    PlayGlobalMessage,
+    ReportPlayerMessage,
+    QueryJitsiJwtMessage
+} from "../Messages/generated/messages_pb";
+import {UserMovesMessage} from "../Messages/generated/messages_pb";
+import {TemplatedApp} from "uWebSockets.js"
+import {parse} from "query-string";
+import {jwtTokenManager} from "../Services/JWTTokenManager";
+import {adminApi, CharacterTexture, FetchMemberDataByUuidResponse} from "../Services/AdminApi";
+import {SocketManager, socketManager} from "../Services/SocketManager";
+import {emitInBatch} from "../Services/IoSocketHelpers";
+import {clientEventsEmitter} from "../Services/ClientEventsEmitter";
+import {ADMIN_API_TOKEN, ADMIN_API_URL, SOCKET_IDLE_TIMER} from "../Enum/EnvironmentVariable";
+import {Zone} from "_Model/Zone";
+
+export class IoSocketController {
+    private nextUserId: number = 1;
+
+    constructor(private readonly app: TemplatedApp) {
+        this.ioConnection();
+        this.adminRoomSocket();
+    }
+
+    adminRoomSocket() {
+        this.app.ws('/admin/rooms', {
+            upgrade: (res, req, context) => {
+                const query = parse(req.getQuery());
+                const websocketKey = req.getHeader('sec-websocket-key');
+                const websocketProtocol = req.getHeader('sec-websocket-protocol');
+                const websocketExtensions = req.getHeader('sec-websocket-extensions');
+                const token = query.token;
+                if (token !== ADMIN_API_TOKEN) {
+                    console.log('Admin access refused for token: '+token)
+                    res.writeStatus("401 Unauthorized").end('Incorrect token');
+                    return;
+                }
+                const roomId = query.roomId as string;
+
+                res.upgrade(
+                    {roomId},
+                    websocketKey, websocketProtocol, websocketExtensions, context,
+                    );
+            },
+            open: (ws) => {
+                console.log('Admin socket connect for room: '+ws.roomId);
+                ws.send('Data:'+JSON.stringify(socketManager.getAdminSocketDataFor(ws.roomId as string)));
+                ws.clientJoinCallback = (clientUUid: string, roomId: string) => {
+                    const wsroomId = ws.roomId as string;
+                    if(wsroomId === roomId) {
+                        ws.send('MemberJoin:'+clientUUid+';'+roomId);
+                    }
+                };
+                ws.clientLeaveCallback = (clientUUid: string, roomId: string) => {
+                    const wsroomId = ws.roomId as string;
+                    if(wsroomId === roomId) {
+                        ws.send('MemberLeave:'+clientUUid+';'+roomId);
+                    }
+                };
+                clientEventsEmitter.registerToClientJoin(ws.clientJoinCallback);
+                clientEventsEmitter.registerToClientLeave(ws.clientLeaveCallback);
+            },
+            message: (ws, arrayBuffer, isBinary): void => {
+                try {
+                    //TODO refactor message type and data
+                    const message: {event: string, message: {type: string, message: unknown, userUuid: string}} =
+                        JSON.parse(new TextDecoder("utf-8").decode(new Uint8Array(arrayBuffer)));
+
+                    if(message.event === 'user-message') {
+                        const messageToEmit = (message.message as { message: string, type: string, userUuid: string });
+                        switch (message.message.type) {
+                            case 'ban': {
+                                socketManager.emitSendUserMessage(messageToEmit);
+                                break;
+                            }
+                            case 'banned': {
+                                const socketUser = socketManager.emitSendUserMessage(messageToEmit);
+                                setTimeout(() => {
+                                    socketUser.close();
+                                }, 10000);
+                                break;
+                            }
+                            default: {
+                                break;
+                            }
+                        }
+                    }
+                }catch (err) {
+                    console.error(err);
+                }
+            },
+            close: (ws, code, message) => {
+                //todo make sure this code unregister the right listeners
+                clientEventsEmitter.unregisterFromClientJoin(ws.clientJoinCallback);
+                clientEventsEmitter.unregisterFromClientLeave(ws.clientLeaveCallback);
+            }
+        })
+    }
+
+    ioConnection() {
+        this.app.ws('/room', {
+            /* Options */
+            //compression: uWS.SHARED_COMPRESSOR,
+            idleTimeout: SOCKET_IDLE_TIMER,
+            maxPayloadLength: 16 * 1024 * 1024,
+            maxBackpressure: 65536, // Maximum 64kB of data in the buffer.
+            //idleTimeout: 10,
+            upgrade: (res, req, context) => {
+                //console.log('An Http connection wants to become WebSocket, URL: ' + req.getUrl() + '!');
+                (async () => {
+                    /* Keep track of abortions */
+                    const upgradeAborted = {aborted: false};
+
+                    res.onAborted(() => {
+                        /* We can simply signal that we were aborted */
+                        upgradeAborted.aborted = true;
+                    });
+
+                    try {
+                        const url = req.getUrl();
+                        const query = parse(req.getQuery());
+                        const websocketKey = req.getHeader('sec-websocket-key');
+                        const websocketProtocol = req.getHeader('sec-websocket-protocol');
+                        const websocketExtensions = req.getHeader('sec-websocket-extensions');
+
+                        const roomId = query.roomId;
+                        if (typeof roomId !== 'string') {
+                            throw new Error('Undefined room ID: ');
+                        }
+
+                        const token = query.token;
+                        const x = Number(query.x);
+                        const y = Number(query.y);
+                        const top = Number(query.top);
+                        const bottom = Number(query.bottom);
+                        const left = Number(query.left);
+                        const right = Number(query.right);
+                        const name = query.name;
+                        if (typeof name !== 'string') {
+                            throw new Error('Expecting name');
+                        }
+                        if (name === '') {
+                            throw new Error('No empty name');
+                        }
+                        let characterLayers = query.characterLayers;
+                        if (characterLayers === null) {
+                            throw new Error('Expecting skin');
+                        }
+                        if (typeof characterLayers === 'string') {
+                            characterLayers = [ characterLayers ];
+                        }
+
+                        const userUuid = await jwtTokenManager.getUserUuidFromToken(token);
+
+                        let memberTags: string[] = [];
+                        let memberTextures: CharacterTexture[] = [];
+                        const room = await socketManager.getOrCreateRoom(roomId);
+                        // TODO: make sure the room isFull is ported in the back part.
+                        /*if(room.isFull){
+                            throw new Error('Room is full');
+                        }*/
+                        if (ADMIN_API_URL) {
+                            try {
+                                const userData = await adminApi.fetchMemberDataByUuid(userUuid);
+                                //console.log('USERDATA', userData)
+                                memberTags = userData.tags;
+                                memberTextures = userData.textures;
+                                if (!room.anonymous && room.policyType === GameRoomPolicyTypes.USE_TAGS_POLICY && !room.canAccess(memberTags)) {
+                                    throw new Error('No correct tags')
+                                }
+                                //console.log('access granted for user '+userUuid+' and room '+roomId);
+                            } catch (e) {
+                                console.log('access not granted for user '+userUuid+' and room '+roomId);
+                                console.error(e);
+                                throw new Error('Client cannot acces this ressource.')
+                            }
+                        }
+
+                        // Generate characterLayers objects from characterLayers string[]
+                        const characterLayerObjs: CharacterLayer[] = SocketManager.mergeCharacterLayersAndCustomTextures(characterLayers, memberTextures);
+
+                        if (upgradeAborted.aborted) {
+                            console.log("Ouch! Client disconnected before we could upgrade it!");
+                            /* You must not upgrade now */
+                            return;
+                        }
+
+                        /* This immediately calls open handler, you must not use res after this call */
+                        res.upgrade({
+                                // Data passed here is accessible on the "websocket" socket object.
+                                url,
+                                token,
+                                userUuid,
+                                roomId,
+                                name,
+                                characterLayers: characterLayerObjs,
+                                tags: memberTags,
+                                textures: memberTextures,
+                                position: {
+                                    x: x,
+                                    y: y,
+                                    direction: 'down',
+                                    moving: false
+                                } as PointInterface,
+                                viewport: {
+                                    top,
+                                    right,
+                                    bottom,
+                                    left
+                                }
+                            },
+                            /* Spell these correctly */
+                            websocketKey,
+                            websocketProtocol,
+                            websocketExtensions,
+                            context);
+
+                    } catch (e) {
+                        if (e instanceof Error) {
+                            console.log(e.message);
+                            res.writeStatus("401 Unauthorized").end(e.message);
+                        } else {
+                            console.log(e);
+                            res.writeStatus("500 Internal Server Error").end('An error occurred');
+                        }
+                        return;
+                    }
+                })();
+            },
+            /* Handlers */
+            open: (ws) => {
+                // Let's join the room
+                const client = this.initClient(ws); //todo: into the upgrade instead?
+                socketManager.handleJoinRoom(client);
+
+                //get data information and show messages
+                if (ADMIN_API_URL) {
+                    adminApi.fetchMemberDataByUuid(client.userUuid).then((res: FetchMemberDataByUuidResponse) => {
+                        if (!res.messages) {
+                            return;
+                        }
+                        res.messages.forEach((c: unknown) => {
+                            const messageToSend = c as { type: string, message: string };
+                            socketManager.emitSendUserMessage({
+                                userUuid: client.userUuid,
+                                type: messageToSend.type,
+                                message: messageToSend.message
+                            })
+                        });
+                    }).catch((err) => {
+                        console.error('fetchMemberDataByUuid => err', err);
+                    });
+                }
+            },
+            message: (ws, arrayBuffer, isBinary): void => {
+                const client = ws as ExSocketInterface;
+                const message = ClientToServerMessage.deserializeBinary(new Uint8Array(arrayBuffer));
+
+                if (message.hasViewportmessage()) {
+                    socketManager.handleViewport(client, (message.getViewportmessage() as ViewportMessage).toObject());
+                } else if (message.hasUsermovesmessage()) {
+                    socketManager.handleUserMovesMessage(client, message.getUsermovesmessage() as UserMovesMessage);
+                } else if (message.hasSetplayerdetailsmessage()) {
+                    socketManager.handleSetPlayerDetails(client, message.getSetplayerdetailsmessage() as SetPlayerDetailsMessage);
+                } else if (message.hasSilentmessage()) {
+                    socketManager.handleSilentMessage(client, message.getSilentmessage() as SilentMessage);
+                } else if (message.hasItemeventmessage()) {
+                    socketManager.handleItemEvent(client, message.getItemeventmessage() as ItemEventMessage);
+                } else if (message.hasWebrtcsignaltoservermessage()) {
+                    socketManager.emitVideo(client, message.getWebrtcsignaltoservermessage() as WebRtcSignalToServerMessage);
+                } else if (message.hasWebrtcscreensharingsignaltoservermessage()) {
+                    socketManager.emitScreenSharing(client, message.getWebrtcscreensharingsignaltoservermessage() as WebRtcSignalToServerMessage);
+                } else if (message.hasPlayglobalmessage()) {
+                    socketManager.emitPlayGlobalMessage(client, message.getPlayglobalmessage() as PlayGlobalMessage);
+                } else if (message.hasReportplayermessage()){
+                    socketManager.handleReportMessage(client, message.getReportplayermessage() as ReportPlayerMessage);
+                } else if (message.hasQueryjitsijwtmessage()){
+                    socketManager.handleQueryJitsiJwtMessage(client, message.getQueryjitsijwtmessage() as QueryJitsiJwtMessage);
+                }
+
+                    /* Ok is false if backpressure was built up, wait for drain */
+                //let ok = ws.send(message, isBinary);
+            },
+            drain: (ws) => {
+                console.log('WebSocket backpressure: ' + ws.getBufferedAmount());
+            },
+            close: (ws, code, message) => {
+                const Client = (ws as ExSocketInterface);
+                try {
+                    Client.disconnecting = true;
+                    //leave room
+                    socketManager.leaveRoom(Client);
+                } catch (e) {
+                    console.error('An error occurred on "disconnect"');
+                    console.error(e);
+                }
+            }
+        })
+    }
+
+    //eslint-disable-next-line @typescript-eslint/no-explicit-any
+    private initClient(ws: any): ExSocketInterface {
+        const client : ExSocketInterface = ws;
+        client.userId = this.nextUserId;
+        this.nextUserId++;
+        client.userUuid = ws.userUuid;
+        client.token = ws.token;
+        client.batchedMessages = new BatchMessage();
+        client.batchTimeout = null;
+        client.emitInBatch = (payload: SubMessage): void => {
+            emitInBatch(client, payload);
+        }
+        client.disconnecting = false;
+
+        client.name = ws.name;
+        client.tags = ws.tags;
+        client.textures = ws.textures;
+        client.characterLayers = ws.characterLayers;
+        client.roomId = ws.roomId;
+        client.listenedZones = new Set<Zone>();
+        return client;
+    }
+}

pusher/src/Controller/MapController.ts

@@ -0,0 +1,73 @@
+import {OK} from "http-status-codes";
+import {URL_ROOM_STARTED} from "../Enum/EnvironmentVariable";
+import {HttpRequest, HttpResponse, TemplatedApp} from "uWebSockets.js";
+import {BaseController} from "./BaseController";
+import {parse} from "query-string";
+import {adminApi} from "../Services/AdminApi";
+
+//todo: delete this
+export class MapController extends BaseController{
+
+    constructor(private App : TemplatedApp) {
+        super();
+        this.App = App;
+        this.getMapUrl();
+    }
+
+
+    // Returns a map mapping map name to file name of the map
+    getMapUrl() {
+        this.App.options("/map", (res: HttpResponse, req: HttpRequest) => {
+            this.addCorsHeaders(res);
+
+            res.end();
+        });
+
+        this.App.get("/map", (res: HttpResponse, req: HttpRequest) => {
+
+            res.onAborted(() => {
+                console.warn('/map request was aborted');
+            })
+
+            const query = parse(req.getQuery());
+
+            if (typeof query.organizationSlug !== 'string') {
+                console.error('Expected organizationSlug parameter');
+                res.writeStatus("400 Bad request");
+                this.addCorsHeaders(res);
+                res.end("Expected organizationSlug parameter");
+                return;
+            }
+            if (typeof query.worldSlug !== 'string') {
+                console.error('Expected worldSlug parameter');
+                res.writeStatus("400 Bad request");
+                this.addCorsHeaders(res);
+                res.end("Expected worldSlug parameter");
+                return;
+            }
+            if (typeof query.roomSlug !== 'string' && query.roomSlug !== undefined) {
+                console.error('Expected only one roomSlug parameter');
+                res.writeStatus("400 Bad request");
+                this.addCorsHeaders(res);
+                res.end("Expected only one roomSlug parameter");
+                return;
+            }
+
+            (async () => {
+                try {
+                    const mapDetails = await adminApi.fetchMapDetails(query.organizationSlug as string, query.worldSlug as string, query.roomSlug as string|undefined);
+
+                    res.writeStatus("200 OK");
+                    this.addCorsHeaders(res);
+                    res.end(JSON.stringify(mapDetails));
+                } catch (e) {
+                    console.error(e.message || e);
+                    res.writeStatus("500 Internal Server Error")
+                    this.addCorsHeaders(res);
+                    res.end("An error occurred");
+                }
+            })();
+
+        });
+    }
+}

pusher/src/Controller/PrometheusController.ts

@@ -0,0 +1,20 @@
+import {App} from "../Server/sifrr.server";
+import {HttpRequest, HttpResponse} from "uWebSockets.js";
+const register = require('prom-client').register;
+const collectDefaultMetrics = require('prom-client').collectDefaultMetrics;
+
+export class PrometheusController {
+    constructor(private App: App) {
+        collectDefaultMetrics({
+            timeout: 10000,
+            gcDurationBuckets: [0.001, 0.01, 0.1, 1, 2, 5], // These are the default buckets.
+        });
+
+        this.App.get("/metrics", this.metrics.bind(this));
+    }
+
+    private metrics(res: HttpResponse, req: HttpRequest): void {
+        res.writeHeader('Content-Type', register.contentType);
+        res.end(register.metrics());
+    }
+}

pusher/src/Enum/EnvironmentVariable.ts

@@ -0,0 +1,30 @@
+const SECRET_KEY = process.env.SECRET_KEY || "THECODINGMACHINE_SECRET_KEY";
+const URL_ROOM_STARTED = "/Floor0/floor0.json";
+const MINIMUM_DISTANCE = process.env.MINIMUM_DISTANCE ? Number(process.env.MINIMUM_DISTANCE) : 64;
+const GROUP_RADIUS = process.env.GROUP_RADIUS ? Number(process.env.GROUP_RADIUS) : 48;
+const ALLOW_ARTILLERY = process.env.ALLOW_ARTILLERY ? process.env.ALLOW_ARTILLERY == 'true' : false;
+const API_URL = process.env.API_URL || '';
+const ADMIN_API_URL = process.env.ADMIN_API_URL || '';
+const ADMIN_API_TOKEN = process.env.ADMIN_API_TOKEN || 'myapitoken';
+const MAX_USERS_PER_ROOM = parseInt(process.env.MAX_USERS_PER_ROOM || '') || 600;
+const CPU_OVERHEAT_THRESHOLD = Number(process.env.CPU_OVERHEAT_THRESHOLD) || 80;
+const JITSI_URL : string|undefined = (process.env.JITSI_URL === '') ? undefined : process.env.JITSI_URL;
+const JITSI_ISS = process.env.JITSI_ISS || '';
+const SECRET_JITSI_KEY = process.env.SECRET_JITSI_KEY || '';
+export const SOCKET_IDLE_TIMER = parseInt(process.env.SOCKET_IDLE_TIMER as string) || 30; // maximum time (in second) without activity before a socket is closed
+
+export {
+    SECRET_KEY,
+    URL_ROOM_STARTED,
+    MINIMUM_DISTANCE,
+    API_URL,
+    ADMIN_API_URL,
+    ADMIN_API_TOKEN,
+    MAX_USERS_PER_ROOM,
+    GROUP_RADIUS,
+    ALLOW_ARTILLERY,
+    CPU_OVERHEAT_THRESHOLD,
+    JITSI_URL,
+    JITSI_ISS,
+    SECRET_JITSI_KEY
+}

pusher/src/Messages/.gitignore

@@ -0,0 +1 @@
+/generated/

pusher/src/Model/Distance.ts

@@ -0,0 +1,7 @@
+import {MessageUserPosition} from "../Model/Websocket/MessageUserPosition";
+
+export interface Distance {
+    distance: number,
+    first: MessageUserPosition,
+    second: MessageUserPosition,
+}

pusher/src/Model/Group.ts

@@ -0,0 +1,138 @@
+import { ConnectCallback, DisconnectCallback } from "./PusherRoom";
+import { User } from "./User";
+import {PositionInterface} from "_Model/PositionInterface";
+import {Movable} from "_Model/Movable";
+import {PositionDispatcher} from "_Model/PositionDispatcher";
+import {gaugeManager} from "../Services/GaugeManager";
+
+export class Group implements Movable {
+    static readonly MAX_PER_GROUP = 4;
+
+    private static nextId: number = 1;
+
+    private id: number;
+    private users: Set<User>;
+    private x!: number;
+    private y!: number;
+    private hasEditedGauge: boolean = false;
+    private wasDestroyed: boolean = false;
+    private roomId: string;
+
+
+    constructor(roomId: string, users: User[], private connectCallback: ConnectCallback, private disconnectCallback: DisconnectCallback, private positionNotifier: PositionDispatcher) {
+        this.roomId = roomId;
+        this.users = new Set<User>();
+        this.id = Group.nextId;
+        Group.nextId++;
+        //we only send a event for prometheus metrics if the group lives more than 5 seconds
+        setTimeout(() => {
+            if (!this.wasDestroyed) {
+                this.hasEditedGauge = true;
+                gaugeManager.incNbGroupsPerRoomGauge(roomId);
+            }
+        }, 5000);
+
+        users.forEach((user: User) => {
+            this.join(user);
+        });
+
+        this.updatePosition();
+    }
+
+    getUsers(): User[] {
+        return Array.from(this.users.values());
+    }
+
+    getId() : number {
+        return this.id;
+    }
+
+    /**
+     * Returns the barycenter of all users (i.e. the center of the group)
+     */
+    getPosition(): PositionInterface {
+        return {
+            x: this.x,
+            y: this.y
+        };
+    }
+
+    /**
+     * Computes the barycenter of all users (i.e. the center of the group)
+     */
+    updatePosition(): void {
+        const oldX = this.x;
+        const oldY = this.y;
+
+        let x = 0;
+        let y = 0;
+        // Let's compute the barycenter of all users.
+        this.users.forEach((user: User) => {
+            const position = user.getPosition();
+            x += position.x;
+            y += position.y;
+        });
+        x /= this.users.size;
+        y /= this.users.size;
+        if (this.users.size === 0) {
+            throw new Error("EMPTY GROUP FOUND!!!");
+        }
+        this.x = x;
+        this.y = y;
+
+        if (oldX === undefined) {
+            this.positionNotifier.enter(this);
+        } else {
+            this.positionNotifier.updatePosition(this, {x, y}, {x: oldX, y: oldY});
+        }
+    }
+
+    isFull(): boolean {
+        return this.users.size >= Group.MAX_PER_GROUP;
+    }
+
+    isEmpty(): boolean {
+        return this.users.size <= 1;
+    }
+
+    join(user: User): void
+    {
+        // Broadcast on the right event
+        this.connectCallback(user, this);
+        this.users.add(user);
+        user.group = this;
+    }
+
+    leave(user: User): void
+    {
+        const success = this.users.delete(user);
+        if (success === false) {
+            throw new Error("Could not find user "+user.id+" in the group "+this.id);
+        }
+        user.group = undefined;
+
+        if (this.users.size !== 0) {
+            this.updatePosition();
+        }
+
+        // Broadcast on the right event
+        this.disconnectCallback(user, this);
+    }
+
+    /**
+     * Let's kick everybody out.
+     * Usually used when there is only one user left.
+     */
+    destroy(): void
+    {
+        if (this.hasEditedGauge) gaugeManager.decNbGroupsPerRoomGauge(this.roomId);
+        for (const user of this.users) {
+            this.leave(user);
+        }
+        this.wasDestroyed = true;
+    }
+
+    get getSize(){
+        return this.users.size;
+    }
+}

pusher/src/Model/Movable.ts

@@ -0,0 +1,8 @@
+import {PositionInterface} from "_Model/PositionInterface";
+
+/**
+ * A physical object that can be placed into a Zone
+ */
+export interface Movable {
+    getPosition(): PositionInterface
+}

pusher/src/Model/PositionDispatcher.ts

@@ -0,0 +1,120 @@
+/**
+ * Tracks the position of every player on the map, and sends notifications to the players interested in knowing about the move
+ * (i.e. players that are looking at the zone the player is currently in)
+ *
+ * Internally, the PositionNotifier works with Zones. A zone is a square area of a map.
+ * Each player is in a given zone, and each player tracks one or many zones (depending on the player viewport)
+ *
+ * The PositionNotifier is important for performance. It allows us to send the position of players only to a restricted
+ * number of players around the current player.
+ */
+import {Zone, ZoneEventListener} from "./Zone";
+import {ViewportInterface} from "_Model/Websocket/ViewportMessage";
+import {ExSocketInterface} from "_Model/Websocket/ExSocketInterface";
+//import Debug from "debug";
+
+//const debug = Debug('positiondispatcher');
+
+interface ZoneDescriptor {
+    i: number;
+    j: number;
+}
+
+export class PositionDispatcher {
+
+    // TODO: we need a way to clean the zones if noone is in the zone and noone listening (to free memory!)
+
+    private zones: Zone[][] = [];
+
+    constructor(public readonly roomId: string, private zoneWidth: number, private zoneHeight: number, private socketListener: ZoneEventListener) {
+    }
+
+    private getZoneDescriptorFromCoordinates(x: number, y: number): ZoneDescriptor {
+        return {
+            i: Math.floor(x / this.zoneWidth),
+            j: Math.floor(y / this.zoneHeight),
+        }
+    }
+
+    /**
+     * Sets the viewport coordinates.
+     */
+    public setViewport(socket: ExSocketInterface, viewport: ViewportInterface): void {
+        if (viewport.left > viewport.right || viewport.top > viewport.bottom) {
+            console.warn('Invalid viewport received: ', viewport);
+            return;
+        }
+
+        const oldZones = socket.listenedZones;
+        const newZones = new Set<Zone>();
+
+        const topLeftDesc = this.getZoneDescriptorFromCoordinates(viewport.left, viewport.top);
+        const bottomRightDesc = this.getZoneDescriptorFromCoordinates(viewport.right, viewport.bottom);
+
+        for (let j = topLeftDesc.j; j <= bottomRightDesc.j; j++) {
+            for (let i = topLeftDesc.i; i <= bottomRightDesc.i; i++) {
+                newZones.add(this.getZone(i, j));
+            }
+        }
+
+        const addedZones = [...newZones].filter(x => !oldZones.has(x));
+        const removedZones = [...oldZones].filter(x => !newZones.has(x));
+
+        for (const zone of addedZones) {
+            zone.startListening(socket);
+        }
+        for (const zone of removedZones) {
+            this.stopListening(zone, socket);
+        }
+    }
+
+    private stopListening(zone: Zone, socket: ExSocketInterface): void {
+        zone.stopListening(socket);
+        if (!zone.hasListeners()) {
+            zone.close();
+            this.deleteZone(zone);
+        }
+    }
+
+    /**
+     * Removes the zone from the dispatcher.
+     * Warning, zone is not closed by this method.
+     */
+    private deleteZone(zone: Zone): void {
+        delete this.zones[zone.y][zone.x];
+        if (Object.keys(this.zones[zone.y]).length === 0) {
+            delete this.zones[zone.y];
+        }
+    }
+
+    public removeViewport(socket: ExSocketInterface): void {
+        // Also, let's stop listening on viewports
+        for (const zone of socket.listenedZones) {
+            this.stopListening(zone, socket);
+        }
+    }
+
+    public isEmpty(): boolean {
+        return Object.keys(this.zones).length === 0;
+    }
+
+    private getZone(i: number, j: number): Zone {
+        let zoneRow = this.zones[j];
+        if (zoneRow === undefined) {
+            zoneRow = new Array<Zone>();
+            this.zones[j] = zoneRow;
+        }
+
+        let zone = this.zones[j][i];
+        if (zone === undefined) {
+            zone = new Zone(this, this.socketListener, i, j, (e, myZone) => {
+                // On failure, we delete the zone from the dispatcher so it can be recreated later.
+                this.deleteZone(myZone);
+                // TODO: we should check if the position dispatcher is still containing a room and propagate the onFailure to the parent if it is empty.
+            });
+            zone.init();
+            this.zones[j][i] = zone;
+        }
+        return zone;
+    }
+}

pusher/src/Model/PositionInterface.ts

@@ -0,0 +1,4 @@
+export interface PositionInterface {
+    x: number,
+    y: number
+}

pusher/src/Model/PusherRoom.ts

@@ -0,0 +1,68 @@
+import {PointInterface} from "./Websocket/PointInterface";
+import {Group} from "./Group";
+import {User} from "./User";
+import {ExSocketInterface} from "_Model/Websocket/ExSocketInterface";
+import {PositionInterface} from "_Model/PositionInterface";
+import {Identificable} from "_Model/Websocket/Identificable";
+import {PositionDispatcher} from "./PositionDispatcher";
+import {ViewportInterface} from "_Model/Websocket/ViewportMessage";
+import {Movable} from "_Model/Movable";
+import {extractDataFromPrivateRoomId, extractRoomSlugPublicRoomId, isRoomAnonymous} from "./RoomIdentifier";
+import {arrayIntersect} from "../Services/ArrayHelper";
+import {MAX_USERS_PER_ROOM} from "../Enum/EnvironmentVariable";
+import {ZoneEventListener} from "_Model/Zone";
+
+export type ConnectCallback = (user: User, group: Group) => void;
+export type DisconnectCallback = (user: User, group: Group) => void;
+
+export enum GameRoomPolicyTypes {
+    ANONYMUS_POLICY = 1,
+    MEMBERS_ONLY_POLICY,
+    USE_TAGS_POLICY,
+}
+
+export class PusherRoom {
+    private readonly positionNotifier: PositionDispatcher;
+    public readonly anonymous: boolean;
+    public tags: string[];
+    public policyType: GameRoomPolicyTypes;
+    public readonly roomSlug: string;
+    public readonly worldSlug: string = '';
+    public readonly organizationSlug: string = '';
+
+    constructor(public readonly roomId: string,
+                private socketListener: ZoneEventListener)
+    {
+        this.anonymous = isRoomAnonymous(roomId);
+        this.tags = [];
+        this.policyType = GameRoomPolicyTypes.ANONYMUS_POLICY;
+
+        if (this.anonymous) {
+            this.roomSlug = extractRoomSlugPublicRoomId(this.roomId);
+        } else {
+            const {organizationSlug, worldSlug, roomSlug} = extractDataFromPrivateRoomId(this.roomId);
+            this.roomSlug = roomSlug;
+            this.organizationSlug = organizationSlug;
+            this.worldSlug = worldSlug;
+        }
+
+        // A zone is 10 sprites wide.
+        this.positionNotifier = new PositionDispatcher(this.roomId, 320, 320, this.socketListener);
+    }
+
+    public setViewport(socket : ExSocketInterface, viewport: ViewportInterface): void {
+        this.positionNotifier.setViewport(socket, viewport);
+    }
+
+    public leave(socket : ExSocketInterface){
+        this.positionNotifier.removeViewport(socket);
+    }
+
+    public canAccess(userTags: string[]): boolean {
+        return arrayIntersect(userTags, this.tags);
+    }
+
+    public isEmpty(): boolean {
+        return this.positionNotifier.isEmpty();
+    }
+}

pusher/src/Model/RoomIdentifier.ts

@@ -0,0 +1,30 @@
+//helper functions to parse room IDs
+
+export const isRoomAnonymous = (roomID: string): boolean => {
+    if (roomID.startsWith('_/')) {
+        return true;
+    } else if(roomID.startsWith('@/')) {
+        return false;
+    } else {
+        throw new Error('Incorrect room ID: '+roomID);
+    }
+}
+
+export const extractRoomSlugPublicRoomId = (roomId: string): string => {
+    const idParts = roomId.split('/');
+    if (idParts.length < 3) throw new Error('Incorrect roomId: '+roomId);
+    return idParts.slice(2).join('/');
+}
+export interface extractDataFromPrivateRoomIdResponse {
+    organizationSlug: string;
+    worldSlug: string;
+    roomSlug: string;
+}
+export const extractDataFromPrivateRoomId = (roomId: string): extractDataFromPrivateRoomIdResponse => {
+    const idParts = roomId.split('/');
+    if (idParts.length < 4) throw new Error('Incorrect roomId: '+roomId);
+    const organizationSlug = idParts[1];
+    const worldSlug = idParts[2];
+    const roomSlug = idParts[3];
+    return {organizationSlug, worldSlug, roomSlug}
+}

pusher/src/Model/User.ts

@@ -0,0 +1,35 @@
+import { Group } from "./Group";
+import { PointInterface } from "./Websocket/PointInterface";
+import {Zone} from "_Model/Zone";
+import {Movable} from "_Model/Movable";
+import {PositionInterface} from "_Model/PositionInterface";
+import {PositionDispatcher} from "_Model/PositionDispatcher";
+import {ExSocketInterface} from "_Model/Websocket/ExSocketInterface";
+
+export class User implements Movable {
+    public listenedZones: Set<Zone>;
+    public group?: Group;
+
+    public constructor(
+        public id: number,
+        public uuid: string,
+        private position: PointInterface,
+        public silent: boolean,
+        private positionNotifier: PositionDispatcher,
+        public readonly socket: ExSocketInterface
+    ) {
+        this.listenedZones = new Set<Zone>();
+
+        this.positionNotifier.enter(this);
+    }
+
+    public getPosition(): PointInterface {
+        return this.position;
+    }
+
+    public setPosition(position: PointInterface): void {
+        const oldPosition = this.position;
+        this.position = position;
+        this.positionNotifier.updatePosition(this, position, oldPosition);
+    }
+}

pusher/src/Model/Websocket/ExSocketInterface.ts

@@ -0,0 +1,42 @@
+import {PointInterface} from "./PointInterface";
+import {Identificable} from "./Identificable";
+import {ViewportInterface} from "_Model/Websocket/ViewportMessage";
+import {
+    BatchMessage,
+    PusherToBackMessage,
+    ServerToClientMessage,
+    SubMessage
+} from "../../Messages/generated/messages_pb";
+import {WebSocket} from "uWebSockets.js"
+import {CharacterTexture} from "../../Services/AdminApi";
+import {ClientDuplexStream} from "grpc";
+import {Zone} from "_Model/Zone";
+
+export type BackConnection = ClientDuplexStream<PusherToBackMessage, ServerToClientMessage>;
+
+export interface CharacterLayer {
+    name: string,
+    url: string|undefined
+}
+
+export interface ExSocketInterface extends WebSocket, Identificable {
+    token: string;
+    roomId: string;
+    //userId: number;   // A temporary (autoincremented) identifier for this user
+    userUuid: string; // A unique identifier for this user
+    name: string;
+    characterLayers: CharacterLayer[];
+    position: PointInterface;
+    viewport: ViewportInterface;
+    /**
+     * Pushes an event that will be sent in the next batch of events
+     */
+    emitInBatch: (payload: SubMessage) => void;
+    batchedMessages: BatchMessage;
+    batchTimeout: NodeJS.Timeout|null;
+    disconnecting: boolean,
+    tags: string[],
+    textures: CharacterTexture[],
+    backConnection: BackConnection,
+    listenedZones: Set<Zone>;
+}

pusher/src/Model/Websocket/GroupUpdateInterface.ts

@@ -0,0 +1,6 @@
+import {PositionInterface} from "_Model/PositionInterface";
+
+export interface GroupUpdateInterface {
+    position: PositionInterface,
+    groupId: number,
+}

pusher/src/Model/Websocket/Identificable.ts

@@ -0,0 +1,3 @@
+export interface Identificable {
+    userId: number;
+}

pusher/src/Model/Websocket/ItemEventMessage.ts

@@ -0,0 +1,10 @@
+import * as tg from "generic-type-guard";
+
+export const isItemEventMessageInterface =
+    new tg.IsInterface().withProperties({
+        itemId: tg.isNumber,
+        event: tg.isString,
+        state: tg.isUnknown,
+        parameters: tg.isUnknown,
+    }).get();
+export type ItemEventMessageInterface = tg.GuardedType<typeof isItemEventMessageInterface>;

pusher/src/Model/Websocket/JoinRoomMessage.ts

@@ -0,0 +1,11 @@
+import * as tg from "generic-type-guard";
+import {isPointInterface} from "./PointInterface";
+import {isViewport} from "./ViewportMessage";
+
+export const isJoinRoomMessageInterface =
+    new tg.IsInterface().withProperties({
+        roomId: tg.isString,
+        position: isPointInterface,
+        viewport: isViewport
+    }).get();
+export type JoinRoomMessageInterface = tg.GuardedType<typeof isJoinRoomMessageInterface>;

pusher/src/Model/Websocket/MessageUserJoined.ts

@@ -0,0 +1,6 @@
+import {PointInterface} from "_Model/Websocket/PointInterface";
+
+export class MessageUserJoined {
+    constructor(public userId: number, public name: string, public characterLayers: string[], public position: PointInterface) {
+    }
+}

pusher/src/Model/Websocket/MessageUserPosition.ts

@@ -0,0 +1,11 @@
+import {PointInterface} from "./PointInterface";
+
+export class Point implements PointInterface{
+    constructor(public x : number, public y : number, public direction : string = "none", public moving : boolean = false) {
+    }
+}
+
+export class MessageUserPosition {
+    constructor(public userId: number, public name: string, public characterLayers: string[], public position: PointInterface) {
+    }
+}

pusher/src/Model/Websocket/PointInterface.ts

@@ -0,0 +1,17 @@
+import * as tg from "generic-type-guard";
+
+/*export interface PointInterface {
+    readonly x: number;
+    readonly y: number;
+    readonly direction: string;
+    readonly moving: boolean;
+}*/
+
+export const isPointInterface =
+    new tg.IsInterface().withProperties({
+        x: tg.isNumber,
+        y: tg.isNumber,
+        direction: tg.isString,
+        moving: tg.isBoolean
+    }).get();
+export type PointInterface = tg.GuardedType<typeof isPointInterface>;

pusher/src/Model/Websocket/ProtobufUtils.ts

@@ -0,0 +1,108 @@
+import {PointInterface} from "./PointInterface";
+import {
+    CharacterLayerMessage,
+    ItemEventMessage,
+    PointMessage,
+    PositionMessage
+} from "../../Messages/generated/messages_pb";
+import {CharacterLayer, ExSocketInterface} from "_Model/Websocket/ExSocketInterface";
+import Direction = PositionMessage.Direction;
+import {ItemEventMessageInterface} from "_Model/Websocket/ItemEventMessage";
+import {PositionInterface} from "_Model/PositionInterface";
+
+export class ProtobufUtils {
+
+    public static toPositionMessage(point: PointInterface): PositionMessage {
+        let direction: Direction;
+        switch (point.direction) {
+            case 'up':
+                direction = Direction.UP;
+                break;
+            case 'down':
+                direction = Direction.DOWN;
+                break;
+            case 'left':
+                direction = Direction.LEFT;
+                break;
+            case 'right':
+                direction = Direction.RIGHT;
+                break;
+            default:
+                throw new Error('unexpected direction');
+        }
+
+        const position = new PositionMessage();
+        position.setX(point.x);
+        position.setY(point.y);
+        position.setMoving(point.moving);
+        position.setDirection(direction);
+
+        return position;
+    }
+
+    public static toPointInterface(position: PositionMessage): PointInterface {
+        let direction: string;
+        switch (position.getDirection()) {
+            case Direction.UP:
+                direction = 'up';
+                break;
+            case Direction.DOWN:
+                direction = 'down';
+                break;
+            case Direction.LEFT:
+                direction = 'left';
+                break;
+            case Direction.RIGHT:
+                direction = 'right';
+                break;
+            default:
+                throw new Error("Unexpected direction");
+        }
+
+        // sending to all clients in room except sender
+        return {
+            x: position.getX(),
+            y: position.getY(),
+            direction,
+            moving: position.getMoving(),
+        };
+    }
+
+    public static toPointMessage(point: PositionInterface): PointMessage {
+        const position = new PointMessage();
+        position.setX(Math.floor(point.x));
+        position.setY(Math.floor(point.y));
+
+        return position;
+    }
+
+    public static toItemEvent(itemEventMessage: ItemEventMessage): ItemEventMessageInterface {
+        return {
+            itemId: itemEventMessage.getItemid(),
+            event: itemEventMessage.getEvent(),
+            parameters: JSON.parse(itemEventMessage.getParametersjson()),
+            state: JSON.parse(itemEventMessage.getStatejson()),
+        }
+    }
+
+    public static toItemEventProtobuf(itemEvent: ItemEventMessageInterface): ItemEventMessage {
+        const itemEventMessage = new ItemEventMessage();
+        itemEventMessage.setItemid(itemEvent.itemId);
+        itemEventMessage.setEvent(itemEvent.event);
+        itemEventMessage.setParametersjson(JSON.stringify(itemEvent.parameters));
+        itemEventMessage.setStatejson(JSON.stringify(itemEvent.state));
+
+        return itemEventMessage;
+    }
+
+    public static toCharacterLayerMessages(characterLayers: CharacterLayer[]): CharacterLayerMessage[] {
+        return characterLayers.map(function(characterLayer): CharacterLayerMessage {
+            const message = new CharacterLayerMessage();
+            message.setName(characterLayer.name);
+            if (characterLayer.url) {
+                message.setUrl(characterLayer.url);
+            }
+            return message;
+        });
+    }
+}

pusher/src/Model/Websocket/SetPlayerDetailsMessage.ts

@@ -0,0 +1,8 @@
+import * as tg from "generic-type-guard";
+
+export const isSetPlayerDetailsMessage =
+    new tg.IsInterface().withProperties({
+        name: tg.isString,
+        characterLayers: tg.isArray(tg.isString)
+    }).get();
+export type SetPlayerDetailsMessage = tg.GuardedType<typeof isSetPlayerDetailsMessage>;

pusher/src/Model/Websocket/UserInGroupInterface.ts

@@ -0,0 +1,5 @@
+export interface UserInGroupInterface {
+    userId: number,
+    name: string,
+    initiator: boolean
+}

pusher/src/Model/Websocket/ViewportMessage.ts

@@ -0,0 +1,10 @@
+import * as tg from "generic-type-guard";
+
+export const isViewport =
+    new tg.IsInterface().withProperties({
+        left: tg.isNumber,
+        top: tg.isNumber,
+        right: tg.isNumber,
+        bottom: tg.isNumber,
+    }).get();
+export type ViewportInterface = tg.GuardedType<typeof isViewport>;

pusher/src/Model/Websocket/WebRtcSignalMessage.ts

@@ -0,0 +1,18 @@
+import * as tg from "generic-type-guard";
+
+export const isSignalData =
+    new tg.IsInterface().withProperties({
+        type: tg.isOptional(tg.isString)
+    }).get();
+
+export const isWebRtcSignalMessageInterface =
+    new tg.IsInterface().withProperties({
+        receiverId: tg.isNumber,
+        signal: isSignalData
+    }).get();
+export const isWebRtcScreenSharingStartMessageInterface =
+    new tg.IsInterface().withProperties({
+        userId: tg.isNumber,
+        roomId: tg.isString
+    }).get();
+export type WebRtcSignalMessageInterface = tg.GuardedType<typeof isWebRtcSignalMessageInterface>;

pusher/src/Model/Zone.ts

@@ -0,0 +1,333 @@
+import {ExSocketInterface} from "./Websocket/ExSocketInterface";
+import {apiClientRepository} from "../Services/ApiClientRepository";
+import {
+    BatchToPusherMessage,
+    CharacterLayerMessage, GroupLeftZoneMessage, GroupUpdateMessage, GroupUpdateZoneMessage,
+    PointMessage, PositionMessage, UserJoinedMessage,
+    UserJoinedZoneMessage, UserLeftZoneMessage, UserMovedMessage,
+    ZoneMessage
+} from "../Messages/generated/messages_pb";
+import * as messages_pb from "../Messages/generated/messages_pb";
+import {ClientReadableStream} from "grpc";
+import {PositionDispatcher} from "_Model/PositionDispatcher";
+import {socketManager} from "../Services/SocketManager";
+import {ProtobufUtils} from "_Model/Websocket/ProtobufUtils";
+import Debug from "debug";
+
+const debug = Debug("zone");
+
+export interface ZoneEventListener {
+    onUserEnters(user: UserDescriptor, listener: ExSocketInterface): void;
+    onUserMoves(user: UserDescriptor, listener: ExSocketInterface): void;
+    onUserLeaves(userId: number, listener: ExSocketInterface): void;
+    onGroupEnters(group: GroupDescriptor, listener: ExSocketInterface): void;
+    onGroupMoves(group: GroupDescriptor, listener: ExSocketInterface): void;
+    onGroupLeaves(groupId: number, listener: ExSocketInterface): void;
+}
+
+/*export type EntersCallback = (thing: Movable, listener: User) => void;
+export type MovesCallback = (thing: Movable, position: PositionInterface, listener: User) => void;
+export type LeavesCallback = (thing: Movable, listener: User) => void;*/
+
+export class UserDescriptor {
+    private constructor(public readonly userId: number, private name: string, private characterLayers: CharacterLayerMessage[], private position: PositionMessage) {
+        if (!Number.isInteger(this.userId)) {
+            throw new Error('UserDescriptor.userId is not an integer: '+this.userId);
+        }
+    }
+
+    public static createFromUserJoinedZoneMessage(message: UserJoinedZoneMessage): UserDescriptor {
+        const position = message.getPosition();
+        if (position === undefined) {
+            throw new Error('Missing position');
+        }
+        return new UserDescriptor(message.getUserid(), message.getName(), message.getCharacterlayersList(), position);
+    }
+
+    public update(userMovedMessage: UserMovedMessage) {
+        const position = userMovedMessage.getPosition();
+        if (position === undefined) {
+            throw new Error('Missing position');
+        }
+        this.position = position;
+    }
+
+    public toUserJoinedMessage(): UserJoinedMessage {
+        const userJoinedMessage = new UserJoinedMessage();
+
+        userJoinedMessage.setUserid(this.userId);
+        userJoinedMessage.setName(this.name);
+        userJoinedMessage.setCharacterlayersList(this.characterLayers);
+        userJoinedMessage.setPosition(this.position);
+
+        return userJoinedMessage;
+    }
+
+    public toUserMovedMessage(): UserMovedMessage {
+        const userMovedMessage = new UserMovedMessage();
+
+        userMovedMessage.setUserid(this.userId);
+        userMovedMessage.setPosition(this.position);
+
+        return userMovedMessage;
+    }
+}
+
+export class GroupDescriptor {
+    private constructor(public readonly groupId: number, private groupSize: number, private position: PointMessage) {
+    }
+
+    public static createFromGroupUpdateZoneMessage(message: GroupUpdateZoneMessage): GroupDescriptor {
+        const position = message.getPosition();
+        if (position === undefined) {
+            throw new Error('Missing position');
+        }
+        return new GroupDescriptor(message.getGroupid(), message.getGroupsize(), position);
+    }
+
+    public update(groupDescriptor: GroupDescriptor) {
+        this.groupSize = groupDescriptor.groupSize;
+        this.position = groupDescriptor.position;
+    }
+
+    public toGroupUpdateMessage(): GroupUpdateMessage {
+        const groupUpdateMessage = new GroupUpdateMessage();
+        if (!Number.isInteger(this.groupId)) {
+            throw new Error('GroupDescriptor.groupId is not an integer: '+this.groupId);
+        }
+        groupUpdateMessage.setGroupid(this.groupId);
+        groupUpdateMessage.setGroupsize(this.groupSize);
+        groupUpdateMessage.setPosition(this.position);
+
+        return groupUpdateMessage;
+    }
+}
+
+interface ZoneDescriptor {
+    x: number,
+    y: number
+}
+
+export class Zone {
+    //private things: Set<Movable> = new Set<Movable>();
+    private users: Map<number, UserDescriptor> = new Map<number, UserDescriptor>();
+    private groups: Map<number, GroupDescriptor> = new Map<number, GroupDescriptor>();
+    private listeners: Set<ExSocketInterface> = new Set<ExSocketInterface>();
+    private backConnection!: ClientReadableStream<BatchToPusherMessage>;
+    private isClosing: boolean = false;
+
+    constructor(private positionDispatcher: PositionDispatcher, private socketListener: ZoneEventListener, public readonly x: number, public readonly y: number, private onBackFailure: (e: Error|null, zone: Zone) => void) {
+    }
+
+    /**
+     * Creates a connection to the back server to track the users.
+     */
+    public async init(): Promise<void> {
+        debug('Opening connection to zone %d, %d on back server', this.x, this.y);
+        const apiClient = await apiClientRepository.getClient(this.positionDispatcher.roomId);
+        const zoneMessage = new ZoneMessage();
+        zoneMessage.setRoomid(this.positionDispatcher.roomId);
+        zoneMessage.setX(this.x);
+        zoneMessage.setY(this.y);
+        this.backConnection = apiClient.listenZone(zoneMessage);
+        this.backConnection.on('data', (batch: BatchToPusherMessage) => {
+            for (const message of batch.getPayloadList()) {
+                if (message.hasUserjoinedzonemessage()) {
+                    const userJoinedZoneMessage = message.getUserjoinedzonemessage() as UserJoinedZoneMessage;
+                    const userDescriptor = UserDescriptor.createFromUserJoinedZoneMessage(userJoinedZoneMessage);
+                    this.users.set(userJoinedZoneMessage.getUserid(), userDescriptor);
+
+                    const fromZone = userJoinedZoneMessage.getFromzone();
+
+                    this.notifyUserEnter(userDescriptor, fromZone?.toObject());
+                } else if (message.hasGroupupdatezonemessage()) {
+                    const groupUpdateZoneMessage = message.getGroupupdatezonemessage() as GroupUpdateZoneMessage;
+                    const groupDescriptor = GroupDescriptor.createFromGroupUpdateZoneMessage(groupUpdateZoneMessage);
+
+                    // Do we have it already?
+                    const groupId = groupUpdateZoneMessage.getGroupid();
+                    const oldGroupDescriptor = this.groups.get(groupId);
+                    if (oldGroupDescriptor !== undefined) {
+                        oldGroupDescriptor.update(groupDescriptor);
+
+                        this.notifyGroupMove(groupDescriptor);
+                    } else {
+                        this.groups.set(groupId, groupDescriptor);
+
+                        const fromZone = groupUpdateZoneMessage.getFromzone();
+
+                        this.notifyGroupEnter(groupDescriptor, fromZone?.toObject());
+                    }
+                } else if (message.hasUserleftzonemessage()) {
+                    const userLeftMessage = message.getUserleftzonemessage() as UserLeftZoneMessage;
+                    this.users.delete(userLeftMessage.getUserid());
+
+                    this.notifyUserLeft(userLeftMessage.getUserid(), userLeftMessage.getTozone()?.toObject());
+                } else if (message.hasGroupleftzonemessage()) {
+                    const groupLeftMessage = message.getGroupleftzonemessage() as GroupLeftZoneMessage;
+                    this.groups.delete(groupLeftMessage.getGroupid());
+
+                    this.notifyGroupLeft(groupLeftMessage.getGroupid(), groupLeftMessage.getTozone()?.toObject());
+                } else if (message.hasUsermovedmessage()) {
+                    const userMovedMessage = message.getUsermovedmessage() as UserMovedMessage;
+
+                    const userId = userMovedMessage.getUserid();
+                    const userDescriptor = this.users.get(userId);
+
+                    if (userDescriptor === undefined) {
+                        console.error('Unexpected move message received for user "'+userId+'"');
+                        return;
+                    }
+
+                    userDescriptor.update(userMovedMessage);
+
+                    this.notifyUserMove(userDescriptor);
+                } else {
+                    throw new Error('Unexpected message');
+                }
+
+            }
+        });
+
+        this.backConnection.on('error', (e) => {
+            if (!this.isClosing) {
+                debug('Error on back connection')
+                this.close();
+                this.onBackFailure(e, this);
+            }
+        });
+        this.backConnection.on('close', () => {
+            if (!this.isClosing) {
+                debug('Close on back connection')
+                this.close();
+                this.onBackFailure(null, this);
+            }
+        });
+    }
+
+    public close(): void {
+        debug('Closing connection to zone %d, %d on back server', this.x, this.y);
+        this.isClosing = true;
+        this.backConnection.cancel();
+    }
+
+    public hasListeners(): boolean {
+        return this.listeners.size !== 0;
+    }
+
+    /**
+     * Notify listeners of this zone that this user entered
+     */
+    private notifyUserEnter(user: UserDescriptor, oldZone: ZoneDescriptor|undefined) {
+        for (const listener of this.listeners) {
+            if (listener.userId === user.userId) {
+                continue;
+            }
+            if (oldZone === undefined || !this.isListeningZone(listener, oldZone.x, oldZone.y)) {
+                this.socketListener.onUserEnters(user, listener);
+            } else {
+                this.socketListener.onUserMoves(user, listener);
+            }
+        }
+    }
+
+    /**
+     * Notify listeners of this zone that this group entered
+     */
+    private notifyGroupEnter(group: GroupDescriptor, oldZone: ZoneDescriptor|undefined) {
+        for (const listener of this.listeners) {
+            if (oldZone === undefined || !this.isListeningZone(listener, oldZone.x, oldZone.y)) {
+                this.socketListener.onGroupEnters(group, listener);
+            } else {
+                this.socketListener.onGroupMoves(group, listener);
+            }
+        }
+    }
+
+    /**
+     * Notify listeners of this zone that this user left
+     */
+    private notifyUserLeft(userId: number, newZone: ZoneDescriptor|undefined) {
+        for (const listener of this.listeners) {
+            if (listener.userId === userId) {
+                continue;
+            }
+            if (newZone === undefined || !this.isListeningZone(listener, newZone.x, newZone.y)) {
+                this.socketListener.onUserLeaves(userId, listener);
+            } else {
+                // Do not send a signal. The move event will be triggered when joining the new room.
+            }
+        }
+    }
+
+    /**
+     * Notify listeners of this zone that this group left
+     */
+    private notifyGroupLeft(groupId: number, newZone: ZoneDescriptor|undefined) {
+        for (const listener of this.listeners) {
+            if (listener.groupId === groupId) {
+                continue;
+            }
+            if (newZone === undefined || !this.isListeningZone(listener, newZone.x, newZone.y)) {
+                this.socketListener.onGroupLeaves(groupId, listener);
+            } else {
+                // Do not send a signal. The move event will be triggered when joining the new room.
+            }
+        }
+    }
+
+    private isListeningZone(socket: ExSocketInterface, x: number, y: number): boolean {
+        // TODO: improve efficiency by not doing a full scan of listened zones.
+        for (const zone of socket.listenedZones) {
+            if (zone.x === x && zone.y === y) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private notifyGroupMove(groupDescriptor: GroupDescriptor) {
+        for (const listener of this.listeners) {
+            this.socketListener.onGroupMoves(groupDescriptor, listener);
+        }
+    }
+
+    private notifyUserMove(userDescriptor: UserDescriptor) {
+        for (const listener of this.listeners) {
+            if (listener.userId === userDescriptor.userId) {
+                continue;
+            }
+            this.socketListener.onUserMoves(userDescriptor, listener);
+        }
+    }
+
+    public startListening(listener: ExSocketInterface): void {
+        for (const [userId, user] of this.users.entries()) {
+            if (userId !== listener.userId) {
+                this.socketListener.onUserEnters(user, listener);
+            }
+        }
+
+        for (const [groupId, group] of this.groups.entries()) {
+            this.socketListener.onGroupEnters(group, listener);
+        }
+
+        this.listeners.add(listener);
+        listener.listenedZones.add(this);
+    }
+
+    public stopListening(listener: ExSocketInterface): void {
+        for (const [userId, user] of this.users.entries()) {
+            if (userId !== listener.userId) {
+                this.socketListener.onUserLeaves(userId, listener);
+            }
+        }
+
+        for (const [groupId, group] of this.groups.entries()) {
+            this.socketListener.onGroupLeaves(groupId, listener);
+        }
+
+        this.listeners.delete(listener);
+        listener.listenedZones.delete(this);
+    }
+}

pusher/src/Server/server/app.ts

@@ -0,0 +1,13 @@
+import { App as _App, AppOptions } from 'uWebSockets.js';
+import BaseApp from './baseapp';
+import { extend } from './utils';
+import { UwsApp } from './types';
+
+class App extends (<UwsApp>_App) {
+  constructor(options: AppOptions = {}) {
+    super(options); // eslint-disable-line constructor-super
+    extend(this, new BaseApp());
+  }
+}
+
+export default App;

pusher/src/Server/server/baseapp.ts

@@ -0,0 +1,116 @@
+import { Readable } from 'stream';
+import { us_listen_socket_close, TemplatedApp, HttpResponse, HttpRequest } from 'uWebSockets.js';
+
+import formData from './formdata';
+import { stob } from './utils';
+import { Handler } from './types';
+import {join} from "path";
+
+const contTypes = ['application/x-www-form-urlencoded', 'multipart/form-data'];
+const noOp = () => true;
+
+const handleBody = (res: HttpResponse, req: HttpRequest) => {
+  const contType = req.getHeader('content-type');
+
+  res.bodyStream = function() {
+    const stream = new Readable();
+    stream._read = noOp; // eslint-disable-line @typescript-eslint/unbound-method
+
+    this.onData((ab: ArrayBuffer, isLast: boolean) => {
+      // uint and then slicing is bit faster than slice and then uint
+      stream.push(new Uint8Array(ab.slice((ab as any).byteOffset, ab.byteLength))); // eslint-disable-line @typescript-eslint/no-explicit-any
+      if (isLast) {
+        stream.push(null);
+      }
+    });
+
+    return stream;
+  };
+
+  res.body = () => stob(res.bodyStream());
+
+  if (contType.includes('application/json'))
+    res.json = async () => JSON.parse(await res.body());
+  if (contTypes.map(t => contType.includes(t)).includes(true))
+    res.formData = formData.bind(res, contType);
+};
+
+class BaseApp {
+  _sockets = new Map();
+  ws!: TemplatedApp['ws'];
+  get!: TemplatedApp['get'];
+  _post!: TemplatedApp['post'];
+  _put!: TemplatedApp['put'];
+  _patch!: TemplatedApp['patch'];
+  _listen!: TemplatedApp['listen'];
+
+  post(pattern: string, handler: Handler) {
+    if (typeof handler !== 'function')
+      throw Error(`handler should be a function, given ${typeof handler}.`);
+    this._post(pattern, (res, req) => {
+      handleBody(res, req);
+      handler(res, req);
+    });
+    return this;
+  }
+
+  put(pattern: string, handler: Handler) {
+    if (typeof handler !== 'function')
+      throw Error(`handler should be a function, given ${typeof handler}.`);
+    this._put(pattern, (res, req) => {
+      handleBody(res, req);
+
+      handler(res, req);
+    });
+    return this;
+  }
+
+  patch(pattern: string, handler: Handler) {
+    if (typeof handler !== 'function')
+      throw Error(`handler should be a function, given ${typeof handler}.`);
+    this._patch(pattern, (res, req) => {
+      handleBody(res, req);
+
+      handler(res, req);
+    });
+    return this;
+  }
+
+  listen(h: string | number, p: Function | number = noOp, cb?: Function) {
+    if (typeof p === 'number' && typeof h === 'string') {
+      this._listen(h, p, socket => {
+        this._sockets.set(p, socket);
+        if (cb === undefined) {
+          throw new Error('cb undefined');
+        }
+        cb(socket);
+      });
+    } else if (typeof h === 'number' && typeof p === 'function') {
+      this._listen(h, socket => {
+        this._sockets.set(h, socket);
+        p(socket);
+      });
+    } else {
+      throw Error(
+        'Argument types: (host: string, port: number, cb?: Function) | (port: number, cb?: Function)'
+      );
+    }
+
+    return this;
+  }
+
+  close(port: null | number = null) {
+    if (port) {
+      this._sockets.has(port) && us_listen_socket_close(this._sockets.get(port));
+      this._sockets.delete(port);
+    } else {
+      this._sockets.forEach(app => {
+        us_listen_socket_close(app);
+      });
+      this._sockets.clear();
+    }
+    return this;
+  }
+}
+
+export default BaseApp;

pusher/src/Server/server/formdata.ts

@@ -0,0 +1,100 @@
+import { createWriteStream } from 'fs';
+import { join, dirname } from 'path';
+import Busboy from 'busboy';
+import mkdirp from 'mkdirp';
+
+function formData(
+  contType: string,
+  options: busboy.BusboyConfig & {
+    abortOnLimit?: boolean;
+    tmpDir?: string;
+    onFile?: (
+      fieldname: string,
+      file: NodeJS.ReadableStream,
+      filename: string,
+      encoding: string,
+      mimetype: string
+    ) => string;
+    onField?: (fieldname: string, value: any) => void; // eslint-disable-line @typescript-eslint/no-explicit-any
+    filename?: (oldName: string) => string;
+  } = {}
+) {
+  console.log('Enter form data');
+  options.headers = {
+    'content-type': contType
+  };
+
+  return new Promise((resolve, reject) => {
+    const busb = new Busboy(options);
+    const ret = {};
+
+    this.bodyStream().pipe(busb);
+
+    busb.on('limit', () => {
+      if (options.abortOnLimit) {
+        reject(Error('limit'));
+      }
+    });
+
+    busb.on('file', function(fieldname, file, filename, encoding, mimetype) {
+      const value: { filePath: string|undefined, filename: string, encoding:string, mimetype: string } = {
+        filename,
+        encoding,
+        mimetype,
+        filePath: undefined
+      };
+
+      if (typeof options.tmpDir === 'string') {
+        if (typeof options.filename === 'function') filename = options.filename(filename);
+        const fileToSave = join(options.tmpDir, filename);
+        mkdirp(dirname(fileToSave));
+
+        file.pipe(createWriteStream(fileToSave));
+        value.filePath = fileToSave;
+      }
+      if (typeof options.onFile === 'function') {
+        value.filePath =
+          options.onFile(fieldname, file, filename, encoding, mimetype) || value.filePath;
+      }
+
+      setRetValue(ret, fieldname, value);
+    });
+
+    busb.on('field', function(fieldname, value) {
+      if (typeof options.onField === 'function') options.onField(fieldname, value);
+
+      setRetValue(ret, fieldname, value);
+    });
+
+    busb.on('finish', function() {
+      resolve(ret);
+    });
+
+    busb.on('error', reject);
+  });
+}
+
+function setRetValue(
+  ret: { [x: string]: any }, // eslint-disable-line @typescript-eslint/no-explicit-any
+  fieldname: string,
+  value: { filename: string; encoding: string; mimetype: string; filePath?: string } | any // eslint-disable-line @typescript-eslint/no-explicit-any
+) {
+  if (fieldname.endsWith('[]')) {
+    fieldname = fieldname.slice(0, fieldname.length - 2);
+    if (Array.isArray(ret[fieldname])) {
+      ret[fieldname].push(value);
+    } else {
+      ret[fieldname] = [value];
+    }
+  } else {
+    if (Array.isArray(ret[fieldname])) {
+      ret[fieldname].push(value);
+    } else if (ret[fieldname]) {
+      ret[fieldname] = [ret[fieldname], value];
+    } else {
+      ret[fieldname] = value;
+    }
+  }
+}
+
+export default formData;

pusher/src/Server/server/sslapp.ts

@@ -0,0 +1,13 @@
+import { SSLApp as _SSLApp, AppOptions } from 'uWebSockets.js';
+import BaseApp from './baseapp';
+import { extend } from './utils';
+import { UwsApp } from './types';
+
+class SSLApp extends (<UwsApp>_SSLApp) {
+  constructor(options: AppOptions) {
+    super(options); // eslint-disable-line constructor-super
+    extend(this, new BaseApp());
+  }
+}
+
+export default SSLApp;

pusher/src/Server/server/types.ts

@@ -0,0 +1,11 @@
+import { AppOptions, TemplatedApp, HttpResponse, HttpRequest } from 'uWebSockets.js';
+
+export type UwsApp = {
+  (options: AppOptions): TemplatedApp;
+  new (options: AppOptions): TemplatedApp;
+  prototype: TemplatedApp;
+};
+
+export type Handler = (res: HttpResponse, req: HttpRequest) => void;
+
+export {};

pusher/src/Server/server/utils.ts

@@ -0,0 +1,37 @@
+import { ReadStream } from 'fs';
+
+function extend(who: any, from: any, overwrite = true) { // eslint-disable-line @typescript-eslint/no-explicit-any
+  const ownProps = Object.getOwnPropertyNames(Object.getPrototypeOf(from)).concat(
+    Object.keys(from)
+  );
+  ownProps.forEach(prop => {
+    if (prop === 'constructor' || from[prop] === undefined) return;
+    if (who[prop] && overwrite) {
+      who[`_${prop}`] = who[prop];
+    }
+    if (typeof from[prop] === 'function') who[prop] = from[prop].bind(who);
+    else who[prop] = from[prop];
+  });
+}
+
+function stob(stream: ReadStream): Promise<Buffer> {
+  return new Promise(resolve => {
+    const buffers: Buffer[] = [];
+    stream.on('data', buffers.push.bind(buffers));
+
+    stream.on('end', () => {
+      switch (buffers.length) {
+        case 0:
+          resolve(Buffer.allocUnsafe(0));
+          break;
+        case 1:
+          resolve(buffers[0]);
+          break;
+        default:
+          resolve(Buffer.concat(buffers));
+      }
+    });
+  });
+}
+
+export { extend, stob };

pusher/src/Server/sifrr.server.ts

@@ -0,0 +1,19 @@
+import { parse } from 'query-string';
+import { HttpRequest } from 'uWebSockets.js';
+import App from './server/app';
+import SSLApp from './server/sslapp';
+import * as types from './server/types';
+
+const getQuery = (req: HttpRequest) => {
+  return parse(req.getQuery());
+};
+
+export { App, SSLApp, getQuery };
+export * from './server/types';
+
+export default {
+  App,
+  SSLApp,
+  getQuery,
+  ...types
+};

pusher/src/Services/AdminApi.ts

@@ -0,0 +1,115 @@
+import {ADMIN_API_TOKEN, ADMIN_API_URL} from "../Enum/EnvironmentVariable";
+import Axios from "axios";
+import {v4} from "uuid";
+
+export interface AdminApiData {
+    organizationSlug: string
+    worldSlug: string
+    roomSlug: string
+    mapUrlStart: string
+    tags: string[]
+    policy_type: number
+    userUuid: string
+    messages?: unknown[],
+    textures: CharacterTexture[]
+}
+
+export interface CharacterTexture {
+    id: number,
+    level: number,
+    url: string,
+    rights: string
+}
+
+export interface FetchMemberDataByUuidResponse {
+    uuid: string;
+    tags: string[];
+    textures: CharacterTexture[];
+    messages: unknown[];
+}
+
+class AdminApi {
+
+    async fetchMapDetails(organizationSlug: string, worldSlug: string, roomSlug: string|undefined): Promise<AdminApiData> {
+        if (!ADMIN_API_URL) {
+            return Promise.reject('No admin backoffice set!');
+        }
+
+        const params: { organizationSlug: string, worldSlug: string, roomSlug?: string } = {
+            organizationSlug,
+            worldSlug
+        };
+
+        if (roomSlug) {
+            params.roomSlug = roomSlug;
+        }
+
+        const res = await Axios.get(ADMIN_API_URL + '/api/map',
+            {
+                headers: {"Authorization": `${ADMIN_API_TOKEN}`},
+                params
+            }
+        )
+        return res.data;
+    }
+
+    async fetchMemberDataByUuid(uuid: string): Promise<FetchMemberDataByUuidResponse> {
+        if (!ADMIN_API_URL) {
+            return Promise.reject('No admin backoffice set!');
+        }
+        try {
+            const res = await Axios.get(ADMIN_API_URL+'/api/membership/'+uuid,
+                { headers: {"Authorization" : `${ADMIN_API_TOKEN}`} }
+            )
+            return res.data;
+        } catch (e) {
+            if (e?.response?.status == 404) {
+                // If we get an HTTP 404, the token is invalid. Let's perform an anonymous login!
+                console.warn('Cannot find user with uuid "'+uuid+'". Performing an anonymous login instead.');
+                return {
+                    uuid: v4(),
+                    tags: [],
+                    textures: [],
+                    messages: [],
+                }
+            } else {
+                throw e;
+            }
+        }
+    }
+
+    async fetchMemberDataByToken(organizationMemberToken: string): Promise<AdminApiData> {
+        if (!ADMIN_API_URL) {
+            return Promise.reject('No admin backoffice set!');
+        }
+        //todo: this call can fail if the corresponding world is not activated or if the token is invalid. Handle that case.
+        const res = await Axios.get(ADMIN_API_URL+'/api/login-url/'+organizationMemberToken,
+            { headers: {"Authorization" : `${ADMIN_API_TOKEN}`} }
+        )
+        return res.data;
+    }
+
+    async fetchCheckUserByToken(organizationMemberToken: string): Promise<AdminApiData> {
+        if (!ADMIN_API_URL) {
+            return Promise.reject('No admin backoffice set!');
+        }
+        //todo: this call can fail if the corresponding world is not activated or if the token is invalid. Handle that case.
+        const res = await Axios.get(ADMIN_API_URL+'/api/check-user/'+organizationMemberToken,
+            { headers: {"Authorization" : `${ADMIN_API_TOKEN}`} }
+        )
+        return res.data;
+    }
+
+    reportPlayer(reportedUserUuid: string, reportedUserComment: string, reporterUserUuid: string) {
+       return Axios.post(`${ADMIN_API_URL}/api/report`, {
+                reportedUserUuid,
+                reportedUserComment,
+                reporterUserUuid,
+            },
+            {
+                headers: {"Authorization": `${ADMIN_API_TOKEN}`}
+            });
+    }
+}
+
+export const adminApi = new AdminApi();

pusher/src/Services/ApiClientRepository.ts

@@ -0,0 +1,22 @@
+/**
+ * A class to get connections to the correct "api" server given a room name.
+ */
+import {RoomManagerClient} from "../Messages/generated/messages_grpc_pb";
+import grpc from 'grpc';
+import {API_URL} from "../Enum/EnvironmentVariable";
+
+
+class ApiClientRepository {
+    private roomManagerClient: RoomManagerClient|null = null;
+
+    public async getClient(roomId: string): Promise<RoomManagerClient> {
+        if (this.roomManagerClient === null) {
+            this.roomManagerClient = new RoomManagerClient(API_URL, grpc.credentials.createInsecure());
+        }
+        return Promise.resolve(this.roomManagerClient);
+    }
+}
+
+const apiClientRepository = new ApiClientRepository();
+
+export { apiClientRepository };

pusher/src/Services/ArrayHelper.ts

@@ -0,0 +1,3 @@
+export const arrayIntersect = (array1: string[], array2: string[]) : boolean => {
+    return array1.filter(value => array2.includes(value)).length > 0;
+}

pusher/src/Services/ClientEventsEmitter.ts

@@ -0,0 +1,32 @@
+const EventEmitter = require('events');
+
+const clientJoinEvent = 'clientJoin';
+const clientLeaveEvent = 'clientLeave';
+
+class ClientEventsEmitter extends EventEmitter {
+    emitClientJoin(clientUUid: string, roomId: string): void {
+        this.emit(clientJoinEvent, clientUUid, roomId);
+    }
+
+    emitClientLeave(clientUUid: string, roomId: string): void {
+        this.emit(clientLeaveEvent, clientUUid, roomId);
+    }
+    
+    registerToClientJoin(callback: (clientUUid: string, roomId: string) => void): void {
+        this.on(clientJoinEvent, callback);
+    }
+
+    registerToClientLeave(callback: (clientUUid: string, roomId: string) => void): void {
+        this.on(clientLeaveEvent, callback);
+    }
+
+    unregisterFromClientJoin(callback: (clientUUid: string, roomId: string) => void): void {
+        this.removeListener(clientJoinEvent, callback);
+    }
+
+    unregisterFromClientLeave(callback: (clientUUid: string, roomId: string) => void): void {
+        this.removeListener(clientLeaveEvent, callback);
+    }
+}
+
+export const clientEventsEmitter = new ClientEventsEmitter();

pusher/src/Services/CpuTracker.ts

@@ -0,0 +1,55 @@
+import {CPU_OVERHEAT_THRESHOLD} from "../Enum/EnvironmentVariable";
+
+function secNSec2ms(secNSec: Array<number>|number) {
+    if (Array.isArray(secNSec)) {
+        return secNSec[0] * 1000 + secNSec[1] / 1000000;
+    }
+    return secNSec / 1000;
+}
+
+class CpuTracker {
+    private cpuPercent: number = 0;
+    private overHeating: boolean = false;
+
+    constructor() {
+        let time  = process.hrtime.bigint()
+        let usage = process.cpuUsage()
+        setInterval(() => {
+            const elapTime = process.hrtime.bigint();
+            const elapUsage = process.cpuUsage(usage)
+            usage = process.cpuUsage()
+
+            const elapTimeMS = elapTime - time;
+            const elapUserMS = secNSec2ms(elapUsage.user)
+            const elapSystMS = secNSec2ms(elapUsage.system)
+            this.cpuPercent = Math.round(100 * (elapUserMS + elapSystMS) / Number(elapTimeMS) * 1000000)
+
+            time = elapTime;
+
+            if (!this.overHeating && this.cpuPercent > CPU_OVERHEAT_THRESHOLD) {
+                this.overHeating = true;
+                console.warn('CPU high threshold alert. Going in "overheat" mode');
+            } else if (this.overHeating && this.cpuPercent <= CPU_OVERHEAT_THRESHOLD) {
+                this.overHeating = false;
+                console.log('CPU is back to normal. Canceling "overheat" mode');
+            }
+
+            /*console.log('elapsed time ms:  ', elapTimeMS)
+            console.log('elapsed user ms:  ', elapUserMS)
+            console.log('elapsed system ms:', elapSystMS)
+            console.log('cpu percent:      ', this.cpuPercent)*/
+        }, 100);
+    }
+
+    public getCpuPercent(): number {
+        return this.cpuPercent;
+    }
+
+    public isOverHeating(): boolean {
+        return this.overHeating;
+    }
+}
+
+const cpuTracker = new CpuTracker();
+
+export { cpuTracker };

pusher/src/Services/GaugeManager.ts

@@ -0,0 +1,54 @@
+import {Counter, Gauge} from "prom-client";
+
+//this class should manage all the custom metrics used by prometheus
+class GaugeManager {
+    private nbClientsGauge: Gauge<string>;
+    private nbClientsPerRoomGauge: Gauge<string>;
+    private nbGroupsPerRoomGauge: Gauge<string>;
+    private nbGroupsPerRoomCounter: Counter<string>;
+
+    constructor() {
+        this.nbClientsGauge = new Gauge({
+            name: 'workadventure_nb_sockets',
+            help: 'Number of connected sockets',
+            labelNames: [ ]
+        });
+        this.nbClientsPerRoomGauge = new Gauge({
+            name: 'workadventure_nb_clients_per_room',
+            help: 'Number of clients per room',
+            labelNames: [ 'room' ]
+        });
+
+        this.nbGroupsPerRoomCounter = new Counter({
+            name: 'workadventure_counter_groups_per_room',
+            help: 'Counter of groups per room',
+            labelNames: [ 'room' ]
+        });
+        this.nbGroupsPerRoomGauge = new Gauge({
+            name: 'workadventure_nb_groups_per_room',
+            help: 'Number of groups per room',
+            labelNames: [ 'room' ]
+        });
+    }
+
+    incNbClientPerRoomGauge(roomId: string): void {
+        this.nbClientsGauge.inc();
+        this.nbClientsPerRoomGauge.inc({ room: roomId });
+    }
+
+    decNbClientPerRoomGauge(roomId: string): void {
+        this.nbClientsGauge.dec();
+        this.nbClientsPerRoomGauge.dec({ room: roomId });
+    }
+
+    incNbGroupsPerRoomGauge(roomId: string): void {
+        this.nbGroupsPerRoomCounter.inc({ room: roomId })
+        this.nbGroupsPerRoomGauge.inc({ room: roomId })
+    }
+    
+    decNbGroupsPerRoomGauge(roomId: string): void {
+        this.nbGroupsPerRoomGauge.dec({ room: roomId })
+    }
+}
+
+export const gaugeManager = new GaugeManager();

pusher/src/Services/IoSocketHelpers.ts

@@ -0,0 +1,35 @@
+import {ExSocketInterface} from "_Model/Websocket/ExSocketInterface";
+import {BatchMessage, ErrorMessage, ServerToClientMessage, SubMessage} from "../Messages/generated/messages_pb";
+
+export function emitInBatch(socket: ExSocketInterface, payload: SubMessage): void {
+    socket.batchedMessages.addPayload(payload);
+
+    if (socket.batchTimeout === null) {
+        socket.batchTimeout = setTimeout(() => {
+            if (socket.disconnecting) {
+                return;
+            }
+
+            const serverToClientMessage = new ServerToClientMessage();
+            serverToClientMessage.setBatchmessage(socket.batchedMessages);
+
+            socket.send(serverToClientMessage.serializeBinary().buffer, true);
+            socket.batchedMessages = new BatchMessage();
+            socket.batchTimeout = null;
+        }, 100);
+    }
+}
+
+export function emitError(Client: ExSocketInterface, message: string): void {
+    const errorMessage = new ErrorMessage();
+    errorMessage.setMessage(message);
+
+    const serverToClientMessage = new ServerToClientMessage();
+    serverToClientMessage.setErrormessage(errorMessage);
+
+    if (!Client.disconnecting) {
+        Client.send(serverToClientMessage.serializeBinary().buffer, true);
+    }
+    console.warn(message);
+}
+

pusher/src/Services/JWTTokenManager.ts

@@ -0,0 +1,76 @@
+import {ADMIN_API_URL, ALLOW_ARTILLERY, SECRET_KEY} from "../Enum/EnvironmentVariable";
+import {uuid} from "uuidv4";
+import Jwt from "jsonwebtoken";
+import {TokenInterface} from "../Controller/AuthenticateController";
+import {adminApi, AdminApiData} from "../Services/AdminApi";
+
+class JWTTokenManager {
+
+    public createJWTToken(userUuid: string) {
+        return Jwt.sign({userUuid: userUuid}, SECRET_KEY, {expiresIn: '200d'}); //todo: add a mechanic to refresh or recreate token
+    }
+
+    public async getUserUuidFromToken(token: unknown): Promise<string> {
+
+        if (!token) {
+            throw new Error('An authentication error happened, a user tried to connect without a token.');
+        }
+        if (typeof(token) !== "string") {
+            throw new Error('Token is expected to be a string');
+        }
+
+
+        if(token === 'test') {
+            if (ALLOW_ARTILLERY) {
+                return uuid();
+            } else {
+                throw new Error("In order to perform a load-testing test on this environment, you must set the ALLOW_ARTILLERY environment variable to 'true'");
+            }
+        }
+
+        return new Promise<string>((resolve, reject) => {
+            Jwt.verify(token, SECRET_KEY,  {},(err, tokenDecoded) => {
+                const tokenInterface = tokenDecoded as TokenInterface;
+                if (err) {
+                    console.error('An authentication error happened, invalid JsonWebToken.', err);
+                    reject(new Error('An authentication error happened, invalid JsonWebToken. ' + err.message));
+                    return;
+                }
+                if (tokenDecoded === undefined) {
+                    console.error('Empty token found.');
+                    reject(new Error('Empty token found.'));
+                    return;
+                }
+
+                //verify token
+                if (!this.isValidToken(tokenInterface)) {
+                    reject(new Error('Authentication error, invalid token structure.'));
+                    return;
+                }
+
+                if (ADMIN_API_URL) {
+                    //verify user in admin
+                    adminApi.fetchCheckUserByToken(tokenInterface.userUuid).then(() => {
+                        resolve(tokenInterface.userUuid);
+                    }).catch((err) => {
+                        //anonymous user
+                        if(err.response && err.response.status && err.response.status === 404){
+                            resolve(tokenInterface.userUuid);
+                            return;
+                        }
+                        reject(err);
+                    });
+                } else {
+                    resolve(tokenInterface.userUuid);
+                }
+            });
+        });
+    }
+
+    private isValidToken(token: object): token is TokenInterface {
+        return !(typeof((token as TokenInterface).userUuid) !== 'string');
+    }
+
+}
+
+export const jwtTokenManager = new JWTTokenManager();

pusher/src/Services/SocketManager.ts

@@ -0,0 +1,744 @@
+import {PusherRoom} from "../Model/PusherRoom";
+import {CharacterLayer, ExSocketInterface} from "../Model/Websocket/ExSocketInterface";
+import {
+    GroupDeleteMessage,
+    GroupUpdateMessage,
+    ItemEventMessage,
+    ItemStateMessage,
+    PlayGlobalMessage,
+    PointMessage,
+    PositionMessage,
+    RoomJoinedMessage,
+    ServerToClientMessage,
+    SetPlayerDetailsMessage,
+    SilentMessage,
+    SubMessage,
+    ReportPlayerMessage,
+    UserJoinedMessage, UserLeftMessage,
+    UserMovedMessage,
+    UserMovesMessage,
+    ViewportMessage, WebRtcDisconnectMessage,
+    WebRtcSignalToClientMessage,
+    WebRtcSignalToServerMessage,
+    WebRtcStartMessage,
+    QueryJitsiJwtMessage,
+    SendJitsiJwtMessage,
+    SendUserMessage, JoinRoomMessage, CharacterLayerMessage, PusherToBackMessage
+} from "../Messages/generated/messages_pb";
+import {PointInterface} from "../Model/Websocket/PointInterface";
+import {User} from "../Model/User";
+import {ProtobufUtils} from "../Model/Websocket/ProtobufUtils";
+import {Group} from "../Model/Group";
+import {cpuTracker} from "./CpuTracker";
+import {isSetPlayerDetailsMessage} from "../Model/Websocket/SetPlayerDetailsMessage";
+import {GROUP_RADIUS, JITSI_ISS, MINIMUM_DISTANCE, SECRET_JITSI_KEY} from "../Enum/EnvironmentVariable";
+import {Movable} from "../Model/Movable";
+import {PositionInterface} from "../Model/PositionInterface";
+import {adminApi, CharacterTexture} from "./AdminApi";
+import Direction = PositionMessage.Direction;
+import {emitError, emitInBatch} from "./IoSocketHelpers";
+import Jwt from "jsonwebtoken";
+import {JITSI_URL} from "../Enum/EnvironmentVariable";
+import {clientEventsEmitter} from "./ClientEventsEmitter";
+import {gaugeManager} from "./GaugeManager";
+import {apiClientRepository} from "./ApiClientRepository";
+import {ServiceError} from "grpc";
+import {GroupDescriptor, UserDescriptor, ZoneEventListener} from "_Model/Zone";
+import Debug from "debug";
+
+const debug = Debug('socket');
+
+interface AdminSocketRoomsList {
+    [index: string]: number;
+}
+interface AdminSocketUsersList {
+    [index: string]: boolean;
+}
+
+export interface AdminSocketData {
+    rooms: AdminSocketRoomsList,
+    users: AdminSocketUsersList,
+}
+
+export class SocketManager implements ZoneEventListener {
+    private Worlds: Map<string, PusherRoom> = new Map<string, PusherRoom>();
+    private sockets: Map<number, ExSocketInterface> = new Map<number, ExSocketInterface>();
+
+    constructor() {
+        clientEventsEmitter.registerToClientJoin((clientUUid: string, roomId: string) => {
+            gaugeManager.incNbClientPerRoomGauge(roomId);
+        });
+        clientEventsEmitter.registerToClientLeave((clientUUid: string, roomId: string) => {
+            gaugeManager.decNbClientPerRoomGauge(roomId);
+        });
+    }
+
+    getAdminSocketDataFor(roomId:string): AdminSocketData {
+        throw new Error('Not reimplemented yet');
+        /*const data:AdminSocketData = {
+            rooms: {},
+            users: {},
+        }
+        const room = this.Worlds.get(roomId);
+        if (room === undefined) {
+            return data;
+        }
+        const users = room.getUsers();
+        data.rooms[roomId] = users.size;
+        users.forEach(user => {
+            data.users[user.uuid] = true
+        })
+        return data;*/
+    }
+
+    async handleJoinRoom(client: ExSocketInterface): Promise<void> {
+        const position = client.position;
+        const viewport = client.viewport;
+        try {
+            // TODO: do we need this.sockets anymore?
+            this.sockets.set(client.userId, client); //todo: should this be at the end of the function?
+
+            const joinRoomMessage = new JoinRoomMessage();
+            joinRoomMessage.setRoomid(client.roomId);
+            joinRoomMessage.setName(client.name);
+            joinRoomMessage.setPositionmessage(ProtobufUtils.toPositionMessage(client.position));
+            for (const characterLayer of client.characterLayers) {
+                const characterLayerMessage = new CharacterLayerMessage();
+                characterLayerMessage.setName(characterLayer.name);
+                if (characterLayer.url !== undefined) {
+                    characterLayerMessage.setUrl(characterLayer.url);
+                }
+
+                joinRoomMessage.addCharacterlayer(characterLayerMessage);
+            }
+
+
+            console.log('Calling joinRoom')
+            const apiClient = await apiClientRepository.getClient(client.roomId);
+            const streamToPusher = apiClient.joinRoom();
+
+            client.backConnection = streamToPusher;
+
+            streamToPusher.on('data', (message: ServerToClientMessage) => {
+                if (message.hasRoomjoinedmessage()) {
+                    // If this is the first message sent, send back the viewport.
+                    this.handleViewport(client, viewport);
+                }
+
+                // Let's pass data over from the back to the client.
+                if (!client.disconnecting) {
+                    client.send(message.serializeBinary().buffer, true);
+                }
+            }).on('end', () => {
+                console.warn('Connection lost to back server');
+                // Let's close the front connection if the back connection is closed. This way, we can retry connecting from the start.
+                if (!client.disconnecting) {
+                    this.closeWebsocketConnection(client);
+                }
+                console.log('A user left');
+            }).on('error', (err: Error) => {
+                console.error('Error in connection to back server:', err);
+                if (!client.disconnecting) {
+                    this.closeWebsocketConnection(client);
+                }
+            });
+
+            const pusherToBackMessage = new PusherToBackMessage();
+            pusherToBackMessage.setJoinroommessage(joinRoomMessage);
+            streamToPusher.write(pusherToBackMessage);
+
+            // TODO: analyze viewport, subscribe to correct handler
+
+            //join new previous room
+            //const gameRoom = this.joinRoom(client, position);
+
+            //const things = gameRoom.setViewport(client, viewport);
+
+            /*const roomJoinedMessage = new RoomJoinedMessage();
+
+            for (const thing of things) {
+                if (thing instanceof User) {
+                    const player: ExSocketInterface|undefined = this.sockets.get(thing.id);
+                    if (player === undefined) {
+                        console.warn('Something went wrong. The World contains a user "'+thing.id+"' but this user does not exist in the sockets list!");
+                        continue;
+                    }
+
+                    const userJoinedMessage = new UserJoinedMessage();
+                    userJoinedMessage.setUserid(thing.id);
+                    userJoinedMessage.setName(player.name);
+                    userJoinedMessage.setCharacterlayersList(ProtobufUtils.toCharacterLayerMessages(player.characterLayers));
+                    userJoinedMessage.setPosition(ProtobufUtils.toPositionMessage(player.position));
+
+                    roomJoinedMessage.addUser(userJoinedMessage);
+                    roomJoinedMessage.setTagList(client.tags);
+                } else if (thing instanceof Group) {
+                    const groupUpdateMessage = new GroupUpdateMessage();
+                    groupUpdateMessage.setGroupid(thing.getId());
+                    groupUpdateMessage.setPosition(ProtobufUtils.toPointMessage(thing.getPosition()));
+
+                    roomJoinedMessage.addGroup(groupUpdateMessage);
+                } else {
+                    console.error("Unexpected type for Movable returned by setViewport");
+                }
+            }
+
+            for (const [itemId, item] of gameRoom.getItemsState().entries()) {
+                const itemStateMessage = new ItemStateMessage();
+                itemStateMessage.setItemid(itemId);
+                itemStateMessage.setStatejson(JSON.stringify(item));
+
+                roomJoinedMessage.addItem(itemStateMessage);
+            }
+
+            roomJoinedMessage.setCurrentuserid(client.userId);
+
+            const serverToClientMessage = new ServerToClientMessage();
+            serverToClientMessage.setRoomjoinedmessage(roomJoinedMessage);
+
+            if (!client.disconnecting) {
+                client.send(serverToClientMessage.serializeBinary().buffer, true);
+            }*/
+        } catch (e) {
+            console.error('An error occurred on "join_room" event');
+            console.error(e);
+        }
+    }
+
+    closeWebsocketConnection(client: ExSocketInterface) {
+        client.disconnecting = true;
+        //this.leaveRoom(client);
+        client.close();
+    }
+
+    handleViewport(client: ExSocketInterface, viewport: ViewportMessage.AsObject) {
+        try {
+            client.viewport = viewport;
+
+            const world = this.Worlds.get(client.roomId);
+            if (!world) {
+                console.error("In SET_VIEWPORT, could not find world with id '", client.roomId, "'");
+                return;
+            }
+            world.setViewport(client, client.viewport);
+        } catch (e) {
+            console.error('An error occurred on "SET_VIEWPORT" event');
+            console.error(e);
+        }
+    }
+
+    handleUserMovesMessage(client: ExSocketInterface, userMovesMessage: UserMovesMessage) {
+        const pusherToBackMessage = new PusherToBackMessage();
+        pusherToBackMessage.setUsermovesmessage(userMovesMessage);
+
+        client.backConnection.write(pusherToBackMessage);
+
+        const viewport = userMovesMessage.getViewport();
+        if (viewport === undefined) {
+            throw new Error('Missing viewport in UserMovesMessage');
+        }
+
+        // Now, we need to listen to the correct viewport.
+        this.handleViewport(client, viewport.toObject())
+    }
+
+    // Useless now, will be useful again if we allow editing details in game
+    handleSetPlayerDetails(client: ExSocketInterface, playerDetailsMessage: SetPlayerDetailsMessage) {
+        const pusherToBackMessage = new PusherToBackMessage();
+        pusherToBackMessage.setSetplayerdetailsmessage(playerDetailsMessage);
+
+        client.backConnection.write(pusherToBackMessage);
+    }
+
+    handleSilentMessage(client: ExSocketInterface, silentMessage: SilentMessage) {
+        const pusherToBackMessage = new PusherToBackMessage();
+        pusherToBackMessage.setSilentmessage(silentMessage);
+
+        client.backConnection.write(pusherToBackMessage);
+    }
+
+    handleItemEvent(client: ExSocketInterface, itemEventMessage: ItemEventMessage) {
+        const pusherToBackMessage = new PusherToBackMessage();
+        pusherToBackMessage.setItemeventmessage(itemEventMessage);
+
+        client.backConnection.write(pusherToBackMessage);
+
+        /*const itemEvent = ProtobufUtils.toItemEvent(itemEventMessage);
+
+        try {
+            const world = this.Worlds.get(ws.roomId);
+            if (!world) {
+                console.error("Could not find world with id '", ws.roomId, "'");
+                return;
+            }
+
+            const subMessage = new SubMessage();
+            subMessage.setItemeventmessage(itemEventMessage);
+
+            // Let's send the event without using the SocketIO room.
+            for (const user of world.getUsers().values()) {
+                const client = this.searchClientByIdOrFail(user.id);
+                //client.emit(SocketIoEvent.ITEM_EVENT, itemEvent);
+                emitInBatch(client, subMessage);
+            }
+
+            world.setItemState(itemEvent.itemId, itemEvent.state);
+        } catch (e) {
+            console.error('An error occurred on "item_event"');
+            console.error(e);
+        }*/
+    }
+
+    async handleReportMessage(client: ExSocketInterface, reportPlayerMessage: ReportPlayerMessage) {
+        try {
+            const reportedSocket = this.sockets.get(reportPlayerMessage.getReporteduserid());
+            if (!reportedSocket) {
+                throw 'reported socket user not found';
+            }
+            //TODO report user on admin application
+            await adminApi.reportPlayer(reportedSocket.userUuid, reportPlayerMessage.getReportcomment(),  client.userUuid)
+        } catch (e) {
+            console.error('An error occurred on "handleReportMessage"');
+            console.error(e);
+        }
+    }
+
+    emitVideo(socket: ExSocketInterface, data: WebRtcSignalToServerMessage): void {
+        const pusherToBackMessage = new PusherToBackMessage();
+        pusherToBackMessage.setWebrtcsignaltoservermessage(data);
+
+        socket.backConnection.write(pusherToBackMessage);
+
+
+        //send only at user
+        /*const client = this.sockets.get(data.getReceiverid());
+        if (client === undefined) {
+            console.warn("While exchanging a WebRTC signal: client with id ", data.getReceiverid(), " does not exist. This might be a race condition.");
+            return;
+        }
+
+        const webrtcSignalToClient = new WebRtcSignalToClientMessage();
+        webrtcSignalToClient.setUserid(socket.userId);
+        webrtcSignalToClient.setSignal(data.getSignal());
+
+        const serverToClientMessage = new ServerToClientMessage();
+        serverToClientMessage.setWebrtcsignaltoclientmessage(webrtcSignalToClient);
+
+        if (!client.disconnecting) {
+            client.send(serverToClientMessage.serializeBinary().buffer, true);
+        }*/
+    }
+
+    emitScreenSharing(socket: ExSocketInterface, data: WebRtcSignalToServerMessage): void {
+        const pusherToBackMessage = new PusherToBackMessage();
+        pusherToBackMessage.setWebrtcscreensharingsignaltoservermessage(data);
+
+        socket.backConnection.write(pusherToBackMessage);
+
+        //send only at user
+        /*const client = this.sockets.get(data.getReceiverid());
+        if (client === undefined) {
+            console.warn("While exchanging a WEBRTC_SCREEN_SHARING signal: client with id ", data.getReceiverid(), " does not exist. This might be a race condition.");
+            return;
+        }
+
+        const webrtcSignalToClient = new WebRtcSignalToClientMessage();
+        webrtcSignalToClient.setUserid(socket.userId);
+        webrtcSignalToClient.setSignal(data.getSignal());
+
+        const serverToClientMessage = new ServerToClientMessage();
+        serverToClientMessage.setWebrtcscreensharingsignaltoclientmessage(webrtcSignalToClient);
+
+        if (!client.disconnecting) {
+            client.send(serverToClientMessage.serializeBinary().buffer, true);
+        }*/
+    }
+
+    private searchClientByIdOrFail(userId: number): ExSocketInterface {
+        const client: ExSocketInterface|undefined = this.sockets.get(userId);
+        if (client === undefined) {
+            throw new Error("Could not find user with id " + userId);
+        }
+        return client;
+    }
+
+    leaveRoom(socket : ExSocketInterface) {
+        // leave previous room and world
+        try {
+            if (socket.roomId) {
+                try {
+                    //user leaves room
+                    const room: PusherRoom | undefined = this.Worlds.get(socket.roomId);
+                    if (room) {
+                        debug('Leaving room %s.', socket.roomId);
+                        room.leave(socket);
+                        if (room.isEmpty()) {
+                            this.Worlds.delete(socket.roomId);
+                            debug('Room %s is empty. Deleting.', socket.roomId);
+                        }
+                    } else {
+                        console.error('Could not find the GameRoom the user is leaving!');
+                    }
+                    //user leave previous room
+                    //Client.leave(Client.roomId);
+                } finally {
+                    //delete Client.roomId;
+                    this.sockets.delete(socket.userId);
+                    clientEventsEmitter.emitClientLeave(socket.userUuid, socket.roomId);
+                    console.log('A user left (', this.sockets.size, ' connected users)');
+                }
+            }
+        } finally {
+            if (socket.backConnection) {
+                socket.backConnection.end();
+            }
+        }
+    }
+
+    async getOrCreateRoom(roomId: string): Promise<PusherRoom> {
+        //check and create new world for a room
+        let world = this.Worlds.get(roomId)
+        if(world === undefined){
+            world = new PusherRoom(
+                roomId,
+                this
+/*                (user: User, group: Group) => this.joinWebRtcRoom(user, group),
+                (user: User, group: Group) => this.disConnectedUser(user, group),
+                MINIMUM_DISTANCE,
+                GROUP_RADIUS,
+                (thing: Movable, listener: User) => this.onRoomEnter(thing, listener),
+                (thing: Movable, position:PositionInterface, listener:User) => this.onClientMove(thing, position, listener),
+                (thing: Movable, listener:User) => this.onClientLeave(thing, listener)*/
+            );
+            if (!world.anonymous) {
+                const data = await adminApi.fetchMapDetails(world.organizationSlug, world.worldSlug, world.roomSlug)
+                world.tags = data.tags
+                world.policyType = Number(data.policy_type)
+            }
+            this.Worlds.set(roomId, world);
+        }
+        return Promise.resolve(world)
+    }
+
+/*    private joinRoom(client : ExSocketInterface, position: PointInterface): PusherRoom {
+
+        const roomId = client.roomId;
+        client.position = position;
+
+        const world = this.Worlds.get(roomId)
+        if(world === undefined){
+            throw new Error('Could not find room for ID: '+client.roomId)
+        }
+
+        // Dispatch groups position to newly connected user
+        world.getGroups().forEach((group: Group) => {
+            this.emitCreateUpdateGroupEvent(client, group);
+        });
+        //join world
+        world.join(client, client.position);
+        clientEventsEmitter.emitClientJoin(client.userUuid, client.roomId);
+        console.log(new Date().toISOString() + ' A user joined (', this.sockets.size, ' connected users)');
+        return world;
+    }
+
+    private onClientMove(thing: Movable, position:PositionInterface, listener:User): void {
+        const clientListener = this.searchClientByIdOrFail(listener.id);
+        if (thing instanceof User) {
+            const clientUser = this.searchClientByIdOrFail(thing.id);
+
+            const userMovedMessage = new UserMovedMessage();
+            userMovedMessage.setUserid(clientUser.userId);
+            userMovedMessage.setPosition(ProtobufUtils.toPositionMessage(clientUser.position));
+
+            const subMessage = new SubMessage();
+            subMessage.setUsermovedmessage(userMovedMessage);
+
+            clientListener.emitInBatch(subMessage);
+            //console.log("Sending USER_MOVED event");
+        } else if (thing instanceof Group) {
+            this.emitCreateUpdateGroupEvent(clientListener, thing);
+        } else {
+            console.error('Unexpected type for Movable.');
+        }
+    }
+
+    private onClientLeave(thing: Movable, listener:User) {
+        const clientListener = this.searchClientByIdOrFail(listener.id);
+        if (thing instanceof User) {
+            const clientUser = this.searchClientByIdOrFail(thing.id);
+            this.emitUserLeftEvent(clientListener, clientUser.userId);
+        } else if (thing instanceof Group) {
+            this.emitDeleteGroupEvent(clientListener, thing.getId());
+        } else {
+            console.error('Unexpected type for Movable.');
+        }
+    }*/
+
+    private emitCreateUpdateGroupEvent(client: ExSocketInterface, group: Group): void {
+        const position = group.getPosition();
+        const pointMessage = new PointMessage();
+        pointMessage.setX(Math.floor(position.x));
+        pointMessage.setY(Math.floor(position.y));
+        const groupUpdateMessage = new GroupUpdateMessage();
+        groupUpdateMessage.setGroupid(group.getId());
+        groupUpdateMessage.setPosition(pointMessage);
+        groupUpdateMessage.setGroupsize(group.getSize);
+
+        const subMessage = new SubMessage();
+        subMessage.setGroupupdatemessage(groupUpdateMessage);
+
+        emitInBatch(client, subMessage);
+        //socket.emit(SocketIoEvent.GROUP_CREATE_UPDATE, groupUpdateMessage.serializeBinary().buffer);
+    }
+
+    private emitDeleteGroupEvent(client: ExSocketInterface, groupId: number): void {
+        const groupDeleteMessage = new GroupDeleteMessage();
+        groupDeleteMessage.setGroupid(groupId);
+
+        const subMessage = new SubMessage();
+        subMessage.setGroupdeletemessage(groupDeleteMessage);
+
+        emitInBatch(client, subMessage);
+    }
+
+    private emitUserLeftEvent(client: ExSocketInterface, userId: number): void {
+        const userLeftMessage = new UserLeftMessage();
+        userLeftMessage.setUserid(userId);
+
+        const subMessage = new SubMessage();
+        subMessage.setUserleftmessage(userLeftMessage);
+
+        emitInBatch(client, subMessage);
+    }
+
+    private joinWebRtcRoom(user: User, group: Group) {
+        /*const roomId: string = "webrtcroom"+group.getId();
+        if (user.socket.webRtcRoomId === roomId) {
+            return;
+        }*/
+
+        for (const otherUser of group.getUsers()) {
+            if (user === otherUser) {
+                continue;
+            }
+
+            // Let's send 2 messages: one to the user joining the group and one to the other user
+            const webrtcStartMessage1 = new WebRtcStartMessage();
+            webrtcStartMessage1.setUserid(otherUser.id);
+            webrtcStartMessage1.setName(otherUser.socket.name);
+            webrtcStartMessage1.setInitiator(true);
+
+            const serverToClientMessage1 = new ServerToClientMessage();
+            serverToClientMessage1.setWebrtcstartmessage(webrtcStartMessage1);
+
+            if (!user.socket.disconnecting) {
+                user.socket.send(serverToClientMessage1.serializeBinary().buffer, true);
+                //console.log('Sending webrtcstart initiator to '+user.socket.userId)
+            }
+
+            const webrtcStartMessage2 = new WebRtcStartMessage();
+            webrtcStartMessage2.setUserid(user.id);
+            webrtcStartMessage2.setName(user.socket.name);
+            webrtcStartMessage2.setInitiator(false);
+
+            const serverToClientMessage2 = new ServerToClientMessage();
+            serverToClientMessage2.setWebrtcstartmessage(webrtcStartMessage2);
+
+            if (!otherUser.socket.disconnecting) {
+                otherUser.socket.send(serverToClientMessage2.serializeBinary().buffer, true);
+                //console.log('Sending webrtcstart to '+otherUser.socket.userId)
+            }
+
+        }
+    }
+
+    //disconnect user
+    private disConnectedUser(user: User, group: Group) {
+        // Most of the time, sending a disconnect event to one of the players is enough (the player will close the connection
+        // which will be shut for the other player).
+        // However! In the rare case where the WebRTC connection is not yet established, if we close the connection on one of the player,
+        // the other player will try connecting until a timeout happens (during this time, the connection icon will be displayed for nothing).
+        // So we also send the disconnect event to the other player.
+        for (const otherUser of group.getUsers()) {
+            if (user === otherUser) {
+                continue;
+            }
+
+            const webrtcDisconnectMessage1 = new WebRtcDisconnectMessage();
+            webrtcDisconnectMessage1.setUserid(user.id);
+
+            const serverToClientMessage1 = new ServerToClientMessage();
+            serverToClientMessage1.setWebrtcdisconnectmessage(webrtcDisconnectMessage1);
+
+            if (!otherUser.socket.disconnecting) {
+                otherUser.socket.send(serverToClientMessage1.serializeBinary().buffer, true);
+            }
+
+
+            const webrtcDisconnectMessage2 = new WebRtcDisconnectMessage();
+            webrtcDisconnectMessage2.setUserid(otherUser.id);
+
+            const serverToClientMessage2 = new ServerToClientMessage();
+            serverToClientMessage2.setWebrtcdisconnectmessage(webrtcDisconnectMessage2);
+
+            if (!user.socket.disconnecting) {
+                user.socket.send(serverToClientMessage2.serializeBinary().buffer, true);
+            }
+        }
+    }
+
+    emitPlayGlobalMessage(client: ExSocketInterface, playglobalmessage: PlayGlobalMessage) {
+        const pusherToBackMessage = new PusherToBackMessage();
+        pusherToBackMessage.setPlayglobalmessage(playglobalmessage);
+
+        client.backConnection.write(pusherToBackMessage);
+    }
+
+    public getWorlds(): Map<string, PusherRoom> {
+        return this.Worlds;
+    }
+
+    /**
+     *
+     * @param token
+     */
+    searchClientByUuid(uuid: string): ExSocketInterface | null {
+        for(const socket of this.sockets.values()){
+            if(socket.userUuid === uuid){
+                return socket;
+            }
+        }
+        return null;
+    }
+
+
+    public handleQueryJitsiJwtMessage(client: ExSocketInterface, queryJitsiJwtMessage: QueryJitsiJwtMessage) {
+        const room = queryJitsiJwtMessage.getJitsiroom();
+        const tag = queryJitsiJwtMessage.getTag(); // FIXME: this is not secure. We should load the JSON for the current room and check rights associated to room instead.
+
+        if (SECRET_JITSI_KEY === '') {
+            throw new Error('You must set the SECRET_JITSI_KEY key to the secret to generate JWT tokens for Jitsi.');
+        }
+
+        // Let's see if the current client has
+        const isAdmin = client.tags.includes(tag);
+
+        const jwt = Jwt.sign({
+            "aud": "jitsi",
+            "iss": JITSI_ISS,
+            "sub": JITSI_URL,
+            "room": room,
+            "moderator": isAdmin
+        }, SECRET_JITSI_KEY, {
+            expiresIn: '1d',
+            algorithm: "HS256",
+            header:
+                {
+                    "alg": "HS256",
+                    "typ": "JWT"
+                }
+        });
+
+        const sendJitsiJwtMessage = new SendJitsiJwtMessage();
+        sendJitsiJwtMessage.setJitsiroom(room);
+        sendJitsiJwtMessage.setJwt(jwt);
+
+        const serverToClientMessage = new ServerToClientMessage();
+        serverToClientMessage.setSendjitsijwtmessage(sendJitsiJwtMessage);
+
+        client.send(serverToClientMessage.serializeBinary().buffer, true);
+    }
+
+    public emitSendUserMessage(messageToSend: {userUuid: string, message: string, type: string}): ExSocketInterface {
+        const socket = this.searchClientByUuid(messageToSend.userUuid);
+        if(!socket){
+            throw 'socket was not found';
+        }
+
+        const sendUserMessage = new SendUserMessage();
+        sendUserMessage.setMessage(messageToSend.message);
+        sendUserMessage.setType(messageToSend.type);
+
+        const serverToClientMessage = new ServerToClientMessage();
+        serverToClientMessage.setSendusermessage(sendUserMessage);
+
+        if (!socket.disconnecting) {
+            socket.send(serverToClientMessage.serializeBinary().buffer, true);
+        }
+        return socket;
+    }
+
+    /**
+     * Merges the characterLayers received from the front (as an array of string) with the custom textures from the back.
+     */
+    static mergeCharacterLayersAndCustomTextures(characterLayers: string[], memberTextures: CharacterTexture[]): CharacterLayer[] {
+        const characterLayerObjs: CharacterLayer[] = [];
+        for (const characterLayer of characterLayers) {
+            if (characterLayer.startsWith('customCharacterTexture')) {
+                const customCharacterLayerId: number = +characterLayer.substr(22);
+                for (const memberTexture of memberTextures) {
+                    if (memberTexture.id == customCharacterLayerId) {
+                        characterLayerObjs.push({
+                            name: characterLayer,
+                            url: memberTexture.url
+                        })
+                        break;
+                    }
+                }
+            } else {
+                characterLayerObjs.push({
+                    name: characterLayer,
+                    url: undefined
+                })
+            }
+        }
+        return characterLayerObjs;
+    }
+
+    public onUserEnters(user: UserDescriptor, listener: ExSocketInterface): void {
+        const subMessage = new SubMessage();
+        subMessage.setUserjoinedmessage(user.toUserJoinedMessage());
+
+        emitInBatch(listener, subMessage);
+    }
+
+    public onUserMoves(user: UserDescriptor, listener: ExSocketInterface): void {
+        const subMessage = new SubMessage();
+        subMessage.setUsermovedmessage(user.toUserMovedMessage());
+
+        emitInBatch(listener, subMessage);
+    }
+
+    public onUserLeaves(userId: number, listener: ExSocketInterface): void {
+        const userLeftMessage = new UserLeftMessage();
+        userLeftMessage.setUserid(userId);
+
+        const subMessage = new SubMessage();
+        subMessage.setUserleftmessage(userLeftMessage);
+
+        emitInBatch(listener, subMessage);
+    }
+
+    public onGroupEnters(group: GroupDescriptor, listener: ExSocketInterface): void {
+        const subMessage = new SubMessage();
+        subMessage.setGroupupdatemessage(group.toGroupUpdateMessage());
+
+        emitInBatch(listener, subMessage);
+    }
+
+    public onGroupMoves(group: GroupDescriptor, listener: ExSocketInterface): void {
+        this.onGroupEnters(group, listener);
+    }
+
+    public onGroupLeaves(groupId: number, listener: ExSocketInterface): void {
+        const groupDeleteMessage = new GroupDeleteMessage();
+        groupDeleteMessage.setGroupid(groupId);
+
+        const subMessage = new SubMessage();
+        subMessage.setGroupdeletemessage(groupDeleteMessage);
+
+        emitInBatch(listener, subMessage);
+    }
+}
+
+export const socketManager = new SocketManager();