Socket emit error

Listening to events

There are several ways to handle events that are transmitted between the server and the client.

EventEmitter methods​

On the server-side, the Socket instance extends the Node.js EventEmitter class.

On the client-side, the Socket instance uses the event emitter provided by the component-emitter library, which exposes a subset of the EventEmitter methods.

socket.on(eventName, listener)​

Adds the listener function to the end of the listeners array for the event named eventName.

socket.once(eventName, listener)​

Adds a one-time listener function for the event named eventName

socket.off(eventName, listener)​

Removes the specified listener from the listener array for the event named eventName.

socket.removeAllListeners( [eventName] )​

Removes all listeners, or those of the specified eventName.

Catch-all listeners​

Since Socket.IO v3, a new API inspired from the EventEmitter2 library allows to declare catch-all listeners.

This feature is available on both the client and the server.

socket.onAny(listener)​

Adds a listener that will be fired when any event is emitted.

socket.prependAny(listener)​

Adds a listener that will be fired when any event is emitted. The listener is added to the beginning of the listeners array.

socket.offAny( [listener] )​

Removes all catch-all listeners, or the given listener.

Validation​

The validation of the event arguments is out of the scope of the Socket.IO library.

There are many packages in the JS ecosystem which cover this use case, among them:

Источник

Client API

Exposed as the io namespace in the standalone build, or the result of calling require(«socket.io-client») .

io.protocol​

The protocol revision number (currently: 5).

The protocol defines the format of the packets exchanged between the client and the server. Both the client and the server must use the same revision in order to understand each other.

You can find more information here.

io( [url][, options] )​

• url (String) (defaults to window.location.host )
• options (Object)
  • forceNew (Boolean) whether to reuse an existing connection
• Returns Socket

Creates a new Manager for the given URL, and attempts to reuse an existing Manager for subsequent calls, unless the multiplex option is passed with false . Passing this option is the equivalent of passing «force new connection»: true or forceNew: true .

A new Socket instance is returned for the namespace specified by the pathname in the URL, defaulting to / . For example, if the url is http://localhost/users , a transport connection will be established to http://localhost and a Socket.IO connection will be established to /users .

