How to use sqs-consumer - 10 common examples
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.
blockchainbox / blockchainbox-core / schedulers / aws / sqsEventConsumer.js View on Github 
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){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) {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);
});
}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){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 })
});
}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);
});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()
});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,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);
}var createConsumer = function(queueUrl, handler) {
var consumer = Consumer.create({
queueUrl: queueUrl,
handleMessage: handler,
sqs: sqs
});
consumer.on('error', (err) => {
logger.error("Error consuming SQS message from queue:", queueUrl);
logger.error(err);
});
consumer.on('processing_error', (err) => {
logger.error("Error processing SQS message from queue:", queueUrl);
logger.error(err);
});
consumer.on('timeout_error', (err) => {sqs-consumer
Build SQS-based Node applications without the boilerplate
