My goal is to create a social community where users are rewarded for receiving upvotes or shares on their answers. Additionally, I want to send notifications to users whenever their answers receive some interaction.
The process flow is detailed in the comments within the code snippet below. The post_EVENT function is accessible through the API and serves as the starting point for the flow.
var answerController = function(){
Emitter.call(this);
var self = this;
var continueWith = null;
var push_event = function(event, answerId, likerId, callback){
// Checking data and preparing queries batch
// Implemented this way due to mongoose limitations
var batch = Answer.collection.initializeOrderedBulkOp();
batch.find(query).upsert().updateOne(update);
batch.execute(function(err,result) {
if(err){
return callback(err);
}else{
return callback(null, result.nModified);
}
});
};
// Made available as an API call for yo/share/view
// Invokes push_event
var post_event = function(req,res, next){
// Validate incoming request data and pass it along
push_event(event,answerId, likerId, function(err, num_updated_docs){
if(err){
return errors.api_error({code: 500, message: err, res: res, next: next});
}else{
if(num_updated_docs){
// Creating calculateScore_args variable
self.emit('calculateScore',calculateScore_args);
res.status(200).send({message : 'success'}).end();
}else{
return errors.api_error({code: 401, message: 'event already exists for user', res: res, next: next});
}
}
});
};
var score = function(args){
var asyncTasks = [];
asyncTasks.push(function(cb){
// Update user's score
// Intensive CPU function (small matrix multiplication)
})
asyncTasks.push(function(cb){
// Update answer's score (user's score depends on various answers)
// Another CPU intensive task, calculates confidence interval --> score
})
async.parallel(asyncTasks, function(err, results){
self.emit('notify', notifyData);
})
};
function notify(args){
// Invoking another controller that notifies the user(GCM) and inserts notification into DB
notification.AnswerEvent(args);
}
self.on('calculateScore', score);
self.on('notify',notify);
return {
post_event : post_event
}
};
Question : I am curious whether this pattern is suitable for handling around 100-200 requests per second. Any advice on alternative patterns (like message queues) would be appreciated. Also, what is the most effective method for debugging event emitter code?
Thanks