How to use the sqs-consumer.create function in sqs-consumer

To help you get started, we’ve selected a few sqs-consumer examples, based on popular ways it is used in public projects.

Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.

github blockchainbox / blockchainbox-core / schedulers / aws / sqsEventConsumer.js View on Github external
apiVersion: '2012-11-05',
    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
    region: process.env.AWS_REGION
});

const addEvent = async (id, eventId, data) => {
  try {
    const body = await eventElasticSearch.update(id, eventId, data);
    console.log("[EXPLORER EVENT CREATE]", body);
  } catch (err) {
    console.log("[EXPLORER EVENT ERROR]", err);
  }
}
 
var consumer = Consumer.create({
	queueUrl: process.env.AWS_EVENT_QUEUE_URL,
  	handleMessage: function (message, done) {
  		// 參考: https://github.com/ethereum/wiki/wiki/JavaScript-API#contract-allevents
  		// update by contractId
		var data = JSON.parse(message.Body);
		done();
  		contract.read(data.contractId).then(function(contractResult) {
			if (contractResult.rowCount > 0) {
				var contractResultData = contractResult.rows[0];
				var contractABI = JSON.parse(contractResultData.abi);
				var contractAddress = contractResultData.address;
				var contractInstance = web3.eth.contract(contractABI).at(contractAddress);
				contractEvent.readByContractId(data.contractId).then(function(contractEventResult) {
					if (contractEventResult.rowCount > 0) {
						var eventArray = {};
						contractEventResult.rows.forEach(function(contractEventResultData){
github rgraciano / echo-sonos / echo-sqs-proxy / server.js View on Github external
sqsServer.createQueue({QueueName: "SQS-Proxy-Server"}, function(err, data) {
   				if (err) console.log(err, err.stack); // an error occurred
   				else {
					serverUrl= data.QueueUrl;           // successful response

					var app = Consumer.create({
  						region:   settings.region,
  						queueUrl: clientUrl,
  						handleMessage: function (message, done) {
    						if (message.MessageId != prevId) {
								var url = "http://" + settings.host + ":" + settings.port + message.Body;
console.log("=>" + url);
								prevId = message.MessageId;
								request(url, function (error, response, body) {
  									if (!error) {
    									console.log(body) // Show the HTML for the Google homepage.
		    							sqsServer.sendMessage(
		    								{
	  											MessageBody: body,
  												QueueUrl: serverUrl
		    								}, 
		    								function(err, data) {
github blockchainbox / blockchainbox-core / schedulers / aws / sqsWebhookConsumer.js View on Github external
var webhookData = require('../../models/postgres/webhookData.js');
var transactionData = require('../../models/postgres/transactionData.js');
var contract = require('../../models/postgres/contract.js');
var contractFunction = require('../../models/postgres/contractFunction.js');
var contractEvent = require('../../models/postgres/contractEvent.js');
var eventData = require('../../models/postgres/eventData.js');
var requestHelper = require('../../helpers/requestHelper.js');
 
AWS.config.update({
    apiVersion: '2012-11-05',
    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
    region: process.env.AWS_REGION
});
 
var consumer = Consumer.create({
	queueUrl: process.env.AWS_WEBHOOK_QUEUE_URL,
	handleMessage: function (message, done) {
    var data = JSON.parse(message.Body);
    console.log('[WEBHOOK] receive data: ', data);
    var transactionHash = data.transactionHash;
    // send by contractFunctionId
    if (data.contractFunctionId) {
      transactionData.readByTransactionHash(transactionHash).then(function(result) {
        result.rows.forEach(function(transactionDataDetail) {
          webhookData.readByContractFunctionId(data.contractFunctionId).then(function(webhookDataResult) {
            if (webhookDataResult.rowCount > 0) {
              webhookDataResult.rows.forEach(function(item){
                console.log('[CONTRACT FUNCTION WEBHOOK] url: ' + item.url + ", data: " + JSON.stringify(transactionDataDetail, null, 2));
                requestHelper.post(item.url, transactionDataDetail);
              });
            }
github blockchainbox / blockchainbox-core / schedulers / aws / sqsContractConsumer.js View on Github external
console.log("[EXPLORER CONTRACT CREATE]", body);
  } catch (err) {
    console.log("[EXPLORER CONTRACT ERROR]", err);
  }
}

const addAddress = async (id, data) => {
  try {
    const body = await addressElasticSearch.update(id, data);
    console.log("[EXPLORER ADDRESS CREATE]", body);
  } catch (err) {
    console.log("[EXPLORER ADDRESS ERROR]", err);
  }
}
 
var consumer = Consumer.create({
  queueUrl: process.env.AWS_CONTRACT_QUEUE_URL,
  handleMessage: function (message, done) {
    var data = JSON.parse(message.Body);
    done();
    contract.read(data.contractId).then(function(result){
      if (result.rowCount > 0) {
        var contractAbi = JSON.parse(result.rows[0].abi);
        var contractInstance = web3.eth.contract(contractAbi);
        var contractByteCode = '0x' + result.rows[0].bytecode;
        var gasEstimate = web3.eth.estimateGas({data: contractByteCode});
        web3.personal.unlockAccount(web3.eth.coinbase, process.env.COINBASE_PASSWORD, 1000)
        contractInstance.new({
          from: web3.eth.coinbase,
          data: contractByteCode,  // TODO need confirm why this need '0x', and check contract is availble for use
          gas: gasEstimate
        }, function(err, instance){
github Circle-gg / thunder-mail / services / consumer / consumer.js View on Github external
function createConsumer(region, accessKeyId, secretAccessKey, queueUrl) {
    // Create a consumer that processes email feedback notifications from an SQS queue
    return Consumer.create({
        queueUrl,
        batchSize: 10,
        handleMessage: receiveMessageCallback,
        sqs: new AWS.SQS({ accessKeyId, secretAccessKey, region })
    });
}
github finanzcheck / sqs-insight / lib / QueueMessageDispatcher.js View on Github external
QueueMessageDispatcher.prototype.addConsumer = function (endpoint) {
    var that = this;

    AWS.config.update({
        region: endpoint.region,
        accessKeyId: endpoint.key,
        secretAccessKey: endpoint.secretKey
    });

    var consumer = Consumer.create({
        sqs: new AWS.SQS(),
        region: endpoint.region,
        queueUrl: endpoint.url,
        batchSize: 1,
        visibilityTimeout: 10,
        waitTimeSeconds: 20,

        handleMessage: function (message, done) {
            that.eventEmitter.emit('queue-message', endpoint, message);
            done();
        }
    });

    consumer.on('error', function (err) {
        that.eventEmitter.emit('queue-error', endpoint, err);
    });
github blockchainbox / blockchainbox-core / schedulers / aws / sqsTransactionConsumer.js View on Github external
var AWS = require('aws-sdk');
var Web3 = require('web3');
var contractController = require('../../controllers/contractController.js');
var eventListener = require('../../helpers/eventListenerHelper.js');
var web3 = new Web3();

web3.setProvider(new web3.providers.HttpProvider(process.env.ENODE_BASE || 'http://localhost:8545'));
 
AWS.config.update({
    apiVersion: '2012-11-05',
    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
    region: process.env.AWS_REGION
});
 
var consumer = Consumer.create({
	queueUrl: process.env.AWS_TRANSACTION_QUEUE_URL,
	handleMessage: function (message, done) {
    console.log('[TRANSACTION QUEUE]: ', message.body);
    web3.personal.unlockAccount(web3.eth.coinbase, process.env.COINBASE_PASSWORD, 1000)
		var data = JSON.parse(message.Body);
		var entity = {
			"contractId": data.contractId,
			"contractFunctionId": data.contractFunctionId,
			"data": data.data,
			"txHash": data.txHash
		};
		contractController.setContractFunctionData(entity);
		done();
	},
	sqs: new AWS.SQS()
});
github blockchainbox / blockchainbox-core / schedulers / aws / sqsTransactionReceiptConsumer.js View on Github external
console.log("[EXPLORER TRANSACTION CREATE]", body);
  } catch (err) {
    console.log("[EXPLORER TRANSACTION ERROR]", err);
  }
}

const addAddress = async (id, transactionHash, data) => {
  try {
    const body = await addressElasticSearch.update(id, transactionHash, data);
    console.log("[EXPLORER ADDRESS CREATE]", body);
  } catch (err) {
    console.log("[EXPLORER ADDRESS ERROR]", err);
  }
}
 
var consumer = Consumer.create({
    queueUrl: process.env.AWS_TRANSACTION_RECEIPT_QUEUE_URL,
    handleMessage: function (message, done) {
        var data = JSON.parse(message.Body);
        console.log('[TRANSACTION RECEIPT] transactionHash: ' + data.transactionHash);
        var eventListener = new EventListenerHelper();
        eventListener.filterWatch(data.transactionHash, function(transactionInfo, transactionReceiptInfo, blockInfo) {
            console.log('[TRANSACTION RECEIPT] transaction info: ', transactionInfo);
            console.log('[TRANSACTION RECEIPT] transaction receipt info: ', transactionReceiptInfo);
            console.log('[TRANSACTION RECEIPT] block info: ', blockInfo);
            var txStatus = transactionData.CONFIRMED;
            if (transactionInfo.gas == transactionReceiptInfo.gasUsed) {
                txStatus = transactionData.FAILED;
            }

            var entity = {
                "transactionHash": data.transactionHash,
github zotoio / github-task-manager / src / serverless / gtmGithubResults / gtmGithubResults.js View on Github external
let awsOptions = {
        queueUrl: process.env.SQS_RESULTS_QUEUE_URL,
        waitTimeSeconds: 10,
        handleMessage: githubUtils.handleEventTaskResult
    };

    if (process.env.AWS_PROXY) {
        AWS.config.update({
            httpOptions: {
                agent: proxy(process.env.AWS_PROXY)
            }
        });
    }
    awsOptions.sqs = new AWS.SQS();

    return consumer.create(awsOptions);
}

sqs-consumer

Build SQS-based Node applications without the boilerplate

Apache-2.0
Latest version published 25 days ago

Package Health Score

92 / 100
Full package analysis