NodeJS async file d'attente trop vite (Ralentissement async file d'attente de la méthode)

J'ai une requête HTTP Get et je veux analyser la réponse et l'enregistrer dans ma base de données.

Si je l'appelle d'analyse(i) independentely-je obtenir de bons résultats. Mais je suis d'appel d'analyse (le), de 1 à 2000.
J'obtiens de bons résultats, mais certaines réponses semblent se perdre et certaines réponses sont des doublons. Je ne pense pas que je comprends comment appeler des milliers de fonctions asynchrones. Je suis l'aide de la async module file d'attente de la fonction, mais jusqu'à présent, je suis toujours en manque quelques données et ont encore quelques doublons. Ce que je fais mal? Merci pour votre aide.

Ce que je suis en rampant

Mon nœud fonctions :

 function getOptions(i) {
    return {
        host: 'magicseaweed.com',
        path: '/syndicate/rss/index.php?id='+i+'&unit=uk',
        method: 'GET'
    }
};

function crawl(i){
var req = http.request(getOptions(i), function(res) {
    res.on('data', function (body) {
        parseLocation(body);
    });
});
req.end();

}

function parseLocation(body){
    parser.parseString(body, function(err, result) {
        if(result && typeof result.rss != 'undefined') {
            var locationTitle = result.rss.channel[0].title;
            var locationString = result.rss.channel[0].item[0].link[0];
            var location = new Location({
                id: locationString.split('/')[2],
                name: locationTitle
            });
            location.save();
        }
    });
  }

N = 2 //# of simultaneous tasks
var q = async.queue(function (task, callback) {
        crawl(task.url);
        callback();
}, N);


q.drain = function() {
    console.log('Crawling done.');
}

for(var i = 0; i < 100; i++){
   q.push({url: 'http://magicseaweed.com/syndicate/rss/index.php?id='+i+'&unit=uk'});
}

[EDIT] bon, après beaucoup de tests, il semble que le service que je suis ramper ne peut pas supporter autant de demande que rapide. Parce que quand je le fais chaque demande de manière séquentielle, je puisse obtenir tous les bonnes réponses.

Est-il un moyen de RALENTIR ASYNC file d'attente méthode?

Il semble que beaucoup de demandes sont défaillants maintenant... Comment puis-je assurer la demande de ne pas échouer?
Avez-vous essayez d'utiliser setTimeOut pour retarder le callback() appel dans votre file d'attente de travailleurs de la fonction? Vous pouvez ralentir l'exécution des tâches dans la file d'attente de cette façon.

OriginalL'auteur William Fortin | 2013-01-16

14

Vous devriez jeter un oeil à ce grand module, async qui simplifie async tâches de ce genre. Vous pouvez utiliser la file d'attente, exemple simple:
```
N = # of simultaneous tasks
var q = async.queue(function (task, callback) {
    somehttprequestfunction(task.url, function(){
    callback();
    } 
}, N);


q.drain = function() {
    console.log('all items have been processed');
}

for(var i = 0; i < 2000; i++){
   q.push({url:"http://somewebsite.com/"+i+"/feed/"});
}
```
Il aura une fenêtre d'actions en cours et les tâches de la salle sera disponible pour une future tâche si vous ne appeler la fonction de rappel. La différence, c'est que votre code s'ouvre maintenant 2000 connexions immidiately et, évidemment, le taux d'échec est élevé. La limiter à une valeur raisonnable, 5,10,20 (dépend du site et de la connexion) se traduira par un meilleur taux de réussite. Si la demande échoue, vous pouvez toujours essayer de nouveau, ou de pousser la tâche à un autre async file d'attente pour un autre essai. Le point clé est d'appeler de rappel() dans la file d'attente de la fonction, de sorte qu'une chambre sera disponible quand il est fait.

