@colyseus/core 0.16.0-preview.9 → 0.16.0

package/build/MatchMaker.js

@@ -17,6 +17,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
@@ -25,7 +29,6 @@ var MatchMaker_exports = {};
 __export(MatchMaker_exports, {
   MatchMakerState: () => MatchMakerState,
   accept: () => accept,
-  cleanupStaleRooms: () => cleanupStaleRooms,
   controller: () => import_controller.default,
   create: () => create,
   createRoom: () => createRoom,
@@ -34,6 +37,7 @@ __export(MatchMaker_exports, {
   driver: () => driver,
   findOneRoomAvailable: () => findOneRoomAvailable,
   getHandler: () => getHandler,
+  getLocalRoomById: () => getLocalRoomById,
   getRoomById: () => getRoomById,
   getRoomClass: () => getRoomClass,
   gracefullyShutdown: () => gracefullyShutdown,
@@ -41,7 +45,6 @@ __export(MatchMaker_exports, {
   hasHandler: () => hasHandler,
   healthCheckAllProcesses: () => healthCheckAllProcesses,
   healthCheckProcessId: () => healthCheckProcessId,
-  isGracefullyShuttingDown: () => isGracefullyShuttingDown,
   join: () => join,
   joinById: () => joinById,
   joinOrCreate: () => joinOrCreate,
@@ -55,34 +58,41 @@ __export(MatchMaker_exports, {
   removeRoomType: () => removeRoomType,
   reserveSeatFor: () => reserveSeatFor,
   selectProcessIdToCreateRoom: () => selectProcessIdToCreateRoom,
+  setHealthChecksEnabled: () => setHealthChecksEnabled,
   setup: () => setup,
   state: () => state,
   stats: () => stats
 });
 module.exports = __toCommonJS(MatchMaker_exports);
-var import_Protocol = require("./Protocol");
-var import_IPC = require("./IPC");
-var import_Utils = require("./utils/Utils");
-var import_DevMode = require("./utils/DevMode");
-var import_RegisteredHandler = require("./matchmaker/RegisteredHandler");
-var import_Room = require("./Room");
-var import_LocalPresence = require("./presence/LocalPresence");
-var import_Debug = require("./Debug");
-var import_SeatReservationError = require("./errors/SeatReservationError");
-var import_ServerError = require("./errors/ServerError");
-var import_driver = require("./matchmaker/driver");
-var import_controller = __toESM(require("./matchmaker/controller"));
-var stats = __toESM(require("./Stats"));
-var import_Logger = require("./Logger");
-var import_discovery = require("./discovery");
+var import_events = require("events");
+var import_Protocol = require("./Protocol.js");
+var import_IPC = require("./IPC.js");
+var import_Utils = require("./utils/Utils.js");
+var import_DevMode = require("./utils/DevMode.js");
+var import_RegisteredHandler = require("./matchmaker/RegisteredHandler.js");
+var import_Room = require("./Room.js");
+var import_LocalPresence = require("./presence/LocalPresence.js");
+var import_Debug = require("./Debug.js");
+var import_SeatReservationError = require("./errors/SeatReservationError.js");
+var import_ServerError = require("./errors/ServerError.js");
+var import_LocalDriver = require("./matchmaker/driver/local/LocalDriver.js");
+var import_controller = __toESM(require("./matchmaker/controller.js"));
+var stats = __toESM(require("./Stats.js"));
+var import_Logger = require("./Logger.js");
+var import_discovery = require("./discovery/index.js");
+var import_api = require("./matchmaker/driver/api.js");
 const handlers = {};
 const rooms = {};
+const events = new import_events.EventEmitter();
 let publicAddress;
 let processId;
 let presence;
 let driver;
 let selectProcessIdToCreateRoom;
-let isGracefullyShuttingDown;
+let enableHealthChecks = true;
+function setHealthChecksEnabled(value) {
+  enableHealthChecks = value;
+}
 let onReady = new import_Utils.Deferred();
 var MatchMakerState = /* @__PURE__ */ ((MatchMakerState2) => {
   MatchMakerState2[MatchMakerState2["INITIALIZING"] = 0] = "INITIALIZING";
@@ -95,10 +105,9 @@ async function setup(_presence, _driver, _publicAddress, _selectProcessIdToCreat
   if (onReady === void 0) {
     onReady = new import_Utils.Deferred();
   }
-  isGracefullyShuttingDown = false;
   state = 0 /* INITIALIZING */;
   presence = _presence || new import_LocalPresence.LocalPresence();
-  driver = _driver || new import_driver.LocalDriver();
+  driver = _driver || new import_LocalDriver.LocalDriver();
   publicAddress = _publicAddress;
   stats.reset(false);
   if (import_DevMode.isDevMode) {
@@ -121,25 +130,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 (import_DevMode.isDevMode) {
     await (0, import_DevMode.reloadFromCache)();
   }
 }
-async function joinOrCreate(roomName, clientOptions = {}, authOptions) {
+async function joinOrCreate(roomName, clientOptions = {}, authContext) {
   return await (0, import_Utils.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 = (0, import_api.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}`, import_Utils.MAX_CONCURRENT_CREATE_ROOM_WAIT_TIME * 2);
+        }
+        return room;
+      });
     }
     return await reserveSeatFor(room, clientOptions, authData);
   }, 5, [import_SeatReservationError.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);
 }
@@ -187,23 +215,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 = import_Utils.REMOTE_ROOM_SHORT_TIMEOUT) {
   const room = rooms[roomId];
@@ -225,23 +251,17 @@ async function remoteRoomCall(roomId, method, args, rejectionTimeout = import_Ut
   }
 }
 function defineRoomType(roomName, klass, defaultOptions) {
-  const registeredHandler = new import_RegisteredHandler.RegisteredHandler(klass, defaultOptions);
+  const registeredHandler = new import_RegisteredHandler.RegisteredHandler(roomName, klass, defaultOptions);
   handlers[roomName] = registeredHandler;
   if (klass.prototype["onAuth"] !== import_Room.Room.prototype["onAuth"]) {
     if (klass["onAuth"] !== import_Room.Room["onAuth"]) {
       import_Logger.logger.info(`\u274C "${roomName}"'s onAuth() defined at the instance level will be ignored.`);
     }
   }
-  if (!import_DevMode.isDevMode) {
-    cleanupStaleRooms(roomName);
-  }
   return registeredHandler;
 }
 function removeRoomType(roomName) {
   delete handlers[roomName];
-  if (!import_DevMode.isDevMode) {
-    cleanupStaleRooms(roomName);
-  }
 }
 function hasHandler(roomName) {
   import_Logger.logger.warn("hasHandler() is deprecated. Use getHandler() instead.");
@@ -276,7 +296,9 @@ async function createRoom(roomName, clientOptions) {
     } catch (e) {
       if (e.message === "ipc_timeout") {
         (0, import_Debug.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;
@@ -300,9 +322,7 @@ async function handleCreateRoom(roomName, clientOptions, restoringRoomId) {
   } else {
     room.roomId = (0, import_Utils.generateId)();
   }
-  if (room.state) {
-    room.setState(room.state);
-  }
+  room["__init"]();
   room.roomName = roomName;
   room.presence = presence;
   const additionalListingData = handler.getFilterOptions(clientOptions);
@@ -342,13 +362,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) {
@@ -357,24 +385,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 import_Utils.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;
+  (0, import_Debug.debugMatchMaking)(`${processId} is shutting down!`);
   state = 2 /* SHUTTING_DOWN */;
   onReady = void 0;
-  (0, import_Debug.debugMatchMaking)(`${processId} is shutting down!`);
+  await lockAndDisposeAll();
   if (import_DevMode.isDevMode) {
     await (0, import_DevMode.cacheRoomHistory)(rooms);
   }
-  await stats.excludeProcess(processId);
   await removeRoomsByProcessId(processId);
   presence.unsubscribe(getProcessChannel());
   return Promise.all(disconnectAll(
@@ -399,7 +445,7 @@ async function reserveSeatFor(room, options, authData) {
     );
   } catch (e) {
     (0, import_Debug.debugMatchMaking)(e);
-    if (e.message === "ipc_timeout" && !await healthCheckProcessId(room.processId)) {
+    if (e.message === "ipc_timeout" && !(enableHealthChecks && await healthCheckProcessId(room.processId))) {
       throw new import_SeatReservationError.SeatReservationError(`process ${room.processId} is not available.`);
     } else {
       successfulSeatReservation = false;
@@ -414,12 +460,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"] !== import_Room.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"] !== import_Room.Room["onAuth"] ? roomClass["onAuth"](authContext.token, clientOptions, authContext) : void 0;
 }
 async function healthCheckAllProcesses() {
   const allStats = await stats.fetchAll();
@@ -461,13 +504,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 });
-    import_Logger.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;
@@ -483,29 +520,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) {
-      (0, import_Debug.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
+      import_Utils.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) {
+      (0, import_Debug.debugMatchMaking)(
+        "receiving %d concurrent joinOrCreate for '%s' (%s)",
+        concurrency,
+        handler.name,
+        concurrencyKey
+      );
+      const result = await presence.brpop(
+        `l:${handler.name}:${concurrencyKey}`,
+        import_Utils.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) {
@@ -530,24 +580,24 @@ function onVisibilityChange(room, isInvisible) {
   handlers[room.roomName].emit("visibility-change", room, isInvisible);
 }
 async function disposeRoom(roomName, room) {
-  (0, import_Debug.debugMatchMaking)("disposing '%s' (%s) on processId '%s' (graceful shutdown: %s)", roomName, room.roomId, processId, isGracefullyShuttingDown);
-  if (!isGracefullyShuttingDown) {
-    stats.local.roomCount--;
+  (0, import_Debug.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 (import_DevMode.isDevMode) {
       await presence.hdel((0, import_DevMode.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}`;
@@ -556,7 +606,6 @@ function getProcessChannel(id = processId) {
 0 && (module.exports = {
   MatchMakerState,
   accept,
-  cleanupStaleRooms,
   controller,
   create,
   createRoom,
@@ -565,6 +614,7 @@ function getProcessChannel(id = processId) {
   driver,
   findOneRoomAvailable,
   getHandler,
+  getLocalRoomById,
   getRoomById,
   getRoomClass,
   gracefullyShutdown,
@@ -572,7 +622,6 @@ function getProcessChannel(id = processId) {
   hasHandler,
   healthCheckAllProcesses,
   healthCheckProcessId,
-  isGracefullyShuttingDown,
   join,
   joinById,
   joinOrCreate,
@@ -586,6 +635,7 @@ function getProcessChannel(id = processId) {
   removeRoomType,
   reserveSeatFor,
   selectProcessIdToCreateRoom,
+  setHealthChecksEnabled,
   setup,
   state,
   stats