@colyseus/core 0.16.0-preview.20 → 0.16.0-preview.27

package/build/MatchMaker.d.ts

@@ -2,7 +2,7 @@ import { Deferred } from './utils/Utils';
 import { RegisteredHandler } from './matchmaker/RegisteredHandler';
 import { Room } from './Room';
 import { Presence } from './presence/Presence';
-import { IRoomListingData, RoomListingData, MatchMakerDriver } from './matchmaker/driver';
+import { IRoomCache, MatchMakerDriver, SortOptions } from './matchmaker/driver/local/LocalDriver';
 import controller from './matchmaker/controller';
 import * as stats from "./Stats";
 import { Type } from './utils/types';
@@ -15,7 +15,7 @@ export type AuthOptions = {
 export type SelectProcessIdCallback = (roomName: string, clientOptions: ClientOptions) => Promise<string>;
 export interface SeatReservation {
     sessionId: string;
-    room: RoomListingData;
+    room: IRoomCache;
     devMode?: boolean;
 }
 export declare let publicAddress: string;
@@ -23,7 +23,7 @@ export declare let processId: string;
 export declare let presence: Presence;
 export declare let driver: MatchMakerDriver;
 export declare let selectProcessIdToCreateRoom: SelectProcessIdCallback;
-export declare let isGracefullyShuttingDown: boolean;
+export declare function setHealthChecksEnabled(value: boolean): void;
 export declare let onReady: Deferred;
 export declare enum MatchMakerState {
     INITIALIZING = 0,
@@ -60,7 +60,7 @@ export declare function join(roomName: string, clientOptions?: ClientOptions, au
  * Join a room by id and return seat reservation
  */
 export declare function reconnect(roomId: string, clientOptions?: ClientOptions): Promise<{
-    room: RoomListingData<any>;
+    room: import("./matchmaker/driver/api").RoomCache<any>;
     sessionId: any;
 }>;
 /**
@@ -70,22 +70,23 @@ export declare function reconnect(roomId: string, clientOptions?: ClientOptions)
  * @param clientOptions - Options for the client seat reservation (for `onJoin`/`onAuth`)
  * @param authOptions - Optional authentication token
  *
- * @returns Promise<SeatReservation> - A promise which contains `sessionId` and `RoomListingData`.
+ * @returns Promise<SeatReservation> - A promise which contains `sessionId` and `IRoomCache`.
  */
 export declare function joinById(roomId: string, clientOptions?: ClientOptions, authOptions?: AuthOptions): Promise<SeatReservation>;
 /**
  * Perform a query for all cached rooms
  */
-export declare function query(conditions?: Partial<IRoomListingData>): Promise<RoomListingData<any>[]>;
+export declare function query(conditions?: Partial<IRoomCache>, sortOptions?: SortOptions): Promise<IRoomCache[]>;
 /**
  * Find for a public and unlocked room available.
  *
  * @param roomName - The Id of the specific room.
- * @param clientOptions - Options for the client seat reservation (for `onJoin`/`onAuth`).
+ * @param filterOptions - Filter options.
+ * @param sortOptions - Sorting options.
  *
- * @returns Promise<RoomListingData> - A promise contaning an object which includes room metadata and configurations.
+ * @returns Promise<IRoomCache> - A promise contaning an object which includes room metadata and configurations.
  */
-export declare function findOneRoomAvailable(roomName: string, clientOptions: ClientOptions): Promise<RoomListingData>;
+export declare function findOneRoomAvailable(roomName: string, filterOptions: ClientOptions, additionalSortOptions?: SortOptions): Promise<import("./matchmaker/driver/api").RoomCache<any>>;
 /**
  * Call a method or return a property on a remote room.
  *
@@ -107,11 +108,19 @@ export declare function getRoomClass(roomName: string): Type<Room>;
  * @param roomName - The identifier you defined on `gameServer.define()`
  * @param clientOptions - Options for `onCreate`
  *
- * @returns Promise<RoomListingData> - A promise contaning an object which includes room metadata and configurations.
+ * @returns Promise<IRoomCache> - A promise contaning an object which includes room metadata and configurations.
  */
-export declare function createRoom(roomName: string, clientOptions: ClientOptions): Promise<RoomListingData>;
-export declare function handleCreateRoom(roomName: string, clientOptions: ClientOptions, restoringRoomId?: string): Promise<RoomListingData>;
-export declare function getRoomById(roomId: string): Room<any, any, any, any>;
+export declare function createRoom(roomName: string, clientOptions: ClientOptions): Promise<IRoomCache>;
+export declare function handleCreateRoom(roomName: string, clientOptions: ClientOptions, restoringRoomId?: string): Promise<IRoomCache>;
+/**
+ * Get room data by roomId.
+ * This method does not return the actual room instance, use `getLocalRoomById` for that.
+ */
+export declare function getRoomById(roomId: string): Promise<import("./matchmaker/driver/api").RoomCache<any>>;
+/**
+ * Get local room instance by roomId. (Can return "undefined" if the room is not available on this process)
+ */
+export declare function getLocalRoomById(roomId: string): Room<any, any, any, any>;
 /**
  * Disconnects every client on every room in the current process.
  */
@@ -120,8 +129,7 @@ export declare function gracefullyShutdown(): Promise<any>;
 /**
  * Reserve a seat for a client in a room
  */
-export declare function reserveSeatFor(room: RoomListingData, options: ClientOptions, authData?: any): Promise<SeatReservation>;
-export declare function cleanupStaleRooms(roomName: string): Promise<void>;
+export declare function reserveSeatFor(room: IRoomCache, options: ClientOptions, authData?: any): Promise<SeatReservation>;
 /**
  * Perform health check on all processes
  */

package/build/MatchMaker.js

@@ -25,7 +25,6 @@ var MatchMaker_exports = {};
 __export(MatchMaker_exports, {
   MatchMakerState: () => MatchMakerState,
   accept: () => accept,
-  cleanupStaleRooms: () => cleanupStaleRooms,
   controller: () => import_controller.default,
   create: () => create,
   createRoom: () => createRoom,
@@ -34,6 +33,7 @@ __export(MatchMaker_exports, {
   driver: () => driver,
   findOneRoomAvailable: () => findOneRoomAvailable,
   getHandler: () => getHandler,
+  getLocalRoomById: () => getLocalRoomById,
   getRoomById: () => getRoomById,
   getRoomClass: () => getRoomClass,
   gracefullyShutdown: () => gracefullyShutdown,
@@ -41,7 +41,6 @@ __export(MatchMaker_exports, {
   hasHandler: () => hasHandler,
   healthCheckAllProcesses: () => healthCheckAllProcesses,
   healthCheckProcessId: () => healthCheckProcessId,
-  isGracefullyShuttingDown: () => isGracefullyShuttingDown,
   join: () => join,
   joinById: () => joinById,
   joinOrCreate: () => joinOrCreate,
@@ -55,6 +54,7 @@ __export(MatchMaker_exports, {
   removeRoomType: () => removeRoomType,
   reserveSeatFor: () => reserveSeatFor,
   selectProcessIdToCreateRoom: () => selectProcessIdToCreateRoom,
+  setHealthChecksEnabled: () => setHealthChecksEnabled,
   setup: () => setup,
   state: () => state,
   stats: () => stats
@@ -70,11 +70,12 @@ 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_LocalDriver = require("./matchmaker/driver/local/LocalDriver");
 var import_controller = __toESM(require("./matchmaker/controller"));
 var stats = __toESM(require("./Stats"));
 var import_Logger = require("./Logger");
 var import_discovery = require("./discovery");
+var import_api = require("./matchmaker/driver/api");
 const handlers = {};
 const rooms = {};
 let publicAddress;
@@ -82,7 +83,10 @@ 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 +99,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,7 +124,9 @@ async function accept() {
       return handleCreateRoom.apply(void 0, args);
     }
   });
-  await healthCheckAllProcesses();
+  if (enableHealthChecks) {
+    await healthCheckAllProcesses();
+  }
   state = 1 /* READY */;
   await stats.persist();
   if (import_DevMode.isDevMode) {
@@ -133,7 +138,23 @@ async function joinOrCreate(roomName, clientOptions = {}, authOptions) {
     const authData = await callOnAuth(roomName, authOptions);
     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]);
@@ -187,23 +208,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 +244,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 +289,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 +315,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);
@@ -349,6 +362,9 @@ async function handleCreateRoom(roomName, clientOptions, restoringRoomId) {
   return room.listing;
 }
 function getRoomById(roomId) {
+  return driver.findOne({ roomId });
+}
+function getLocalRoomById(roomId) {
   return rooms[roomId];
 }
 function disconnectAll(closeCode) {
@@ -364,10 +380,9 @@ function disconnectAll(closeCode) {
   return promises;
 }
 async function gracefullyShutdown() {
-  if (isGracefullyShuttingDown) {
+  if (state === 2 /* SHUTTING_DOWN */) {
     return Promise.reject("already_shutting_down");
   }
-  isGracefullyShuttingDown = true;
   state = 2 /* SHUTTING_DOWN */;
   onReady = void 0;
   (0, import_Debug.debugMatchMaking)(`${processId} is shutting down!`);
@@ -399,7 +414,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;
@@ -418,9 +433,6 @@ function callOnAuth(roomName, authOptions) {
   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));
-}
 async function healthCheckAllProcesses() {
   const allStats = await stats.fetchAll();
   if (allStats.length > 0) {
@@ -461,13 +473,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 +489,39 @@ 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,
+      import_Utils.MAX_CONCURRENT_CREATE_ROOM_WAIT_TIME * 2
+    ) - 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
+      );
+      return await fulfill(result && result[1]);
+    } else {
+      return await fulfill();
+    }
   });
 }
 function onClientJoinRoom(room, client) {
@@ -530,8 +546,9 @@ 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) {
+  (0, import_Debug.debugMatchMaking)("disposing '%s' (%s) on processId '%s' (graceful shutdown: %s)", roomName, room.roomId, processId, state === 2 /* SHUTTING_DOWN */);
+  room.listing.remove();
+  if (state !== 2 /* SHUTTING_DOWN */) {
     stats.local.roomCount--;
     stats.persist();
     if (import_DevMode.isDevMode) {
@@ -539,15 +556,14 @@ async function disposeRoom(roomName, room) {
     }
   }
   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 +572,6 @@ function getProcessChannel(id = processId) {
 0 && (module.exports = {
   MatchMakerState,
   accept,
-  cleanupStaleRooms,
   controller,
   create,
   createRoom,
@@ -565,6 +580,7 @@ function getProcessChannel(id = processId) {
   driver,
   findOneRoomAvailable,
   getHandler,
+  getLocalRoomById,
   getRoomById,
   getRoomClass,
   gracefullyShutdown,
@@ -572,7 +588,6 @@ function getProcessChannel(id = processId) {
   hasHandler,
   healthCheckAllProcesses,
   healthCheckProcessId,
-  isGracefullyShuttingDown,
   join,
   joinById,
   joinOrCreate,
@@ -586,6 +601,7 @@ function getProcessChannel(id = processId) {
   removeRoomType,
   reserveSeatFor,
   selectProcessIdToCreateRoom,
+  setHealthChecksEnabled,
   setup,
   state,
   stats