J'ai essayé ta solution et j'ai encore des doublons et beaucoup de réponses manquantes. J'ai mis à jour ma Question et le Code, pouvez-vous expliquer plus? Merci.
En tant que vos demandes sont simples, vous pouvez utiliser demande de module, je ne vois pas ce qui est erroné avec votre code à l'heure actuelle.
est attendre pour limiter le nombre d'éléments détachés de la file d'attente par seconde?

OriginalL'auteur Mustafa

var q = async.queue(function (task, callback) {
    crawl(task.url);
    callback();
}, N);

Vous sont de l'exécution de la tâche suivante immédiatement après le démarrage de la précédente, de cette façon, la file d'attente est tout simplement dénuée de sens. Vous devez modifier votre code comme ceci:

//first, modify your 'crawl' function to take a callback argument, and call this callback after the job is done.

//then
var q = async.queue(function (task, next/* name this argument as 'next' is more meaningful */) {
    crawl(task.url, function () {
        //after this one is done, start next one.
        next();
    });     
    //or, more simple way, crawl(task.url, next);
}, N);

OriginalL'auteur Aaron Wang

Une autre option, si vous le souhaitez. Vanilla JS sans fantaisie bibliothèques.

var incrementer = 0;
var resultsArray = [];

var myInterval = setInterval(function() {
    incrementer++
    if(incrementer == 100){
        clearInterval(myInterval)
        //when done parse results array
    }
    //make request here
    //push request result to array here

}, 500);

Appelle la fonction toutes les demi-secondes. Moyen facile de force et de synchronisation de sortie après x demandes.

OriginalL'auteur Lockless

Je sais que je suis un peu en retard sur la question, cependant voici une solution que j'ai écrit pour ralentir le nombre de demandes lors de l'essai d'une api d'extrémité, à l'aide de nœud 4 nœud ou de 5:

var fs = require('fs');
var supertest = require('supertest');
var request = supertest("http://sometesturl.com/api/test/v1/")
var Helper = require('./check.helper');
var basicAuth = Helper.basicAuth;
var options = Helper.options;
fs.readFile('test.txt', function(err, data){
var parsedItems = JSON.parse(data);
var urlparts = []
//create a queue
for (let year of range(1975, 2016)) {
for (var make in parsedItems[year]){
console.log(year, make, '/models/' + year + '/' + make)
urlparts.push({urlpart:'/models/' + year + '/' + make, year: year, make: make})
}
}
//start dequeue
waitDequeue();
//This function calls itself after the makeRequest promise completes
function waitDequeue(){
var item = urlparts.pop()
if (item){
makeRequest(item)
.then(function(){
//wait this time before next dequeue
setTimeout(function() {
waitDequeue();
}, 3000);
})
} else {
write(parsedItems)
}
}
//make a request, mutate parsedItems then resolve
function makeRequest(item){
return new Promise((resolve, reject)=>{
request
.get(item.urlpart)
.set(options.auth[0], options.auth[1])
.set(options.type[0], options.type[1])
.end(function(err, res) {
if (err) return done1(err);
console.log(res.body)
res.body.forEach(function(model){
parsedItems[item.year][item.make][model] = {}
});
resolve()
})
})
}
//write the results back to the file
function write(parsedItems){
fs.writeFile('test.txt', JSON.stringify(parsedItems, null, 4), function(err){
console.log(err)
})
}
})

OriginalL'auteur jmunsch

Un peu de retard, mais j'ai trouvé cela fonctionne!
À l'aide de async vous pouvez ralentir la file d'attente en utilisant tout l'intérieur de la tâche de gestionnaire ex:

var q = async.priorityQueue(function(task, callback) {
//your code process here for each task
//when ready to complete the task delay it by calling
async.whilst( //wait 6 seconds
function() {         
return count < 10;      
},
function(callback) {
count++;
setTimeout(function() {
callback(null, count);
}, 1000);
},
function (err, n) {
//n seconds have passed  
callback(); //callback to q handler 
}
); //whilst
} , 5);

OriginalL'auteur CodeFriendly

Vous devez vous connecter pour publier un commentaire.