crypto-nodes/processorConnector.js

var io = require('socket.io-client');
var moment = require('moment');

var redis = require("redis");


module.exports = function(RED) {

    function processorConnector(config) {
		var publisher  = redis.createClient('6379', process.env.REDIS_SERVER || 'node1.builder-apps.org', { password: process.env.REDIS_PASSWORD });
		
        RED.nodes.createNode(this,config);
		var node = this;

		node.conf = false;

        var mode = 'redis';

        if(mode == 'redis') {

        	var all_symbols = {};

			node.on('input', function(msg) {
				
				if(msg.payload && msg.payload.data && msg.payload.sym_from && msg.payload.sym_to) {
					var sym = msg.payload.sym_from + '/' + msg.payload.sym_to;
					publisher.publish("orderbook_" + sym, JSON.stringify(msg));
					all_symbols[sym] = true;
					//process.stdout.write(".");
				}

			});

			if(this.symbols_list_interval) { clearInterval(this.symbols_list_interval); }
			this.symbols_list_interval = setInterval(function () {
				publisher.set("orderbook_symbols", Object.keys(all_symbols).join(','));
			}, 1000);

        }
        
		var socket = io.connect(config.server, {reconnect: true});
		
		var connected = false;
		
		socket.on('connect', function(){
			
			connected = true;
			
			node.send({ payload:{socketId:node.id, status:'connected'} });
			node.status({fill:"green",shape:"dot", text:"connected"});
		});

		socket.on('disconnect', function(){
			
			connected = false;
			
			node.send({payload:{socketId:node.id, status:'disconnected'}});
			node.status({fill:'red',shape:'ring', text:'disconnected'});
		});

		socket.on('connect_error', function(err) {
			
			connected = false;
			
			if (err) {
			  node.status({fill:'red',shape:'ring',text:'disconnected'});
			  node.send({payload:{socketId:node.id, status:'disconnected'}});
			}
		});
		
		socket.on('status', function(data) {
			node.status({ fill:'green',shape:'ring',text:JSON.stringify(data) });
		});
		
		this.on('close', function(done) {
			
			connected = false;
			
			socket.disconnect();
			socket.removeAllListeners();
			node.status({});
			done();

		});
				
		node.on('input', function(msg) {
		
			if(connected) {
				
				if(msg.payload.op == 'subscribe') {

					node.conf = {
						symbols: msg.payload.symbols,
						flipped: msg.payload.config.flipped,
						exchanges: msg.payload.config.exchanges,
						lookup: {},
					}

					for(x in node.conf.symbols) {

						var sym = node.conf.symbols[x];
						var tmp = sym.split('/');

						if(node.conf.flipped.indexOf(sym) > 0) {
							
							// Should be stored inverted
							node.conf.lookup[sym] = { from: tmp[1], to: tmp[0], flip: true }

							// If its flipped, keep as is
							node.conf.lookup[tmp[1] + '/' + tmp[0]] = { from: tmp[1], to: tmp[0], flip: true }


						} else {

							// If its correct lookup, keep as is
							node.conf.lookup[sym] = { from: tmp[0], to: tmp[1] }

							// If its flipped on input, change it
							node.conf.lookup[tmp[1] + '/' + tmp[0]] = { from: tmp[0], to: tmp[1] }

						}

					}
					
					if(node.conf.exchanges) {
						for(x in node.conf.exchanges) {
							if(node.conf.exchanges[x].disabled) {
								socket.emit('process', { payload: { op: 'flush', exchange: x } });
							}
						}
					}
					
					return;

				}

				if(node.conf) {

					var sym = msg.payload.sym_from + '/' + msg.payload.sym_to;
					
					if(node.conf.lookup[sym]) {
						msg.payload.sym_from = node.conf.lookup[sym].from;
						msg.payload.sym_to = node.conf.lookup[sym].to;
					}

					if(msg.payload.exchange && node.conf.exchanges[msg.payload.exchange]) {

						var ex = node.conf.exchanges[msg.payload.exchange];

						if(!ex.disabled) {
							socket.emit('process', msg);
						} else {
							// process.stdout.write("!");
						}

					} else {
						socket.emit('process', msg);
					}

					
				} else {
					socket.emit('process', msg);
				}

			}
			
        });
		
	
    }
	
    RED.nodes.registerType("processorConnector", processorConnector);
	
}