@colyseus/core 0.16.0-preview.9 → 0.16.1

package/build/MatchMaker.mjs

@@ -1,39 +1,45 @@
-import { ErrorCode, Protocol } from "./Protocol";
-import { requestFromIPC, subscribeIPC } from "./IPC";
-import { Deferred, generateId, merge, REMOTE_ROOM_SHORT_TIMEOUT, retry } from "./utils/Utils";
-import { isDevMode, cacheRoomHistory, getPreviousProcessId, getRoomRestoreListKey, reloadFromCache } from "./utils/DevMode";
-import { RegisteredHandler } from "./matchmaker/RegisteredHandler";
-import { Room, RoomInternalState } from "./Room";
-import { LocalPresence } from "./presence/LocalPresence";
-import { debugAndPrintError, debugMatchMaking } from "./Debug";
-import { SeatReservationError } from "./errors/SeatReservationError";
-import { ServerError } from "./errors/ServerError";
-import { LocalDriver } from "./matchmaker/driver";
-import controller from "./matchmaker/controller";
-import * as stats from "./Stats";
-import { logger } from "./Logger";
-import { getHostname } from "./discovery";
-const handlers = {};
-const rooms = {};
-let publicAddress;
-let processId;
-let presence;
-let driver;
-let selectProcessIdToCreateRoom;
-let isGracefullyShuttingDown;
-let onReady = new Deferred();
+// packages/core/src/MatchMaker.ts
+import { EventEmitter } from "events";
+import { ErrorCode, Protocol } from "./Protocol.mjs";
+import { requestFromIPC, subscribeIPC } from "./IPC.mjs";
+import { Deferred, generateId, merge, retry, MAX_CONCURRENT_CREATE_ROOM_WAIT_TIME, REMOTE_ROOM_SHORT_TIMEOUT } from "./utils/Utils.mjs";
+import { isDevMode, cacheRoomHistory, getPreviousProcessId, getRoomRestoreListKey, reloadFromCache } from "./utils/DevMode.mjs";
+import { RegisteredHandler } from "./matchmaker/RegisteredHandler.mjs";
+import { Room, RoomInternalState } from "./Room.mjs";
+import { LocalPresence } from "./presence/LocalPresence.mjs";
+import { debugAndPrintError, debugMatchMaking } from "./Debug.mjs";
+import { SeatReservationError } from "./errors/SeatReservationError.mjs";
+import { ServerError } from "./errors/ServerError.mjs";
+import { LocalDriver } from "./matchmaker/driver/local/LocalDriver.mjs";
+import controller from "./matchmaker/controller.mjs";
+import * as stats from "./Stats.mjs";
+import { logger } from "./Logger.mjs";
+import { getHostname } from "./discovery/index.mjs";
+import { getLockId } from "./matchmaker/driver/api.mjs";
+var handlers = {};
+var rooms = {};
+var events = new EventEmitter();
+var publicAddress;
+var processId;
+var presence;
+var driver;
+var selectProcessIdToCreateRoom;
+var enableHealthChecks = true;
+function setHealthChecksEnabled(value) {
+  enableHealthChecks = value;
+}
+var onReady = new Deferred();
 var MatchMakerState = /* @__PURE__ */ ((MatchMakerState2) => {
   MatchMakerState2[MatchMakerState2["INITIALIZING"] = 0] = "INITIALIZING";
   MatchMakerState2[MatchMakerState2["READY"] = 1] = "READY";
   MatchMakerState2[MatchMakerState2["SHUTTING_DOWN"] = 2] = "SHUTTING_DOWN";
   return MatchMakerState2;
 })(MatchMakerState || {});
