|
|
"use strict";
|
|
|
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
|
};
|
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
exports.Socket = exports.RESERVED_EVENTS = void 0;
|
|
|
const socket_io_parser_1 = require("socket.io-parser");
|
|
|
const debug_1 = __importDefault(require("debug"));
|
|
|
const typed_events_1 = require("./typed-events");
|
|
|
const base64id_1 = __importDefault(require("base64id"));
|
|
|
const broadcast_operator_1 = require("./broadcast-operator");
|
|
|
const debug = (0, debug_1.default)("socket.io:socket");
|
|
|
const RECOVERABLE_DISCONNECT_REASONS = new Set([
|
|
|
"transport error",
|
|
|
"transport close",
|
|
|
"forced close",
|
|
|
"ping timeout",
|
|
|
"server shutting down",
|
|
|
"forced server close",
|
|
|
]);
|
|
|
exports.RESERVED_EVENTS = new Set([
|
|
|
"connect",
|
|
|
"connect_error",
|
|
|
"disconnect",
|
|
|
"disconnecting",
|
|
|
"newListener",
|
|
|
"removeListener",
|
|
|
]);
|
|
|
function noop() { }
|
|
|
/**
|
|
|
* This is the main object for interacting with a client.
|
|
|
*
|
|
|
* A Socket belongs to a given {@link Namespace} and uses an underlying {@link Client} to communicate.
|
|
|
*
|
|
|
* Within each {@link Namespace}, you can also define arbitrary channels (called "rooms") that the {@link Socket} can
|
|
|
* join and leave. That provides a convenient way to broadcast to a group of socket instances.
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* console.log(`socket ${socket.id} connected`);
|
|
|
*
|
|
|
* // send an event to the client
|
|
|
* socket.emit("foo", "bar");
|
|
|
*
|
|
|
* socket.on("foobar", () => {
|
|
|
* // an event was received from the client
|
|
|
* });
|
|
|
*
|
|
|
* // join the room named "room1"
|
|
|
* socket.join("room1");
|
|
|
*
|
|
|
* // broadcast to everyone in the room named "room1"
|
|
|
* io.to("room1").emit("hello");
|
|
|
*
|
|
|
* // upon disconnection
|
|
|
* socket.on("disconnect", (reason) => {
|
|
|
* console.log(`socket ${socket.id} disconnected due to ${reason}`);
|
|
|
* });
|
|
|
* });
|
|
|
*/
|
|
|
class Socket extends typed_events_1.StrictEventEmitter {
|
|
|
/**
|
|
|
* Interface to a `Client` for a given `Namespace`.
|
|
|
*
|
|
|
* @param {Namespace} nsp
|
|
|
* @param {Client} client
|
|
|
* @param {Object} auth
|
|
|
* @package
|
|
|
*/
|
|
|
constructor(nsp, client, auth, previousSession) {
|
|
|
super();
|
|
|
this.nsp = nsp;
|
|
|
this.client = client;
|
|
|
/**
|
|
|
* Whether the connection state was recovered after a temporary disconnection. In that case, any missed packets will
|
|
|
* be transmitted to the client, the data attribute and the rooms will be restored.
|
|
|
*/
|
|
|
this.recovered = false;
|
|
|
/**
|
|
|
* Additional information that can be attached to the Socket instance and which will be used in the
|
|
|
* {@link Server.fetchSockets()} method.
|
|
|
*/
|
|
|
this.data = {};
|
|
|
/**
|
|
|
* Whether the socket is currently connected or not.
|
|
|
*
|
|
|
* @example
|
|
|
* io.use((socket, next) => {
|
|
|
* console.log(socket.connected); // false
|
|
|
* next();
|
|
|
* });
|
|
|
*
|
|
|
* io.on("connection", (socket) => {
|
|
|
* console.log(socket.connected); // true
|
|
|
* });
|
|
|
*/
|
|
|
this.connected = false;
|
|
|
this.acks = new Map();
|
|
|
this.fns = [];
|
|
|
this.flags = {};
|
|
|
this.server = nsp.server;
|
|
|
this.adapter = this.nsp.adapter;
|
|
|
if (previousSession) {
|
|
|
this.id = previousSession.sid;
|
|
|
this.pid = previousSession.pid;
|
|
|
previousSession.rooms.forEach((room) => this.join(room));
|
|
|
this.data = previousSession.data;
|
|
|
previousSession.missedPackets.forEach((packet) => {
|
|
|
this.packet({
|
|
|
type: socket_io_parser_1.PacketType.EVENT,
|
|
|
data: packet,
|
|
|
});
|
|
|
});
|
|
|
this.recovered = true;
|
|
|
}
|
|
|
else {
|
|
|
if (client.conn.protocol === 3) {
|
|
|
// @ts-ignore
|
|
|
this.id = nsp.name !== "/" ? nsp.name + "#" + client.id : client.id;
|
|
|
}
|
|
|
else {
|
|
|
this.id = base64id_1.default.generateId(); // don't reuse the Engine.IO id because it's sensitive information
|
|
|
}
|
|
|
if (this.server._opts.connectionStateRecovery) {
|
|
|
this.pid = base64id_1.default.generateId();
|
|
|
}
|
|
|
}
|
|
|
this.handshake = this.buildHandshake(auth);
|
|
|
}
|
|
|
/**
|
|
|
* Builds the `handshake` BC object
|
|
|
*
|
|
|
* @private
|
|
|
*/
|
|
|
buildHandshake(auth) {
|
|
|
return {
|
|
|
headers: this.request.headers,
|
|
|
time: new Date() + "",
|
|
|
address: this.conn.remoteAddress,
|
|
|
xdomain: !!this.request.headers.origin,
|
|
|
// @ts-ignore
|
|
|
secure: !!this.request.connection.encrypted,
|
|
|
issued: +new Date(),
|
|
|
url: this.request.url,
|
|
|
// @ts-ignore
|
|
|
query: this.request._query,
|
|
|
auth,
|
|
|
};
|
|
|
}
|
|
|
/**
|
|
|
* Emits to this client.
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* socket.emit("hello", "world");
|
|
|
*
|
|
|
* // all serializable datastructures are supported (no need to call JSON.stringify)
|
|
|
* socket.emit("hello", 1, "2", { 3: ["4"], 5: Buffer.from([6]) });
|
|
|
*
|
|
|
* // with an acknowledgement from the client
|
|
|
* socket.emit("hello", "world", (val) => {
|
|
|
* // ...
|
|
|
* });
|
|
|
* });
|
|
|
*
|
|
|
* @return Always returns `true`.
|
|
|
*/
|
|
|
emit(ev, ...args) {
|
|
|
if (exports.RESERVED_EVENTS.has(ev)) {
|
|
|
throw new Error(`"${String(ev)}" is a reserved event name`);
|
|
|
}
|
|
|
const data = [ev, ...args];
|
|
|
const packet = {
|
|
|
type: socket_io_parser_1.PacketType.EVENT,
|
|
|
data: data,
|
|
|
};
|
|
|
// access last argument to see if it's an ACK callback
|
|
|
if (typeof data[data.length - 1] === "function") {
|
|
|
const id = this.nsp._ids++;
|
|
|
debug("emitting packet with ack id %d", id);
|
|
|
this.registerAckCallback(id, data.pop());
|
|
|
packet.id = id;
|
|
|
}
|
|
|
const flags = Object.assign({}, this.flags);
|
|
|
this.flags = {};
|
|
|
// @ts-ignore
|
|
|
if (this.nsp.server.opts.connectionStateRecovery) {
|
|
|
// this ensures the packet is stored and can be transmitted upon reconnection
|
|
|
this.adapter.broadcast(packet, {
|
|
|
rooms: new Set([this.id]),
|
|
|
except: new Set(),
|
|
|
flags,
|
|
|
});
|
|
|
}
|
|
|
else {
|
|
|
this.notifyOutgoingListeners(packet);
|
|
|
this.packet(packet, flags);
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
/**
|
|
|
* Emits an event and waits for an acknowledgement
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", async (socket) => {
|
|
|
* // without timeout
|
|
|
* const response = await socket.emitWithAck("hello", "world");
|
|
|
*
|
|
|
* // with a specific timeout
|
|
|
* try {
|
|
|
* const response = await socket.timeout(1000).emitWithAck("hello", "world");
|
|
|
* } catch (err) {
|
|
|
* // the client did not acknowledge the event in the given delay
|
|
|
* }
|
|
|
* });
|
|
|
*
|
|
|
* @return a Promise that will be fulfilled when the client acknowledges the event
|
|
|
*/
|
|
|
emitWithAck(ev, ...args) {
|
|
|
// the timeout flag is optional
|
|
|
const withErr = this.flags.timeout !== undefined;
|
|
|
return new Promise((resolve, reject) => {
|
|
|
args.push((arg1, arg2) => {
|
|
|
if (withErr) {
|
|
|
return arg1 ? reject(arg1) : resolve(arg2);
|
|
|
}
|
|
|
else {
|
|
|
return resolve(arg1);
|
|
|
}
|
|
|
});
|
|
|
this.emit(ev, ...args);
|
|
|
});
|
|
|
}
|
|
|
/**
|
|
|
* @private
|
|
|
*/
|
|
|
registerAckCallback(id, ack) {
|
|
|
const timeout = this.flags.timeout;
|
|
|
if (timeout === undefined) {
|
|
|
this.acks.set(id, ack);
|
|
|
return;
|
|
|
}
|
|
|
const timer = setTimeout(() => {
|
|
|
debug("event with ack id %d has timed out after %d ms", id, timeout);
|
|
|
this.acks.delete(id);
|
|
|
ack.call(this, new Error("operation has timed out"));
|
|
|
}, timeout);
|
|
|
this.acks.set(id, (...args) => {
|
|
|
clearTimeout(timer);
|
|
|
ack.apply(this, [null, ...args]);
|
|
|
});
|
|
|
}
|
|
|
/**
|
|
|
* Targets a room when broadcasting.
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* // the “foo” event will be broadcast to all connected clients in the “room-101” room, except this socket
|
|
|
* socket.to("room-101").emit("foo", "bar");
|
|
|
*
|
|
|
* // the code above is equivalent to:
|
|
|
* io.to("room-101").except(socket.id).emit("foo", "bar");
|
|
|
*
|
|
|
* // with an array of rooms (a client will be notified at most once)
|
|
|
* socket.to(["room-101", "room-102"]).emit("foo", "bar");
|
|
|
*
|
|
|
* // with multiple chained calls
|
|
|
* socket.to("room-101").to("room-102").emit("foo", "bar");
|
|
|
* });
|
|
|
*
|
|
|
* @param room - a room, or an array of rooms
|
|
|
* @return a new {@link BroadcastOperator} instance for chaining
|
|
|
*/
|
|
|
to(room) {
|
|
|
return this.newBroadcastOperator().to(room);
|
|
|
}
|
|
|
/**
|
|
|
* Targets a room when broadcasting. Similar to `to()`, but might feel clearer in some cases:
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* // disconnect all clients in the "room-101" room, except this socket
|
|
|
* socket.in("room-101").disconnectSockets();
|
|
|
* });
|
|
|
*
|
|
|
* @param room - a room, or an array of rooms
|
|
|
* @return a new {@link BroadcastOperator} instance for chaining
|
|
|
*/
|
|
|
in(room) {
|
|
|
return this.newBroadcastOperator().in(room);
|
|
|
}
|
|
|
/**
|
|
|
* Excludes a room when broadcasting.
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* // the "foo" event will be broadcast to all connected clients, except the ones that are in the "room-101" room
|
|
|
* // and this socket
|
|
|
* socket.except("room-101").emit("foo", "bar");
|
|
|
*
|
|
|
* // with an array of rooms
|
|
|
* socket.except(["room-101", "room-102"]).emit("foo", "bar");
|
|
|
*
|
|
|
* // with multiple chained calls
|
|
|
* socket.except("room-101").except("room-102").emit("foo", "bar");
|
|
|
* });
|
|
|
*
|
|
|
* @param room - a room, or an array of rooms
|
|
|
* @return a new {@link BroadcastOperator} instance for chaining
|
|
|
*/
|
|
|
except(room) {
|
|
|
return this.newBroadcastOperator().except(room);
|
|
|
}
|
|
|
/**
|
|
|
* Sends a `message` event.
|
|
|
*
|
|
|
* This method mimics the WebSocket.send() method.
|
|
|
*
|
|
|
* @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* socket.send("hello");
|
|
|
*
|
|
|
* // this is equivalent to
|
|
|
* socket.emit("message", "hello");
|
|
|
* });
|
|
|
*
|
|
|
* @return self
|
|
|
*/
|
|
|
send(...args) {
|
|
|
this.emit("message", ...args);
|
|
|
return this;
|
|
|
}
|
|
|
/**
|
|
|
* Sends a `message` event. Alias of {@link send}.
|
|
|
*
|
|
|
* @return self
|
|
|
*/
|
|
|
write(...args) {
|
|
|
this.emit("message", ...args);
|
|
|
return this;
|
|
|
}
|
|
|
/**
|
|
|
* Writes a packet.
|
|
|
*
|
|
|
* @param {Object} packet - packet object
|
|
|
* @param {Object} opts - options
|
|
|
* @private
|
|
|
*/
|
|
|
packet(packet, opts = {}) {
|
|
|
packet.nsp = this.nsp.name;
|
|
|
opts.compress = false !== opts.compress;
|
|
|
this.client._packet(packet, opts);
|
|
|
}
|
|
|
/**
|
|
|
* Joins a room.
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* // join a single room
|
|
|
* socket.join("room1");
|
|
|
*
|
|
|
* // join multiple rooms
|
|
|
* socket.join(["room1", "room2"]);
|
|
|
* });
|
|
|
*
|
|
|
* @param {String|Array} rooms - room or array of rooms
|
|
|
* @return a Promise or nothing, depending on the adapter
|
|
|
*/
|
|
|
join(rooms) {
|
|
|
debug("join room %s", rooms);
|
|
|
return this.adapter.addAll(this.id, new Set(Array.isArray(rooms) ? rooms : [rooms]));
|
|
|
}
|
|
|
/**
|
|
|
* Leaves a room.
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* // leave a single room
|
|
|
* socket.leave("room1");
|
|
|
*
|
|
|
* // leave multiple rooms
|
|
|
* socket.leave("room1").leave("room2");
|
|
|
* });
|
|
|
*
|
|
|
* @param {String} room
|
|
|
* @return a Promise or nothing, depending on the adapter
|
|
|
*/
|
|
|
leave(room) {
|
|
|
debug("leave room %s", room);
|
|
|
return this.adapter.del(this.id, room);
|
|
|
}
|
|
|
/**
|
|
|
* Leave all rooms.
|
|
|
*
|
|
|
* @private
|
|
|
*/
|
|
|
leaveAll() {
|
|
|
this.adapter.delAll(this.id);
|
|
|
}
|
|
|
/**
|
|
|
* Called by `Namespace` upon successful
|
|
|
* middleware execution (ie: authorization).
|
|
|
* Socket is added to namespace array before
|
|
|
* call to join, so adapters can access it.
|
|
|
*
|
|
|
* @private
|
|
|
*/
|
|
|
_onconnect() {
|
|
|
debug("socket connected - writing packet");
|
|
|
this.connected = true;
|
|
|
this.join(this.id);
|
|
|
if (this.conn.protocol === 3) {
|
|
|
this.packet({ type: socket_io_parser_1.PacketType.CONNECT });
|
|
|
}
|
|
|
else {
|
|
|
this.packet({
|
|
|
type: socket_io_parser_1.PacketType.CONNECT,
|
|
|
data: { sid: this.id, pid: this.pid },
|
|
|
});
|
|
|
}
|
|
|
}
|
|
|
/**
|
|
|
* Called with each packet. Called by `Client`.
|
|
|
*
|
|
|
* @param {Object} packet
|
|
|
* @private
|
|
|
*/
|
|
|
_onpacket(packet) {
|
|
|
debug("got packet %j", packet);
|
|
|
switch (packet.type) {
|
|
|
case socket_io_parser_1.PacketType.EVENT:
|
|
|
this.onevent(packet);
|
|
|
break;
|
|
|
case socket_io_parser_1.PacketType.BINARY_EVENT:
|
|
|
this.onevent(packet);
|
|
|
break;
|
|
|
case socket_io_parser_1.PacketType.ACK:
|
|
|
this.onack(packet);
|
|
|
break;
|
|
|
case socket_io_parser_1.PacketType.BINARY_ACK:
|
|
|
this.onack(packet);
|
|
|
break;
|
|
|
case socket_io_parser_1.PacketType.DISCONNECT:
|
|
|
this.ondisconnect();
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
/**
|
|
|
* Called upon event packet.
|
|
|
*
|
|
|
* @param {Packet} packet - packet object
|
|
|
* @private
|
|
|
*/
|
|
|
onevent(packet) {
|
|
|
const args = packet.data || [];
|
|
|
debug("emitting event %j", args);
|
|
|
if (null != packet.id) {
|
|
|
debug("attaching ack callback to event");
|
|
|
args.push(this.ack(packet.id));
|
|
|
}
|
|
|
if (this._anyListeners && this._anyListeners.length) {
|
|
|
const listeners = this._anyListeners.slice();
|
|
|
for (const listener of listeners) {
|
|
|
listener.apply(this, args);
|
|
|
}
|
|
|
}
|
|
|
this.dispatch(args);
|
|
|
}
|
|
|
/**
|
|
|
* Produces an ack callback to emit with an event.
|
|
|
*
|
|
|
* @param {Number} id - packet id
|
|
|
* @private
|
|
|
*/
|
|
|
ack(id) {
|
|
|
const self = this;
|
|
|
let sent = false;
|
|
|
return function () {
|
|
|
// prevent double callbacks
|
|
|
if (sent)
|
|
|
return;
|
|
|
const args = Array.prototype.slice.call(arguments);
|
|
|
debug("sending ack %j", args);
|
|
|
self.packet({
|
|
|
id: id,
|
|
|
type: socket_io_parser_1.PacketType.ACK,
|
|
|
data: args,
|
|
|
});
|
|
|
sent = true;
|
|
|
};
|
|
|
}
|
|
|
/**
|
|
|
* Called upon ack packet.
|
|
|
*
|
|
|
* @private
|
|
|
*/
|
|
|
onack(packet) {
|
|
|
const ack = this.acks.get(packet.id);
|
|
|
if ("function" == typeof ack) {
|
|
|
debug("calling ack %s with %j", packet.id, packet.data);
|
|
|
ack.apply(this, packet.data);
|
|
|
this.acks.delete(packet.id);
|
|
|
}
|
|
|
else {
|
|
|
debug("bad ack %s", packet.id);
|
|
|
}
|
|
|
}
|
|
|
/**
|
|
|
* Called upon client disconnect packet.
|
|
|
*
|
|
|
* @private
|
|
|
*/
|
|
|
ondisconnect() {
|
|
|
debug("got disconnect packet");
|
|
|
this._onclose("client namespace disconnect");
|
|
|
}
|
|
|
/**
|
|
|
* Handles a client error.
|
|
|
*
|
|
|
* @private
|
|
|
*/
|
|
|
_onerror(err) {
|
|
|
if (this.listeners("error").length) {
|
|
|
this.emitReserved("error", err);
|
|
|
}
|
|
|
else {
|
|
|
console.error("Missing error handler on `socket`.");
|
|
|
console.error(err.stack);
|
|
|
}
|
|
|
}
|
|
|
/**
|
|
|
* Called upon closing. Called by `Client`.
|
|
|
*
|
|
|
* @param {String} reason
|
|
|
* @param description
|
|
|
* @throw {Error} optional error object
|
|
|
*
|
|
|
* @private
|
|
|
*/
|
|
|
_onclose(reason, description) {
|
|
|
if (!this.connected)
|
|
|
return this;
|
|
|
debug("closing socket - reason %s", reason);
|
|
|
this.emitReserved("disconnecting", reason, description);
|
|
|
if (this.server._opts.connectionStateRecovery &&
|
|
|
RECOVERABLE_DISCONNECT_REASONS.has(reason)) {
|
|
|
debug("connection state recovery is enabled for sid %s", this.id);
|
|
|
this.adapter.persistSession({
|
|
|
sid: this.id,
|
|
|
pid: this.pid,
|
|
|
rooms: [...this.rooms],
|
|
|
data: this.data,
|
|
|
});
|
|
|
}
|
|
|
this._cleanup();
|
|
|
this.nsp._remove(this);
|
|
|
this.client._remove(this);
|
|
|
this.connected = false;
|
|
|
this.emitReserved("disconnect", reason, description);
|
|
|
return;
|
|
|
}
|
|
|
/**
|
|
|
* Makes the socket leave all the rooms it was part of and prevents it from joining any other room
|
|
|
*
|
|
|
* @private
|
|
|
*/
|
|
|
_cleanup() {
|
|
|
this.leaveAll();
|
|
|
this.join = noop;
|
|
|
}
|
|
|
/**
|
|
|
* Produces an `error` packet.
|
|
|
*
|
|
|
* @param {Object} err - error object
|
|
|
*
|
|
|
* @private
|
|
|
*/
|
|
|
_error(err) {
|
|
|
this.packet({ type: socket_io_parser_1.PacketType.CONNECT_ERROR, data: err });
|
|
|
}
|
|
|
/**
|
|
|
* Disconnects this client.
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* // disconnect this socket (the connection might be kept alive for other namespaces)
|
|
|
* socket.disconnect();
|
|
|
*
|
|
|
* // disconnect this socket and close the underlying connection
|
|
|
* socket.disconnect(true);
|
|
|
* })
|
|
|
*
|
|
|
* @param {Boolean} close - if `true`, closes the underlying connection
|
|
|
* @return self
|
|
|
*/
|
|
|
disconnect(close = false) {
|
|
|
if (!this.connected)
|
|
|
return this;
|
|
|
if (close) {
|
|
|
this.client._disconnect();
|
|
|
}
|
|
|
else {
|
|
|
this.packet({ type: socket_io_parser_1.PacketType.DISCONNECT });
|
|
|
this._onclose("server namespace disconnect");
|
|
|
}
|
|
|
return this;
|
|
|
}
|
|
|
/**
|
|
|
* Sets the compress flag.
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* socket.compress(false).emit("hello");
|
|
|
* });
|
|
|
*
|
|
|
* @param {Boolean} compress - if `true`, compresses the sending data
|
|
|
* @return {Socket} self
|
|
|
*/
|
|
|
compress(compress) {
|
|
|
this.flags.compress = compress;
|
|
|
return this;
|
|
|
}
|
|
|
/**
|
|
|
* Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to
|
|
|
* receive messages (because of network slowness or other issues, or because they’re connected through long polling
|
|
|
* and is in the middle of a request-response cycle).
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* socket.volatile.emit("hello"); // the client may or may not receive it
|
|
|
* });
|
|
|
*
|
|
|
* @return {Socket} self
|
|
|
*/
|
|
|
get volatile() {
|
|
|
this.flags.volatile = true;
|
|
|
return this;
|
|
|
}
|
|
|
/**
|
|
|
* Sets a modifier for a subsequent event emission that the event data will only be broadcast to every sockets but the
|
|
|
* sender.
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* // the “foo” event will be broadcast to all connected clients, except this socket
|
|
|
* socket.broadcast.emit("foo", "bar");
|
|
|
* });
|
|
|
*
|
|
|
* @return a new {@link BroadcastOperator} instance for chaining
|
|
|
*/
|
|
|
get broadcast() {
|
|
|
return this.newBroadcastOperator();
|
|
|
}
|
|
|
/**
|
|
|
* Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* // the “foo” event will be broadcast to all connected clients on this node, except this socket
|
|
|
* socket.local.emit("foo", "bar");
|
|
|
* });
|
|
|
*
|
|
|
* @return a new {@link BroadcastOperator} instance for chaining
|
|
|
*/
|
|
|
get local() {
|
|
|
return this.newBroadcastOperator().local;
|
|
|
}
|
|
|
/**
|
|
|
* Sets a modifier for a subsequent event emission that the callback will be called with an error when the
|
|
|
* given number of milliseconds have elapsed without an acknowledgement from the client:
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* socket.timeout(5000).emit("my-event", (err) => {
|
|
|
* if (err) {
|
|
|
* // the client did not acknowledge the event in the given delay
|
|
|
* }
|
|
|
* });
|
|
|
* });
|
|
|
*
|
|
|
* @returns self
|
|
|
*/
|
|
|
timeout(timeout) {
|
|
|
this.flags.timeout = timeout;
|
|
|
return this;
|
|
|
}
|
|
|
/**
|
|
|
* Dispatch incoming event to socket listeners.
|
|
|
*
|
|
|
* @param {Array} event - event that will get emitted
|
|
|
* @private
|
|
|
*/
|
|
|
dispatch(event) {
|
|
|
debug("dispatching an event %j", event);
|
|
|
this.run(event, (err) => {
|
|
|
process.nextTick(() => {
|
|
|
if (err) {
|
|
|
return this._onerror(err);
|
|
|
}
|
|
|
if (this.connected) {
|
|
|
super.emitUntyped.apply(this, event);
|
|
|
}
|
|
|
else {
|
|
|
debug("ignore packet received after disconnection");
|
|
|
}
|
|
|
});
|
|
|
});
|
|
|
}
|
|
|
/**
|
|
|
* Sets up socket middleware.
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* socket.use(([event, ...args], next) => {
|
|
|
* if (isUnauthorized(event)) {
|
|
|
* return next(new Error("unauthorized event"));
|
|
|
* }
|
|
|
* // do not forget to call next
|
|
|
* next();
|
|
|
* });
|
|
|
*
|
|
|
* socket.on("error", (err) => {
|
|
|
* if (err && err.message === "unauthorized event") {
|
|
|
* socket.disconnect();
|
|
|
* }
|
|
|
* });
|
|
|
* });
|
|
|
*
|
|
|
* @param {Function} fn - middleware function (event, next)
|
|
|
* @return {Socket} self
|
|
|
*/
|
|
|
use(fn) {
|
|
|
this.fns.push(fn);
|
|
|
return this;
|
|
|
}
|
|
|
/**
|
|
|
* Executes the middleware for an incoming event.
|
|
|
*
|
|
|
* @param {Array} event - event that will get emitted
|
|
|
* @param {Function} fn - last fn call in the middleware
|
|
|
* @private
|
|
|
*/
|
|
|
run(event, fn) {
|
|
|
const fns = this.fns.slice(0);
|
|
|
if (!fns.length)
|
|
|
return fn(null);
|
|
|
function run(i) {
|
|
|
fns[i](event, function (err) {
|
|
|
// upon error, short-circuit
|
|
|
if (err)
|
|
|
return fn(err);
|
|
|
// if no middleware left, summon callback
|
|
|
if (!fns[i + 1])
|
|
|
return fn(null);
|
|
|
// go on to next
|
|
|
run(i + 1);
|
|
|
});
|
|
|
}
|
|
|
run(0);
|
|
|
}
|
|
|
/**
|
|
|
* Whether the socket is currently disconnected
|
|
|
*/
|
|
|
get disconnected() {
|
|
|
return !this.connected;
|
|
|
}
|
|
|
/**
|
|
|
* A reference to the request that originated the underlying Engine.IO Socket.
|
|
|
*/
|
|
|
get request() {
|
|
|
return this.client.request;
|
|
|
}
|
|
|
/**
|
|
|
* A reference to the underlying Client transport connection (Engine.IO Socket object).
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* console.log(socket.conn.transport.name); // prints "polling" or "websocket"
|
|
|
*
|
|
|
* socket.conn.once("upgrade", () => {
|
|
|
* console.log(socket.conn.transport.name); // prints "websocket"
|
|
|
* });
|
|
|
* });
|
|
|
*/
|
|
|
get conn() {
|
|
|
return this.client.conn;
|
|
|
}
|
|
|
/**
|
|
|
* Returns the rooms the socket is currently in.
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* console.log(socket.rooms); // Set { <socket.id> }
|
|
|
*
|
|
|
* socket.join("room1");
|
|
|
*
|
|
|
* console.log(socket.rooms); // Set { <socket.id>, "room1" }
|
|
|
* });
|
|
|
*/
|
|
|
get rooms() {
|
|
|
return this.adapter.socketRooms(this.id) || new Set();
|
|
|
}
|
|
|
/**
|
|
|
* Adds a listener that will be fired when any event is received. The event name is passed as the first argument to
|
|
|
* the callback.
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* socket.onAny((event, ...args) => {
|
|
|
* console.log(`got event ${event}`);
|
|
|
* });
|
|
|
* });
|
|
|
*
|
|
|
* @param listener
|
|
|
*/
|
|
|
onAny(listener) {
|
|
|
this._anyListeners = this._anyListeners || [];
|
|
|
this._anyListeners.push(listener);
|
|
|
return this;
|
|
|
}
|
|
|
/**
|
|
|
* Adds a listener that will be fired when any event is received. The event name is passed as the first argument to
|
|
|
* the callback. The listener is added to the beginning of the listeners array.
|
|
|
*
|
|
|
* @param listener
|
|
|
*/
|
|
|
prependAny(listener) {
|
|
|
this._anyListeners = this._anyListeners || [];
|
|
|
this._anyListeners.unshift(listener);
|
|
|
return this;
|
|
|
}
|
|
|
/**
|
|
|
* Removes the listener that will be fired when any event is received.
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* const catchAllListener = (event, ...args) => {
|
|
|
* console.log(`got event ${event}`);
|
|
|
* }
|
|
|
*
|
|
|
* socket.onAny(catchAllListener);
|
|
|
*
|
|
|
* // remove a specific listener
|
|
|
* socket.offAny(catchAllListener);
|
|
|
*
|
|
|
* // or remove all listeners
|
|
|
* socket.offAny();
|
|
|
* });
|
|
|
*
|
|
|
* @param listener
|
|
|
*/
|
|
|
offAny(listener) {
|
|
|
if (!this._anyListeners) {
|
|
|
return this;
|
|
|
}
|
|
|
if (listener) {
|
|
|
const listeners = this._anyListeners;
|
|
|
for (let i = 0; i < listeners.length; i++) {
|
|
|
if (listener === listeners[i]) {
|
|
|
listeners.splice(i, 1);
|
|
|
return this;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else {
|
|
|
this._anyListeners = [];
|
|
|
}
|
|
|
return this;
|
|
|
}
|
|
|
/**
|
|
|
* Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
|
|
|
* e.g. to remove listeners.
|
|
|
*/
|
|
|
listenersAny() {
|
|
|
return this._anyListeners || [];
|
|
|
}
|
|
|
/**
|
|
|
* Adds a listener that will be fired when any event is sent. The event name is passed as the first argument to
|
|
|
* the callback.
|
|
|
*
|
|
|
* Note: acknowledgements sent to the client are not included.
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* socket.onAnyOutgoing((event, ...args) => {
|
|
|
* console.log(`sent event ${event}`);
|
|
|
* });
|
|
|
* });
|
|
|
*
|
|
|
* @param listener
|
|
|
*/
|
|
|
onAnyOutgoing(listener) {
|
|
|
this._anyOutgoingListeners = this._anyOutgoingListeners || [];
|
|
|
this._anyOutgoingListeners.push(listener);
|
|
|
return this;
|
|
|
}
|
|
|
/**
|
|
|
* Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
|
|
|
* callback. The listener is added to the beginning of the listeners array.
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* socket.prependAnyOutgoing((event, ...args) => {
|
|
|
* console.log(`sent event ${event}`);
|
|
|
* });
|
|
|
* });
|
|
|
*
|
|
|
* @param listener
|
|
|
*/
|
|
|
prependAnyOutgoing(listener) {
|
|
|
this._anyOutgoingListeners = this._anyOutgoingListeners || [];
|
|
|
this._anyOutgoingListeners.unshift(listener);
|
|
|
return this;
|
|
|
}
|
|
|
/**
|
|
|
* Removes the listener that will be fired when any event is sent.
|
|
|
*
|
|
|
* @example
|
|
|
* io.on("connection", (socket) => {
|
|
|
* const catchAllListener = (event, ...args) => {
|
|
|
* console.log(`sent event ${event}`);
|
|
|
* }
|
|
|
*
|
|
|
* socket.onAnyOutgoing(catchAllListener);
|
|
|
*
|
|
|
* // remove a specific listener
|
|
|
* socket.offAnyOutgoing(catchAllListener);
|
|
|
*
|
|
|
* // or remove all listeners
|
|
|
* socket.offAnyOutgoing();
|
|
|
* });
|
|
|
*
|
|
|
* @param listener - the catch-all listener
|
|
|
*/
|
|
|
offAnyOutgoing(listener) {
|
|
|
if (!this._anyOutgoingListeners) {
|
|
|
return this;
|
|
|
}
|
|
|
if (listener) {
|
|
|
const listeners = this._anyOutgoingListeners;
|
|
|
for (let i = 0; i < listeners.length; i++) {
|
|
|
if (listener === listeners[i]) {
|
|
|
listeners.splice(i, 1);
|
|
|
return this;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else {
|
|
|
this._anyOutgoingListeners = [];
|
|
|
}
|
|
|
return this;
|
|
|
}
|
|
|
/**
|
|
|
* Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
|
|
|
* e.g. to remove listeners.
|
|
|
*/
|
|
|
listenersAnyOutgoing() {
|
|
|
return this._anyOutgoingListeners || [];
|
|
|
}
|
|
|
/**
|
|
|
* Notify the listeners for each packet sent (emit or broadcast)
|
|
|
*
|
|
|
* @param packet
|
|
|
*
|
|
|
* @private
|
|
|
*/
|
|
|
notifyOutgoingListeners(packet) {
|
|
|
if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) {
|
|
|
const listeners = this._anyOutgoingListeners.slice();
|
|
|
for (const listener of listeners) {
|
|
|
listener.apply(this, packet.data);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
newBroadcastOperator() {
|
|
|
const flags = Object.assign({}, this.flags);
|
|
|
this.flags = {};
|
|
|
return new broadcast_operator_1.BroadcastOperator(this.adapter, new Set(), new Set([this.id]), flags);
|
|
|
}
|
|
|
}
|
|
|
exports.Socket = Socket;
|
