@magicworks/client-party-game 0.1.0-rc.4 → 0.1.0-rc.6

package/dist/client.js

@@ -1,12 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PartyGameClient = void 0;
+const connection_1 = require("./connection");
 const protocol_1 = require("./protocol");
+/**
+ * The global fetch, looked up when called. Called as a plain function, as
+ * browsers insist, and without `globalThis`, which the app's oldest web
+ * engine (Chrome 56) does not have.
+ */
+const globalFetch = url => typeof fetch === 'function'
+    ? fetch(url)
+    : Promise.reject(new Error('no fetch: pass one to PartyGameClient'));
 const defaultAckTimeoutMs = 8000;
+const defaultPlacementTimeoutMs = 4000;
 const defaultClockSyncIntervalMs = 60 * 1000;
+/**
+ * A server that has gone keeps its TVs waiting no more than about 15s for a
+ * new room, and one that stalls for a few seconds keeps them: a TV that gives
+ * up on its room mid-game leaves its phones behind in it.
+ */
+const defaultRoomRetryMs = [1000, 3000, 5000, 10000, 15000];
 const clockSyncSamples = 5;
-/** Servers that can be on their way out at once, during a deploy. */
-const maxDrainingRetries = 3;
 /** Hops a room can have made between servers since we last knew its code. */
 const maxRedirects = 3;
 /**
@@ -29,21 +43,14 @@ const moduleRoomMemory = {
         rememberedCode = code;
     },
 };
-function withTimeout(promise, ms, what) {
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error(`party server did not answer ${what} in ${ms}ms`)), ms);
-        promise.then(value => {
-            clearTimeout(timer);
-            resolve(value);
-        }, error => {
-            clearTimeout(timer);
-            reject(error);
-        });
+/** `players` with each one's flags in `flags` taken on: a new list, so a screen holding the last one sees the change. */
+function withFlags(players, flags) {
+    const changed = new Map(flags.map(entry => [entry.id, entry]));
+    return players.map(player => {
+        const entry = changed.get(player.id);
+        return entry ? { ...player, ...entry } : player;
     });
 }
