dl/lib/queue/QueuePublisher.js

DreamLab Libs

var core = require('core');
var Event = core.event.Event;
var RbmqExchange = core.client.rabbitmq.RbmqExchange;

var QueueClient = require('./QueueClient').QueueClient;
var QueueMessage = require('./QueueMessage').QueueMessage;

var QueuePublisher = function() {
    QueueClient.apply(this, arguments);
    this._publishBuffer = [];
    this._publishBufferSize = 0;
};

QueuePublisher.prototype = Object.create(QueueClient.prototype);

QueuePublisher.prototype._onConnected = function () {
    this._exchangeConfig = this._credentials.getExchangeConfig();
    this._rbmqChannel = new RbmqExchange(this._rbmqConnection, this._exchangeConfig);

    QueueClient.prototype._onConnected.call(this);
};

QueuePublisher.prototype._onChannelOpened = function () {
    QueueClient.prototype._onChannelOpened.call(this);

    while (this._publishBuffer.length > 0) {
        console.info('QueuePublisher/_onConnected: Publishing queued messages');
        this.publish(this._publishBuffer.shift());
    }
};

QueuePublisher.prototype.setPublishBufferSize = function (size) {
    this._publishBufferSize = size;
};

QueuePublisher.prototype.getPublishBufferSize = function () {
    return this._publishBufferSize;
};

QueuePublisher.prototype._addToBuffer = function (msg) {
    if (this._publishBuffer.length < this.getPublishBufferSize()) {
        this._publishBuffer.push(msg);
    } else {
        var errorTxt = 'Publish buffer limit exceeded. ' +  this._publishBuffer.length + '/' +  this.getPublishBufferSize();
        var errObj = new Error('Queue buffer limit exceeded');

        errObj.code = QueuePublisher.Error.BUFFER_LIMIT_EXCEEDED;

        msg.dispatchEvent(new Event(QueueMessage.Event.REJECTED, {
            message: msg,
            error: errObj
        }));

        this.dispatchEvent(new Event(QueuePublisher.Event.MESSAGE_BUFFER_EXCEEDED, {
            message: errorTxt,
            error: errObj
        }));
    }
};

QueuePublisher.prototype.publish = function(message) {
    if (!this._rbmqChannel) {
        if (this.getPublishBufferSize()) {
            this._addToBuffer(message);
        } else {
            message.dispatchEvent(new Event(QueueMessage.Event.REJECTED, {
                message: message,
                error: new Error('Queue disconnected')
            }));
        }
        return;
    }

    if (message.isPublished()) {
        message.dispatchEvent(new Event(QueueMessage.Event.REJECTED, {
            message: message,
            error: new Error('Message has already been published before, create new one')
        }));
        return;
    }

    if (this._exchangeConfig.publish.messageSizeLimit && message.getSize() > this._exchangeConfig.publish.messageSizeLimit) {
        message.dispatchEvent(new Event(QueueMessage.Event.REJECTED, {
            message: message,
            error: new Error('Message too big. Current limit is ' + this._exchangeConfig.publish.messageSizeLimit)
        }));
        return;
    }

    message.setUserId(this._userId);

    var that = this;
    var timestamp = Date.now();

    message.addEventListener(QueueMessage.Event.PUBLISHED, function() {
        that._logger.log('publish', 'confirm.delay', Date.now() - timestamp, message.getMessageId());
    });

    message.addEventListener(QueueMessage.Event.REJECTED, function() {
        that._logger.log('publish', 'reject.delay', Date.now() - timestamp, message.getMessageId());
    });

    this._logger.log('publish', 'size.total', message.getSize(), message.getMessageId());
    this._logger.log('publish', 'size.body', message.getBodySize(), message.getMessageId());

    this._rbmqChannel.publish(message);
};

QueuePublisher.Event = {};
QueuePublisher.Event.CONNECTED = QueueClient.Event.CONNECTED;
QueuePublisher.Event.DISCONNECTED = QueueClient.Event.DISCONNECTED;
QueuePublisher.Event.MESSAGE_BUFFER_EXCEEDED = 'QueuePublisher_Event_Message_buffer_exceeded';

QueuePublisher.Error = {};
QueuePublisher.Error.BUFFER_LIMIT_EXCEEDED = -1;


exports.QueuePublisher = QueuePublisher;