Can I use Master, and Workers process communication when also using Sticky Session?

[Trysonic]

I'm trying to use sticky-session for socket.io as a load balancer.

I use this example from the main page:

    var express = require('express'),
        cluster = require('cluster'),
        net = require('net'),
        sio = require('socket.io'),
        sio_redis = require('socket.io-redis'),
        farmhash = require('farmhash');

    var port = 3000,
        num_processes = require('os').cpus().length;

    if (cluster.isMaster) {
        // This stores our workers. We need to keep them to be able to reference
        // them based on source IP address. It's also useful for auto-restart,
        // for example.
        var workers = [];

        // Helper function for spawning worker at index 'i'.
        var spawn = function(i) {
            workers[i] = cluster.fork();

            // Optional: Restart worker on exit
            workers[i].on('exit', function(code, signal) {
                console.log('respawning worker', i);
                spawn(i);
            });
        };

        // Spawn workers.
        for (var i = 0; i < num_processes; i++) {
            spawn(i);
        }

        // Helper function for getting a worker index based on IP address.
        // This is a hot path so it should be really fast. The way it works
        // is by converting the IP address to a number by removing non numeric
      // characters, then compressing it to the number of slots we have.
        //
        // Compared against "real" hashing (from the sticky-session code) and
        // "real" IP number conversion, this function is on par in terms of
        // worker index distribution only much faster.
        var worker_index = function(ip, len) {
            return farmhash.fingerprint32(ip) % len; // Farmhash is the fastest and works with IPv6, too
        };

        // Create the outside facing server listening on our port.
        var server = net.createServer({ pauseOnConnect: true }, function(connection) {
            // We received a connection and need to pass it to the appropriate
            // worker. Get the worker for this connection's source IP and pass
            // it the connection.
            var worker = workers[worker_index(connection.remoteAddress, num_processes)];
            worker.send('sticky-session:connection', connection);
        }).listen(port);
    } else {
        // Note we don't use a port here because the master listens on it for us.
        var app = new express();

        // Here you might use middleware, attach routes, etc.

        // Don't expose our internal server to the outside.
        var server = app.listen(0, 'localhost'),
            io = sio(server);

        // Tell Socket.IO to use the redis adapter. By default, the redis
        // server is assumed to be on localhost:6379. You don't have to
        // specify them explicitly unless you want to change them.
        io.adapter(sio_redis({ host: 'localhost', port: 6379 }));

        // Here you might use Socket.IO middleware for authorization etc.

        // Listen to messages sent from the master. Ignore everything else.
        process.on('message', function(message, connection) {
            if (message !== 'sticky-session:connection') {
                return;
            }

            // Emulate a connection event on the server by emitting the
            // event with the connection the master sent us.
            server.emit('connection', connection);

            connection.resume();
        });
    }

My problem are these lines:

    // Listen to messages sent from the master. Ignore everything else.
    process.on('message', function(message, connection) {
        if (message !== 'sticky-session:connection') {
            return;
        }

        // Emulate a connection event on the server by emitting the
        // event with the connection the master sent us.
        server.emit('connection', connection);

        connection.resume();
    });

For my app, I need to use "process.on / process.send" communication, as well as "worker[worker_id].send" when in my Master cluster.

Is it banned to do so with sticky session? Can it break the communication?

I want to use something like that:

    process.on('message', function(message, connection) {
        if (message !== 'sticky-session:connection')
        {
            if(message.action == "calculX")
            {
                //redirect to function in this worker
            }   
            if(message.action == "calculY")
            {
                //redirect to function in this worker
            }               

            return;
        }

        // Emulate a connection event on the server by emitting the
        // event with the connection the master sent us.
        server.emit('connection', connection);

        connection.resume();
    });

Is it allowed or will it break the "connection" system?

Thanks in advance.