-function routesAlike(a, b) {
-    return (a ? (0, protocol_1.codePrefixOf)(a) : null) === (b ? (0, protocol_1.codePrefixOf)(b) : null);
-}
 /**
  * Host side of the party games protocol. The TV owns the video and therefore
  * owns round timing: it tells the server when a round starts and when it ends,
@@ -53,32 +60,18 @@ function routesAlike(a, b) {
  * so navigating from the lobby into the first round keeps the same room and
  * the same players.
  *
- * Rooms live in the memory of one server of several, and the load balancer
- * finds it by the room code: every connection made for a room carries its
- * code (ROUTING_QUERY_KEY). A connection made before there is a room goes to
- * any server, so once that server has opened one the client connects again
- * with its code - in the lobby, where a moment's reconnect costs nothing,
- * rather than leaving the game on a route the load balancer can take away.
+ * Rooms live in the memory of one server of several. Reaching the room's -
+ * placing each socket, and placing it again when it drops - is the
+ * connection's job: see PartyConnection.
  */
 class PartyGameClient {
-    url;
-    regionUrls;
-    io;
+    connection;
     hostId;
     roomMemory;
     logger;
-    ackTimeoutMs;
     clockSyncIntervalMs;
-    socket = null;
-    /** The room code the current socket was routed by, if any. */
-    routedCode = null;
-    /**
-     * Whether the current connection is attached to the session's room. Host
-     * calls wait for it: sent while a reconnect is still re-attaching, they
-     * would reach the server from a socket it does not know the room of.
-     */
-    attached = true;
-    attachedWaiters = [];
+    /** Roster changes for a room this TV is about to be handed: see adopt. */
+    earlyFlags = null;
     session = null;
     /** Where the session's room is now, when a server has said it moved. */
     redirectCode = null;
@@ -99,21 +92,28 @@ class PartyGameClient {
     clockOffset = 0;
     clockSyncTimer = null;
     constructor(options) {
-        this.url = options.url.replace(/\/+$/, '');
-        /* No Object.entries or fromEntries: older TV browsers lack them, and the
-           app has no polyfill. */
-        const regionUrls = options.regionUrls || {};
-        this.regionUrls = {};
-        for (const region of Object.keys(regionUrls)) {
-            this.regionUrls[region] = regionUrls[region].replace(/\/+$/, '');
-        }
-        this.io = options.io;
         this.hostId = options.hostId || processHostId;
         this.roomMemory = options.roomMemory || moduleRoomMemory;
         this.logger = options.logger || console;
-        this.ackTimeoutMs = options.ackTimeoutMs ?? defaultAckTimeoutMs;
         this.clockSyncIntervalMs =
             options.clockSyncIntervalMs ?? defaultClockSyncIntervalMs;
+        this.connection = new connection_1.PartyConnection({
+            url: options.url.replace(/\/+$/, ''),
+            regionUrls: options.regionUrls || {},
+            io: options.io,
+            fetch: options.fetch || globalFetch,
+            logger: this.logger,
+            ackTimeoutMs: options.ackTimeoutMs ?? defaultAckTimeoutMs,
+            placementTimeoutMs: options.placementTimeoutMs ?? defaultPlacementTimeoutMs,
+            roomRetryMs: options.roomRetryMs ?? defaultRoomRetryMs,
+        }, {
+            roomCode: () => this.redirectCode || this.session?.code || null,
+            opened: socket => this.listen(socket),
+            connected: (socket, prefix) => {
+                this.syncClock();
+                this.reattach(socket, prefix);
+            },
+        });
     }
     getSession() {
         return this.session;
@@ -122,7 +122,7 @@ class PartyGameClient {
         return this.players;
     }
     isConnected() {
-        return this.socket ? this.socket.connected : false;
+        return this.connection.isConnected();
     }
     /**
      * A download of at least `bytes` random bytes for the TV to time in the
@@ -140,81 +140,8 @@ class PartyGameClient {
         return { url: `${origin}${(0, protocol_1.speedtestPath)(size)}`, bytes: size };
     }
     /* ---------------------------------------------------------- connection */
-    /** The socket for `code`'s room (or for no room), connecting a new one if need be. */
-    socketFor(code, { fresh = false } = {}) {
-        if (this.socket && !fresh && routesAlike(this.routedCode, code)) {
-            return this.socket;
-        }
-        if (this.socket) {
-            this.logger.debug('PartyGames', 'reconnecting to route by', code);
-            this.socket.close();
-        }
-        this.routedCode = code;
-        this.socket = this.openSocket(code);
-        return this.socket;
-    }
-    currentSocket() {
-        return this.socket || this.socketFor(this.session?.code || null);
-    }
-    setAttached(attached) {
-        this.attached = attached;
-        if (attached) {
-            const waiters = this.attachedWaiters;
-            this.attachedWaiters = [];
-            for (const waiter of waiters) {
-                waiter();
-            }
-        }
-    }
-    whenAttached(what) {
-        if (this.attached) {
-            return Promise.resolve();
-        }
-        return withTimeout(new Promise(resolve => this.attachedWaiters.push(resolve)), this.ackTimeoutMs, `${what} (reconnecting)`);
-    }
-    /** Where `code`'s room is: its region's servers, or for no room, the nearest. */
-    urlFor(code) {
-        return code
-            ? (0, protocol_1.socketUrlForCode)(code, {
-                socketUrl: this.url,
-                regionSocketUrls: this.regionUrls,
-            })
-            : this.url;
-    }
-    /** A socket routed by `code`, to `url` (by default, where `code`'s room is). */
-    connectTo(code, url = this.urlFor(code)) {
-        return this.io(url, {
-            transports: ['websocket'],
-            jsonp: false,
-            query: code ? { [protocol_1.ROUTING_QUERY_KEY]: code } : {},
-            forceNew: true,
-            reconnection: true,
-            reconnectionDelay: 1000,
-            reconnectionDelayMax: 5000,
-            timeout: this.ackTimeoutMs,
-        });
-    }
-    openSocket(code) {
-        this.setAttached(false);
-        const socket = this.connectTo(code);
-        socket.on('connect', () => {
-            if (socket !== this.socket) {
-                return;
-            }
-            this.logger.debug('PartyGames', 'connected to', this.url);
-            this.syncClock();
-            this.reattach(socket);
-        });
-        socket.on('disconnect', () => {
-            if (socket !== this.socket) {
-                return;
-            }
-            this.logger.debug('PartyGames', 'disconnected');
-            this.setAttached(false);
-        });
-        socket.on('connect_error', (error) => {
-            this.logger.warn('PartyGames', 'connect error', error?.message);
-        });
+    /** Listens for the room's messages on a socket the connection has opened. */
+    listen(socket) {
         socket.on(protocol_1.HostMessage.Players, (payload) => {
             if (this.session && payload?.code && payload.code !== this.session.code) {
                 /* a room this TV is only now being given - its own went, or moved -
@@ -222,10 +149,26 @@ class PartyGameClient {
                    the roster is the room's it was in */
                 return;
             }
-            this.players = payload?.players || [];
-            for (const listener of this.playersListeners) {
-                listener(this.players);
+            this.setPlayers(payload?.players || []);
+        });
+        socket.on(protocol_1.HostMessage.PlayersChanged, (payload) => {
+            if (!payload?.players) {
+                return;
+            }
+            if (payload.code !== this.session?.code) {
+                /* a room being handed to this TV, whose answer has not been taken
+                   on yet: kept until it is, as unlike a whole roster these are not
+                   sent again */
+                this.earlyFlags =
+                    this.earlyFlags?.code === payload.code
+                        ? {
+                            code: payload.code,
+                            players: [...this.earlyFlags.players, ...payload.players],
+                        }
+                        : payload;
+                return;
             }
+            this.setPlayers(withFlags(this.players, payload.players));
         });
         socket.on(protocol_1.HostMessage.AllAnswered, (payload) => {
             for (const listener of this.allAnsweredListeners) {
@@ -241,7 +184,7 @@ class PartyGameClient {
             }
         });
         socket.on(protocol_1.HostMessage.Move, (message) => {
-            if (socket === this.socket && message?.token) {
+            if (socket === this.connection.current() && message?.token) {
                 this.moveRoom(socket, message.token);
             }
         });
@@ -257,25 +200,35 @@ class PartyGameClient {
             /* clocks drift, and so does the route to the server */
             this.clockSyncTimer = setInterval(() => this.syncClock(), this.clockSyncIntervalMs);
         }
-        return socket;
+    }
+    setPlayers(players) {
+        this.players = players;
+        for (const listener of this.playersListeners) {
+            listener(this.players);
+        }
     }
     /**
      * Back on the room we were already hosting, so a dropped connection
      * mid-party does not lose the players or their scores. If the room is gone
      * - its server is - the server opens a new one, and the session follows.
      */
-    reattach(socket) {
+    reattach(socket, prefix) {
         const session = this.session;
         if (!session) {
-            this.setAttached(true);
+            this.connection.attachedTo(socket);
             return;
         }
-        this.send(socket, protocol_1.HostEvent.Create, {
+        let attached = true;
+        this.connection
+            .send(socket, protocol_1.HostEvent.Create, {
             code: this.redirectCode || session.code,
             hostId: this.hostId,
             features,
         })
             .then(response => {
+            if (socket !== this.connection.current()) {
+                return;
+            }
             if (response?.ok) {
                 // A re-attach is not a reopen, so it says `reused: false`; the
                 // lobby still is the one it was.
@@ -294,13 +247,14 @@ class PartyGameClient {
             }
             else if (response?.reason === protocol_1.HostRefusal.Moved && response.movedTo) {
                 /* it left that server while we were away: follow it */
+                attached = false;
                 this.redirectCode = response.movedTo;
-                this.socketFor(response.movedTo);
+                this.connection.connectFor(response.movedTo);
             }
             else if (response?.reason === protocol_1.HostRefusal.Draining) {
-                /* the room is gone and its server opens no new ones: another will,
-                   over a new connection the load balancer can send elsewhere */
-                this.socketFor(null, { fresh: true });
+                /* the room is gone and its server opens no new ones: another will */
+                attached = false;
+                this.connection.connectFor(null, { avoid: [prefix] });
             }
             else {
                 this.logger.warn('PartyGames', 'failed to re-attach', response);
@@ -308,13 +262,16 @@ class PartyGameClient {
         })
             .catch(error => this.logger.warn('PartyGames', 'failed to re-attach', error))
             .finally(() => {
-            if (socket === this.socket) {
-                this.setAttached(true);
+            if (attached) {
+                this.connection.attachedTo(socket);
             }
         });
     }
     /** Takes on a session the server has handed back, rerouting by its code if need be. */
     adopt(response) {
+        if (response.regionSocketUrls) {
+            this.connection.setRegionUrls(response.regionSocketUrls);
+        }
         const previous = this.session;
         this.redirectCode = null;
         this.session = {
@@ -327,6 +284,11 @@ class PartyGameClient {
             players: response.players || [],
         };
         this.players = this.session.players;
+        const early = this.earlyFlags;
+        this.earlyFlags = null;
+        if (early?.code === response.code) {
+            this.setPlayers(withFlags(this.players, early.players));
+        }
         this.roomMemory.set(response.code);
         if (previous && previous.code !== response.code) {
             this.logger.warn('PartyGames', 'room', previous.code, 'is gone, now', response.code);
@@ -334,60 +296,66 @@ class PartyGameClient {
                 listener(this.session);
             }
         }
-        if (!routesAlike(this.routedCode, response.code)) {
-            this.socketFor(response.code);
-        }
-        else {
-            /* same server: from now on this socket stands for the room */
-            this.routedCode = response.code;
+        if (!this.connection.routesTo(response.code)) {
+            this.connection.connectFor(response.code);
         }
     }
-    send(socket, event, payload = {}) {
-        return withTimeout(new Promise(resolve => socket.emit(event, payload, resolve)), this.ackTimeoutMs, event);
-    }
     /**
      * A host call: once the connection is attached to the room. A call that
      * crossed the room's move to another server is sent again from there.
      */
     async emit(event, payload = {}) {
         for (let attempt = 0;; ++attempt) {
-            const socket = this.currentSocket();
-            await this.whenAttached(event);
-            const response = await this.send(this.socket || socket, event, payload);
+            this.connection.ensure();
+            await this.connection.whenAttached(event);
+            const socket = this.connection.current();
+            if (!socket) {
+                throw new Error(`party server not connected for ${event}`);
+            }
+            const response = await this.connection.send(socket, event, payload);
             const reason = response?.reason;
             if (reason !== protocol_1.HostRefusal.Moving || attempt >= maxMovingRetries) {
                 return response;
             }
-            if (this.attached) {
+            if (this.connection.isAttached()) {
                 /* refused before the server said where the room is going: the
                    room:move follows, and has us reconnecting - or the move failed
                    and the server lets the room go on here after a while */
                 await new Promise(resolve => setTimeout(resolve, movingRetryMs));
             }
             /* the room:move that came before this answer has us reconnecting */
-            await this.whenAttached(event);
+            await this.connection.whenAttached(event);
         }
     }
     /**
      * Takes the room to another server, which the one it is on asked for: it
-     * is on its way out, and no game is being played. The room is adopted over
-     * a connection with no room in its query - so the load balancer hands it
-     * to a server still taking parties - the old server is told where it went,
-     * for the phones, and the client then connects for the new code as usual.
-     * Host calls wait meanwhile. If it cannot be done the room stays where it
-     * was, and the server asks again later.
+     * is on its way out, and no game is being played. Another server of the
+     * room's region - the handover is between them, in their tables - is
+     * placed for no room and adopts it over a socket of its own; the old server
+     * is told where it went, for the phones; and the client then connects for
+     * the new code as usual. Host calls wait meanwhile. If it cannot be done
+     * the room stays where it was, and the server asks again later.
      */
     async moveRoom(oldSocket, token) {
-        this.setAttached(false);
-        // The handover is between the servers of one region, whose tables hold
-        // it, so it goes to the room's region rather than the nearest.
-        const regionUrl = this.urlFor(this.session?.code || null);
+        this.connection.setAttached(false);
+        const regionUrl = this.connection.urlFor(this.session?.code || null);
+        const avoid = this.connection.avoidingRouted();
         let adopted = null;
-        for (let attempt = 0; attempt <= maxDrainingRetries && !adopted; ++attempt) {
-            const socket = this.connectTo(null, regionUrl);
+        for (let attempt = 0; attempt <= connection_1.maxDrainingRetries && !adopted; ++attempt) {
+            const placed = await this.connection.place(regionUrl, null, avoid);
+            if (!placed) {
+                /* no server answered: give it a moment before asking again */
+                await new Promise(resolve => setTimeout(resolve, (0, protocol_1.reconnectDelay)(attempt)));
+                continue;
+            }
+            if (placed === connection_1.refused) {
+                /* the next ask goes to the next server */
+                continue;
+            }
+            const socket = this.connection.connectTo(placed.prefix, placed.url);
             try {
-                await withTimeout(new Promise(resolve => socket.on('connect', () => resolve())), this.ackTimeoutMs, 'connecting to move the room');
-                const response = await this.send(socket, protocol_1.HostEvent.Adopt, {
+                await this.connection.whenConnected(socket, 'connecting to move the room');
+                const response = await this.connection.send(socket, protocol_1.HostEvent.Adopt, {
                     token,
                     hostId: this.hostId,
                     features,
@@ -395,28 +363,34 @@ class PartyGameClient {
                 if (response?.ok) {
                     adopted = response;
                 }
-                else if (response?.reason !== protocol_1.HostRefusal.Draining) {
+                else if (response?.reason === protocol_1.HostRefusal.Draining) {
+                    avoid.push(placed.prefix);
+                }
+                else {
                     this.logger.warn('PartyGames', 'could not move the room', response);
                     break;
                 }
             }
             catch (error) {
                 this.logger.warn('PartyGames', 'could not move the room', error);
+                avoid.push(placed.prefix);
             }
             finally {
                 socket.close();
             }
         }
-        if (oldSocket !== this.socket) {
+        if (oldSocket !== this.connection.current()) {
             return;
         }
         if (!adopted) {
-            this.setAttached(true);
+            this.connection.setAttached(true);
             return;
         }
         this.logger.debug('PartyGames', 'room moved to', adopted.code);
-        await this.send(oldSocket, protocol_1.HostEvent.Moved, { code: adopted.code }).catch(error => this.logger.warn('PartyGames', 'could not say where the room went', error));
-        if (oldSocket === this.socket) {
+        await this.connection
+            .send(oldSocket, protocol_1.HostEvent.Moved, { code: adopted.code })
+            .catch(error => this.logger.warn('PartyGames', 'could not say where the room went', error));
+        if (oldSocket === this.connection.current()) {
             this.adopt(adopted);
         }
     }
@@ -430,8 +404,12 @@ class PartyGameClient {
         let best = null;
         for (let sample = 0; sample < clockSyncSamples; ++sample) {
             try {
+                const socket = this.connection.current();
+                if (!socket) {
+                    break;
+                }
                 const sentAt = Date.now();
-                const response = await this.send(this.currentSocket(), protocol_1.TimeEvent.Ping);
+                const response = await this.connection.send(socket, protocol_1.TimeEvent.Ping);
                 const receivedAt = Date.now();
                 const rtt = receivedAt - sentAt;
                 if (typeof response?.now === 'number' && (!best || rtt < best.rtt)) {
@@ -487,8 +465,8 @@ class PartyGameClient {
         };
         /* A fresh room is opened over the connection we have, so the server
            holding the old one closes it; any other ask goes where its room is. */
-        if (!fresh) {
-            this.socketFor(code || null);
+        if (!fresh && !this.connection.connectedFor(code || null)) {
+            this.connection.connectFor(code || null);
         }
         for (let attempt = 0;; ++attempt) {
             if (!fresh && attempt > 0) {
@@ -498,7 +476,7 @@ class PartyGameClient {
             const response = await this.emit(protocol_1.HostEvent.Create, request);
             if (response?.ok) {
                 this.adopt(response);
-                await this.whenAttached('the room');
+                await this.connection.whenAttached('the room');
                 return this.session;
             }
             if (response?.reason === protocol_1.HostRefusal.Moved &&
@@ -506,11 +484,11 @@ class PartyGameClient {
                 attempt < maxRedirects) {
                 /* opened again on another server since we last knew it */
                 this.redirectCode = response.movedTo;
-                this.socketFor(response.movedTo);
+                this.connection.connectFor(response.movedTo);
                 continue;
             }
             if (response?.reason === protocol_1.HostRefusal.Draining &&
-                attempt < maxDrainingRetries) {
+                attempt < connection_1.maxDrainingRetries) {
                 /* asked a server on its way out: any other server will do */
                 this.logger.debug('PartyGames', 'server draining, asking another');
                 if (fresh) {
@@ -519,7 +497,9 @@ class PartyGameClient {
                 }
                 // A new connection even if this one had no room either: over the
                 // same socket the same draining server would answer again.
-                this.socketFor(null, { fresh: true });
+                this.connection.connectFor(null, {
+                    avoid: this.connection.avoidingRouted(),
+                });
                 continue;
             }
             throw new Error(response?.error || 'failed to open a party game room');
@@ -674,7 +654,9 @@ class PartyGameClient {
             this.lastHost) {
             const { gameType, genre, genreName } = this.lastHost;
             this.session = null;
-            this.socketFor(null, { fresh: true });
+            this.connection.connectFor(null, {
+                avoid: this.connection.avoidingRouted(),
+            });
             return (await this.host(gameType, genre, genreName, true)).players;
         }
         if (!response?.ok) {
@@ -729,13 +711,8 @@ class PartyGameClient {
         this.session = null;
         this.redirectCode = null;
         this.players = [];
-        if (this.socket) {
-            const socket = this.socket;
-            this.socket = null;
-            this.routedCode = null;
-            socket.close();
-        }
-        this.setAttached(true);
+        this.earlyFlags = null;
+        this.connection.close();
     }
 }
 exports.PartyGameClient = PartyGameClient;