nodejs push notification that subscribes to redis

Question

For logged in users only, I want to somehow notify them if they have any e.g. new notifications.

For example, say a member has sent them a private message, I want to tell the user that they have a new message to view (assuming they have not refreshed the page).

With Nodejs and redis, how would I go about doing this?

Note: I only need nodejs to send a small json to the user saying they have a new message.

The workflow is as follows that I was thinking:

    1. user is logged in, a new message is sent to them.
    2. somehow using nodejs and redis and long-polling, nodejs communicates back to the logged in users browser they have a pending message.
    3. when nodejs sends this push notification, I then call another javascript function that will call a rest service to pull down additional json with the message.

I am integrating nodejs into an existing application, so I want to keep it as simple as possible with nodejs responsible for only notifying and not doing any additional logic.

Can someone outline how I should get going with this? Should I be using redis http://redis.io/topics/pubsub somehow?
I'm not really sure how that works even after reading the page about it.

Answer 1

Here is also a really nice explanation from Flickr on how they created a highly available and scalable push notification system with NodeJS and Redis.

http://code.flickr.net/2012/12/12/highly-available-real-time-notifications/

Answer 2

If you are integrating your node service into an existing application I would rather use some sort of messaging system to communicate messages from that application to node instead of a DB, even an in-memory DB. For clarity, I will assume you can use rabbitmq. If you do need to use redis, you will just need to find a way to use its publishing instead of rabbitmq publishing and corresponding node-side subscription, but I would imagine that the overall solution would be identical.

You need the following modules:

• rabbitmq server (installation complexity about the same as for redis)
• rabbitmq library in your external application to send messages, most languages are supported
• rabit.js module for node to subscribe to messages or to communicate back to the external application
• socket.io module for node to establish real-time connection between the node server and clients

I will also assume that both your external application and your node server have access to some shared DB (which can be redis), where node client session information is stored (e.g. redis-session-store for node). This would allow to use sessionId to validate who the message is for, if the user in the session is logged in and if certain users need to be sent notifications at all (by an external app).

This is how your stack might look like (unpolished):

Define a publisher in node to notify your external application that it needs to start/stop sending messages for a given sessionId. I will assume that for a given sessionId the user information can be recovered on either side (node or external application) from the shared DB and the user can be validated (here for simplicity by checking session.authenticated_user). Also define a subscriber to listen to incoming messages for the users:

var context = require('rabbit.js').createContext();

var pub = context.socket('PUB');
var sub = context.socket('SUB');

Define a socket.io connection(s) from your node server to the clients. As soon the client's web page is (re)loaded and io.connect() is called the below code will be executed (see clinet side at the end of the answer). As a new connection is established, validate the user is logged in (meaning its credentials are in the session), register the socket handler and publish a notification to the external application to start sending messages for this sessionId. The code here assumes a page reload on login/logout (and thus new socket.io session). If this is not the case, just emit a corresponding socket.io message from the client to node and register a handler in the method below in the same way as it is done for a new connection (this is beyond the scope of this example):

var sessionStore = undefined; // out-of-scope: define redis-session-store or any other store

var cookie = require("cookie"),
    parseSignedCookie = require('connect').utils.parseSignedCookie;

// will store a map of all active sessionIds to sockets
var sockets = {};

// bind socket.io to the node http server
var io = require('socket.io').listen(httpServer);

// assumes some config object with session secrect and cookie sid
io.sockets.on("connection", function(socket) {
    if (socket.handshake.headers.cookie) {
        var cks = cookie.parse(socket.handshake.headers.cookie);
        var sessionId = parseSignedCookie(cks[config.connectSid], config.sessionSecret);

        // retrieve session from session store for sessionId
        sessionStore.get(sessionId, function(err, session) {
            // check if user of this session is logged in, 
            // define your elaborate method here
            if (!err && session.authenticated_user) { 
                // define cleanup first for the case when user leaves the page
                socket.on("disconnect", function() {
                    delete sockets[sessionId];
                    // notify external app that it should STOP publishing
                    pub.connect('user_exchange', function() {
                        pub.write(JSON.stringify({sessionId: sessionId, action: 'stop', reason: 'user disconnected'}), 'utf8');
                    });
                });

                // store client-specific socket for emits to the client
                sockets[sessionId] = socket;

                // notify external app that it should START publishing
                pub.connect('user_exchange', function() {
                    pub.write(JSON.stringify({sessionId: sessionId, action: 'start'}), 'utf8');
                });
            }
        });
    }
});

Connect subscriber to the rabbitmq exchange to catch messages and emit them to clients:

sub.connect('messages_exchange', function() {
    sub.on("readable", function() {
        // parse incoming message, we need at least sessionId
        var data = JSON.parse(sub.read());
        // get socket to emit for this sessionId
        var socket = sockets[data.sessionId];
        if (socket) {
            socket.emit("message", data.message);
        } else {
            // notify external app that it should STOP publishing
            pub.connect('user_exchange', function() {
                pub.write(JSON.stringify({sessionId: sessionId, action: 'stop', reason: 'user disconnected'}), 'utf8');
            });
            // further error handling if no socket found
        }
    });
});

Finally your client will look roughly like this (here in Jade, but that's just because I already have this whole stack along these lines):

script(src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js")
script(src="/socket.io/socket.io.js")

script(type='text/javascript').
    $(function(){
        var iosocket = io.connect();
        iosocket.on('connect', function () {
            // do whatever you like on connect (re-loading the page)

            iosocket.on('message', function(message) {
                // this is where your client finally gets the message
                // do whatever you like with your new message
            });
        });

        // if you want to communicate back to node, e.g. that user was logged in,
        // do it roughly like this
        $('#btnSend').click(function(event) {
            iosocket.send('a message back to the node server if you need one');
        });
    });