You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
466 lines
10 KiB
466 lines
10 KiB
'use strict';
|
|
|
|
var ee2 = require('eventemitter2').EventEmitter2;
|
|
var net = require('net');
|
|
var util = require('util');
|
|
var types = require('./connectionType.js');
|
|
|
|
var kestrel = function( options ){
|
|
|
|
this._settings = {
|
|
servers: ['127.0.0.1:22133'],
|
|
connectionType: types.ROUND_ROBIN,
|
|
reconnect: false,
|
|
reconnectDelay: 200
|
|
};
|
|
this._currentConnection = 0;
|
|
this._connections = [];
|
|
this._openConnection = null;
|
|
|
|
if( options instanceof Object ){
|
|
for( var key in options ){
|
|
if( this._settings[key] !== undefined ){
|
|
this._settings[key] = options[key];
|
|
}
|
|
}
|
|
}
|
|
|
|
this._pendingSetCallback = null;
|
|
|
|
ee2.call(this);
|
|
};
|
|
|
|
util.inherits(kestrel,ee2);
|
|
|
|
//open connections to kestrel server(s)
|
|
kestrel.prototype.connect = function(){
|
|
var type = this._settings.connectionType;
|
|
|
|
if( types[type] === undefined || types[type] === null ){
|
|
throw 'Kestrel Client Connection: Argument 1 Must Be A Valid Kestrel Connection Type';
|
|
}
|
|
|
|
var parts,port,host;
|
|
|
|
switch( type ){
|
|
case types.RANDOM:
|
|
case types.ROUND_ROBIN:
|
|
for(var i in this._settings.servers){
|
|
parts = this._settings.servers[i].split(':');
|
|
port = (parts.length>1)?parts[1]:'22133';
|
|
host = parts[0];
|
|
this._connections.push( _createConnection(port,host,this) );
|
|
}
|
|
break;
|
|
case types.FAILOVER:
|
|
var rand = Math.floor( Math.random()*this._settings.servers.length );
|
|
parts = this._settings.servers[rand].split(':');
|
|
port = (parts.length>1)?parts[1]:'22133';
|
|
host = parts[0];
|
|
this._connections.push( _createConnection(port,host,this) );
|
|
break;
|
|
default:
|
|
throw 'Kestrel Client Connection: Unknown Connection Type';
|
|
}
|
|
};
|
|
|
|
function _createConnection(port, host, self){
|
|
var connection = net.connect(port,host);
|
|
|
|
connection.on('error', function(err){
|
|
self._openConnection = null;
|
|
self.emit('error', err);
|
|
if(self._settings.reconnect){
|
|
setTimeout(function(){
|
|
self.connect();
|
|
},self._settings.reconnectDelay);
|
|
}
|
|
});
|
|
|
|
connection.on('data', function(data){
|
|
_handleData(data,self);
|
|
self.emit('data', data);
|
|
});
|
|
|
|
return connection;
|
|
}
|
|
|
|
function _handleData(data, self){
|
|
|
|
|
|
if( isResponse(data,'VALUE') ){
|
|
return _handleGet(data,self);
|
|
}
|
|
|
|
data = data.toString();
|
|
|
|
if( isResponse(data,'STORED') ) {
|
|
self.emit('stored', true);
|
|
if(self._pendingSetCallback){
|
|
var callback = self._pendingSetCallback;
|
|
self._pendingSetCallback = null;
|
|
callback(null);
|
|
}
|
|
}
|
|
|
|
else if( isResponse(data,'STAT') ){
|
|
_handleStats(data,self);
|
|
}
|
|
|
|
else if( isResponse(data,'queue') ){
|
|
_handleDumpStats(data, self);
|
|
}
|
|
|
|
else if( isResponse(data,'DELETED\r\n') ){
|
|
self.emit('deleted', true);
|
|
}
|
|
|
|
else if( isResponse(data,'VERSION') ){
|
|
self.emit('version', data.split(' ')[1].replace('\r\n',''));
|
|
}
|
|
|
|
else if( isResponse(data,'Reloaded config.\r\n') ){
|
|
self.emit('reloaded', true);
|
|
}
|
|
|
|
else if( isResponse(data,'END\r\n') ){
|
|
self._openConnection = null;
|
|
self.emit('empty', null);
|
|
}
|
|
|
|
else {
|
|
console.log('unknown data from server',data, data.toString());
|
|
}
|
|
}
|
|
|
|
function isResponse(data,responseType){
|
|
var buffer = null;
|
|
|
|
if(Buffer.isBuffer(data)){
|
|
buffer = data;
|
|
} else {
|
|
buffer = new Buffer(data,'utf8');
|
|
}
|
|
return bufferStartsWithString(buffer,responseType);
|
|
}
|
|
|
|
function bufferStartsWithString(buffer,responseType){
|
|
var responseTypeAsBuffer = new Buffer(responseType,'utf8');
|
|
return bufferStartsWith(buffer,responseTypeAsBuffer);
|
|
}
|
|
|
|
function bufferStartsWith(buffer,prefixBuffer){
|
|
if(!buffer)
|
|
return false;
|
|
|
|
if( buffer.length < prefixBuffer.length){
|
|
return false;
|
|
}
|
|
|
|
for(var i = 0; i < prefixBuffer.length; i++) {
|
|
if(prefixBuffer[i] != buffer[i]){
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function _handleGet(data, self){
|
|
var msg = {};
|
|
|
|
var header = parseValueHeader(data);
|
|
|
|
msg.queue = header.queue;
|
|
msg.data = data.slice(header.dataStart,header.dataEnd);
|
|
|
|
self.emit('message', msg);
|
|
}
|
|
|
|
function parseValueHeader(data){
|
|
var endOfLineMarker = '\r\n';
|
|
var indexOfEndOfLineMarker = findEndOfLine(data,endOfLineMarker);
|
|
|
|
if(indexOfEndOfLineMarker<=0){
|
|
throw new Error('incorrect \r\n in VALUE header');
|
|
}
|
|
|
|
var headerString = data.slice(0,indexOfEndOfLineMarker).toString();
|
|
var headerParts = headerString.split(' ');
|
|
|
|
if(headerParts[0] != 'VALUE'){
|
|
throw new Error('Invalid VALUE header', headerString);
|
|
}
|
|
|
|
var dataLength = parseInt(headerParts[3],10);
|
|
var headerLength = indexOfEndOfLineMarker + endOfLineMarker.length;
|
|
|
|
return {
|
|
queue: headerParts[1],
|
|
length: dataLength,
|
|
dataStart: headerLength,
|
|
dataEnd: headerLength+dataLength
|
|
};
|
|
}
|
|
|
|
function findEndOfLine(buffer,endOfLineMarker){
|
|
var eol = new Buffer(endOfLineMarker,'utf8');
|
|
var firstEolCharacter = eol[0];
|
|
|
|
if(buffer.length < eol.length){
|
|
return;
|
|
}
|
|
|
|
for (var i = 0; i < buffer.length-eol.length; i++) {
|
|
if(buffer[i] !== firstEolCharacter){
|
|
continue;
|
|
}
|
|
|
|
var comparisonBuffer = buffer.slice(i,i+eol.length);
|
|
console.log(i,eol,comparisonBuffer);
|
|
if(bufferStartsWith(comparisonBuffer,eol)){
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
function _handleStats(data, self){
|
|
var stats = {};
|
|
|
|
var parts = data.match(/STAT ([a-zA-Z_]+) (.*?)\r\n/g);
|
|
|
|
for( var i in parts ){
|
|
var part = parts[i].split(' ');
|
|
stats[part[1]] = part[2].replace('\r\n', '');
|
|
}
|
|
|
|
self.emit('stats', stats);
|
|
}
|
|
|
|
function _handleDumpStats(data, self){
|
|
var stats = {};
|
|
|
|
var parts = data.replace('\r\n}\r\nEND','').split('}\r\n');
|
|
|
|
for( var i in parts ){
|
|
var part = parts[i].split('\r\n');
|
|
var queue = part[0].match(/[a-zA-Z_]+/g)[1];
|
|
stats[queue] = {};
|
|
for( var lcv = 1; lcv < part.length-1; ++lcv ){
|
|
var p = part[lcv].split('=');
|
|
stats[queue][ p[0].replace(/ /g,'') ] = p[1];
|
|
}
|
|
}
|
|
|
|
self.emit('dump_stats', stats);
|
|
}
|
|
|
|
|
|
kestrel.prototype._getConnection = function(){
|
|
if( this._connections.length == 1 ) {
|
|
return this._connections[0];
|
|
} else if( this._connections.length === 0 ) {
|
|
return null;
|
|
}
|
|
|
|
var connection = null;
|
|
|
|
switch(this._settings.connectionType) {
|
|
case types.RANDOM:
|
|
var rand = Math.floor( Math.random()*this._connections.length );
|
|
connection = this._connections[rand];
|
|
break;
|
|
case types.ROUND_ROBIN:
|
|
this._currentConnection += 1;
|
|
if( this._currentConnection > this._connections.length ){
|
|
this._currentConnection = 0;
|
|
}
|
|
connection = this._connections[this._currentConnection];
|
|
break;
|
|
case types.FAILOVER:
|
|
connection = this._connections[0];
|
|
break;
|
|
}
|
|
|
|
return connection;
|
|
};
|
|
|
|
kestrel.prototype.close = function(){
|
|
//close any open connections
|
|
for( var i in this._connections ){
|
|
this._connections[i].destroy();
|
|
}
|
|
};
|
|
|
|
kestrel.prototype.set = function( queue, value, lifetime, callback){
|
|
if( typeof(lifetime) === 'function' ){
|
|
callback = lifetime;
|
|
lifetime = null;
|
|
}
|
|
if( lifetime === undefined || lifetime === null ){
|
|
lifetime = 0;
|
|
}
|
|
|
|
if(this._pendingSetCallback && callback){
|
|
return callback('Cannot write again. Still waiting for previous write to be stored');
|
|
}
|
|
|
|
var command = 'SET ' + queue + ' 0 ' + lifetime + ' ';
|
|
command += value.length + '\r\n';
|
|
|
|
var connection = this._getConnection();
|
|
if( connection ){
|
|
if(callback){
|
|
this._pendingSetCallback = callback;
|
|
}
|
|
connection.write(command);
|
|
connection.write(value);
|
|
connection.write('\r\n');
|
|
} else {
|
|
if(callback){
|
|
callback('No connection');
|
|
} else {
|
|
throw new Error('No connection');
|
|
}
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
kestrel.prototype.get = function(queue, timeout){
|
|
var command = 'GET ' + queue;
|
|
|
|
timeout = parseInt(timeout,10);
|
|
if( timeout > 0 ){
|
|
command += '/t='+timeout;
|
|
}
|
|
|
|
var connection = this._getConnection();
|
|
if( connection ){
|
|
connection.write(command + '\r\n');
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
|
|
kestrel.prototype.getNextOpen = function(queue, timeout){
|
|
var command = 'GET ' + queue;
|
|
|
|
timeout = parseInt(timeout,10);
|
|
if( timeout > 0 ){
|
|
command += '/t='+timeout;
|
|
}
|
|
|
|
var connection = this._openConnection;
|
|
|
|
if(connection) {
|
|
command += '/close';
|
|
} else {
|
|
connection = this._getConnection();
|
|
this._openConnection = connection;
|
|
}
|
|
|
|
command += '/open';
|
|
|
|
if( connection ){
|
|
connection.write(command + '\r\n');
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
|
|
|
|
kestrel.prototype.delete = function(queue){
|
|
//delete given queue
|
|
var connection = this._getConnection();
|
|
if( connection ){
|
|
connection.write('DELETE ' + queue + '\r\n');
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
kestrel.prototype.flush = function(queue){
|
|
//flush given queue
|
|
var connection = this._getConnection();
|
|
if( connection ){
|
|
connection.write('FLUSH ' + queue + '\r\n');
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
kestrel.prototype.flushAll = function(){
|
|
//flush all queues
|
|
var connection = this._getConnection();
|
|
if( connection ){
|
|
connection.write('FLUSH_ALL\r\n');
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
kestrel.prototype.version = function(){
|
|
//get version of server
|
|
var connection = this._getConnection();
|
|
if( connection ){
|
|
connection.write('VERSION\r\n');
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
kestrel.prototype.shutdown = function(){
|
|
//shutdown server
|
|
var connection = this._getConnection();
|
|
if( connection ){
|
|
connection.write('SHUTDOWN\r\n');
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
kestrel.prototype.reload = function(){
|
|
//reload the server
|
|
var connection = this._getConnection();
|
|
if( connection ){
|
|
connection.write('RELOAD\r\n');
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
kestrel.prototype.stats = function(){
|
|
//get server stats
|
|
var connection = this._getConnection();
|
|
if( connection ){
|
|
connection.write('STATS\r\n');
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
kestrel.prototype.dumpStats = function(){
|
|
//dump server stats
|
|
var connection = this._getConnection();
|
|
if( connection ){
|
|
connection.write('DUMP_STATS\r\n');
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
|
|
kestrel.prototype.monitor = function(queue, seconds, maxItems){
|
|
//monitor the given queue
|
|
};
|
|
|
|
kestrel.prototype.confirm = function(queue, count){
|
|
//confirm received items
|
|
};
|
|
|
|
module.exports = kestrel;
|