How can I avoid "Callback was already called" with async.queue? - asynchronous

Question

I'm trying to make a series of calls using async.queue, and each call has its own callback where I'm using mocha to test that an expected result was returned.
When I use a concurrency value of 1 (my NUMBER_OF_THREADS variable), this all works great. However, when I use any value greater than 1, I get errors stating, "Error: Callback was already called." For instance, If I send 10 messages, and set my NUMBER_OF_THREADS to 5, the first 5 messages will go smoothly, but then I start seeing the duplicate-callback errors around message 6 or 7 (see below). Do you know how I can avoid this error?
My test file (where async queue is defined):
var myQueue = async.queue(function(options, callback){
var counter = options.counter;
myService.sendMyMessage(options.text, counter, function(result) {
var myText = result.content.text;
console.log("Response " + myService.counter + ": " + myText);
responses.push(myText);
callback();
});
}, NUMBER_OF_THREADS);
myQueue.drain = function(){
console.log("sends completed");
for (var i = 0; i < numberOfSends; i++) {
assert.equal(myExpectedResponse,responses[i],"text doesn't match");
}
done();
};
for (var j = 1; j <= numberOfSends; j++) {
var options = {
counter: j,
text: "Hello_" + j
};
myQueue.push(options);
}
My service file (where the sends and responses happen):
myService.callback = function() {};
myService.sendMyMessage = function(message, counter, myCallback) {
console.log("Sending message " + counter + ": " + message);
var myContent = JSON.stringify(myModel.makeMessage(message));
myModel.post(content)
.then(function(res) {
myService.callback = myCallback;
});
};
myService.otherService = function(done) {
app = express();
app.use(express.bodyParser());
app.post('/myRoute/events', function(req, res, next) {
var response = {
"myId": "1234567890",
"myVersion": 1
};
res.set('Content-Type', 'application/json;charset=UTF-8');
res.send(JSON.stringify(response));
if (myService.callback)
{
myService.counter ++;
myService.callback(req.body);
//myService.callback = null;
}
else
{
console.log('the callback is NULL');
}
});
My results in the console:
Sending message 1: Hello_1
Sending message 2: Hello_2
Sending message 3: Hello_3
Sending message 4: Hello_4
Sending message 5: Hello_5
Response 1: myResponse
Sending message 6: Hello_6
Response 2: myResponse
Sending message 7: Hello_7
Response 3: myResponse
Sending message 8: Hello_8
Response 4: myResponse
Sending message 9: Hello_9
Response 5: myResponse
Sending message 10: Hello_10
Response 6: myResponse
Response 7: myResponse
Error: Callback was already called.
at myFile.js:12:34
If I un-comment the myService.callback = null line, the the first send of my last batch causes myService.callback to be null too early. For example, if I send 10 requests with NUMBER_OF_THREADS=5, requests 1 thru 5 will work great. However, once I send requests 1 thru 10, request #10 will nullify myService.callback too early. Example responses:
Sending message 1: Hello_1
Sending message 2: Hello_2
Sending message 3: Hello_3
Sending message 4: Hello_4
Sending message 5: Hello_5
Response 1: myResponse
Sending message 6: Hello_6
Response 2: myResponse
Sending message 7: Hello_7
Response 3: myResponse
Sending message 8: Hello_8
Response 4: myResponse
Sending message 9: Hello_9
Response 5: myResponse
Sending message 10: Hello_10
Response 6: myResponse
the callback is NULL
the callback is NULL
the callback is NULL
the callback is NULL

Answer 1

I've fixed this now.
In my test file, I'm simply calling sendMyMessage now; I no longer expect a callback from sendMyMessage. In drain, I wait for the total number of responses to be hit, and then loop through those responses.
var myQueue = async.queue(function(options, callback){
var counter = options.counter;
myService.sendMyMessage(options.text, counter);
callback();
}, NUMBER_OF_THREADS);
myQueue.drain = function(){
var myInterval = setInterval(function() {
if (myService.responseCounter == myNumberOfMessages) {
clearInterval(myInterval);
for (var i = 0; i < myNumberOfMessages; i++) {
assert.equal(myExpectedResponse,myService.responses[i],"error");
}
done();
}
}, 5000);
};
for (var j = 1; j <= myNumberOfMessages; j++) {
var options = {
counter: j,
text: "Hello"
};
myQueue.push(options);
}
Then, in my service file, I'm now using an array of callbacks; I'm no longer dependent on a single callback getting set or nullified. Each call to myModel.post defines a new element in this callbacks array.
myService.sendLineMessage = function(message, counter) {
myModel.post(content, sign, config, request, log, run)
.then(function(res) {
myService.callbacks[counter] = function(result) {
var myText = result.content.text;
myService.responses.push(resultText);
};
});
};
myService.otherService = function(done) {
app = express();
app.use(express.bodyParser());
app.post('/myRoute/events', function(req, res, next) {
var response = {
"myId": "1234567890",
"myVersion": 1
};
res.set('Content-Type', 'application/json;charset=UTF-8');
res.send(JSON.stringify(response));
myService.responseCounter++;
if (myService.callbacks[myService.responseCounter])
{
myService.callbacks[myService.responseCounter](req.body);
myService.callbacks[myService.responseCounter] = null;
}
else
{
console.log('the callback is NULL');
}
});