未处理的socket.io事件会发生什么？

Question

Does socket.io ignore\\drop them? The reason why Im asking this is the following. There is a client with several states. Each state has its own set of socket handlers. At different moments server notifies the client of state change and after that sends several state dependent messages. But! It takes some time for the client to change state and to set new handlers. In this case client can miss some msgs... because there are no handlers at the moment. If I understand correctly unhandled msgs are lost for client.

May be I miss the concept or do smth wrong... How to hanle this issues?

Answer 1

Unhandled messages are just ignored. It's just like when an event occurs and there are no event listeners for that event. The socket receives the msg and doesn't find a handler for it so nothing happens with it.

You could avoid missing messages by always having the handlers installed and then deciding in the handlers (based on other state) whether to do anything with the message or not.

Answer 2

jfriend00's answer is a good one, and you are probably fine just leaving the handlers in place and using logic in the callback to ignore events as needed. If you really want to manage the unhandled packets though, read on...

You can get the list of callbacks from the socket internals, and use it to compare to the incoming message header. This client-side code will do just that.

// Save a copy of the onevent function
socket._onevent = socket.onevent;

// Replace the onevent function with a handler that captures all messages
socket.onevent = function (packet) {
  // Compare the list of callbacks to the incoming event name
  if( !Object.keys(socket._callbacks).map(x => x.substr(1)).includes(packet.data[0]) ) {
    console.log(`WARNING: Unhandled Event: ${packet.data}`);

  }
  socket._onevent.apply(socket, Array.prototype.slice.call(arguments));
};

The object socket._callbacks contains the callbacks and the keys are the names. They have a $ prepended to them, so you can trim that off the entire list by mapping substring(1) onto it. That results in a nice clean list of event names.

IMPORTANT NOTE: Normally you should not attempt to externally modify any object member starting with an underscore. Also, expect that any data in it is unstable. The underscore indicates it is for internal use in that object, class or function. Though this object is not stable, it should be up to date enough for us to use it, and we aren't modifying it directly.

The event name is stored in the first entry under packet.data. Just check to see if it is in the list, and raise the alarm if it is not. Now when you send an event from the server the client does not know it will note it in the browser console.

Now you need to save the unhandled messages in a buffer, to play back once the handlers are available again. So to expand on our client-side code from before...

// Save a copy of the onevent function
socket._onevent = socket.onevent;

// Make buffer and configure buffer timings
socket._packetBuffer = [];
socket._packetBufferWaitTime = 1000; // in milliseconds
socket._packetBufferPopDelay = 50;   // in milliseconds

function isPacketUnhandled(packet) {
  return !Object.keys(socket._callbacks).map(x => x.substr(1)).includes(packet.data[0]);
}

// Define the function that will process the buffer
socket._packetBufferHandler = function(packet) {
  if( isPacketUnhandled(packet) ) {
    // packet can't be processed yet, restart wait cycle
    socket._packetBuffer.push(packet);
    console.log(`packet handling not completed, retrying`)
    setTimeout(socket._packetBufferHandler, socket._packetBufferWaitTime, socket._packetBuffer.pop());
  }
  else {
    // packet can be processed now, start going through buffer
    socket._onevent.apply(socket, Array.prototype.slice.call(arguments));
    if(socket._packetBuffer.length > 0) {
      setTimeout(socket._packetBufferHandler,socket._packetBufferPopDelay(), socket._packetBuffer.pop());
    }
    else {
      console.log(`all packets in buffer processed`)
      socket._packetsWaiting = false;
    }
  }
}

// Replace the onevent function with a handler that captures all messages
socket.onevent = function (packet) {
  // Compare the list of callbacks to the incoming event name
  if( isPacketUnhandled(packet) ) {
    console.log(`WARNING: Unhandled Event: ${packet.data}`);
    socket._packetBuffer.push(packet);
    if(!socket._packetsWaiting) {
      socket._packetsWaiting = true;
      setTimeout(socket._packetBufferHandler, socket._packetBufferWaitTime, socket._packetBuffer.pop());
    }
  }
  socket._onevent.apply(socket, Array.prototype.slice.call(arguments));
};

Here the unhandled packets get pushed into the buffer and a timer is set running. Once the given amount of time has passed, if starts checking to see if the handlers for each item are ready. Each one is handled until all are exhausted or a handler is missing, which trigger another wait.

This can and will stack up unhandled calls until you blow out the client's allotted memory, so make sure that those handlers DO get loaded in a reasonable time span. And take care not to send it anything that will never get handled, because it will keep trying forever.

I tested it with really long strings and it was able to push them through, so what they are calling 'packet' is probably not a standard packet.

Tested with SocketIO version 2.2.0 on Chrome.