-let state;
+var state;
 async function setup(_presence, _driver, _publicAddress, _selectProcessIdToCreateRoom) {
   if (onReady === void 0) {
     onReady = new Deferred();
   }
-  isGracefullyShuttingDown = false;
   state = 0 /* INITIALIZING */;
   presence = _presence || new LocalPresence();
   driver = _driver || new LocalDriver();
@@ -59,25 +65,44 @@ async function accept() {
       return handleCreateRoom.apply(void 0, args);
     }
   });
-  await healthCheckAllProcesses();
+  if (enableHealthChecks) {
+    await healthCheckAllProcesses();
+    stats.setAutoPersistInterval();
+  }
   state = 1 /* READY */;
   await stats.persist();
   if (isDevMode) {
     await reloadFromCache();
   }
 }
-async function joinOrCreate(roomName, clientOptions = {}, authOptions) {
+async function joinOrCreate(roomName, clientOptions = {}, authContext) {
   return await retry(async () => {
-    const authData = await callOnAuth(roomName, authOptions);
+    const authData = await callOnAuth(roomName, clientOptions, authContext);
     let room = await findOneRoomAvailable(roomName, clientOptions);
     if (!room) {
-      room = await createRoom(roomName, clientOptions);
+      const handler = getHandler(roomName);
+      const filterOptions = handler.getFilterOptions(clientOptions);
+      const concurrencyKey = getLockId(filterOptions);
+      await concurrentJoinOrCreateRoomLock(handler, concurrencyKey, async (roomId) => {
+        if (roomId) {
+          room = await driver.findOne({ roomId });
+        }
+        if (!room) {
+          room = await findOneRoomAvailable(roomName, clientOptions);
+        }
+        if (!room) {
+          room = await createRoom(roomName, clientOptions);
+          presence.lpush(`l:${handler.name}:${concurrencyKey}`, room.roomId);
+          presence.expire(`l:${handler.name}:${concurrencyKey}`, MAX_CONCURRENT_CREATE_ROOM_WAIT_TIME * 2);
+        }
+        return room;
+      });
     }
     return await reserveSeatFor(room, clientOptions, authData);
   }, 5, [SeatReservationError]);
 }
-async function create(roomName, clientOptions = {}, authOptions) {
-  const authData = await callOnAuth(roomName, authOptions);
+async function create(roomName, clientOptions = {}, authContext) {
+  const authData = await callOnAuth(roomName, clientOptions, authContext);
   const room = await createRoom(roomName, clientOptions);
   return reserveSeatFor(room, clientOptions, authData);
 }
@@ -125,23 +150,21 @@ async function joinById(roomId, clientOptions = {}, authOptions) {
   const authData = await callOnAuth(room.name, authOptions);
   return reserveSeatFor(room, clientOptions, authData);
 }
-async function query(conditions = {}) {
-  return await driver.find(conditions);
-}
-async function findOneRoomAvailable(roomName, clientOptions) {
-  return await awaitRoomAvailable(roomName, async () => {
-    const handler = getHandler(roomName);
-    const roomQuery = driver.findOne({
-      locked: false,
-      name: roomName,
-      private: false,
-      ...handler.getFilterOptions(clientOptions)
-    });
-    if (handler.sortOptions) {
-      roomQuery.sort(handler.sortOptions);
-    }
-    return await roomQuery;
-  });
+async function query(conditions = {}, sortOptions) {
+  return await driver.query(conditions, sortOptions);
+}
+async function findOneRoomAvailable(roomName, filterOptions, additionalSortOptions) {
+  const handler = getHandler(roomName);
+  const sortOptions = Object.assign({}, handler.sortOptions ?? {});
+  if (additionalSortOptions) {
+    Object.assign(sortOptions, additionalSortOptions);
+  }
+  return await driver.findOne({
+    locked: false,
+    name: roomName,
+    private: false,
+    ...handler.getFilterOptions(filterOptions)
+  }, sortOptions);
 }
 async function remoteRoomCall(roomId, method, args, rejectionTimeout = REMOTE_ROOM_SHORT_TIMEOUT) {
   const room = rooms[roomId];
@@ -163,23 +186,17 @@ async function remoteRoomCall(roomId, method, args, rejectionTimeout = REMOTE_RO
   }
 }
 function defineRoomType(roomName, klass, defaultOptions) {
-  const registeredHandler = new RegisteredHandler(klass, defaultOptions);
+  const registeredHandler = new RegisteredHandler(roomName, klass, defaultOptions);
   handlers[roomName] = registeredHandler;
   if (klass.prototype["onAuth"] !== Room.prototype["onAuth"]) {
     if (klass["onAuth"] !== Room["onAuth"]) {
       logger.info(`\u274C "${roomName}"'s onAuth() defined at the instance level will be ignored.`);
     }
   }
-  if (!isDevMode) {
-    cleanupStaleRooms(roomName);
-  }
   return registeredHandler;
 }
 function removeRoomType(roomName) {
   delete handlers[roomName];
-  if (!isDevMode) {
-    cleanupStaleRooms(roomName);
-  }
 }
 function hasHandler(roomName) {
   logger.warn("hasHandler() is deprecated. Use getHandler() instead.");
@@ -214,7 +231,9 @@ async function createRoom(roomName, clientOptions) {
     } catch (e) {
       if (e.message === "ipc_timeout") {
         debugAndPrintError(`${e.message}: create room request timed out for ${roomName} on processId ${selectedProcessId}.`);
-        await stats.excludeProcess(selectedProcessId);
+        if (enableHealthChecks) {
+          await stats.excludeProcess(selectedProcessId);
+        }
         room = await handleCreateRoom(roomName, clientOptions);
       } else {
         throw e;
@@ -238,9 +257,7 @@ async function handleCreateRoom(roomName, clientOptions, restoringRoomId) {
   } else {
     room.roomId = generateId();
   }
-  if (room.state) {
-    room.setState(room.state);
-  }
+  room["__init"]();
   room.roomName = roomName;
   room.presence = presence;
   const additionalListingData = handler.getFilterOptions(clientOptions);
@@ -280,13 +297,21 @@ async function handleCreateRoom(roomName, clientOptions, restoringRoomId) {
     room._events.removeAllListeners("unlock");
     room._events.removeAllListeners("visibility-change");
     room._events.removeAllListeners("dispose");
+    if (stats.local.roomCount <= 0) {
+      events.emit("no-active-rooms");
+    }
   });
   await createRoomReferences(room, true);
-  await room.listing.save();
+  if (state !== 2 /* SHUTTING_DOWN */) {
+    await room.listing.save();
+  }
   handler.emit("create", room);
   return room.listing;
 }
 function getRoomById(roomId) {
+  return driver.findOne({ roomId });
+}
+function getLocalRoomById(roomId) {
   return rooms[roomId];
 }
 function disconnectAll(closeCode) {
@@ -295,24 +320,42 @@ function disconnectAll(closeCode) {
     if (!rooms.hasOwnProperty(roomId)) {
       continue;
     }
-    const room = rooms[roomId];
-    room._events.removeAllListeners("leave");
-    promises.push(room.disconnect(closeCode));
+    promises.push(rooms[roomId].disconnect(closeCode));
   }
   return promises;
 }
+async function lockAndDisposeAll() {
+  await stats.excludeProcess(processId);
+  if (enableHealthChecks) {
+    stats.clearAutoPersistInterval();
+  }
+  const noActiveRooms = new Deferred();
+  if (stats.local.roomCount <= 0) {
+    noActiveRooms.resolve();
+  } else {
+    events.once("no-active-rooms", () => noActiveRooms.resolve());
+  }
+  for (const roomId in rooms) {
+    if (!rooms.hasOwnProperty(roomId)) {
+      continue;
+    }
+    const room = rooms[roomId];
+    room.lock();
+    room.onBeforeShutdown();
+  }
+  await noActiveRooms;
+}
 async function gracefullyShutdown() {
-  if (isGracefullyShuttingDown) {
+  if (state === 2 /* SHUTTING_DOWN */) {
     return Promise.reject("already_shutting_down");
   }
-  isGracefullyShuttingDown = true;
+  debugMatchMaking(`${processId} is shutting down!`);
   state = 2 /* SHUTTING_DOWN */;
   onReady = void 0;
-  debugMatchMaking(`${processId} is shutting down!`);
+  await lockAndDisposeAll();
   if (isDevMode) {
     await cacheRoomHistory(rooms);
   }
-  await stats.excludeProcess(processId);
   await removeRoomsByProcessId(processId);
   presence.unsubscribe(getProcessChannel());
   return Promise.all(disconnectAll(
@@ -337,7 +380,7 @@ async function reserveSeatFor(room, options, authData) {
     );
   } catch (e) {
     debugMatchMaking(e);
-    if (e.message === "ipc_timeout" && !await healthCheckProcessId(room.processId)) {
+    if (e.message === "ipc_timeout" && !(enableHealthChecks && await healthCheckProcessId(room.processId))) {
       throw new SeatReservationError(`process ${room.processId} is not available.`);
     } else {
       successfulSeatReservation = false;
@@ -352,12 +395,9 @@ async function reserveSeatFor(room, options, authData) {
   }
   return response;
 }
-function callOnAuth(roomName, authOptions) {
+function callOnAuth(roomName, clientOptions, authContext) {
   const roomClass = getRoomClass(roomName);
-  return roomClass && roomClass["onAuth"] && roomClass["onAuth"] !== Room["onAuth"] ? roomClass["onAuth"](authOptions.token, authOptions.request) : void 0;
-}
-async function cleanupStaleRooms(roomName) {
-  await presence.del(getHandlerConcurrencyKey(roomName));
+  return roomClass && roomClass["onAuth"] && roomClass["onAuth"] !== Room["onAuth"] ? roomClass["onAuth"](authContext.token, clientOptions, authContext) : void 0;
 }
 async function healthCheckAllProcesses() {
   const allStats = await stats.fetchAll();
@@ -367,7 +407,7 @@ async function healthCheckAllProcesses() {
     );
   }
 }
-const _healthCheckByProcessId = {};
+var _healthCheckByProcessId = {};
 function healthCheckProcessId(processId2) {
   if (_healthCheckByProcessId[processId2] !== void 0) {
     return _healthCheckByProcessId[processId2];
@@ -399,13 +439,7 @@ function healthCheckProcessId(processId2) {
   return _healthCheckByProcessId[processId2];
 }
 async function removeRoomsByProcessId(processId2) {
-  if (typeof driver.cleanup === "function") {
-    await driver.cleanup(processId2);
-  } else {
-    const cachedRooms = await driver.find({ processId: processId2 }, { _id: 1 });
-    logger.debug("> Removing stale rooms by processId:", processId2, `(${cachedRooms.length} rooms found)`);
-    cachedRooms.forEach((room) => room.remove());
-  }
+  await driver.cleanup(processId2);
 }
 async function createRoomReferences(room, init = false) {
   rooms[room.roomId] = room;
@@ -421,29 +455,42 @@ async function createRoomReferences(room, init = false) {
   }
   return true;
 }
-async function awaitRoomAvailable(roomToJoin, callback) {
+async function concurrentJoinOrCreateRoomLock(handler, concurrencyKey, callback) {
   return new Promise(async (resolve, reject) => {
-    const concurrencyKey = getHandlerConcurrencyKey(roomToJoin);
-    const concurrency = await presence.incr(concurrencyKey) - 1;
-    const concurrencyTimeout = Math.min(concurrency * 100, 500);
-    if (concurrency > 0) {
-      debugMatchMaking(
-        "receiving %d concurrent requests for joining '%s' (waiting %d ms)",
-        concurrency,
-        roomToJoin,
-        concurrencyTimeout
-      );
-    }
-    setTimeout(async () => {
+    const hkey = getConcurrencyHashKey(handler.name);
+    const concurrency = await presence.hincrbyex(
+      hkey,
+      concurrencyKey,
+      1,
+      // increment by 1
+      MAX_CONCURRENT_CREATE_ROOM_WAIT_TIME * 2
+      // expire in 2x the time of MAX_CONCURRENT_CREATE_ROOM_WAIT_TIME
+    ) - 1;
+    const fulfill = async (roomId) => {
       try {
-        const result = await callback();
-        resolve(result);
+        resolve(await callback(roomId));
       } catch (e) {
         reject(e);
       } finally {
-        await presence.decr(concurrencyKey);
+        await presence.hincrby(hkey, concurrencyKey, -1);
       }
-    }, concurrencyTimeout);
+    };
+    if (concurrency > 0) {
+      debugMatchMaking(
+        "receiving %d concurrent joinOrCreate for '%s' (%s)",
+        concurrency,
+        handler.name,
+        concurrencyKey
+      );
+      const result = await presence.brpop(
+        `l:${handler.name}:${concurrencyKey}`,
+        MAX_CONCURRENT_CREATE_ROOM_WAIT_TIME + Math.min(concurrency, 3) * 0.2
+        // add extra milliseconds for each concurrent request
+      );
+      return await fulfill(result && result[1]);
+    } else {
+      return await fulfill();
+    }
   });
 }
 function onClientJoinRoom(room, client) {
@@ -468,24 +515,24 @@ function onVisibilityChange(room, isInvisible) {
   handlers[room.roomName].emit("visibility-change", room, isInvisible);
 }
 async function disposeRoom(roomName, room) {
-  debugMatchMaking("disposing '%s' (%s) on processId '%s' (graceful shutdown: %s)", roomName, room.roomId, processId, isGracefullyShuttingDown);
-  if (!isGracefullyShuttingDown) {
-    stats.local.roomCount--;
+  debugMatchMaking("disposing '%s' (%s) on processId '%s' (graceful shutdown: %s)", roomName, room.roomId, processId, state === 2 /* SHUTTING_DOWN */);
+  room.listing.remove();
+  stats.local.roomCount--;
+  if (state !== 2 /* SHUTTING_DOWN */) {
     stats.persist();
     if (isDevMode) {
       await presence.hdel(getRoomRestoreListKey(), room.roomId);
     }
   }
   handlers[roomName].emit("dispose", room);
-  presence.del(getHandlerConcurrencyKey(roomName));
   presence.unsubscribe(getRoomChannel(room.roomId));
   delete rooms[room.roomId];
 }
 function getRoomChannel(roomId) {
   return `$${roomId}`;
 }
-function getHandlerConcurrencyKey(name) {
-  return `c:${name}`;
+function getConcurrencyHashKey(roomName) {
+  return `ch:${roomName}`;
 }
 function getProcessChannel(id = processId) {
   return `p:${id}`;
@@ -493,7 +540,6 @@ function getProcessChannel(id = processId) {
 export {
   MatchMakerState,
   accept,
-  cleanupStaleRooms,
   controller,
   create,
   createRoom,
@@ -502,6 +548,7 @@ export {
   driver,
   findOneRoomAvailable,
   getHandler,
+  getLocalRoomById,
   getRoomById,
   getRoomClass,
   gracefullyShutdown,
@@ -509,7 +556,6 @@ export {
   hasHandler,
   healthCheckAllProcesses,
   healthCheckProcessId,
-  isGracefullyShuttingDown,
   join,
   joinById,
   joinOrCreate,
@@ -523,6 +569,7 @@ export {
   removeRoomType,
   reserveSeatFor,
   selectProcessIdToCreateRoom,
+  setHealthChecksEnabled,
   setup,
   state,
   stats