Node.js 队列长度<；时Azure服务总线中的出列请求；10经常返回空值_Node.js_Azure_Queue_Azure Servicebus Queues

Node.js 队列长度<；时Azure服务总线中的出列请求；10经常返回空值

node.js azure

Node.js 队列长度<；时Azure服务总线中的出列请求；10经常返回空值,node.js,azure,queue,azure-servicebus-queues,Node.js,Azure,Queue,Azure Servicebus Queues,我一直在NodeJS中试验Azure服务总线队列。我根据文档中的代码示例构建了sender.js和listener.js。建立一个队列很好。在消息长度达到10之前，退出队列和从队列中删除消息都可以正常工作。此时，出列请求返回空消息的次数约为5次中的4次。如果我继续循环出列请求，最终它将出列并删除最后10条消息。但是，这似乎效率很低。还有其他人遇到过这个问题吗 listener.js var azure = require('azure'); var async = require("async"

我一直在NodeJS中试验Azure服务总线队列。我根据文档中的代码示例构建了sender.js和listener.js。建立一个队列很好。在消息长度达到10之前，退出队列和从队列中删除消息都可以正常工作。此时，出列请求返回空消息的次数约为5次中的4次。如果我继续循环出列请求，最终它将出列并删除最后10条消息。但是，这似乎效率很低。还有其他人遇到过这个问题吗

listener.js

var azure = require('azure');
var async = require("async");

var connectionString = process.env.CONNECTION_STRING || "Endpoint=sb://endpoint"; // dev

console.log(process.env.CONNECTION_STRING);

var serviceBusService = azure.createServiceBusService(connectionString);
// var serviceBusService = azure.createServiceBusService();

exports.createQueue = function (req,res) {

    var body = req.body;

    serviceBusService.createQueueIfNotExists(body.queueName, function(error){
        console.log(error);
        if(!error){
            // Queue exists
            return res.send(200);
        } else {
            return res.send(500, error);   
        }
    });
};

exports.sendMessageToQueue = function (req, res) {
    var body = req.body;

    var message = {
        body: 'Test message',
        customProperties: {
            testproperty: 'TestValue'
        }};

    serviceBusService.sendQueueMessage(body.queueName, message, function(error){
        if(!error){
            // message sent
            return res.send(200);
        } else {
            return res.send(500, error);   
        }
    });
}

exports.receiveMessageFromQueue = function (req, res) {
    var body = req.body;

    serviceBusService.receiveQueueMessage(body.queueName, function(error, receivedMessage){
        if(!error){
            console.log(receivedMessage);

            // Message received and deleted
            return res.send(200,receivedMessage);
        }  else {
            return res.send(500, error);   
        }
    });
}

function _receiveMessageFromQueue(queueName,delayTimeIfQueueIsEmpty,callback) {
    serviceBusService.receiveQueueMessage(queueName, function(error, receivedMessage){
        console.log(error, receivedMessage);
        // console.log(error);
        if (error == 'No messages to receive') {
            // call the rest of the code and have it execute after 30 seconds
            setTimeout(function() {
                callback(receivedMessage);
            }, delayTimeIfQueueIsEmpty);
        } else {
            // callback immediately
            callback(receivedMessage);
        }
    });
}

function _sendQueueMessage(queueName,message,callback) {
    serviceBusService.sendQueueMessage(queueName, message, function(error){
        console.log(error);
        callback();
    });
}

function listenMessageQueue(concurrency,delayTimeIfQueueIsEmpty,queueName) {

    var taskHandler = function(task, done) {
        _receiveMessageFromQueue(task.queueName, delayTimeIfQueueIsEmpty, function(message) {
            if (message) {
                console.log('hello ' + message.body);
            }

            myQueue.push({ id: task.id + 1, queueName: queueName, url: "http://localhost/get-person/" + task.id + 1});

            done();
        });
      };

    var queueSize = concurrency;

    var myQueue = async.queue(taskHandler, queueSize);

    myQueue.drain = function() {
        console.log("All the work has been done.");
    }

    for(var i = 0; i < concurrency; i++) {
        myQueue.push({ id: i, queueName: queueName, url: "http://localhost/get-person/"+i });
    }

}

delayTimeIfQueueIsEmpty = 30000; // 30s
concurrency = 2;
queueName = "jobs";
// listen and dequeue message from azure message bus
listenMessageQueue(concurrency,delayTimeIfQueueIsEmpty,queueName);

var azure=require（'azure'）；
var async=require（“异步”）；
var connectionString=process.env.CONNECTION_STRING | | |“Endpoint=sb://Endpoint”//发展
console.log（process.env.CONNECTION\u字符串）；
var serviceBusService=azure.createServiceBusService（connectionString）；
//var serviceBusService=azure.createServiceBusService（）；
exports.createQueue=函数（req，res）{
var body=请求body；
serviceBusService.createQueueIfNotExists（body.queueName，函数（错误）{
console.log（错误）；
如果（！错误）{
//队列存在
返回res.send（200）；
}否则{
返回res.send（500，错误）；
}
});
};
exports.sendMessageToQueue=函数（req，res）{
var body=请求body；
var消息={
正文：“测试消息”，
自定义属性：{
testproperty:'TestValue'
}};
serviceBusService.sendQueueMessage（body.queueName、消息、函数）（错误）{
如果（！错误）{
//发送的消息
返回res.send（200）；
}否则{
返回res.send（500，错误）；
}
});
}
exports.receiveMessageFromQueue=函数（req，res）{
var body=请求body；
serviceBusService.receiveQueueMessage（body.queueName，函数）（错误，receivedMessage）{
如果（！错误）{
console.log（receivedMessage）；
//收到和删除的邮件
返回res.send（200，receivedMessage）；
}否则{
返回res.send（500，错误）；
}
});
}
函数_receiveMessageFromQueue（queueName、delayTimeIfQueueIsEmpty、callback）{
serviceBusService.receiveQueueMessage（队列名称，函数（错误，receivedMessage）{
console.log（错误，receivedMessage）；
//console.log（错误）；
如果（错误=='没有要接收的消息'）{
//调用其余代码，并在30秒后执行
setTimeout（函数（）{
回调（receivedMessage）；
}，delayTimeIfQueueIsEmpty）；
}否则{
//马上回电话
回调（receivedMessage）；
}
});
}
函数_sendQueueMessage（队列名称、消息、回调）{
serviceBusService.sendQueueMessage（队列名称、消息、函数）（错误）{
console.log（错误）；
回调（）；
});
}
函数listenMessageQueue（并发、delayTimeIfQueueIsEmpty、queueName）{
var taskHandler=函数（任务，完成）{
_receiveMessageFromQueue（task.queueName、delayTimeIfQueueIsEmpty、函数（message）{
如果（信息）{
log（'hello'+message.body）；
}
myQueue.push（{id:task.id+1，queueName:queueName，url:）http://localhost/get-person/“+task.id+1}）；
完成（）；
});
};
var queueSize=并发性；
var myQueue=async.queue（taskHandler，queueSize）；
myQueue.drain=函数（）{
log（“所有的工作都完成了。”）；
}
for（var i=0；i


sender.js
var azure = require('azure');
var async = require("async");

var connectionString = process.env.CONNECTION_STRING || "Endpoint=sb://endpoint";

console.log(process.env.CONNECTION_STRING);

var serviceBusService = azure.createServiceBusService(connectionString);

exports.createQueue = function (req,res) {

    var body = req.body;

    serviceBusService.createQueueIfNotExists(body.queueName, function(error){
        console.log(error);
        if(!error){
            // Queue exists
            return res.send(200);
        } else {
            return res.send(500, error);   
        }
    });
};

exports.sendMessageToQueue = function (req, res) {
    var body = req.body;

    var message = {
        body: 'Test message',
        customProperties: {
            testproperty: 'TestValue'
        }};

    serviceBusService.sendQueueMessage(body.queueName, message, function(error){
        if(!error){
            // message sent
            return res.send(200);
        } else {
            return res.send(500, error);   
        }
    });
}

exports.receiveMessageFromQueue = function (req, res) {
    var body = req.body;

    serviceBusService.receiveQueueMessage(body.queueName, function(error, receivedMessage){
        if(!error){
            console.log(receivedMessage);

            // Message received and deleted
            return res.send(200,receivedMessage);
        }  else {
            return res.send(500, error);   
        }
    });
}

function _receiveMessageFromQueue(queueName,delayTimeIfQueueIsEmpty,callback) {
    serviceBusService.receiveQueueMessage(queueName, function(error, receivedMessage){
        console.log(error, receivedMessage);
        // console.log(error);
        if (error == 'No messages to receive') {
            // call the rest of the code and have it execute after 30 seconds
            setTimeout(function() {
                callback(receivedMessage);
            }, delayTimeIfQueueIsEmpty);
        } else {
            // callback immediately
            callback(receivedMessage);
        }
    });
}

function _sendQueueMessage(queueName,message,callback) {
    serviceBusService.sendQueueMessage(queueName, message, function(error){
        console.log(error);
        callback();
    });
}

function listenMessageQueue(concurrency,delayTimeIfQueueIsEmpty,queueName) {

    var taskHandler = function(task, done) {
        _receiveMessageFromQueue(task.queueName, delayTimeIfQueueIsEmpty, function(message) {
            if (message) {
                console.log('hello ' + message.body);
            }

            myQueue.push({ id: task.id + 1, queueName: queueName, url: "http://localhost/get-person/" + task.id + 1});

            done();
        });
      };

    var queueSize = concurrency;

    var myQueue = async.queue(taskHandler, queueSize);

    myQueue.drain = function() {
        console.log("All the work has been done.");
    }

    for(var i = 0; i < concurrency; i++) {
        myQueue.push({ id: i, queueName: queueName, url: "http://localhost/get-person/"+i });
    }

}

function pushMessageQueue(concurrency,queueName) {

    var taskHandler = function(task, done) {

        var message = {
            body: String(task.id),
            customProperties: {
                url: task.url
            }};

        _sendQueueMessage(task.queueName, message, function() {
            console.log('hello ' + task.id);
            myQueue.push({ id: task.id + 1, queueName: queueName, url: "http://localhost/get-person/" + task.id + 1});
            done();
        });
      };

    var queueSize = concurrency;

    var myQueue = async.queue(taskHandler, queueSize);

    myQueue.drain = function() {
        console.log("All the work has been done.");
    }

    for(var i = 0; i < concurrency; i++) {
        myQueue.push({ id: i, queueName: queueName, url: "http://localhost/get-person/"+i });
    }

}

concurrency = 2;
queueName = "jobs";
pushMessageQueue(concurrency,queueName); // push message to queue for testing: 100 messages per call

var azure=require（'azure'）；
var async=require（“异步”）；
var connectionString=process.env.CONNECTION_STRING | |“Endpoint=sb://Endpoint”；
console.log（process.env.CONNECTION\u字符串）；
var serviceBusService=azure.createServiceBusService（connectionString）；
exports.createQueue=函数（req，res）{
var body=请求body；
serviceBusService.createQueueIfNotExists（body.queueName，函数（错误）{
console.log（错误）；
如果（！错误）{
//队列存在
返回res.send（200）；
}否则{
返回res.send（500，错误）；
}
});
};
exports.sendMessageToQueue=函数（req，res）{
var body=请求body；
var消息={
正文：“测试消息”，
自定义属性：{
testproperty:'TestValue'
}};
serviceBusService.sendQueueMessage（body.queueName、消息、函数）（错误）{
如果（！错误）{
//发送的消息
返回res.send（200）；
}否则{
返回res.send（500，错误）；
}
});
}
exports.receiveMessageFromQueue=函数（req，res）{
var body=请求body；
serviceBusService.receiveQueueMessage（body.queueName，函数）（错误，receivedMessage）{
如果（！错误）{
console.log（receivedMessage）；
//收到和删除的邮件
返回res.send（200，receivedMessage）；
}否则{
返回res.send（500，错误）；
}
});
}
函数_receiveMessageFromQueue（queueName、delayTimeIfQueueIsEmpty、callback）{
serviceBusService.receiveQueueMessage（队列名称，函数（错误，receivedMessage）{
console.log（错误，receivedMessage）；
//console.log（错误）；
如果（错误=='没有要接收的消息'）{
//调用其余代码，并在30秒后执行
setTimeout（函数（）{
回调（receivedMessage）；
}，delayTimeIfQueueIsEmpty）；
}否则{
//马上回电话