CODEWITHSUNDEEP
node.jssocket.io
Zik
Zik

Reputation: 750

Socket.IO server throttling a fast client

I have a server that uses socket.io and I need a way of throttling a client that is sending the server data too quickly. The server exposes both a TCP interface and a socket.io interface - with the TCP server (from the net module) I can use socket.pause() and socket.resume(), and this effectively throttles the client. But with socket.io's socket class there are no pause() and resume() methods.

What would be the easiest way of getting feedback to a client that it is overwhelming the server and needs to slow down? I liked socket.pause() and socket.resume() because it didn't require any additional code on the client-side - backup the TCP socket and things naturally slow down. Any equivalent for socket.io?

Update: I provide an API to interact with the server (there is currently a python version which runs over TCP and a JavaScript version which uses socket.io). So I don't have any real control over what the client does. Which is why using socket.pause() and socket.resume() is so great - backing up the TCP stream slows the python client down no matter what it tries to do. I'm looking for an equivalent for a JavaScript client.

Upvotes: 4

Views: 6277

Answers (6)

Ravi Teja
Ravi Teja

Reputation: 192

simply wrap your client emitter into a function like below

let emit_live_users = throttle(function () {
    socket.emit("event", "some_data");
}, 2000);

using use a throttle function like below

function throttle(fn, threshold) {
    threshold = threshold || 250;
    var last, deferTimer;

    return function() {
        var now = +new Date, args = arguments;
        if(last && now < last + threshold) {
            clearTimeout(deferTimer);
            deferTimer = setTimeout(function() {
                last = now;
                fn.apply(this, args);
            }, threshold);
        } else {
            last = now;
            fn.apply(this, args);
        }
    }
}

Upvotes: 0

Kaan Yy
Kaan Yy

Reputation: 491

Here is a dirty way to achieve throttling. Although this is a old post; some people may benefit from it:

First register a middleware:

io.on("connection", function (socket) {

 socket.use(function (packet, next) {
    if (throttler.canBeServed(socket, packet)) {
        next();
    }
 });
 //You other code ..
});

canBeServed is a simple throttler as seen below:

function canBeServed(socket, packet) {
 if (socket.markedForDisconnect) {
     return false;
 }

 var previous = socket.lastAccess;
 var now = Date.now();
 if (previous) {
    var diff = now - previous;

    //Check diff and disconnect if needed.
    if (diff < 50) {
        socket.markedForDisconnect = true;
        setTimeout(function () {
            socket.disconnect(true);
        }, 1000);
        return false;
    }
}

socket.lastAccess = now;

return true;
}

You can use process.hrtime() instead of Date.time().

Upvotes: 4

Grant Li
Grant Li

Reputation: 973

As another suggestion, I would propose a solution like this: It is common for MySQL to get a large amount of requests which would take longer time to apply than the rate the requests coming in. The server can record the requests in a table in db assuming this action is fast enough for the rate the requests are coming in and then process the queue at a normal rate for the server to sustain. This buffer system will allow the server to run slow but still process all the requests.

But if you want something sequential, then the request callback should be verified before the client can send another request. In this case, there should be a server ready flag. If the client is sending request while the flag is still red, then there can be a message telling the client to slow down.

Upvotes: 0

Zik
Zik

Reputation: 750

With enough digging I found this:

this.manager.transports[this.id].socket.pause();

and

this.manager.transports[this.id].socket.resume();

Granted this probably won't work if the socket.io connection isn't a web sockets connection, and may break in a future update, but for now I'm going to go with it. When I get some time in the future I'll probably change it to the QUOTA_EXCEEDED solution that Pascal proposed.

Upvotes: 5

Pascal Belloncle
Pascal Belloncle

Reputation: 11389

Looks like you should slow down your clients. If one client can send too fast for your server to keep up, this is not going to go very well with 100s of clients.

One way to do this would be have the client wait for the reply for each emit before emitting anything else. This way the server can control how fast the client can send by only answering when ready for example, or only answer after a set time.

If this is not enough, when a client exceeded x requests per second, start replying with something like QUOTA_EXCEEDED error, and ignore the data they send in. This will force external developers to make their app behave as you want them to do.

Upvotes: 1

AndyD
AndyD

Reputation: 5385

If you have a callback on your server somewhere which normally sends back the response to your client, you could try and change it like this:

before:

  var respond = function (res, callback) {
    res.send(data);
  };

after

var respond = function (res, callback) {
    setTimeout(function(){
        res.send(data);
      }, 500); // or whatever delay you want.
  };

Upvotes: 1

Related Questions