dl/lib/queue/QueueHostPreferrer.js

DreamLab Libs

var Dns = require('dns');

var QueueHostPreferrer = function () {
    this._preferredHosts = {};
    this._resolvedHosts = {};
};

QueueHostPreferrer.prototype.setHosts = function (hosts) {
    this._preferredHosts = hosts;
    this._resolvedHosts = false;
};

/**
 * Check if class has preferred hosts enabled
 * 
 * @return {Boolean} 
 */
QueueHostPreferrer.prototype.hasPreferredHosts = function () {
    return Object.keys(this._preferredHosts).length === 0 ? false : true;
};

/**
 * Find and assign weight based on preferredHosts
 *
 * @param {object} hosts Object with hosts configration
 */
QueueHostPreferrer.prototype.parseHosts = function (hosts, callback) {
    if (Object.keys(this._preferredHosts).length === 0) {
        return callback(null, hosts);
    }

    var that = this;
    var toReturn = [];

    //resolve hosts to ip address
    this._resolvePreferredHosts(this._preferredHosts, function (err, preferred) {
        if (err) {
            return callback(err);
        }

        that._resolveSourceHosts(hosts, function (err, resolvedHosts) {
            if (err) {
                return callback(err);
            }

            var preferredKeys = Object.keys(preferred);
            for (var i = 0, hl = resolvedHosts.length; i < hl; i++) {
                toReturn.push({
                    host: resolvedHosts[i].host,
                    port: resolvedHosts[i].port,
                    weight: (preferredKeys.indexOf(resolvedHosts[i].host) > -1) ? preferred[resolvedHosts[i].host] : 0
                });
            }

            return callback(null, toReturn);
        });

    });
};

/**
 * Resolve data source hosts to ip
 * 
 * @param  {array}
 * @param  {Function}
 * @return {void}
 */
QueueHostPreferrer.prototype._resolveSourceHosts = function (hosts, callback) {
    var toReturn = [];
    var counter = 0;
    var hostsLength = hosts.length;

    var progress = function (host) {
        Dns.lookup(host.host, function (err, data) {
            counter++;
            toReturn.push({
                host: err ? host.host : data,
                port: host.port
            });

            if (counter === hostsLength) {
                callback(null, toReturn);
            }
        });
    };

    for (var i = 0; i < hostsLength; i++) {
        progress(hosts[i]);
    }
};

/**
 * Resolve hostnames to ip
 *
 * @param {Object}   hosts    Object with host:wehgit pairs
 * @param {Function} callback
 */
QueueHostPreferrer.prototype._resolvePreferredHosts = function (hosts, callback) {
    var counter = 0;
    var hostsKeys = Object.keys(hosts);
    var hostsLength = hostsKeys.length;
    var results = {};
    var that = this;

    if (this._resolvedHosts) {
        return callback(null, this._resolvedHosts);
    }

    var progress = function (host, weight) {
        Dns.lookup(host, function (err, data) {
            counter++;

            //if we cant resolve hosts to ip we leave the hostname
            if (err) {
                results[host] = weight;
            } else {
                results[data] = weight;
            }

            if (counter === hostsLength) {
                that._resolvedHosts = results;
                callback(null, results);
            }
        });
    };

    for (var i = 0; i < hostsLength; i++) {
        progress(hostsKeys[i], hosts[hostsKeys[i]]);
    }
};

module.exports.QueueHostPreferrer = QueueHostPreferrer;