Merge pull request #432 from thecodingmachine/scaling

Adding "pusher" container to add scaling capability

.github/workflows/build-and-deploy.yml

@@ -56,6 +56,52 @@ jobs:
           tags: ${{ env.GITHUB_REF_SLUG }}
           add_git_labels: true
 
+  build-pusher:
+
+    runs-on: ubuntu-latest
+
+    steps:
+
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      # Create a slugified value of the branch
+      - uses: rlespinasse/github-slug-action@3.1.0
+
+      - name: "Build and push back image"
+        uses: docker/build-push-action@v1
+        with:
+          dockerfile: pusher/Dockerfile
+          path: ./
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+          repository: thecodingmachine/workadventure-pusher
+          tags: ${{ env.GITHUB_REF_SLUG }}
+          add_git_labels: true
+
+  build-uploader:
+
+    runs-on: ubuntu-latest
+
+    steps:
+
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      # Create a slugified value of the branch
+      - uses: rlespinasse/github-slug-action@3.1.0
+
+      - name: "Build and push back image"
+        uses: docker/build-push-action@v1
+        with:
+          dockerfile: uploader/Dockerfile
+          path: ./
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+          repository: thecodingmachine/workadventure-uploader
+          tags: ${{ env.GITHUB_REF_SLUG }}
+          add_git_labels: true
+
   build-website:
 
     runs-on: ubuntu-latest
@@ -107,6 +153,10 @@ jobs:
     needs:
       - build-front
       - build-back
+      - build-pusher
+      - build-maps
+      - build-uploader
+      - build-website
     runs-on: ubuntu-latest
 
     steps:

back/Dockerfile

@@ -10,6 +10,7 @@ COPY --from=builder --chown=docker:docker /var/www/messages/generated /usr/src/a
 RUN yarn install
 
 ENV NODE_ENV=production
+RUN yarn run tsc
 
-CMD ["yarn", "run", "prod"]
+CMD ["yarn", "run", "runprod"]
 

back/package.json

@@ -7,6 +7,7 @@
     "tsc": "tsc",
     "dev": "ts-node-dev --respawn ./server.ts",
     "prod": "tsc && node --max-old-space-size=4096 ./dist/server.js",
+    "runprod": "node --max-old-space-size=4096 ./dist/server.js",
     "profile": "tsc && node --prof ./dist/server.js",
     "test": "ts-node node_modules/jasmine/bin/jasmine --config=jasmine.json",
     "lint": "node_modules/.bin/eslint src/ . --ext .ts",
@@ -40,8 +41,10 @@
     "body-parser": "^1.19.0",
     "busboy": "^0.3.1",
     "circular-json": "^0.5.9",
+    "debug": "^4.3.1",
     "generic-type-guard": "^3.2.0",
     "google-protobuf": "^3.13.0",
+    "grpc": "^1.24.4",
     "http-status-codes": "^1.4.0",
     "iterall": "^1.3.0",
     "jsonwebtoken": "^8.5.1",
@@ -58,6 +61,7 @@
   "devDependencies": {
     "@types/busboy": "^0.2.3",
     "@types/circular-json": "^0.4.0",
+    "@types/debug": "^4.1.5",
     "@types/google-protobuf": "^3.7.3",
     "@types/http-status-codes": "^1.2.0",
     "@types/jasmine": "^3.5.10",

back/position-test.js

@@ -1,148 +0,0 @@
-// Constants
-let MIN_DISTANCE = 12;
-let MAX_PER_GROUP = 3;
-let NB_USERS = 10;
-
-// Utils
-let rand = function(min, max) {
-    min = Math.ceil(min);
-    max = Math.floor(max);
-    return Math.floor(Math.random() * (max - min + 1)) + min;
-};
-
-let compareDistances = function(distA, distB) {
-    if (distA.distance < distB.distance) {
-        return -1;
-    }
-    if (distA.distance > distB.distance) {
-        return 1;
-    }
-    return 0;
-};
-
-let computeDistance = function (user1, user2) {
-    return Math.sqrt(Math.pow(user2.X - user1.X, 2) + Math.pow(user2.Y - user1.Y, 2));
-};
-
-// Test Data
-let users = [];
-for(let i = 1; i <= NB_USERS; i++) {
-    let user = {};
-    user.id = rand(0,99999);
-    user.X = rand(0, 40);
-    user.Y = rand(0, 40);
-    users.push(user);
-}
-
-// Compute distance between each user
-let getDistanceOfEachUser = function(users) {
-    let i = 0;
-    let distances = [];
-
-    users.forEach(function(user1, key1) {
-        users.forEach(function(user2, key2) {
-            if(key1 < key2) {
-                let distanceObj = {};
-                distanceObj.distance = computeDistance(user1, user2);
-                distanceObj.first = user1;
-                distanceObj.second = user2;
-
-                distances[i] = distanceObj;
-                i++;
-            }
-        });
-    });
-
-    return distances;
-};
-
-// Organise groups
-let createGroups = function(distances) {
-    let i = 0;
-    let groups = [];
-    let alreadyInAGroup = [];
-
-    for(let j = 0; j < distances.length; j++) {
-        let dist = distances[j];
-
-        if(dist.distance <= MIN_DISTANCE) {
-            if(typeof groups[i] === 'undefined') {
-                groups[i] = [];
-            }
-
-            if(groups[i].indexOf(dist.first) === -1 && typeof alreadyInAGroup[dist.first.id] === 'undefined') {
-                if(groups[i].length > 1) {
-                    // if group is not empty we check current user can be added in the group according to its distance to the others already in it
-                    for(let l = 0; l < groups[i].length; l++) {
-                        let userTotest = groups[i][l];
-                        if(computeDistance(dist.first, userTotest) <= MIN_DISTANCE) {
-                            groups[i].push(dist.first);
-                            alreadyInAGroup[dist.first.id] = true;
-                            break;
-                        }
-                    }
-                } else {
-                    groups[i].push(dist.first);
-                    alreadyInAGroup[dist.first.id] = true;
-                }
-            }
-
-            if(groups[i].length === MAX_PER_GROUP) {
-                i++; // on créé un nouveau groupe
-                if(i > (NB_USERS / MAX_PER_GROUP)) {
-                    console.log('There is no room left for user ID : ' + dist.second.id + ' !');
-                    break;
-                }
-                continue;
-            }
-
-            if(groups[i].indexOf(dist.second) === -1 && typeof alreadyInAGroup[dist.second.id] === 'undefined') {
-                if(groups[i].length > 1) {
-                    // if group is not empty we check current user can be added in the group according to its distance to the others already in it
-                    for(let l = 0; l < groups[i].length; l++) {
-                        let userTotest = groups[i][l];
-                        if(computeDistance(dist.second, userTotest) <= MIN_DISTANCE) {
-                            groups[i].push(dist.second);
-                            alreadyInAGroup[dist.second.id] = true;
-                            break;
-                        }
-                    }
-                } else {
-                    groups[i].push(dist.second);
-                    alreadyInAGroup[dist.second.id] = true;
-                }
-            }
-        }
-    }
-
-    return groups;
-};
-
-let distances = getDistanceOfEachUser(users);
-
-// ordonner par distance pour prioriser l'association en groupe des utilisateurs les plus proches
-distances.sort(compareDistances);
-
-let groups = createGroups(distances);
-
-// Compute distance between each user of a already existing group
-let checkGroupDistance = function(groups) {
-    for(let i = 0; i < groups.length; i++) {
-        let group = groups[i];
-            group.forEach(function(user1, key1) {
-                group.forEach(function(user2, key2) {
-                    if(key1 < key2) {
-                        let distance = computeDistance(user1, user2);
-                        if(distance > MIN_DISTANCE) {
-                            // TODO : message a user1 et user2
-                        }
-                    }
-            });
-        });
-    }
-};
-
-console.log(users);
-console.log(distances);
-console.log(groups);
-

back/server.ts

@@ -1,3 +1,13 @@
 // lib/server.ts
 import App from "./src/App";
+import grpc from "grpc";
+import {roomManager} from "./src/RoomManager";
+import {IRoomManagerServer, RoomManagerService} from "./src/Messages/generated/messages_grpc_pb";
+
 App.listen(8080, () => console.log(`WorkAdventure starting on port 8080!`))
+
+const server = new grpc.Server();
+server.addService<IRoomManagerServer>(RoomManagerService, roomManager);
+
+server.bind('0.0.0.0:50051', grpc.ServerCredentials.createInsecure());
+server.start();

back/src/App.ts

@@ -1,29 +1,16 @@
 // 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);
     }

back/src/Controller/DebugController.ts

@@ -1,10 +1,10 @@
 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";
