Wie wiederhole ich Anfragen, bis man erfolgreich ist, ohne im Knoten zu blockieren?

Question

Ich habe eine Funktion, die einen Parameter und einen Rückruf nimmt. Es soll eine Anfrage an eine Remote-API senden und einige Informationen basierend auf dem Parameter erhalten. Wenn es die Informationen erhält, muss es an den Rückruf gesendet werden. Jetzt schlägt die Remote-API manchmal fehl. Ich brauche meine Funktion zu versuchen, bis es gelingt, es zu tun und dann den Rückruf mit den richtigen Daten aufrufen.

Derzeit habe ich den folgenden Code innerhalb der Funktion, aber ich denke, dass Sachen wie während (!done); ist kein richtiger Knotencode.

var history = {}; 
while (true) { 
    var done = false; 
    var retry = true; 
    var req = https.request(options, function(res) { 
     var acc = ""; 
     res.on("data", function(msg) { 
      acc += msg.toString("utf-8"); 
     }); 
     res.on("end", function() { 
      done = true; 
      history = JSON.parse(acc); 
      if (history.success) { 
       retry = false; 
      } 
     }); 
    }); 
    req.end(); 
    while (!done); 
    if (!retry) break; 
} 
callback(history); 

Wie mache ich es richtig?

Answer 1

Definitiv nicht der Weg zu gehen - während (! Getan); wird in eine harte Schleife gehen und alle Ihre CPU aufnehmen.

Stattdessen könnte man so etwas tun (ungetestet und Sie können eine Back-off von einer Art implementieren möchten):

function tryUntilSuccess(options, callback) { 
    var req = https.request(options, function(res) { 
     var acc = ""; 
     res.on("data", function(msg) { 
      acc += msg.toString("utf-8"); 
     }); 
     res.on("end", function() { 
      var history = JSON.parse(acc); //<== Protect this if you may not get JSON back 
      if (history.success) { 
       callback(null, history); 
      } else { 
       tryUntilSuccess(options, callback); 
      } 
     }); 
    }); 
    req.end(); 

    req.on('error', function(e) { 
     // Decide what to do here 
     // if error is recoverable 
     //  tryUntilSuccess(options, callback); 
     // else 
     //  callback(e); 
    }); 
} 

// Use the standard callback pattern of err in first param, success in second 
tryUntilSuccess(options, function(err, resp) { 
    // Your code here... 
}); 

Answer 2

Sie könnten etwas in den folgenden Zeilen versuchen. Ich schreibe eine allgemeine Idee, Sie sollten trySomething durch Ihre HTTP-Anfrage ersetzen.

function keepTrying(onSuccess) { 
    function trySomething(onSuccess, onError) { 
    if (Date.now() % 7 === 0) { 
     process.nextTick(onSuccess); 
    } else { 
     process.nextTick(onError); 
    } 
    } 
    trySomething(onSuccess, function() { 
    console.log('Failed, retrying...'); 
    keepTrying(onSuccess); 
    }); 
} 

keepTrying(function() { 
    console.log('Succeeded!'); 
}); 

Ich hoffe, das hilft.

Answer 3

Ist das, was Sie zu tun versuchen?

var history = {}; 

function sendRequest(options, callback) { 
    var req = https.request(options, function (res) { 
     var acc = ""; 
     res.on("data", function (msg) { 
      acc += msg.toString("utf-8"); 
     }); 
     res.on("end", function() { 
      history = JSON.parse(acc); 
      if (history.success) { 
       callback(history); 
      } 
      else { 
       sendRequest(options, callback); 
      } 
     }); 
    }); 
    req.end(); 
} 

sendRequest(options, callback); 

Answer 4

Es gibt keine Notwendigkeit, das Rad neu zu erfinden ist ... können Sie eine beliebte Asynchron-Utility-Bibliothek verwenden, ‚Retry‘ Methode in diesem Fall.

async.retry(3, apiMethod, function(err, result) { 
    // do something with the result 
}); 

async GitHub page

async.retry docs

Answer 5

ich gelöst habe dieses Problem mit dem retry Modul.

Beispiel:

var retry = require('retry'); 

// configuration 
var operation = retry.operation({ 
    retries: 2,   // try 1 time and retry 2 times if needed, total = 3 
    minTimeout: 1 * 1000, // the number of milliseconds before starting the first retry 
    maxTimeout: 3 * 1000 // the maximum number of milliseconds between two retries 
}); 

// your unreliable task 
var task = function(input, callback) { 

    Math.random() > 0.5 
    ? callback(null, 'ok') // success 
    : callback(new Error()); // error 
} 

// define a function that wraps our unreliable task into a fault tolerant task 
function faultTolerantTask(input, callback) { 

    operation.attempt(function(currentAttempt) { 

    task(input, function(err, result) { 

     console.log('Current attempt: ' + currentAttempt); 

     if (operation.retry(err)) { // retry if needed 
      return; 
     } 

     callback(err ? operation.mainError() : null, result); 
    }); 
    }); 
} 

// test 
faultTolerantTask('some input', function(err, result) { 
    console.log(err, result); 
}); 

Answer 6

Eine Bibliothek namens Flashheart auch eine geeignete Alternative. Es handelt sich um einen Rest-Client, der benutzerfreundlich ist und Wiederholungsversuche unterstützt.

Beispielsweise konfigurieren Flashheart 10-mal zu wiederholen, mit einer Verzögerung von 500ms zwischen Anfragen:

const client = require('flashheart').createClient({ 
    retries: 10, 
    retryTimeout: 500 
}); 

const url = "https://www.example.com/"; 
client.get(url, (err, body) => { 
    if (err) { 
     console.error('handle error: ', err); 
     return; 
    } 
    console.log(body); 
}); 

Für weitere Informationen besuchen Sie die Dokumentation aus: https://github.com/bbc/flashheart

Haftungsausschluss: Ich habe dazu beigetragen, diese Bibliothek.