Expecting exactly one acknowledgment when broadcasting with timeout

[giovanni-bertoncelli]

I was wondering if there is any way to broadcast an event with a timeout and not awaiting all acknowledgments but only the first one (or the first N acks) in order to proceed.

I've seen this API

io.timeout(1000).emit('event', (errors, acks) => {
 // .. proceed
})

but I guess that, in this case, acks contains the acks of all the clients that replied before the timeout (so I have also to wait for the timeout to complete...)

[darrachequesne]

Hi! No, this is not currently possible, the server waits for all clients before calling the callback method.

I guess we could indeed provide a way to iterate over the acks as they come, maybe something like this:

try {
  for await (const ack of io.timeout(1000).emitWithAck("event")) {
    console.log(ack);
  }
} catch (e) {
  // timeout
}

[darrachequesne]

I guess you can use fetchSockets(), and then emit to each socket:

const sockets = await io.fetchSockets();

for (const socket of sockets) {
  socket.timeout(1000).emit("event", (err, response) => {
    // ...
  });
}

It's not optimal though, as the same packet is emitted multiple times.

[giovanni-bertoncelli]

Okay, thank you

[darrachequesne]

Feature request: #5136

[giovanni-bertoncelli]

For anyone interested, here the full solution:

const sockets = await io.fetchSockets();
const emissionPromises = sockets.map(socket => {
  return new Promise((res) => {
     socket.timeout(1000).emit((e, response) => {
       if (e) {
          return res('timeout');
       }

       if (!isValid(response)) {
          // log and ignore invalid payloads
          return;
       }
        
      return res(response);
    });
  });
});

// wait for first promise to resolve and ensure a timeout resolution in case all the responses are invalid
const response = await Promise.race(
   emissionPromises.concat(new Promise(res => setTimeout(() => res('timeout'), 1000)))
);

[giovanni-bertoncelli]

@darrachequesne is there any wait to cancel the timers in socket.timeout() in order to not call any callback when I do not need the results anymore?