+import {ServerWritableStream} from "grpc";
 
 export class DebugController {
     constructor(private App : App) {
@@ -23,6 +23,15 @@ export class DebugController {
             return res.writeStatus('200 OK').writeHeader('Content-Type', 'application/json').end(stringify(
                 socketManager.getWorlds(),
                 (key: unknown, value: unknown) => {
+                    if (key === 'listeners') {
+                        return 'Listeners';
+                    }
+                    if (key === 'socket') {
+                        return 'Socket';
+                    }
+                    if (key === 'batchedMessages') {
+                        return 'BatchedMessages';
+                    }
                     if(value instanceof Map) {
                         const obj: any = {}; // eslint-disable-line @typescript-eslint/no-explicit-any
                         for (const [mapKey, mapValue] of value.entries()) {

back/src/Model/Admin.ts

@@ -0,0 +1,37 @@
+import { Group } from "./Group";
+import { PointInterface } from "./Websocket/PointInterface";
+import {Zone} from "_Model/Zone";
+import {Movable} from "_Model/Movable";
+import {PositionNotifier} from "_Model/PositionNotifier";
+import {ServerDuplexStream} from "grpc";
+import {
+    BatchMessage,
+    PusherToBackMessage,
+    ServerToAdminClientMessage,
+    ServerToClientMessage,
+    SubMessage
+} from "../Messages/generated/messages_pb";
+import {CharacterLayer} from "_Model/Websocket/CharacterLayer";
+import {AdminSocket} from "../RoomManager";
+
+
+export class Admin {
+    public constructor(
+        private readonly socket: AdminSocket
+    ) {
+    }
+
+    public sendUserJoin(uuid: string): void {
+        const serverToAdminClientMessage = new ServerToAdminClientMessage();
+        serverToAdminClientMessage.setUseruuidjoinedroom(uuid);
+
+        this.socket.write(serverToAdminClientMessage);
+    }
+
+    public sendUserLeft(uuid: string): void {
+        const serverToAdminClientMessage = new ServerToAdminClientMessage();
+        serverToAdminClientMessage.setUseruuidleftroom(uuid);
+
+        this.socket.write(serverToAdminClientMessage);
+    }
+}

back/src/Model/Distance.ts

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

back/src/Model/GameRoom.ts

@@ -1,22 +1,23 @@
 import {PointInterface} from "./Websocket/PointInterface";
 import {Group} from "./Group";
-import {User} from "./User";
+import {User, UserSocket} from "./User";
-import {ExSocketInterface} from "_Model/Websocket/ExSocketInterface";
 import {PositionInterface} from "_Model/PositionInterface";
-import {Identificable} from "_Model/Websocket/Identificable";
 import {EntersCallback, LeavesCallback, MovesCallback} from "_Model/Zone";
 import {PositionNotifier} from "./PositionNotifier";
-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 {JoinRoomMessage} from "../Messages/generated/messages_pb";
+import {ProtobufUtils} from "../Model/Websocket/ProtobufUtils";
+import {ZoneSocket} from "src/RoomManager";
+import {Admin} from "../Model/Admin";
 
 export type ConnectCallback = (user: User, group: Group) => void;
 export type DisconnectCallback = (user: User, group: Group) => void;
 
 export enum GameRoomPolicyTypes {
-    ANONYMUS_POLICY = 1,
+    ANONYMOUS_POLICY = 1,
     MEMBERS_ONLY_POLICY,
     USE_TAGS_POLICY,
 }
@@ -27,7 +28,9 @@ export class GameRoom {
 
     // Users, sorted by ID
     private readonly users: Map<number, User>;
+    private readonly usersByUuid: Map<string, User>;
     private readonly groups: Set<Group>;
+    private readonly admins: Set<Admin>;
 
     private readonly connectCallback: ConnectCallback;
     private readonly disconnectCallback: DisconnectCallback;
@@ -42,6 +45,7 @@ export class GameRoom {
     public readonly roomSlug: string;
     public readonly worldSlug: string = '';
     public readonly organizationSlug: string = '';
+    private nextUserId: number = 1;
 
     constructor(roomId: string,
                 connectCallback: ConnectCallback,
@@ -55,7 +59,7 @@ export class GameRoom {
         this.roomId = roomId;
         this.anonymous = isRoomAnonymous(roomId);
         this.tags = [];
-        this.policyType = GameRoomPolicyTypes.ANONYMUS_POLICY;
+        this.policyType = GameRoomPolicyTypes.ANONYMOUS_POLICY;
 
         if (this.anonymous) {
             this.roomSlug = extractRoomSlugPublicRoomId(this.roomId);
@@ -68,6 +72,8 @@ export class GameRoom {
 
 
         this.users = new Map<number, User>();
+        this.usersByUuid = new Map<string, User>();
+        this.admins = new Set<Admin>();
         this.groups = new Set<Group>();
         this.connectCallback = connectCallback;
         this.disconnectCallback = disconnectCallback;
@@ -85,28 +91,52 @@ export class GameRoom {
         return this.users;
     }
 
-    public join(socket : ExSocketInterface, userPosition: PointInterface): void {
+    public getUserByUuid(uuid: string): User|undefined {
-        const user = new User(socket.userId, socket.userUuid, userPosition, false, this.positionNotifier, socket);
+        return this.usersByUuid.get(uuid);
-        this.users.set(socket.userId, user);
+    }
+
+    public join(socket : UserSocket, joinRoomMessage: JoinRoomMessage): User {
+        const positionMessage = joinRoomMessage.getPositionmessage();
+        if (positionMessage === undefined) {
+            throw new Error('Missing position message');
+        }
+        const position = ProtobufUtils.toPointInterface(positionMessage);
+
+        const user = new User(this.nextUserId, joinRoomMessage.getUseruuid(), position, false, this.positionNotifier, socket, joinRoomMessage.getTagList(), joinRoomMessage.getName(), ProtobufUtils.toCharacterLayerObjects(joinRoomMessage.getCharacterlayerList()));
+        this.nextUserId++;
+        this.users.set(user.id, user);
+        this.usersByUuid.set(user.uuid, user);
         // Let's call update position to trigger the join / leave room
         //this.updatePosition(socket, userPosition);
         this.updateUserGroup(user);
+
+        // Notify admins
+        for (const admin of this.admins) {
+            admin.sendUserJoin(user.uuid);
         }
 
-    public leave(user : Identificable){
+        return user;
-        const userObj = this.users.get(user.userId);
+    }
+
+    public leave(user : User){
+        const userObj = this.users.get(user.id);
         if (userObj === undefined) {
-            console.warn('User ', user.userId, 'does not belong to world! It should!');
+            console.warn('User ', user.id, 'does not belong to this game room! It should!');
         }
         if (userObj !== undefined && typeof userObj.group !== 'undefined') {
             this.leaveGroup(userObj);
         }
-        this.users.delete(user.userId);
+        this.users.delete(user.id);
+        this.usersByUuid.delete(user.uuid);
 
         if (userObj !== undefined) {
-            this.positionNotifier.removeViewport(userObj);
             this.positionNotifier.leave(userObj);
         }
+
+        // Notify admins
+        for (const admin of this.admins) {
+            admin.sendUserLeft(user.uuid);
+        }
     }
 
     get isFull(): boolean {
@@ -114,15 +144,10 @@ export class GameRoom {
     }
 
     public isEmpty(): boolean {
-        return this.users.size === 0;
+        return this.users.size === 0 && this.admins.size === 0;
-    }
-
-    public updatePosition(socket : Identificable, userPosition: PointInterface): void {
-        const user = this.users.get(socket.userId);
-        if(typeof user === 'undefined') {
-            return;
     }
 
+    public updatePosition(user : User, userPosition: PointInterface): void {
         user.setPosition(userPosition);
 
         this.updateUserGroup(user);
@@ -170,12 +195,7 @@ export class GameRoom {
         }
     }
 
-    setSilent(socket: Identificable, silent: boolean) {
+    setSilent(user: User, silent: boolean) {
-        const user = this.users.get(socket.userId);
-        if(typeof user === 'undefined') {
-            console.warn('In setSilent, could not find user with ID "'+socket.userId+'" in world.');
-            return;
-        }
         if (user.silent === silent) {
             return;
         }
@@ -186,7 +206,7 @@ export class GameRoom {
         }
         if (!silent) {
             // If we are back to life, let's trigger a position update to see if we can join some group.
-            this.updatePosition(socket, user.getPosition());
+            this.updatePosition(user, user.getPosition());
         }
     }
 
@@ -281,17 +301,28 @@ export class GameRoom {
         return this.itemsState;
     }
 
-
+    public canAccess(userTags: string[]): boolean {
-    setViewport(socket : Identificable, viewport: ViewportInterface): Movable[] {
-        const user = this.users.get(socket.userId);
-        if(typeof user === 'undefined') {
-            console.warn('In setViewport, could not find user with ID "'+socket.userId+'" in world.');
-            return [];
-        }
-        return this.positionNotifier.setViewport(user, viewport);
-    }
-
-    canAccess(userTags: string[]): boolean {
         return arrayIntersect(userTags, this.tags);
     }
+
+    public addZoneListener(call: ZoneSocket, x: number, y: number): Set<Movable> {
+        return this.positionNotifier.addZoneListener(call, x, y);
+    }
+
+    public removeZoneListener(call: ZoneSocket, x: number, y: number): void {
+        return this.positionNotifier.removeZoneListener(call, x, y);
+    }
+
+    public adminJoin(admin: Admin): void {
+        this.admins.add(admin);
+
+        // Let's send all connected users
+        for (const user of this.users.values()) {
+            admin.sendUserJoin(user.uuid);
+        }
+    }
+
+    public adminLeave(admin: Admin): void {
+        this.admins.delete(admin);
+    }
 }

back/src/Model/PositionNotifier.ts

@@ -9,11 +9,9 @@
  * number of players around the current player.
  */
 import {EntersCallback, LeavesCallback, MovesCallback, Zone} from "./Zone";
-import {PointInterface} from "_Model/Websocket/PointInterface";
-import {User} from "_Model/User";
-import {ViewportInterface} from "_Model/Websocket/ViewportMessage";
 import {Movable} from "_Model/Movable";
 import {PositionInterface} from "_Model/PositionInterface";
+import {ZoneSocket} from "../RoomManager";
 
 interface ZoneDescriptor {
     i: number;
@@ -36,44 +34,6 @@ export class PositionNotifier {
         }
     }
 
-    /**
-     * Sets the viewport coordinates.
-     * Returns the list of new users to add
-     */
-    public setViewport(user: User, viewport: ViewportInterface): Movable[] {
-        if (viewport.left > viewport.right || viewport.top > viewport.bottom) {
-            console.warn('Invalid viewport received: ', viewport);
-            return [];
-        }
-
-        const oldZones = user.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));
-
-
-        let things: Movable[] = [];
-        for (const zone of addedZones) {
-            zone.startListening(user);
-            things = things.concat(Array.from(zone.getThings()))
-        }
-        for (const zone of removedZones) {
-            zone.stopListening(user);
-        }
-
-        return things;
-    }
-
     public enter(thing: Movable): void {
         const position = thing.getPosition();
         const zoneDesc = this.getZoneDescriptorFromCoordinates(position.x, position.y);
@@ -108,13 +68,6 @@ export class PositionNotifier {
         oldZone.leave(thing, null);
     }
 
-    public removeViewport(user: User): void {
-        // Also, let's stop listening on viewports
-        for (const zone of user.listenedZones) {
-            zone.stopListening(user);
-        }
-    }
-
     private getZone(i: number, j: number): Zone {
         let zoneRow = this.zones[j];
         if (zoneRow === undefined) {
@@ -129,4 +82,15 @@ export class PositionNotifier {
         }
         return zone;
     }
+
+    public addZoneListener(call: ZoneSocket, x: number, y: number): Set<Movable> {
+        const zone = this.getZone(x, y);
+        zone.addListener(call);
+        return zone.getThings();
+    }
+
+    public removeZoneListener(call: ZoneSocket, x: number, y: number): void {
+        const zone = this.getZone(x, y);
+        zone.removeListener(call);
+    }
 }

back/src/Model/User.ts

@@ -2,9 +2,12 @@ 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 {PositionNotifier} from "_Model/PositionNotifier";
-import {ExSocketInterface} from "_Model/Websocket/ExSocketInterface";
+import {ServerDuplexStream} from "grpc";
+import {BatchMessage, PusherToBackMessage, ServerToClientMessage, SubMessage} from "../Messages/generated/messages_pb";
+import {CharacterLayer} from "_Model/Websocket/CharacterLayer";
+
+export type UserSocket = ServerDuplexStream<PusherToBackMessage, ServerToClientMessage>;
 
 export class User implements Movable {
     public listenedZones: Set<Zone>;
@@ -12,11 +15,14 @@ export class User implements Movable {
 
     public constructor(
         public id: number,
-        public uuid: string,
+        public readonly uuid: string,
         private position: PointInterface,
         public silent: boolean,
         private positionNotifier: PositionNotifier,
-        public readonly socket: ExSocketInterface
+        public readonly socket: UserSocket,
+        public readonly tags: string[],
+        public readonly name: string,
+        public readonly characterLayers: CharacterLayer[]
     ) {
         this.listenedZones = new Set<Zone>();
 
@@ -32,4 +38,27 @@ export class User implements Movable {
         this.position = position;
         this.positionNotifier.updatePosition(this, position, oldPosition);
     }
+
+
+    private batchedMessages: BatchMessage = new BatchMessage();
+    private batchTimeout: NodeJS.Timeout|null = null;
+
+    public emitInBatch(payload: SubMessage): void {
+        this.batchedMessages.addPayload(payload);
+
+        if (this.batchTimeout === null) {
+            this.batchTimeout = setTimeout(() => {
+                /*if (socket.disconnecting) {
+                    return;
+                }*/
+
+                const serverToClientMessage = new ServerToClientMessage();
+                serverToClientMessage.setBatchmessage(this.batchedMessages);
+
+                this.socket.write(serverToClientMessage);
+                this.batchedMessages = new BatchMessage();
+                this.batchTimeout = null;
+            }, 100);
+        }
+    }
 }

back/src/Model/Websocket/CharacterLayer.ts

@@ -0,0 +1,4 @@
+export interface CharacterLayer {
+    name: string,
+    url: string|undefined
+}

back/src/Model/Websocket/GroupUpdateInterface.ts

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

back/src/Model/Websocket/JoinRoomMessage.ts

@@ -1,11 +0,0 @@
-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>;

back/src/Model/Websocket/MessageUserJoined.ts

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

back/src/Model/Websocket/MessageUserPosition.ts

@@ -5,7 +5,3 @@ export class Point implements PointInterface{
     }
 }
 
-export class MessageUserPosition {
-    constructor(public userId: number, public name: string, public characterLayers: string[], public position: PointInterface) {
-    }
-}

back/src/Model/Websocket/ProtobufUtils.ts

@@ -5,7 +5,7 @@ import {
     PointMessage,
     PositionMessage
 } from "../../Messages/generated/messages_pb";
-import {CharacterLayer, ExSocketInterface} from "_Model/Websocket/ExSocketInterface";
+import {CharacterLayer} from "_Model/Websocket/CharacterLayer";
 import Direction = PositionMessage.Direction;
 import {ItemEventMessageInterface} from "_Model/Websocket/ItemEventMessage";
 import {PositionInterface} from "_Model/PositionInterface";
@@ -13,7 +13,7 @@ import {PositionInterface} from "_Model/PositionInterface";
 export class ProtobufUtils {
 
     public static toPositionMessage(point: PointInterface): PositionMessage {
-        let direction: PositionMessage.DirectionMap[keyof PositionMessage.DirectionMap];
+        let direction: Direction;
         switch (point.direction) {
             case 'up':
                 direction = Direction.UP;
@@ -105,4 +105,14 @@ export class ProtobufUtils {
             return message;
         });
     }
+
+    public static toCharacterLayerObjects(characterLayers: CharacterLayerMessage[]): CharacterLayer[] {
+        return characterLayers.map(function(characterLayer): CharacterLayer {
+            const url = characterLayer.getUrl();
+            return {
+                name: characterLayer.getName(),
+                url: url ? url : undefined,
+            };
+        });
+    }
 }

back/src/Model/Websocket/SetPlayerDetailsMessage.ts

@@ -1,8 +0,0 @@
-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>;

back/src/Model/Websocket/UserInGroupInterface.ts

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

back/src/Model/Websocket/WebRtcSignalMessage.ts

@@ -1,18 +0,0 @@
-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>;

back/src/Model/Zone.ts

@@ -2,20 +2,21 @@ import {User} from "./User";
 import {PositionInterface} from "_Model/PositionInterface";
 import {Movable} from "./Movable";
 import {Group} from "./Group";
+import {ZoneSocket} from "../RoomManager";
 
-export type EntersCallback = (thing: Movable, listener: User) => void;
+export type EntersCallback = (thing: Movable, fromZone: Zone|null, listener: ZoneSocket) => void;
-export type MovesCallback = (thing: Movable, position: PositionInterface, listener: User) => void;
+export type MovesCallback = (thing: Movable, position: PositionInterface, listener: ZoneSocket) => void;
-export type LeavesCallback = (thing: Movable, listener: User) => void;
+export type LeavesCallback = (thing: Movable, newZone: Zone|null, listener: ZoneSocket) => void;
 
 export class Zone {
     private things: Set<Movable> = new Set<Movable>();
-    private listeners: Set<User> = new Set<User>();
+    private listeners: Set<ZoneSocket> = new Set<ZoneSocket>();
 
     /**
      * @param x For debugging purpose only
      * @param y For debugging purpose only
      */
-    constructor(private onEnters: EntersCallback, private onMoves: MovesCallback, private onLeaves: LeavesCallback, private x: number, private y: number) {
+    constructor(private onEnters: EntersCallback, private onMoves: MovesCallback, private onLeaves: LeavesCallback, public readonly x: number, public readonly y: number) {
     }
 
     /**
@@ -40,9 +41,9 @@ export class Zone {
      */
     private notifyLeft(thing: Movable, newZone: Zone|null) {
         for (const listener of this.listeners) {
-            if (listener !== thing && (newZone === null || !listener.listenedZones.has(newZone))) {
+            //if (listener !== thing && (newZone === null || !listener.listenedZones.has(newZone))) {
-                this.onLeaves(thing, listener);
+                this.onLeaves(thing, newZone, listener);
-            }
+            //}
         }
     }
 
@@ -56,16 +57,19 @@ export class Zone {
      */
     private notifyEnter(thing: Movable, oldZone: Zone|null, position: PositionInterface) {
         for (const listener of this.listeners) {
-            if (listener === thing) {
+
+            /*if (listener === thing) {
                 continue;
             }
             if (oldZone === null || !listener.listenedZones.has(oldZone)) {
                 this.onEnters(thing, listener);
             } else {
                 this.onMoves(thing, position, listener);
+            }*/
+            this.onEnters(thing, oldZone, listener);
         }
     }
-    }
+
 
     public move(thing: Movable, position: PositionInterface) {
         if (!this.things.has(thing)) {
@@ -75,13 +79,13 @@ export class Zone {
         }
 
         for (const listener of this.listeners) {
-            if (listener !== thing) {
+            //if (listener !== thing) {
                 this.onMoves(thing,position, listener);
-            }
+            //}
         }
     }
 
-    public startListening(listener: User): void {
+    /*public startListening(listener: User): void {
         for (const thing of this.things) {
             if (thing !== listener) {
                 this.onEnters(thing, listener);
@@ -101,9 +105,18 @@ export class Zone {
 
         this.listeners.delete(listener);
         listener.listenedZones.delete(this);
-    }
+    }*/
 
     public getThings(): Set<Movable> {
         return this.things;
     }
+
+    public addListener(socket: ZoneSocket): void {
+        this.listeners.add(socket);
+        // TODO: here, we should trigger in some way the sending of current items
+    }
+
+    public removeListener(socket: ZoneSocket): void {
+        this.listeners.delete(socket);
+    }
 }

back/src/RoomManager.ts

@@ -0,0 +1,206 @@
+import {IRoomManagerServer} from "./Messages/generated/messages_grpc_pb";
+import {
+    AdminGlobalMessage,
+    AdminMessage,
+    AdminPusherToBackMessage, BanMessage,
+    ClientToServerMessage, EmptyMessage,
+    ItemEventMessage,
+    JoinRoomMessage,
+    PlayGlobalMessage,
+    PusherToBackMessage,
+    QueryJitsiJwtMessage,
+    ReportPlayerMessage,
+    RoomJoinedMessage,
+    ServerToAdminClientMessage,
+    ServerToClientMessage,
+    SilentMessage,
+    UserMovesMessage,
+    ViewportMessage,
+    WebRtcSignalToServerMessage,
+    ZoneMessage
+} from "./Messages/generated/messages_pb";
+import grpc, {sendUnaryData, ServerDuplexStream, ServerUnaryCall, ServerWritableStream} from "grpc";
+import {Empty} from "google-protobuf/google/protobuf/empty_pb";
+import {socketManager} from "./Services/SocketManager";
+import {emitError} from "./Services/MessageHelpers";
+import {User, UserSocket} from "./Model/User";
+import {GameRoom} from "./Model/GameRoom";
+import Debug from "debug";
+import {Admin} from "./Model/Admin";
+
+const debug = Debug('roommanager');
+
+export type AdminSocket = ServerDuplexStream<AdminPusherToBackMessage, ServerToAdminClientMessage>;
+export type ZoneSocket = ServerWritableStream<ZoneMessage, ServerToClientMessage>;
+
+const roomManager: IRoomManagerServer = {
+    joinRoom: (call: UserSocket): void => {
+        console.log('joinRoom called');
+
+        let room: GameRoom|null = null;
+        let user: User|null = null;
+
+        call.on('data', (message: PusherToBackMessage) => {
+            try {
+                if (room === null || user === null) {
+                    if (message.hasJoinroommessage()) {
+                        socketManager.handleJoinRoom(call, message.getJoinroommessage() as JoinRoomMessage).then(({room: gameRoom, user: myUser}) => {
+                            room = gameRoom;
+                            user = myUser;
+                        });
+                    } else {
+                        throw new Error('The first message sent MUST be of type JoinRoomMessage');
+                    }
+                } else {
+                    if (message.hasJoinroommessage()) {
+                        throw new Error('Cannot call JoinRoomMessage twice!');
+                    /*} else if (message.hasViewportmessage()) {
+                        socketManager.handleViewport(client, message.getViewportmessage() as ViewportMessage);*/
+                    } else if (message.hasUsermovesmessage()) {
+                        socketManager.handleUserMovesMessage(room, user, message.getUsermovesmessage() as UserMovesMessage);
+                        /*} else if (message.hasSetplayerdetailsmessage()) {
+                            socketManager.handleSetPlayerDetails(client, message.getSetplayerdetailsmessage() as SetPlayerDetailsMessage);*/
+                    } else if (message.hasSilentmessage()) {
+                        socketManager.handleSilentMessage(room, user, message.getSilentmessage() as SilentMessage);
+                    } else if (message.hasItemeventmessage()) {
+                        socketManager.handleItemEvent(room, user, message.getItemeventmessage() as ItemEventMessage);
+                    } else if (message.hasWebrtcsignaltoservermessage()) {
+                        socketManager.emitVideo(room, user, message.getWebrtcsignaltoservermessage() as WebRtcSignalToServerMessage);
+                    } else if (message.hasWebrtcscreensharingsignaltoservermessage()) {
+                        socketManager.emitScreenSharing(room, user, message.getWebrtcscreensharingsignaltoservermessage() as WebRtcSignalToServerMessage);
+                    } else if (message.hasPlayglobalmessage()) {
+                        socketManager.emitPlayGlobalMessage(room, message.getPlayglobalmessage() as PlayGlobalMessage);
+                    /*} else if (message.hasReportplayermessage()){
+                        socketManager.handleReportMessage(client, message.getReportplayermessage() as ReportPlayerMessage);*/
+                    } else if (message.hasQueryjitsijwtmessage()){
+                        socketManager.handleQueryJitsiJwtMessage(user, message.getQueryjitsijwtmessage() as QueryJitsiJwtMessage);
+                    } else {
+                        throw new Error('Unhandled message type');
+                    }
+                }
+            } catch (e) {
+                emitError(call, e);
+                call.end();
+            }
+
+        });
+
+        call.on('end', () => {
+            debug('joinRoom ended');
+            if (user !== null && room !== null) {
+                socketManager.leaveRoom(room, user);
+            }
+            call.end();
+            room = null;
+            user = null;
+        });
+
+        call.on('error', (err: Error) => {
+            console.error('An error occurred in joinRoom stream:', err);
+        });
+
+    },
+
+    listenZone(call: ZoneSocket): void {
+        debug('listenZone called');
+        const zoneMessage = call.request;
+
+        socketManager.addZoneListener(call, zoneMessage.getRoomid(), zoneMessage.getX(), zoneMessage.getY());
+
+        call.on('cancelled', () => {
+            debug('listenZone cancelled');
+            socketManager.removeZoneListener(call, zoneMessage.getRoomid(), zoneMessage.getX(), zoneMessage.getY());
+            call.end();
+        })
+
+        /*call.on('finish', () => {
+            debug('listenZone finish');
+        })*/
+        call.on('close', () => {
+            debug('listenZone connection closed');
+            socketManager.removeZoneListener(call, zoneMessage.getRoomid(), zoneMessage.getX(), zoneMessage.getY());
+        }).on('error', (e) => {
+            console.error('An error occurred in listenZone stream:', e);
+            socketManager.removeZoneListener(call, zoneMessage.getRoomid(), zoneMessage.getX(), zoneMessage.getY());
+            call.end();
+        });
+    },
+
+    adminRoom(call: AdminSocket): void {
+        console.log('adminRoom called');
+
+        const admin = new Admin(call);
+        let room: GameRoom|null = null;
+
+        call.on('data', (message: AdminPusherToBackMessage) => {
+            try {
+                if (room === null) {
+                    if (message.hasSubscribetoroom()) {
+                        const roomId = message.getSubscribetoroom();
+                        socketManager.handleJoinAdminRoom(admin, roomId).then((gameRoom: GameRoom) => {
+                            room = gameRoom;
+                        });
+                    } else {
+                        throw new Error('The first message sent MUST be of type JoinRoomMessage');
+                    }
+                } else {
+                    /*if (message.hasJoinroommessage()) {
+                        throw new Error('Cannot call JoinRoomMessage twice!');
+                    } else if (message.hasUsermovesmessage()) {
+                        socketManager.handleUserMovesMessage(room, user, message.getUsermovesmessage() as UserMovesMessage);
+                    } else if (message.hasSilentmessage()) {
+                        socketManager.handleSilentMessage(room, user, message.getSilentmessage() as SilentMessage);
+                    } else if (message.hasItemeventmessage()) {
+                        socketManager.handleItemEvent(room, user, message.getItemeventmessage() as ItemEventMessage);
+                    } else if (message.hasWebrtcsignaltoservermessage()) {
+                        socketManager.emitVideo(room, user, message.getWebrtcsignaltoservermessage() as WebRtcSignalToServerMessage);
+                    } else if (message.hasWebrtcscreensharingsignaltoservermessage()) {
+                        socketManager.emitScreenSharing(room, user, message.getWebrtcscreensharingsignaltoservermessage() as WebRtcSignalToServerMessage);
+                    } else if (message.hasPlayglobalmessage()) {
+                        socketManager.emitPlayGlobalMessage(room, message.getPlayglobalmessage() as PlayGlobalMessage);
+                    } else if (message.hasQueryjitsijwtmessage()){
+                        socketManager.handleQueryJitsiJwtMessage(user, message.getQueryjitsijwtmessage() as QueryJitsiJwtMessage);
+                    } else {
+                        throw new Error('Unhandled message type');
+                    }*/
+                }
+            } catch (e) {
+                emitError(call, e);
+                call.end();
+            }
+
+        });
+
+        call.on('end', () => {
+            debug('joinRoom ended');
+            if (room !== null) {
+                socketManager.leaveAdminRoom(room, admin);
+            }
+            call.end();
+            room = null;
+        });
+
+        call.on('error', (err: Error) => {
+            console.error('An error occurred in joinAdminRoom stream:', err);
+        });
+    },
+    sendAdminMessage(call: ServerUnaryCall<AdminMessage>, callback: sendUnaryData<EmptyMessage>): void {
+
+        socketManager.sendAdminMessage(call.request.getRoomid(), call.request.getRecipientuuid(), call.request.getMessage());
+
+        callback(null, new EmptyMessage());
+    },
+    sendGlobalAdminMessage(call: ServerUnaryCall<AdminGlobalMessage>, callback: sendUnaryData<EmptyMessage>): void {
+        throw new Error('Not implemented yet');
+        // TODO
+        callback(null, new EmptyMessage());
+    },
+    ban(call: ServerUnaryCall<BanMessage>, callback: sendUnaryData<EmptyMessage>): void {
+
+        socketManager.banUser(call.request.getRoomid(), call.request.getRecipientuuid());
+
+        callback(null, new EmptyMessage());
+    },
+};
+
+export {roomManager};

back/src/Services/MessageHelpers.ts

@@ -0,0 +1,15 @@
+import {ErrorMessage, ServerToClientMessage} from "../Messages/generated/messages_pb";
+import {UserSocket} from "_Model/User";
+
+export function emitError(Client: UserSocket, message: string): void {
+    const errorMessage = new ErrorMessage();
+    errorMessage.setMessage(message);
+
+    const serverToClientMessage = new ServerToClientMessage();
+    serverToClientMessage.setErrormessage(errorMessage);
+
+    //if (!Client.disconnecting) {
+        Client.write(serverToClientMessage);
+    //}
+    console.warn(message);
+}

back/src/Services/SocketManager.ts

@@ -1,5 +1,5 @@
 import {GameRoom} from "../Model/GameRoom";
-import {CharacterLayer, ExSocketInterface} from "../Model/Websocket/ExSocketInterface";
+import {CharacterLayer} from "_Model/Websocket/CharacterLayer";
 import {
     GroupDeleteMessage,
     GroupUpdateMessage,
@@ -14,33 +14,43 @@ import {
     SilentMessage,
     SubMessage,
     ReportPlayerMessage,
-    UserJoinedMessage, UserLeftMessage,
+    UserJoinedMessage,
+    UserLeftMessage,
     UserMovedMessage,
     UserMovesMessage,
-    ViewportMessage, WebRtcDisconnectMessage,
+    ViewportMessage,
+    WebRtcDisconnectMessage,
     WebRtcSignalToClientMessage,
     WebRtcSignalToServerMessage,
     WebRtcStartMessage,
     QueryJitsiJwtMessage,
     SendJitsiJwtMessage,
-    SendUserMessage
+    SendUserMessage,
+    JoinRoomMessage,
+    Zone as ProtoZone,
+    BatchMessage,
+    BatchToPusherMessage,
+    SubToPusherMessage,
+    UserJoinedZoneMessage, GroupUpdateZoneMessage, GroupLeftZoneMessage, UserLeftZoneMessage, AdminMessage, BanMessage
 } from "../Messages/generated/messages_pb";
-import {PointInterface} from "../Model/Websocket/PointInterface";
+import {User, UserSocket} from "../Model/User";
-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 {ADMIN_API_URL, GROUP_RADIUS, JITSI_ISS, MINIMUM_DISTANCE, SECRET_JITSI_KEY} from "../Enum/EnvironmentVariable";
-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 {adminApi, CharacterTexture, FetchMemberDataByUuidResponse} 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 {AdminSocket, ZoneSocket} from "../RoomManager";
+import {Zone} from "_Model/Zone";
+import Debug from "debug";
+import {Admin} from "_Model/Admin";
+
+const debug = Debug('sockermanager');
 
 interface AdminSocketRoomsList {
     [index: string]: number;
@@ -54,9 +64,16 @@ export interface AdminSocketData {
     users: AdminSocketUsersList,
 }
 
+function emitZoneMessage(subMessage: SubToPusherMessage, socket: ZoneSocket): void {
+    // TODO: should we batch those every 100ms?
+    const batchMessage = new BatchToPusherMessage();
+    batchMessage.addPayload(subMessage);
+
+    socket.write(batchMessage);
+}
+
 export class SocketManager {
-    private Worlds: Map<string, GameRoom> = new Map<string, GameRoom>();
+    private rooms: Map<string, GameRoom> = new Map<string, GameRoom>();
-    private sockets: Map<number, ExSocketInterface> = new Map<number, ExSocketInterface>();
 
     constructor() {
         clientEventsEmitter.registerToClientJoin((clientUUid: string, roomId: string) => {
@@ -67,12 +84,12 @@ export class SocketManager {
         });
     }
 
-    getAdminSocketDataFor(roomId:string): AdminSocketData {
+    /*getAdminSocketDataFor(roomId:string): AdminSocketData {
         const data:AdminSocketData = {
             rooms: {},
             users: {},
         }
-        const room = this.Worlds.get(roomId);
+        const room = this.rooms.get(roomId);
         if (room === undefined) {
             return data;
         }
@@ -82,21 +99,28 @@ export class SocketManager {
             data.users[user.uuid] = true
         })
         return data;
-    }
+    }*/
+
+    public async handleJoinRoom(socket: UserSocket, joinRoomMessage: JoinRoomMessage): Promise<{ room: GameRoom; user: User }> {
+        /*const positionMessage = joinRoomMessage.getPositionmessage();
+        if (positionMessage === undefined) {
+            // TODO: send error message?
+            throw new Error('Empty pointMessage found in JoinRoomMessage');
+        }*/
+
+        //const position = ProtobufUtils.toPointInterface(positionMessage);
+        //const viewport = client.viewport;
+
+        //this.sockets.set(client.userId, client); //todo: should this be at the end of the function?
 
-    handleJoinRoom(client: ExSocketInterface): void {
-        const position = client.position;
-        const viewport = client.viewport;
-        try {
-            this.sockets.set(client.userId, client); //todo: should this be at the end of the function?
         //join new previous room
-            const gameRoom = this.joinRoom(client, position);
+        const {room, user} = await this.joinRoom(socket, joinRoomMessage);
 
-            const things = gameRoom.setViewport(client, viewport);
+        //const things = room.setViewport(client, viewport);
 
         const roomJoinedMessage = new RoomJoinedMessage();
 
-            for (const thing of things) {
+        /*for (const thing of things) {
             if (thing instanceof User) {
                 const player: ExSocketInterface|undefined = this.sockets.get(thing.id);
                 if (player === undefined) {
@@ -111,7 +135,7 @@ export class SocketManager {
                 userJoinedMessage.setPosition(ProtobufUtils.toPositionMessage(player.position));
 
                 roomJoinedMessage.addUser(userJoinedMessage);
-                    roomJoinedMessage.setTagList(client.tags);
+                roomJoinedMessage.setTagList(joinRoomMessage.getTagList());
             } else if (thing instanceof Group) {
                 const groupUpdateMessage = new GroupUpdateMessage();
                 groupUpdateMessage.setGroupid(thing.getId());
@@ -121,9 +145,9 @@ export class SocketManager {
             } else {
                 console.error("Unexpected type for Movable returned by setViewport");
             }
-            }
+        }*/
 
-            for (const [itemId, item] of gameRoom.getItemsState().entries()) {
+        for (const [itemId, item] of room.getItemsState().entries()) {
             const itemStateMessage = new ItemStateMessage();
             itemStateMessage.setItemid(itemId);
             itemStateMessage.setStatejson(JSON.stringify(item));
@@ -131,48 +155,39 @@ export class SocketManager {
             roomJoinedMessage.addItem(itemStateMessage);
         }
 
-            roomJoinedMessage.setCurrentuserid(client.userId);
+        roomJoinedMessage.setCurrentuserid(user.id);
 
         const serverToClientMessage = new ServerToClientMessage();
         serverToClientMessage.setRoomjoinedmessage(roomJoinedMessage);
 
+        //user.socket.write(serverToClientMessage);
+        console.log('SENDING MESSAGE roomJoinedMessage');
+        socket.write(serverToClientMessage);
+
+        return {
+            room,
+            user
+        };
+
+        /*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);
-        }
     }
 
-    handleViewport(client: ExSocketInterface, viewportMessage: ViewportMessage) {
+    handleUserMovesMessage(room: GameRoom, user: User, userMovesMessage: UserMovesMessage) {
-        try {
-            const viewport = viewportMessage.toObject();
-
-            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) {
         try {
             const userMoves = userMovesMessage.toObject();
+            const position = userMovesMessage.getPosition();
 
             // If CPU is high, let's drop messages of users moving (we will only dispatch the final position)
             if (cpuTracker.isOverHeating() && userMoves.position?.moving === true) {
                 return;
             }
 
-            const position = userMoves.position;
             if (position === undefined) {
                 throw new Error('Position not found in message');
             }
@@ -181,41 +196,18 @@ export class SocketManager {
                 throw new Error('Viewport not found in message');
             }
 
-            let direction: string;
-            switch (position.direction) {
-                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
-            client.position = {
+            /*client.position = {
                 x: position.x,
                 y: position.y,
                 direction,
                 moving: position.moving,
             };
-            client.viewport = viewport;
+            client.viewport = viewport;*/
 
             // update position in the world
-            const world = this.Worlds.get(client.roomId);
+            room.updatePosition(user, ProtobufUtils.toPointInterface(position));
-            if (!world) {
+            //room.setViewport(client, client.viewport);
-                console.error("In USER_POSITION, could not find world with id '", client.roomId, "'");
-                return;
-            }
-            world.updatePosition(client, client.position);
-            world.setViewport(client, client.viewport);
         } catch (e) {
             console.error('An error occurred on "user_position" event');
             console.error(e);
@@ -223,7 +215,7 @@ export class SocketManager {
     }
 
     // Useless now, will be useful again if we allow editing details in game
-    handleSetPlayerDetails(client: ExSocketInterface, playerDetailsMessage: SetPlayerDetailsMessage) {
+    /*handleSetPlayerDetails(client: UserSocket, playerDetailsMessage: SetPlayerDetailsMessage) {
         const playerDetails = {
             name: playerDetailsMessage.getName(),
             characterLayers: playerDetailsMessage.getCharacterlayersList()
@@ -235,51 +227,39 @@ export class SocketManager {
         }
         client.name = playerDetails.name;
         client.characterLayers = SocketManager.mergeCharacterLayersAndCustomTextures(playerDetails.characterLayers, client.textures);
-    }
+    }*/
 
-    handleSilentMessage(client: ExSocketInterface, silentMessage: SilentMessage) {
+    handleSilentMessage(room: GameRoom, user: User, silentMessage: SilentMessage) {
         try {
-            // update position in the world
+            room.setSilent(user, silentMessage.getSilent());
-            const world = this.Worlds.get(client.roomId);
-            if (!world) {
-                console.error("In handleSilentMessage, could not find world with id '", client.roomId, "'");
-                return;
-            }
-            world.setSilent(client, silentMessage.getSilent());
         } catch (e) {
             console.error('An error occurred on "handleSilentMessage"');
             console.error(e);
         }
     }
 
-    handleItemEvent(ws: ExSocketInterface, itemEventMessage: ItemEventMessage) {
+    handleItemEvent(room: GameRoom, user: User, itemEventMessage: ItemEventMessage) {
         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()) {
+            // TODO: move this in the GameRoom class.
-                const client = this.searchClientByIdOrFail(user.id);
+            for (const user of room.getUsers().values()) {
-                //client.emit(SocketIoEvent.ITEM_EVENT, itemEvent);
+                user.emitInBatch(subMessage);
-                emitInBatch(client, subMessage);
             }
 
-            world.setItemState(itemEvent.itemId, itemEvent.state);
+            room.setItemState(itemEvent.itemId, itemEvent.state);
         } catch (e) {
             console.error('An error occurred on "item_event"');
             console.error(e);
         }
     }
 
-    async handleReportMessage(client: ExSocketInterface, reportPlayerMessage: ReportPlayerMessage) {
+    // TODO: handle this message in pusher
+    /*async handleReportMessage(client: ExSocketInterface, reportPlayerMessage: ReportPlayerMessage) {
         try {
             const reportedSocket = this.sockets.get(reportPlayerMessage.getReporteduserid());
             if (!reportedSocket) {
@@ -291,83 +271,69 @@ export class SocketManager {
             console.error('An error occurred on "handleReportMessage"');
             console.error(e);
         }
-    }
+    }*/
 
-    emitVideo(socket: ExSocketInterface, data: WebRtcSignalToServerMessage): void {
+    emitVideo(room: GameRoom, user: User, data: WebRtcSignalToServerMessage): void {
         //send only at user
-        const client = this.sockets.get(data.getReceiverid());
+        const remoteUser = room.getUsers().get(data.getReceiverid());
-        if (client === undefined) {
+        if (remoteUser === 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.setUserid(user.id);
         webrtcSignalToClient.setSignal(data.getSignal());
 
         const serverToClientMessage = new ServerToClientMessage();
         serverToClientMessage.setWebrtcsignaltoclientmessage(webrtcSignalToClient);
 
-        if (!client.disconnecting) {
+        //if (!client.disconnecting) {
-            client.send(serverToClientMessage.serializeBinary().buffer, true);
+            remoteUser.socket.write(serverToClientMessage);
-        }
+        //}
     }
 
-    emitScreenSharing(socket: ExSocketInterface, data: WebRtcSignalToServerMessage): void {
+    emitScreenSharing(room: GameRoom, user: User, data: WebRtcSignalToServerMessage): void {
         //send only at user
-        const client = this.sockets.get(data.getReceiverid());
+        const remoteUser = room.getUsers().get(data.getReceiverid());
-        if (client === undefined) {
+        if (remoteUser === 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.setUserid(user.id);
         webrtcSignalToClient.setSignal(data.getSignal());
 
         const serverToClientMessage = new ServerToClientMessage();
         serverToClientMessage.setWebrtcscreensharingsignaltoclientmessage(webrtcSignalToClient);
 
-        if (!client.disconnecting) {
+        //if (!client.disconnecting) {
-            client.send(serverToClientMessage.serializeBinary().buffer, true);
+            remoteUser.socket.write(serverToClientMessage);
-        }
+        //}
     }
 
-    private searchClientByIdOrFail(userId: number): ExSocketInterface {
+    leaveRoom(room: GameRoom, user: User){
-        const client: ExSocketInterface|undefined = this.sockets.get(userId);
-        if (client === undefined) {
-            throw new Error("Could not find user with id " + userId);
-        }
-        return client;
-    }
-
-    leaveRoom(Client : ExSocketInterface){
         // leave previous room and world
-        if(Client.roomId){
         try {
             //user leave previous world
-                const world: GameRoom | undefined = this.Worlds.get(Client.roomId);
+            room.leave(user);
-                if (world) {
+            if (room.isEmpty()) {
-                    world.leave(Client);
+                this.rooms.delete(room.roomId);
-                    if (world.isEmpty()) {
-                        this.Worlds.delete(Client.roomId);
                 gaugeManager.decNbRoomGauge();
+                debug('Room is empty. Deleting room "%s"', room.roomId);
             }
-                }
-                //user leave previous room
-                //Client.leave(Client.roomId);
         } finally {
             //delete Client.roomId;
-                this.sockets.delete(Client.userId);
+            //this.sockets.delete(Client.userId);
-                clientEventsEmitter.emitClientLeave(Client.userUuid, Client.roomId);
+            clientEventsEmitter.emitClientLeave(user.uuid, room.roomId);
-                console.log('A user left (', this.sockets.size, ' connected users)');
+            console.log('A user left');
-            }
         }
     }
 
     async getOrCreateRoom(roomId: string): Promise<GameRoom> {
         //check and create new world for a room
-        let world = this.Worlds.get(roomId)
+        let world = this.rooms.get(roomId)
         if(world === undefined){
             world = new GameRoom(
                 roomId,
@@ -375,9 +341,9 @@ export class SocketManager {
                 (user: User, group: Group) => this.disConnectedUser(user, group),
                 MINIMUM_DISTANCE,
                 GROUP_RADIUS,
-                (thing: Movable, listener: User) => this.onRoomEnter(thing, listener),
+                (thing: Movable, fromZone: Zone|null, listener: ZoneSocket) => this.onZoneEnter(thing, fromZone, listener),
-                (thing: Movable, position:PositionInterface, listener:User) => this.onClientMove(thing, position, listener),
+                (thing: Movable, position:PositionInterface, listener: ZoneSocket) => this.onClientMove(thing, position, listener),
-                (thing: Movable, listener:User) => this.onClientLeave(thing, listener)
+                (thing: Movable, newZone: Zone|null, listener: ZoneSocket) => this.onClientLeave(thing, newZone, listener)
             );
             if (!world.anonymous) {
                 const data = await adminApi.fetchMapDetails(world.organizationSlug, world.worldSlug, world.roomSlug)
@@ -385,125 +351,133 @@ export class SocketManager {
                 world.policyType = Number(data.policy_type)
             }
             gaugeManager.incNbRoomGauge();
-            this.Worlds.set(roomId, world);
+            this.rooms.set(roomId, world);
         }
         return Promise.resolve(world)
     }
 
-    private joinRoom(client : ExSocketInterface, position: PointInterface): GameRoom {
+    private async joinRoom(socket: UserSocket, joinRoomMessage: JoinRoomMessage): Promise<{ room: GameRoom; user: User }> {
 
-        const roomId = client.roomId;
+        const roomId = joinRoomMessage.getRoomid();
-        client.position = position;
 
-        const world = this.Worlds.get(roomId)
+        const world = await socketManager.getOrCreateRoom(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) => {
+        /*world.getGroups().forEach((group: Group) => {
-            this.emitCreateUpdateGroupEvent(client, group);
+            this.emitCreateUpdateGroupEvent(socket, group);
-        });
+        });*/
+
         //join world
-        world.join(client, client.position);
+        const user = world.join(socket, joinRoomMessage);
-        clientEventsEmitter.emitClientJoin(client.userUuid, client.roomId);
+
-        console.log(new Date().toISOString() + ' A user joined (', this.sockets.size, ' connected users)');
+        clientEventsEmitter.emitClientJoin(user.uuid, roomId);
-        return world;
+        //console.log(new Date().toISOString() + ' A user joined (', this.sockets.size, ' connected users)');
+        console.log(new Date().toISOString() + ' A user joined');
+        return {room: world, user};
     }
 
-    private onRoomEnter(thing: Movable, listener: User) {
+    private onZoneEnter(thing: Movable, fromZone: Zone|null, listener: ZoneSocket) {
-        const clientListener = this.searchClientByIdOrFail(listener.id);
         if (thing instanceof User) {
-            const clientUser = this.searchClientByIdOrFail(thing.id);
+            const userJoinedZoneMessage = new UserJoinedZoneMessage();
-
+            if (!Number.isInteger(thing.id)) {
-            const userJoinedMessage = new UserJoinedMessage();
+                throw new Error('clientUser.userId is not an integer '+thing.id);
-            if (!Number.isInteger(clientUser.userId)) {
-                throw new Error('clientUser.userId is not an integer '+clientUser.userId);
             }
-            userJoinedMessage.setUserid(clientUser.userId);
+            userJoinedZoneMessage.setUserid(thing.id);
-            userJoinedMessage.setName(clientUser.name);
+            userJoinedZoneMessage.setName(thing.name);
-            userJoinedMessage.setCharacterlayersList(ProtobufUtils.toCharacterLayerMessages(clientUser.characterLayers));
+            userJoinedZoneMessage.setCharacterlayersList(ProtobufUtils.toCharacterLayerMessages(thing.characterLayers));
-            userJoinedMessage.setPosition(ProtobufUtils.toPositionMessage(clientUser.position));
+            userJoinedZoneMessage.setPosition(ProtobufUtils.toPositionMessage(thing.getPosition()));
+            userJoinedZoneMessage.setFromzone(this.toProtoZone(fromZone));
 
-            const subMessage = new SubMessage();
+            const subMessage = new SubToPusherMessage();
-            subMessage.setUserjoinedmessage(userJoinedMessage);
+            subMessage.setUserjoinedzonemessage(userJoinedZoneMessage);
 
-            emitInBatch(clientListener, subMessage);
+            emitZoneMessage(subMessage, listener);
+            //listener.emitInBatch(subMessage);
         } else if (thing instanceof Group) {
-            this.emitCreateUpdateGroupEvent(clientListener, thing);
+            this.emitCreateUpdateGroupEvent(listener, fromZone, thing);
         } else {
             console.error('Unexpected type for Movable.');
         }
     }
 
-    private onClientMove(thing: Movable, position:PositionInterface, listener:User): void {
+    private onClientMove(thing: Movable, position:PositionInterface, listener: ZoneSocket): 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.setUserid(thing.id);
-            userMovedMessage.setPosition(ProtobufUtils.toPositionMessage(clientUser.position));
+            userMovedMessage.setPosition(ProtobufUtils.toPositionMessage(thing.getPosition()));
 
-            const subMessage = new SubMessage();
+            const subMessage = new SubToPusherMessage();
             subMessage.setUsermovedmessage(userMovedMessage);
 
-            clientListener.emitInBatch(subMessage);
+            emitZoneMessage(subMessage, listener);
+            //listener.emitInBatch(subMessage);
             //console.log("Sending USER_MOVED event");
         } else if (thing instanceof Group) {
-            this.emitCreateUpdateGroupEvent(clientListener, thing);
+            this.emitCreateUpdateGroupEvent(listener, null, thing);
         } else {
             console.error('Unexpected type for Movable.');
         }
     }
 
-    private onClientLeave(thing: Movable, listener:User) {
+    private onClientLeave(thing: Movable, newZone: Zone|null, listener: ZoneSocket) {
-        const clientListener = this.searchClientByIdOrFail(listener.id);
         if (thing instanceof User) {
-            const clientUser = this.searchClientByIdOrFail(thing.id);
+            this.emitUserLeftEvent(listener, thing.id, newZone);
-            this.emitUserLeftEvent(clientListener, clientUser.userId);
         } else if (thing instanceof Group) {
-            this.emitDeleteGroupEvent(clientListener, thing.getId());
+            this.emitDeleteGroupEvent(listener, thing.getId(), newZone);
         } else {
             console.error('Unexpected type for Movable.');
         }
     }
 
-    private emitCreateUpdateGroupEvent(client: ExSocketInterface, group: Group): void {
+    private emitCreateUpdateGroupEvent(client: ZoneSocket, fromZone: Zone|null, 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();
+        const groupUpdateMessage = new GroupUpdateZoneMessage();
         groupUpdateMessage.setGroupid(group.getId());
         groupUpdateMessage.setPosition(pointMessage);
         groupUpdateMessage.setGroupsize(group.getSize);
+        groupUpdateMessage.setFromzone(this.toProtoZone(fromZone));
 
-        const subMessage = new SubMessage();
+        const subMessage = new SubToPusherMessage();
-        subMessage.setGroupupdatemessage(groupUpdateMessage);
+        subMessage.setGroupupdatezonemessage(groupUpdateMessage);
 
-        emitInBatch(client, subMessage);
+        emitZoneMessage(subMessage, client);
-        //socket.emit(SocketIoEvent.GROUP_CREATE_UPDATE, groupUpdateMessage.serializeBinary().buffer);
+        //client.emitInBatch(subMessage);
     }
 
-    private emitDeleteGroupEvent(client: ExSocketInterface, groupId: number): void {
+    private emitDeleteGroupEvent(client: ZoneSocket, groupId: number, newZone: Zone|null): void {
-        const groupDeleteMessage = new GroupDeleteMessage();
+        const groupDeleteMessage = new GroupLeftZoneMessage();
         groupDeleteMessage.setGroupid(groupId);
+        groupDeleteMessage.setTozone(this.toProtoZone(newZone));
 
-        const subMessage = new SubMessage();
+        const subMessage = new SubToPusherMessage();
-        subMessage.setGroupdeletemessage(groupDeleteMessage);
+        subMessage.setGroupleftzonemessage(groupDeleteMessage);
 
-        emitInBatch(client, subMessage);
+        emitZoneMessage(subMessage, client);
+        //user.emitInBatch(subMessage);
     }
 
-    private emitUserLeftEvent(client: ExSocketInterface, userId: number): void {
+    private emitUserLeftEvent(client: ZoneSocket, userId: number, newZone: Zone|null): void {
-        const userLeftMessage = new UserLeftMessage();
+        const userLeftMessage = new UserLeftZoneMessage();
         userLeftMessage.setUserid(userId);
+        userLeftMessage.setTozone(this.toProtoZone(newZone));
 
-        const subMessage = new SubMessage();
+        const subMessage = new SubToPusherMessage();
-        subMessage.setUserleftmessage(userLeftMessage);
+        subMessage.setUserleftzonemessage(userLeftMessage);
 
-        emitInBatch(client, subMessage);
+        emitZoneMessage(subMessage, client);
+    }
+
+    private toProtoZone(zone: Zone|null): ProtoZone|undefined {
+        if (zone !== null) {
+            const zoneMessage = new ProtoZone();
+            zoneMessage.setX(zone.x);
+            zoneMessage.setY(zone.y);
+            return zoneMessage;
+        }
+        return undefined;
     }
 
     private joinWebRtcRoom(user: User, group: Group) {
@@ -520,29 +494,29 @@ export class SocketManager {
             // 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.setName(otherUser.name);
             webrtcStartMessage1.setInitiator(true);
 
             const serverToClientMessage1 = new ServerToClientMessage();
             serverToClientMessage1.setWebrtcstartmessage(webrtcStartMessage1);
 
-            if (!user.socket.disconnecting) {
+            //if (!user.socket.disconnecting) {
-                user.socket.send(serverToClientMessage1.serializeBinary().buffer, true);
+                user.socket.write(serverToClientMessage1);
                 //console.log('Sending webrtcstart initiator to '+user.socket.userId)
-            }
+            //}
 
             const webrtcStartMessage2 = new WebRtcStartMessage();
             webrtcStartMessage2.setUserid(user.id);
-            webrtcStartMessage2.setName(user.socket.name);
+            webrtcStartMessage2.setName(user.name);
             webrtcStartMessage2.setInitiator(false);
 
             const serverToClientMessage2 = new ServerToClientMessage();
             serverToClientMessage2.setWebrtcstartmessage(webrtcStartMessage2);
 
-            if (!otherUser.socket.disconnecting) {
+            //if (!otherUser.socket.disconnecting) {
-                otherUser.socket.send(serverToClientMessage2.serializeBinary().buffer, true);
+                otherUser.socket.write(serverToClientMessage2);
                 //console.log('Sending webrtcstart to '+otherUser.socket.userId)
-            }
+            //}
 
         }
     }
@@ -565,9 +539,9 @@ export class SocketManager {
             const serverToClientMessage1 = new ServerToClientMessage();
             serverToClientMessage1.setWebrtcdisconnectmessage(webrtcDisconnectMessage1);
 
-            if (!otherUser.socket.disconnecting) {
+            //if (!otherUser.socket.disconnecting) {
-                otherUser.socket.send(serverToClientMessage1.serializeBinary().buffer, true);
+                otherUser.socket.write(serverToClientMessage1);
-            }
+            //}
 
 
             const webrtcDisconnectMessage2 = new WebRtcDisconnectMessage();
@@ -576,25 +550,19 @@ export class SocketManager {
             const serverToClientMessage2 = new ServerToClientMessage();
             serverToClientMessage2.setWebrtcdisconnectmessage(webrtcDisconnectMessage2);
 
-            if (!user.socket.disconnecting) {
+            //if (!user.socket.disconnecting) {
-                user.socket.send(serverToClientMessage2.serializeBinary().buffer, true);
+                user.socket.write(serverToClientMessage2);
-            }
+            //}
         }
     }
 
-    emitPlayGlobalMessage(client: ExSocketInterface, playglobalmessage: PlayGlobalMessage) {
+    emitPlayGlobalMessage(room: GameRoom, playGlobalMessage: PlayGlobalMessage) {
         try {
-            const world = this.Worlds.get(client.roomId);
-            if (!world) {
-                console.error("In emitPlayGlobalMessage, could not find world with id '", client.roomId, "'");
-                return;
-            }
-
             const serverToClientMessage = new ServerToClientMessage();
-            serverToClientMessage.setPlayglobalmessage(playglobalmessage);
+            serverToClientMessage.setPlayglobalmessage(playGlobalMessage);
 
-            for (const [id, user] of world.getUsers().entries()) {
+            for (const [id, user] of room.getUsers().entries()) {
-                user.socket.send(serverToClientMessage.serializeBinary().buffer, true);
+                user.socket.write(serverToClientMessage);
             }
         } catch (e) {
             console.error('An error occurred on "emitPlayGlobalMessage" event');
@@ -604,24 +572,24 @@ export class SocketManager {
     }
 
     public getWorlds(): Map<string, GameRoom> {
-        return this.Worlds;
+        return this.rooms;
     }
 
     /**
      *
      * @param token
      */
-    searchClientByUuid(uuid: string): ExSocketInterface | null {
+    /*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) {
+    public handleQueryJitsiJwtMessage(user: User, 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.
 
@@ -630,7 +598,7 @@ export class SocketManager {
         }
 
         // Let's see if the current client has
-        const isAdmin = client.tags.includes(tag);
+        const isAdmin = user.tags.includes(tag);
 
         const jwt = Jwt.sign({
             "aud": "jitsi",
@@ -655,26 +623,7 @@ export class SocketManager {
         const serverToClientMessage = new ServerToClientMessage();
         serverToClientMessage.setSendjitsijwtmessage(sendJitsiJwtMessage);
 
-        client.send(serverToClientMessage.serializeBinary().buffer, true);
+        user.socket.write(serverToClientMessage);
-    }
-
-    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;
     }
 
     /**
@@ -703,6 +652,129 @@ export class SocketManager {
         }
         return characterLayerObjs;
     }
+
+    public addZoneListener(call: ZoneSocket, roomId: string, x: number, y: number): void {
+        const room = this.rooms.get(roomId);
+        if (!room) {
+            console.error("In addZoneListener, could not find room with id '" +  roomId + "'");
+            return;
+        }
+
+        const things = room.addZoneListener(call, x, y);
+
+        const batchMessage = new BatchToPusherMessage();
+
+        for (const thing of things) {
+            if (thing instanceof User) {
+                const userJoinedMessage = new UserJoinedZoneMessage();
+                userJoinedMessage.setUserid(thing.id);
+                userJoinedMessage.setName(thing.name);
+                userJoinedMessage.setCharacterlayersList(ProtobufUtils.toCharacterLayerMessages(thing.characterLayers));
+                userJoinedMessage.setPosition(ProtobufUtils.toPositionMessage(thing.getPosition()));
+
+                const subMessage = new SubToPusherMessage();
+                subMessage.setUserjoinedzonemessage(userJoinedMessage);
+
+                batchMessage.addPayload(subMessage);
+            } else if (thing instanceof Group) {
+                const groupUpdateMessage = new GroupUpdateZoneMessage();
+                groupUpdateMessage.setGroupid(thing.getId());
+                groupUpdateMessage.setPosition(ProtobufUtils.toPointMessage(thing.getPosition()));
+
+                const subMessage = new SubToPusherMessage();
+                subMessage.setGroupupdatezonemessage(groupUpdateMessage);
+
+                batchMessage.addPayload(subMessage);
+            } else {
+                console.error("Unexpected type for Movable returned by setViewport");
+            }
+        }
+
+        call.write(batchMessage);
+    }
+
+    removeZoneListener(call: ZoneSocket, roomId: string, x: number, y: number) {
+        const room = this.rooms.get(roomId);
+        if (!room) {
+            console.error("In removeZoneListener, could not find room with id '" +  roomId + "'");
+            return;
+        }
+
+        room.removeZoneListener(call, x, y);
+    }
+
+    public async handleJoinAdminRoom(admin: Admin, roomId: string): Promise<GameRoom> {
+        const room = await socketManager.getOrCreateRoom(roomId);
+
+        // Dispatch groups position to newly connected user
+        /*world.getGroups().forEach((group: Group) => {
+            this.emitCreateUpdateGroupEvent(socket, group);
+        });*/
+
+        room.adminJoin(admin);
+
+        return room;
+    }
+
+    public leaveAdminRoom(room: GameRoom, admin: Admin){
+        room.adminLeave(admin);
+        if (room.isEmpty()) {
+            this.rooms.delete(room.roomId);
+            gaugeManager.decNbRoomGauge();
+            debug('Room is empty. Deleting room "%s"', room.roomId);
+        }
+    }
+
+    public sendAdminMessage(roomId: string, recipientUuid: string, message: string): void {
+        const room = this.rooms.get(roomId);
+        if (!room) {
+            console.error("In sendAdminMessage, could not find room with id '" +  roomId + "'. Maybe the room was closed a few milliseconds ago and there was a race condition?");
+            return;
+        }
+
+        const recipient = room.getUserByUuid(recipientUuid);
+        if (recipient === undefined) {
+            console.error("In sendAdminMessage, could not find user with id '" + recipientUuid + "'. Maybe the user left the room a few milliseconds ago and there was a race condition?");
+            return;
+        }
+
+        const sendUserMessage = new SendUserMessage();
+        sendUserMessage.setMessage(message);
+        sendUserMessage.setType('ban');
+
+        const subToPusherMessage = new SubToPusherMessage();
+        subToPusherMessage.setSendusermessage(sendUserMessage);
+
+        recipient.socket.write(subToPusherMessage);
+    }
+
+    public banUser(roomId: string, recipientUuid: string): void {
+        const room = this.rooms.get(roomId);
+        if (!room) {
+            console.error("In banUser, could not find room with id '" +  roomId + "'. Maybe the room was closed a few milliseconds ago and there was a race condition?");
+            return;
+        }
+
+        const recipient = room.getUserByUuid(recipientUuid);
+        if (recipient === undefined) {
+            console.error("In banUser, could not find user with id '" + recipientUuid + "'. Maybe the user left the room a few milliseconds ago and there was a race condition?");
+            return;
+        }
+
+        // Let's leave the room now.
+        room.leave(recipient);
+
+        const sendUserMessage = new SendUserMessage();
+        sendUserMessage.setType('banned');
+
+        const subToPusherMessage = new SubToPusherMessage();
+        subToPusherMessage.setSendusermessage(sendUserMessage);
+
+        recipient.socket.write(subToPusherMessage);
+
+        // Let's close the connection when the user is banned.
+        recipient.socket.end();
+    }
 }
 
 export const socketManager = new SocketManager();

back/tests/GameRoomTest.ts

@@ -1,14 +1,35 @@
 import "jasmine";
-import {GameRoom, ConnectCallback, DisconnectCallback } from "../src/Model/GameRoom";
+import {ConnectCallback, DisconnectCallback, GameRoom} from "../src/Model/GameRoom";
 import {Point} from "../src/Model/Websocket/MessageUserPosition";
 import {Group} from "../src/Model/Group";
-import {ExSocketInterface} from "_Model/Websocket/ExSocketInterface";
+import {User, UserSocket} from "_Model/User";
-import {User} from "_Model/User";
+import {JoinRoomMessage, PositionMessage} from "../src/Messages/generated/messages_pb";
+import Direction = PositionMessage.Direction;
 
-function createMockUser(userId: number): ExSocketInterface {
+function createMockUser(userId: number): User {
     return {
         userId
-    } as ExSocketInterface;
+    } as unknown as User;
+}
+
+function createMockUserSocket(): UserSocket {
+    return {
+    } as unknown as UserSocket;
+}
+
+function createJoinRoomMessage(uuid: string, x: number, y: number): JoinRoomMessage
+{
+    const positionMessage = new PositionMessage();
+    positionMessage.setX(x);
+    positionMessage.setY(y);
+    positionMessage.setDirection(Direction.DOWN);
+    positionMessage.setMoving(false);
+    const joinRoomMessage = new JoinRoomMessage();
+    joinRoomMessage.setUseruuid('1');
+    joinRoomMessage.setName('foo');
+    joinRoomMessage.setRoomid('_/global/test.json');
+    joinRoomMessage.setPositionmessage(positionMessage);
+    return joinRoomMessage;
 }
 
 describe("GameRoom", () => {
@@ -23,19 +44,21 @@ describe("GameRoom", () => {
 
         const world = new GameRoom('_/global/test.json', connect, disconnect, 160, 160, () => {}, () => {}, () => {});
 
-        world.join(createMockUser(1), new Point(100, 100));
 
-        world.join(createMockUser(2), new Point(500, 100));
 
-        world.updatePosition({ userId: 2 }, new Point(261, 100));
+        const user1 = world.join(createMockUserSocket(), createJoinRoomMessage('1', 100, 100));
+
+        const user2 = world.join(createMockUserSocket(), createJoinRoomMessage('2', 500, 100));
+
+        world.updatePosition(user2, new Point(261, 100));
 
         expect(connectCalledNumber).toBe(0);
 
-        world.updatePosition({ userId: 2 }, new Point(101, 100));
+        world.updatePosition(user2, new Point(101, 100));
 
         expect(connectCalledNumber).toBe(2);
 
-        world.updatePosition({ userId: 2 }, new Point(102, 100));
+        world.updatePosition(user2, new Point(102, 100));
         expect(connectCalledNumber).toBe(2);
     });
 
@@ -50,19 +73,19 @@ describe("GameRoom", () => {
 
         const world = new GameRoom('_/global/test.json', connect, disconnect, 160, 160, () => {}, () => {}, () => {});
 
-        world.join(createMockUser(1), new Point(100, 100));
+        const user1 = world.join(createMockUserSocket(), createJoinRoomMessage('1', 100, 100));
 
-        world.join(createMockUser(2), new Point(200, 100));
+        const user2 = world.join(createMockUserSocket(), createJoinRoomMessage('2', 200, 100));
 
         expect(connectCalled).toBe(true);
         connectCalled = false;
 
         // baz joins at the outer limit of the group
-        world.join(createMockUser(3), new Point(311, 100));
+        const user3 = world.join(createMockUserSocket(), createJoinRoomMessage('2', 311, 100));
 
         expect(connectCalled).toBe(false);
 
-        world.updatePosition({ userId: 3 }, new Point(309, 100));
+        world.updatePosition(user3, new Point(309, 100));
 
         expect(connectCalled).toBe(true);
     });
@@ -79,18 +102,18 @@ describe("GameRoom", () => {
 
         const world = new GameRoom('_/global/test.json', connect, disconnect, 160, 160, () => {}, () => {}, () => {});
 
-        world.join(createMockUser(1), new Point(100, 100));
+        const user1 = world.join(createMockUserSocket(), createJoinRoomMessage('1', 100, 100));
 
-        world.join(createMockUser(2), new Point(259, 100));
+        const user2 = world.join(createMockUserSocket(), createJoinRoomMessage('2', 259, 100));
 
         expect(connectCalled).toBe(true);
         expect(disconnectCallNumber).toBe(0);
 
-        world.updatePosition({ userId: 2 }, new Point(100+160+160+1, 100));
+        world.updatePosition(user2, new Point(100+160+160+1, 100));
 
         expect(disconnectCallNumber).toBe(2);
 
-        world.updatePosition({ userId: 2 }, new Point(262, 100));
+        world.updatePosition(user2, new Point(262, 100));
         expect(disconnectCallNumber).toBe(2);
     });
 

back/tests/PositionNotifierTest.ts

@@ -3,12 +3,12 @@ import {GameRoom, ConnectCallback, DisconnectCallback } from "_Model/GameRoom";
 import {Point} from "../src/Model/Websocket/MessageUserPosition";
 import { Group } from "../src/Model/Group";
 import {PositionNotifier} from "../src/Model/PositionNotifier";
-import {User} from "../src/Model/User";
+import {User, UserSocket} from "../src/Model/User";
 import {PointInterface} from "../src/Model/Websocket/PointInterface";
 import {Zone} from "_Model/Zone";
 import {Movable} from "_Model/Movable";
 import {PositionInterface} from "_Model/PositionInterface";
-import {ExSocketInterface} from "_Model/Websocket/ExSocketInterface";
+import {ZoneSocket} from "../src/RoomManager";
 
 
 describe("PositionNotifier", () => {
@@ -30,21 +30,25 @@ describe("PositionNotifier", () => {
             y: 500,
             moving: false,
             direction: 'down'
-        }, false, positionNotifier, {} as ExSocketInterface);
+        }, false, positionNotifier, {} as UserSocket, [], 'foo', []);
 
         const user2 = new User(2, 'test', {
             x: -9999,
             y: -9999,
             moving: false,
             direction: 'down'
-        }, false, positionNotifier, {} as ExSocketInterface);
+        }, false, positionNotifier, {} as UserSocket, [], 'foo', []);
 
-        positionNotifier.setViewport(user1, {
+        positionNotifier.addZoneListener({} as ZoneSocket, 0, 0);
+        positionNotifier.addZoneListener({} as ZoneSocket, 0, 1);
+        positionNotifier.addZoneListener({} as ZoneSocket, 1, 1);
+        positionNotifier.addZoneListener({} as ZoneSocket, 1, 0);
+        /*positionNotifier.setViewport(user1, {
             left: 200,
             right: 600,
             top: 100,
             bottom: 500
-        });
+        });*/
 
         user2.setPosition({x: 500, y: 500, direction: 'down', moving: false});
 
@@ -74,16 +78,9 @@ describe("PositionNotifier", () => {
         expect(leaveTriggered).toBe(false);
         enterTriggered = false;
 
-        // Move out of the zone in a zone that we do track
-        user2.setPosition({x: 200, y: 500, direction: 'down', moving: false});
-        expect(enterTriggered).toBe(false);
-        expect(moveTriggered).toBe(true);
-        expect(leaveTriggered).toBe(false);
-        moveTriggered = false;
-
         // Leave the room
         positionNotifier.leave(user2);
-        positionNotifier.removeViewport(user2);
+        //positionNotifier.removeViewport(user2);
         expect(enterTriggered).toBe(false);
         expect(moveTriggered).toBe(false);
         expect(leaveTriggered).toBe(true);
@@ -95,7 +92,7 @@ describe("PositionNotifier", () => {
         let moveTriggered = false;
         let leaveTriggered = false;
 
-        const positionNotifier = new PositionNotifier(300, 300, (thing: Movable) => {
+        const positionNotifier = new PositionNotifier(300, 300, (thing: Movable, fromZone: Zone|null ) => {
             enterTriggered = true;
         }, (thing: Movable, position: PositionInterface) => {
             moveTriggered = true;
@@ -108,69 +105,85 @@ describe("PositionNotifier", () => {
             y: 500,
             moving: false,
             direction: 'down'
-        }, false, positionNotifier, {} as ExSocketInterface);
+        }, false, positionNotifier, {} as UserSocket, [], 'foo', []);
 
         const user2 = new User(2, 'test', {
             x: 0,
             y: 0,
             moving: false,
             direction: 'down'
-        }, false, positionNotifier, {} as ExSocketInterface);
+        }, false, positionNotifier, {} as UserSocket, [], 'foo', []);
 
-        let newUsers = positionNotifier.setViewport(user1, {
+        const listener = {} as ZoneSocket;
+        positionNotifier.addZoneListener(listener, 0, 0);
+        positionNotifier.addZoneListener(listener, 0, 1);
+        positionNotifier.addZoneListener(listener, 1, 1);
+        positionNotifier.addZoneListener(listener, 1, 0);
+        /*let newUsers = positionNotifier.setViewport(user1, {
             left: 200,
             right: 600,
             top: 100,
             bottom: 500
-        });
+        });*/
+        positionNotifier.enter(user1);
+        positionNotifier.enter(user2);
 
-        expect(newUsers.length).toBe(2);
+
+        //expect(newUsers.length).toBe(2);
         expect(enterTriggered).toBe(true);
         enterTriggered = false;
 
+
+        //positionNotifier.updatePosition(user2, {x:500, y:500}, {x:0, y: 0})
         user2.setPosition({x: 500, y: 500, direction: 'down', moving: false});
 
-        expect(enterTriggered).toBe(false);
+        expect(enterTriggered).toBe(true);
-        expect(moveTriggered).toBe(true);
+        expect(moveTriggered).toBe(false);
-        moveTriggered = false;
+        expect(leaveTriggered).toBe(true);
+        enterTriggered = false;
+        leaveTriggered = false;
 
-        // Move the viewport but the user stays inside.
+        // Add a listener, but the user in not in this zone.
-        positionNotifier.setViewport(user1, {
+        positionNotifier.addZoneListener(listener, 10, 10);
+
+        /*positionNotifier.setViewport(user1, {
             left: 201,
             right: 601,
             top: 100,
             bottom: 500
-        });
+        });*/
 
         expect(enterTriggered).toBe(false);
         expect(moveTriggered).toBe(false);
         expect(leaveTriggered).toBe(false);
 
+        // Stop listening to zone
+        positionNotifier.removeZoneListener(listener, 1, 1);
         // Move the viewport out of the user.
-        positionNotifier.setViewport(user1, {
+        /*positionNotifier.setViewport(user1, {
             left: 901,
             right: 1001,
             top: 100,
             bottom: 500
-        });
+        });*/
 
         expect(enterTriggered).toBe(false);
         expect(moveTriggered).toBe(false);
-        expect(leaveTriggered).toBe(true);
+        expect(leaveTriggered).toBe(false);
-        leaveTriggered = false;
 
         // Move the viewport back on the user.
-        newUsers = positionNotifier.setViewport(user1, {
+        positionNotifier.addZoneListener(listener, 1, 1);
+        /*newUsers = positionNotifier.setViewport(user1, {
             left: 200,
             right: 600,
             top: 100,
             bottom: 500
-        });
+        });*/
 
-        expect(enterTriggered).toBe(true);
+        expect(enterTriggered).toBe(false);
         expect(moveTriggered).toBe(false);
         expect(leaveTriggered).toBe(false);
         enterTriggered = false;
-        expect(newUsers.length).toBe(2);
+        //expect(newUsers.length).toBe(2);
     });
 })

back/yarn.lock

@@ -43,6 +43,14 @@
   dependencies:
     "@types/node" "*"
 
+"@types/bytebuffer@^5.0.40":
+  version "5.0.42"
+  resolved "https://registry.yarnpkg.com/@types/bytebuffer/-/bytebuffer-5.0.42.tgz#1c602a77942d34c5c0879ad75c58d5d8c07dfb3b"
+  integrity sha512-lEgKojWUAc/MG2t649oZS5AfYFP2xRNPoDuwDBlBMjHXd8MaGPgFgtCXUK7inZdBOygmVf10qxc1Us8GXC96aw==
+  dependencies:
+    "@types/long" "*"
+    "@types/node" "*"
+
 "@types/circular-json@^0.4.0":
   version "0.4.0"
   resolved "https://registry.yarnpkg.com/@types/circular-json/-/circular-json-0.4.0.tgz#7401f7e218cfe87ad4c43690da5658b9acaf51be"
@@ -53,6 +61,11 @@
   resolved "https://registry.yarnpkg.com/@types/color-name/-/color-name-1.1.1.tgz#1c1261bbeaa10a8055bbc5d8ab84b7b2afc846a0"
   integrity sha512-rr+OQyAjxze7GgWrSaJwydHStIhHq2lvY3BOC2Mj7KnzI7XK0Uw1TOOdI9lDoajEbSWLiYgoo4f1R51erQfhPQ==
 
+"@types/debug@^4.1.5":
+  version "4.1.5"
+  resolved "https://registry.yarnpkg.com/@types/debug/-/debug-4.1.5.tgz#b14efa8852b7768d898906613c23f688713e02cd"
+  integrity sha512-Q1y515GcOdTHgagaVFhHnIFQ38ygs/kmxdNpvpou+raI9UO3YZcHDngBSYKQklcKlvA7iuQlmIKbzvmxcOE9CQ==
+
 "@types/eslint-visitor-keys@^1.0.0":
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/@types/eslint-visitor-keys/-/eslint-visitor-keys-1.0.0.tgz#1ee30d79544ca84d68d4b3cdb0af4f205663dd2d"
@@ -87,6 +100,11 @@
   dependencies:
     "@types/node" "*"
 
+"@types/long@*":
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/@types/long/-/long-4.0.1.tgz#459c65fa1867dafe6a8f322c4c51695663cc55e9"
+  integrity sha512-5tXH6Bx/kNGd3MgffdmP4dy2Z+G4eaXw0SE81Tq3BNadtnMR5/ySMzX4SLEzHJzSmPNn4HIdpQsBvXMUykr58w==
+
 "@types/mkdirp@^1.0.1":
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/@types/mkdirp/-/mkdirp-1.0.1.tgz#0930b948914a78587de35458b86c907b6e98bbf6"
@@ -164,6 +182,11 @@
     semver "^7.3.2"
     tsutils "^3.17.1"
 
+abbrev@1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/abbrev/-/abbrev-1.1.1.tgz#f8f2c887ad10bf67f634f005b6987fed3179aac8"
+  integrity sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==
+
 acorn-jsx@^5.2.0:
   version "5.3.1"
   resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.1.tgz#fc8661e11b7ac1539c47dbfea2e72b3af34d267b"
@@ -191,6 +214,16 @@ ansi-escapes@^4.2.1:
   dependencies:
     type-fest "^0.11.0"
 
+ansi-regex@^2.0.0:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-2.1.1.tgz#c3b33ab5ee360d86e0e628f0468ae7ef27d654df"
+  integrity sha1-w7M6te42DYbg5ijwRorn7yfWVN8=
+
+ansi-regex@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-3.0.0.tgz#ed0317c322064f79466c02966bddb605ab37d998"
+  integrity sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=
+
 ansi-regex@^4.1.0:
   version "4.1.0"
   resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-4.1.0.tgz#8b9f8f08cf1acb843756a839ca8c7e3168c51997"
@@ -229,6 +262,19 @@ append-field@^1.0.0:
   resolved "https://registry.yarnpkg.com/append-field/-/append-field-1.0.0.tgz#1e3440e915f0b1203d23748e78edd7b9b5b43e56"
   integrity sha1-HjRA6RXwsSA9I3SOeO3XubW0PlY=
 
+aproba@^1.0.3:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/aproba/-/aproba-1.2.0.tgz#6802e6264efd18c790a1b0d517f0f2627bf2c94a"
+  integrity sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw==
+
+are-we-there-yet@~1.1.2:
+  version "1.1.5"
+  resolved "https://registry.yarnpkg.com/are-we-there-yet/-/are-we-there-yet-1.1.5.tgz#4b35c2944f062a8bfcda66410760350fe9ddfc21"
+  integrity sha512-5hYdAkZlcG8tOLujVDTgCT+uPX0VnpAH28gWsLfzpXYm7wP6mp5Q/gYyR7YQ0cKVJcXJnl3j2kpBan13PtQf6w==
+  dependencies:
+    delegates "^1.0.0"
+    readable-stream "^2.0.6"
+
 arg@^4.1.0:
   version "4.1.3"
   resolved "https://registry.yarnpkg.com/arg/-/arg-4.1.3.tgz#269fc7ad5b8e42cb63c896d5666017261c144089"
@@ -266,6 +312,14 @@ array-unique@^0.3.2:
   resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.3.2.tgz#a894b75d4bc4f6cd679ef3244a9fd8f46ae2d428"
   integrity sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=
 
+ascli@~1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/ascli/-/ascli-1.0.1.tgz#bcfa5974a62f18e81cabaeb49732ab4a88f906bc"
+  integrity sha1-vPpZdKYvGOgcq660lzKrSoj5Brw=
+  dependencies:
+    colour "~0.7.1"
+    optjs "~3.2.2"
+
 assign-symbols@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/assign-symbols/-/assign-symbols-1.0.0.tgz#59667f41fadd4f20ccbc2bb96b8d4f7f78ec0367"
@@ -388,6 +442,13 @@ busboy@^0.3.1:
   dependencies:
     dicer "0.3.0"
 
+bytebuffer@~5:
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/bytebuffer/-/bytebuffer-5.0.1.tgz#582eea4b1a873b6d020a48d58df85f0bba6cfddd"
+  integrity sha1-WC7qSxqHO20CCkjVjfhfC7ps/d0=
+  dependencies:
+    long "~3"
+
 bytes@3.1.0:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/bytes/-/bytes-3.1.0.tgz#f6cf7933a360e0588fa9fde85651cdc7f805d1f6"
@@ -426,7 +487,7 @@ camelcase-keys@^2.0.0:
     camelcase "^2.0.0"
     map-obj "^1.0.0"
 
-camelcase@^2.0.0:
+camelcase@^2.0.0, camelcase@^2.0.1:
   version "2.1.1"
   resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-2.1.1.tgz#7c1d16d679a1bbe59ca02cacecfb011e201f5a1f"
   integrity sha1-fB0W1nmhu+WcoCys7PsBHiAfWh8=
@@ -468,6 +529,11 @@ chokidar@^3.4.0:
   optionalDependencies:
     fsevents "~2.1.2"
 
+chownr@^1.1.1:
+  version "1.1.4"
+  resolved "https://registry.yarnpkg.com/chownr/-/chownr-1.1.4.tgz#6fc9d7b42d32a583596337666e7d08084da2cc6b"
+  integrity sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==
+
 circular-json@^0.5.9:
   version "0.5.9"
   resolved "https://registry.yarnpkg.com/circular-json/-/circular-json-0.5.9.tgz#932763ae88f4f7dead7a0d09c8a51a4743a53b1d"
@@ -495,6 +561,20 @@ cli-width@^3.0.0:
   resolved "https://registry.yarnpkg.com/cli-width/-/cli-width-3.0.0.tgz#a2f48437a2caa9a22436e794bf071ec9e61cedf6"
   integrity sha512-FxqpkPPwu1HjuN93Omfm4h8uIanXofW0RxVEW3k5RKx+mJJYSthzNhp32Kzxxy3YAEZ/Dc/EWN1vZRY0+kOhbw==
 
+cliui@^3.0.3:
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/cliui/-/cliui-3.2.0.tgz#120601537a916d29940f934da3b48d585a39213d"
+  integrity sha1-EgYBU3qRbSmUD5NNo7SNWFo5IT0=
+  dependencies:
+    string-width "^1.0.1"
+    strip-ansi "^3.0.1"
+    wrap-ansi "^2.0.0"
+
+code-point-at@^1.0.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/code-point-at/-/code-point-at-1.1.0.tgz#0d070b4d043a5bea33a2f1a40e2edb3d9a4ccf77"
+  integrity sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=
+
 collection-visit@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/collection-visit/-/collection-visit-1.0.0.tgz#4bc0373c164bc3291b4d368c829cf1a80a59dca0"
@@ -527,6 +607,11 @@ color-name@~1.1.4:
   resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2"
   integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
 
+colour@~0.7.1:
+  version "0.7.1"
+  resolved "https://registry.yarnpkg.com/colour/-/colour-0.7.1.tgz#9cb169917ec5d12c0736d3e8685746df1cadf778"
+  integrity sha1-nLFpkX7F0SwHNtPoaFdG3xyt93g=
+
 component-emitter@^1.2.1:
   version "1.3.0"
   resolved "https://registry.yarnpkg.com/component-emitter/-/component-emitter-1.3.0.tgz#16e4070fba8ae29b679f2215853ee181ab2eabc0"
@@ -547,6 +632,11 @@ concat-stream@^1.5.2:
     readable-stream "^2.2.2"
     typedarray "^0.0.6"
 
+console-control-strings@^1.0.0, console-control-strings@~1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/console-control-strings/-/console-control-strings-1.1.0.tgz#3d7cf4464db6446ea644bf4b39507f9851008e8e"
+  integrity sha1-PXz0Rk22RG6mRL9LOVB/mFEAjo4=
+
 content-type@~1.0.4:
   version "1.0.4"
   resolved "https://registry.yarnpkg.com/content-type/-/content-type-1.0.4.tgz#e138cc75e040c727b1966fe5e5f8c9aee256fe3b"
@@ -595,6 +685,13 @@ debug@2.6.9, debug@^2.2.0, debug@^2.3.3:
   dependencies:
     ms "2.0.0"
 
+debug@^3.2.6:
+  version "3.2.6"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-3.2.6.tgz#e83d17de16d8a7efb7717edbe5fb10135eee629b"
+  integrity sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==
+  dependencies:
+    ms "^2.1.1"
+
 debug@^4.0.1, debug@^4.1.1:
   version "4.2.0"
   resolved "https://registry.yarnpkg.com/debug/-/debug-4.2.0.tgz#7f150f93920e94c58f5574c2fd01a3110effe7f1"
@@ -602,7 +699,14 @@ debug@^4.0.1, debug@^4.1.1:
   dependencies:
     ms "2.1.2"
 
-decamelize@^1.1.2:
+debug@^4.3.1:
+  version "4.3.1"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.1.tgz#f0d229c505e0c6d8c49ac553d1b13dc183f6b2ee"
+  integrity sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ==
+  dependencies:
+    ms "2.1.2"
+
+decamelize@^1.1.1, decamelize@^1.1.2:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290"
   integrity sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=
@@ -612,6 +716,11 @@ decode-uri-component@^0.2.0:
   resolved "https://registry.yarnpkg.com/decode-uri-component/-/decode-uri-component-0.2.0.tgz#eb3913333458775cb84cd1a1fae062106bb87545"
   integrity sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=
 
+deep-extend@^0.6.0:
+  version "0.6.0"
+  resolved "https://registry.yarnpkg.com/deep-extend/-/deep-extend-0.6.0.tgz#c4fa7c95404a17a9c3e8ca7e1537312b736330ac"
+  integrity sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==
+
 deep-is@~0.1.3:
   version "0.1.3"
   resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.3.tgz#b369d6fb5dbc13eecf524f91b070feedc357cf34"
@@ -639,11 +748,21 @@ define-property@^2.0.2:
     is-descriptor "^1.0.2"
     isobject "^3.0.1"
 
+delegates@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/delegates/-/delegates-1.0.0.tgz#84c6e159b81904fdca59a0ef44cd870d31250f9a"
+  integrity sha1-hMbhWbgZBP3KWaDvRM2HDTElD5o=
+
 depd@~1.1.2:
   version "1.1.2"
   resolved "https://registry.yarnpkg.com/depd/-/depd-1.1.2.tgz#9bcd52e14c097763e749b274c4346ed2e560b5a9"
   integrity sha1-m81S4UwJd2PnSbJ0xDRu0uVgtak=
 
+detect-libc@^1.0.2:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/detect-libc/-/detect-libc-1.0.3.tgz#fa137c4bd698edf55cd5cd02ac559f91a4c4ba9b"
+  integrity sha1-+hN8S9aY7fVc1c0CrFWfkaTEups=
+
 dicer@0.2.5:
   version "0.2.5"
   resolved "https://registry.yarnpkg.com/dicer/-/dicer-0.2.5.tgz#5996c086bb33218c812c090bddc09cd12facb70f"
@@ -973,6 +1092,13 @@ fragment-cache@^0.2.1:
   dependencies:
     map-cache "^0.2.2"
 
+fs-minipass@^1.2.5:
+  version "1.2.7"
+  resolved "https://registry.yarnpkg.com/fs-minipass/-/fs-minipass-1.2.7.tgz#ccff8570841e7fe4265693da88936c55aed7f7c7"
+  integrity sha512-GWSSJGFy4e9GUeCcbIkED+bgAoFyj7XF1mV8rma3QW4NIqX9Kyx79N/PF61H5udOV3aY1IaMLs6pGbH71nlCTA==
+  dependencies:
+    minipass "^2.6.0"
+
 fs.realpath@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
@@ -988,6 +1114,20 @@ functional-red-black-tree@^1.0.1:
   resolved "https://registry.yarnpkg.com/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz#1b0ab3bd553b2a0d6399d29c0e3ea0b252078327"
   integrity sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=
 
+gauge@~2.7.3:
+  version "2.7.4"
+  resolved "https://registry.yarnpkg.com/gauge/-/gauge-2.7.4.tgz#2c03405c7538c39d7eb37b317022e325fb018bf7"
+  integrity sha1-LANAXHU4w51+s3sxcCLjJfsBi/c=
+  dependencies:
+    aproba "^1.0.3"
+    console-control-strings "^1.0.0"
+    has-unicode "^2.0.0"
+    object-assign "^4.1.0"
+    signal-exit "^3.0.0"
+    string-width "^1.0.1"
+    strip-ansi "^3.0.1"
+    wide-align "^1.1.0"
+
 generic-type-guard@^3.2.0:
   version "3.3.3"
   resolved "https://registry.yarnpkg.com/generic-type-guard/-/generic-type-guard-3.3.3.tgz#954b846fecff91047cadb0dcc28930811fcb9dc1"
@@ -1023,7 +1163,7 @@ glob-to-regexp@^0.3.0:
   resolved "https://registry.yarnpkg.com/glob-to-regexp/-/glob-to-regexp-0.3.0.tgz#8c5a1494d2066c570cc3bfe4496175acc4d502ab"
   integrity sha1-jFoUlNIGbFcMw7/kSWF1rMTVAqs=
 
-glob@^7.1.3, glob@^7.1.6:
+glob@^7.0.5, glob@^7.1.3, glob@^7.1.6:
   version "7.1.6"
   resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.6.tgz#141f33b81a7c2492e125594307480c46679278a6"
   integrity sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==
@@ -1052,6 +1192,18 @@ graceful-fs@^4.1.2:
   resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.4.tgz#2256bde14d3632958c465ebc96dc467ca07a29fb"
   integrity sha512-WjKPNJF79dtJAVniUlGGWHYGz2jWxT6VhN/4m1NdkbZ2nOsEF+cI1Edgql5zCRhs/VsQYRvrXctxktVXZUkixw==
 
+grpc@^1.24.4:
+  version "1.24.4"
+  resolved "https://registry.yarnpkg.com/grpc/-/grpc-1.24.4.tgz#9240a3ea33cfaf04cd32ce8346798709bbd6782d"
+  integrity sha512-mHRAwuitCMuSHo1tp1+Zc0sz3cYa7pkhVJ77pkIXD5gcVORtkRiyW6msXYqTDT+35jazg98lbO3XzuTo2+XrcA==
+  dependencies:
+    "@types/bytebuffer" "^5.0.40"
+    lodash.camelcase "^4.3.0"
+    lodash.clone "^4.5.0"
+    nan "^2.13.2"
+    node-pre-gyp "^0.16.0"
+    protobufjs "^5.0.3"
+
 has-flag@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd"
@@ -1062,6 +1214,11 @@ has-flag@^4.0.0:
   resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b"
   integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
 
+has-unicode@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/has-unicode/-/has-unicode-2.0.1.tgz#e0e6fe6a28cf51138855e086d1691e771de2a8b9"
+  integrity sha1-4Ob+aijPUROIVeCG0Wkedx3iqLk=
+
 has-value@^0.3.1:
   version "0.3.1"
   resolved "https://registry.yarnpkg.com/has-value/-/has-value-0.3.1.tgz#7b1f58bada62ca827ec0a2078025654845995e1f"
@@ -1119,13 +1276,20 @@ http-status-codes@^1.4.0:
   resolved "https://registry.yarnpkg.com/http-status-codes/-/http-status-codes-1.4.0.tgz#6e4c15d16ff3a9e2df03b89f3a55e1aae05fb477"
   integrity sha512-JrT3ua+WgH8zBD3HEJYbeEgnuQaAnUeRRko/YojPAJjGmIfGD3KPU/asLdsLwKjfxOmQe5nXMQ0pt/7MyapVbQ==
 
-iconv-lite@0.4.24, iconv-lite@^0.4.24:
+iconv-lite@0.4.24, iconv-lite@^0.4.24, iconv-lite@^0.4.4:
   version "0.4.24"
   resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b"
   integrity sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==
   dependencies:
     safer-buffer ">= 2.1.2 < 3"
 
+ignore-walk@^3.0.1:
+  version "3.0.3"
+  resolved "https://registry.yarnpkg.com/ignore-walk/-/ignore-walk-3.0.3.tgz#017e2447184bfeade7c238e4aefdd1e8f95b1e37"
+  integrity sha512-m7o6xuOaT1aqheYHKf8W6J5pYH85ZI9w077erOzLje3JsB1gkafkAhHHY19dqjulgIZHFm32Cp5uNZgcQqdJKw==
+  dependencies:
+    minimatch "^3.0.4"
+
 ignore@^4.0.6:
   version "4.0.6"
   resolved "https://registry.yarnpkg.com/ignore/-/ignore-4.0.6.tgz#750e3db5862087b4737ebac8207ffd1ef27b25fc"
@@ -1169,6 +1333,11 @@ inherits@2.0.3:
   resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.3.tgz#633c2c83e3da42a502f52466022480f4208261de"
   integrity sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=
 
+ini@~1.3.0:
+  version "1.3.5"
+  resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.5.tgz#eee25f56db1c9ec6085e0c22778083f596abf927"
+  integrity sha512-RZY5huIKCMRWDUqZlEi72f/lmXKMvuszcMBduliQ3nnWbx9X/ZBQO7DijMEYS9EhHBb2qacRUMtC7svLwe0lcw==
+
 inquirer@^7.0.0:
   version "7.3.3"
   resolved "https://registry.yarnpkg.com/inquirer/-/inquirer-7.3.3.tgz#04d176b2af04afc157a83fd7c100e98ee0aad003"
@@ -1188,6 +1357,11 @@ inquirer@^7.0.0:
     strip-ansi "^6.0.0"
     through "^2.3.6"
 
+invert-kv@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/invert-kv/-/invert-kv-1.0.0.tgz#104a8e4aaca6d3d8cd157a8ef8bfab2d7a3ffdb6"
+  integrity sha1-EEqOSqym09jNFXqO+L+rLXo//bY=
+
 is-accessor-descriptor@^0.1.6:
   version "0.1.6"
   resolved "https://registry.yarnpkg.com/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz#a9e12cb3ae8d876727eeef3843f8a0897b5c98d6"
@@ -1273,6 +1447,13 @@ is-finite@^1.0.0:
   resolved "https://registry.yarnpkg.com/is-finite/-/is-finite-1.1.0.tgz#904135c77fb42c0641d6aa1bcdbc4daa8da082f3"
   integrity sha512-cdyMtqX/BOqqNBBiKlIVkytNHm49MtMlYyn1zxzvJKWmFMlGzm+ry5BBfYyeY9YmNKbRSo/o7OX9w9ale0wg3w==
 
+is-fullwidth-code-point@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz#ef9e31386f031a7f0d643af82fde50c457ef00cb"
+  integrity sha1-754xOG8DGn8NZDr4L95QxFfvAMs=
+  dependencies:
+    number-is-nan "^1.0.0"
+
 is-fullwidth-code-point@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz#a3b30a5c4f199183167aaab93beefae3ddfb654f"
@@ -1451,6 +1632,13 @@ kind-of@^6.0.0, kind-of@^6.0.2:
   resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.3.tgz#07c05034a6c349fa06e24fa35aa76db4580ce4dd"
   integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==
 
+lcid@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/lcid/-/lcid-1.0.0.tgz#308accafa0bc483a3867b4b6f2b9506251d1b835"
+  integrity sha1-MIrMr6C8SDo4Z7S28rlQYlHRuDU=
+  dependencies:
+    invert-kv "^1.0.0"
+
 levn@^0.3.0, levn@~0.3.0:
   version "0.3.0"
   resolved "https://registry.yarnpkg.com/levn/-/levn-0.3.0.tgz#3b09924edf9f083c0490fdd4c0bc4421e04764ee"
@@ -1470,6 +1658,16 @@ load-json-file@^1.0.0:
     pinkie-promise "^2.0.0"
     strip-bom "^2.0.0"
 
+lodash.camelcase@^4.3.0:
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz#b28aa6288a2b9fc651035c7711f65ab6190331a6"
+  integrity sha1-soqmKIorn8ZRA1x3EfZathkDMaY=
+
+lodash.clone@^4.5.0:
+  version "4.5.0"
+  resolved "https://registry.yarnpkg.com/lodash.clone/-/lodash.clone-4.5.0.tgz#195870450f5a13192478df4bc3d23d2dea1907b6"
+  integrity sha1-GVhwRQ9aExkkeN9Lw9I9LeoZB7Y=
+
 lodash.includes@^4.3.0:
   version "4.3.0"
   resolved "https://registry.yarnpkg.com/lodash.includes/-/lodash.includes-4.3.0.tgz#60bb98a87cb923c68ca1e51325483314849f553f"
@@ -1510,6 +1708,11 @@ lodash@^4.17.14, lodash@^4.17.15, lodash@^4.17.19:
   resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.20.tgz#b44a9b6297bcb698f1c51a3545a2b3b368d59c52"
   integrity sha512-PlhdFcillOINfeV7Ni6oF1TAEayyZBoZ8bcshTHqOYJYlrqzRK5hagpagky5o4HfCzzd1TRkXPMFq6cKk9rGmA==
 
+long@~3:
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/long/-/long-3.2.0.tgz#d821b7138ca1cb581c172990ef14db200b5c474b"
+  integrity sha1-2CG3E4yhy1gcFymQ7xTbIAtcR0s=
+
 loud-rejection@^1.0.0:
   version "1.6.0"
   resolved "https://registry.yarnpkg.com/loud-rejection/-/loud-rejection-1.6.0.tgz#5b46f80147edee578870f086d04821cf998e551f"
@@ -1609,11 +1812,26 @@ minimatch@^3.0.4:
   dependencies:
     brace-expansion "^1.1.7"
 
-minimist@^1.1.3, minimist@^1.2.5:
+minimist@^1.1.3, minimist@^1.2.0, minimist@^1.2.5:
   version "1.2.5"
   resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.5.tgz#67d66014b66a6a8aaa0c083c5fd58df4e4e97602"
   integrity sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==
 
+minipass@^2.6.0, minipass@^2.8.6, minipass@^2.9.0:
+  version "2.9.0"
+  resolved "https://registry.yarnpkg.com/minipass/-/minipass-2.9.0.tgz#e713762e7d3e32fed803115cf93e04bca9fcc9a6"
+  integrity sha512-wxfUjg9WebH+CUDX/CdbRlh5SmfZiy/hpkxaRI16Y9W56Pa75sWgd/rvFilSgrauD9NyFymP/+JFV3KwzIsJeg==
+  dependencies:
+    safe-buffer "^5.1.2"
+    yallist "^3.0.0"
+
+minizlib@^1.2.1:
+  version "1.3.3"
+  resolved "https://registry.yarnpkg.com/minizlib/-/minizlib-1.3.3.tgz#2290de96818a34c29551c8a8d301216bd65a861d"
+  integrity sha512-6ZYMOEnmVsdCeTJVE0W9ZD+pVnE8h9Hma/iOwwRDsdQoePpoX56/8B6z3P9VNwppJuBKNRuFDRNRqRWexT9G9Q==
+  dependencies:
+    minipass "^2.9.0"
+
 mixin-deep@^1.2.0:
   version "1.3.2"
   resolved "https://registry.yarnpkg.com/mixin-deep/-/mixin-deep-1.3.2.tgz#1120b43dc359a785dce65b55b82e257ccf479566"
@@ -1622,7 +1840,7 @@ mixin-deep@^1.2.0:
     for-in "^1.0.2"
     is-extendable "^1.0.1"
 
-mkdirp@^0.5.1:
+mkdirp@^0.5.0, mkdirp@^0.5.1, mkdirp@^0.5.3:
   version "0.5.5"
   resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.5.tgz#d91cefd62d1436ca0f41620e251288d420099def"
   integrity sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==
@@ -1663,6 +1881,11 @@ mute-stream@0.0.8:
   resolved "https://registry.yarnpkg.com/mute-stream/-/mute-stream-0.0.8.tgz#1630c42b2251ff81e2a283de96a5497ea92e5e0d"
   integrity sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA==
 
+nan@^2.13.2:
+  version "2.14.2"
+  resolved "https://registry.yarnpkg.com/nan/-/nan-2.14.2.tgz#f5376400695168f4cc694ac9393d0c9585eeea19"
+  integrity sha512-M2ufzIiINKCuDfBSAUr1vWQ+vuVcA9kqx8JJUsbQi6yf1uGRyb7HfpdfUr5qLXf3B/t8dPvcjhKMmlfnP47EzQ==
+
 nanomatch@^1.2.9:
   version "1.2.13"
   resolved "https://registry.yarnpkg.com/nanomatch/-/nanomatch-1.2.13.tgz#b87a8aa4fc0de8fe6be88895b38983ff265bd119"
@@ -1685,11 +1908,44 @@ natural-compare@^1.4.0:
   resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7"
   integrity sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=
 
+needle@^2.5.0:
+  version "2.5.2"
+  resolved "https://registry.yarnpkg.com/needle/-/needle-2.5.2.tgz#cf1a8fce382b5a280108bba90a14993c00e4010a"
+  integrity sha512-LbRIwS9BfkPvNwNHlsA41Q29kL2L/6VaOJ0qisM5lLWsTV3nP15abO5ITL6L81zqFhzjRKDAYjpcBcwM0AVvLQ==
+  dependencies:
+    debug "^3.2.6"
+    iconv-lite "^0.4.4"
+    sax "^1.2.4"
+
 nice-try@^1.0.4:
   version "1.0.5"
   resolved "https://registry.yarnpkg.com/nice-try/-/nice-try-1.0.5.tgz#a3378a7696ce7d223e88fc9b764bd7ef1089e366"
   integrity sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==
 
+node-pre-gyp@^0.16.0:
+  version "0.16.0"
+  resolved "https://registry.yarnpkg.com/node-pre-gyp/-/node-pre-gyp-0.16.0.tgz#238fa540364784e5015dfcdba78da3937e18dbdc"
+  integrity sha512-4efGA+X/YXAHLi1hN8KaPrILULaUn2nWecFrn1k2I+99HpoyvcOGEbtcOxpDiUwPF2ZANMJDh32qwOUPenuR1g==
+  dependencies:
+    detect-libc "^1.0.2"
+    mkdirp "^0.5.3"
+    needle "^2.5.0"
+    nopt "^4.0.1"
+    npm-packlist "^1.1.6"
+    npmlog "^4.0.2"
+    rc "^1.2.7"
+    rimraf "^2.6.1"
+    semver "^5.3.0"
+    tar "^4.4.2"
+
+nopt@^4.0.1:
+  version "4.0.3"
+  resolved "https://registry.yarnpkg.com/nopt/-/nopt-4.0.3.tgz#a375cad9d02fd921278d954c2254d5aa57e15e48"
+  integrity sha512-CvaGwVMztSMJLOeXPrez7fyfObdZqNUK1cPAEzLHrTybIua9pMdmmPR5YwtfNftIOMv3DPUhFaxsZMNTQO20Kg==
+  dependencies:
+    abbrev "1"
+    osenv "^0.1.4"
+
 normalize-package-data@^2.3.2, normalize-package-data@^2.3.4:
   version "2.5.0"
   resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-2.5.0.tgz#e66db1838b200c1dfc233225d12cb36520e234a8"
@@ -1705,7 +1961,43 @@ normalize-path@^3.0.0, normalize-path@~3.0.0:
   resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65"
   integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==
 
-object-assign@^4.0.1, object-assign@^4.1.1:
+npm-bundled@^1.0.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/npm-bundled/-/npm-bundled-1.1.1.tgz#1edd570865a94cdb1bc8220775e29466c9fb234b"
+  integrity sha512-gqkfgGePhTpAEgUsGEgcq1rqPXA+tv/aVBlgEzfXwA1yiUJF7xtEt3CtVwOjNYQOVknDk0F20w58Fnm3EtG0fA==
+  dependencies:
+    npm-normalize-package-bin "^1.0.1"
+
+npm-normalize-package-bin@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/npm-normalize-package-bin/-/npm-normalize-package-bin-1.0.1.tgz#6e79a41f23fd235c0623218228da7d9c23b8f6e2"
+  integrity sha512-EPfafl6JL5/rU+ot6P3gRSCpPDW5VmIzX959Ob1+ySFUuuYHWHekXpwdUZcKP5C+DS4GEtdJluwBjnsNDl+fSA==
+
+npm-packlist@^1.1.6:
+  version "1.4.8"
+  resolved "https://registry.yarnpkg.com/npm-packlist/-/npm-packlist-1.4.8.tgz#56ee6cc135b9f98ad3d51c1c95da22bbb9b2ef3e"
+  integrity sha512-5+AZgwru5IevF5ZdnFglB5wNlHG1AOOuw28WhUq8/8emhBmLv6jX5by4WJCh7lW0uSYZYS6DXqIsyZVIXRZU9A==
+  dependencies:
+    ignore-walk "^3.0.1"
+    npm-bundled "^1.0.1"
+    npm-normalize-package-bin "^1.0.1"
+
+npmlog@^4.0.2:
+  version "4.1.2"
+  resolved "https://registry.yarnpkg.com/npmlog/-/npmlog-4.1.2.tgz#08a7f2a8bf734604779a9efa4ad5cc717abb954b"
+  integrity sha512-2uUqazuKlTaSI/dC8AzicUck7+IrEaOnN/e0jd3Xtt1KcGpwx30v50mL7oPyr/h9bL3E4aZccVwpwP+5W9Vjkg==
+  dependencies:
+    are-we-there-yet "~1.1.2"
+    console-control-strings "~1.1.0"
+    gauge "~2.7.3"
+    set-blocking "~2.0.0"
+
+number-is-nan@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/number-is-nan/-/number-is-nan-1.0.1.tgz#097b602b53422a522c1afb8790318336941a011d"
+  integrity sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=
+
+object-assign@^4.0.1, object-assign@^4.1.0, object-assign@^4.1.1:
   version "4.1.1"
   resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
   integrity sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=
@@ -1766,11 +2058,36 @@ optionator@^0.8.3:
     type-check "~0.3.2"
     word-wrap "~1.2.3"
 
-os-tmpdir@~1.0.2:
+optjs@~3.2.2:
+  version "3.2.2"
+  resolved "https://registry.yarnpkg.com/optjs/-/optjs-3.2.2.tgz#69a6ce89c442a44403141ad2f9b370bd5bb6f4ee"
+  integrity sha1-aabOicRCpEQDFBrS+bNwvVu29O4=
+
+os-homedir@^1.0.0:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/os-homedir/-/os-homedir-1.0.2.tgz#ffbc4988336e0e833de0c168c7ef152121aa7fb3"
+  integrity sha1-/7xJiDNuDoM94MFox+8VISGqf7M=
+
+os-locale@^1.4.0:
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/os-locale/-/os-locale-1.4.0.tgz#20f9f17ae29ed345e8bde583b13d2009803c14d9"
+  integrity sha1-IPnxeuKe00XoveWDsT0gCYA8FNk=
+  dependencies:
+    lcid "^1.0.0"
+
+os-tmpdir@^1.0.0, os-tmpdir@~1.0.2:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274"
   integrity sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=
 
+osenv@^0.1.4:
+  version "0.1.5"
+  resolved "https://registry.yarnpkg.com/osenv/-/osenv-0.1.5.tgz#85cdfafaeb28e8677f416e287592b5f3f49ea410"
+  integrity sha512-0CWcCECdMVc2Rw3U5w9ZjqX6ga6ubk1xDVKxtBQPK7wis/0F2r9T6k4ydGYhecl7YUBxBVxhL5oisPsNxAPe2g==
+  dependencies:
+    os-homedir "^1.0.0"
+    os-tmpdir "^1.0.0"
+
 parent-module@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/parent-module/-/parent-module-1.0.1.tgz#691d2709e78c79fae3a156622452d00762caaaa2"
@@ -1875,6 +2192,16 @@ prom-client@^12.0.0:
   dependencies:
     tdigest "^0.1.1"
 
+protobufjs@^5.0.3:
+  version "5.0.3"
+  resolved "https://registry.yarnpkg.com/protobufjs/-/protobufjs-5.0.3.tgz#e4dfe9fb67c90b2630d15868249bcc4961467a17"
+  integrity sha512-55Kcx1MhPZX0zTbVosMQEO5R6/rikNXd9b6RQK4KSPcrSIIwoXTtebIczUrXlwaSrbz4x8XUVThGPob1n8I4QA==
+  dependencies:
+    ascli "~1"
+    bytebuffer "~5"
+    glob "^7.0.5"
+    yargs "^3.10.0"
+
 punycode@^2.1.0:
   version "2.1.1"
   resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.1.1.tgz#b58b010ac40c22c5657616c8d2c2c02c7bf479ec"
@@ -1904,6 +2231,16 @@ raw-body@2.4.0:
     iconv-lite "0.4.24"
     unpipe "1.0.0"
 
+rc@^1.2.7:
+  version "1.2.8"
+  resolved "https://registry.yarnpkg.com/rc/-/rc-1.2.8.tgz#cd924bf5200a075b83c188cd6b9e211b7fc0d3ed"
+  integrity sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==
+  dependencies:
+    deep-extend "^0.6.0"
+    ini "~1.3.0"
+    minimist "^1.2.0"
+    strip-json-comments "~2.0.1"
+
 read-pkg-up@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-1.0.1.tgz#9d63c13276c065918d57f002a57f40a1b643fb02"
@@ -1931,7 +2268,7 @@ readable-stream@1.1.x:
     isarray "0.0.1"
     string_decoder "~0.10.x"
 
-readable-stream@^2.2.2:
+readable-stream@^2.0.6, readable-stream@^2.2.2:
   version "2.3.7"
   resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.7.tgz#1eca1cf711aef814c04f62252a36a62f6cb23b57"
   integrity sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==
@@ -2050,7 +2387,7 @@ rxjs@^6.6.0:
   dependencies:
     tslib "^1.9.0"
 
-safe-buffer@^5.0.1:
+safe-buffer@^5.0.1, safe-buffer@^5.1.2:
   version "5.2.1"
   resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"
   integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
@@ -2072,7 +2409,12 @@ safe-regex@^1.1.0:
   resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a"
   integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==
 
-"semver@2 || 3 || 4 || 5", semver@^5.5.0, semver@^5.6.0:
+sax@^1.2.4:
+  version "1.2.4"
+  resolved "https://registry.yarnpkg.com/sax/-/sax-1.2.4.tgz#2816234e2378bddc4e5354fab5caa895df7100d9"
+  integrity sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==
+
+"semver@2 || 3 || 4 || 5", semver@^5.3.0, semver@^5.5.0, semver@^5.6.0:
   version "5.7.1"
   resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.1.tgz#a954f931aeba508d307bbf069eff0c01c96116f7"
   integrity sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==
@@ -2087,6 +2429,11 @@ semver@^7.3.2:
   resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.2.tgz#604962b052b81ed0786aae84389ffba70ffd3938"
   integrity sha512-OrOb32TeeambH6UrhtShmF7CRDqhL6/5XpPNp2DuRH6+9QLw/orhp72j87v8Qa1ScDkvrrBNpZcDejAirJmfXQ==
 
+set-blocking@~2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/set-blocking/-/set-blocking-2.0.0.tgz#045f9782d011ae9a6803ddd382b24392b3d890f7"
+  integrity sha1-BF+XgtARrppoA93TgrJDkrPYkPc=
+
 set-value@^2.0.0, set-value@^2.0.1:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/set-value/-/set-value-2.0.1.tgz#a18d40530e6f07de4228c7defe4227af8cad005b"
@@ -2258,6 +2605,23 @@ strict-uri-encode@^2.0.0:
   resolved "https://registry.yarnpkg.com/strict-uri-encode/-/strict-uri-encode-2.0.0.tgz#b9c7330c7042862f6b142dc274bbcc5866ce3546"
   integrity sha1-ucczDHBChi9rFC3CdLvMWGbONUY=
 
+string-width@^1.0.1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-1.0.2.tgz#118bdf5b8cdc51a2a7e70d211e07e2b0b9b107d3"
+  integrity sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=
+  dependencies:
+    code-point-at "^1.0.0"
+    is-fullwidth-code-point "^1.0.0"
+    strip-ansi "^3.0.0"
+
+"string-width@^1.0.2 || 2":
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-2.1.1.tgz#ab93f27a8dc13d28cac815c462143a6d9012ae9e"
+  integrity sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==
+  dependencies:
+    is-fullwidth-code-point "^2.0.0"
+    strip-ansi "^4.0.0"
+
 string-width@^3.0.0:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/string-width/-/string-width-3.1.0.tgz#22767be21b62af1081574306f69ac51b62203961"
@@ -2288,6 +2652,20 @@ string_decoder@~1.1.1:
   dependencies:
     safe-buffer "~5.1.0"
 
+strip-ansi@^3.0.0, strip-ansi@^3.0.1:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-3.0.1.tgz#6a385fb8853d952d5ff05d0e8aaf94278dc63dcf"
+  integrity sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=
+  dependencies:
+    ansi-regex "^2.0.0"
+
+strip-ansi@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-4.0.0.tgz#a8479022eb1ac368a871389b635262c505ee368f"
+  integrity sha1-qEeQIusaw2iocTibY1JixQXuNo8=
+  dependencies:
+    ansi-regex "^3.0.0"
+
 strip-ansi@^5.1.0, strip-ansi@^5.2.0:
   version "5.2.0"
   resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-5.2.0.tgz#8c9a536feb6afc962bdfa5b104a5091c1ad9c0ae"
@@ -2321,7 +2699,7 @@ strip-indent@^1.0.1:
   dependencies:
     get-stdin "^4.0.1"
 
-strip-json-comments@^2.0.0:
+strip-json-comments@^2.0.0, strip-json-comments@~2.0.1:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-2.0.1.tgz#3c531942e908c2697c0ec344858c286c7ca0a60a"
   integrity sha1-PFMZQukIwml8DsNEhYwobHygpgo=
@@ -2360,6 +2738,19 @@ table@^5.2.3:
     slice-ansi "^2.1.0"
     string-width "^3.0.0"
 
+tar@^4.4.2:
+  version "4.4.13"
+  resolved "https://registry.yarnpkg.com/tar/-/tar-4.4.13.tgz#43b364bc52888d555298637b10d60790254ab525"
+  integrity sha512-w2VwSrBoHa5BsSyH+KxEqeQBAllHhccyMFVHtGtdMpF4W7IRWfZjFiQceJPChOeTsSDVUpER2T8FA93pr0L+QA==
+  dependencies:
+    chownr "^1.1.1"
+    fs-minipass "^1.2.5"
+    minipass "^2.8.6"
+    minizlib "^1.2.1"
+    mkdirp "^0.5.0"
+    safe-buffer "^5.1.2"
+    yallist "^3.0.3"
+
 tdigest@^0.1.1:
   version "0.1.1"
   resolved "https://registry.yarnpkg.com/tdigest/-/tdigest-0.1.1.tgz#2e3cb2c39ea449e55d1e6cd91117accca4588021"
@@ -2598,11 +2989,31 @@ which@^1.2.9:
   dependencies:
     isexe "^2.0.0"
 
+wide-align@^1.1.0:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/wide-align/-/wide-align-1.1.3.tgz#ae074e6bdc0c14a431e804e624549c633b000457"
+  integrity sha512-QGkOQc8XL6Bt5PwnsExKBPuMKBxnGxWWW3fU55Xt4feHozMUhdUMaBCk290qpm/wG5u/RSKzwdAC4i51YigihA==
+  dependencies:
+    string-width "^1.0.2 || 2"
+
+window-size@^0.1.4:
+  version "0.1.4"
+  resolved "https://registry.yarnpkg.com/window-size/-/window-size-0.1.4.tgz#f8e1aa1ee5a53ec5bf151ffa09742a6ad7697876"
+  integrity sha1-+OGqHuWlPsW/FR/6CXQqatdpeHY=
+
 word-wrap@~1.2.3:
   version "1.2.3"
   resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.3.tgz#610636f6b1f703891bd34771ccb17fb93b47079c"
   integrity sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==
 
+wrap-ansi@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-2.1.0.tgz#d8fc3d284dd05794fe84973caecdd1cf824fdd85"
+  integrity sha1-2Pw9KE3QV5T+hJc8rs3Rz4JP3YU=
+  dependencies:
+    string-width "^1.0.1"
+    strip-ansi "^3.0.1"
+
 wrappy@1:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
@@ -2620,6 +3031,29 @@ xtend@^4.0.0:
   resolved "https://registry.yarnpkg.com/xtend/-/xtend-4.0.2.tgz#bb72779f5fa465186b1f438f674fa347fdb5db54"
   integrity sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==
 
+y18n@^3.2.0:
+  version "3.2.1"
+  resolved "https://registry.yarnpkg.com/y18n/-/y18n-3.2.1.tgz#6d15fba884c08679c0d77e88e7759e811e07fa41"
+  integrity sha1-bRX7qITAhnnA136I53WegR4H+kE=
+
+yallist@^3.0.0, yallist@^3.0.3:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/yallist/-/yallist-3.1.1.tgz#dbb7daf9bfd8bac9ab45ebf602b8cbad0d5d08fd"
+  integrity sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==
+
+yargs@^3.10.0:
+  version "3.32.0"
+  resolved "https://registry.yarnpkg.com/yargs/-/yargs-3.32.0.tgz#03088e9ebf9e756b69751611d2a5ef591482c995"
+  integrity sha1-AwiOnr+edWtpdRYR0qXvWRSCyZU=
+  dependencies:
+    camelcase "^2.0.1"
+    cliui "^3.0.3"
+    decamelize "^1.1.1"
+    os-locale "^1.4.0"
+    string-width "^1.0.1"
+    window-size "^0.1.4"
+    y18n "^3.2.0"
+
 yn@3.1.1:
   version "3.1.1"
   resolved "https://registry.yarnpkg.com/yn/-/yn-3.1.1.tgz#1e87401a09d767c1d5eab26a6e4c185182d2eb50"

benchmark/index.ts

@@ -2,6 +2,7 @@ import {RoomConnection} from "../front/src/Connexion/RoomConnection";
 import {connectionManager} from "../front/src/Connexion/ConnectionManager";
 import * as WebSocket from "ws"
 
+let userMovedCount = 0;
 
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
@@ -13,7 +14,7 @@ RoomConnection.setWebsocketFactory((url: string) => {
 
 async function startOneUser(): Promise<void> {
     await connectionManager.anonymousLogin(true);
-    const connection = await connectionManager.connectToRoomSocket(process.env.ROOM_ID ? process.env.ROOM_ID : '_/global/maps.workadventure.localhost/Floor0/floor0.json', 'TEST', ['male3'],
+    const onConnect = await connectionManager.connectToRoomSocket(process.env.ROOM_ID ? process.env.ROOM_ID : '_/global/maps.workadventure.localhost/Floor0/floor0.json', 'TEST', ['male3'],
         {
             x: 783,
             y: 170
@@ -24,6 +25,12 @@ async function startOneUser(): Promise<void> {
             right: 800
         });
 
+    const connection = onConnect.connection;
+
+    connection.onUserMoved(() => {
+        userMovedCount++;
+    })
+
     console.log(connection.getUserId());
 
     let angle = Math.random() * Math.PI * 2;
@@ -51,10 +58,15 @@ async function startOneUser(): Promise<void> {
 (async () => {
     connectionManager.initBenchmark();
 
+    const promises = [];
 
     for (let userNo = 0; userNo < 160; userNo++) {
-        startOneUser();
+        const promise = startOneUser();
+        promises.push(promise);
         // Wait 0.5s between adding users
         await sleep(125);
     }
+
+    await Promise.all(promises);
+    console.log('User moved count: '+userMovedCount);
 })();

deeployer.libsonnet

@@ -11,6 +11,25 @@
        "image": "thecodingmachine/workadventure-back:"+tag,
        "host": {
          "url": "api."+url,
+         "https": "enable",
+         "containerPort": 8080
+       },
+       "ports": [8080, 50051],
+       "env": {
+         "SECRET_KEY": "tempSecretKeyNeedsToChange",
+         "ADMIN_API_TOKEN": env.ADMIN_API_TOKEN,
+         "JITSI_ISS": env.JITSI_ISS,
+         "JITSI_URL": env.JITSI_URL,
+         "SECRET_JITSI_KEY": env.SECRET_JITSI_KEY,
+       } + if adminUrl != null then {
+         "ADMIN_API_URL": adminUrl,
+       } else {}
+     },
+     "pusher": {
+            "replicas": 2,
+            "image": "thecodingmachine/workadventure-pusher:"+tag,
+            "host": {
+              "url": "pusher."+url,
               "https": "enable"
             },
             "ports": [8080],
@@ -19,6 +38,7 @@
               "ADMIN_API_TOKEN": env.ADMIN_API_TOKEN,
               "JITSI_ISS": env.JITSI_ISS,
               "JITSI_URL": env.JITSI_URL,
+              "API_URL": "back:50051",
               "SECRET_JITSI_KEY": env.SECRET_JITSI_KEY,
             } + if adminUrl != null then {
               "ADMIN_API_URL": adminUrl,
@@ -32,7 +52,8 @@
       },
       "ports": [80],
       "env": {
-        "API_URL": "api."+url,
+        "API_URL": "pusher."+url,
+        "UPLOADER_URL": "uploader."+url,
         "ADMIN_URL": "admin."+url,
         "JITSI_URL": env.JITSI_URL,
         "SECRET_JITSI_KEY": env.SECRET_JITSI_KEY,
@@ -42,6 +63,17 @@
         "JITSI_PRIVATE_MODE": if env.SECRET_JITSI_KEY != '' then "true" else "false"
       }
     },
+    "uploader": {
+           "image": "thecodingmachine/workadventure-uploader:"+tag,
+           "host": {
+             "url": "uploader."+url,
+             "https": "enable",
+             "containerPort": 8080
+           },
+           "ports": [8080],
+           "env": {
+           }
+         },
     "maps": {
       "image": "thecodingmachine/workadventure-maps:"+tag,
       "host": {

docker-compose.yaml

@@ -26,7 +26,8 @@ services:
       JITSI_PRIVATE_MODE: "$JITSI_PRIVATE_MODE"
       HOST: "0.0.0.0"
       NODE_ENV: development
-      API_URL: api.workadventure.localhost
+      API_URL: pusher.workadventure.localhost
+      UPLOADER_URL: uploader.workadventure.localhost
       ADMIN_URL: admin.workadventure.localhost
       STARTUP_COMMAND_1: yarn install
       TURN_SERVER: "turn:coturn.workadventu.re:443,turns:coturn.workadventu.re:443"
@@ -44,6 +45,31 @@ services:
       - "traefik.http.routers.front-ssl.tls=true"
       - "traefik.http.routers.front-ssl.service=front"
 
+  pusher:
+    image: thecodingmachine/nodejs:12
+    command: yarn dev
+    #command: yarn run prod
+    #command: yarn run profile
+    environment:
+      DEBUG: "*"
+      STARTUP_COMMAND_1: yarn install
+      SECRET_JITSI_KEY: "$SECRET_JITSI_KEY"
+      SECRET_KEY: yourSecretKey
+      ADMIN_API_TOKEN: "$ADMIN_API_TOKEN"
+      API_URL: back:50051
+      JITSI_URL: $JITSI_URL
+      JITSI_ISS: $JITSI_ISS
+    volumes:
+      - ./pusher:/usr/src/app
+    labels:
+      - "traefik.http.routers.pusher.rule=Host(`pusher.workadventure.localhost`)"
+      - "traefik.http.routers.pusher.entryPoints=web"
+      - "traefik.http.services.pusher.loadbalancer.server.port=8080"
+      - "traefik.http.routers.pusher-ssl.rule=Host(`pusher.workadventure.localhost`)"
+      - "traefik.http.routers.pusher-ssl.entryPoints=websecure"
+      - "traefik.http.routers.pusher-ssl.tls=true"
+      - "traefik.http.routers.pusher-ssl.service=pusher"
+
   maps:
     image: thecodingmachine/nodejs:12-apache
     environment:
@@ -72,6 +98,7 @@ services:
     command: yarn dev
     #command: yarn run profile
     environment:
+      DEBUG: "*"
       STARTUP_COMMAND_1: yarn install
       SECRET_KEY: yourSecretKey
       SECRET_JITSI_KEY: "$SECRET_JITSI_KEY"
@@ -90,6 +117,23 @@ services:
       - "traefik.http.routers.back-ssl.tls=true"
       - "traefik.http.routers.back-ssl.service=back"
 
+  uploader:
+    image: thecodingmachine/nodejs:12
+    command: yarn dev
+    #command: yarn run profile
+    environment:
+      DEBUG: "*"
+      STARTUP_COMMAND_1: yarn install
+    volumes:
+      - ./uploader:/usr/src/app
+    labels:
+      - "traefik.http.routers.uploader.rule=Host(`uploader.workadventure.localhost`)"
+      - "traefik.http.routers.uploader.entryPoints=web"
+      - "traefik.http.services.uploader.loadbalancer.server.port=8080"
+      - "traefik.http.routers.uploader-ssl.rule=Host(`uploader.workadventure.localhost`)"
+      - "traefik.http.routers.uploader-ssl.entryPoints=websecure"
+      - "traefik.http.routers.uploader-ssl.tls=true"
+      - "traefik.http.routers.uploader-ssl.service=uploader"
 
   website:
     image: thecodingmachine/nodejs:12-apache
@@ -109,11 +153,14 @@ services:
       - "traefik.http.routers.website-ssl.service=website"
 
   messages:
+    #image: thecodingmachine/nodejs:14
     image: thecodingmachine/workadventure-back-base:latest
     environment:
+      #STARTUP_COMMAND_0: sudo apt-get install -y inotify-tools
       STARTUP_COMMAND_1: yarn install
       STARTUP_COMMAND_2: yarn run proto:watch
     volumes:
       - ./messages:/usr/src/app
       - ./back:/usr/src/back
       - ./front:/usr/src/front
+      - ./pusher:/usr/src/pusher

docs/diagrams.md

@@ -0,0 +1,27 @@
+Diagrams are rendered with "mermaid.js"
+
+sequenceDiagram
+    participant Br as Browser
+    participant P as Pusher
+    participant Ba as Back
+    participant A as Admin
+    Note left of Br: The user has a JWT token
+    Br->>P: /verify: verify the token (no answer)
+    P->>A: /api/check-user: the user must not be banned
+    A->>P: 200 (no body)
+    P->>Br: 200 (no body)
+    Br->>P: connect to websocket /room?roomid=...
+    P->>A: /api/check-user(uuid): the user must not be banned
+    A->>P: 200 (no body)
+    P->>A: /api/membership(uuid): get data from the user
+    A->>P: 200 (user data)
+    Note right of P: Zones are computed on Pusher
+    P->>Ba: doJoinRoom + list of listened zones
+    Ba->>P: RoomJoinedMessage
+    P->>Br: RoomJoinedMessage (users/groups/items/current user id)
+    P->>A: /api/membership(uuid): get data from the user (again!)
+    A->>P: 200 (user data)
+    P->>Br: SendUserMessage (if any message to send)
+
+    
+    

front/src/Administration/GlobalMessageManager.ts

@@ -1,6 +1,6 @@
 import {HtmlUtils} from "./../WebRtc/HtmlUtils";
 import {AUDIO_TYPE, MESSAGE_TYPE} from "./ConsoleGlobalMessageManager";
-import {API_URL} from "../Enum/EnvironmentVariable";
+import {API_URL, UPLOADER_URL} from "../Enum/EnvironmentVariable";
 import {RoomConnection} from "../Connexion/RoomConnection";
 import {PlayGlobalMessageInterface} from "../Connexion/ConnexionModels";
 
@@ -79,7 +79,7 @@ export class GlobalMessageManager {
             divAudio.classList.add('active');
         }
         const messageAudioSource : HTMLSourceElement = document.createElement('source');
-        messageAudioSource.src = `${API_URL}${urlMessage}`;
+        messageAudioSource.src = `${UPLOADER_URL}${urlMessage}`;
         messageAudio.appendChild(messageAudioSource);
         mainSectionDiv.appendChild(messageAudio);
     }

front/src/Connexion/ConnectionManager.ts

@@ -1,7 +1,7 @@
 import Axios from "axios";
 import {API_URL} from "../Enum/EnvironmentVariable";
 import {RoomConnection} from "./RoomConnection";
-import {PositionInterface, ViewportInterface} from "./ConnexionModels";
+import {OnConnectInterface, PositionInterface, ViewportInterface} from "./ConnexionModels";
 import {GameConnexionTypes, urlManager} from "../Url/UrlManager";
 import {localUserStore} from "./LocalUserStore";
 import {LocalUser} from "./LocalUser";
@@ -78,21 +78,29 @@ class ConnectionManager {
         this.localUser = new LocalUser('', 'test', []);
     }
 
-    public connectToRoomSocket(roomId: string, name: string, characterLayers: string[], position: PositionInterface, viewport: ViewportInterface): Promise<RoomConnection> {
+    public connectToRoomSocket(roomId: string, name: string, characterLayers: string[], position: PositionInterface, viewport: ViewportInterface): Promise<OnConnectInterface> {
-        return new Promise<RoomConnection>((resolve, reject) => {
+        return new Promise<OnConnectInterface>((resolve, reject) => {
             const connection = new RoomConnection(this.localUser.jwtToken, roomId, name, characterLayers, position, viewport);
             connection.onConnectError((error: object) => {
                 console.log('An error occurred while connecting to socket server. Retrying');
                 reject(error);
             });
-            connection.onConnect(() => {
+
-                resolve(connection);
+            connection.onConnectingError((event: CloseEvent) => {
-            })
+                console.log('An error occurred while connecting to socket server. Retrying');
+                reject(new Error('An error occurred while connecting to socket server. Retrying. Code: '+event.code+', Reason: '+event.reason));
+            });
+
+            connection.onConnect((connect: OnConnectInterface) => {
+                resolve(connect);
+            });
+
         }).catch((err) => {
             // Let's retry in 4-6 seconds
-            return new Promise<RoomConnection>((resolve, reject) => {
+            return new Promise<OnConnectInterface>((resolve, reject) => {
                 setTimeout(() => {
-                    //todo: allow a way to break recurrsion?
+                    //todo: allow a way to break recursion?
+                    //todo: find a way to avoid recursive function. Otherwise, the call stack will grow indefinitely.
                     this.connectToRoomSocket(roomId, name, characterLayers, position, viewport).then((connection) => resolve(connection));
                 }, 4000 + Math.floor(Math.random() * 2000) );
             });

front/src/Connexion/ConnexionModels.ts

@@ -2,12 +2,14 @@ import {PlayerAnimationNames} from "../Phaser/Player/Animation";
 import {UserSimplePeerInterface} from "../WebRtc/SimplePeer";
 import {SignalData} from "simple-peer";
 import {BodyResourceDescriptionInterface} from "../Phaser/Entity/body_character";
+import {RoomConnection} from "./RoomConnection";
 
 export enum EventMessage{
+    CONNECT = "connect",
     WEBRTC_SIGNAL = "webrtc-signal",
     WEBRTC_SCREEN_SHARING_SIGNAL = "webrtc-screen-sharing-signal",
     WEBRTC_START = "webrtc-start",
-    START_ROOM = "start-room", // From server to client: list of all room users/groups/items
+    //START_ROOM = "start-room", // From server to client: list of all room users/groups/items
     JOIN_ROOM = "join-room", // bi-directional
     USER_POSITION = "user-position", // From client to server
     USER_MOVED = "user-moved", // From server to client
@@ -20,6 +22,7 @@ export enum EventMessage{
     ITEM_EVENT = 'item-event',
 
     CONNECT_ERROR = "connect_error",
+    CONNECTING_ERROR = "connecting_error",
     SET_SILENT = "set_silent", // Set or unset the silent mode for this user.
     SET_VIEWPORT = "set-viewport",
     BATCH = "batch",
@@ -121,8 +124,8 @@ export interface ItemEventMessageInterface {
 }
 
 export interface RoomJoinedMessageInterface {
-    users: MessageUserPositionInterface[],
+    //users: MessageUserPositionInterface[],
-    groups: GroupCreatedUpdatedMessageInterface[],
+    //groups: GroupCreatedUpdatedMessageInterface[],
     items: { [itemId: number] : unknown }
 }
 
@@ -131,3 +134,8 @@ export interface PlayGlobalMessageInterface {
     type: string
     message: string
 }
+
+export interface OnConnectInterface {
+    connection: RoomConnection,
+    room: RoomJoinedMessageInterface
+}

front/src/Connexion/RoomConnection.ts

@@ -1,4 +1,4 @@
-import {API_URL} from "../Enum/EnvironmentVariable";
+import {API_URL, UPLOADER_URL} from "../Enum/EnvironmentVariable";
 import Axios from "axios";
 import {
     BatchMessage,
@@ -36,7 +36,7 @@ import {ProtobufClientUtils} from "../Network/ProtobufClientUtils";
 import {
     EventMessage,
     GroupCreatedUpdatedMessageInterface, ItemEventMessageInterface,
-    MessageUserJoined, PlayGlobalMessageInterface, PositionInterface,
+    MessageUserJoined, OnConnectInterface, PlayGlobalMessageInterface, PositionInterface,
     RoomJoinedMessageInterface,
     ViewportInterface, WebRtcDisconnectMessageInterface,
     WebRtcSignalReceivedMessageInterface,
@@ -52,7 +52,6 @@ export class RoomConnection implements RoomConnection {
     private static websocketFactory: null|((url: string)=>any) = null; // eslint-disable-line @typescript-eslint/no-explicit-any
     private closed: boolean = false;
     private tags: string[] = [];
-    private intervalId!: NodeJS.Timeout;
 
     public static setWebsocketFactory(websocketFactory: (url: string)=>any): void { // eslint-disable-line @typescript-eslint/no-explicit-any
         RoomConnection.websocketFactory = websocketFactory;
@@ -87,16 +86,25 @@ export class RoomConnection implements RoomConnection {
 
         this.socket.binaryType = 'arraybuffer';
 
+        let interval: ReturnType<typeof setInterval>|undefined = undefined;
+
         this.socket.onopen = (ev) => {
             //we manually ping every 20s to not be logged out by the server, even when the game is in background.
             const pingMessage = new PingMessage();
-            this.intervalId = setInterval(() => this.socket.send(pingMessage.serializeBinary().buffer), manualPingDelay);
+            interval = setInterval(() => this.socket.send(pingMessage.serializeBinary().buffer), manualPingDelay);
         };
 
-        this.socket.onclose = () => {
+        this.socket.addEventListener('close', (event) => {
-            clearTimeout(this.intervalId);
+            if (interval) {
+                clearInterval(interval);
             }
 
+            // If we are not connected yet (if a JoinRoomMessage was not sent), we need to retry.
+            if (this.userId === null) {
+                this.dispatch(EventMessage.CONNECTING_ERROR, event);
+            }
+        });
+
         this.socket.onmessage = (messageEvent) => {
             const arrayBuffer: ArrayBuffer = messageEvent.data;
             const message = ServerToClientMessage.deserializeBinary(new Uint8Array(arrayBuffer));
@@ -132,8 +140,8 @@ export class RoomConnection implements RoomConnection {
             } else if (message.hasRoomjoinedmessage()) {
                 const roomJoinedMessage = message.getRoomjoinedmessage() as RoomJoinedMessage;
 
-                const users: Array<MessageUserJoined> = roomJoinedMessage.getUserList().map(this.toMessageUserJoined.bind(this));
+                //const users: Array<MessageUserJoined> = roomJoinedMessage.getUserList().map(this.toMessageUserJoined.bind(this));
-                const groups: Array<GroupCreatedUpdatedMessageInterface> = roomJoinedMessage.getGroupList().map(this.toGroupCreatedUpdatedMessage.bind(this));
+                //const groups: Array<GroupCreatedUpdatedMessageInterface> = roomJoinedMessage.getGroupList().map(this.toGroupCreatedUpdatedMessage.bind(this));
                 const items: { [itemId: number] : unknown } = {};
                 for (const item of roomJoinedMessage.getItemList()) {
                     items[item.getItemid()] = JSON.parse(item.getStatejson());
@@ -142,11 +150,22 @@ export class RoomConnection implements RoomConnection {
                 this.userId = roomJoinedMessage.getCurrentuserid();
                 this.tags = roomJoinedMessage.getTagList();
 
-                this.dispatch(EventMessage.START_ROOM, {
+                //console.log('Dispatching CONNECT')
-                    users,
+                this.dispatch(EventMessage.CONNECT, {
-                    groups,
+                    connection: this,
+                    room: {
+                        //users,
+                        //groups,
                         items
+                    } as RoomJoinedMessageInterface
                 });
+
+                /*console.log('Dispatching START_ROOM')
+                this.dispatch(EventMessage.START_ROOM, {
+                    //users,
+                    //groups,
+                    items
+                });*/
             } else if (message.hasErrormessage()) {
                 console.error(EventMessage.MESSAGE_ERROR, message.getErrormessage()?.getMessage());
             } else if (message.hasWebrtcsignaltoclientmessage()) {
@@ -204,7 +223,7 @@ export class RoomConnection implements RoomConnection {
         const positionMessage = new PositionMessage();
         positionMessage.setX(Math.floor(x));
         positionMessage.setY(Math.floor(y));
-        let directionEnum: PositionMessage.DirectionMap[keyof PositionMessage.DirectionMap];
+        let directionEnum: Direction;
         switch (direction) {
             case 'up':
                 directionEnum = Direction.UP;
@@ -356,20 +375,30 @@ export class RoomConnection implements RoomConnection {
         });
     }
 
+    public onConnectingError(callback: (event: CloseEvent) => void): void {
+        this.onMessage(EventMessage.CONNECTING_ERROR, (event: CloseEvent) => {
+            callback(event);
+        });
+    }
+
     public onConnectError(callback: (error: Event) => void): void {
         this.socket.addEventListener('error', callback)
     }
 
-    public onConnect(callback: (event: Event) => void): void {
+    /*public onConnect(callback: (e: Event) => void): void {
         this.socket.addEventListener('open', callback)
+    }*/
+    public onConnect(callback: (roomConnection: OnConnectInterface) => void): void {
+        //this.socket.addEventListener('open', callback)
+        this.onMessage(EventMessage.CONNECT, callback);
     }
 
     /**
      * Triggered when we receive all the details of a room (users, groups, ...)
      */
-    public onStartRoom(callback: (event: RoomJoinedMessageInterface) => void): void {
+    /*public onStartRoom(callback: (event: RoomJoinedMessageInterface) => void): void {
         this.onMessage(EventMessage.START_ROOM, callback);
-    }
+    }*/
 
     public sendWebrtcSignal(signal: unknown, receiverId: number) {
         const webRtcSignal = new WebRtcSignalToServerMessage();
@@ -472,7 +501,7 @@ export class RoomConnection implements RoomConnection {
     }
 
     public uploadAudio(file : FormData){
-        return Axios.post(`${API_URL}/upload-audio-message`, file).then((res: {data:{}}) => {
+        return Axios.post(`${UPLOADER_URL}/upload-audio-message`, file).then((res: {data:{}}) => {
             return res.data;
         }).catch((err) => {
             console.error(err);

front/src/Enum/EnvironmentVariable.ts

@@ -1,5 +1,6 @@
 const DEBUG_MODE: boolean = process.env.DEBUG_MODE == "true";
-const API_URL = (process.env.API_PROTOCOL || (typeof(window) !== 'undefined' ? window.location.protocol : 'http:')) + '//' + (process.env.API_URL || "api.workadventure.localhost");
+const API_URL = (process.env.API_PROTOCOL || (typeof(window) !== 'undefined' ? window.location.protocol : 'http:')) + '//' + (process.env.API_URL || "pusher.workadventure.localhost");
+const UPLOADER_URL = (process.env.API_PROTOCOL || (typeof(window) !== 'undefined' ? window.location.protocol : 'http:')) + '//' + (process.env.UPLOADER_URL || 'uploader.workadventure.localhost');
 const ADMIN_URL = (process.env.API_PROTOCOL || (typeof(window) !== 'undefined' ? window.location.protocol : 'http:')) + '//' + (process.env.ADMIN_URL || "admin.workadventure.localhost");
 const TURN_SERVER: string = process.env.TURN_SERVER || "turn:numb.viagenie.ca";
 const TURN_USER: string = process.env.TURN_USER || 'g.parant@thecodingmachine.com';
@@ -14,6 +15,7 @@ const MAX_EXTRAPOLATION_TIME = 100; // Extrapolate a maximum of 250ms if no new
 export {
     DEBUG_MODE,
     API_URL,
+    UPLOADER_URL,
     ADMIN_URL,
     RESOLUTION,
     ZOOM_LEVEL,

front/src/Phaser/Game/GameScene.ts

@@ -3,7 +3,7 @@ import {
     GroupCreatedUpdatedMessageInterface,
     MessageUserJoined,
     MessageUserMovedInterface,
-    MessageUserPositionInterface,
+    MessageUserPositionInterface, OnConnectInterface,
     PointInterface,
     PositionInterface,
     RoomJoinedMessageInterface
@@ -62,7 +62,8 @@ import {jitsiFactory} from "../../WebRtc/JitsiFactory";
 import {urlManager} from "../../Url/UrlManager";
 
 export interface GameSceneInitInterface {
-    initPosition: PointInterface|null
+    initPosition: PointInterface|null,
+    reconnecting: boolean
 }
 
 interface InitUserPositionEventInterface {
@@ -146,6 +147,7 @@ export class GameScene extends ResizableScene implements CenterListener {
     // The item that can be selected by pressing the space key.
     private outlinedItem: ActionableItem|null = null;
     private userInputManager!: UserInputManager;
+    private isReconnecting: boolean = false;
     private startLayerName!: string | null;
 
     constructor(private room: Room, MapUrlFile: string) {
@@ -297,6 +299,9 @@ export class GameScene extends ResizableScene implements CenterListener {
         if (initData.initPosition !== undefined) {
             this.initPosition = initData.initPosition; //todo: still used?
         }
+        if (initData.initPosition !== undefined) {
+            this.isReconnecting = initData.reconnecting;
+        }
     }
 
     //hook create scene
@@ -389,7 +394,12 @@ export class GameScene extends ResizableScene implements CenterListener {
         this.circleRedTexture.refresh();
 
         // Let's pause the scene if the connection is not established yet
-        if (this.connection === undefined) {
+        if (this.isReconnecting) {
+            setTimeout(() => {
+            this.scene.sleep();
+            this.scene.launch(ReconnectingSceneName);
+            }, 0);
+        } else if (this.connection === undefined) {
             // Let's wait 0.5 seconds before printing the "connecting" screen to avoid blinking
             setTimeout(() => {
                 if (this.connection === undefined) {
@@ -446,18 +456,14 @@ export class GameScene extends ResizableScene implements CenterListener {
                 top: camera.scrollY,
                 right: camera.scrollX + camera.width,
                 bottom: camera.scrollY + camera.height,
-            }).then((connection: RoomConnection) => {
+            }).then((onConnect: OnConnectInterface) => {
-            this.connection = connection;
+            this.connection = onConnect.connection;
 
             //this.connection.emitPlayerDetailsMessage(gameManager.getPlayerName(), gameManager.getCharacterSelected())
-            connection.onStartRoom((roomJoinedMessage: RoomJoinedMessageInterface) => {
+            /*this.connection.onStartRoom((roomJoinedMessage: RoomJoinedMessageInterface) => {
-                this.initUsersPosition(roomJoinedMessage.users);
-                this.connectionAnswerPromiseResolve(roomJoinedMessage);
-                // Analyze tags to find if we are admin. If yes, show console.
-                this.ConsoleGlobalMessageManager = new ConsoleGlobalMessageManager(this.connection, this.userInputManager, this.connection.hasTag('admin'));
-            });
 
-            connection.onUserJoins((message: MessageUserJoined) => {
+            });*/
+            this.connection.onUserJoins((message: MessageUserJoined) => {
                 const userMessage: AddPlayerInterface = {
                     userId: message.userId,
                     characterLayers: message.characterLayers,
@@ -467,7 +473,7 @@ export class GameScene extends ResizableScene implements CenterListener {
                 this.addPlayer(userMessage);
             });
 
-            connection.onUserMoved((message: UserMovedMessage) => {
+            this.connection.onUserMoved((message: UserMovedMessage) => {
                 const position = message.getPosition();
                 if (position === undefined) {
                     throw new Error('Position missing from UserMovedMessage');
@@ -481,15 +487,15 @@ export class GameScene extends ResizableScene implements CenterListener {
                 this.updatePlayerPosition(messageUserMoved);
             });
 
-            connection.onUserLeft((userId: number) => {
+            this.connection.onUserLeft((userId: number) => {
                 this.removePlayer(userId);
             });
 
-            connection.onGroupUpdatedOrCreated((groupPositionMessage: GroupCreatedUpdatedMessageInterface) => {
+            this.connection.onGroupUpdatedOrCreated((groupPositionMessage: GroupCreatedUpdatedMessageInterface) => {
                 this.shareGroupPosition(groupPositionMessage);
             })
 
-            connection.onGroupDeleted((groupId: number) => {
+            this.connection.onGroupDeleted((groupId: number) => {
                 try {
                     this.deleteGroup(groupId);
                 } catch (e) {
@@ -497,7 +503,7 @@ export class GameScene extends ResizableScene implements CenterListener {
                 }
             })
 
-            connection.onServerDisconnected(() => {
+            this.connection.onServerDisconnected(() => {
                 console.log('Player disconnected from server. Reloading scene.');
 
                 this.simplePeer.closeAllConnections();
@@ -510,14 +516,15 @@ export class GameScene extends ResizableScene implements CenterListener {
                         initPosition: {
                             x: this.CurrentPlayer.x,
                             y: this.CurrentPlayer.y
-                        }
+                        },
+                        reconnecting: true
                     });
 
                 this.scene.stop(this.scene.key);
                 this.scene.remove(this.scene.key);
             })
 
-            connection.onActionableEvent((message => {
+            this.connection.onActionableEvent((message => {
                 const item = this.actionableItems.get(message.itemId);
                 if (item === undefined) {
                     console.warn('Received an event about object "' + message.itemId + '" but cannot find this item on the map.');
@@ -529,7 +536,7 @@ export class GameScene extends ResizableScene implements CenterListener {
             /**
              * Triggered when we receive the JWT token to connect to Jitsi
              */
-            connection.onStartJitsiRoom((jwt, room) => {
+            this.connection.onStartJitsiRoom((jwt, room) => {
                 this.startJitsi(room, jwt);
             });
 
@@ -559,13 +566,19 @@ export class GameScene extends ResizableScene implements CenterListener {
                 this.gameMap.setPosition(event.x, event.y);
             })
 
+            //this.initUsersPosition(roomJoinedMessage.users);
+            this.connectionAnswerPromiseResolve(onConnect.room);
+            // Analyze tags to find if we are admin. If yes, show console.
+            this.ConsoleGlobalMessageManager = new ConsoleGlobalMessageManager(this.connection, this.userInputManager, this.connection.hasTag('admin'));
+
+
         this.scene.wake();
             this.scene.sleep(ReconnectingSceneName);
 
             //init user position and play trigger to check layers properties
             this.gameMap.setPosition(this.CurrentPlayer.x, this.CurrentPlayer.y);
 
-            return connection;
+            return this.connection;
         });
     }
 

front/webpack.config.js

@@ -45,7 +45,7 @@ module.exports = {
         new webpack.ProvidePlugin({
             Phaser: 'phaser'
         }),
-        new webpack.EnvironmentPlugin(['API_URL', 'ADMIN_URL', 'DEBUG_MODE', 'TURN_SERVER', 'TURN_USER', 'TURN_PASSWORD', 'JITSI_URL', 'JITSI_PRIVATE_MODE'])
+        new webpack.EnvironmentPlugin(['API_URL', 'UPLOADER_URL', 'ADMIN_URL', 'DEBUG_MODE', 'TURN_SERVER', 'TURN_USER', 'TURN_PASSWORD', 'JITSI_URL', 'JITSI_PRIVATE_MODE'])
     ],
 
 };

messages/package.json

@@ -2,45 +2,45 @@
   "name": "workadventure-messages",
   "version": "1.0.0",
   "description": "",
-  "main": "generated/src/proto/messages_pb.js",
   "scripts": {
-    "proto": "protoc --plugin=\"protoc-gen-ts=./node_modules/.bin/protoc-gen-ts\" --js_out=\"import_style=commonjs,binary:generated\" --ts_out=\"generated\" messages.proto",
+    "proto": "grpc_tools_node_protoc --plugin=protoc-gen-ts=./node_modules/.bin/protoc-gen-ts --grpc_out=generated --js_out=\"import_style=commonjs,binary:generated\" --ts_out=generated -I ./protos protos/*.proto",
     "copy-to-back": "rm -rf ../back/src/Messages/generated && cp -rf generated/ ../back/src/Messages/generated",
     "copy-to-front": "rm -rf ../front/src/Messages/generated && cp -rf generated/ ../front/src/Messages/generated",
-    "proto-all": "yarn run proto && yarn run copy-to-back && yarn run copy-to-front",
+    "copy-to-pusher": "rm -rf ../pusher/src/Messages/generated && cp -rf generated/ ../pusher/src/Messages/generated",
-    "proto:watch": "yarn run proto-all; inotifywait -q -m -e close_write messages.proto | while read -r filename event; do yarn run proto-all; done"
+    "proto-all": "yarn run proto && yarn run copy-to-back && yarn run copy-to-front && yarn run copy-to-pusher",
+    "proto:watch": "yarn run proto-all; inotifywait -q -m -e close_write protos/messages.proto | while read -r filename event; do yarn run proto-all; done"
+  },
+  "dependencies": {
+    "google-protobuf": "^3.13.0",
+    "grpc": "^1.24.4"
+  },
+  "devDependencies": {
+    "@types/google-protobuf": "^3.7.4",
+    "@types/node": "^14.14.7",
+    "@typescript-eslint/eslint-plugin": "^4.7.0",
+    "@typescript-eslint/parser": "^4.7.0",
+    "dtslint": "^4.0.5",
+    "eslint": "^7.13.0",
+    "eslint-config-airbnb-typescript": "^12.0.0",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-sonarjs": "^0.5.0",
+    "grpc-tools": "^1.9.1",
+    "grpc_tools_node_protoc_ts": "^5.0.1",
+    "protobufjs": "^6.10.1",
+    "rimraf": "^3.0.2",
+    "shelljs": "^0.8.4",
+    "typescript": "^4.0.5"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/thecodingmachine/workadventure.git"
+    "url": "https://github.com/CatsMiaow/node-grpc-typescript.git"
   },
-  "contributors": [
+  "keywords": [
-    {
+    "Node.js",
-      "name": "Grégoire Parant",
+    "gRPC",
-      "email": "g.parant@thecodingmachine.com"
+    "TypeScript"
-    },
-    {
-      "name": "David Négrier",
-      "email": "d.negrier@thecodingmachine.com"
-    },
-    {
-      "name": "Arthmaël Poly",
-      "email": "a.poly@thecodingmachine.com"
-    }
   ],
-  "license": "SEE LICENSE IN LICENSE.txt",
+  "homepage": "https://github.com/CatsMiaow/node-grpc-typescript#readme",
-  "bugs": {
+  "author": "CatsMiaow",
-    "url": "https://github.com/thecodingmachine/workadventure/issues"
+  "license": "MIT"
-  },
-  "homepage": "https://github.com/thecodingmachine/workadventure#readme",
-  "dependencies": {
-    "google-protobuf": "^3.13.0",
-    "typescript": "^3.8.3"
-  },
-  "devDependencies": {
-    "ts-node-dev": "^1.0.0-pre.44",
-    "@types/google-protobuf": "^3.7.3",
-    "concurrently": "^5.3.0",
-    "ts-protoc-gen": "^0.13.0"
-  }
 }

messages/protos/messages.proto

@@ -157,8 +157,8 @@ message ItemStateMessage {
 }
 
 message RoomJoinedMessage {
-  repeated UserJoinedMessage user = 1;
+  //repeated UserJoinedMessage user = 1;
-  repeated GroupUpdateMessage group = 2;
+  //repeated GroupUpdateMessage group = 2;
   repeated ItemStateMessage item = 3;
   int32 currentUserId = 4;
   repeated string tag = 5;
@@ -209,3 +209,144 @@ message ServerToClientMessage {
     SendUserMessage sendUserMessage = 12;
   }
 }
+
+
+/************************** SERVICES **************************/
+
+message JoinRoomMessage {
+  PositionMessage positionMessage = 1;
+  string name = 2;
+  repeated CharacterLayerMessage characterLayer = 3;
+  string userUuid = 4;
+  string roomId = 5;
+  repeated string tag = 6;
+}
+
+message UserJoinedZoneMessage {
+  int32 userId = 1;
+  string name = 2;
+  repeated CharacterLayerMessage characterLayers = 3;
+  PositionMessage position = 4;
+  Zone fromZone = 5;
+}
+
+message UserLeftZoneMessage {
+  int32 userId = 1;
+  Zone toZone = 2;
+}
+
+message GroupUpdateZoneMessage {
+  int32 groupId = 1;
+  PointMessage position = 2;
+  int32 groupSize = 3;
+  Zone fromZone = 4;
+}
+
+message GroupLeftZoneMessage {
+  int32 groupId = 1;
+  Zone toZone = 2;
+}
+
+
+message Zone {
+  int32 x = 1;
+  int32 y = 2;
+}
+
+message ZoneMessage {
+  string roomId = 1;
+  int32 x = 2;
+  int32 y = 3;
+}
+
+message PusherToBackMessage {
+  oneof message {
+    JoinRoomMessage joinRoomMessage = 1;
+    UserMovesMessage userMovesMessage = 2;
+    SilentMessage silentMessage = 3;
+    ViewportMessage viewportMessage = 4;
+    ItemEventMessage itemEventMessage = 5;
+    SetPlayerDetailsMessage setPlayerDetailsMessage = 6;
+    WebRtcSignalToServerMessage webRtcSignalToServerMessage = 7;
+    WebRtcSignalToServerMessage webRtcScreenSharingSignalToServerMessage = 8;
+    PlayGlobalMessage playGlobalMessage = 9;
+    StopGlobalMessage stopGlobalMessage = 10;
+    ReportPlayerMessage reportPlayerMessage = 11;
+    QueryJitsiJwtMessage queryJitsiJwtMessage = 12;
+  }
+}
+
+message BatchToPusherMessage {
+  repeated SubToPusherMessage payload = 2;
+}
+
+message SubToPusherMessage {
+  oneof message {
+    UserJoinedZoneMessage userJoinedZoneMessage = 1;
+    GroupUpdateZoneMessage groupUpdateZoneMessage = 2;
+    UserMovedMessage userMovedMessage = 3;
+    GroupLeftZoneMessage groupLeftZoneMessage = 4;
+    UserLeftZoneMessage userLeftZoneMessage = 5;
+    ItemEventMessage itemEventMessage = 6;
+    SendUserMessage sendUserMessage = 7;
+  }
+}
+
+/*message BatchToAdminPusherMessage {
+  repeated SubToAdminPusherMessage payload = 2;
+}*/
+
+/*message SubToAdminPusherMessage {
+  oneof message {
+    string userUuidJoinedRoom = 1;
+    string userUuidLeftRoom = 2;
+  }
+}
+
+message ServerToAdminClientMessage {
+  repeated SubToAdminPusherMessage payload = 2;
+}*/
+
+message ServerToAdminClientMessage {
+  oneof message {
+    string userUuidJoinedRoom = 1;
+    string userUuidLeftRoom = 2;
+  }
+}
+
+message AdminPusherToBackMessage {
+  oneof message {
+    string subscribeToRoom = 1;
+    // TODO ban, unban
+  }
+}
+
+// A message sent by an administrator to a recipient
+message AdminMessage {
+  string message = 1;
+  string recipientUuid = 2;
+  string roomId = 3;
+}
+
+// A message sent by an administrator to absolutely everybody
+message AdminGlobalMessage {
+  string message = 1;
+}
+
+message BanMessage {
+  string recipientUuid = 1;
+  string roomId = 2;
+}
+
+message EmptyMessage {
+
+}
+
+service RoomManager {
+  rpc joinRoom(stream PusherToBackMessage) returns (stream ServerToClientMessage);
+  rpc listenZone(ZoneMessage) returns (stream BatchToPusherMessage);
+  rpc adminRoom(stream AdminPusherToBackMessage) returns (stream ServerToAdminClientMessage);
+  rpc sendAdminMessage(AdminMessage) returns (EmptyMessage);
+  rpc sendGlobalAdminMessage(AdminGlobalMessage) returns (EmptyMessage);
+  rpc ban(BanMessage) returns (EmptyMessage);
+}

pusher/.dockerignore

@@ -0,0 +1,5 @@
+/dist/
+/node_modules/
+/dist/bundle.js
+/yarn-error.log
+/Dockerfile

pusher/.eslintrc.json

@@ -0,0 +1,30 @@
+{
+    "root": true,
+    "env": {
+        "browser": true,
+        "es6": true,
+        "node": true
+    },
+    "extends": [
+        "eslint:recommended",
+        "plugin:@typescript-eslint/eslint-recommended",
+        "plugin:@typescript-eslint/recommended-requiring-type-checking"
+    ],
+    "globals": {
+        "Atomics": "readonly",
+        "SharedArrayBuffer": "readonly"
+    },
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+        "ecmaVersion": 2018,
+        "sourceType": "module",
+        "project": "./tsconfig.json"
+    },
+    "plugins": [
+        "@typescript-eslint"
+    ],
+    "rules": {
+        "no-unused-vars": "off",
+        "@typescript-eslint/no-explicit-any": "error"
+    }
+}

pusher/.gitignore

@@ -0,0 +1,4 @@
+/dist/
+/node_modules/
+/dist/bundle.js
+/yarn-error.log

pusher/Dockerfile

@@ -0,0 +1,15 @@
+FROM thecodingmachine/workadventure-back-base:latest as builder
+WORKDIR /var/www/messages
+COPY --chown=docker:docker messages .
+RUN yarn install && yarn proto
+
+FROM thecodingmachine/nodejs:12
+
+COPY --chown=docker:docker pusher .
+COPY --from=builder --chown=docker:docker /var/www/messages/generated /usr/src/app/src/Messages/generated
+RUN yarn install
+
+ENV NODE_ENV=production
+RUN yarn run tsc
+
+CMD ["yarn", "run", "runprod"]

pusher/LICENSE.txt

@@ -0,0 +1,691 @@
+NOTICE
+This package contains software licensed under different
+licenses, please refer to the NOTICE.txt file for further
+information and LICENSES.txt for full license texts.
+
+WorkAdventure Enterprise edition can be licensed independently from
+the source under separate commercial terms.
+
+The software ("Software") is developed and owned by TheCodingMachine
+and is subject to the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
+Version 3, with the Commons Clause as follows:
+
+
+
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license
+for software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are
+designed to take away your freedom to share and change the works.  By
+contrast, our General Public Licenses are intended to guarantee your
+freedom to share and change all versions of a program--to make sure it
+remains free software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public
+License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds
+of works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further restriction,
+you may remove that term.  If a license document contains a further
+restriction but permits relicensing or conveying under this License, you
+may add to a covered work material governed by the terms of that license
+document, provided that the further restriction does not survive such
+relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have permission
+to link or combine any covered work with a work licensed under version 3
+of the GNU General Public License into a single combined work, and to
+convey the resulting work.  The terms of this License will continue to
+apply to the part which is the covered work, but the work with which it is
+combined will remain governed by version 3 of the GNU General Public
+License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new
+versions will be similar in spirit to the present version, but may differ
+in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero
+General Public License "or any later version" applies to it, you have
+the option of following the terms and conditions either of that
+numbered version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number
+of the GNU Affero General Public License, you may choose any version
+ever published by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that
+proxy's public statement of acceptance of a version permanently
+authorizes you to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                       END OF TERMS AND CONDITIONS
+
+              How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as
+    published by the Free Software Foundation, either version 3 of the
+    License, or (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<http://www.gnu.org/licenses/>.
+
+
+"Commons Clause" License Condition
+
+The Software is provided to you by the Licensor under the License, as
+defined below, subject to the following condition. Without limiting
+other conditions in the License, the grant of rights under the License
+will not include, and the License does not grant to you, the right to
+Sell the Software.  For purposes of the foregoing, "Sell" means
+practicing any or all of the rights granted to you under the License
+to provide to third parties, for a fee or other consideration,
+a product or service that consists, entirely or substantially,
+of the Software or the functionality of the Software. Any license
+notice or attribution required by the License must also include
+this Commons Cause License Condition notice.

pusher/README.md

@@ -0,0 +1,5 @@
+# Pusher
+
+The pusher component is in charge of accepting WebSocket and HTTP connections from the front and forwarding them
+to the correct "api" server (or to the "admin").
+ 

pusher/jasmine.json

@@ -0,0 +1,5 @@
+{
+  "spec_dir": "tests",
+  "spec_files": ["**/*[tT]est.ts"],
+  "stopSpecOnExpectationFailure": false
+}

pusher/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "workadventureback",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "tsc": "tsc",
+    "dev": "ts-node-dev --respawn ./server.ts",
+    "prod": "tsc && node --max-old-space-size=4096 ./dist/server.js",
+    "runprod": "node --max-old-space-size=4096 ./dist/server.js",
+    "profile": "tsc && node --prof ./dist/server.js",
+    "test": "ts-node node_modules/jasmine/bin/jasmine --config=jasmine.json",
+    "lint": "node_modules/.bin/eslint src/ . --ext .ts",
+    "fix": "node_modules/.bin/eslint --fix src/ . --ext .ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thecodingmachine/workadventure.git"
+  },
+  "contributors": [
+    {
+      "name": "Grégoire Parant",
+      "email": "g.parant@thecodingmachine.com"
+    },
+    {
+      "name": "David Négrier",
+      "email": "d.negrier@thecodingmachine.com"
+    },
+    {
+      "name": "Arthmaël Poly",
+      "email": "a.poly@thecodingmachine.com"
+    }
+  ],
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "bugs": {
+    "url": "https://github.com/thecodingmachine/workadventure/issues"
+  },
+  "homepage": "https://github.com/thecodingmachine/workadventure#readme",
+  "dependencies": {
+    "axios": "^0.20.0",
+    "body-parser": "^1.19.0",
+    "busboy": "^0.3.1",
+    "circular-json": "^0.5.9",
+    "debug": "^4.3.1",
+    "generic-type-guard": "^3.2.0",
+    "google-protobuf": "^3.13.0",
+    "grpc": "^1.24.4",
+    "http-status-codes": "^1.4.0",
+    "iterall": "^1.3.0",
+    "jsonwebtoken": "^8.5.1",
+    "mkdirp": "^1.0.4",
+    "multer": "^1.4.2",
+    "prom-client": "^12.0.0",
+    "query-string": "^6.13.3",
+    "systeminformation": "^4.27.11",
+    "ts-node-dev": "^1.0.0-pre.44",
+    "typescript": "^3.8.3",
+    "uWebSockets.js": "uNetworking/uWebSockets.js#v18.5.0",
+    "uuidv4": "^6.0.7"
+  },
+  "devDependencies": {
+    "@types/busboy": "^0.2.3",
+    "@types/circular-json": "^0.4.0",
+    "@types/debug": "^4.1.5",
+    "@types/google-protobuf": "^3.7.3",
+    "@types/http-status-codes": "^1.2.0",
+    "@types/jasmine": "^3.5.10",
+    "@types/jsonwebtoken": "^8.3.8",
+    "@types/mkdirp": "^1.0.1",
+    "@types/uuidv4": "^5.0.0",
+    "@typescript-eslint/eslint-plugin": "^2.26.0",
+    "@typescript-eslint/parser": "^2.26.0",
+    "eslint": "^6.8.0",
+    "jasmine": "^3.5.0"
+  }
+}

pusher/server.ts

@@ -0,0 +1,3 @@
+// lib/server.ts
+import App from "./src/App";
+App.listen(8080, () => console.log(`WorkAdventure starting on port 8080!`))

pusher/src/App.ts

@@ -0,0 +1,29 @@
+// 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 {DebugController} from "./Controller/DebugController";
+import {App as uwsApp} from "./Server/sifrr.server";
+
+class App {
+    public app: uwsApp;
+    public ioSocketController: IoSocketController;
+    public authenticateController: AuthenticateController;
+    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.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/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/IoSocketController.ts

@@ -1,5 +1,5 @@
 import {CharacterLayer, ExSocketInterface} from "../Model/Websocket/ExSocketInterface"; //TODO fix import by "_Model/.."
-import {GameRoomPolicyTypes} from "../Model/GameRoom";
+import {GameRoomPolicyTypes} from "../Model/PusherRoom";
 import {PointInterface} from "../Model/Websocket/PointInterface";
 import {
     SetPlayerDetailsMessage,
@@ -12,7 +12,7 @@ import {
     WebRtcSignalToServerMessage,
     PlayGlobalMessage,
     ReportPlayerMessage,
-    QueryJitsiJwtMessage
+    QueryJitsiJwtMessage, SendUserMessage, ServerToClientMessage
 } from "../Messages/generated/messages_pb";
 import {UserMovesMessage} from "../Messages/generated/messages_pb";
 import {TemplatedApp} from "uWebSockets.js"
@@ -23,6 +23,8 @@ 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";
+import {ExAdminSocketInterface} from "_Model/Websocket/ExAdminSocketInterface";
 
 export class IoSocketController {
     private nextUserId: number = 1;
@@ -45,7 +47,12 @@ export class IoSocketController {
                     res.writeStatus("401 Unauthorized").end('Incorrect token');
                     return;
                 }
-                const roomId = query.roomId as string;
+                const roomId = query.roomId;
+                if (typeof roomId !== 'string') {
+                    console.error('Received')
+                    res.writeStatus("400 Bad Request").end('Missing room id');
+                    return;
+                }
 
                 res.upgrade(
                     {roomId},
@@ -54,7 +61,11 @@ export class IoSocketController {
             },
             open: (ws) => {
                 console.log('Admin socket connect for room: '+ws.roomId);
-                ws.send('Data:'+JSON.stringify(socketManager.getAdminSocketDataFor(ws.roomId as string)));
+                ws.disconnecting = false;
+
+                socketManager.handleAdminRoom(ws as ExAdminSocketInterface, ws.roomId as string);
+
+                /*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) {
@@ -68,10 +79,12 @@ export class IoSocketController {
                     }
                 };
                 clientEventsEmitter.registerToClientJoin(ws.clientJoinCallback);
-                clientEventsEmitter.registerToClientLeave(ws.clientLeaveCallback);
+                clientEventsEmitter.registerToClientLeave(ws.clientLeaveCallback);*/
             },
             message: (ws, arrayBuffer, isBinary): void => {
                 try {
+                    const roomId = ws.roomId as string;
+
                     //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)));
@@ -80,14 +93,11 @@ export class IoSocketController {
                         const messageToEmit = (message.message as { message: string, type: string, userUuid: string });
                         switch (message.message.type) {
                             case 'ban': {
-                                socketManager.emitSendUserMessage(messageToEmit);
+                                socketManager.emitSendUserMessage(messageToEmit.userUuid, messageToEmit.message, roomId);
                                 break;
                             }
                             case 'banned': {
-                                const socketUser = socketManager.emitSendUserMessage(messageToEmit);
+                                socketManager.emitBan(messageToEmit.userUuid, messageToEmit.message, roomId);
-                                setTimeout(() => {
-                                    socketUser.close();
-                                }, 10000);
                                 break;
                             }
                             default: {
@@ -100,9 +110,15 @@ export class IoSocketController {
                 }
             },
             close: (ws, code, message) => {
-                //todo make sure this code unregister the right listeners
+                const Client = (ws as ExAdminSocketInterface);
-                clientEventsEmitter.unregisterFromClientJoin(ws.clientJoinCallback);
+                try {
-                clientEventsEmitter.unregisterFromClientLeave(ws.clientLeaveCallback);
+                    Client.disconnecting = true;
+                    //leave room
+                    socketManager.leaveAdminRoom(Client);
+                } catch (e) {
+                    console.error('An error occurred on admin "disconnect"');
+                    console.error(e);
+                }
             }
         })
     }
@@ -165,9 +181,10 @@ export class IoSocketController {
                         let memberTags: string[] = [];
                         let memberTextures: CharacterTexture[] = [];
                         const room = await socketManager.getOrCreateRoom(roomId);
-                        if(room.isFull){
+                        // 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);
@@ -250,11 +267,17 @@ export class IoSocketController {
                         }
                         res.messages.forEach((c: unknown) => {
                             const messageToSend = c as { type: string, message: string };
-                            socketManager.emitSendUserMessage({
+
-                                userUuid: client.userUuid,
+                            const sendUserMessage = new SendUserMessage();
-                                type: messageToSend.type,
+                            sendUserMessage.setType(messageToSend.type);
-                                message: messageToSend.message
+                            sendUserMessage.setMessage(messageToSend.message);
-                            })
+
+                            const serverToClientMessage = new ServerToClientMessage();
+                            serverToClientMessage.setSendusermessage(sendUserMessage);
+
+                            if (!client.disconnecting) {
+                                client.send(serverToClientMessage.serializeBinary().buffer, true);
+                            }
                         });
                     }).catch((err) => {
                         console.error('fetchMemberDataByUuid => err', err);
@@ -266,7 +289,7 @@ export class IoSocketController {
                 const message = ClientToServerMessage.deserializeBinary(new Uint8Array(arrayBuffer));
 
                 if (message.hasViewportmessage()) {
-                    socketManager.handleViewport(client, message.getViewportmessage() as ViewportMessage);
+                    socketManager.handleViewport(client, (message.getViewportmessage() as ViewportMessage).toObject());
                 } else if (message.hasUsermovesmessage()) {
                     socketManager.handleUserMovesMessage(client, message.getUsermovesmessage() as UserMovesMessage);
                 } else if (message.hasSetplayerdetailsmessage()) {
@@ -326,6 +349,7 @@ export class IoSocketController {
         client.textures = ws.textures;
         client.characterLayers = ws.characterLayers;
         client.roomId = ws.roomId;
+        client.listenedZones = new Set<Zone>();
         return client;
     }
 }

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/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,58 @@
+import {ExSocketInterface} from "_Model/Websocket/ExSocketInterface";
+import {PositionDispatcher} from "./PositionDispatcher";
+import {ViewportInterface} from "_Model/Websocket/ViewportMessage";
+import {extractDataFromPrivateRoomId, extractRoomSlugPublicRoomId, isRoomAnonymous} from "./RoomIdentifier";
+import {arrayIntersect} from "../Services/ArrayHelper";
+import {ZoneEventListener} from "_Model/Zone";
+
+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/Websocket/ExAdminSocketInterface.ts

@@ -0,0 +1,21 @@
+import {PointInterface} from "./PointInterface";
+import {Identificable} from "./Identificable";
+import {ViewportInterface} from "_Model/Websocket/ViewportMessage";
+import {
+    AdminPusherToBackMessage,
+    BatchMessage,
+    PusherToBackMessage, ServerToAdminClientMessage,
+    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 AdminConnection = ClientDuplexStream<AdminPusherToBackMessage, ServerToAdminClientMessage>;
+
+export interface ExAdminSocketInterface extends WebSocket {
+    adminConnection: AdminConnection,
+    disconnecting: boolean,
+}

pusher/src/Model/Websocket/ExSocketInterface.ts

@@ -1,9 +1,18 @@
 import {PointInterface} from "./PointInterface";
 import {Identificable} from "./Identificable";
 import {ViewportInterface} from "_Model/Websocket/ViewportMessage";
-import {BatchMessage, SubMessage} from "../../Messages/generated/messages_pb";
+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,
@@ -28,4 +37,6 @@ export interface ExSocketInterface extends WebSocket, Identificable {
     disconnecting: boolean,
     tags: string[],
     textures: CharacterTexture[],
+    backConnection: BackConnection,
+    listenedZones: Set<Zone>;
 }

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/Point.ts

@@ -0,0 +1,6 @@
+import {PointInterface} from "./PointInterface";
+
+export class Point implements PointInterface{
+    constructor(public x : number, public y : number, public direction : string = "none", public moving : boolean = false) {
+    }
+}

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/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
+};