Question

So I’ve read some articles about scaling Socket.IO. For various reasons I don’t want to use built-in Socket.IO scaling mechanism (mostly it seems to be inefficient, since it publishes a lot more stuff to Redis then required from my point of view).

So I’ve came up with this simple idea:

Each Socket.IO server creates Redis pub/sub/store clients, connects to Redis and subscribes to a channel. Now, when I want to broadcast data I just publish it to Redis and all other Socket.IO servers get it and push it to users.

There is a problem, though (which I think is also a problem for Socket.IO built-in mechanism). Let’s say I want to know the number of all connected users. There are at least two ways of doing that:

1. Server A publishes give_me_clients to Redis. Then each Socket.IO server counts connections and publishes number_of_clients. Server A grabs this data, combines it and sends it to the client.

2. Each server updates number_of_clients_for::ID_HERE in Redis whenever user connects/disconnects to the server. Then Server A just fetches data and combines it. Might be more efficient.

There are problems with these solutions though:

1. Server A is not aware of other servers. Therefore he does not know when he should stop listening to number_of_clients. One could fix it with making Server A aware of other servers: whenever a server connects to Redis he publishes new_server (Server A grabs the data and stores it in memory). But what to do, when Redis – Socket.IO connection breaks? Is there a way for Redis to notify clients that one of the client disconnected?

2. Actually the same as above. When a Socket.IO server crashes how to clear number_of_clients data?

So the real question is: can Redis notify (publish to chanel) clients that the connection with one of them has just ended??

Answer 1

After a lot of testing it seems, that Redis does not have such functionality. Also I’ve found out, that scaling Socket.IO is really a pain.

So I’ve switched from Socket.IO to WS (see this link). It is low level (but perfect for my use) and it only supports WebSockets (in all major versions). But then again I only want to support WebSockets and FlashSocket (which I have to imlement manually, but that’s fine).

The advantage is that I can easily create cluster with such servers. HAProxy works with such servers almost out of the box (some minor tuning). Servers can easily communicate on a local net (with UDP or central TCP server if the cluster is big).

The disadvantage is that one have to manually implement some cool features like heartbeats, broadcasting, rooms, etc. Also you want have long-polling fallback, but that’s fine in my case. Scaling is still more important, imho.