Rückruf bei rekursiver Funktion

Question

Der folgende Code wird verwendet, um eine .zip Datei von unserer Webanwendung abzurufen. Die Datei wird erzeugt, indem eine andere Anwendung sicher geschlossen und dann gezippt wird, um sie schließlich zum Herunterladen zu senden.

var dl = function() { 
    request({ 
     method: 'GET', 
     uri: 'some_url', 
     headers: { 
      'User-Agent': 'Scripted-Download' 
     }, 
     encoding: null, 
     jar: true 
    }, function(err, res, body) { 
     if (err) throw(err) 
     if (res.headers['content-type'] === 'application/zip;charset=utf-8') { 
      process.stdout.write('\rDownloading file ..') 
      var id = uuid.v4() 
      , file = path.resolve(__dirname, '../../' + id + '.zip') 
      fs.writeFile(file, body, function(err) { 
       if (err) throw(err) 
       process.stdout.write('\rFile downloaded ' + id + '.zip') 
       process.exit(0) 
      }) 
     } else { 
      process.stdout.write('\rAwaiting file ..') 
      setTimeout(dl(), 30 * 1000) 
     } 
    }) 
} 

Dies funktioniert wie erwartet. Ich muss dies jedoch von einem anderen Skript aus verwenden. Also der obige Code gibt eine id der heruntergeladenen Datei, dann von einem anderen Skript kann ich die .zip extrahieren und die extrahierten Dateien in ein Verzeichnis mit der gleichen id. Diese Dateien würden dann zum Download bereitgestellt werden.

EDIT Im Grunde muss ich dieses Skript auszuführen, um den Inhalt zu extrahieren, wenn es dann mit res.render() eine Benutzeroberfläche heruntergeladen ist laden, wenn die beiden vorherigen Schritte abgeschlossen sind. Dies muss mit einer id durchgeführt werden, so dass zwei Benutzer keine in Konflikt stehenden Dateien erstellen.

Answer 1

in den Kommentaren erwähnt soll, verspricht dies einfach machen. Stellen Sie zunächst die benötigte Async-Funktionalität fest:

function makeRequest(parameters) { 
    return new Promise(function (resolve, reject) { 
     request(parameters, function (err, res, body) { 
      if (err) { reject (err); } 
      else { resolve({ res: res, body: body }); } 
     }); 
    }); 
} 

function writeFile(file, body) { 
    return new Promise(function (resolve, reject) { 
     fs.writeFile(file, body, function(err) { 
      if (err) { reject(err); } 
      else { resolve(); } 
     }); 
    }); 
} 

function timeout(duration) { 
    return new Promise(function (resolve) { 
     setTimeout(resolve, duration); 
    }); 
} 

Dann verwenden Sie sie.

var dl = function() { 
    return makeRequest({ 
     method: 'GET', 
     uri: 'some_url', 
     headers: { 
      'User-Agent': 'Scripted-Download' 
     }, 
     encoding: null, 
     jar: true 
    }).then(function (result) { 
     if (result.res.headers['content-type'] === 'application/zip;charset=utf-8') { 
      process.stdout.write('\rDownloading file ..') 
      var id = uuid.v4() 
      , file = path.resolve(__dirname, '../../' + id + '.zip'); 

      return writeFile(file, result.body) 
       .then(function() { return id; }); 
     } else { 
      process.stdout.write('\rAwaiting file ..'); 

      return timeout(30 * 1000).then(dl); 
     } 
    }); 
} 

dl().then(function (id) { process.stdout.write('\rid is: ' + id); }); 

Answer 2

Sie können eine asynchrone Dienstprogrammbibliothek wie async verwenden.

Das Muster, das Sie suchen, scheint das waterfall Muster zu sein. Dadurch können Sie die Daten, die Sie benötigen, von einer Aufgabe zur nächsten weitergeben.

function requestFile(cb){ 
    request({ 
     method: 'GET', 
     uri: 'some_url', 
     headers: { 
      'User-Agent': 'Scripted-Download' 
     }, 
     encoding: null, 
     jar: true 
    }, function(err, res, body) { 
     if (err) throw(err) 
     if (res.headers['content-type'] === 'application/zip;charset=utf-8') { 
      process.stdout.write('\rDownloading file ..'); 
      cb(null, body); 
     } 
     else{ 
      process.stdout.write('\rAwaiting file ..'); 
      setTimeout(requestFile, 30 * 1000) 
     } 
    }); 
} 


function saveFile(body, cb){ 
    var id = uuid.v4() 
     , file = path.resolve(__dirname, '../../' + id + '.zip') 
    fs.writeFile(file, body, function(err) { 
     if (err) throw(err) 
     process.stdout.write('\rFile downloaded ' + id + '.zip'); 
     cb(null, id); 
    }) 
} 

function render(id, cb) { 
    //do what ever you need with your id 
    cb(); 
} 

async.waterfall([ 
    requestFile, 
    saveFile, 
    render 
], function(err){ 

}); 

BTW, empfehle ich Ihnen die Daten direkt aus dem Server streamen auf der Festplatte, anstatt sie alle in einem Puffer zu sammeln und dann speichern.

Sie können data Zuhörer auf dem Request-Objekt erstellen und sie dann auf der Festplatte direkt streamen oder sogar request.pipe(file)

Beispiel verwenden nur: Wie

function streamFile(){ 

    var id = uuid.v4() 
     , file = path.resolve(__dirname, '../../' + id + '.zip'); 
    var stream = fs.createWriteStream(file); 
    stream.on('error', function(err){ 
     throw err; 
    }).on('close', function(){ 
     process.stdout.write('\rFile downloaded ' + id + '.zip') 
    }); 

    request({ 
     method: 'GET', 
     uri: 'some_url', 
     headers: { 
      'User-Agent': 'Scripted-Download' 
     }, 
     encoding: null, 
     jar: true 
    }).on('error', function(err) { 
     throw(err) 
    }).on('response', function(res){ 
     if (res.headers['content-type'] === 'application/zip;charset=utf-8') { 
      process.stdout.write('\rDownloading file ..'); 
      cb(null, body); 
     } 
     else{ 
      process.stdout.write('\rAwaiting file ..'); 
      res.destroy(); 
      setTimeout(streamFile, 30 * 1000) 
     } 
    }).pipe(stream); 
}