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

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());
+    }
+}