Steuern Sie die Async-Schleife

Question

Ich habe zwei verschiedene Node.js-Programme.

Einer ist ein Express.js Server (PROGRAM1), der die Benutzeroberfläche und RESTful APIs bereitstellen soll.

Der andere ist ein Crawler (PROGRAM2), der Artikel weiterlesen, aus dem Internet herunterladen und alles in der Datenbank speichern. Übrigens verwende ich die Array.prototype.reduce() und Promise, um die Dateien zu iterieren und I/Os nacheinander zu behandeln.

Eine Sache, die ich hier tun möchte, ist, den Fortschritt des Crawlers (PROGRAM2) von der PROGRAM1 zu überwachen und zu steuern.

Aber ich fand es sehr kompliziert.

// Control the loop by this `flag`, the value can be assigned from outside 
var flag = "IDLE"; 
// The outside can read this `index`, and monitor the progress 
var current_index = -1; 
var PAGE_SIZE = 100; 
function handleBatch(index){ 
    var defer = q.defer(); 
    // Mongoose statement to find documents... 
    Book.find() 
     .skip(index*PAGE_SIZE).limit(PAGE_SIZE).then(function(books){ 
      var finished = 0; 
      for(var i=0; i<books.length; i++){ 
       var book = books[i]; 
       downloadInfo(book).then(function(bookInfo){ 
        if(flag === "STOP") 
         defer.reject(new Error("The loop should stop!")); 
        //store the info... 
        finished ++; 
        if(finished === PAGE_SIZE) 
        defer.resolve(); 
       }); 
      } 
     }); 
    return defer.promise; 
} 

var promiseHandler; 
function main(){ 
    while(true){ 
     if(flag === "IDLE") 
     continue; 
     else if(flag === "START"){ 
      var [0,1,2,3,4,5...,2500].reduce(function(lastPromise, nextIndex){ 
      promiseHandler = lastPromise.then(function(){ 
       currentIndex = nextIndex; 
      }); 
      }, q()); 
     }else if(flag === "STOP"){ 
      promiseHandler.then(null, function(err){ 
       flag = "IDLE";      
      }); 
     } 
    }  
} 

main() ist nur ein Beispiel (z. Eigentlich ist es ein Server, und der Zustand kann durch die Anforderungen von PROGRAM1 geändert werden). Durch Setzen der flag als STOP wird die Schleife in handleBatch() die Änderung entdecken und Exception werfen, dann wird das Programm angehalten.

Allerdings mag ich diesen Weg einfach nicht, weil er zu hässlich aussieht und den Prozess kontrolliert, indem er Fehler wirft. Also suche ich nach einer besseren Möglichkeit, den Loop zu kontrollieren und zu überwachen. Irgendeine Idee?

Answer 1

Sie sollten in der Dokumentation für node.js 'process suchen. Und um Ihre Frage zum Beenden der Ausführung zu beantworten, hier ->

process.exit (0);

Nur als Tipp: Steuern Sie Ihr Programm nicht mit einer Schleife. Es ist schlecht.

Answer 2

Mit dem Klang davon sind Sie nach einer Möglichkeit, Interprozesskommunikation in Knoten js zu implementieren. Dies ist ein weitläufiges Programmierthema, das weit über den Knoten js hinausgeht. Es gibt viele Muster und Mittel, um dies zu erreichen, aber einer meiner Favoriten ist die Verwendung einer Nachrichtenwarteschlange, um die beiden Prozesse lose zu koppeln.

Auf Knoten js haben wir Dinge wie Redis und node-redis, die verwendet werden können, um ein Publish-Subscribe-Muster zu implementieren. Natürlich gibt es viele Messaging-Bibliotheken, die auch funktionieren würden.

In Ihrem Fall könnte die Express-API ein "Pause" -Ereignis veröffentlichen, und der Crawler könnte dieses Ereignis abonnieren und etwas unternehmen. Deine Knoten-Apps bleiben dann asynchron (kein (wahrer) Unsinn!).