Query parameters can also be provided, either with the query option or directly in the url (example: http://localhost/users?token=abc ).

is the short version of:

See new Manager(url[, options]) for the list of available options .

Please note: manager.socket(«/my-namespace», options ) will only read the auth key in the options object. query: <…>and other optional values are only used when passed via a new Manager(uri, options) instance.

See Migrating from 2.x to 3.0 for more on the difference between the auth and query options.

Manager​

The Manager manages the Engine.IO client instance, which is the low-level engine that establishes the connection to the server (by using transports like WebSocket or HTTP long-polling).

The Manager handles the reconnection logic.

A single Manager can be used by several Sockets. You can find more information about this multiplexing feature here.

Please note that, in most cases, you won’t use the Manager directly but use the Socket instance instead.

new Manager(url [, options] )​

• url (String)
• options (Object)
• Returns Manager

Available options for the underlying Engine.IO client:

Node.js-only options for the underlying Engine.IO client:

manager.reconnection( [value] )​

• value (Boolean)
• Returns Manager|Boolean

Sets the reconnection option, or returns it if no parameters are passed.

manager.reconnectionAttempts( [value] )​

• value (Number)
• Returns Manager|Number

Sets the reconnectionAttempts option, or returns it if no parameters are passed.

manager.reconnectionDelay( [value] )​

• value (Number)
• Returns Manager|Number

Sets the reconnectionDelay option, or returns it if no parameters are passed.

Источник

Client API

The io method is bound to the global scope in the standalone build:

An ESM bundle is also available since version 4.3.0:

Else, in all other cases (with some build tools, in Node.js or React Native), it can be imported from the socket.io-client package:

io.protocol​

The protocol revision number (currently: 5).

The protocol defines the format of the packets exchanged between the client and the server. Both the client and the server must use the same revision in order to understand each other.

You can find more information here.

io( [url][, options] )​

• url (defaults to window.location.host )
• options
  • forceNew whether to create a new connection
• Returns

Creates a new Manager for the given URL, and attempts to reuse an existing Manager for subsequent calls, unless the multiplex option is passed with false . Passing this option is the equivalent of passing «force new connection»: true or forceNew: true .

A new Socket instance is returned for the namespace specified by the pathname in the URL, defaulting to / . For example, if the url is http://localhost/users , a transport connection will be established to http://localhost and a Socket.IO connection will be established to /users .

Query parameters can also be provided, either with the query option or directly in the url (example: http://localhost/users?token=abc ).

To understand what happens under the hood, the following example:

is the short version of:

The complete list of available options can be found here.

Manager​

The Manager manages the Engine.IO client instance, which is the low-level engine that establishes the connection to the server (by using transports like WebSocket or HTTP long-polling).

The Manager handles the reconnection logic.

A single Manager can be used by several Sockets. You can find more information about this multiplexing feature here.

Please note that, in most cases, you won’t use the Manager directly but use the Socket instance instead.

Constructor​

new Manager(url [, options] )​

• url
• options
• Returns

The complete list of available options can be found here.

Events​

Event: ‘error’​

Fired upon a connection error.

Event: ‘ping’​

Fired when a ping packet is received from the server.

Event: ‘reconnect’​

• attempt reconnection attempt number

Fired upon a successful reconnection.

Event: ‘reconnect_attempt’​

• attempt reconnection attempt number

Fired upon an attempt to reconnect.

Event: ‘reconnect_error’​

Fired upon a reconnection attempt error.

Event: ‘reconnect_failed’​

Fired when couldn’t reconnect within reconnectionAttempts .

Methods​

manager.connect( [callback] )​

manager.open( [callback] )​

• callback
• Returns

If the manager was initiated with autoConnect to false , launch a new connection attempt.

The callback argument is optional and will be called once the attempt fails/succeeds.

manager.reconnection( [value] )​

Sets the reconnection option, or returns it if no parameters are passed.

manager.reconnectionAttempts( [value] )​

Sets the reconnectionAttempts option, or returns it if no parameters are passed.

manager.reconnectionDelay( [value] )​

Sets the reconnectionDelay option, or returns it if no parameters are passed.

manager.reconnectionDelayMax( [value] )​

Sets the reconnectionDelayMax option, or returns it if no parameters are passed.

manager.socket(nsp, options)​

• nsp
• options
• Returns

Creates a new Socket for the given namespace. Only auth ( < auth: > ) is read from the options object. Other keys will be ignored and should be passed when instancing a new Manager(nsp, options) .

manager.timeout( [value] )​

Sets the timeout option, or returns it if no parameters are passed.

Socket​

A Socket is the fundamental class for interacting with the server. A Socket belongs to a certain Namespace (by default / ) and uses an underlying Manager to communicate.

A Socket is basically an EventEmitter which sends events to — and receive events from — the server over the network.

More information can be found here.

Events​

Event: ‘connect’​

Fired upon connection to the Namespace (including a successful reconnection).

Please note that you shouldn’t register event handlers in the connect handler itself, as a new handler will be registered every time the Socket reconnects:

Event: ‘disconnect’​

Fired upon disconnection. The list of possible disconnection reasons:

In the first two cases (explicit disconnection), the client will not try to reconnect and you need to manually call socket.connect() .

In all other cases, the client will wait for a small random delay and then try to reconnect:

Event: ‘connect_error’​

Fired when a namespace middleware error occurs.

Источник

The 2.0.0 release is the first release which is compatible with the Socket.IO v3 server. You can find more information about the v3 release here: https://socket.io/blog/socket-io-3-release/

Here is the compatibility table:

Important note: due to the backward incompatible changes to the Socket.IO protocol, a 2.x Java client will not be able to reach a 2.x server, and vice-versa

Since the Java client matches the Javascript client quite closely, most of the changes listed in the migration guide here also apply to the Java client:

• A middleware error will now emit an Error object
• The Socket query option is renamed to auth
• The Socket instance will no longer forward the events emitted by its Manager
• No more “pong” event

Additional changes which are specific to the Java client:

• An extraHeaders option is now available

socket.on(Socket.EVENT_ERROR, new Emitter.Listener() {
    @Override
    public void call(Object... args) {
        String error = (String) args[0];
        System.out.println(error); // not authorized
    }
});

socket.on(Socket.EVENT_CONNECT_ERROR, new Emitter.Listener() {
    @Override
    public void call(Object... args) {
        JSONObject error = (JSONObject) args[0];
        String message = error.getString("message");
        System.out.println(error); // not authorized

        JSONObject data = error.getJSONObject("data"); // additional details (optional)
    }
});

IO.Options options = new IO.Options();
options.query = singletonMap("abc", singletonList("def")); // included in the query parameters
options.auth = singletonMap("token", singletonList("1234")); // included in the Socket.IO handshake

Socket socket = IO.socket("https://example.com", options);

socket.on(Socket.EVENT_RECONNECT_ATTEMPT, new Emitter.Listener() {
    @Override
    public void call(Object... objects) {
        // ...
    }
});

socket.io().on(Manager.EVENT_RECONNECT_ATTEMPT, new Emitter.Listener() {
    @Override
    public void call(Object... objects) {
        // ...
    }
});

socket.emit("connect_error"); // will now throw an exception

socket.once(Socket.EVENT_PONG, new Emitter.Listener() {
    @Override
    public void call(Object... args) {
        long latency = (long) args[0];
        // ...
    }
});

IO.Options options = new IO.Options();
options.extraHeaders = singletonMap("Authorization", singletonList("Bearer abcd"));

Socket socket = IO.socket("https://example.com", options);

IO.Options options = IO.Options.builder()
    .setExtraHeaders(singletonMap("Authorization", singletonList("Bearer abcd")))
    .build();

Socket socket = IO.socket("https://example.com", options);

Прослушивание мероприятий

Существует несколько способов обработки событий,которые передаются между сервером и клиентом.

EventEmitter methods

На стороне сервера экземпляр Socket расширяет класс Node.js EventEmitter .

На стороне клиента экземпляр Socket использует эмиттер событий, предоставляемый библиотекой компонентов-эмиттеров , которая предоставляет подмножество методов EventEmitter.

socket.on(eventName, listener)

Добавляет функцию прослушивателя в конец массива слушателей для события с именем eventName .

socket.on("details", (...args) => {
  // ...
});

socket.once(eventName, listener)

Добавляет одноразовую функцию прослушивания для события с именем eventName

socket.once("details", (...args) => {
  // ...
});

socket.off(eventName, listener)

Удаляет указанный слушатель из массива слушателей для события с именем eventName .

const listener = (...args) => {
  console.log(args);
}

socket.on("details", listener);

// and then later...
socket.off("details", listener);

socket.removeAllListeners([eventName])

Удаляет всех слушателей или слушателей указанного eventName .

socket.removeAllListeners("details");

socket.removeAllListeners();

Catch-all listeners

Начиная с Socket.IO v3, новый API, вдохновленный библиотекой EventEmitter2, позволяет объявлять универсальных прослушивателей.

Эта функция доступна как на клиенте,так и на сервере.

socket.onAny(listener)

Добавляет слушателя,который будет запускаться при возникновении любого события.

socket.onAny((eventName, ...args) => {
  // ...
});

socket.prependAny(listener)

Добавляет слушатель,который будет запускаться при возникновении любого события.Слушатель добавляется в начало массива слушателей.

socket.prependAny((eventName, ...args) => {
  // ...
});

socket.offAny([listener])

Удаляет все прослушивающие устройства или указанное прослушивающее устройство.

const listener = (eventName, ...args) => {
  console.log(eventName, args);
}

socket.onAny(listener);


socket.offAny(listener);


socket.offAny();

Validation

Проверка аргументов события выходит за рамки библиотеки Socket.IO.

В экосистеме JS есть много пакетов,которые охватывают этот вариант использования,среди них:

• joi
• ajv
• validatorjs

Пример с joi и благодарностями :

const Joi = require("joi");

const userSchema = Joi.object({
  username: Joi.string().max(30).required(),
  email: Joi.string().email().required()
});

io.on("connection", (socket) => {
  socket.on("create user", (payload, callback) => {
    if (typeof callback !== "function") {
      
      return socket.disconnect();
    }
    const { error, value } = userSchema.validate(payload);
    if (error) {
      return callback({
        status: "KO",
        error
      });
    }
    
    callback({
      status: "OK"
    });
  });

});

Error handling

В настоящее время в библиотеке Socket.IO нет встроенной обработки ошибок,что означает,что вы должны поймать любую ошибку,которая может быть брошена в слушателе.

io.on("connection", (socket) => {
  socket.on("list items", async (callback) => {
    try {
      const items = await findItems();
      callback({
        status: "OK",
        items
      });
    } catch (e) {
      callback({
        status: "NOK"
      });
    }
  });
});

На стороне сервера использование EventEmitter.captureRejections = true (экспериментальное, см. Здесь ) тоже может быть интересным, в зависимости от вашего варианта использования.

require("events").captureRejections = true;

io.on("connection", (socket) => {
  socket.on("list products", async () => {
    const products = await findProducts();
    socket.emit("products", products);
  });

  socket[Symbol.for('nodejs.rejection')] = (err) => {
    socket.emit("error", err);
  };
});

Socket.IO

4.5

• Handling CORS

• Как это работает

• Load testing

• Logging and debugging