280 lines
7.4 KiB
TypeScript
280 lines
7.4 KiB
TypeScript
|
import { EventEmitter } from "events"
|
||
|
|
||
|
export type SocketId = string
|
||
|
export type Room = string
|
||
|
|
||
|
export interface BroadcastFlags {
|
||
|
volatile?: boolean
|
||
|
compress?: boolean
|
||
|
local?: boolean
|
||
|
broadcast?: boolean
|
||
|
binary?: boolean
|
||
|
}
|
||
|
|
||
|
export interface BroadcastOptions {
|
||
|
rooms: Set<Room>
|
||
|
except?: Set<SocketId>
|
||
|
flags?: BroadcastFlags
|
||
|
}
|
||
|
|
||
|
export class Adapter extends EventEmitter {
|
||
|
public rooms: Map<Room, Set<SocketId>> = new Map();
|
||
|
public sids: Map<SocketId, Set<Room>> = new Map();
|
||
|
private readonly encoder
|
||
|
|
||
|
/**
|
||
|
* In-memory adapter constructor.
|
||
|
*
|
||
|
* @param {Namespace} nsp
|
||
|
*/
|
||
|
constructor(readonly nsp: any) {
|
||
|
super()
|
||
|
this.encoder = nsp.server.encoder
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* To be overridden
|
||
|
*/
|
||
|
public init(): Promise<void> | void { }
|
||
|
|
||
|
/**
|
||
|
* To be overridden
|
||
|
*/
|
||
|
public close(): Promise<void> | void { }
|
||
|
|
||
|
/**
|
||
|
* Adds a socket to a list of room.
|
||
|
*
|
||
|
* @param {SocketId} id the socket id
|
||
|
* @param {Set<Room>} rooms a set of rooms
|
||
|
* @public
|
||
|
*/
|
||
|
public addAll(id: SocketId, rooms: Set<Room>): Promise<void> | void {
|
||
|
if (!this.sids.has(id)) {
|
||
|
this.sids.set(id, new Set())
|
||
|
}
|
||
|
|
||
|
for (const room of rooms) {
|
||
|
this.sids.get(id).add(room)
|
||
|
|
||
|
if (!this.rooms.has(room)) {
|
||
|
this.rooms.set(room, new Set())
|
||
|
this.emit("create-room", room)
|
||
|
}
|
||
|
if (!this.rooms.get(room).has(id)) {
|
||
|
this.rooms.get(room).add(id)
|
||
|
this.emit("join-room", room, id)
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Removes a socket from a room.
|
||
|
*
|
||
|
* @param {SocketId} id the socket id
|
||
|
* @param {Room} room the room name
|
||
|
*/
|
||
|
public del(id: SocketId, room: Room): Promise<void> | void {
|
||
|
if (this.sids.has(id)) {
|
||
|
this.sids.get(id).delete(room)
|
||
|
}
|
||
|
|
||
|
this._del(room, id)
|
||
|
}
|
||
|
|
||
|
private _del(room, id) {
|
||
|
if (this.rooms.has(room)) {
|
||
|
const deleted = this.rooms.get(room).delete(id)
|
||
|
if (deleted) {
|
||
|
this.emit("leave-room", room, id)
|
||
|
}
|
||
|
if (this.rooms.get(room).size === 0) {
|
||
|
this.rooms.delete(room)
|
||
|
this.emit("delete-room", room)
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Removes a socket from all rooms it's joined.
|
||
|
*
|
||
|
* @param {SocketId} id the socket id
|
||
|
*/
|
||
|
public delAll(id: SocketId): void {
|
||
|
if (!this.sids.has(id)) {
|
||
|
return
|
||
|
}
|
||
|
|
||
|
for (const room of this.sids.get(id)) {
|
||
|
this._del(room, id)
|
||
|
}
|
||
|
|
||
|
this.sids.delete(id)
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Broadcasts a packet.
|
||
|
*
|
||
|
* Options:
|
||
|
* - `flags` {Object} flags for this packet
|
||
|
* - `except` {Array} sids that should be excluded
|
||
|
* - `rooms` {Array} list of rooms to broadcast to
|
||
|
*
|
||
|
* @param {Object} packet the packet object
|
||
|
* @param {Object} opts the options
|
||
|
* @public
|
||
|
*/
|
||
|
public broadcast(packet: any, opts: BroadcastOptions): void {
|
||
|
const flags = opts.flags || {}
|
||
|
const basePacketOpts = {
|
||
|
preEncoded: true,
|
||
|
volatile: flags.volatile,
|
||
|
compress: flags.compress
|
||
|
}
|
||
|
|
||
|
packet.nsp = this.nsp.name
|
||
|
const encodedPackets = this.encoder.encode(packet)
|
||
|
|
||
|
const packetOpts = encodedPackets.map(encodedPacket => {
|
||
|
if (typeof encodedPacket === "string") {
|
||
|
return {
|
||
|
...basePacketOpts,
|
||
|
wsPreEncoded: "4" + encodedPacket // "4" being the "message" packet type in Engine.IO
|
||
|
}
|
||
|
} else {
|
||
|
return basePacketOpts
|
||
|
}
|
||
|
})
|
||
|
|
||
|
this.apply(opts, socket => {
|
||
|
for (let i = 0; i < encodedPackets.length; i++) {
|
||
|
socket.client.writeToEngine(encodedPackets[i], packetOpts[i])
|
||
|
}
|
||
|
})
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Gets a list of sockets by sid.
|
||
|
*
|
||
|
* @param {Set<Room>} rooms the explicit set of rooms to check.
|
||
|
*/
|
||
|
public sockets(rooms: Set<Room>): Promise<Set<SocketId>> {
|
||
|
const sids = new Set<SocketId>()
|
||
|
|
||
|
this.apply({ rooms }, socket => {
|
||
|
sids.add(socket.id)
|
||
|
})
|
||
|
|
||
|
return Promise.resolve(sids)
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Gets the list of rooms a given socket has joined.
|
||
|
*
|
||
|
* @param {SocketId} id the socket id
|
||
|
*/
|
||
|
public socketRooms(id: SocketId): Set<Room> | undefined {
|
||
|
return this.sids.get(id)
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Returns the matching socket instances
|
||
|
*
|
||
|
* @param opts - the filters to apply
|
||
|
*/
|
||
|
public fetchSockets(opts: BroadcastOptions): Promise<any[]> {
|
||
|
const sockets = []
|
||
|
|
||
|
this.apply(opts, socket => {
|
||
|
sockets.push(socket)
|
||
|
})
|
||
|
|
||
|
return Promise.resolve(sockets)
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Makes the matching socket instances join the specified rooms
|
||
|
*
|
||
|
* @param opts - the filters to apply
|
||
|
* @param rooms - the rooms to join
|
||
|
*/
|
||
|
public addSockets(opts: BroadcastOptions, rooms: Room[]): void {
|
||
|
this.apply(opts, socket => {
|
||
|
socket.join(rooms)
|
||
|
})
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Makes the matching socket instances leave the specified rooms
|
||
|
*
|
||
|
* @param opts - the filters to apply
|
||
|
* @param rooms - the rooms to leave
|
||
|
*/
|
||
|
public delSockets(opts: BroadcastOptions, rooms: Room[]): void {
|
||
|
this.apply(opts, socket => {
|
||
|
rooms.forEach(room => socket.leave(room))
|
||
|
})
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Makes the matching socket instances disconnect
|
||
|
*
|
||
|
* @param opts - the filters to apply
|
||
|
* @param close - whether to close the underlying connection
|
||
|
*/
|
||
|
public disconnectSockets(opts: BroadcastOptions, close: boolean): void {
|
||
|
this.apply(opts, socket => {
|
||
|
socket.disconnect(close)
|
||
|
})
|
||
|
}
|
||
|
|
||
|
private apply(opts: BroadcastOptions, callback: (socket) => void): void {
|
||
|
const rooms = opts.rooms
|
||
|
const except = this.computeExceptSids(opts.except)
|
||
|
|
||
|
if (rooms.size) {
|
||
|
const ids = new Set()
|
||
|
for (const room of rooms) {
|
||
|
if (!this.rooms.has(room)) continue
|
||
|
|
||
|
for (const id of this.rooms.get(room)) {
|
||
|
if (ids.has(id) || except.has(id)) continue
|
||
|
const socket = this.nsp.sockets.get(id)
|
||
|
if (socket) {
|
||
|
callback(socket)
|
||
|
ids.add(id)
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
} else {
|
||
|
for (const [id] of this.sids) {
|
||
|
if (except.has(id)) continue
|
||
|
const socket = this.nsp.sockets.get(id)
|
||
|
if (socket) callback(socket)
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
private computeExceptSids(exceptRooms?: Set<Room>) {
|
||
|
const exceptSids = new Set()
|
||
|
if (exceptRooms && exceptRooms.size > 0) {
|
||
|
for (const room of exceptRooms) {
|
||
|
if (this.rooms.has(room)) {
|
||
|
this.rooms.get(room).forEach(sid => exceptSids.add(sid))
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return exceptSids
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Send a packet to the other Socket.IO servers in the cluster
|
||
|
* @param packet - an array of arguments, which may include an acknowledgement callback at the end
|
||
|
*/
|
||
|
public serverSideEmit(packet: any[]): void {
|
||
|
throw new Error(
|
||
|
"this adapter does not support the serverSideEmit() functionality"
|
||
|
)
|
||
|
}
|
||
|
}
|