@incdevco/framework/lambda/queue-consumer/index.js

node.js lambda framework

var Util = require('util');

var AWS = require('aws-sdk');

AWS.config.setPromisesDependency(require('bluebird'));

var Base = require('../index');

function Lambda(config) {
  'use strict';
  
  Base.call(this, config);
  
  this.attempts = config.attempts || 1;
  this.attributeNames = config.attributeNames;
  this.maxNumberOfMessages = config.maxNumberOfMessages || 10;
  this.messageAttributeNames = config.messageAttributeNames;
  this.queueName = config.queueName;
  this.queueUrl = config.queueUrl ||  null;
  this.sqs = config.sqs || new AWS.SQS();
  this.visibilityTimeout = config.visibilityTimeout;
  this.waitTimeSeconds = config.waitTimeSeconds || 20;
  
}

Util.inherits(Lambda, Base);

Lambda.prototype.getQueueUrl = function () {
  'use strict';
  
  if (this.queueUrl) {
    
    return Promise.resolve({
      QueueUrl: this.queueUrl
    });
    
  } else {
    
    return this.sqs.getQueueUrl({
      QueueName: this.queueName
    }).promise();
    
  }
  
};

Lambda.prototype.handler = function (event, context) {
  'use strict';
  
  var attempts = 0,
    messages = 0, 
    promise = this.Promise.resolve(true), 
    self = this;
  
  this.log('original-event', JSON.stringify(event, null, 2));
  
  for (var i = this.attempts; i; i--) {
    
    promise = promise.then(function () {
      
      attempts++;
      
      return self.receiveMessages(event)
      .then(function (count) {
        
        messages += count;
        
        return true;
        
      });
      
    });
    
  }
  
  promise
  .then(function () {
    
    context.succeed({
      attempts: attempts,
      messages: messages
    });
    
  })
  .catch(function (exception) {
    
    context.fail(exception);
    
  });
  
};

Lambda.prototype.handleMessage = function (event, message) {
  'use strict';
  
  return this.Promise.resolve(message);
  
};

Lambda.prototype.receiveMessages = function (event) {
  'use strict';
  
  var count = 0, queueUrl, self = this;
  
  return this.getQueueUrl()
  .then(function (result) {
    
    queueUrl = result.QueueUrl;
    
    var params = {
      AttributeNames: self.attributNames,
      MaxNumberOfMessages: self.maxNumberOfMessages,
      MessageAttributeNames: self.messageAttributeNames,
      QueueUrl: queueUrl,
      VisibilityTimeout: self.visibilityTimeout,
      WaitTimeSeconds: self.waitTimeSeconds
    };
    
    self.console.log('sqs.receiveMessage', 'params', JSON.stringify(params, null, 2));
    
    return self.sqs.receiveMessage(params).promise();
    
  })
  .then(function (result) {
    
    var promise = self.Promise.resolve(true);
    
    if (result.Messages) {
      
      result.Messages.forEach(function (message) {
        
        promise = promise.then(function () {
          
          message = new Message(self.sqs, queueUrl, message);
            
          count++;
          
          return self.handleMessage(event, message);
          
        });
        
      });
      
    }
    
    return promise;
    
  })
  .then(function () {
    
    return count;
    
  });
  
};

function Message(sqs, queueUrl, message) {
  'use strict';
  
  this._message = message;
  
  this.attributes = message.MessageAttributes;
  this.body = message.Body;
  this.id = message.MessageId;
  this.queueUrl = queueUrl;
  this.receiptHandle = message.ReceiptHandle;
  this.sqs = sqs;
  
}

Message.prototype.delete = function () {
  'use strict';
  
  return this.sqs.deleteMessage({
    QueueUrl: this.queueUrl,
    ReceiptHandle: this.receiptHandle
  }).promise();
  
};

module.exports = Lambda;

module.exports.Message = Message;